diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index fddcca8..4f30a87 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 snowflake tsql doris trino" + ALL_PARSERS="redshift postgresql cql snowflake tsql doris trino plsql" # Add more parsers here as they are added to the repository # ALL_PARSERS="redshift mysql postgresql" diff --git a/plsql/Makefile b/plsql/Makefile new file mode 100644 index 0000000..a72da10 --- /dev/null +++ b/plsql/Makefile @@ -0,0 +1,7 @@ +all: build test + +build: + antlr -Dlanguage=Go -package plsql -visitor -o . PlSqlLexer.g4 PlSqlParser.g4 + +test: + go test -v -run TestPLSQLParser diff --git a/plsql/PlSqlLexer.g4 b/plsql/PlSqlLexer.g4 new file mode 100644 index 0000000..b5f3b6a --- /dev/null +++ b/plsql/PlSqlLexer.g4 @@ -0,0 +1,2605 @@ +/** + * Oracle(c) PL/SQL 11g Parser + * + * Copyright (c) 2009-2011 Alexandre Porcelli + * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies). + * Copyright (c) 2017 Mark Adams + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +lexer grammar PlSqlLexer; + +options { + superClass=PlSqlLexerBase; + caseInsensitive = true; +} + +@lexer::postinclude { +#include +} + +ABORT: 'ABORT'; +ABS: 'ABS'; +ABSENT: 'ABSENT'; +ACCESS: 'ACCESS'; +ACCESSED: 'ACCESSED'; +ACCOUNT: 'ACCOUNT'; +ACL: 'ACL'; +ACOS: 'ACOS'; +ACROSS: 'ACROSS'; +ACTION: 'ACTION'; +ACTIONS: 'ACTIONS'; +ACTIVATE: 'ACTIVATE'; +ACTIVE: 'ACTIVE'; +ACTIVE_COMPONENT: 'ACTIVE_COMPONENT'; +ACTIVE_DATA: 'ACTIVE_DATA'; +ACTIVE_FUNCTION: 'ACTIVE_FUNCTION'; +ACTIVE_TAG: 'ACTIVE_TAG'; +ACTIVITY: 'ACTIVITY'; +ADAPTIVE_PLAN: 'ADAPTIVE_PLAN'; +ADD: 'ADD'; +ADD_COLUMN: 'ADD_COLUMN'; +ADD_GROUP: 'ADD_GROUP'; +ADD_MONTHS: 'ADD_MONTHS'; +ADJ_DATE: 'ADJ_DATE'; +ADMIN: 'ADMIN'; +ADMINISTER: 'ADMINISTER'; +ADMINISTRATOR: 'ADMINISTRATOR'; +ADVANCED: 'ADVANCED'; +ADVISE: 'ADVISE'; +ADVISOR: 'ADVISOR'; +AFD_DISKSTRING: 'AFD_DISKSTRING'; +AFTER: 'AFTER'; +AGENT: 'AGENT'; +AGGREGATE: 'AGGREGATE'; +A_LETTER: 'A'; +ALIAS: 'ALIAS'; +ALL: 'ALL'; +ALLOCATE: 'ALLOCATE'; +ALLOW: 'ALLOW'; +ALL_ROWS: 'ALL_ROWS'; +ALTER: 'ALTER'; +ALTERNATE: 'ALTERNATE'; +ALWAYS: 'ALWAYS'; +ANALYTIC: 'ANALYTIC'; +ANALYZE: 'ANALYZE'; +ANCESTOR: 'ANCESTOR'; +ANCILLARY: 'ANCILLARY'; +AND: 'AND'; +AND_EQUAL: 'AND_EQUAL'; +ANOMALY: 'ANOMALY'; +ANSI_REARCH: 'ANSI_REARCH'; +ANTIJOIN: 'ANTIJOIN'; +ANY: 'ANY'; +ANYSCHEMA: 'ANYSCHEMA'; +APPEND: 'APPEND'; +APPENDCHILDXML: 'APPENDCHILDXML'; +APPEND_VALUES: 'APPEND_VALUES'; +APPLICATION: 'APPLICATION'; +APPLY: 'APPLY'; +APPROX_COUNT_DISTINCT: 'APPROX_COUNT_DISTINCT'; +ARCHIVAL: 'ARCHIVAL'; +ARCHIVE: 'ARCHIVE'; +ARCHIVED: 'ARCHIVED'; +ARCHIVELOG: 'ARCHIVELOG'; +ARRAY: 'ARRAY'; +AS: 'AS'; +ASC: 'ASC'; +ASCII: 'ASCII'; +ASCIISTR: 'ASCIISTR'; +ASIN: 'ASIN'; +ASIS: 'ASIS'; +ASSEMBLY: 'ASSEMBLY'; +ASSIGN: 'ASSIGN'; +ASSOCIATE: 'ASSOCIATE'; +ASYNC: 'ASYNC'; +ASYNCHRONOUS: 'ASYNCHRONOUS'; +ATAN2: 'ATAN2'; +ATAN: 'ATAN'; +AT: 'AT'; +ATTRIBUTE: 'ATTRIBUTE'; +ATTRIBUTES: 'ATTRIBUTES'; +AUDIT: 'AUDIT'; +AUTHENTICATED: 'AUTHENTICATED'; +AUTHENTICATION: 'AUTHENTICATION'; +AUTHID: 'AUTHID'; +AUTHORIZATION: 'AUTHORIZATION'; +AUTOALLOCATE: 'AUTOALLOCATE'; +AUTO: 'AUTO'; +// AUTOBACKUP: 'AUTOBACKUP'; +AUTOEXTEND: 'AUTOEXTEND'; +AUTO_LOGIN: 'AUTO_LOGIN'; +AUTOMATIC: 'AUTOMATIC'; +AUTONOMOUS_TRANSACTION: 'AUTONOMOUS_TRANSACTION'; +AUTO_REOPTIMIZE: 'AUTO_REOPTIMIZE'; +AVAILABILITY: 'AVAILABILITY'; +AVRO: 'AVRO'; +BACKGROUND: 'BACKGROUND'; +BACKINGFILE: 'BACKINGFILE'; +BACKUP: 'BACKUP'; +BACKUPS: 'BACKUPS'; +// BACKUPSET: 'BACKUPSET'; +BASIC: 'BASIC'; +BASICFILE: 'BASICFILE'; +BATCH: 'BATCH'; +BATCHSIZE: 'BATCHSIZE'; +BATCH_TABLE_ACCESS_BY_ROWID: 'BATCH_TABLE_ACCESS_BY_ROWID'; +BECOME: 'BECOME'; +BEFORE: 'BEFORE'; +BEGIN: 'BEGIN'; +BEGINNING: 'BEGINNING'; +BEGIN_OUTLINE_DATA: 'BEGIN_OUTLINE_DATA'; +BEHALF: 'BEHALF'; +BEQUEATH: 'BEQUEATH'; +BETWEEN: 'BETWEEN'; +BFILE: 'BFILE'; +BFILENAME: 'BFILENAME'; +BIGFILE: 'BIGFILE'; +BINARY: 'BINARY'; +BINARY_DOUBLE: 'BINARY_DOUBLE'; +BINARY_DOUBLE_INFINITY: 'BINARY_DOUBLE_INFINITY'; +BINARY_DOUBLE_NAN: 'BINARY_DOUBLE_NAN'; +BINARY_FLOAT: 'BINARY_FLOAT'; +BINARY_FLOAT_INFINITY: 'BINARY_FLOAT_INFINITY'; +BINARY_FLOAT_NAN: 'BINARY_FLOAT_NAN'; +BINARY_INTEGER: 'BINARY_INTEGER'; +BIND_AWARE: 'BIND_AWARE'; +BINDING: 'BINDING'; +BIN_TO_NUM: 'BIN_TO_NUM'; +BITAND: 'BITAND'; +BITMAP_AND: 'BITMAP_AND'; +BITMAP: 'BITMAP'; +BITMAPS: 'BITMAPS'; +BITMAP_TREE: 'BITMAP_TREE'; +BITS: 'BITS'; +BLOB: 'BLOB'; +BLOCK: 'BLOCK'; +BLOCK_RANGE: 'BLOCK_RANGE'; +BLOCKS: 'BLOCKS'; +BLOCKSIZE: 'BLOCKSIZE'; +BODY: 'BODY'; +BOOLEAN: 'BOOLEAN'; +BOTH: 'BOTH'; +BOUND: 'BOUND'; +BRANCH: 'BRANCH'; +BREADTH: 'BREADTH'; +BROADCAST: 'BROADCAST'; +BSON: 'BSON'; +BUFFER: 'BUFFER'; +BUFFER_CACHE: 'BUFFER_CACHE'; +BUFFER_POOL: 'BUFFER_POOL'; +BUILD: 'BUILD'; +BULK: 'BULK'; +BY: 'BY'; +BYPASS_RECURSIVE_CHECK: 'BYPASS_RECURSIVE_CHECK'; +BYPASS_UJVC: 'BYPASS_UJVC'; +BYTE: 'BYTE'; +CACHE: 'CACHE'; +CACHE_CB: 'CACHE_CB'; +CACHE_INSTANCES: 'CACHE_INSTANCES'; +CACHE_TEMP_TABLE: 'CACHE_TEMP_TABLE'; +CACHING: 'CACHING'; +CALCULATED: 'CALCULATED'; +CALLBACK: 'CALLBACK'; +CALL: 'CALL'; +CANCEL: 'CANCEL'; +CANONICAL: 'CANONICAL'; +CAPACITY: 'CAPACITY'; +CAPTION: 'CAPTION'; +CARDINALITY: 'CARDINALITY'; +CASCADE: 'CASCADE'; +CASE: 'CASE'; +CAST: 'CAST'; +CASESENSITIVE: 'CASE-SENSITIVE'; +CATEGORY: 'CATEGORY'; +CDBDEFAULT: 'CDB$DEFAULT'; +CEIL: 'CEIL'; +CELL_FLASH_CACHE: 'CELL_FLASH_CACHE'; +CERTIFICATE: 'CERTIFICATE'; +CFILE: 'CFILE'; +CHAINED: 'CHAINED'; +CHANGE: 'CHANGE'; +// CHANGETRACKING: 'CHANGETRACKING'; +CHANGE_DUPKEY_ERROR_INDEX: 'CHANGE_DUPKEY_ERROR_INDEX'; +CHARACTER: 'CHARACTER'; +CHAR: 'CHAR'; +CHAR_CS: 'CHAR_CS'; +CHARTOROWID: 'CHARTOROWID'; +CHECK_ACL_REWRITE: 'CHECK_ACL_REWRITE'; +CHECK: 'CHECK'; +CHECKPOINT: 'CHECKPOINT'; +CHILD: 'CHILD'; +CHOOSE: 'CHOOSE'; +CHR: 'CHR'; +CHUNK: 'CHUNK'; +CLASS: 'CLASS'; +CLASSIFICATION: 'CLASSIFICATION'; +CLASSIFIER: 'CLASSIFIER'; +CLAUSE: 'CLAUSE'; +CLEAN: 'CLEAN'; +CLEANUP: 'CLEANUP'; +CLEAR: 'CLEAR'; +C_LETTER: 'C'; +CLIENT: 'CLIENT'; +CLOB: 'CLOB'; +CLONE: 'CLONE'; +CLOSE_CACHED_OPEN_CURSORS: 'CLOSE_CACHED_OPEN_CURSORS'; +CLOSE: 'CLOSE'; +CLUSTER_BY_ROWID: 'CLUSTER_BY_ROWID'; +CLUSTER: 'CLUSTER'; +CLUSTER_DETAILS: 'CLUSTER_DETAILS'; +CLUSTER_DISTANCE: 'CLUSTER_DISTANCE'; +CLUSTER_ID: 'CLUSTER_ID'; +CLUSTERING: 'CLUSTERING'; +CLUSTERING_FACTOR: 'CLUSTERING_FACTOR'; +CLUSTER_PROBABILITY: 'CLUSTER_PROBABILITY'; +CLUSTER_SET: 'CLUSTER_SET'; +COALESCE: 'COALESCE'; +COALESCE_SQ: 'COALESCE_SQ'; +COARSE: 'COARSE'; +CO_AUTH_IND: 'CO_AUTH_IND'; +COLD: 'COLD'; +COLLECT: 'COLLECT'; +COLUMNAR: 'COLUMNAR'; +COLUMN_AUTH_INDICATOR: 'COLUMN_AUTH_INDICATOR'; +COLUMN: 'COLUMN'; +COLUMNS: 'COLUMNS'; +COLUMN_STATS: 'COLUMN_STATS'; +COLUMN_VALUE: 'COLUMN_VALUE'; +COMMENT: 'COMMENT'; +COMMIT: 'COMMIT'; +COMMITTED: 'COMMITTED'; +COMMON: 'COMMON'; +COMMON_DATA: 'COMMON_DATA'; +COMPACT: 'COMPACT'; +COMPATIBILITY: 'COMPATIBILITY'; +COMPILE: 'COMPILE'; +COMPLETE: 'COMPLETE'; +COMPLIANCE: 'COMPLIANCE'; +COMPONENT: 'COMPONENT'; +COMPONENTS: 'COMPONENTS'; +COMPOSE: 'COMPOSE'; +COMPOSITE: 'COMPOSITE'; +COMPOSITE_LIMIT: 'COMPOSITE_LIMIT'; +COMPOUND: 'COMPOUND'; +COMPRESS: 'COMPRESS'; +COMPUTE: 'COMPUTE'; +CONCAT: 'CONCAT'; +CON_DBID_TO_ID: 'CON_DBID_TO_ID'; +CONDITIONAL: 'CONDITIONAL'; +CONDITION: 'CONDITION'; +CONFIRM: 'CONFIRM'; +CONFORMING: 'CONFORMING'; +CON_GUID_TO_ID: 'CON_GUID_TO_ID'; +CON_ID: 'CON_ID'; +CON_NAME_TO_ID: 'CON_NAME_TO_ID'; +CONNECT_BY_CB_WHR_ONLY: 'CONNECT_BY_CB_WHR_ONLY'; +CONNECT_BY_COMBINE_SW: 'CONNECT_BY_COMBINE_SW'; +CONNECT_BY_COST_BASED: 'CONNECT_BY_COST_BASED'; +CONNECT_BY_ELIM_DUPS: 'CONNECT_BY_ELIM_DUPS'; +CONNECT_BY_FILTERING: 'CONNECT_BY_FILTERING'; +CONNECT_BY_ISCYCLE: 'CONNECT_BY_ISCYCLE'; +CONNECT_BY_ISLEAF: 'CONNECT_BY_ISLEAF'; +CONNECT_BY_ROOT: 'CONNECT_BY_ROOT'; +CONNECT: 'CONNECT'; +CONNECT_TIME: 'CONNECT_TIME'; +CONSIDER: 'CONSIDER'; +CONSISTENT: 'CONSISTENT'; +CONSTANT: 'CONSTANT'; +CONST: 'CONST'; +CONSTRAINT: 'CONSTRAINT'; +CONSTRAINTS: 'CONSTRAINTS'; +CONSTRUCTOR: 'CONSTRUCTOR'; +CONTAINER: 'CONTAINER'; +CONTAINERS: 'CONTAINERS'; +CONTAINERS_DEFAULT: 'CONTAINERS_DEFAULT'; +CONTAINER_DATA: 'CONTAINER_DATA'; +CONTAINER_MAP: 'CONTAINER_MAP'; +CONTENT: 'CONTENT'; +CONTENTS: 'CONTENTS'; +CONTEXT: 'CONTEXT'; +CONTINUE: 'CONTINUE'; +CONTROLFILE: 'CONTROLFILE'; +CON_UID_TO_ID: 'CON_UID_TO_ID'; +CONVERT: 'CONVERT'; +CONVERSION: 'CONVERSION'; +COOKIE: 'COOKIE'; +COPY: 'COPY'; +CORR_K: 'CORR_K'; +CORR_S: 'CORR_S'; +CORRUPTION: 'CORRUPTION'; +CORRUPT_XID_ALL: 'CORRUPT_XID_ALL'; +CORRUPT_XID: 'CORRUPT_XID'; +COS: 'COS'; +COSH: 'COSH'; +COST: 'COST'; +COST_XML_QUERY_REWRITE: 'COST_XML_QUERY_REWRITE'; +COUNT: 'COUNT'; +COVAR_POP: 'COVAR_POP'; +COVAR_SAMP: 'COVAR_SAMP'; +CPU_COSTING: 'CPU_COSTING'; +CPU_PER_CALL: 'CPU_PER_CALL'; +CPU_PER_SESSION: 'CPU_PER_SESSION'; +CRASH: 'CRASH'; +CREATE: 'CREATE'; +CREATE_FILE_DEST: 'CREATE_FILE_DEST'; +CREATE_STORED_OUTLINES: 'CREATE_STORED_OUTLINES'; +CREATION: 'CREATION'; +CREDENTIAL: 'CREDENTIAL'; +CRITICAL: 'CRITICAL'; +CROSS: 'CROSS'; +CROSSEDITION: 'CROSSEDITION'; +CSCONVERT: 'CSCONVERT'; +CUBE_AJ: 'CUBE_AJ'; +CUBE: 'CUBE'; +CUBE_GB: 'CUBE_GB'; +CUBE_SJ: 'CUBE_SJ'; +CUME_DISTM: 'CUME_DISTM'; +CURRENT: 'CURRENT'; +CURRENT_DATE: 'CURRENT_DATE'; +CURRENT_SCHEMA: 'CURRENT_SCHEMA'; +CURRENT_TIME: 'CURRENT_TIME'; +CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +CURRENT_USER: 'CURRENT_USER'; +CURRENTV: 'CURRENTV'; +CURSOR: 'CURSOR'; +CURSOR_SHARING_EXACT: 'CURSOR_SHARING_EXACT'; +CURSOR_SPECIFIC_SEGMENT: 'CURSOR_SPECIFIC_SEGMENT'; +CUSTOMDATUM: 'CUSTOMDATUM'; +CV: 'CV'; +CYCLE: 'CYCLE'; +DANGLING: 'DANGLING'; +DATABASE: 'DATABASE'; +DATA: 'DATA'; +DATAFILE: 'DATAFILE'; +DATAFILES: 'DATAFILES'; +// DATAGUARDCONFIG: 'DATAGUARDCONFIG'; +DATAMOVEMENT: 'DATAMOVEMENT'; +DATAOBJNO: 'DATAOBJNO'; +DATAOBJ_TO_MAT_PARTITION: 'DATAOBJ_TO_MAT_PARTITION'; +DATAOBJ_TO_PARTITION: 'DATAOBJ_TO_PARTITION'; +DATAPUMP: 'DATAPUMP'; +DATA_SECURITY_REWRITE_LIMIT: 'DATA_SECURITY_REWRITE_LIMIT'; +DATE: 'DATE'; +DATE_MODE: 'DATE_MODE'; +DAY: 'DAY'; +DAYS: 'DAYS'; +DBA: 'DBA'; +DBA_RECYCLEBIN: 'DBA_RECYCLEBIN'; +DBMS_STATS: 'DBMS_STATS'; +DB_ROLE_CHANGE: 'DB_ROLE_CHANGE'; +DBTIMEZONE: 'DBTIMEZONE'; +DB_UNIQUE_NAME: 'DB_UNIQUE_NAME'; +DB_VERSION: 'DB_VERSION'; +DDL: 'DDL'; +DEALLOCATE: 'DEALLOCATE'; +DEBUG: 'DEBUG'; +DEBUGGER: 'DEBUGGER'; +DEC: 'DEC'; +DECIMAL: 'DECIMAL'; +DECLARE: 'DECLARE'; +DECOMPOSE: 'DECOMPOSE'; +DECORRELATE: 'DECORRELATE'; +DECR: 'DECR'; +DECREMENT: 'DECREMENT'; +DECRYPT: 'DECRYPT'; +DEDUPLICATE: 'DEDUPLICATE'; +DEFAULT: 'DEFAULT'; +DEFAULTS: 'DEFAULTS'; +DEFAULT_COLLATION: 'DEFAULT_COLLATION'; +DEFAULT_CREDENTIAL: 'DEFAULT_CREDENTIAL'; +DEFERRABLE: 'DEFERRABLE'; +DEFERRED: 'DEFERRED'; +DEFINED: 'DEFINED'; +DEFINE: 'DEFINE'; +DEFINER: 'DEFINER'; +DEGREE: 'DEGREE'; +DELAY: 'DELAY'; +DELEGATE: 'DELEGATE'; +DELETE_ALL: 'DELETE_ALL'; +DELETE: 'DELETE'; +DELETEXML: 'DELETEXML'; +DEMAND: 'DEMAND'; +DENSE_RANKM: 'DENSE_RANKM'; +DEPENDENT: 'DEPENDENT'; +DEPTH: 'DEPTH'; +DEQUEUE: 'DEQUEUE'; +DEREF: 'DEREF'; +DEREF_NO_REWRITE: 'DEREF_NO_REWRITE'; +DESC: 'DESC'; +DESCRIPTION: 'DESCRIPTION'; +DESTROY: 'DESTROY'; +DETACHED: 'DETACHED'; +DETERMINES: 'DETERMINES'; +DETERMINISTIC: 'DETERMINISTIC'; +DICTIONARY: 'DICTIONARY'; +DIMENSION: 'DIMENSION'; +DIMENSIONS: 'DIMENSIONS'; +DIRECT_LOAD: 'DIRECT_LOAD'; +DIRECTORY: 'DIRECTORY'; +DIRECT_PATH: 'DIRECT_PATH'; +DISABLE_ALL: 'DISABLE_ALL'; +DISABLE: 'DISABLE'; +DISABLE_PARALLEL_DML: 'DISABLE_PARALLEL_DML'; +DISABLE_PRESET: 'DISABLE_PRESET'; +DISABLE_RPKE: 'DISABLE_RPKE'; +DISALLOW: 'DISALLOW'; +DISASSOCIATE: 'DISASSOCIATE'; +DISCARD: 'DISCARD'; +DISCONNECT: 'DISCONNECT'; +DISK: 'DISK'; +DISKGROUP: 'DISKGROUP'; +// DISKGROUP_PLUS: '\'+ DISKGROUP'; +DISKS: 'DISKS'; +DISMOUNT: 'DISMOUNT'; +DISTINCT: 'DISTINCT'; +DISTINGUISHED: 'DISTINGUISHED'; +DISTRIBUTED: 'DISTRIBUTED'; +DISTRIBUTE: 'DISTRIBUTE'; +DML: 'DML'; +DML_UPDATE: 'DML_UPDATE'; +DOCFIDELITY: 'DOCFIDELITY'; +DOCUMENT: 'DOCUMENT'; +DOMAIN_INDEX_FILTER: 'DOMAIN_INDEX_FILTER'; +DOMAIN_INDEX_NO_SORT: 'DOMAIN_INDEX_NO_SORT'; +DOMAIN_INDEX_SORT: 'DOMAIN_INDEX_SORT'; +DOUBLE: 'DOUBLE'; +DOWNGRADE: 'DOWNGRADE'; +DRIVING_SITE: 'DRIVING_SITE'; +DROP_COLUMN: 'DROP_COLUMN'; +DROP: 'DROP'; +DROP_GROUP: 'DROP_GROUP'; +DSINTERVAL_UNCONSTRAINED: 'DSINTERVAL_UNCONSTRAINED'; +DST_UPGRADE_INSERT_CONV: 'DST_UPGRADE_INSERT_CONV'; +DUMP: 'DUMP'; +// DUMPSET: 'DUMPSET'; +DUPLICATE: 'DUPLICATE'; +DV: 'DV'; +DYNAMIC: 'DYNAMIC'; +DYNAMIC_SAMPLING: 'DYNAMIC_SAMPLING'; +DYNAMIC_SAMPLING_EST_CDN: 'DYNAMIC_SAMPLING_EST_CDN'; +E_LETTER: 'E'; +EACH: 'EACH'; +EDITIONABLE: 'EDITIONABLE'; +EDITION: 'EDITION'; +EDITIONING: 'EDITIONING'; +EDITIONS: 'EDITIONS'; +ELEMENT: 'ELEMENT'; +ELIM_GROUPBY: 'ELIM_GROUPBY'; +ELIMINATE_JOIN: 'ELIMINATE_JOIN'; +ELIMINATE_OBY: 'ELIMINATE_OBY'; +ELIMINATE_OUTER_JOIN: 'ELIMINATE_OUTER_JOIN'; +ELSE: 'ELSE'; +ELSIF: 'ELSIF'; +EM: 'EM'; +EMPTY_BLOB: 'EMPTY_BLOB'; +EMPTY_CLOB: 'EMPTY_CLOB'; +EMPTY: 'EMPTY'; +ENABLE_ALL: 'ENABLE_ALL'; +ENABLE: 'ENABLE'; +ENABLE_PARALLEL_DML: 'ENABLE_PARALLEL_DML'; +ENABLE_PRESET: 'ENABLE_PRESET'; +ENCODING: 'ENCODING'; +ENCRYPT: 'ENCRYPT'; +ENCRYPTION: 'ENCRYPTION'; +END: 'END'; +END_OUTLINE_DATA: 'END_OUTLINE_DATA'; +ENFORCED: 'ENFORCED'; +ENFORCE: 'ENFORCE'; +ENQUEUE: 'ENQUEUE'; +ENTERPRISE: 'ENTERPRISE'; +ENTITYESCAPING: 'ENTITYESCAPING'; +ENTRY: 'ENTRY'; +EQUIPART: 'EQUIPART'; +ERR: 'ERR'; +ERROR_ARGUMENT: 'ERROR_ARGUMENT'; +ERROR: 'ERROR'; +ERROR_ON_OVERLAP_TIME: 'ERROR_ON_OVERLAP_TIME'; +ERRORS: 'ERRORS'; +ESCAPE: 'ESCAPE'; +ESTIMATE: 'ESTIMATE'; +EVAL: 'EVAL'; +EVALNAME: 'EVALNAME'; +EVALUATE: 'EVALUATE'; +EVALUATION: 'EVALUATION'; +EVENTS: 'EVENTS'; +EVERY: 'EVERY'; +EXCEPT: 'EXCEPT'; +EXCEPTION: 'EXCEPTION'; +EXCEPTION_INIT: 'EXCEPTION_INIT'; +EXCEPTIONS: 'EXCEPTIONS'; +EXCHANGE: 'EXCHANGE'; +EXCLUDE: 'EXCLUDE'; +EXCLUDING: 'EXCLUDING'; +EXCLUSIVE: 'EXCLUSIVE'; +EXECUTE: 'EXECUTE'; +EXEMPT: 'EXEMPT'; +EXISTING: 'EXISTING'; +EXISTS: 'EXISTS'; +EXISTSNODE: 'EXISTSNODE'; +EXIT: 'EXIT'; +EXPAND_GSET_TO_UNION: 'EXPAND_GSET_TO_UNION'; +EXPAND_TABLE: 'EXPAND_TABLE'; +EXP: 'EXP'; +EXPIRE: 'EXPIRE'; +EXPLAIN: 'EXPLAIN'; +EXPLOSION: 'EXPLOSION'; +EXPORT: 'EXPORT'; +EXPR_CORR_CHECK: 'EXPR_CORR_CHECK'; +EXPRESS: 'EXPRESS'; +EXTENDS: 'EXTENDS'; +EXTENT: 'EXTENT'; +EXTENTS: 'EXTENTS'; +EXTERNAL: 'EXTERNAL'; +EXTERNALLY: 'EXTERNALLY'; +EXTRACTCLOBXML: 'EXTRACTCLOBXML'; +EXTRACT: 'EXTRACT'; +EXTRACTVALUE: 'EXTRACTVALUE'; +EXTRA: 'EXTRA'; +FACILITY: 'FACILITY'; +FACT: 'FACT'; +FACTOR: 'FACTOR'; +FACTORIZE_JOIN: 'FACTORIZE_JOIN'; +FAILED: 'FAILED'; +FAILED_LOGIN_ATTEMPTS: 'FAILED_LOGIN_ATTEMPTS'; +FAILGROUP: 'FAILGROUP'; +FAILOVER: 'FAILOVER'; +FAILURE: 'FAILURE'; +FALSE: 'FALSE'; +FAMILY: 'FAMILY'; +FAR: 'FAR'; +FAST: 'FAST'; +FASTSTART: 'FASTSTART'; +FBTSCAN: 'FBTSCAN'; +FEATURE: 'FEATURE'; +FEATURE_DETAILS: 'FEATURE_DETAILS'; +FEATURE_ID: 'FEATURE_ID'; +FEATURE_SET: 'FEATURE_SET'; +FEATURE_VALUE: 'FEATURE_VALUE'; +FETCH: 'FETCH'; +FILE: 'FILE'; +FILE_NAME_CONVERT: 'FILE_NAME_CONVERT'; +FILEGROUP: 'FILEGROUP'; +FILESTORE: 'FILESTORE'; +FILESYSTEM_LIKE_LOGGING: 'FILESYSTEM_LIKE_LOGGING'; +FILTER: 'FILTER'; +FINAL: 'FINAL'; +FINE: 'FINE'; +FINISH: 'FINISH'; +FIRST: 'FIRST'; +FIRSTM: 'FIRSTM'; +FIRST_ROWS: 'FIRST_ROWS'; +FIRST_VALUE: 'FIRST_VALUE'; +FIXED_VIEW_DATA: 'FIXED_VIEW_DATA'; +FLAGGER: 'FLAGGER'; +FLASHBACK: 'FLASHBACK'; +FLASH_CACHE: 'FLASH_CACHE'; +FLOAT: 'FLOAT'; +FLOB: 'FLOB'; +FLEX: 'FLEX'; +FLOOR: 'FLOOR'; +FLUSH: 'FLUSH'; +FOLDER: 'FOLDER'; +FOLLOWING: 'FOLLOWING'; +FOLLOWS: 'FOLLOWS'; +FORALL: 'FORALL'; +FORCE: 'FORCE'; +FORCE_XML_QUERY_REWRITE: 'FORCE_XML_QUERY_REWRITE'; +FOREIGN: 'FOREIGN'; +FOREVER: 'FOREVER'; +FOR: 'FOR'; +FORMAT: 'FORMAT'; +FORWARD: 'FORWARD'; +FRAGMENT_NUMBER: 'FRAGMENT_NUMBER'; +FREELIST: 'FREELIST'; +FREELISTS: 'FREELISTS'; +FREEPOOLS: 'FREEPOOLS'; +FRESH: 'FRESH'; +FROM: 'FROM'; +FROM_TZ: 'FROM_TZ'; +FULL: 'FULL'; +FULL_OUTER_JOIN_TO_OUTER: 'FULL_OUTER_JOIN_TO_OUTER'; +FUNCTION: 'FUNCTION'; +FUNCTIONS: 'FUNCTIONS'; +FTP: 'FTP'; +G_LETTER: 'G'; +GATHER_OPTIMIZER_STATISTICS: 'GATHER_OPTIMIZER_STATISTICS'; +GATHER_PLAN_STATISTICS: 'GATHER_PLAN_STATISTICS'; +GBY_CONC_ROLLUP: 'GBY_CONC_ROLLUP'; +GBY_PUSHDOWN: 'GBY_PUSHDOWN'; +GENERATED: 'GENERATED'; +GET: 'GET'; +GLOBAL: 'GLOBAL'; +GLOBALLY: 'GLOBALLY'; +GLOBAL_NAME: 'GLOBAL_NAME'; +GLOBAL_TOPIC_ENABLED: 'GLOBAL_TOPIC_ENABLED'; +GOTO: 'GOTO'; +GRANT: 'GRANT'; +GROUP_BY: 'GROUP_BY'; +GROUP: 'GROUP'; +GROUP_ID: 'GROUP_ID'; +GROUPING: 'GROUPING'; +GROUPING_ID: 'GROUPING_ID'; +GROUPS: 'GROUPS'; +GUARANTEED: 'GUARANTEED'; +GUARANTEE: 'GUARANTEE'; +GUARD: 'GUARD'; +HALF_YEARS: 'HALF_YEARS'; +HASH_AJ: 'HASH_AJ'; +HASH: 'HASH'; +HASHKEYS: 'HASHKEYS'; +HASH_SJ: 'HASH_SJ'; +HAVING: 'HAVING'; +HEADER: 'HEADER'; +HEAP: 'HEAP'; +HELP: 'HELP'; +HEXTORAW: 'HEXTORAW'; +HEXTOREF: 'HEXTOREF'; +HIDDEN_KEYWORD: 'HIDDEN'; +HIDE: 'HIDE'; +HIER_ORDER: 'HIER_ORDER'; +HIERARCHICAL: 'HIERARCHICAL'; +HIERARCHIES: 'HIERARCHIES'; +HIERARCHY: 'HIERARCHY'; +HIGH: 'HIGH'; +HINTSET_BEGIN: 'HINTSET_BEGIN'; +HINTSET_END: 'HINTSET_END'; +HOT: 'HOT'; +HOUR: 'HOUR'; +HOURS: 'HOURS'; +HTTP: 'HTTP'; +HWM_BROKERED: 'HWM_BROKERED'; +HYBRID: 'HYBRID'; +H_LETTER: 'H'; +IDENTIFIED: 'IDENTIFIED'; +IDENTIFIER: 'IDENTIFIER'; +IDENTITY: 'IDENTITY'; +IDGENERATORS: 'IDGENERATORS'; +ID: 'ID'; +IDLE_TIME: 'IDLE_TIME'; +IF: 'IF'; +IGNORE: 'IGNORE'; +IGNORE_OPTIM_EMBEDDED_HINTS: 'IGNORE_OPTIM_EMBEDDED_HINTS'; +IGNORE_ROW_ON_DUPKEY_INDEX: 'IGNORE_ROW_ON_DUPKEY_INDEX'; +IGNORE_WHERE_CLAUSE: 'IGNORE_WHERE_CLAUSE'; +ILM: 'ILM'; +IMMEDIATE: 'IMMEDIATE'; +IMPACT: 'IMPACT'; +IMPORT: 'IMPORT'; +INACTIVE: 'INACTIVE'; +INACTIVE_ACCOUNT_TIME: 'INACTIVE_ACCOUNT_TIME'; +INCLUDE: 'INCLUDE'; +INCLUDE_VERSION: 'INCLUDE_VERSION'; +INCLUDING: 'INCLUDING'; +INCREMENTAL: 'INCREMENTAL'; +INCREMENT: 'INCREMENT'; +INCR: 'INCR'; +INDENT: 'INDENT'; +INDEX_ASC: 'INDEX_ASC'; +INDEX_COMBINE: 'INDEX_COMBINE'; +INDEX_DESC: 'INDEX_DESC'; +INDEXED: 'INDEXED'; +INDEXES: 'INDEXES'; +INDEX_FFS: 'INDEX_FFS'; +INDEX_FILTER: 'INDEX_FILTER'; +INDEX: 'INDEX'; +INDEXING: 'INDEXING'; +INDEX_JOIN: 'INDEX_JOIN'; +INDEX_ROWS: 'INDEX_ROWS'; +INDEX_RRS: 'INDEX_RRS'; +INDEX_RS_ASC: 'INDEX_RS_ASC'; +INDEX_RS_DESC: 'INDEX_RS_DESC'; +INDEX_RS: 'INDEX_RS'; +INDEX_SCAN: 'INDEX_SCAN'; +INDEX_SKIP_SCAN: 'INDEX_SKIP_SCAN'; +INDEX_SS_ASC: 'INDEX_SS_ASC'; +INDEX_SS_DESC: 'INDEX_SS_DESC'; +INDEX_SS: 'INDEX_SS'; +INDEX_STATS: 'INDEX_STATS'; +INDEXTYPE: 'INDEXTYPE'; +INDEXTYPES: 'INDEXTYPES'; +INDICATOR: 'INDICATOR'; +INDICES: 'INDICES'; +INFINITE: 'INFINITE'; +INFORMATIONAL: 'INFORMATIONAL'; +INHERIT: 'INHERIT'; +IN: 'IN'; +INITCAP: 'INITCAP'; +INITIAL: 'INITIAL'; +INITIALIZED: 'INITIALIZED'; +INITIALLY: 'INITIALLY'; +INITRANS: 'INITRANS'; +INLINE: 'INLINE'; +INLINE_XMLTYPE_NT: 'INLINE_XMLTYPE_NT'; +INMEMORY: 'INMEMORY'; +IN_MEMORY_METADATA: 'IN_MEMORY_METADATA'; +INMEMORY_PRUNING: 'INMEMORY_PRUNING'; +INNER: 'INNER'; +INOUT: 'INOUT'; +INPLACE: 'INPLACE'; +INSERTCHILDXMLAFTER: 'INSERTCHILDXMLAFTER'; +INSERTCHILDXMLBEFORE: 'INSERTCHILDXMLBEFORE'; +INSERTCHILDXML: 'INSERTCHILDXML'; +INSERT: 'INSERT'; +INSERTXMLAFTER: 'INSERTXMLAFTER'; +INSERTXMLBEFORE: 'INSERTXMLBEFORE'; +INSTANCE: 'INSTANCE'; +INSTANCES: 'INSTANCES'; +INSTANTIABLE: 'INSTANTIABLE'; +INSTANTLY: 'INSTANTLY'; +INSTEAD: 'INSTEAD'; +INSTR2: 'INSTR2'; +INSTR4: 'INSTR4'; +INSTRB: 'INSTRB'; +INSTRC: 'INSTRC'; +INSTR: 'INSTR'; +INTEGER: 'INTEGER'; +INTERLEAVED: 'INTERLEAVED'; +INTERMEDIATE: 'INTERMEDIATE'; +INTERNAL_CONVERT: 'INTERNAL_CONVERT'; +INTERNAL_USE: 'INTERNAL_USE'; +INTERPRETED: 'INTERPRETED'; +INTERSECT: 'INTERSECT'; +INTERVAL: 'INTERVAL'; +INT: 'INT'; +INTO: 'INTO'; +INVALIDATE: 'INVALIDATE'; +INVISIBLE: 'INVISIBLE'; +IN_XQUERY: 'IN_XQUERY'; +IS: 'IS'; +IS_LEAF: 'IS_LEAF'; +ISOLATION: 'ISOLATION'; +ISOLATION_LEVEL: 'ISOLATION_LEVEL'; +ITERATE: 'ITERATE'; +ITERATION_NUMBER: 'ITERATION_NUMBER'; +JAVA: 'JAVA'; +JOB: 'JOB'; +JOIN: 'JOIN'; +JSON_ARRAYAGG: 'JSON_ARRAYAGG'; +JSON_ARRAY: 'JSON_ARRAY'; +JSON_EQUAL: 'JSON_EQUAL'; +JSON_EXISTS2: 'JSON_EXISTS2'; +JSON_EXISTS: 'JSON_EXISTS'; +JSONGET: 'JSONGET'; +JSON: 'JSON'; +JSON_OBJECTAGG: 'JSON_OBJECTAGG'; +JSON_OBJECT: 'JSON_OBJECT'; +JSONPARSE: 'JSONPARSE'; +JSON_QUERY: 'JSON_QUERY'; +JSON_SERIALIZE: 'JSON_SERIALIZE'; +JSON_TABLE: 'JSON_TABLE'; +JSON_TEXTCONTAINS2: 'JSON_TEXTCONTAINS2'; +JSON_TEXTCONTAINS: 'JSON_TEXTCONTAINS'; +JSON_TRANSFORM: 'JSON_TRANSFORM'; +JSON_VALUE: 'JSON_VALUE'; +K_LETTER: 'K'; +KEEP_DUPLICATES: 'KEEP_DUPLICATES'; +KEEP: 'KEEP'; +KERBEROS: 'KERBEROS'; +KEY: 'KEY'; +KEY_LENGTH: 'KEY_LENGTH'; +KEYSIZE: 'KEYSIZE'; +KEYS: 'KEYS'; +KEYSTORE: 'KEYSTORE'; +KILL: 'KILL'; +LABEL: 'LABEL'; +LANGUAGE: 'LANGUAGE'; +LAST_DAY: 'LAST_DAY'; +LAST: 'LAST'; +LAST_VALUE: 'LAST_VALUE'; +LATERAL: 'LATERAL'; +LAX: 'LAX'; +LAYER: 'LAYER'; +LDAP_REGISTRATION_ENABLED: 'LDAP_REGISTRATION_ENABLED'; +LDAP_REGISTRATION: 'LDAP_REGISTRATION'; +LDAP_REG_SYNC_INTERVAL: 'LDAP_REG_SYNC_INTERVAL'; +LEAF: 'LEAF'; +LEAD_CDB: 'LEAD_CDB'; +LEAD_CDB_URI: 'LEAD_CDB_URI'; +LEADING: 'LEADING'; +LEFT: 'LEFT'; +LENGTH2: 'LENGTH2'; +LENGTH4: 'LENGTH4'; +LENGTHB: 'LENGTHB'; +LENGTHC: 'LENGTHC'; +LENGTH: 'LENGTH'; +LESS: 'LESS'; +LEVEL: 'LEVEL'; +LEVEL_NAME: 'LEVEL_NAME'; +LEVELS: 'LEVELS'; +LIBRARY: 'LIBRARY'; +LIFECYCLE: 'LIFECYCLE'; +LIFE: 'LIFE'; +LIFETIME: 'LIFETIME'; +LIKE2: 'LIKE2'; +LIKE4: 'LIKE4'; +LIKEC: 'LIKEC'; +LIKE_EXPAND: 'LIKE_EXPAND'; +LIKE: 'LIKE'; +LIMIT: 'LIMIT'; +LINEAR: 'LINEAR'; +LINK: 'LINK'; +LIST: 'LIST'; +LN: 'LN'; +LNNVL: 'LNNVL'; +LOAD: 'LOAD'; +LOB: 'LOB'; +LOBNVL: 'LOBNVL'; +LOBS: 'LOBS'; +LOCAL_INDEXES: 'LOCAL_INDEXES'; +LOCAL: 'LOCAL'; +LOCALTIME: 'LOCALTIME'; +LOCALTIMESTAMP: 'LOCALTIMESTAMP'; +LOCATION: 'LOCATION'; +LOCATOR: 'LOCATOR'; +LOCKDOWN: 'LOCKDOWN'; +LOCKED: 'LOCKED'; +LOCKING: 'LOCKING'; +LOCK: 'LOCK'; +LOGFILE: 'LOGFILE'; +LOGFILES: 'LOGFILES'; +LOGGING: 'LOGGING'; +LOGICAL: 'LOGICAL'; +LOGICAL_READS_PER_CALL: 'LOGICAL_READS_PER_CALL'; +LOGICAL_READS_PER_SESSION: 'LOGICAL_READS_PER_SESSION'; +LOG: 'LOG'; +LOGMINING: 'LOGMINING'; +LOGOFF: 'LOGOFF'; +LOGON: 'LOGON'; +LOG_READ_ONLY_VIOLATIONS: 'LOG_READ_ONLY_VIOLATIONS'; +LONG: 'LONG'; +LOOP: 'LOOP'; +LOST: 'LOST'; +LOWER: 'LOWER'; +LOW: 'LOW'; +LPAD: 'LPAD'; +LTRIM: 'LTRIM'; +M_LETTER: 'M'; +MAIN: 'MAIN'; +MAKE_REF: 'MAKE_REF'; +MANAGED: 'MANAGED'; +MANAGE: 'MANAGE'; +MANAGEMENT: 'MANAGEMENT'; +MANAGER: 'MANAGER'; +MANDATORY: 'MANDATORY'; +MANUAL: 'MANUAL'; +MAP: 'MAP'; +MAPPING: 'MAPPING'; +MASTER: 'MASTER'; +MATCHED: 'MATCHED'; +MATCHES: 'MATCHES'; +MATCH: 'MATCH'; +MATCH_NUMBER: 'MATCH_NUMBER'; +MATCH_RECOGNIZE: 'MATCH_RECOGNIZE'; +MATERIALIZED: 'MATERIALIZED'; +MATERIALIZE: 'MATERIALIZE'; +MAXARCHLOGS: 'MAXARCHLOGS'; +MAXDATAFILES: 'MAXDATAFILES'; +MAXEXTENTS: 'MAXEXTENTS'; +MAXIMIZE: 'MAXIMIZE'; +MAXINSTANCES: 'MAXINSTANCES'; +MAXLOGFILES: 'MAXLOGFILES'; +MAXLOGHISTORY: 'MAXLOGHISTORY'; +MAXLOGMEMBERS: 'MAXLOGMEMBERS'; +MAX_SHARED_TEMP_SIZE: 'MAX_SHARED_TEMP_SIZE'; +MAXSIZE: 'MAXSIZE'; +MAXTRANS: 'MAXTRANS'; +MAXVALUE: 'MAXVALUE'; +MEASURE: 'MEASURE'; +MEASURES: 'MEASURES'; +MEDIUM: 'MEDIUM'; +MEMBER: 'MEMBER'; +MEMBER_CAPTION: 'MEMBER_CAPTION'; +MEMBER_DESCRIPTION: 'MEMBER_DESCRIPTION'; +MEMBER_NAME: 'MEMBER_NAME'; +MEMBER_UNIQUE_NAME: 'MEMBER_UNIQUE_NAME'; +MEMCOMPRESS: 'MEMCOMPRESS'; +MEMORY: 'MEMORY'; +MERGEACTIONS: 'MERGE$ACTIONS'; +MERGE_AJ: 'MERGE_AJ'; +MERGE_CONST_ON: 'MERGE_CONST_ON'; +MERGE: 'MERGE'; +MERGE_SJ: 'MERGE_SJ'; +METADATA: 'METADATA'; +METHOD: 'METHOD'; +MIGRATE: 'MIGRATE'; +MIGRATION: 'MIGRATION'; +MINEXTENTS: 'MINEXTENTS'; +MINIMIZE: 'MINIMIZE'; +MINIMUM: 'MINIMUM'; +MINING: 'MINING'; +MINUS: 'MINUS'; +MINUS_NULL: 'MINUS_NULL'; +MINUTE: 'MINUTE'; +MINUTES: 'MINUTES'; +MINVALUE: 'MINVALUE'; +MIRRORCOLD: 'MIRRORCOLD'; +MIRRORHOT: 'MIRRORHOT'; +MIRROR: 'MIRROR'; +MISSING: 'MISSING'; +MISMATCH: 'MISMATCH'; +MLSLABEL: 'MLSLABEL'; +MODEL_COMPILE_SUBQUERY: 'MODEL_COMPILE_SUBQUERY'; +MODEL_DONTVERIFY_UNIQUENESS: 'MODEL_DONTVERIFY_UNIQUENESS'; +MODEL_DYNAMIC_SUBQUERY: 'MODEL_DYNAMIC_SUBQUERY'; +MODEL_MIN_ANALYSIS: 'MODEL_MIN_ANALYSIS'; +MODEL: 'MODEL'; +MODEL_NB: 'MODEL_NB'; +MODEL_NO_ANALYSIS: 'MODEL_NO_ANALYSIS'; +MODEL_PBY: 'MODEL_PBY'; +MODEL_PUSH_REF: 'MODEL_PUSH_REF'; +MODEL_SV: 'MODEL_SV'; +MODE: 'MODE'; +MODIFICATION: 'MODIFICATION'; +MODIFY_COLUMN_TYPE: 'MODIFY_COLUMN_TYPE'; +MODIFY: 'MODIFY'; +MOD: 'MOD'; +MODULE: 'MODULE'; +MONITORING: 'MONITORING'; +MONITOR: 'MONITOR'; +MONTH: 'MONTH'; +MONTHS_BETWEEN: 'MONTHS_BETWEEN'; +MONTHS: 'MONTHS'; +MOUNT: 'MOUNT'; +MOUNTPATH: 'MOUNTPATH'; +MOUNTPOINT: 'MOUNTPOINT'; +MOVEMENT: 'MOVEMENT'; +MOVE: 'MOVE'; +MULTIDIMENSIONAL: 'MULTIDIMENSIONAL'; +MULTISET: 'MULTISET'; +MV_MERGE: 'MV_MERGE'; +NAMED: 'NAMED'; +NAME: 'NAME'; +NAMESPACE: 'NAMESPACE'; +NAN: 'NAN'; +NANVL: 'NANVL'; +NATIONAL: 'NATIONAL'; +NATIVE_FULL_OUTER_JOIN: 'NATIVE_FULL_OUTER_JOIN'; +NATIVE: 'NATIVE'; +NATURAL: 'NATURAL'; +NATURALN: 'NATURALN'; +NAV: 'NAV'; +NCHAR_CS: 'NCHAR_CS'; +NCHAR: 'NCHAR'; +NCHR: 'NCHR'; +NCLOB: 'NCLOB'; +NEEDED: 'NEEDED'; +NEG: 'NEG'; +NESTED: 'NESTED'; +NESTED_TABLE_FAST_INSERT: 'NESTED_TABLE_FAST_INSERT'; +NESTED_TABLE_GET_REFS: 'NESTED_TABLE_GET_REFS'; +NESTED_TABLE_ID: 'NESTED_TABLE_ID'; +NESTED_TABLE_SET_REFS: 'NESTED_TABLE_SET_REFS'; +NESTED_TABLE_SET_SETID: 'NESTED_TABLE_SET_SETID'; +NETWORK: 'NETWORK'; +NEVER: 'NEVER'; +NEW: 'NEW'; +NEW_TIME: 'NEW_TIME'; +NEXT_DAY: 'NEXT_DAY'; +NEXT: 'NEXT'; +NL_AJ: 'NL_AJ'; +NLJ_BATCHING: 'NLJ_BATCHING'; +NLJ_INDEX_FILTER: 'NLJ_INDEX_FILTER'; +NLJ_INDEX_SCAN: 'NLJ_INDEX_SCAN'; +NLJ_PREFETCH: 'NLJ_PREFETCH'; +NLS_CALENDAR: 'NLS_CALENDAR'; +NLS_CHARACTERSET: 'NLS_CHARACTERSET'; +NLS_CHARSET_DECL_LEN: 'NLS_CHARSET_DECL_LEN'; +NLS_CHARSET_ID: 'NLS_CHARSET_ID'; +NLS_CHARSET_NAME: 'NLS_CHARSET_NAME'; +NLS_COMP: 'NLS_COMP'; +NLS_CURRENCY: 'NLS_CURRENCY'; +NLS_DATE_FORMAT: 'NLS_DATE_FORMAT'; +NLS_DATE_LANGUAGE: 'NLS_DATE_LANGUAGE'; +NLS_INITCAP: 'NLS_INITCAP'; +NLS_ISO_CURRENCY: 'NLS_ISO_CURRENCY'; +NL_SJ: 'NL_SJ'; +NLS_LANG: 'NLS_LANG'; +NLS_LANGUAGE: 'NLS_LANGUAGE'; +NLS_LENGTH_SEMANTICS: 'NLS_LENGTH_SEMANTICS'; +NLS_LOWER: 'NLS_LOWER'; +NLS_NCHAR_CONV_EXCP: 'NLS_NCHAR_CONV_EXCP'; +NLS_NUMERIC_CHARACTERS: 'NLS_NUMERIC_CHARACTERS'; +NLS_SORT: 'NLS_SORT'; +NLSSORT: 'NLSSORT'; +NLS_SPECIAL_CHARS: 'NLS_SPECIAL_CHARS'; +NLS_TERRITORY: 'NLS_TERRITORY'; +NLS_UPPER: 'NLS_UPPER'; +NO_ACCESS: 'NO_ACCESS'; +NO_ADAPTIVE_PLAN: 'NO_ADAPTIVE_PLAN'; +NO_ANSI_REARCH: 'NO_ANSI_REARCH'; +NOAPPEND: 'NOAPPEND'; +NOARCHIVELOG: 'NOARCHIVELOG'; +NOAUDIT: 'NOAUDIT'; +NO_AUTO_REOPTIMIZE: 'NO_AUTO_REOPTIMIZE'; +NO_BASETABLE_MULTIMV_REWRITE: 'NO_BASETABLE_MULTIMV_REWRITE'; +NO_BATCH_TABLE_ACCESS_BY_ROWID: 'NO_BATCH_TABLE_ACCESS_BY_ROWID'; +NO_BIND_AWARE: 'NO_BIND_AWARE'; +NO_BUFFER: 'NO_BUFFER'; +NOCACHE: 'NOCACHE'; +NO_CARTESIAN: 'NO_CARTESIAN'; +NO_CHECK_ACL_REWRITE: 'NO_CHECK_ACL_REWRITE'; +NO_CLUSTER_BY_ROWID: 'NO_CLUSTER_BY_ROWID'; +NO_CLUSTERING: 'NO_CLUSTERING'; +NO_COALESCE_SQ: 'NO_COALESCE_SQ'; +NO_COMMON_DATA: 'NO_COMMON_DATA'; +NOCOMPRESS: 'NOCOMPRESS'; +NO_CONNECT_BY_CB_WHR_ONLY: 'NO_CONNECT_BY_CB_WHR_ONLY'; +NO_CONNECT_BY_COMBINE_SW: 'NO_CONNECT_BY_COMBINE_SW'; +NO_CONNECT_BY_COST_BASED: 'NO_CONNECT_BY_COST_BASED'; +NO_CONNECT_BY_ELIM_DUPS: 'NO_CONNECT_BY_ELIM_DUPS'; +NO_CONNECT_BY_FILTERING: 'NO_CONNECT_BY_FILTERING'; +NOCOPY: 'NOCOPY'; +NO_COST_XML_QUERY_REWRITE: 'NO_COST_XML_QUERY_REWRITE'; +NO_CPU_COSTING: 'NO_CPU_COSTING'; +NOCPU_COSTING: 'NOCPU_COSTING'; +NOCYCLE: 'NOCYCLE'; +NO_DATA_SECURITY_REWRITE: 'NO_DATA_SECURITY_REWRITE'; +NO_DECORRELATE: 'NO_DECORRELATE'; +NODELAY: 'NODELAY'; +NO_DOMAIN_INDEX_FILTER: 'NO_DOMAIN_INDEX_FILTER'; +NO_DST_UPGRADE_INSERT_CONV: 'NO_DST_UPGRADE_INSERT_CONV'; +NO_ELIM_GROUPBY: 'NO_ELIM_GROUPBY'; +NO_ELIMINATE_JOIN: 'NO_ELIMINATE_JOIN'; +NO_ELIMINATE_OBY: 'NO_ELIMINATE_OBY'; +NO_ELIMINATE_OUTER_JOIN: 'NO_ELIMINATE_OUTER_JOIN'; +NOENTITYESCAPING: 'NOENTITYESCAPING'; +NO_EXPAND_GSET_TO_UNION: 'NO_EXPAND_GSET_TO_UNION'; +NO_EXPAND: 'NO_EXPAND'; +NO_EXPAND_TABLE: 'NO_EXPAND_TABLE'; +NO_FACT: 'NO_FACT'; +NO_FACTORIZE_JOIN: 'NO_FACTORIZE_JOIN'; +NO_FILTERING: 'NO_FILTERING'; +NOFORCE: 'NOFORCE'; +NO_FULL_OUTER_JOIN_TO_OUTER: 'NO_FULL_OUTER_JOIN_TO_OUTER'; +NO_GATHER_OPTIMIZER_STATISTICS: 'NO_GATHER_OPTIMIZER_STATISTICS'; +NO_GBY_PUSHDOWN: 'NO_GBY_PUSHDOWN'; +NOGUARANTEE: 'NOGUARANTEE'; +NO_INDEX_FFS: 'NO_INDEX_FFS'; +NO_INDEX: 'NO_INDEX'; +NO_INDEX_SS: 'NO_INDEX_SS'; +NO_INMEMORY: 'NO_INMEMORY'; +NO_INMEMORY_PRUNING: 'NO_INMEMORY_PRUNING'; +NOKEEP: 'NOKEEP'; +NO_LOAD: 'NO_LOAD'; +NOLOCAL: 'NOLOCAL'; +NOLOGGING: 'NOLOGGING'; +NOMAPPING: 'NOMAPPING'; +NOMAXVALUE: 'NOMAXVALUE'; +NO_MERGE: 'NO_MERGE'; +NOMINIMIZE: 'NOMINIMIZE'; +NOMINVALUE: 'NOMINVALUE'; +NO_MODEL_PUSH_REF: 'NO_MODEL_PUSH_REF'; +NO_MONITORING: 'NO_MONITORING'; +NOMONITORING: 'NOMONITORING'; +NO_MONITOR: 'NO_MONITOR'; +NO_MULTIMV_REWRITE: 'NO_MULTIMV_REWRITE'; +NO_NATIVE_FULL_OUTER_JOIN: 'NO_NATIVE_FULL_OUTER_JOIN'; +NONBLOCKING: 'NONBLOCKING'; +NONEDITIONABLE: 'NONEDITIONABLE'; +NONE: 'NONE'; +NO_NLJ_BATCHING: 'NO_NLJ_BATCHING'; +NO_NLJ_PREFETCH: 'NO_NLJ_PREFETCH'; +NO: 'NO'; +NONSCHEMA: 'NONSCHEMA'; +NO_OBJECT_LINK: 'NO_OBJECT_LINK'; +NOORDER: 'NOORDER'; +NO_ORDER_ROLLUPS: 'NO_ORDER_ROLLUPS'; +NO_OUTER_JOIN_TO_ANTI: 'NO_OUTER_JOIN_TO_ANTI'; +NO_OUTER_JOIN_TO_INNER: 'NO_OUTER_JOIN_TO_INNER'; +NOOVERRIDE: 'NOOVERRIDE'; +NO_PARALLEL_INDEX: 'NO_PARALLEL_INDEX'; +NOPARALLEL_INDEX: 'NOPARALLEL_INDEX'; +NO_PARALLEL: 'NO_PARALLEL'; +NOPARALLEL: 'NOPARALLEL'; +NO_PARTIAL_COMMIT: 'NO_PARTIAL_COMMIT'; +NO_PARTIAL_JOIN: 'NO_PARTIAL_JOIN'; +NO_PARTIAL_ROLLUP_PUSHDOWN: 'NO_PARTIAL_ROLLUP_PUSHDOWN'; +NOPARTITION: 'NOPARTITION'; +NO_PLACE_DISTINCT: 'NO_PLACE_DISTINCT'; +NO_PLACE_GROUP_BY: 'NO_PLACE_GROUP_BY'; +NO_PQ_CONCURRENT_UNION: 'NO_PQ_CONCURRENT_UNION'; +NO_PQ_MAP: 'NO_PQ_MAP'; +NOPROMPT: 'NOPROMPT'; +NO_PQ_REPLICATE: 'NO_PQ_REPLICATE'; +NO_PQ_SKEW: 'NO_PQ_SKEW'; +NO_PRUNE_GSETS: 'NO_PRUNE_GSETS'; +NO_PULL_PRED: 'NO_PULL_PRED'; +NO_PUSH_PRED: 'NO_PUSH_PRED'; +NO_PUSH_SUBQ: 'NO_PUSH_SUBQ'; +NO_PX_FAULT_TOLERANCE: 'NO_PX_FAULT_TOLERANCE'; +NO_PX_JOIN_FILTER: 'NO_PX_JOIN_FILTER'; +NO_QKN_BUFF: 'NO_QKN_BUFF'; +NO_QUERY_TRANSFORMATION: 'NO_QUERY_TRANSFORMATION'; +NO_REF_CASCADE: 'NO_REF_CASCADE'; +NORELOCATE: 'NORELOCATE'; +NORELY: 'NORELY'; +NOREPAIR: 'NOREPAIR'; +NOREPLAY: 'NOREPLAY'; +NORESETLOGS: 'NORESETLOGS'; +NO_RESULT_CACHE: 'NO_RESULT_CACHE'; +NOREVERSE: 'NOREVERSE'; +NO_REWRITE: 'NO_REWRITE'; +NOREWRITE: 'NOREWRITE'; +NORMAL: 'NORMAL'; +NO_ROOT_SW_FOR_LOCAL: 'NO_ROOT_SW_FOR_LOCAL'; +NOROWDEPENDENCIES: 'NOROWDEPENDENCIES'; +NOSCHEMACHECK: 'NOSCHEMACHECK'; +NOSEGMENT: 'NOSEGMENT'; +NO_SEMIJOIN: 'NO_SEMIJOIN'; +NO_SEMI_TO_INNER: 'NO_SEMI_TO_INNER'; +NO_SET_TO_JOIN: 'NO_SET_TO_JOIN'; +NOSORT: 'NOSORT'; +NO_SQL_TRANSLATION: 'NO_SQL_TRANSLATION'; +NO_SQL_TUNE: 'NO_SQL_TUNE'; +NO_STAR_TRANSFORMATION: 'NO_STAR_TRANSFORMATION'; +NO_STATEMENT_QUEUING: 'NO_STATEMENT_QUEUING'; +NO_STATS_GSETS: 'NO_STATS_GSETS'; +NOSTRICT: 'NOSTRICT'; +NO_SUBQUERY_PRUNING: 'NO_SUBQUERY_PRUNING'; +NO_SUBSTRB_PAD: 'NO_SUBSTRB_PAD'; +NO_SWAP_JOIN_INPUTS: 'NO_SWAP_JOIN_INPUTS'; +NOSWITCH: 'NOSWITCH'; +NO_TABLE_LOOKUP_BY_NL: 'NO_TABLE_LOOKUP_BY_NL'; +NO_TEMP_TABLE: 'NO_TEMP_TABLE'; +NOTHING: 'NOTHING'; +NOTIFICATION: 'NOTIFICATION'; +NOT: 'NOT'; +NO_TRANSFORM_DISTINCT_AGG: 'NO_TRANSFORM_DISTINCT_AGG'; +NO_UNNEST: 'NO_UNNEST'; +NO_USE_CUBE: 'NO_USE_CUBE'; +NO_USE_HASH_AGGREGATION: 'NO_USE_HASH_AGGREGATION'; +NO_USE_HASH_GBY_FOR_PUSHDOWN: 'NO_USE_HASH_GBY_FOR_PUSHDOWN'; +NO_USE_HASH: 'NO_USE_HASH'; +NO_USE_INVISIBLE_INDEXES: 'NO_USE_INVISIBLE_INDEXES'; +NO_USE_MERGE: 'NO_USE_MERGE'; +NO_USE_NL: 'NO_USE_NL'; +NO_USE_VECTOR_AGGREGATION: 'NO_USE_VECTOR_AGGREGATION'; +NOVALIDATE: 'NOVALIDATE'; +NO_VECTOR_TRANSFORM_DIMS: 'NO_VECTOR_TRANSFORM_DIMS'; +NO_VECTOR_TRANSFORM_FACT: 'NO_VECTOR_TRANSFORM_FACT'; +NO_VECTOR_TRANSFORM: 'NO_VECTOR_TRANSFORM'; +NOWAIT: 'NOWAIT'; +NO_XDB_FASTPATH_INSERT: 'NO_XDB_FASTPATH_INSERT'; +NO_XML_DML_REWRITE: 'NO_XML_DML_REWRITE'; +NO_XMLINDEX_REWRITE_IN_SELECT: 'NO_XMLINDEX_REWRITE_IN_SELECT'; +NO_XMLINDEX_REWRITE: 'NO_XMLINDEX_REWRITE'; +NO_XML_QUERY_REWRITE: 'NO_XML_QUERY_REWRITE'; +NO_ZONEMAP: 'NO_ZONEMAP'; +NTH_VALUE: 'NTH_VALUE'; +NULLIF: 'NULLIF'; +NULL_: 'NULL'; +NULLS: 'NULLS'; +NUMBER: 'NUMBER'; +NUMERIC: 'NUMERIC'; +NUM_INDEX_KEYS: 'NUM_INDEX_KEYS'; +NUMTODSINTERVAL: 'NUMTODSINTERVAL'; +NUMTOYMINTERVAL: 'NUMTOYMINTERVAL'; +NVARCHAR2: 'NVARCHAR2'; +NVL2: 'NVL2'; +OBJECT2XML: 'OBJECT2XML'; +OBJECT: 'OBJECT'; +OBJ_ID: 'OBJ_ID'; +OBJNO: 'OBJNO'; +OBJNO_REUSE: 'OBJNO_REUSE'; +OCCURENCES: 'OCCURENCES'; +OFFLINE: 'OFFLINE'; +OFF: 'OFF'; +OFFSET: 'OFFSET'; +OF: 'OF'; +OIDINDEX: 'OIDINDEX'; +OID: 'OID'; +OLAP: 'OLAP'; +OLD: 'OLD'; +OLD_PUSH_PRED: 'OLD_PUSH_PRED'; +OLS: 'OLS'; +OLTP: 'OLTP'; +OMIT: 'OMIT'; +ONE: 'ONE'; +ONLINE: 'ONLINE'; +// ONLINELOG: 'ONLINELOG'; +ONLY: 'ONLY'; +ON: 'ON'; +OPAQUE: 'OPAQUE'; +OPAQUE_TRANSFORM: 'OPAQUE_TRANSFORM'; +OPAQUE_XCANONICAL: 'OPAQUE_XCANONICAL'; +OPCODE: 'OPCODE'; +OPEN: 'OPEN'; +OPERATIONS: 'OPERATIONS'; +OPERATOR: 'OPERATOR'; +OPT_ESTIMATE: 'OPT_ESTIMATE'; +OPTIMAL: 'OPTIMAL'; +OPTIMIZE: 'OPTIMIZE'; +OPTIMIZER_FEATURES_ENABLE: 'OPTIMIZER_FEATURES_ENABLE'; +OPTIMIZER_GOAL: 'OPTIMIZER_GOAL'; +OPTION: 'OPTION'; +OPT_PARAM: 'OPT_PARAM'; +ORA_BRANCH: 'ORA_BRANCH'; +ORA_CHECK_ACL: 'ORA_CHECK_ACL'; +ORA_CHECK_PRIVILEGE: 'ORA_CHECK_PRIVILEGE'; +ORA_CLUSTERING: 'ORA_CLUSTERING'; +ORADATA: 'ORADATA'; +ORADEBUG: 'ORADEBUG'; +ORA_DST_AFFECTED: 'ORA_DST_AFFECTED'; +ORA_DST_CONVERT: 'ORA_DST_CONVERT'; +ORA_DST_ERROR: 'ORA_DST_ERROR'; +ORA_GET_ACLIDS: 'ORA_GET_ACLIDS'; +ORA_GET_PRIVILEGES: 'ORA_GET_PRIVILEGES'; +ORA_HASH: 'ORA_HASH'; +ORA_INVOKING_USERID: 'ORA_INVOKING_USERID'; +ORA_INVOKING_USER: 'ORA_INVOKING_USER'; +ORA_INVOKING_XS_USER_GUID: 'ORA_INVOKING_XS_USER_GUID'; +ORA_INVOKING_XS_USER: 'ORA_INVOKING_XS_USER'; +ORA_RAWCOMPARE: 'ORA_RAWCOMPARE'; +ORA_RAWCONCAT: 'ORA_RAWCONCAT'; +ORA_ROWSCN: 'ORA_ROWSCN'; +ORA_ROWSCN_RAW: 'ORA_ROWSCN_RAW'; +ORA_ROWVERSION: 'ORA_ROWVERSION'; +ORA_TABVERSION: 'ORA_TABVERSION'; +ORA_WRITE_TIME: 'ORA_WRITE_TIME'; +ORDERED: 'ORDERED'; +ORDERED_PREDICATES: 'ORDERED_PREDICATES'; +ORDER: 'ORDER'; +ORDINALITY: 'ORDINALITY'; +OR_EXPAND: 'OR_EXPAND'; +ORGANIZATION: 'ORGANIZATION'; +OR: 'OR'; +OR_PREDICATES: 'OR_PREDICATES'; +OSERROR: 'OSERROR'; +OTHER: 'OTHER'; +OUTER_JOIN_TO_ANTI: 'OUTER_JOIN_TO_ANTI'; +OUTER_JOIN_TO_INNER: 'OUTER_JOIN_TO_INNER'; +OUTER: 'OUTER'; +OUTLINE_LEAF: 'OUTLINE_LEAF'; +OUTLINE: 'OUTLINE'; +OUT_OF_LINE: 'OUT_OF_LINE'; +OUT: 'OUT'; +OVERFLOW_NOMOVE: 'OVERFLOW_NOMOVE'; +OVERFLOW: 'OVERFLOW'; +OVERLAPS: 'OVERLAPS'; +OVER: 'OVER'; +OVERRIDING: 'OVERRIDING'; +OWNER: 'OWNER'; +OWNERSHIP: 'OWNERSHIP'; +OWN: 'OWN'; +P_LETTER: 'P'; +PACKAGE: 'PACKAGE'; +PACKAGES: 'PACKAGES'; +PARALLEL_ENABLE: 'PARALLEL_ENABLE'; +PARALLEL_INDEX: 'PARALLEL_INDEX'; +PARALLEL: 'PARALLEL'; +// PARAMETERFILE: 'PARAMETERFILE'; +PARAMETERS: 'PARAMETERS'; +PARAM: 'PARAM'; +PARENT: 'PARENT'; +PARENT_LEVEL_NAME: 'PARENT_LEVEL_NAME'; +PARENT_UNIQUE_NAME: 'PARENT_UNIQUE_NAME'; +PARITY: 'PARITY'; +PARTIAL_JOIN: 'PARTIAL_JOIN'; +PARTIALLY: 'PARTIALLY'; +PARTIAL: 'PARTIAL'; +PARTIAL_ROLLUP_PUSHDOWN: 'PARTIAL_ROLLUP_PUSHDOWN'; +PARTITION_HASH: 'PARTITION_HASH'; +PARTITION_LIST: 'PARTITION_LIST'; +PARTITION: 'PARTITION'; +PARTITION_RANGE: 'PARTITION_RANGE'; +PARTITIONS: 'PARTITIONS'; +PARTNUMINST: 'PART$NUM$INST'; +PASSING: 'PASSING'; +PASSWORD_GRACE_TIME: 'PASSWORD_GRACE_TIME'; +PASSWORD_LIFE_TIME: 'PASSWORD_LIFE_TIME'; +PASSWORD_LOCK_TIME: 'PASSWORD_LOCK_TIME'; +PASSWORD: 'PASSWORD'; +PASSWORD_REUSE_MAX: 'PASSWORD_REUSE_MAX'; +PASSWORD_REUSE_TIME: 'PASSWORD_REUSE_TIME'; +PASSWORD_ROLLOVER_TIME: 'PASSWORD_ROLLOVER_TIME'; +PASSWORD_VERIFY_FUNCTION: 'PASSWORD_VERIFY_FUNCTION'; +PAST: 'PAST'; +PATCH: 'PATCH'; +PATH: 'PATH'; +PATH_PREFIX: 'PATH_PREFIX'; +PATHS: 'PATHS'; +PATTERN: 'PATTERN'; +PBL_HS_BEGIN: 'PBL_HS_BEGIN'; +PBL_HS_END: 'PBL_HS_END'; +PCTFREE: 'PCTFREE'; +PCTINCREASE: 'PCTINCREASE'; +PCTTHRESHOLD: 'PCTTHRESHOLD'; +PCTUSED: 'PCTUSED'; +PCTVERSION: 'PCTVERSION'; +PENDING: 'PENDING'; +PERCENT_FOUND: '%' SPACE* 'FOUND'; +PERCENT_ISOPEN: '%' SPACE* 'ISOPEN'; +PERCENT_NOTFOUND: '%' SPACE* 'NOTFOUND'; +PERCENT_KEYWORD: 'PERCENT'; +PERCENT_RANKM: 'PERCENT_RANKM'; +PERCENT_ROWCOUNT: '%' SPACE* 'ROWCOUNT'; +PERCENT_ROWTYPE: '%' SPACE* 'ROWTYPE'; +PERCENT_TYPE: '%' SPACE* 'TYPE'; +PERFORMANCE: 'PERFORMANCE'; +PERIOD_KEYWORD: 'PERIOD'; +PERMANENT: 'PERMANENT'; +PERMISSION: 'PERMISSION'; +PERMUTE: 'PERMUTE'; +PER: 'PER'; +PFILE: 'PFILE'; +PHYSICAL: 'PHYSICAL'; +PIKEY: 'PIKEY'; +PIPELINED: 'PIPELINED'; +PIPE: 'PIPE'; +PIV_GB: 'PIV_GB'; +PIVOT: 'PIVOT'; +PIV_SSF: 'PIV_SSF'; +PLACE_DISTINCT: 'PLACE_DISTINCT'; +PLACE_GROUP_BY: 'PLACE_GROUP_BY'; +PLAN: 'PLAN'; +PLSCOPE_SETTINGS: 'PLSCOPE_SETTINGS'; +PLS_INTEGER: 'PLS_INTEGER'; +PLSQL_CCFLAGS: 'PLSQL_CCFLAGS'; +PLSQL_CODE_TYPE: 'PLSQL_CODE_TYPE'; +PLSQL_DEBUG: 'PLSQL_DEBUG'; +PLSQL_OPTIMIZE_LEVEL: 'PLSQL_OPTIMIZE_LEVEL'; +PLSQL_WARNINGS: 'PLSQL_WARNINGS'; +PLUGGABLE: 'PLUGGABLE'; +PMEM: 'PMEM'; +POINT: 'POINT'; +POLICY: 'POLICY'; +POOL_16K: 'POOL_16K'; +POOL_2K: 'POOL_2K'; +POOL_32K: 'POOL_32K'; +POOL_4K: 'POOL_4K'; +POOL_8K: 'POOL_8K'; +POSITIVEN: 'POSITIVEN'; +POSITIVE: 'POSITIVE'; +POST_TRANSACTION: 'POST_TRANSACTION'; +POWERMULTISET_BY_CARDINALITY: 'POWERMULTISET_BY_CARDINALITY'; +POWERMULTISET: 'POWERMULTISET'; +POWER: 'POWER'; +PQ_CONCURRENT_UNION: 'PQ_CONCURRENT_UNION'; +PQ_DISTRIBUTE: 'PQ_DISTRIBUTE'; +PQ_DISTRIBUTE_WINDOW: 'PQ_DISTRIBUTE_WINDOW'; +PQ_FILTER: 'PQ_FILTER'; +PQ_MAP: 'PQ_MAP'; +PQ_NOMAP: 'PQ_NOMAP'; +PQ_REPLICATE: 'PQ_REPLICATE'; +PQ_SKEW: 'PQ_SKEW'; +PRAGMA: 'PRAGMA'; +PREBUILT: 'PREBUILT'; +PRECEDES: 'PRECEDES'; +PRECEDING: 'PRECEDING'; +PRECISION: 'PRECISION'; +PRECOMPUTE_SUBQUERY: 'PRECOMPUTE_SUBQUERY'; +PREDICATE_REORDERS: 'PREDICATE_REORDERS'; +PRELOAD: 'PRELOAD'; +PREPARE: 'PREPARE'; +PRESENTNNV: 'PRESENTNNV'; +PRESENT: 'PRESENT'; +PRESENTV: 'PRESENTV'; +PRESERVE_OID: 'PRESERVE_OID'; +PRESERVE: 'PRESERVE'; +PRETTY: 'PRETTY'; +PREVIOUS: 'PREVIOUS'; +PREV: 'PREV'; +PRIMARY: 'PRIMARY'; +PRINTBLOBTOCLOB: 'PRINTBLOBTOCLOB'; +PRIORITY: 'PRIORITY'; +PRIOR: 'PRIOR'; +PRIVATE: 'PRIVATE'; +PRIVATE_SGA: 'PRIVATE_SGA'; +PRIVILEGED: 'PRIVILEGED'; +PRIVILEGE: 'PRIVILEGE'; +PRIVILEGES: 'PRIVILEGES'; +PROCEDURAL: 'PROCEDURAL'; +PROCEDURE: 'PROCEDURE'; +PROCESS: 'PROCESS'; +PROFILE: 'PROFILE'; +PROGRAM: 'PROGRAM'; +PROJECT: 'PROJECT'; +PROPAGATE: 'PROPAGATE'; +PROPERTY: 'PROPERTY'; +PROTECTED: 'PROTECTED'; +PROTECTION: 'PROTECTION'; +PROTOCOL: 'PROTOCOL'; +PROXY: 'PROXY'; +PRUNING: 'PRUNING'; +PUBLIC: 'PUBLIC'; +PULL_PRED: 'PULL_PRED'; +PURGE: 'PURGE'; +PUSH_PRED: 'PUSH_PRED'; +PUSH_SUBQ: 'PUSH_SUBQ'; +PX_FAULT_TOLERANCE: 'PX_FAULT_TOLERANCE'; +PX_GRANULE: 'PX_GRANULE'; +PX_JOIN_FILTER: 'PX_JOIN_FILTER'; +QB_NAME: 'QB_NAME'; +QUARTERS: 'QUARTERS'; +QUERY_BLOCK: 'QUERY_BLOCK'; +QUERY: 'QUERY'; +QUEUE_CURR: 'QUEUE_CURR'; +QUEUE: 'QUEUE'; +QUEUE_ROWP: 'QUEUE_ROWP'; +QUIESCE: 'QUIESCE'; +QUORUM: 'QUORUM'; +QUOTA: 'QUOTA'; +QUOTAGROUP: 'QUOTAGROUP'; +RAISE: 'RAISE'; +RANDOM_LOCAL: 'RANDOM_LOCAL'; +RANDOM: 'RANDOM'; +RANGE: 'RANGE'; +RANKM: 'RANKM'; +RAPIDLY: 'RAPIDLY'; +RAW: 'RAW'; +RAWTOHEX: 'RAWTOHEX'; +RAWTONHEX: 'RAWTONHEX'; +RBA: 'RBA'; +RBO_OUTLINE: 'RBO_OUTLINE'; +RDBA: 'RDBA'; +READ: 'READ'; +READS: 'READS'; +REALM: 'REALM'; +REAL: 'REAL'; +REBALANCE: 'REBALANCE'; +REBUILD: 'REBUILD'; +RECORD: 'RECORD'; +RECORDS_PER_BLOCK: 'RECORDS_PER_BLOCK'; +RECOVERABLE: 'RECOVERABLE'; +RECOVER: 'RECOVER'; +RECOVERY: 'RECOVERY'; +RECYCLEBIN: 'RECYCLEBIN'; +RECYCLE: 'RECYCLE'; +REDACTION: 'REDACTION'; +REDEFINE: 'REDEFINE'; +REDO: 'REDO'; +REDUCED: 'REDUCED'; +REDUNDANCY: 'REDUNDANCY'; +REF_CASCADE_CURSOR: 'REF_CASCADE_CURSOR'; +REFERENCED: 'REFERENCED'; +REFERENCE: 'REFERENCE'; +REFERENCES: 'REFERENCES'; +REFERENCING: 'REFERENCING'; +REF: 'REF'; +REFRESH: 'REFRESH'; +REFTOHEX: 'REFTOHEX'; +REGEXP_COUNT: 'REGEXP_COUNT'; +REGEXP_INSTR: 'REGEXP_INSTR'; +REGEXP_LIKE: 'REGEXP_LIKE'; +REGEXP_REPLACE: 'REGEXP_REPLACE'; +REGEXP_SUBSTR: 'REGEXP_SUBSTR'; +REGISTER: 'REGISTER'; +REGR_AVGX: 'REGR_AVGX'; +REGR_AVGY: 'REGR_AVGY'; +REGR_COUNT: 'REGR_COUNT'; +REGR_INTERCEPT: 'REGR_INTERCEPT'; +REGR_R2: 'REGR_R2'; +REGR_SLOPE: 'REGR_SLOPE'; +REGR_SXX: 'REGR_SXX'; +REGR_SXY: 'REGR_SXY'; +REGR_SYY: 'REGR_SYY'; +REGULAR: 'REGULAR'; +REJECT: 'REJECT'; +REKEY: 'REKEY'; +RELATIONAL: 'RELATIONAL'; +RELIES_ON: 'RELIES_ON'; +RELOCATE: 'RELOCATE'; +RELY: 'RELY'; +REMAINDER: 'REMAINDER'; +REMOTE: 'REMOTE'; +REMOTE_MAPPED: 'REMOTE_MAPPED'; +REMOVE: 'REMOVE'; +RENAME: 'RENAME'; +REPAIR: 'REPAIR'; +REPEAT: 'REPEAT'; +REPLACE: 'REPLACE'; +REPLICATION: 'REPLICATION'; +REQUIRED: 'REQUIRED'; +RESETLOGS: 'RESETLOGS'; +RESET: 'RESET'; +RESIZE: 'RESIZE'; +RESOLVE: 'RESOLVE'; +RESOLVER: 'RESOLVER'; +RESOURCE: 'RESOURCE'; +RESPECT: 'RESPECT'; +RESTART: 'RESTART'; +RESTORE_AS_INTERVALS: 'RESTORE_AS_INTERVALS'; +RESTORE: 'RESTORE'; +RESTRICT_ALL_REF_CONS: 'RESTRICT_ALL_REF_CONS'; +RESTRICTED: 'RESTRICTED'; +RESTRICT_REFERENCES: 'RESTRICT_REFERENCES'; +RESTRICT: 'RESTRICT'; +RESULT_CACHE: 'RESULT_CACHE'; +RESULT: 'RESULT'; +RESUMABLE: 'RESUMABLE'; +RESUME: 'RESUME'; +RETENTION: 'RETENTION'; +RETRY_ON_ROW_CHANGE: 'RETRY_ON_ROW_CHANGE'; +RETURNING: 'RETURNING'; +RETURN: 'RETURN'; +REUSE: 'REUSE'; +REVERSE: 'REVERSE'; +REVOKE: 'REVOKE'; +REWRITE_OR_ERROR: 'REWRITE_OR_ERROR'; +REWRITE: 'REWRITE'; +RIGHT: 'RIGHT'; +ROLE: 'ROLE'; +ROLESET: 'ROLESET'; +ROLES: 'ROLES'; +ROLLBACK: 'ROLLBACK'; +ROLLING: 'ROLLING'; +ROLLUP: 'ROLLUP'; +ROWDEPENDENCIES: 'ROWDEPENDENCIES'; +ROWID_MAPPING_TABLE: 'ROWID_MAPPING_TABLE'; +ROWID: 'ROWID'; +ROWIDTOCHAR: 'ROWIDTOCHAR'; +ROWIDTONCHAR: 'ROWIDTONCHAR'; +ROW_LENGTH: 'ROW_LENGTH'; +ROWNUM: 'ROWNUM'; +ROW: 'ROW'; +ROWS: 'ROWS'; +RPAD: 'RPAD'; +RTRIM: 'RTRIM'; +RULE: 'RULE'; +RULES: 'RULES'; +RUNNING: 'RUNNING'; +SALT: 'SALT'; +SAMPLE: 'SAMPLE'; +SAVE_AS_INTERVALS: 'SAVE_AS_INTERVALS'; +SAVEPOINT: 'SAVEPOINT'; +SAVE: 'SAVE'; +SB4: 'SB4'; +SCALE_ROWS: 'SCALE_ROWS'; +SCALE: 'SCALE'; +SCAN_INSTANCES: 'SCAN_INSTANCES'; +SCAN: 'SCAN'; +SCHEDULER: 'SCHEDULER'; +SCHEMACHECK: 'SCHEMACHECK'; +SCHEMA: 'SCHEMA'; +SCN_ASCENDING: 'SCN_ASCENDING'; +SCN: 'SCN'; +SCOPE: 'SCOPE'; +SCRUB: 'SCRUB'; +SD_ALL: 'SD_ALL'; +SD_INHIBIT: 'SD_INHIBIT'; +SDO_GEOM_MBR: 'SDO_GEOM_MBR'; +SDO_GEOMETRY: 'SDO_GEOMETRY'; +SD_SHOW: 'SD_SHOW'; +SEARCH: 'SEARCH'; +SECOND: 'SECOND'; +SECONDS: 'SECONDS'; +SECRET: 'SECRET'; +SECUREFILE_DBA: 'SECUREFILE_DBA'; +SECUREFILE: 'SECUREFILE'; +SECURITY: 'SECURITY'; +SEED: 'SEED'; +SEG_BLOCK: 'SEG_BLOCK'; +SEG_FILE: 'SEG_FILE'; +SEGMENT: 'SEGMENT'; +SELECTIVITY: 'SELECTIVITY'; +SELECT: 'SELECT'; +SELF: 'SELF'; +SEMIJOIN_DRIVER: 'SEMIJOIN_DRIVER'; +SEMIJOIN: 'SEMIJOIN'; +SEMI_TO_INNER: 'SEMI_TO_INNER'; +SEQUENCED: 'SEQUENCED'; +SEQUENCE: 'SEQUENCE'; +SEQUENTIAL: 'SEQUENTIAL'; +// SEQ: 'SEQ'; +SERIALIZABLE: 'SERIALIZABLE'; +SERIALLY_REUSABLE: 'SERIALLY_REUSABLE'; +SERIAL: 'SERIAL'; +SERVERERROR: 'SERVERERROR'; +SERVICE_NAME_CONVERT: 'SERVICE_NAME_CONVERT'; +SERVICE: 'SERVICE'; +SERVICES: 'SERVICES'; +SESSION_CACHED_CURSORS: 'SESSION_CACHED_CURSORS'; +SESSION: 'SESSION'; +SESSIONS_PER_USER: 'SESSIONS_PER_USER'; +SESSIONTIMEZONE: 'SESSIONTIMEZONE'; +SESSIONTZNAME: 'SESSIONTZNAME'; +SET: 'SET'; +SETS: 'SETS'; +SETTINGS: 'SETTINGS'; +SET_TO_JOIN: 'SET_TO_JOIN'; +SEVERE: 'SEVERE'; +SHARDSPACE: 'SHARDSPACE'; +SHARED_POOL: 'SHARED_POOL'; +SHARED: 'SHARED'; +SHARE: 'SHARE'; +SHARING: 'SHARING'; +SHELFLIFE: 'SHELFLIFE'; +SHOW: 'SHOW'; +SHRINK: 'SHRINK'; +SHUTDOWN: 'SHUTDOWN'; +SIBLINGS: 'SIBLINGS'; +SID: 'SID'; +SITE: 'SITE'; +SIGNAL_COMPONENT: 'SIGNAL_COMPONENT'; +SIGNAL_FUNCTION: 'SIGNAL_FUNCTION'; +SIGN: 'SIGN'; +SIGNTYPE: 'SIGNTYPE'; +SIMPLE_INTEGER: 'SIMPLE_INTEGER'; +SIMPLE: 'SIMPLE'; +SINGLE: 'SINGLE'; +SINGLETASK: 'SINGLETASK'; +SINH: 'SINH'; +SIN: 'SIN'; +SIZE: 'SIZE'; +SKIP_EXT_OPTIMIZER: 'SKIP_EXT_OPTIMIZER'; +SKIP_ : 'SKIP'; +SKIP_UNQ_UNUSABLE_IDX: 'SKIP_UNQ_UNUSABLE_IDX'; +SKIP_UNUSABLE_INDEXES: 'SKIP_UNUSABLE_INDEXES'; +SMALLFILE: 'SMALLFILE'; +SMALLINT: 'SMALLINT'; +SNAPSHOT: 'SNAPSHOT'; +SOME: 'SOME'; +SORT: 'SORT'; +SOUNDEX: 'SOUNDEX'; +SOURCE_FILE_DIRECTORY: 'SOURCE_FILE_DIRECTORY'; +SOURCE_FILE_NAME_CONVERT: 'SOURCE_FILE_NAME_CONVERT'; +SOURCE: 'SOURCE'; +SPACE_KEYWORD: 'SPACE'; +SPECIFICATION: 'SPECIFICATION'; +SPFILE: 'SPFILE'; +SPLIT: 'SPLIT'; +SPREADSHEET: 'SPREADSHEET'; +SQLDATA: 'SQLDATA'; +SQLERROR: 'SQLERROR'; +SQLLDR: 'SQLLDR'; +SQL: 'SQL'; +SQL_MACRO: 'SQL_MACRO'; +SQL_TRACE: 'SQL_TRACE'; +SQL_TRANSLATION_PROFILE: 'SQL_TRANSLATION_PROFILE'; +SQRT: 'SQRT'; +STALE: 'STALE'; +STANDALONE: 'STANDALONE'; +STANDARD: 'STANDARD'; +STANDARD_HASH: 'STANDARD_HASH'; +STANDBY_MAX_DATA_DELAY: 'STANDBY_MAX_DATA_DELAY'; +STANDBYS: 'STANDBYS'; +STANDBY: 'STANDBY'; +STAR: 'STAR'; +STAR_TRANSFORMATION: 'STAR_TRANSFORMATION'; +START: 'START'; +STARTUP: 'STARTUP'; +STATEMENT_ID: 'STATEMENT_ID'; +STATEMENT_QUEUING: 'STATEMENT_QUEUING'; +STATEMENTS: 'STATEMENTS'; +STATEMENT: 'STATEMENT'; +STATE: 'STATE'; +STATIC: 'STATIC'; +STATISTICS: 'STATISTICS'; +STATS_BINOMIAL_TEST: 'STATS_BINOMIAL_TEST'; +STATS_CROSSTAB: 'STATS_CROSSTAB'; +STATS_F_TEST: 'STATS_F_TEST'; +STATS_KS_TEST: 'STATS_KS_TEST'; +STATS_MODE: 'STATS_MODE'; +STATS_MW_TEST: 'STATS_MW_TEST'; +STATS_ONE_WAY_ANOVA: 'STATS_ONE_WAY_ANOVA'; +STATS_T_TEST_INDEP: 'STATS_T_TEST_INDEP'; +STATS_T_TEST_INDEPU: 'STATS_T_TEST_INDEPU'; +STATS_T_TEST_ONE: 'STATS_T_TEST_ONE'; +STATS_T_TEST_PAIRED: 'STATS_T_TEST_PAIRED'; +STATS_WSR_TEST: 'STATS_WSR_TEST'; +STDDEV_POP: 'STDDEV_POP'; +STDDEV_SAMP: 'STDDEV_SAMP'; +STOP: 'STOP'; +STORAGE: 'STORAGE'; +STORE: 'STORE'; +STREAMS: 'STREAMS'; +STREAM: 'STREAM'; +STRICT: 'STRICT'; +STRING: 'STRING'; +STRIPE_COLUMNS: 'STRIPE_COLUMNS'; +STRIPE_WIDTH: 'STRIPE_WIDTH'; +STRIP: 'STRIP'; +STRUCTURE: 'STRUCTURE'; +SUBMULTISET: 'SUBMULTISET'; +SUBPARTITION_REL: 'SUBPARTITION_REL'; +SUBPARTITIONS: 'SUBPARTITIONS'; +SUBPARTITION: 'SUBPARTITION'; +SUBQUERIES: 'SUBQUERIES'; +SUBQUERY_PRUNING: 'SUBQUERY_PRUNING'; +SUBSCRIBE: 'SUBSCRIBE'; +SUBSET: 'SUBSET'; +SUBSTITUTABLE: 'SUBSTITUTABLE'; +SUBSTR2: 'SUBSTR2'; +SUBSTR4: 'SUBSTR4'; +SUBSTRB: 'SUBSTRB'; +SUBSTRC: 'SUBSTRC'; +SUBTYPE: 'SUBTYPE'; +SUCCESSFUL: 'SUCCESSFUL'; +SUCCESS: 'SUCCESS'; +SUMMARY: 'SUMMARY'; +SUPPLEMENTAL: 'SUPPLEMENTAL'; +SUSPEND: 'SUSPEND'; +SWAP_JOIN_INPUTS: 'SWAP_JOIN_INPUTS'; +SWITCHOVER: 'SWITCHOVER'; +SWITCH: 'SWITCH'; +SYNCHRONOUS: 'SYNCHRONOUS'; +SYNC: 'SYNC'; +SYNONYM: 'SYNONYM'; +SYS: 'SYS'; +SYSASM: 'SYSASM'; +SYS_AUDIT: 'SYS_AUDIT'; +SYSAUX: 'SYSAUX'; +SYSBACKUP: 'SYSBACKUP'; +SYS_CHECKACL: 'SYS_CHECKACL'; +SYS_CHECK_PRIVILEGE: 'SYS_CHECK_PRIVILEGE'; +SYS_CONNECT_BY_PATH: 'SYS_CONNECT_BY_PATH'; +SYS_CONTEXT: 'SYS_CONTEXT'; +SYSDATE: 'SYSDATE'; +SYSDBA: 'SYSDBA'; +SYS_DBURIGEN: 'SYS_DBURIGEN'; +SYSDG: 'SYSDG'; +SYS_DL_CURSOR: 'SYS_DL_CURSOR'; +SYS_DM_RXFORM_CHR: 'SYS_DM_RXFORM_CHR'; +SYS_DM_RXFORM_NUM: 'SYS_DM_RXFORM_NUM'; +SYS_DOM_COMPARE: 'SYS_DOM_COMPARE'; +SYS_DST_PRIM2SEC: 'SYS_DST_PRIM2SEC'; +SYS_DST_SEC2PRIM: 'SYS_DST_SEC2PRIM'; +SYS_ET_BFILE_TO_RAW: 'SYS_ET_BFILE_TO_RAW'; +SYS_ET_BLOB_TO_IMAGE: 'SYS_ET_BLOB_TO_IMAGE'; +SYS_ET_IMAGE_TO_BLOB: 'SYS_ET_IMAGE_TO_BLOB'; +SYS_ET_RAW_TO_BFILE: 'SYS_ET_RAW_TO_BFILE'; +SYS_EXTPDTXT: 'SYS_EXTPDTXT'; +SYS_EXTRACT_UTC: 'SYS_EXTRACT_UTC'; +SYS_FBT_INSDEL: 'SYS_FBT_INSDEL'; +SYS_FILTER_ACLS: 'SYS_FILTER_ACLS'; +SYS_FNMATCHES: 'SYS_FNMATCHES'; +SYS_FNREPLACE: 'SYS_FNREPLACE'; +SYS_GET_ACLIDS: 'SYS_GET_ACLIDS'; +SYS_GET_COL_ACLIDS: 'SYS_GET_COL_ACLIDS'; +SYS_GET_PRIVILEGES: 'SYS_GET_PRIVILEGES'; +SYS_GETTOKENID: 'SYS_GETTOKENID'; +SYS_GETXTIVAL: 'SYS_GETXTIVAL'; +SYS_GUID: 'SYS_GUID'; +SYSGUID: 'SYSGUID'; +SYSKM: 'SYSKM'; +SYS_MAKE_XMLNODEID: 'SYS_MAKE_XMLNODEID'; +SYS_MAKEXML: 'SYS_MAKEXML'; +SYS_MKXMLATTR: 'SYS_MKXMLATTR'; +SYS_MKXTI: 'SYS_MKXTI'; +SYSOBJ: 'SYSOBJ'; +SYS_OP_ADT2BIN: 'SYS_OP_ADT2BIN'; +SYS_OP_ADTCONS: 'SYS_OP_ADTCONS'; +SYS_OP_ALSCRVAL: 'SYS_OP_ALSCRVAL'; +SYS_OP_ATG: 'SYS_OP_ATG'; +SYS_OP_BIN2ADT: 'SYS_OP_BIN2ADT'; +SYS_OP_BITVEC: 'SYS_OP_BITVEC'; +SYS_OP_BL2R: 'SYS_OP_BL2R'; +SYS_OP_BLOOM_FILTER_LIST: 'SYS_OP_BLOOM_FILTER_LIST'; +SYS_OP_BLOOM_FILTER: 'SYS_OP_BLOOM_FILTER'; +SYS_OP_C2C: 'SYS_OP_C2C'; +SYS_OP_CAST: 'SYS_OP_CAST'; +SYS_OP_CEG: 'SYS_OP_CEG'; +SYS_OP_CL2C: 'SYS_OP_CL2C'; +SYS_OP_COMBINED_HASH: 'SYS_OP_COMBINED_HASH'; +SYS_OP_COMP: 'SYS_OP_COMP'; +SYS_OP_CONVERT: 'SYS_OP_CONVERT'; +SYS_OP_COUNTCHG: 'SYS_OP_COUNTCHG'; +SYS_OP_CSCONV: 'SYS_OP_CSCONV'; +SYS_OP_CSCONVTEST: 'SYS_OP_CSCONVTEST'; +SYS_OP_CSR: 'SYS_OP_CSR'; +SYS_OP_CSX_PATCH: 'SYS_OP_CSX_PATCH'; +SYS_OP_CYCLED_SEQ: 'SYS_OP_CYCLED_SEQ'; +SYS_OP_DECOMP: 'SYS_OP_DECOMP'; +SYS_OP_DESCEND: 'SYS_OP_DESCEND'; +SYS_OP_DISTINCT: 'SYS_OP_DISTINCT'; +SYS_OP_DRA: 'SYS_OP_DRA'; +SYS_OP_DUMP: 'SYS_OP_DUMP'; +SYS_OP_DV_CHECK: 'SYS_OP_DV_CHECK'; +SYS_OP_ENFORCE_NOT_NULL: 'SYS_OP_ENFORCE_NOT_NULL$'; +SYSOPER: 'SYSOPER'; +SYS_OP_EXTRACT: 'SYS_OP_EXTRACT'; +SYS_OP_GROUPING: 'SYS_OP_GROUPING'; +SYS_OP_GUID: 'SYS_OP_GUID'; +SYS_OP_HASH: 'SYS_OP_HASH'; +SYS_OP_IIX: 'SYS_OP_IIX'; +SYS_OP_ITR: 'SYS_OP_ITR'; +SYS_OP_KEY_VECTOR_CREATE: 'SYS_OP_KEY_VECTOR_CREATE'; +SYS_OP_KEY_VECTOR_FILTER_LIST: 'SYS_OP_KEY_VECTOR_FILTER_LIST'; +SYS_OP_KEY_VECTOR_FILTER: 'SYS_OP_KEY_VECTOR_FILTER'; +SYS_OP_KEY_VECTOR_SUCCEEDED: 'SYS_OP_KEY_VECTOR_SUCCEEDED'; +SYS_OP_KEY_VECTOR_USE: 'SYS_OP_KEY_VECTOR_USE'; +SYS_OP_LBID: 'SYS_OP_LBID'; +SYS_OP_LOBLOC2BLOB: 'SYS_OP_LOBLOC2BLOB'; +SYS_OP_LOBLOC2CLOB: 'SYS_OP_LOBLOC2CLOB'; +SYS_OP_LOBLOC2ID: 'SYS_OP_LOBLOC2ID'; +SYS_OP_LOBLOC2NCLOB: 'SYS_OP_LOBLOC2NCLOB'; +SYS_OP_LOBLOC2TYP: 'SYS_OP_LOBLOC2TYP'; +SYS_OP_LSVI: 'SYS_OP_LSVI'; +SYS_OP_LVL: 'SYS_OP_LVL'; +SYS_OP_MAKEOID: 'SYS_OP_MAKEOID'; +SYS_OP_MAP_NONNULL: 'SYS_OP_MAP_NONNULL'; +SYS_OP_MSR: 'SYS_OP_MSR'; +SYS_OP_NICOMBINE: 'SYS_OP_NICOMBINE'; +SYS_OP_NIEXTRACT: 'SYS_OP_NIEXTRACT'; +SYS_OP_NII: 'SYS_OP_NII'; +SYS_OP_NIX: 'SYS_OP_NIX'; +SYS_OP_NOEXPAND: 'SYS_OP_NOEXPAND'; +SYS_OP_NTCIMG: 'SYS_OP_NTCIMG$'; +SYS_OP_NUMTORAW: 'SYS_OP_NUMTORAW'; +SYS_OP_OIDVALUE: 'SYS_OP_OIDVALUE'; +SYS_OP_OPNSIZE: 'SYS_OP_OPNSIZE'; +SYS_OP_PAR_1: 'SYS_OP_PAR_1'; +SYS_OP_PARGID_1: 'SYS_OP_PARGID_1'; +SYS_OP_PARGID: 'SYS_OP_PARGID'; +SYS_OP_PAR: 'SYS_OP_PAR'; +SYS_OP_PART_ID: 'SYS_OP_PART_ID'; +SYS_OP_PIVOT: 'SYS_OP_PIVOT'; +SYS_OP_R2O: 'SYS_OP_R2O'; +SYS_OP_RAWTONUM: 'SYS_OP_RAWTONUM'; +SYS_OP_RDTM: 'SYS_OP_RDTM'; +SYS_OP_REF: 'SYS_OP_REF'; +SYS_OP_RMTD: 'SYS_OP_RMTD'; +SYS_OP_ROWIDTOOBJ: 'SYS_OP_ROWIDTOOBJ'; +SYS_OP_RPB: 'SYS_OP_RPB'; +SYS_OPTLOBPRBSC: 'SYS_OPTLOBPRBSC'; +SYS_OP_TOSETID: 'SYS_OP_TOSETID'; +SYS_OP_TPR: 'SYS_OP_TPR'; +SYS_OP_TRTB: 'SYS_OP_TRTB'; +SYS_OPTXICMP: 'SYS_OPTXICMP'; +SYS_OPTXQCASTASNQ: 'SYS_OPTXQCASTASNQ'; +SYS_OP_UNDESCEND: 'SYS_OP_UNDESCEND'; +SYS_OP_VECAND: 'SYS_OP_VECAND'; +SYS_OP_VECBIT: 'SYS_OP_VECBIT'; +SYS_OP_VECOR: 'SYS_OP_VECOR'; +SYS_OP_VECXOR: 'SYS_OP_VECXOR'; +SYS_OP_VERSION: 'SYS_OP_VERSION'; +SYS_OP_VREF: 'SYS_OP_VREF'; +SYS_OP_VVD: 'SYS_OP_VVD'; +SYS_OP_XMLCONS_FOR_CSX: 'SYS_OP_XMLCONS_FOR_CSX'; +SYS_OP_XPTHATG: 'SYS_OP_XPTHATG'; +SYS_OP_XPTHIDX: 'SYS_OP_XPTHIDX'; +SYS_OP_XPTHOP: 'SYS_OP_XPTHOP'; +SYS_OP_XTXT2SQLT: 'SYS_OP_XTXT2SQLT'; +SYS_OP_ZONE_ID: 'SYS_OP_ZONE_ID'; +SYS_ORDERKEY_DEPTH: 'SYS_ORDERKEY_DEPTH'; +SYS_ORDERKEY_MAXCHILD: 'SYS_ORDERKEY_MAXCHILD'; +SYS_ORDERKEY_PARENT: 'SYS_ORDERKEY_PARENT'; +SYS_PARALLEL_TXN: 'SYS_PARALLEL_TXN'; +SYS_PATHID_IS_ATTR: 'SYS_PATHID_IS_ATTR'; +SYS_PATHID_IS_NMSPC: 'SYS_PATHID_IS_NMSPC'; +SYS_PATHID_LASTNAME: 'SYS_PATHID_LASTNAME'; +SYS_PATHID_LASTNMSPC: 'SYS_PATHID_LASTNMSPC'; +SYS_PATH_REVERSE: 'SYS_PATH_REVERSE'; +SYS_PXQEXTRACT: 'SYS_PXQEXTRACT'; +SYS_RAW_TO_XSID: 'SYS_RAW_TO_XSID'; +SYS_RID_ORDER: 'SYS_RID_ORDER'; +SYS_ROW_DELTA: 'SYS_ROW_DELTA'; +SYS_SC_2_XMLT: 'SYS_SC_2_XMLT'; +SYS_SYNRCIREDO: 'SYS_SYNRCIREDO'; +SYSTEM_DEFINED: 'SYSTEM_DEFINED'; +SYSTEM: 'SYSTEM'; +SYSTIMESTAMP: 'SYSTIMESTAMP'; +SYS_TYPEID: 'SYS_TYPEID'; +SYS_UMAKEXML: 'SYS_UMAKEXML'; +SYS_XMLANALYZE: 'SYS_XMLANALYZE'; +SYS_XMLCONTAINS: 'SYS_XMLCONTAINS'; +SYS_XMLCONV: 'SYS_XMLCONV'; +SYS_XMLEXNSURI: 'SYS_XMLEXNSURI'; +SYS_XMLGEN: 'SYS_XMLGEN'; +SYS_XMLI_LOC_ISNODE: 'SYS_XMLI_LOC_ISNODE'; +SYS_XMLI_LOC_ISTEXT: 'SYS_XMLI_LOC_ISTEXT'; +SYS_XMLINSTR: 'SYS_XMLINSTR'; +SYS_XMLLOCATOR_GETSVAL: 'SYS_XMLLOCATOR_GETSVAL'; +SYS_XMLNODEID_GETCID: 'SYS_XMLNODEID_GETCID'; +SYS_XMLNODEID_GETLOCATOR: 'SYS_XMLNODEID_GETLOCATOR'; +SYS_XMLNODEID_GETOKEY: 'SYS_XMLNODEID_GETOKEY'; +SYS_XMLNODEID_GETPATHID: 'SYS_XMLNODEID_GETPATHID'; +SYS_XMLNODEID_GETPTRID: 'SYS_XMLNODEID_GETPTRID'; +SYS_XMLNODEID_GETRID: 'SYS_XMLNODEID_GETRID'; +SYS_XMLNODEID_GETSVAL: 'SYS_XMLNODEID_GETSVAL'; +SYS_XMLNODEID_GETTID: 'SYS_XMLNODEID_GETTID'; +SYS_XMLNODEID: 'SYS_XMLNODEID'; +SYS_XMLT_2_SC: 'SYS_XMLT_2_SC'; +SYS_XMLTRANSLATE: 'SYS_XMLTRANSLATE'; +SYS_XMLTYPE2SQL: 'SYS_XMLTYPE2SQL'; +SYS_XQ_ASQLCNV: 'SYS_XQ_ASQLCNV'; +SYS_XQ_ATOMCNVCHK: 'SYS_XQ_ATOMCNVCHK'; +SYS_XQBASEURI: 'SYS_XQBASEURI'; +SYS_XQCASTABLEERRH: 'SYS_XQCASTABLEERRH'; +SYS_XQCODEP2STR: 'SYS_XQCODEP2STR'; +SYS_XQCODEPEQ: 'SYS_XQCODEPEQ'; +SYS_XQCON2SEQ: 'SYS_XQCON2SEQ'; +SYS_XQCONCAT: 'SYS_XQCONCAT'; +SYS_XQDELETE: 'SYS_XQDELETE'; +SYS_XQDFLTCOLATION: 'SYS_XQDFLTCOLATION'; +SYS_XQDOC: 'SYS_XQDOC'; +SYS_XQDOCURI: 'SYS_XQDOCURI'; +SYS_XQDURDIV: 'SYS_XQDURDIV'; +SYS_XQED4URI: 'SYS_XQED4URI'; +SYS_XQENDSWITH: 'SYS_XQENDSWITH'; +SYS_XQERRH: 'SYS_XQERRH'; +SYS_XQERR: 'SYS_XQERR'; +SYS_XQESHTMLURI: 'SYS_XQESHTMLURI'; +SYS_XQEXLOBVAL: 'SYS_XQEXLOBVAL'; +SYS_XQEXSTWRP: 'SYS_XQEXSTWRP'; +SYS_XQEXTRACT: 'SYS_XQEXTRACT'; +SYS_XQEXTRREF: 'SYS_XQEXTRREF'; +SYS_XQEXVAL: 'SYS_XQEXVAL'; +SYS_XQFB2STR: 'SYS_XQFB2STR'; +SYS_XQFNBOOL: 'SYS_XQFNBOOL'; +SYS_XQFNCMP: 'SYS_XQFNCMP'; +SYS_XQFNDATIM: 'SYS_XQFNDATIM'; +SYS_XQFNLNAME: 'SYS_XQFNLNAME'; +SYS_XQFNNM: 'SYS_XQFNNM'; +SYS_XQFNNSURI: 'SYS_XQFNNSURI'; +SYS_XQFNPREDTRUTH: 'SYS_XQFNPREDTRUTH'; +SYS_XQFNQNM: 'SYS_XQFNQNM'; +SYS_XQFNROOT: 'SYS_XQFNROOT'; +SYS_XQFORMATNUM: 'SYS_XQFORMATNUM'; +SYS_XQFTCONTAIN: 'SYS_XQFTCONTAIN'; +SYS_XQFUNCR: 'SYS_XQFUNCR'; +SYS_XQGETCONTENT: 'SYS_XQGETCONTENT'; +SYS_XQINDXOF: 'SYS_XQINDXOF'; +SYS_XQINSERT: 'SYS_XQINSERT'; +SYS_XQINSPFX: 'SYS_XQINSPFX'; +SYS_XQIRI2URI: 'SYS_XQIRI2URI'; +SYS_XQLANG: 'SYS_XQLANG'; +SYS_XQLLNMFRMQNM: 'SYS_XQLLNMFRMQNM'; +SYS_XQMKNODEREF: 'SYS_XQMKNODEREF'; +SYS_XQNILLED: 'SYS_XQNILLED'; +SYS_XQNODENAME: 'SYS_XQNODENAME'; +SYS_XQNORMSPACE: 'SYS_XQNORMSPACE'; +SYS_XQNORMUCODE: 'SYS_XQNORMUCODE'; +SYS_XQ_NRNG: 'SYS_XQ_NRNG'; +SYS_XQNSP4PFX: 'SYS_XQNSP4PFX'; +SYS_XQNSPFRMQNM: 'SYS_XQNSPFRMQNM'; +SYS_XQPFXFRMQNM: 'SYS_XQPFXFRMQNM'; +SYS_XQ_PKSQL2XML: 'SYS_XQ_PKSQL2XML'; +SYS_XQPOLYABS: 'SYS_XQPOLYABS'; +SYS_XQPOLYADD: 'SYS_XQPOLYADD'; +SYS_XQPOLYCEL: 'SYS_XQPOLYCEL'; +SYS_XQPOLYCSTBL: 'SYS_XQPOLYCSTBL'; +SYS_XQPOLYCST: 'SYS_XQPOLYCST'; +SYS_XQPOLYDIV: 'SYS_XQPOLYDIV'; +SYS_XQPOLYFLR: 'SYS_XQPOLYFLR'; +SYS_XQPOLYMOD: 'SYS_XQPOLYMOD'; +SYS_XQPOLYMUL: 'SYS_XQPOLYMUL'; +SYS_XQPOLYRND: 'SYS_XQPOLYRND'; +SYS_XQPOLYSQRT: 'SYS_XQPOLYSQRT'; +SYS_XQPOLYSUB: 'SYS_XQPOLYSUB'; +SYS_XQPOLYUMUS: 'SYS_XQPOLYUMUS'; +SYS_XQPOLYUPLS: 'SYS_XQPOLYUPLS'; +SYS_XQPOLYVEQ: 'SYS_XQPOLYVEQ'; +SYS_XQPOLYVGE: 'SYS_XQPOLYVGE'; +SYS_XQPOLYVGT: 'SYS_XQPOLYVGT'; +SYS_XQPOLYVLE: 'SYS_XQPOLYVLE'; +SYS_XQPOLYVLT: 'SYS_XQPOLYVLT'; +SYS_XQPOLYVNE: 'SYS_XQPOLYVNE'; +SYS_XQREF2VAL: 'SYS_XQREF2VAL'; +SYS_XQRENAME: 'SYS_XQRENAME'; +SYS_XQREPLACE: 'SYS_XQREPLACE'; +SYS_XQRESVURI: 'SYS_XQRESVURI'; +SYS_XQRNDHALF2EVN: 'SYS_XQRNDHALF2EVN'; +SYS_XQRSLVQNM: 'SYS_XQRSLVQNM'; +SYS_XQRYENVPGET: 'SYS_XQRYENVPGET'; +SYS_XQRYVARGET: 'SYS_XQRYVARGET'; +SYS_XQRYWRP: 'SYS_XQRYWRP'; +SYS_XQSEQ2CON4XC: 'SYS_XQSEQ2CON4XC'; +SYS_XQSEQ2CON: 'SYS_XQSEQ2CON'; +SYS_XQSEQDEEPEQ: 'SYS_XQSEQDEEPEQ'; +SYS_XQSEQINSB: 'SYS_XQSEQINSB'; +SYS_XQSEQRM: 'SYS_XQSEQRM'; +SYS_XQSEQRVS: 'SYS_XQSEQRVS'; +SYS_XQSEQSUB: 'SYS_XQSEQSUB'; +SYS_XQSEQTYPMATCH: 'SYS_XQSEQTYPMATCH'; +SYS_XQSTARTSWITH: 'SYS_XQSTARTSWITH'; +SYS_XQSTATBURI: 'SYS_XQSTATBURI'; +SYS_XQSTR2CODEP: 'SYS_XQSTR2CODEP'; +SYS_XQSTRJOIN: 'SYS_XQSTRJOIN'; +SYS_XQSUBSTRAFT: 'SYS_XQSUBSTRAFT'; +SYS_XQSUBSTRBEF: 'SYS_XQSUBSTRBEF'; +SYS_XQTOKENIZE: 'SYS_XQTOKENIZE'; +SYS_XQTREATAS: 'SYS_XQTREATAS'; +SYS_XQ_UPKXML2SQL: 'SYS_XQ_UPKXML2SQL'; +SYS_XQXFORM: 'SYS_XQXFORM'; +SYS_XSID_TO_RAW: 'SYS_XSID_TO_RAW'; +SYS_ZMAP_FILTER: 'SYS_ZMAP_FILTER'; +SYS_ZMAP_REFRESH: 'SYS_ZMAP_REFRESH'; +T_LETTER: 'T'; +TABLE_LOOKUP_BY_NL: 'TABLE_LOOKUP_BY_NL'; +TABLESPACE_NO: 'TABLESPACE_NO'; +TABLESPACE: 'TABLESPACE'; +TABLES: 'TABLES'; +TABLE_STATS: 'TABLE_STATS'; +TABLE: 'TABLE'; +TABNO: 'TABNO'; +TAG: 'TAG'; +TANH: 'TANH'; +TAN: 'TAN'; +TBLORIDXPARTNUM: 'TBL$OR$IDX$PART$NUM'; +TEMPFILE: 'TEMPFILE'; +TEMPLATE: 'TEMPLATE'; +TEMPORARY: 'TEMPORARY'; +TEMP_TABLE: 'TEMP_TABLE'; +TEST: 'TEST'; +TEXT: 'TEXT'; +THAN: 'THAN'; +THEN: 'THEN'; +THE: 'THE'; +THREAD: 'THREAD'; +THROUGH: 'THROUGH'; +TIER: 'TIER'; +TIES: 'TIES'; +TIMEOUT: 'TIMEOUT'; +TIMESTAMP_LTZ_UNCONSTRAINED: 'TIMESTAMP_LTZ_UNCONSTRAINED'; +TIMESTAMP: 'TIMESTAMP'; +TIMESTAMP_TZ_UNCONSTRAINED: 'TIMESTAMP_TZ_UNCONSTRAINED'; +TIMESTAMP_UNCONSTRAINED: 'TIMESTAMP_UNCONSTRAINED'; +TIMES: 'TIMES'; +TIME: 'TIME'; +TIMEZONE: 'TIMEZONE'; +TIMEZONE_ABBR: 'TIMEZONE_ABBR'; +TIMEZONE_HOUR: 'TIMEZONE_HOUR'; +TIMEZONE_MINUTE: 'TIMEZONE_MINUTE'; +TIMEZONE_OFFSET: 'TIMEZONE_OFFSET'; +TIMEZONE_REGION: 'TIMEZONE_REGION'; +TIME_ZONE: 'TIME_ZONE'; +TIMING: 'TIMING'; +TIV_GB: 'TIV_GB'; +TIV_SSF: 'TIV_SSF'; +TO_ACLID: 'TO_ACLID'; +TO_BINARY_DOUBLE: 'TO_BINARY_DOUBLE'; +TO_BINARY_FLOAT: 'TO_BINARY_FLOAT'; +TO_BLOB: 'TO_BLOB'; +TO_CLOB: 'TO_CLOB'; +TO_DSINTERVAL: 'TO_DSINTERVAL'; +TO_LOB: 'TO_LOB'; +TO_MULTI_BYTE: 'TO_MULTI_BYTE'; +TO_NCHAR: 'TO_NCHAR'; +TO_NCLOB: 'TO_NCLOB'; +TO_NUMBER: 'TO_NUMBER'; +TOPLEVEL: 'TOPLEVEL'; +TO_SINGLE_BYTE: 'TO_SINGLE_BYTE'; +TO_TIMESTAMP: 'TO_TIMESTAMP'; +TO_TIMESTAMP_TZ: 'TO_TIMESTAMP_TZ'; +TO_TIME: 'TO_TIME'; +TO_TIME_TZ: 'TO_TIME_TZ'; +TO: 'TO'; +TO_YMINTERVAL: 'TO_YMINTERVAL'; +TRACE: 'TRACE'; +TRACING: 'TRACING'; +TRACKING: 'TRACKING'; +TRAILING: 'TRAILING'; +TRANSACTION: 'TRANSACTION'; +TRANSFORM: 'TRANSFORM'; +TRANSFORM_DISTINCT_AGG: 'TRANSFORM_DISTINCT_AGG'; +TRANSITIONAL: 'TRANSITIONAL'; +TRANSITION: 'TRANSITION'; +TRANSLATE: 'TRANSLATE'; +TRANSLATION: 'TRANSLATION'; +TREAT: 'TREAT'; +TRIGGERS: 'TRIGGERS'; +TRIGGER: 'TRIGGER'; +TRUE: 'TRUE'; +TRUNCATE: 'TRUNCATE'; +TRUNC: 'TRUNC'; +TRUSTED: 'TRUSTED'; +TRUST: 'TRUST'; +TUNING: 'TUNING'; +TX: 'TX'; +TYPES: 'TYPES'; +TYPE: 'TYPE'; +TZ_OFFSET: 'TZ_OFFSET'; +UB2: 'UB2'; +UBA: 'UBA'; +UCS2: 'UCS2'; +UID: 'UID'; +UNARCHIVED: 'UNARCHIVED'; +UNBOUNDED: 'UNBOUNDED'; +UNBOUND: 'UNBOUND'; +UNCONDITIONAL: 'UNCONDITIONAL'; +UNDER: 'UNDER'; +UNDO: 'UNDO'; +UNDROP: 'UNDROP'; +UNIFORM: 'UNIFORM'; +UNION: 'UNION'; +UNIQUE: 'UNIQUE'; +UNISTR: 'UNISTR'; +UNLIMITED: 'UNLIMITED'; +UNLOAD: 'UNLOAD'; +UNLOCK: 'UNLOCK'; +UNMATCHED: 'UNMATCHED'; +UNNEST_INNERJ_DISTINCT_VIEW: 'UNNEST_INNERJ_DISTINCT_VIEW'; +UNNEST_NOSEMIJ_NODISTINCTVIEW: 'UNNEST_NOSEMIJ_NODISTINCTVIEW'; +UNNEST_SEMIJ_VIEW: 'UNNEST_SEMIJ_VIEW'; +UNNEST: 'UNNEST'; +UNPACKED: 'UNPACKED'; +UNPIVOT: 'UNPIVOT'; +UNPLUG: 'UNPLUG'; +UNPROTECTED: 'UNPROTECTED'; +UNQUIESCE: 'UNQUIESCE'; +UNRECOVERABLE: 'UNRECOVERABLE'; +UNRESTRICTED: 'UNRESTRICTED'; +UNSUBSCRIBE: 'UNSUBSCRIBE'; +UNTIL: 'UNTIL'; +UNUSABLE: 'UNUSABLE'; +UNUSED: 'UNUSED'; +UPDATABLE: 'UPDATABLE'; +UPDATED: 'UPDATED'; +UPDATE: 'UPDATE'; +UPDATEXML: 'UPDATEXML'; +UPD_INDEXES: 'UPD_INDEXES'; +UPD_JOININDEX: 'UPD_JOININDEX'; +UPGRADE: 'UPGRADE'; +UPPER: 'UPPER'; +UPSERT: 'UPSERT'; +UROWID: 'UROWID'; +USABLE: 'USABLE'; +USAGE: 'USAGE'; +USE_ANTI: 'USE_ANTI'; +USE_CONCAT: 'USE_CONCAT'; +USE_CUBE: 'USE_CUBE'; +USE_HASH_AGGREGATION: 'USE_HASH_AGGREGATION'; +USE_HASH_GBY_FOR_PUSHDOWN: 'USE_HASH_GBY_FOR_PUSHDOWN'; +USE_HASH: 'USE_HASH'; +USE_HIDDEN_PARTITIONS: 'USE_HIDDEN_PARTITIONS'; +USE_INVISIBLE_INDEXES: 'USE_INVISIBLE_INDEXES'; +USE_MERGE_CARTESIAN: 'USE_MERGE_CARTESIAN'; +USE_MERGE: 'USE_MERGE'; +USE_NL: 'USE_NL'; +USE_NL_WITH_INDEX: 'USE_NL_WITH_INDEX'; +USE_PRIVATE_OUTLINES: 'USE_PRIVATE_OUTLINES'; +USER_DATA: 'USER_DATA'; +USER_DEFINED: 'USER_DEFINED'; +USERENV: 'USERENV'; +USERGROUP: 'USERGROUP'; +USER_RECYCLEBIN: 'USER_RECYCLEBIN'; +USERS: 'USERS'; +USER_TABLESPACES: 'USER_TABLESPACES'; +USER: 'USER'; +USE_SEMI: 'USE_SEMI'; +USE_STORED_OUTLINES: 'USE_STORED_OUTLINES'; +USE_TTT_FOR_GSETS: 'USE_TTT_FOR_GSETS'; +USE: 'USE'; +USE_VECTOR_AGGREGATION: 'USE_VECTOR_AGGREGATION'; +USE_WEAK_NAME_RESL: 'USE_WEAK_NAME_RESL'; +USING_NO_EXPAND: 'USING_NO_EXPAND'; +USING: 'USING'; +UTF16BE: 'UTF16BE'; +UTF16LE: 'UTF16LE'; +UTF32: 'UTF32'; +UTF8: 'UTF8'; +V1: 'V1'; +V2: 'V2'; +VALIDATE: 'VALIDATE'; +VALIDATE_CONVERSION: 'VALIDATE_CONVERSION'; +VALIDATION: 'VALIDATION'; +VALID_TIME_END: 'VALID_TIME_END'; +VALUES: 'VALUES'; +VALUE: 'VALUE'; +VARCHAR2: 'VARCHAR2'; +VARCHAR: 'VARCHAR'; +VARIABLE: 'VARIABLE'; +VAR_POP: 'VAR_POP'; +VARRAYS: 'VARRAYS'; +VARRAY: 'VARRAY'; +VAR_SAMP: 'VAR_SAMP'; +VARYING: 'VARYING'; +VECTOR_READ_TRACE: 'VECTOR_READ_TRACE'; +VECTOR_READ: 'VECTOR_READ'; +VECTOR_TRANSFORM_DIMS: 'VECTOR_TRANSFORM_DIMS'; +VECTOR_TRANSFORM_FACT: 'VECTOR_TRANSFORM_FACT'; +VECTOR_TRANSFORM: 'VECTOR_TRANSFORM'; +VERIFIER: 'VERIFIER'; +VERIFY: 'VERIFY'; +VERSIONING: 'VERSIONING'; +VERSIONS_ENDSCN: 'VERSIONS_ENDSCN'; +VERSIONS_ENDTIME: 'VERSIONS_ENDTIME'; +VERSIONS_OPERATION: 'VERSIONS_OPERATION'; +VERSIONS_STARTSCN: 'VERSIONS_STARTSCN'; +VERSIONS_STARTTIME: 'VERSIONS_STARTTIME'; +VERSIONS: 'VERSIONS'; +VERSIONS_XID: 'VERSIONS_XID'; +VERSION: 'VERSION'; +VIEW: 'VIEW'; +VIOLATION: 'VIOLATION'; +VIRTUAL: 'VIRTUAL'; +VISIBILITY: 'VISIBILITY'; +VISIBLE: 'VISIBLE'; +VOLUME: 'VOLUME'; +VSIZE: 'VSIZE'; +WAIT: 'WAIT'; +WALLET: 'WALLET'; +WARNING: 'WARNING'; +WEEKS: 'WEEKS'; +WEEK: 'WEEK'; +WELLFORMED: 'WELLFORMED'; +WHENEVER: 'WHENEVER'; +WHEN: 'WHEN'; +WHERE: 'WHERE'; +WHILE: 'WHILE'; +WHITESPACE: 'WHITESPACE'; +WIDTH_BUCKET: 'WIDTH_BUCKET'; +WITHIN: 'WITHIN'; +WITHOUT: 'WITHOUT'; +WITH_PLSQL: 'WITH_PLSQL'; +WITH: 'WITH'; +WORK: 'WORK'; +WRAPPED: 'WRAPPED'; +WRAPPER: 'WRAPPER'; +WRITE: 'WRITE'; +XDB_FASTPATH_INSERT: 'XDB_FASTPATH_INSERT'; +XDB: 'XDB'; +X_DYN_PRUNE: 'X_DYN_PRUNE'; +XID: 'XID'; +XML2OBJECT: 'XML2OBJECT'; +XMLAGG: 'XMLAGG'; +XMLATTRIBUTES: 'XMLATTRIBUTES'; +XMLCAST: 'XMLCAST'; +XMLCDATA: 'XMLCDATA'; +XMLCOLATTVAL: 'XMLCOLATTVAL'; +XMLCOMMENT: 'XMLCOMMENT'; +XMLCONCAT: 'XMLCONCAT'; +XMLDIFF: 'XMLDIFF'; +XML_DML_RWT_STMT: 'XML_DML_RWT_STMT'; +XMLELEMENT: 'XMLELEMENT'; +XMLEXISTS2: 'XMLEXISTS2'; +XMLEXISTS: 'XMLEXISTS'; +XMLFOREST: 'XMLFOREST'; +XMLINDEX: 'XMLINDEX'; +XMLINDEX_REWRITE_IN_SELECT: 'XMLINDEX_REWRITE_IN_SELECT'; +XMLINDEX_REWRITE: 'XMLINDEX_REWRITE'; +XMLINDEX_SEL_IDX_TBL: 'XMLINDEX_SEL_IDX_TBL'; +XMLISNODE: 'XMLISNODE'; +XMLISVALID: 'XMLISVALID'; +XMLNAMESPACES: 'XMLNAMESPACES'; +XMLPARSE: 'XMLPARSE'; +XMLPATCH: 'XMLPATCH'; +XMLPI: 'XMLPI'; +XMLQUERYVAL: 'XMLQUERYVAL'; +XMLQUERY: 'XMLQUERY'; +XMLROOT: 'XMLROOT'; +XMLSCHEMA: 'XMLSCHEMA'; +XMLSERIALIZE: 'XMLSERIALIZE'; +XMLTABLE: 'XMLTABLE'; +XMLTRANSFORMBLOB: 'XMLTRANSFORMBLOB'; +XMLTRANSFORM: 'XMLTRANSFORM'; +XMLTYPE: 'XMLTYPE'; +XML: 'XML'; +XPATHTABLE: 'XPATHTABLE'; +XS_SYS_CONTEXT: 'XS_SYS_CONTEXT'; +XS: 'XS'; +// XTRANSPORT: 'XTRANSPORT'; +YEARS: 'YEARS'; +YEAR: 'YEAR'; +YES: 'YES'; +YMINTERVAL_UNCONSTRAINED: 'YMINTERVAL_UNCONSTRAINED'; +ZONEMAP: 'ZONEMAP'; +ZONE: 'ZONE'; +PREDICTION: 'PREDICTION'; +PREDICTION_BOUNDS: 'PREDICTION_BOUNDS'; +PREDICTION_COST: 'PREDICTION_COST'; +PREDICTION_DETAILS: 'PREDICTION_DETAILS'; +PREDICTION_PROBABILITY: 'PREDICTION_PROBABILITY'; +PREDICTION_SET: 'PREDICTION_SET'; + +BLOCKCHAIN: 'BLOCKCHAIN'; +COLLATE: 'COLLATE'; +COLLATION: 'COLLATION'; +DEFINITION: 'DEFINITION'; +DUPLICATED: 'DUPLICATED'; +EXTENDED: 'EXTENDED'; +HASHING: 'HASHING'; +IDLE: 'IDLE'; +IMMUTABLE: 'IMMUTABLE'; +ORACLE_DATAPUMP: 'ORACLE_DATAPUMP'; +ORACLE_HDFS: 'ORACLE_HDFS'; +ORACLE_HIVE: 'ORACLE_HIVE'; +ORACLE_LOADER: 'ORACLE_LOADER'; +SHA2_512_Q: '"SHA2_512"'; +SHARDED: 'SHARDED'; +V1_Q: '"V1"'; + +ISOLATE: 'ISOLATE'; +ROOT: 'ROOT'; +UNITE: 'UNITE'; +ALGORITHM: 'ALGORITHM'; + +CUME_DIST: 'CUME_DIST'; +DENSE_RANK: 'DENSE_RANK'; +LISTAGG: 'LISTAGG'; +PERCENT_RANK: 'PERCENT_RANK'; +PERCENTILE_CONT: 'PERCENTILE_CONT'; +PERCENTILE_DISC: 'PERCENTILE_DISC'; +RANK: 'RANK'; + +AVG: 'AVG'; +CORR: 'CORR'; +COVAR_: 'COVAR_'; +DECODE: 'DECODE'; +LAG: 'LAG'; +LAG_DIFF: 'LAG_DIFF'; +LAG_DIFF_PERCENT: 'LAG_DIFF_PERCENT'; +LEAD: 'LEAD'; +MAX: 'MAX'; +MEDIAN: 'MEDIAN'; +MEMOPTIMIZE: 'MEMOPTIMIZE'; +MIN: 'MIN'; +NTILE: 'NTILE'; +NVL: 'NVL'; +RATIO_TO_REPORT: 'RATIO_TO_REPORT'; +REGR_: 'REGR_'; +ROUND: 'ROUND'; +ROW_NUMBER: 'ROW_NUMBER'; +SUBSTR: 'SUBSTR'; +TO_CHAR: 'TO_CHAR'; +TRIM: 'TRIM'; +SUM: 'SUM'; +STDDEV: 'STDDEV'; +VAR_: 'VAR_'; +VARIANCE: 'VARIANCE'; +LEAST: 'LEAST'; +GREATEST: 'GREATEST'; +TO_DATE: 'TO_DATE'; +DEFAULTIF: 'DEFAULTIF'; +LLS: 'LLS'; +ENCLOSED: 'ENCLOSED'; +TERMINATED: 'TERMINATED'; +OPTIONALLY: 'OPTIONALLY'; +LRTRIM: 'LRTRIM'; +NOTRIM: 'NOTRIM'; +LDRTRIM: 'LDRTRIM'; +DATE_FORMAT: 'DATE_FORMAT'; +MASK: 'MASK'; +TRANSFORMS: 'TRANSFORMS'; +LOBFILE: 'LOBFILE'; +STARTOF: 'STARTOF'; +CHARACTERSET: 'CHARACTERSET'; +RECORDS: 'RECORDS'; +FIXED: 'FIXED'; +DELIMITED: 'DELIMITED'; +XMLTAG: 'XMLTAG'; +PREPROCESSOR: 'PREPROCESSOR'; +TERRITORY: 'TERRITORY'; +LITTLE: 'LITTLE'; +BIG: 'BIG'; +ENDIAN: 'ENDIAN'; +BYTEORDERMARK: 'BYTEORDERMARK'; +NOCHECK: 'NOCHECK'; +SIZES: 'SIZES'; +ARE: 'ARE'; +BYTES: 'BYTES'; +CHARACTERS: 'CHARACTERS'; +READSIZE: 'READSIZE'; +DISABLE_DIRECTORY_LINK_CHECK: 'DISABLE_DIRECTORY_LINK_CHECK'; +DATE_CACHE: 'DATE_CACHE'; +FIELD_NAMES: 'FIELD_NAMES'; +FILES: 'FILES'; +IO_OPTIONS: 'IO_OPTIONS'; +DIRECTIO: 'DIRECTIO'; +NODIRECTIO: 'NODIRECTIO'; +DNFS_ENABLE: 'DNFS_ENABLE'; +DNFS_DISABLE: 'DNFS_DISABLE'; +DNFS_READBUFFERS: 'DNFS_READBUFFERS'; +NOBADFILE: 'NOBADFILE'; +BADFILE: 'BADFILE'; +NODISCARDFILE: 'NODISCARDFILE'; +DISCARDFILE: 'DISCARDFILE'; +NOLOGFILE: 'NOLOGFILE'; +FIELDS: 'FIELDS'; +IGNORE_CHARS_AFTER_EOR: 'IGNORE_CHARS_AFTER_EOR'; +CSV: 'CSV'; +EMBEDDED: 'EMBEDDED'; +OVERRIDE: 'OVERRIDE'; +THESE: 'THESE'; +FIELD: 'FIELD'; +NONULLIF: 'NONULLIF'; +POSITION: 'POSITION'; +NEWLINE_: 'NEWLINE'; +DETECTED: 'DETECTED'; +UNSIGNED: 'UNSIGNED'; +ZONED: 'ZONED'; +ORACLE_DATE: 'ORACLE_DATE'; +ORACLE_NUMBER: 'ORACLE_NUMBER'; +COUNTED: 'COUNTED'; +VARRAW: 'VARRAW'; +VARCHARC: 'VARCHARC'; +VARRAWC: 'VARRAWC'; + +// Rule #358 - subtoken typecast in , it also incorporates +// Lowercase 'n' is a usual addition to the standard + +NATIONAL_CHAR_STRING_LIT: 'N' '\'' (~('\'' | '\r' | '\n' ) | '\'' '\'' | NEWLINE)* '\''; + +// Rule #040 - subtoken typecast in +// Lowercase 'b' is a usual addition to the standard + +BIT_STRING_LIT: 'B' ('\'' [01]* '\'')+; + +// Rule #284 - subtoken typecast in +// Lowercase 'x' is a usual addition to the standard + +HEX_STRING_LIT: 'X' ('\'' [A-F0-9]* '\'')+; +DOUBLE_PERIOD: '..'; +PERIOD: '.'; + +//{ Rule #238 +// This rule is a bit tricky - it resolves the ambiguity with +// It also incorporates and for the +// Rule #501 was incorporated directly in the token +// See also the rule #617 +/* + : ( + UNSIGNED_INTEGER + ( '.' UNSIGNED_INTEGER + | {$type = UNSIGNED_INTEGER;} + ) ( E ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )? + | '.' UNSIGNED_INTEGER ( E ('+' | '-')? UNSIGNED_INTEGER {$type = APPROXIMATE_NUM_LIT;} )? + ) + (D | F)? + ;*/ + +UNSIGNED_INTEGER: [0-9]+; +APPROXIMATE_NUM_LIT: FLOAT_FRAGMENT ('E' ('+'|'-')? (FLOAT_FRAGMENT | [0-9]+))? ('D' | 'F')?; + + +// Rule #--- is a base for Rule #065 , it incorporates +// and a superfluous subtoken typecasting of the "QUOTE" +CHAR_STRING: '\'' (~('\'' | '\r' | '\n') | '\'' '\'' | NEWLINE)* '\''; + +// See https://livesql.oracle.com/apex/livesql/file/content_CIREYU9EA54EOKQ7LAMZKRF6P.html +// TODO: context sensitive string quotes (any characted after quote) +CHAR_STRING_PERL : 'Q' '\'' ( + QS_ANGLE + | QS_BRACE + | QS_BRACK + | QS_PAREN + | QS_EXCLAM + | QS_SHARP + | QS_QUOTE + | QS_DQUOTE + | QS_BACKSLASH + | QS_AMPERSAND + | QS_ATSIGN + | QS_BACKTICK + | QS_CARET + | QS_COLON + | QS_COMMA + | QS_ASTERISK + | QS_DOLLAR + | QS_EQUAL + | QS_MINUS + | QS_PERCENT + | QS_PLUS + | QS_PERIOD + | QS_SEMICOLON + | QS_SLASH + | QS_UNDERSCORE + | QS_PIPE + | QS_TILDE + | QS_QUESTION + ) '\'' -> type(CHAR_STRING); +fragment QS_ANGLE : '<' .*? '>'; +fragment QS_BRACE : '{' .*? '}'; +fragment QS_BRACK : '[' .*? ']'; +fragment QS_PAREN : '(' .*? ')'; +fragment QS_EXCLAM : '!' .*? '!'; +fragment QS_SHARP : '#' .*? '#'; +fragment QS_QUOTE : '\'' .*? '\''; +fragment QS_DQUOTE : '"' .*? '"'; +fragment QS_BACKSLASH : '\\' .*? '\\'; +fragment QS_AMPERSAND : '&' .*? '&'; +fragment QS_ATSIGN : '@' .*? '@'; +fragment QS_BACKTICK : '`' .*? '`'; +fragment QS_CARET : '^' .*? '^'; +fragment QS_COLON : ':' .*? ':'; +fragment QS_COMMA : ',' .*? ','; +fragment QS_ASTERISK : '*' .*? '*'; +fragment QS_DOLLAR : '$' .*? '$'; +fragment QS_EQUAL : '=' .*? '='; +fragment QS_MINUS : '-' .*? '-'; +fragment QS_PERCENT : '%' .*? '%'; +fragment QS_PLUS : '+' .*? '+'; +fragment QS_PERIOD : '.' .*? '.'; +fragment QS_SEMICOLON : ';' .*? ';'; +fragment QS_SLASH : '/' .*? '/'; +fragment QS_UNDERSCORE : '_' .*? '_'; +fragment QS_PIPE : '|' .*? '|'; +fragment QS_TILDE : '~' .*? '~'; +fragment QS_QUESTION : '?' .*? '?'; + +DELIMITED_ID: '"' (~('"' | '\r' | '\n') | '"' '"')+ '"' ; + +PERCENT: '%'; +AMPERSAND: '&'; +LEFT_PAREN: '('; +RIGHT_PAREN: ')'; +DOUBLE_ASTERISK: '**'; +ASTERISK: '*'; +PLUS_SIGN: '+'; +MINUS_SIGN: '-'; +COMMA: ','; +SOLIDUS: '/'; +AT_SIGN: '@'; +ASSIGN_OP: ':='; +HASH_OP: '#'; + +SQ: '\''; + +BINDVAR + : ':' SIMPLE_LETTER (SIMPLE_LETTER | [0-9] | '_')* + | ':' DELIMITED_ID // not used in SQL but spotted in v$sqltext when using cursor_sharing + | ':' UNSIGNED_INTEGER + | QUESTION_MARK // not in SQL, not in Oracle, not in OCI, use this for JDBC + ; + +NOT_EQUAL_OP: '!=' + | '<>' + | '^=' + | '~=' + ; +CARRET_OPERATOR_PART: '^'; +TILDE_OPERATOR_PART: '~'; +EXCLAMATION_OPERATOR_PART: '!'; +GREATER_THAN_OP: '>'; +LESS_THAN_OP: '<'; +COLON: ':'; +SEMICOLON: ';'; + +BAR: '|'; +EQUALS_OP: '='; + +LEFT_BRACKET: '['; +RIGHT_BRACKET: ']'; + +INTRODUCER: '_'; + +// Comments https://docs.oracle.com/cd/E11882_01/server.112/e41084/sql_elements006.htm + +SINGLE_LINE_COMMENT: '--' ~('\r' | '\n')* NEWLINE_EOF -> channel(HIDDEN); +MULTI_LINE_COMMENT: '/*' .*? '*/' -> channel(HIDDEN); +// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve034.htm#SQPUG054 +REMARK_COMMENT: 'REM' {p.IsNewlineAtPos(-4)}? 'ARK'? (' ' ~('\r' | '\n')*)? NEWLINE_EOF -> channel(HIDDEN); + +// https://docs.oracle.com/cd/E11882_01/server.112/e16604/ch_twelve032.htm#SQPUG052 +PROMPT_MESSAGE: 'PRO' {p.IsNewlineAtPos(-4)}? 'MPT'? (' ' ~('\r' | '\n')*)? NEWLINE_EOF; + +// TODO: should starts with newline +START_CMD + //: 'STA' 'RT'? SPACE ~('\r' | '\n')* NEWLINE_EOF + // https://docs.oracle.com/cd/B19306_01/server.102/b14357/ch12002.htm + // https://docs.oracle.com/cd/B19306_01/server.102/b14357/ch12003.htm + : '@' {p.IsNewlineAtPos(-2)}? '@'? ~('\r' | '\n')* NEWLINE_EOF + ; + +REGULAR_ID: (SIMPLE_LETTER | FULL_WIDTH_LETTER) (SIMPLE_LETTER | FULL_WIDTH_LETTER | '$' | '_' | '#' | [0-9])*; + +SPACES: [ \t\r\n] -> channel(HIDDEN); + +// Fragment rules + +fragment NEWLINE_EOF : NEWLINE | EOF; +fragment QUESTION_MARK : '?'; +fragment SIMPLE_LETTER : [A-Z]; +fragment FLOAT_FRAGMENT : UNSIGNED_INTEGER* '.'? UNSIGNED_INTEGER+; +fragment NEWLINE : '\r'? '\n'; +fragment SPACE : [ \t]; + +fragment FULL_WIDTH_LETTER 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/plsql/PlSqlParser.g4 b/plsql/PlSqlParser.g4 new file mode 100644 index 0000000..1996acd --- /dev/null +++ b/plsql/PlSqlParser.g4 @@ -0,0 +1,9645 @@ + /** + * Oracle(c) PL/SQL 11g Parser + * + * Copyright (c) 2009-2011 Alexandre Porcelli + * Copyright (c) 2015-2019 Ivan Kochurkin (KvanTTT, kvanttt@gmail.com, Positive Technologies). + * Copyright (c) 2017-2018 Mark Adams + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +parser grammar PlSqlParser; + +options { + tokenVocab=PlSqlLexer; + superClass=PlSqlParserBase; +} + +@parser::postinclude { +#include +} + +sql_script + : ( + (sql_plus_command | unit_statement) SEMICOLON? + | SEMICOLON + )* EOF + ; + +unit_statement + : alter_analytic_view + | alter_attribute_dimension + | alter_audit_policy + | alter_cluster + | alter_database + | alter_database_link + | alter_dimension + | alter_diskgroup + | alter_flashback_archive + | alter_function + | alter_hierarchy + | alter_index + | alter_inmemory_join_group + | alter_java + | alter_library + | alter_lockdown_profile + | alter_materialized_view + | alter_materialized_view_log + | alter_materialized_zonemap + | alter_operator + | alter_outline + | alter_package + | alter_pmem_filestore + | alter_procedure + | alter_resource_cost + | alter_role + | alter_rollback_segment + | alter_sequence + | alter_session + | alter_synonym + | alter_table + | alter_tablespace + | alter_tablespace_set + | alter_trigger + | alter_type + | alter_user + | alter_view + + | create_analytic_view + | create_attribute_dimension + | create_audit_policy + | create_cluster + | create_context + | create_controlfile + | create_database + | create_database_link + | create_dimension + | create_directory + | create_diskgroup + | create_edition + | create_flashback_archive + | create_function_body + | create_hierarchy + | create_index + | create_inmemory_join_group + | create_java + | create_library + | create_lockdown_profile + | create_materialized_view + | create_materialized_view_log + | create_materialized_zonemap + | create_operator + | create_outline + | create_package + | create_package_body + | create_pmem_filestore + | create_procedure_body + | create_profile + | create_restore_point + | create_role + | create_rollback_segment + | create_sequence + | create_spfile + | create_synonym + | create_table + | create_tablespace + | create_tablespace_set + | create_trigger + | create_type + | create_user + | create_view + + | drop_analytic_view + | drop_attribute_dimension + | drop_audit_policy + | drop_cluster + | drop_context + | drop_database + | drop_database_link + | drop_directory + | drop_diskgroup + | drop_edition + | drop_flashback_archive + | drop_function + | drop_hierarchy + | drop_index + | drop_indextype + | drop_inmemory_join_group + | drop_java + | drop_library + | drop_lockdown_profile + | drop_materialized_view + | drop_materialized_zonemap + | drop_operator + | drop_outline + | drop_package + | drop_pmem_filestore + | drop_procedure + | drop_restore_point + | drop_role + | drop_rollback_segment + | drop_sequence + | drop_synonym + | drop_table + | drop_tablespace + | drop_tablespace_set + | drop_trigger + | drop_type + | drop_user + | drop_view + + | administer_key_management + | analyze + | anonymous_block + | associate_statistics + | audit_traditional + | comment_on_column + | comment_on_materialized + | comment_on_table + | data_manipulation_language_statements + | disassociate_statistics + | flashback_table + | grant_statement + | noaudit_statement + | purge_statement + | rename_object + | revoke_statement + | transaction_control_statements + | truncate_cluster + | truncate_table + | unified_auditing + | call_statement // put call statement after all statements. + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-DISKGROUP.html +alter_diskgroup + : ALTER DISKGROUP ( id_expression (((add_disk_clause | drop_disk_clause)+ | resize_disk_clause) rebalance_diskgroup_clause? + | ( replace_disk_clause + | rename_disk_clause + | disk_online_clause + | disk_offline_clause + | rebalance_diskgroup_clause + | check_diskgroup_clause + | diskgroup_template_clauses + | diskgroup_directory_clauses + | diskgroup_alias_clauses + | diskgroup_volume_clauses + | diskgroup_attributes + | drop_diskgroup_file_clause + | convert_redundancy_clause + | usergroup_clauses + | user_clauses + | file_permissions_clause + | file_owner_clause + | scrub_clause + | quotagroup_clauses + | filegroup_clauses + ) + ) + | (id_expression (',' id_expression)* | ALL) (undrop_disk_clause | diskgroup_availability | enable_disable_volume) + ) + ; + +add_disk_clause + : ADD ( (SITE sn=id_expression)? quorum_regular? (FAILGROUP fgn=id_expression)? DISK qualified_disk_clause (',' qualified_disk_clause)*)+ + ; + +drop_disk_clause + : DROP ( quorum_regular? DISK id_expression force_noforce? (',' id_expression force_noforce?)* + | DISKS IN quorum_regular? FAILGROUP id_expression force_noforce? (',' id_expression force_noforce?)* + ) + ; + +resize_disk_clause + : RESIZE ALL (SIZE size_clause)? + ; + +replace_disk_clause + : REPLACE DISK id_expression WITH CHAR_STRING force_noforce? (',' id_expression WITH CHAR_STRING force_noforce?)* + (POWER numeric)? + wait_nowait? + ; + +wait_nowait + : WAIT + | NOWAIT + ; + +rename_disk_clause + : RENAME ( DISK id_expression TO id_expression (',' id_expression TO id_expression)* + | DISKS ALL + ) + ; + +disk_online_clause + : ONLINE ( (quorum_regular? DISK id_expression (',' id_expression)* | DISKS IN quorum_regular? FAILGROUP id_expression (',' id_expression)*)+ + | ALL + ) + (POWER numeric)? + wait_nowait? + ; + +disk_offline_clause + : OFFLINE ( quorum_regular? DISK id_expression (',' id_expression)* + | DISKS IN quorum_regular? FAILGROUP id_expression (',' id_expression)* + ) timeout_clause? + ; + +timeout_clause + : DROP AFTER numeric (M_LETTER | H_LETTER) + ; + +rebalance_diskgroup_clause + : REBALANCE ( ((WITH | WITHOUT) phase+)? (POWER numeric) (WAIT | NOWAIT)? + | MODIFY POWER numeric? + ) + ; + +phase + : id_expression //TODO + ; + +check_diskgroup_clause + : CHECK ALL? (REPAIR | NOREPAIR)? //inconsistent documentation + ; + +diskgroup_template_clauses + : (ADD | MODIFY) TEMPLATE id_expression qualified_template_clause (',' id_expression qualified_template_clause)* + | DROP TEMPLATE id_expression (',' id_expression)* + ; + +qualified_template_clause + : ATTRIBUTES '(' redundancy_clause? striping_clause? ')' //inconsistent documentation + ; + +redundancy_clause + : MIRROR + | HIGH + | UNPROTECTED + | PARITY + | DOUBLE + ; + +striping_clause + : FINE + | COARSE + ; + +force_noforce + : FORCE + | NOFORCE + ; + +diskgroup_directory_clauses + : ADD DIRECTORY filename (',' filename)* + | DROP DIRECTORY filename force_noforce? (','filename force_noforce?)* + | RENAME DIRECTORY dir_name TO dir_name (',' dir_name TO dir_name)* + ; + +dir_name + : CHAR_STRING + ; + +diskgroup_alias_clauses + : ADD ALIAS CHAR_STRING FOR CHAR_STRING (',' CHAR_STRING FOR CHAR_STRING)* + | DROP ALIAS CHAR_STRING (',' CHAR_STRING)* + | RENAME ALIAS CHAR_STRING TO CHAR_STRING (',' CHAR_STRING TO CHAR_STRING)* + ; + +diskgroup_volume_clauses + : add_volume_clause + | modify_volume_clause + | RESIZE VOLUME id_expression SIZE size_clause + | DROP VOLUME id_expression + ; + +add_volume_clause + : ADD VOLUME id_expression SIZE size_clause redundancy_clause? + (STRIPE_WIDTH numeric (K_LETTER | M_LETTER))? + (STRIPE_COLUMNS numeric)? + ; + +modify_volume_clause + : MODIFY VOLUME id_expression (MOUNTPATH CHAR_STRING)? + (USAGE CHAR_STRING)? + ; + +diskgroup_attributes + : SET ATTRIBUTE CHAR_STRING '=' CHAR_STRING + ; + +modify_diskgroup_file + : MODIFY FILE CHAR_STRING ATTRIBUTE '(' disk_region_clause ')' (',' CHAR_STRING ATTRIBUTE '(' disk_region_clause ')')* + ; + +disk_region_clause + : + ; + +drop_diskgroup_file_clause + : DROP FILE filename (',' filename)* + ; + +convert_redundancy_clause + : CONVERT REDUNDANCY TO FLEX + ; + +usergroup_clauses + : ADD USERGROUP CHAR_STRING WITH MEMBER CHAR_STRING (',' CHAR_STRING)* + | MODIFY USERGROUP CHAR_STRING (ADD | DROP) MEMBER CHAR_STRING (',' CHAR_STRING)* + | DROP USERGROUP CHAR_STRING + ; + +user_clauses + : ADD USER CHAR_STRING (',' CHAR_STRING)* + | DROP USER CHAR_STRING (',' CHAR_STRING)* CASCADE? + | REPLACE USER CHAR_STRING WITH CHAR_STRING (',' CHAR_STRING WITH CHAR_STRING)* + ; + +file_permissions_clause + : SET PERMISSION (OWNER | GROUP | OTHER) '=' (NONE | READ (ONLY | WRITE)) (',' (OWNER | GROUP | OTHER) '=' (NONE | READ (ONLY | WRITE)))* + FOR FILE CHAR_STRING (',' CHAR_STRING)* + ; + +file_owner_clause + : SET OWNERSHIP (OWNER | GROUP) '=' CHAR_STRING (',' (OWNER | GROUP) '=' CHAR_STRING)* FOR FILE CHAR_STRING (',' CHAR_STRING)* + ; + +scrub_clause + : SCRUB (FILE CHAR_STRING | DISK id_expression)? + (REPAIR | NOREPAIR)? + (POWER (AUTO | LOW | HIGH | MAX))? + wait_nowait? + force_noforce? + STOP? + ; + +quotagroup_clauses + : ADD QUOTAGROUP id_expression (SET property_name '=' property_value)? + | MODIFY QUOTAGROUP id_expression SET property_name '=' property_value + | MOVE QUOTAGROUP id_expression TO id_expression + | DROP QUOTAGROUP id_expression + ; + +property_name + : id_expression + ; + +property_value + : id_expression + ; + +filegroup_clauses + : add_filegroup_clause + | modify_filegroup_clause + | move_to_filegroup_clause + | drop_filegroup_clause + ; + +add_filegroup_clause + : ADD FILEGROUP id_expression ((DATABASE | CLUSTER | VOLUME) id_expression | TEMPLATE) (FROM TEMPLATE id_expression)? + (SET CHAR_STRING '=' CHAR_STRING)? + ; + +modify_filegroup_clause + : MODIFY FILEGROUP id_expression + SET CHAR_STRING '=' CHAR_STRING + ; + +move_to_filegroup_clause + : MOVE FILE CHAR_STRING TO FILEGROUP id_expression + ; + +drop_filegroup_clause + : DROP FILEGROUP id_expression CASCADE? + ; + + +quorum_regular + : QUORUM + | REGULAR + ; + +undrop_disk_clause + : UNDROP DISKS + ; + +diskgroup_availability + : MOUNT (RESTRICTED | NORMAL)? (FORCE | NOFORCE)? + | DISMOUNT (FORCE | NOFORCE)? + ; + +enable_disable_volume + : (ENABLE | DISABLE) VOLUME ( id_expression (',' id_expression)* | ALL) + ; + +// DDL -> SQL Statements for Stored PL/SQL Units + +// Function DDLs + +drop_function + : DROP FUNCTION function_name ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-FLASHBACK-ARCHIVE.html +alter_flashback_archive + : ALTER FLASHBACK ARCHIVE fa=id_expression + ( SET DEFAULT + | (ADD | MODIFY) TABLESPACE ts=id_expression flashback_archive_quota? + | REMOVE TABLESPACE rts=id_expression + | MODIFY /*RETENTION*/ flashback_archive_retention // inconsistent documentation + | PURGE (ALL | BEFORE (SCN expression | TIMESTAMP expression)) + | NO? OPTIMIZE DATA + ) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-HIERARCHY.html +alter_hierarchy + : ALTER HIERARCHY (schema_name '.')? hn=id_expression (RENAME TO nhn=id_expression | COMPILE) + ; + +alter_function + : ALTER FUNCTION function_name COMPILE DEBUG? compiler_parameters_clause* (REUSE SETTINGS)? ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-JAVA.html +alter_java + : ALTER JAVA (SOURCE | CLASS) (schema_name '.')? o=id_expression + (RESOLVER '(' ('(' match_string ','? (schema_name | '-') ')')+ ')')? + (COMPILE | RESOLVE | invoker_rights_clause) + ; + +match_string + : DELIMITED_ID + | '*' + ; + +create_function_body + : CREATE (OR REPLACE)? FUNCTION function_name ('(' parameter (',' parameter)* ')')? + RETURN type_spec (invoker_rights_clause | parallel_enable_clause | result_cache_clause | DETERMINISTIC)* + ((PIPELINED? (IS | AS) (DECLARE? seq_of_declare_specs? body | call_spec)) + | (PIPELINED | AGGREGATE) USING implementation_type_name + | sql_macro_body + ) ';' + ; + +sql_macro_body + : SQL_MACRO IS BEGIN RETURN quoted_string SEMICOLON END + ; + +// Creation Function - Specific Clauses + +parallel_enable_clause + : PARALLEL_ENABLE partition_by_clause? + ; + +partition_by_clause + : '(' PARTITION expression BY (ANY | (HASH | RANGE | LIST) paren_column_list) streaming_clause? ')' + ; + +result_cache_clause + : RESULT_CACHE relies_on_part? + ; + +relies_on_part + : RELIES_ON '(' tableview_name (',' tableview_name)* ')' + ; + +streaming_clause + : (ORDER | CLUSTER) expression BY paren_column_list + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-OUTLINE.html +alter_outline + : ALTER OUTLINE (PUBLIC | PRIVATE)? o=id_expression + outline_options+ + ; + +outline_options + : REBUILD + | RENAME TO non=id_expression + | CHANGE CATEGORY TO ncn=id_expression + | ENABLE + | DISABLE + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-LOCKDOWN-PROFILE.html +alter_lockdown_profile + : ALTER LOCKDOWN PROFILE id_expression (lockdown_feature | lockdown_options | lockdown_statements) + (USERS '=' (ALL | COMMON | LOCAL))? + ; + +lockdown_feature + : disable_enable FEATURE ( '=' '(' string_list ')' + | ALL (EXCEPT '=' '(' string_list ')')? + ) + ; + +lockdown_options + : disable_enable OPTION ( '=' '(' string_list ')' + | ALL (EXCEPT '=' '(' string_list ')')? + ) + ; + +lockdown_statements + : disable_enable STATEMENT ( '=' '(' string_list ')' + | '=' '(' CHAR_STRING ')' statement_clauses + | ALL (EXCEPT '=' '(' string_list ')')? + ) + ; + +statement_clauses + : CLAUSE ( '=' '(' string_list ')' + | '=' '(' CHAR_STRING ')' clause_options + | ALL (EXCEPT '=' '(' string_list ')')? + ) + ; + +clause_options + : OPTION ( '=' '(' string_list ')' + | '=' '(' CHAR_STRING ')' option_values+ + | ALL (EXCEPT '=' '(' string_list ')')? + ) + ; + +option_values + : VALUE '=' '(' string_list ')' + | (MINVALUE | MAXVALUE) '=' CHAR_STRING + ; + +string_list + : CHAR_STRING (',' CHAR_STRING)* + ; + +disable_enable + : DISABLE + | ENABLE + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-LOCKDOWN-PROFILE.html +drop_lockdown_profile + : DROP LOCKDOWN PROFILE p=id_expression + ; + +// Package DDLs + +drop_package + : DROP PACKAGE BODY? (schema_object_name '.')? package_name ';' + ; + +alter_package + : ALTER PACKAGE package_name COMPILE DEBUG? (PACKAGE | BODY | SPECIFICATION)? compiler_parameters_clause* (REUSE SETTINGS)? ';' + ; + +create_package + : CREATE (OR REPLACE)? PACKAGE (schema_object_name '.')? package_name invoker_rights_clause? (IS | AS) package_obj_spec* END package_name? ';' + ; + +create_package_body + : CREATE (OR REPLACE)? PACKAGE BODY (schema_object_name '.')? package_name (IS | AS) package_obj_body* (BEGIN seq_of_statements)? END package_name? ';' + ; + +// Create Package Specific Clauses + +package_obj_spec + : pragma_declaration + | exception_declaration + | variable_declaration + | subtype_declaration + | cursor_declaration + | type_declaration + | procedure_spec + | function_spec + ; + +procedure_spec + : PROCEDURE identifier ('(' parameter ( ',' parameter )* ')')? ';' + ; + +function_spec + : FUNCTION identifier ('(' parameter ( ',' parameter)* ')')? + RETURN type_spec PIPELINED? DETERMINISTIC? (RESULT_CACHE)? ';' + ; + +package_obj_body + : exception_declaration + | subtype_declaration + | cursor_declaration + | variable_declaration + | type_declaration + | procedure_body + | function_body + | procedure_spec + | function_spec + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/alter-pmem-filestore.html +alter_pmem_filestore + : ALTER PMEM FILESTORE fsn=id_expression + ( RESIZE size_clause + | autoextend_clause + | MOUNT (MOUNTPOINT file_path)? (BACKINGFILE filename)? FORCE? //inconsistent documentation + | DISMOUNT + ) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/drop-pmem-filestore.html +drop_pmem_filestore + : DROP PMEM FILESTORE fsn=id_expression + ((FORCE? INCLUDING | EXCLUDING) CONTENTS)? + ; + +// Procedure DDLs + +drop_procedure + : DROP PROCEDURE procedure_name ';' + ; + +alter_procedure + : ALTER PROCEDURE procedure_name COMPILE DEBUG? compiler_parameters_clause* (REUSE SETTINGS)? ';' + ; + +function_body + : FUNCTION identifier ('(' parameter (',' parameter)* ')')? + RETURN type_spec (invoker_rights_clause | parallel_enable_clause | result_cache_clause | DETERMINISTIC)* + ((PIPELINED? DETERMINISTIC? (IS | AS) (DECLARE? seq_of_declare_specs? body | call_spec)) | (PIPELINED | AGGREGATE) USING implementation_type_name) ';' + ; + +procedure_body + : PROCEDURE identifier ('(' parameter (',' parameter)* ')')? (IS | AS) + (DECLARE? seq_of_declare_specs? body | call_spec | EXTERNAL) ';' + ; + +create_procedure_body + : CREATE (OR REPLACE)? PROCEDURE procedure_name ('(' parameter (',' parameter)* ')')? + invoker_rights_clause? (IS | AS) + (DECLARE? seq_of_declare_specs? body | call_spec | EXTERNAL) ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-RESOURCE-COST.html +alter_resource_cost + : ALTER RESOURCE COST ((CPU_PER_SESSION | CONNECT_TIME | LOGICAL_READS_PER_SESSION | PRIVATE_SGA) UNSIGNED_INTEGER)+ + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-OUTLINE.html +drop_outline + : DROP OUTLINE o=id_expression + ; + +// Rollback Segment DDLs + +//https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_2011.htm#SQLRF00816 +alter_rollback_segment + : ALTER ROLLBACK SEGMENT rollback_segment_name (ONLINE | OFFLINE | storage_clause | SHRINK (TO size_clause)?) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-RESTORE-POINT.html +drop_restore_point + : DROP RESTORE POINT rp=id_expression (FOR PLUGGABLE DATABASE pdb=id_expression)? + ; + +drop_rollback_segment + : DROP ROLLBACK SEGMENT rollback_segment_name + ; + +drop_role + : DROP ROLE role_name ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/create-pmem-filestore.html +create_pmem_filestore + : CREATE PMEM FILESTORE fsn=id_expression + pmem_filestore_options+ + ; + +pmem_filestore_options + : MOUNTPOINT file_path + | BACKINGFILE filename REUSE? + | (SIZE | BLOCKSIZE) size_clause + | autoextend_clause + ; + +file_path + : CHAR_STRING + ; + +create_rollback_segment + : CREATE PUBLIC? ROLLBACK SEGMENT rollback_segment_name (TABLESPACE tablespace | storage_clause)* + ; + +// Trigger DDLs + +drop_trigger + : DROP TRIGGER trigger_name ';' + ; + +alter_trigger + : ALTER TRIGGER alter_trigger_name=trigger_name + ((ENABLE | DISABLE) | RENAME TO rename_trigger_name=trigger_name | COMPILE DEBUG? compiler_parameters_clause* (REUSE SETTINGS)?) ';' + ; + +create_trigger + : CREATE ( OR REPLACE )? TRIGGER trigger_name + (simple_dml_trigger | compound_dml_trigger | non_dml_trigger) + trigger_follows_clause? (ENABLE | DISABLE)? trigger_when_clause? trigger_body ';' + ; + +trigger_follows_clause + : FOLLOWS trigger_name (',' trigger_name)* + ; + +trigger_when_clause + : WHEN '(' condition ')' + ; + +// Create Trigger Specific Clauses + +simple_dml_trigger + : (BEFORE | AFTER | INSTEAD OF) dml_event_clause referencing_clause? for_each_row? + ; + +for_each_row + : FOR EACH ROW + ; + +compound_dml_trigger + : FOR dml_event_clause referencing_clause? + ; + +non_dml_trigger + : (BEFORE | AFTER) non_dml_event (OR non_dml_event)* ON (DATABASE | (schema_name '.')? SCHEMA) + ; + +trigger_body + : COMPOUND TRIGGER + | CALL identifier + | trigger_block + ; + +routine_clause + : routine_name function_argument? + ; + +compound_trigger_block + : COMPOUND TRIGGER seq_of_declare_specs? timing_point_section+ END trigger_name + ; + +timing_point_section + : bk=BEFORE STATEMENT IS trigger_block BEFORE STATEMENT ';' + | bk=BEFORE EACH ROW IS trigger_block BEFORE EACH ROW ';' + | ak=AFTER STATEMENT IS trigger_block AFTER STATEMENT ';' + | ak=AFTER EACH ROW IS trigger_block AFTER EACH ROW ';' + ; + +non_dml_event + : ALTER + | ANALYZE + | ASSOCIATE STATISTICS + | AUDIT + | COMMENT + | CREATE + | DISASSOCIATE STATISTICS + | DROP + | GRANT + | NOAUDIT + | RENAME + | REVOKE + | TRUNCATE + | DDL + | STARTUP + | SHUTDOWN + | DB_ROLE_CHANGE + | LOGON + | LOGOFF + | SERVERERROR + | SUSPEND + | DATABASE + | SCHEMA + | FOLLOWS + ; + +dml_event_clause + : dml_event_element (OR dml_event_element)* ON dml_event_nested_clause? tableview_name + ; + +dml_event_element + : (DELETE | INSERT | UPDATE) (OF column_list)? + ; + +dml_event_nested_clause + : NESTED TABLE tableview_name OF + ; + +referencing_clause + : REFERENCING referencing_element+ + ; + +referencing_element + : (NEW | OLD | PARENT) column_alias + ; + +// DDLs + +drop_type + : DROP TYPE BODY? type_name (FORCE | VALIDATE)? ';' + ; + +alter_type + : ALTER TYPE type_name + (compile_type_clause + | replace_type_clause + //TODO | {input.LT(2).getText().equalsIgnoreCase("attribute")}? alter_attribute_definition + | alter_method_spec + | alter_collection_clauses + | modifier_clause + | overriding_subprogram_spec + ) dependent_handling_clause? ';' + ; + +// Alter Type Specific Clauses + +compile_type_clause + : COMPILE DEBUG? (SPECIFICATION | BODY)? compiler_parameters_clause* (REUSE SETTINGS)? + ; + +replace_type_clause + : REPLACE invoker_rights_clause? AS OBJECT '(' object_member_spec (',' object_member_spec)* ')' + ; + +alter_method_spec + : alter_method_element (',' alter_method_element)* + ; + +alter_method_element + : (ADD | DROP) (map_order_function_spec | subprogram_spec) + ; + +alter_attribute_definition + : (ADD | MODIFY | DROP) ATTRIBUTE (attribute_definition | '(' attribute_definition (',' attribute_definition)* ')') + ; + +attribute_definition + : attribute_name type_spec? + ; + +alter_collection_clauses + : MODIFY (LIMIT expression | ELEMENT TYPE type_spec) + ; + +dependent_handling_clause + : INVALIDATE + | CASCADE (CONVERT TO SUBSTITUTABLE | NOT? INCLUDING TABLE DATA)? dependent_exceptions_part? + ; + +dependent_exceptions_part + : FORCE? EXCEPTIONS INTO tableview_name + ; + +create_type + : CREATE (OR REPLACE)? TYPE (type_definition | type_body) ';' + ; + +// Create Type Specific Clauses + +type_definition + : type_name (OID CHAR_STRING)? FORCE? object_type_def? + ; + +object_type_def + : invoker_rights_clause? (object_as_part | object_under_part) sqlj_object_type? + ('(' object_member_spec (',' object_member_spec)* ')')? modifier_clause* + ; + +object_as_part + : (IS | AS) (OBJECT | varray_type_def | nested_table_type_def) + ; + +object_under_part + : UNDER type_spec + ; + +nested_table_type_def + : TABLE OF type_spec (NOT NULL_)? + ; + +sqlj_object_type + : EXTERNAL NAME expression LANGUAGE JAVA USING (SQLDATA | CUSTOMDATUM | ORADATA) + ; + +type_body + : BODY type_name (IS | AS) (type_body_elements)+ END + ; + +type_body_elements + : map_order_func_declaration + | subprog_decl_in_type + | overriding_subprogram_spec + ; + +map_order_func_declaration + : (MAP | ORDER) MEMBER func_decl_in_type + ; + +subprog_decl_in_type + : (MEMBER | STATIC) (proc_decl_in_type | func_decl_in_type | constructor_declaration) + ; + +proc_decl_in_type + : PROCEDURE procedure_name '(' type_elements_parameter (',' type_elements_parameter)* ')' + (IS | AS) (call_spec | DECLARE? seq_of_declare_specs? body ';') + ; + +func_decl_in_type + : FUNCTION function_name ('(' type_elements_parameter (',' type_elements_parameter)* ')')? + RETURN type_spec (IS | AS) (call_spec | DECLARE? seq_of_declare_specs? body ';') + ; + +constructor_declaration + : FINAL? INSTANTIABLE? CONSTRUCTOR FUNCTION type_spec + ('(' (SELF IN OUT type_spec ',') type_elements_parameter (',' type_elements_parameter)* ')')? + RETURN SELF AS RESULT (IS | AS) (call_spec | DECLARE? seq_of_declare_specs? body ';') + ; + +// Common Type Clauses + +modifier_clause + : NOT? (INSTANTIABLE | FINAL | OVERRIDING) + ; + +object_member_spec + : identifier type_spec sqlj_object_type_attr? + | element_spec + ; + +sqlj_object_type_attr + : EXTERNAL NAME expression + ; + +element_spec + : modifier_clause? element_spec_options+ (',' pragma_clause)? + ; + +element_spec_options + : subprogram_spec + | constructor_spec + | map_order_function_spec + ; + +subprogram_spec + : (MEMBER | STATIC) (type_procedure_spec | type_function_spec) + ; + +// TODO: should be refactored such as Procedure body and Function body, maybe Type_Function_Body and overriding_function_body +overriding_subprogram_spec + : OVERRIDING MEMBER overriding_function_spec + ; + +overriding_function_spec + : FUNCTION function_name ('(' type_elements_parameter (',' type_elements_parameter)* ')')? + RETURN (type_spec | SELF AS RESULT) + (PIPELINED? (IS | AS) (DECLARE? seq_of_declare_specs? body))? ';'? + ; + +type_procedure_spec + : PROCEDURE procedure_name '(' type_elements_parameter (',' type_elements_parameter)* ')' ((IS | AS) call_spec)? + ; + +type_function_spec + : FUNCTION function_name ('(' type_elements_parameter (',' type_elements_parameter)* ')')? + RETURN (type_spec | SELF AS RESULT) ((IS | AS) call_spec | EXTERNAL VARIABLE? NAME expression)? + ; + +constructor_spec + : FINAL? INSTANTIABLE? CONSTRUCTOR FUNCTION + type_spec ('(' (SELF IN OUT type_spec ',') type_elements_parameter (',' type_elements_parameter)* ')')? + RETURN SELF AS RESULT ((IS | AS) call_spec)? + ; + +map_order_function_spec + : (MAP | ORDER) MEMBER type_function_spec + ; + +pragma_clause + : PRAGMA RESTRICT_REFERENCES '(' pragma_elements (',' pragma_elements)* ')' + ; + +pragma_elements + : identifier + | DEFAULT + ; + +type_elements_parameter + : parameter_name type_spec + ; + +// Sequence DDLs + +drop_sequence + : DROP SEQUENCE sequence_name ';' + ; + +alter_sequence + : ALTER SEQUENCE sequence_name sequence_spec+ ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-SESSION.html +alter_session + : ALTER SESSION ( + ADVISE ( COMMIT | ROLLBACK | NOTHING ) + | CLOSE DATABASE LINK parameter_name + | enable_or_disable COMMIT IN PROCEDURE + | enable_or_disable GUARD + | (enable_or_disable | FORCE) PARALLEL (DML | DDL | QUERY) (PARALLEL (literal | parameter_name))? + | SET alter_session_set_clause + ) + ; + +alter_session_set_clause + : (parameter_name '=' parameter_value)+ + | EDITION '=' en=id_expression + | CONTAINER '=' cn=id_expression (SERVICE '=' sn=id_expression)? + | ROW ARCHIVAL VISIBILITY '=' (ACTIVE | ALL) + | DEFAULT_COLLATION '=' (c=id_expression | NONE) + ; + +create_sequence + : CREATE SEQUENCE sequence_name (sequence_start_clause | sequence_spec)* ';' + ; + +// Common Sequence + +sequence_spec + : INCREMENT BY UNSIGNED_INTEGER + | MAXVALUE UNSIGNED_INTEGER + | NOMAXVALUE + | MINVALUE UNSIGNED_INTEGER + | NOMINVALUE + | CYCLE + | NOCYCLE + | CACHE UNSIGNED_INTEGER + | NOCACHE + | ORDER + | NOORDER + ; + +sequence_start_clause + : START WITH UNSIGNED_INTEGER + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-ANALYTIC-VIEW.html +create_analytic_view + : CREATE (OR REPLACE)? (NOFORCE | FORCE)? ANALYTIC VIEW av=id_expression + (SHARING '=' (METADATA | NONE))? + classification_clause* + cav_using_clause? + dim_by_clause? + measures_clause? + default_measure_clause? + default_aggregate_clause? + cache_clause? + fact_columns_clause? + qry_transform_clause? + ; + +classification_clause +// : (CAPTION c=quoted_string)? (DESCRIPTION d=quoted_string)? classification_item* +// to handle - 'rule contains a closure with at least one alternative that can match an empty string' + : (caption_clause description_clause? | caption_clause? description_clause) classification_item* + | caption_clause? description_clause? classification_item+ + ; + +caption_clause + : CAPTION c=quoted_string + ; + +description_clause + : DESCRIPTION d=quoted_string + ; + +classification_item + : CLASSIFICATION cn=id_expression (VALUE cv=quoted_string)? (LANGUAGE language)? + ; + +language + : NULL_ + | nls=id_expression + ; + +cav_using_clause + : USING (schema_name '.')? t=id_expression REMOTE? (AS? ta=id_expression)? + ; + +dim_by_clause + : DIMENSION BY '(' dim_key (',' dim_key)* ')' + ; + +dim_key + : dim_ref classification_clause* + KEY ( '(' (a=id_expression '.')? f=column_name (',' (a=id_expression '.')? f=column_name)* ')' + | (a=id_expression '.')? f=column_name + ) + REFERENCES DISTINCT? ('(' attribute_name (',' attribute_name) ')' | attribute_name) + HIERARCHIES '(' hier_ref (',' hier_ref)* ')' + ; + +dim_ref + : (schema_name '.')? ad=id_expression (AS? da=id_expression)? + ; + +hier_ref + : (schema_name '.')? h=id_expression (AS? ha=id_expression)? DEFAULT? + ; + +measures_clause + : MEASURES '(' av_measure (',' av_measure)* ')' + ; + +av_measure + : mn=id_expression (base_meas_clause | calc_meas_clause)? //classification_clause* + ; + +base_meas_clause + : FACT /*FOR MEASURE*/ bm=id_expression meas_aggregate_clause? //FIXME inconsistent documentation + ; + +meas_aggregate_clause + : AGGREGATE BY aggregate_function_name + ; + +calc_meas_clause + : /*m=id_expression*/ AS '(' expression ')' //FIXME inconsistent documentation + ; + +default_measure_clause + : DEFAULT MEASURE m=id_expression + ; + +default_aggregate_clause + : DEFAULT AGGREGATE BY aggregate_function_name + ; + +cache_clause + : CACHE cache_specification (',' cache_specification)* + ; + +cache_specification + : MEASURE GROUP (ALL | '(' id_expression (',' id_expression)* ')' levels_clause (',' levels_clause)* ) + ; + +levels_clause + : LEVELS '(' level_specification (',' level_specification)* ')' level_group_type + ; + +level_specification + : '(' ((d=id_expression '.')? h=id_expression '.')? l=id_expression ')' + ; + +level_group_type + : DYNAMIC + | MATERIALIZED (USING (schema_name '.')? t=id_expression)? + ; + +fact_columns_clause + : FACT COLUMN f=column_name (AS? fa=id_expression (',' AS? fa=id_expression)* )? + ; + +qry_transform_clause + : ENABLE QUERY TRANSFORM (RELY | NORELY)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-ATTRIBUTE-DIMENSION.html +create_attribute_dimension + : CREATE (OR REPLACE)? (NOFORCE | FORCE)? ATTRIBUTE DIMENSION (schema_name '.')? ad=id_expression + (SHARING '=' (METADATA | NONE))? + classification_clause* + (DIMENSION TYPE (STANDARD | TIME))? + ad_using_clause + attributes_clause + ad_level_clause+ + all_clause? + ; + +ad_using_clause + : USING source_clause (',' source_clause)* join_path_clause* + ; + +source_clause + : (schema_name '.')? ftov=id_expression REMOTE? (AS? a=id_expression)? + ; + +join_path_clause + : JOIN PATH jpn=id_expression ON join_condition + ; + +join_condition + : join_condition_item (AND join_condition_item)* + ; + +join_condition_item + : (a=id_expression '.')? column_name '=' (b=id_expression '.')? column_name + ; + +attributes_clause + : ATTRIBUTES '(' ad_attributes_clause (',' ad_attributes_clause)* ')' + ; + +ad_attributes_clause + : (a=id_expression '.')? column_name (AS? an=id_expression)? + classification_clause* + ; + +ad_level_clause + : LEVEL l=id_expression (NOT NULL_ | SKIP_ WHEN NULL_)? + (LEVEL TYPE (STANDARD | YEARS | HALF_YEARS | QUARTERS | MONTHS | WEEKS | DAYS | HOURS | MINUTES | SECONDS))? + classification_clause* //inconsistent documentation - LEVEL TYPE goes after the classification_clause rule + key_clause + alternate_key_clause? + (MEMBER NAME expression)? + (MEMBER CAPTION expression)? + (MEMBER DESCRIPTION expression)? + (ORDER BY (MIN | MAX)? dim_order_clause (',' (MIN | MAX)? dim_order_clause)*)? + (DETERMINES '(' id_expression (',' id_expression)* ')')? + ; + +key_clause + : KEY (a=id_expression | '(' id_expression (',' id_expression)* ')') + ; + +alternate_key_clause + : ALTERNATE key_clause + ; + +dim_order_clause + : a=id_expression (ASC | DESC)? (NULLS (FIRST | LAST))? + ; + +all_clause + : ALL MEMBER ( NAME expression (MEMBER CAPTION expression)? + | CAPTION expression (MEMBER DESCRIPTION expression)? + | DESCRIPTION expression + ) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-AUDIT-POLICY-Unified-Auditing.html +create_audit_policy + : CREATE AUDIT POLICY p=id_expression + privilege_audit_clause? + action_audit_clause? + role_audit_clause? + (WHEN quoted_string EVALUATE PER (STATEMENT | SESSION | INSTANCE))? + (ONLY TOPLEVEL)? + container_clause? + ; + +privilege_audit_clause + : PRIVILEGES system_privilege (',' system_privilege)* + ; + +action_audit_clause + : (standard_actions | component_actions)+ + ; + +standard_actions + : ACTIONS actions_clause (',' actions_clause)* + ; + +actions_clause + : (object_action | ALL) ON (DIRECTORY directory_name | (MINING MODEL)? (schema_name '.')? id_expression) + | (system_action | ALL) + ; + +object_action + : ALTER + | GRANT + | READ + | EXECUTE + | AUDIT + | COMMENT + | DELETE + | INDEX + | INSERT + | LOCK + | SELECT + | UPDATE + | FLASHBACK + | RENAME + ; + +system_action + : id_expression // SELECT name FROM AUDITABLE_SYSTEM_ACTIONS WHERE component = 'Standard'; + | (CREATE | ALTER | DROP) JAVA + | LOCK TABLE + | (READ | WRITE | EXECUTE) DIRECTORY + ; + +component_actions + : ACTIONS COMPONENT '=' ( (DATAPUMP | DIRECT_LOAD | OLS | XS) component_action (',' component_action)* + | DV component_action ON id_expression (',' component_action ON id_expression)* + | PROTOCOL (FTP | HTTP | AUTHENTICATION) + ) + ; + +component_action + : id_expression // SELECT name FROM auditable_system_actions WHERE component = 'Datapump'; + ; + +role_audit_clause + : ROLES role_name (',' role_name)* + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-CONTROLFILE.html +create_controlfile + : CREATE CONTROLFILE REUSE? SET? DATABASE d=id_expression + logfile_clause? (RESETLOGS | NORESETLOGS) + (DATAFILE file_specification (',' file_specification)*)? + controlfile_options* + character_set_clause? + ; + +controlfile_options + : MAXLOGFILES numeric + | MAXLOGMEMBERS numeric + | MAXLOGHISTORY numeric + | MAXDATAFILES numeric + | MAXINSTANCES numeric + | ARCHIVELOG + | NOARCHIVELOG + | FORCE LOGGING + | SET STANDBY NOLOGGING FOR (DATA AVAILABILITY | LOAD PERFORMANCE) + ; + +logfile_clause + : LOGFILE (GROUP? numeric)? file_specification (',' (GROUP? numeric)? file_specification)* + ; + +character_set_clause + : CHARACTER SET cs=id_expression + ; + +file_specification + : datafile_tempfile_spec + | redo_log_file_spec + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-DISKGROUP.html +create_diskgroup + : CREATE DISKGROUP id_expression ((HIGH | NORMAL | FLEX | EXTENDED (SITE sn=id_expression)? | EXTERNAL) REDUNDANCY)? + (quorum_regular? (FAILGROUP fg=id_expression)? DISK qualified_disk_clause (',' qualified_disk_clause)*)+ + (ATTRIBUTE an=CHAR_STRING '=' av=CHAR_STRING (',' CHAR_STRING '=' CHAR_STRING)*)? + ; + +qualified_disk_clause + : ss=CHAR_STRING (NAME dn=id_expression)? (SIZE size_clause)? force_noforce? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-EDITION.html +create_edition + : CREATE EDITION e=id_expression (AS CHILD OF pe=id_expression)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-FLASHBACK-ARCHIVE.html +create_flashback_archive + : CREATE FLASHBACK ARCHIVE DEFAULT? fa=id_expression TABLESPACE ts=id_expression + flashback_archive_quota? + (NO? OPTIMIZE DATA)? + flashback_archive_retention + ; + +flashback_archive_quota + : QUOTA UNSIGNED_INTEGER (M_LETTER | G_LETTER | T_LETTER | P_LETTER | E_LETTER) + ; + +flashback_archive_retention + : RETENTION UNSIGNED_INTEGER (YEAR | MONTH | DAY) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-HIERARCHY.html +create_hierarchy + : CREATE (OR REPLACE)? (NO? FORCE)? HIERARCHY (schema_name '.')? h=id_expression + (SHARING '=' (METADATA | NONE))? + classification_clause* + hier_using_clause + level_hier_clause + hier_attrs_clause? + ; + +hier_using_clause + : USING (schema_name '.')? ad=id_expression + ; + +level_hier_clause + : '(' (l=id_expression (CHILD OF)?)+ ')' + ; + +hier_attrs_clause + : HIERARCHICAL ATTRIBUTES '(' hier_attr_clause ')' + ; + +hier_attr_clause + : hier_attr_name classification_clause* + ; + +hier_attr_name + : MEMBER_NAME + | MEMBER_UNIQUE_NAME + | MEMBER_CAPTION + | MEMBER_DESCRIPTION + | LEVEL_NAME + | HIER_ORDER + | DEPTH + | IS_LEAF + | PARENT_LEVEL_NAME + | PARENT_UNIQUE_NAME + ; + +create_index + : CREATE (UNIQUE | BITMAP)? INDEX index_name + ON (cluster_index_clause | table_index_clause | bitmap_join_index_clause) + (USABLE | UNUSABLE)? + ';' + ; + +cluster_index_clause + : CLUSTER cluster_name index_attributes? + ; + +cluster_name + : (id_expression '.')? id_expression + ; + +table_index_clause + : tableview_name table_alias? '(' index_expr_option (',' index_expr_option)* ')' + index_properties? + ; +bitmap_join_index_clause + : tableview_name '(' (tableview_name | table_alias)? column_name (ASC | DESC)? (',' (tableview_name | table_alias)? column_name (ASC | DESC)? )* ')' + FROM tableview_name table_alias (',' tableview_name table_alias)* + where_clause local_partitioned_index? index_attributes? + ; + +index_expr_option + : index_expr (ASC | DESC)? + ; + +index_expr + : column_name + | expression + ; + +index_properties + : (global_partitioned_index | local_partitioned_index | index_attributes)+ + | INDEXTYPE IS (domain_index_clause | xmlindex_clause) + ; + +domain_index_clause + : indextype local_domain_index_clause? parallel_clause? (PARAMETERS '(' odci_parameters ')' )? + ; + +local_domain_index_clause + : LOCAL ('(' PARTITION partition_name (PARAMETERS '(' odci_parameters ')' )? (',' PARTITION partition_name (PARAMETERS '(' odci_parameters ')' )? )* ')' )? + ; + +xmlindex_clause + : (XDB '.')? XMLINDEX local_xmlindex_clause? + parallel_clause? //TODO xmlindex_parameters_clause? + ; + +local_xmlindex_clause + : LOCAL ('(' PARTITION partition_name (',' PARTITION partition_name //TODO xmlindex_parameters_clause? + )* ')')? + ; + +global_partitioned_index + : GLOBAL ( + PARTITION BY (RANGE '(' column_name (',' column_name)* ')' '(' index_partitioning_clause (',' index_partitioning_clause)* ')' + | HASH '(' column_name (',' column_name)* ')' + (individual_hash_partitions + | hash_partitions_by_quantity + ) + ) + )? + ; + +index_partitioning_clause + : PARTITION partition_name? VALUES LESS THAN '(' literal (',' literal)* ')' + segment_attributes_clause? + ; + +local_partitioned_index + : LOCAL (on_range_partitioned_table + | on_list_partitioned_table + | on_hash_partitioned_table + | on_comp_partitioned_table + )? + ; + +on_range_partitioned_table + : '(' partitioned_table (',' partitioned_table)* ')' + ; + +on_list_partitioned_table + : '(' partitioned_table (',' partitioned_table)* ')' + ; + +partitioned_table + : PARTITION partition_name? + (segment_attributes_clause | key_compression)* + UNUSABLE? + ; + +on_hash_partitioned_table + : STORE IN '(' tablespace (',' tablespace)* ')' + | '(' on_hash_partitioned_clause (',' on_hash_partitioned_clause)* ')' + ; + +on_hash_partitioned_clause + : PARTITION partition_name? (TABLESPACE tablespace)? + key_compression? UNUSABLE? + ; +on_comp_partitioned_table + : (STORE IN '(' tablespace (',' tablespace)* ')' )? + '(' on_comp_partitioned_clause (',' on_comp_partitioned_clause)* ')' + ; + +on_comp_partitioned_clause + : PARTITION partition_name? + (segment_attributes_clause | key_compression)* + UNUSABLE index_subpartition_clause? + ; + +index_subpartition_clause + : STORE IN '(' tablespace (',' tablespace)* ')' + | '(' index_subpartition_subclause (',' index_subpartition_subclause)* ')' + ; + +index_subpartition_subclause + : SUBPARTITION subpartition_name? (TABLESPACE tablespace)? + key_compression? UNUSABLE? + ; + +odci_parameters + : CHAR_STRING + ; + +indextype + : (id_expression '.')? id_expression + ; + +//https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_1010.htm#SQLRF00805 +alter_index + : ALTER INDEX index_name (alter_index_ops_set1 | alter_index_ops_set2) ';' + ; + +alter_index_ops_set1 + : ( deallocate_unused_clause + | allocate_extent_clause + | shrink_clause + | parallel_clause + | physical_attributes_clause + | logging_clause + )+ + ; + +alter_index_ops_set2 + : rebuild_clause + | PARAMETERS '(' odci_parameters ')' + | COMPILE + | enable_or_disable + | UNUSABLE + | visible_or_invisible + | RENAME TO new_index_name + | COALESCE + | monitoring_nomonitoring USAGE + | UPDATE BLOCK REFERENCES + | alter_index_partitioning + ; + +visible_or_invisible + : VISIBLE + | INVISIBLE + ; + +monitoring_nomonitoring + : MONITORING + | NOMONITORING + ; + +rebuild_clause + : REBUILD ( PARTITION partition_name + | SUBPARTITION subpartition_name + | REVERSE + | NOREVERSE + )? + ( parallel_clause + | TABLESPACE tablespace + | PARAMETERS '(' odci_parameters ')' +//TODO | xmlindex_parameters_clause + | ONLINE + | physical_attributes_clause + | key_compression + | logging_clause + )* + ; + +alter_index_partitioning + : modify_index_default_attrs + | add_hash_index_partition + | modify_index_partition + | rename_index_partition + | drop_index_partition + | split_index_partition + | coalesce_index_partition + | modify_index_subpartition + ; + +modify_index_default_attrs + : MODIFY DEFAULT ATTRIBUTES (FOR PARTITION partition_name)? + ( physical_attributes_clause + | TABLESPACE (tablespace | DEFAULT) + | logging_clause + ) + ; + +add_hash_index_partition + : ADD PARTITION partition_name? (TABLESPACE tablespace)? + key_compression? parallel_clause? + ; + +coalesce_index_partition + : COALESCE PARTITION parallel_clause? + ; + +modify_index_partition + : MODIFY PARTITION partition_name + ( modify_index_partitions_ops+ + | PARAMETERS '(' odci_parameters ')' + | COALESCE + | UPDATE BLOCK REFERENCES + | UNUSABLE + ) + ; + +modify_index_partitions_ops + : deallocate_unused_clause + | allocate_extent_clause + | physical_attributes_clause + | logging_clause + | key_compression + ; + +rename_index_partition + : RENAME (PARTITION partition_name | SUBPARTITION subpartition_name) + TO new_partition_name + ; + +drop_index_partition + : DROP PARTITION partition_name + ; + +split_index_partition + : SPLIT PARTITION partition_name_old AT '(' literal (',' literal)* ')' + (INTO '(' index_partition_description ',' index_partition_description ')' ) ? parallel_clause? + ; + +index_partition_description + : PARTITION (partition_name ( (segment_attributes_clause | key_compression)+ + | PARAMETERS '(' odci_parameters ')' + ) + UNUSABLE? + )? + ; + +modify_index_subpartition + : MODIFY SUBPARTITION subpartition_name (UNUSABLE + | allocate_extent_clause + | deallocate_unused_clause + ) + ; + +partition_name_old + : partition_name + ; + +new_partition_name + : partition_name + ; + +new_index_name + : index_name + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-INMEMORY-JOIN-GROUP.html +alter_inmemory_join_group + : ALTER INMEMORY JOIN GROUP (schema_name '.')? jg=id_expression + (ADD | REMOVE) '(' (schema_name '.')? t=id_expression '(' c=id_expression ')' ')' + ; + +create_user + : CREATE USER + user_object_name + ( identified_by + | identified_other_clause + | user_tablespace_clause + | quota_clause + | profile_clause + | password_expire_clause + | user_lock_clause + | user_editions_clause + | container_clause + )+ ';' + ; + +// The standard clauses only permit one user per statement. +// The proxy clause allows multiple users for a proxy designation. +alter_user + : ALTER USER + user_object_name + ( alter_identified_by + | identified_other_clause + | user_tablespace_clause + | quota_clause + | profile_clause + | user_default_role_clause + | password_expire_clause + | user_lock_clause + | alter_user_editions_clause + | container_clause + | container_data_clause + )+ + ';' + | user_object_name (',' user_object_name)* proxy_clause ';' + ; + +drop_user + : DROP USER user_object_name CASCADE? + ; + +alter_identified_by + : identified_by (REPLACE id_expression)? + ; + +identified_by + : IDENTIFIED BY id_expression + ; + +identified_other_clause + : IDENTIFIED (EXTERNALLY | GLOBALLY) (AS quoted_string)? + ; + +user_tablespace_clause + : (DEFAULT | TEMPORARY) TABLESPACE id_expression + ; + +quota_clause + : QUOTA (size_clause | UNLIMITED) ON id_expression + ; + +profile_clause + : PROFILE id_expression + ; + +role_clause + : role_name (',' role_name)* + | ALL (EXCEPT role_name (',' role_name)*)* + ; + +user_default_role_clause + : DEFAULT ROLE (NONE | role_clause) + ; + +password_expire_clause + : PASSWORD EXPIRE + ; + +user_lock_clause + : ACCOUNT (LOCK | UNLOCK) + ; + +user_editions_clause + : ENABLE EDITIONS + ; + +alter_user_editions_clause + : user_editions_clause (FOR regular_id (',' regular_id)*)? FORCE? + ; + +proxy_clause + : REVOKE CONNECT THROUGH (ENTERPRISE USERS | user_object_name) + | GRANT CONNECT THROUGH + ( ENTERPRISE USERS + | user_object_name + (WITH (NO ROLES | ROLE role_clause))? + (AUTHENTICATION REQUIRED)? + (AUTHENTICATED USING (PASSWORD | CERTIFICATE | DISTINGUISHED NAME))? + ) + ; + +container_names + : LEFT_PAREN id_expression (',' id_expression)* RIGHT_PAREN + ; + +set_container_data + : SET CONTAINER_DATA EQUALS_OP (ALL | DEFAULT | container_names) + ; + +add_rem_container_data + : (ADD | REMOVE) CONTAINER_DATA EQUALS_OP container_names + ; + +container_data_clause + : set_container_data + | add_rem_container_data (FOR container_tableview_name)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ADMINISTER-KEY-MANAGEMENT.html +administer_key_management + : ADMINISTER KEY MANAGEMENT ( keystore_management_clauses + | key_management_clauses + | secret_management_clauses + | zero_downtime_software_patching_clauses + ) + ';' + ; + +keystore_management_clauses + : create_keystore + | open_keystore + | close_keystore + | backup_keystore + | alter_keystore_password + | merge_into_new_keystore + | merge_into_existing_keystore + | isolate_keystore + | unite_keystore + ; + +create_keystore + : CREATE ( KEYSTORE ksl=CHAR_STRING + | LOCAL? AUTO_LOGIN KEYSTORE FROM KEYSTORE ksl=CHAR_STRING + ) IDENTIFIED BY keystore_password + ; + +open_keystore + : SET KEYSTORE OPEN force_keystore? + identified_by_store + container_clause? + ; + +force_keystore + : FORCE KEYSTORE + ; + +close_keystore + : SET KEYSTORE CLOSE identified_by_store? + container_clause? + ; + +backup_keystore + : BACKUP KEYSTORE (USING bi=CHAR_STRING)? force_keystore? + identified_by_store + (TO ksl=CHAR_STRING)? + ; + +alter_keystore_password + : ALTER KEYSTORE PASSWORD force_keystore? IDENTIFIED BY o=keystore_password + SET n=keystore_password with_backup_clause? + ; + +merge_into_new_keystore + : MERGE KEYSTORE ksl1=CHAR_STRING identified_by_password_clause? + AND KEYSTORE ksl2=CHAR_STRING identified_by_password_clause? + INTO NEW KEYSTORE ksl2=CHAR_STRING identified_by_password_clause + ; + +merge_into_existing_keystore + : MERGE KEYSTORE ksl1=CHAR_STRING identified_by_password_clause? + INTO EXISTING KEYSTORE ksl2=CHAR_STRING identified_by_password_clause + with_backup_clause? + ; + +isolate_keystore + : FORCE? ISOLATE KEYSTORE IDENTIFIED BY i=keystore_password FROM ROOT KEYSTORE + force_keystore? + identified_by_store + with_backup_clause? + ; + +unite_keystore + : UNITE KEYSTORE IDENTIFIED BY i=keystore_password WITH ROOT KEYSTORE + force_keystore? + identified_by_store + with_backup_clause? + ; + +key_management_clauses + : set_key + | create_key + | use_key + | set_key_tag + | export_keys + | import_keys + | migrate_keys + | reverse_migrate_keys + | move_keys + ; + +set_key + : SET ENCRYPTION? KEY ((mkid ':')? mk)? using_tag_clause? + using_algorithm_clause? force_keystore? + identified_by_store + with_backup_clause? + container_clause? + ; + +create_key + : CREATE ENCRYPTION? KEY ((mkid ':')? mk)? using_tag_clause? + using_algorithm_clause? force_keystore? + identified_by_store + with_backup_clause? + container_clause? + ; + +mkid + : CHAR_STRING + ; + +mk + : CHAR_STRING + ; + +use_key + : USE ENCRYPTION? KEY k=CHAR_STRING using_tag_clause? force_keystore? + identified_by_store + with_backup_clause? + ; + +set_key_tag + : SET TAG t=CHAR_STRING FOR k=CHAR_STRING force_keystore? + identified_by_store + with_backup_clause? + ; + +export_keys + : EXPORT ENCRYPTION? KEYS WITH SECRET secret TO filename + force_keystore? identified_by_store + (WITH IDENTIFIER IN (CHAR_STRING (',' CHAR_STRING)* | '(' subquery ')'))? + ; + +import_keys + : IMPORT ENCRYPTION? KEYS WITH SECRET secret FROM filename + force_keystore? + identified_by_store + with_backup_clause? + ; + +migrate_keys + : SET ENCRYPTION? KEY IDENTIFIED BY hsm=secret + force_keystore? + MIGRATE USING keystore_password + with_backup_clause? + ; + +reverse_migrate_keys + : SET ENCRYPTION? KEY IDENTIFIED BY s=secret + force_keystore? + REVERSE MIGRATE USING hsm=secret + ; + +move_keys + : MOVE ENCRYPTION? KEYS TO NEW KEYSTORE ksl1=CHAR_STRING + IDENTIFIED BY ksp1=keystore_password FROM FORCE? KEYSTORE IDENTIFIED BY ksp=keystore_password + (WITH IDENTIFIER IN (CHAR_STRING (',' CHAR_STRING)* | subquery))? + with_backup_clause? + ; + +identified_by_store + : IDENTIFIED BY (EXTERNAL STORE | keystore_password) + ; + +using_algorithm_clause + : USING ALGORITHM ea=CHAR_STRING + ; + +using_tag_clause + : USING TAG t=CHAR_STRING + ; + +secret_management_clauses + : add_update_secret + | delete_secret + | add_update_secret_seps + | delete_secret_seps + ; + +add_update_secret + : (ADD | UPDATE) SECRET s=CHAR_STRING FOR CLIENT ci=CHAR_STRING + using_tag_clause? + force_keystore? + identified_by_store? + with_backup_clause? + ; + +delete_secret + : DELETE SECRET FOR CLIENT ci=CHAR_STRING + force_keystore? + identified_by_store + with_backup_clause? + ; + +add_update_secret_seps + : (ADD | UPDATE) SECRET s=CHAR_STRING FOR CLIENT ci=CHAR_STRING + using_tag_clause? + TO LOCAL? AUTO_LOGIN KEYSTORE directory_path + ; + +delete_secret_seps + : DELETE SECRET s=CHAR_STRING SQ FOR CLIENT ci=CHAR_STRING + FROM LOCAL? AUTO_LOGIN KEYSTORE directory_path + ; + +zero_downtime_software_patching_clauses + : SWITCHOVER TO? LIBRARY path FOR ALL CONTAINERS //inconsistent documentation + ; + +with_backup_clause + : WITH BACKUP (USING bi=CHAR_STRING)? + ; + +identified_by_password_clause + : IDENTIFIED BY keystore_password + ; + +keystore_password + : DELIMITED_ID + ; + +path + : CHAR_STRING + ; + +secret + : DELIMITED_ID + ; + +// https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4005.htm#SQLRF01105 +analyze + : ( ANALYZE (TABLE tableview_name | INDEX index_name) partition_extention_clause? + | ANALYZE CLUSTER cluster_name + ) + + ( validation_clauses + | LIST CHAINED ROWS into_clause1? + | DELETE SYSTEM? STATISTICS + ) + ';' + ; + +partition_extention_clause + : PARTITION ( '(' partition_name ')' + | FOR '(' partition_key_value (',' partition_key_value)* ')' + ) + | SUBPARTITION ( '(' subpartition_name ')' + | FOR '(' subpartition_key_value (',' subpartition_key_value)* ')' + ) + ; + +validation_clauses + : VALIDATE REF UPDATE (SET DANGLING TO NULL_)? + | VALIDATE STRUCTURE + ( CASCADE FAST + | CASCADE online_or_offline? into_clause? + | CASCADE + )? + online_or_offline? into_clause? + ; + +compute_clauses + : COMPUTE SYSTEM? STATISTICS for_clause? + ; +for_clause + : FOR ( TABLE for_clause* + | ALL (INDEXED? COLUMNS (SIZE UNSIGNED_INTEGER)? for_clause* | LOCAL? INDEXES) + | COLUMNS (SIZE UNSIGNED_INTEGER)? (column_name SIZE UNSIGNED_INTEGER)+ for_clause* + ) + ; + +online_or_offline + : OFFLINE + | ONLINE + ; + +into_clause1 + : INTO tableview_name? + ; + +//Making assumption on partition ad subpartition key value clauses +partition_key_value + : literal + | TIMESTAMP quoted_string + ; + +subpartition_key_value + : literal + | TIMESTAMP quoted_string + ; + +//https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4006.htm#SQLRF01106 +associate_statistics + : ASSOCIATE STATISTICS + WITH (column_association | function_association) + storage_table_clause? + ';' + ; + +column_association + : COLUMNS tableview_name '.' column_name (',' tableview_name '.' column_name)* using_statistics_type + ; + +function_association + : ( FUNCTIONS function_name (',' function_name)* + | PACKAGES package_name (',' package_name)* + | TYPES type_name (',' type_name)* + | INDEXES index_name (',' index_name)* + | INDEXTYPES indextype_name (',' indextype_name)* + ) + + ( using_statistics_type + | default_cost_clause (',' default_selectivity_clause)? + | default_selectivity_clause (',' default_cost_clause)? + ) + ; + +indextype_name + : id_expression + ; + + +using_statistics_type + : USING (statistics_type_name | NULL_) + ; + +statistics_type_name + : regular_id + ; + +default_cost_clause + : DEFAULT COST '(' cpu_cost ',' io_cost ',' network_cost ')' + ; + +cpu_cost + : UNSIGNED_INTEGER + ; + +io_cost + : UNSIGNED_INTEGER + ; + +network_cost + : UNSIGNED_INTEGER + ; + +default_selectivity_clause + : DEFAULT SELECTIVITY default_selectivity + ; + +default_selectivity + : UNSIGNED_INTEGER + ; + +storage_table_clause + : WITH (SYSTEM | USER) MANAGED STORAGE TABLES + ; + +// https://docs.oracle.com/database/121/SQLRF/statements_4008.htm#SQLRF56110 +unified_auditing + : {p.isVersion12()}? + AUDIT (POLICY policy_name ((BY | EXCEPT) audit_user (',' audit_user)* )? + (WHENEVER NOT? SUCCESSFUL)? + | CONTEXT NAMESPACE oracle_namespace + ATTRIBUTES attribute_name (',' attribute_name)* (BY audit_user (',' audit_user)*)? + ) + ';' + ; + +policy_name + : identifier + ; + +// https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4007.htm#SQLRF01107 +// https://docs.oracle.com/database/121/SQLRF/statements_4007.htm#SQLRF01107 + +audit_traditional + : AUDIT ( audit_operation_clause (auditing_by_clause | IN SESSION CURRENT)? + | audit_schema_object_clause + | NETWORK + | audit_direct_path + ) + (BY (SESSION | ACCESS) )? (WHENEVER NOT? SUCCESSFUL)? + audit_container_clause? + ';' + ; + +audit_direct_path + : {p.isVersion12()}? DIRECT_PATH auditing_by_clause + ; + +audit_container_clause + : {p.isVersion12()}? (CONTAINER EQUALS_OP (CURRENT | ALL)) + ; + +audit_operation_clause + : ( (sql_statement_shortcut | ALL STATEMENTS?) (',' (sql_statement_shortcut | ALL STATEMENTS?) )* + | (system_privilege | ALL PRIVILEGES) (',' (system_privilege | ALL PRIVILEGES) )* + ) + ; + +auditing_by_clause + : BY audit_user (',' audit_user)* + ; + +audit_user + : regular_id + ; + +audit_schema_object_clause + : ( sql_operation (',' sql_operation)* | ALL) auditing_on_clause + ; + +sql_operation + : ALTER + | AUDIT + | COMMENT + | DELETE + | EXECUTE + | FLASHBACK + | GRANT + | INDEX + | INSERT + | LOCK + | READ + | RENAME + | SELECT + | UPDATE + ; + +auditing_on_clause + : ON ( object_name + | DIRECTORY regular_id + | MINING MODEL model_name + | {p.isVersion12()}? SQL TRANSLATION PROFILE profile_name + | DEFAULT + ) + ; + +model_name + : (id_expression '.')? id_expression + ; + +object_name + : (id_expression '.')? id_expression + ; + +profile_name + : (id_expression '.')? id_expression + ; + +sql_statement_shortcut + : ALTER SYSTEM + | CLUSTER + | CONTEXT + | DATABASE LINK + | DIMENSION + | DIRECTORY + | INDEX + | MATERIALIZED VIEW + | NOT EXISTS + | OUTLINE + | {p.isVersion12()}? PLUGGABLE DATABASE + | PROCEDURE + | PROFILE + | PUBLIC DATABASE LINK + | PUBLIC SYNONYM + | ROLE + | ROLLBACK SEGMENT + | SEQUENCE + | SESSION + | SYNONYM + | SYSTEM AUDIT + | SYSTEM GRANT + | TABLE + | TABLESPACE + | TRIGGER + | TYPE + | USER + | VIEW + | ALTER SEQUENCE + | ALTER TABLE + | COMMENT TABLE + | DELETE TABLE + | EXECUTE PROCEDURE + | GRANT DIRECTORY + | GRANT PROCEDURE + | GRANT SEQUENCE + | GRANT TABLE + | GRANT TYPE + | INSERT TABLE + | LOCK TABLE + | SELECT SEQUENCE + | SELECT TABLE + | UPDATE TABLE + ; + +drop_index + : DROP INDEX index_name ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DISASSOCIATE-STATISTICS.html +disassociate_statistics + : DISASSOCIATE STATISTICS FROM + ( COLUMNS (schema_name '.')? tb=id_expression '.' c=id_expression (',' (schema_name '.')? tb=id_expression '.' c=id_expression)* + | FUNCTIONS (schema_name '.')? fn=id_expression (',' (schema_name '.')? fn=id_expression)* + | PACKAGES (schema_name '.')? pkg=id_expression (',' (schema_name '.')? pkg=id_expression)* + | TYPES (schema_name '.')? t=id_expression (',' (schema_name '.')? t=id_expression)* + | INDEXES (schema_name '.')? ix=id_expression (',' (schema_name '.')? ix=id_expression)* + | INDEXTYPES (schema_name '.')? it=id_expression (',' (schema_name '.')? it=id_expression)* + ) + FORCE? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-INDEXTYPE.html +drop_indextype + : DROP INDEXTYPE (schema_name '.')? it=id_expression FORCE? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-INMEMORY-JOIN-GROUP.html +drop_inmemory_join_group + : DROP INMEMORY JOIN GROUP (schema_name '.')? jg=id_expression + ; + +flashback_table + : FLASHBACK TABLE tableview_name (',' tableview_name)* TO + ( ((SCN | TIMESTAMP) expression | RESTORE POINT restore_point) ((ENABLE | DISABLE) TRIGGERS)? + | BEFORE DROP (RENAME TO tableview_name)? + ) + ; + +restore_point + : identifier ('.' id_expression)* + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/PURGE.html +purge_statement + : PURGE ( (TABLE | INDEX) id_expression + | TABLESPACE SET? ts=id_expression (USER u=id_expression)? + | RECYCLEBIN + | DBA_RECYCLEBIN + ) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/NOAUDIT-Traditional-Auditing.html +noaudit_statement + : NOAUDIT + ( audit_operation_clause auditing_by_clause? + | audit_schema_object_clause + | NETWORK + | DIRECT_PATH LOAD auditing_by_clause? + ) + (WHENEVER NOT? SUCCESSFUL)? + container_clause? + ; + +rename_object + : RENAME object_name TO object_name ';' + ; + +grant_statement + : GRANT + ( ','? + (role_name + | system_privilege + | object_privilege paren_column_list? + ) + )+ + (ON grant_object_name)? + TO (grantee_name | PUBLIC) (',' (grantee_name | PUBLIC) )* + (WITH (ADMIN | DELEGATE) OPTION)? + (WITH HIERARCHY OPTION)? + (WITH GRANT OPTION)? + container_clause? ';' + ; + +container_clause + : CONTAINER EQUALS_OP (CURRENT | ALL) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/REVOKE.html +revoke_statement + : REVOKE ((revoke_system_privilege | revoke_object_privileges) container_clause? | revoke_roles_from_programs) + ; + +revoke_system_privilege + : (system_privilege | role_name | ALL PRIVILEGES) FROM revokee_clause + ; + +revokee_clause + : (id_expression | PUBLIC) (',' (id_expression | PUBLIC))* + ; + +revoke_object_privileges + : (object_privilege | ALL PRIVILEGES?) (',' (object_privilege | ALL PRIVILEGES?))* on_object_clause + FROM revokee_clause (CASCADE CONSTRAINTS | FORCE)? + ; + +on_object_clause + : ON ( (schema_name '.')? o=id_expression + | USER id_expression (',' id_expression)* + | DIRECTORY directory_name + | EDITION edition_name + | MINING MODEL (schema_name '.')? mmn=id_expression + | JAVA (SOURCE | RESOURCE) (schema_name '.')? o2=id_expression + | SQL TRANSLATION PROFILE (schema_name '.')? p=id_expression + ) + ; + +revoke_roles_from_programs + : (role_name (',' role_name)* | ALL) FROM program_unit (',' program_unit)* + ; + +program_unit + : (FUNCTION | PROCEDURE | PACKAGE) (schema_name '.')? id_expression + ; + +create_dimension + : CREATE DIMENSION identifier level_clause+ (hierarchy_clause | attribute_clause | extended_attribute_clause)+ + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-DIRECTORY.html +create_directory + : CREATE (OR REPLACE)? DIRECTORY directory_name + (SHARING '=' (METADATA | NONE))? + AS directory_path + ';' + ; + +directory_name + : id_expression + ; + +directory_path + : CHAR_STRING + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-INMEMORY-JOIN-GROUP.html +create_inmemory_join_group + : CREATE INMEMORY JOIN GROUP (schema_name '.')? jg=id_expression + '(' (schema_name '.')? t=id_expression '(' c=id_expression ')' (',' (schema_name '.')? t=id_expression '(' c=id_expression ')')+ ')' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-HIERARCHY.html +drop_hierarchy + : DROP HIERARCHY (schema_name '.')? hn=id_expression + ; + +// https://docs.oracle.com/cd/E11882_01/appdev.112/e25519/alter_library.htm#LNPLS99946 +// https://docs.oracle.com/database/121/LNPLS/alter_library.htm#LNPLS99946 +alter_library + : ALTER LIBRARY library_name + ( COMPILE library_debug? compiler_parameters_clause* (REUSE SETTINGS)? + | library_editionable + ) + ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-JAVA.html +drop_java + : DROP JAVA (SOURCE | CLASS | RESOURCE) (schema_name '.')? id_expression + ; + +drop_library + : DROP LIBRARY library_name + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-JAVA.html +create_java + : CREATE (OR REPLACE)? (AND (RESOLVE | COMPILE))? NOFORCE? + JAVA ( (SOURCE | RESOURCE) NAMED (schema_name '.')? pn=id_expression + | CLASS (SCHEMA id_expression)? + ) + (SHARING '=' (METADATA | NONE))? + invoker_rights_clause? + (RESOLVER '(' ('(' CHAR_STRING ','? (sn=id_expression | '-') ')')+ ')')? + ( USING (BFILE '(' d=id_expression ',' filename ')' | (CLOB | BLOB | BFILE) subquery | CHAR_STRING) + | AS CHAR_STRING + ) + ; + +create_library + : CREATE (OR REPLACE)? (EDITIONABLE | NONEDITIONABLE)? LIBRARY plsql_library_source + ; + +plsql_library_source + : library_name (IS | AS) quoted_string (IN directory_name)? + (AGENT quoted_string)? (CREDENTIAL credential_name)? + ; + +credential_name + : (id_expression '.')? id_expression + ; + +library_editionable + : {p.isVersion12()}? (EDITIONABLE | NONEDITIONABLE) + ; + +library_debug + : {p.isVersion12()}? DEBUG + ; + + +compiler_parameters_clause + : parameter_name EQUALS_OP parameter_value + ; + +parameter_value + : regular_id + | CHAR_STRING + ; + +library_name + : (regular_id '.')? regular_id + ; + +alter_dimension + : ALTER DIMENSION identifier + ( (ADD (level_clause | hierarchy_clause | attribute_clause | extended_attribute_clause))+ + | (DROP (LEVEL identifier (RESTRICT | CASCADE)? | HIERARCHY identifier | ATTRIBUTE identifier (LEVEL identifier (COLUMN column_name (',' COLUMN column_name)*)?)? ))+ + | COMPILE + ) + ; + +level_clause + : LEVEL identifier IS (table_name '.' column_name | '(' table_name '.' column_name (',' table_name '.' column_name)* ')') + (SKIP_ WHEN NULL_)? + ; + +hierarchy_clause + : HIERARCHY identifier '(' identifier (CHILD OF identifier)+ dimension_join_clause? ')' + ; + +dimension_join_clause + : (JOIN KEY column_one_or_more_sub_clause REFERENCES identifier)+ + ; + +attribute_clause + : (ATTRIBUTE identifier DETERMINES column_one_or_more_sub_clause)+ + ; + +extended_attribute_clause + : ATTRIBUTE identifier (LEVEL identifier DETERMINES column_one_or_more_sub_clause )+ + ; + +column_one_or_more_sub_clause + : column_name + | '(' column_name (',' column_name)* ')' + ; + +// https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_4004.htm#SQLRF01104 +// https://docs.oracle.com/database/121/SQLRF/statements_4004.htm#SQLRF01104 +alter_view + : ALTER VIEW tableview_name + ( ADD out_of_line_constraint + | MODIFY CONSTRAINT constraint_name (RELY | NORELY) + | DROP ( CONSTRAINT constraint_name + | PRIMARY KEY + | UNIQUE '(' column_name (',' column_name)* ')' + ) + | COMPILE + | READ (ONLY | WRITE) + | alter_view_editionable? + ) + ';' + ; + +alter_view_editionable + : {p.isVersion12()}? (EDITIONABLE | NONEDITIONABLE) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-VIEW.html +create_view + : CREATE (OR REPLACE)? (NO? FORCE)? editioning_clause? VIEW (schema_name '.')? v=id_expression + (SHARING '=' (METADATA | EXTENDED? DATA | NONE))? + view_options? + (DEFAULT COLLATION cn=id_expression)? + (BEQUEATH (CURRENT_USER | DEFINER))? + AS select_only_statement subquery_restriction_clause? + (CONTAINER_MAP | CONTAINERS_DEFAULT)? + ; + +editioning_clause + : EDITIONING + | EDITIONABLE EDITIONING? + | NONEDITIONABLE + ; + +view_options + : view_alias_constraint + | object_view_clause + | xmltype_view_clause + ; + +view_alias_constraint + : '(' ( ','? (table_alias inline_constraint* | out_of_line_constraint) )+ ')' + ; + +object_view_clause + : OF (schema_name '.')? tn=id_expression + ( WITH OBJECT (IDENTIFIER | ID) (DEFAULT | '(' REGULAR_ID (',' REGULAR_ID)* ')') + | UNDER (schema_name '.')? sv=id_expression + ) + ('(' (','? (out_of_line_constraint | REGULAR_ID inline_constraint))+ ')')* + ; + +inline_constraint + : (CONSTRAINT constraint_name)? + ( NOT? NULL_ + | UNIQUE + | PRIMARY KEY + | references_clause + | check_constraint + ) + constraint_state? + ; + +inline_ref_constraint + : SCOPE IS tableview_name + | WITH ROWID + | (CONSTRAINT constraint_name)? references_clause constraint_state? + ; + +out_of_line_ref_constraint + : SCOPE FOR '(' ref_col_or_attr=regular_id ')' IS tableview_name + | REF '(' ref_col_or_attr=regular_id ')' WITH ROWID + | (CONSTRAINT constraint_name)? FOREIGN KEY '(' ( ','? ref_col_or_attr=regular_id)+ ')' references_clause constraint_state? + ; + +out_of_line_constraint + : ( (CONSTRAINT constraint_name)? + ( UNIQUE '(' column_name (',' column_name)* ')' + | PRIMARY KEY '(' column_name (',' column_name)* ')' + | foreign_key_clause + | CHECK '(' condition ')' + ) + ) + constraint_state? + ; + +constraint_state + : ( NOT? DEFERRABLE + | INITIALLY (IMMEDIATE | DEFERRED) + | (RELY | NORELY) + | (ENABLE | DISABLE) + | (VALIDATE | NOVALIDATE) + | using_index_clause + )+ + ; + +xmltype_view_clause + : OF XMLTYPE xml_schema_spec? WITH OBJECT (IDENTIFIER | ID) (DEFAULT | '(' expression (',' expression)* ')') + ; + +xml_schema_spec + : (XMLSCHEMA xml_schema_url)? ELEMENT (element | xml_schema_url '#' element) + (STORE ALL VARRAYS AS (LOBS | TABLES))? + (allow_or_disallow NONSCHEMA)? + (allow_or_disallow ANYSCHEMA)? + ; + +xml_schema_url + : DELIMITED_ID + ; + +element + : DELIMITED_ID + ; + +alter_tablespace + : ALTER TABLESPACE tablespace + ( DEFAULT table_compression? storage_clause? + | MINIMUM EXTENT size_clause + | RESIZE size_clause + | COALESCE + | SHRINK SPACE_KEYWORD (KEEP size_clause)? + | RENAME TO new_tablespace_name + | begin_or_end BACKUP + | datafile_tempfile_clauses + | tablespace_logging_clauses + | tablespace_group_clause + | tablespace_state_clauses + | autoextend_clause + | flashback_mode_clause + | tablespace_retention_clause + ) + ';' + ; + +datafile_tempfile_clauses + : ADD (datafile_specification | tempfile_specification) + | DROP (DATAFILE | TEMPFILE) (filename | UNSIGNED_INTEGER) (KEEP size_clause)? + | SHRINK TEMPFILE (filename | UNSIGNED_INTEGER) (KEEP size_clause)? + | RENAME DATAFILE filename (',' filename)* TO filename (',' filename)* + | (DATAFILE | TEMPFILE) (online_or_offline) + ; + +tablespace_logging_clauses + : logging_clause + | NO? FORCE LOGGING + ; + +tablespace_group_clause + : TABLESPACE GROUP (tablespace_group_name | CHAR_STRING) + ; + +tablespace_group_name + : regular_id + ; + +tablespace_state_clauses + : ONLINE + | OFFLINE (NORMAL | TEMPORARY | IMMEDIATE)? + | READ (ONLY | WRITE) + | PERMANENT + | TEMPORARY + ; + +flashback_mode_clause + : FLASHBACK (ON | OFF) + ; + +new_tablespace_name + : tablespace + ; + +create_tablespace + : CREATE (BIGFILE | SMALLFILE)? + ( permanent_tablespace_clause + | temporary_tablespace_clause + | undo_tablespace_clause + ) + ';' + ; + +permanent_tablespace_clause + : TABLESPACE id_expression datafile_specification? + ( MINIMUM EXTENT size_clause + | BLOCKSIZE size_clause + | logging_clause + | FORCE LOGGING + | (ONLINE | OFFLINE) + | ENCRYPTION tablespace_encryption_spec + | DEFAULT //TODO table_compression? storage_clause? + | extent_management_clause + | segment_management_clause + | flashback_mode_clause + )* + ; + +tablespace_encryption_spec + : USING encrypt_algorithm=CHAR_STRING + ; + +logging_clause + : LOGGING + | NOLOGGING + | FILESYSTEM_LIKE_LOGGING + ; + +extent_management_clause + : EXTENT MANAGEMENT LOCAL + ( AUTOALLOCATE + | UNIFORM (SIZE size_clause)? + )? + ; + +segment_management_clause + : SEGMENT SPACE_KEYWORD MANAGEMENT (AUTO | MANUAL) + ; + +temporary_tablespace_clause + : TEMPORARY TABLESPACE tablespace_name=id_expression + tempfile_specification? + tablespace_group_clause? extent_management_clause? + ; + +undo_tablespace_clause + : UNDO TABLESPACE tablespace_name=id_expression + datafile_specification? + extent_management_clause? tablespace_retention_clause? + ; + +tablespace_retention_clause + : RETENTION (GUARANTEE | NOGUARANTEE) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-TABLESPACE-SET.html +create_tablespace_set + : CREATE TABLESPACE SET tss=id_expression (IN SHARDSPACE ss=id_expression)? + (USING TEMPLATE '(' (DATAFILE file_specification (',' file_specification)*)? permanent_tablespace_attrs+ ')')? + ; + +permanent_tablespace_attrs + : MINIMUM EXTENT size_clause + | BLOCKSIZE numeric K_LETTER? + | logging_clause + | FORCE LOGGING + | tablespace_encryption_clause + | default_tablespace_params + | ONLINE + | OFFLINE + | extent_management_clause + | segment_management_clause + | flashback_mode_clause + | lost_write_protection + ; + +tablespace_encryption_clause + : ENCRYPTION (tablespace_encryption_spec? ENCRYPT | DECRYPT) + ; + +default_tablespace_params + : DEFAULT default_table_compression? default_index_compression? inmmemory_clause? ilm_clause? storage_clause? + ; + +default_table_compression + : TABLE ( COMPRESS FOR (OLTP | QUERY low_high | ARCHIVE low_high) + | NOCOMPRESS + ) + ; + +low_high + : LOW + | HIGH + ; + +default_index_compression + : INDEX (COMPRESS ADVANCED low_high | NOCOMPRESS) + ; + +inmmemory_clause + : INMEMORY inmemory_attributes? (TEXT (column_name (',' column_name)* | column_name USING policy_name (',' column_name USING policy_name)*))? + | NO INMEMORY + ; + +// asm_filename is just a charater string. Would need to parse the string +// to find diskgroup... +datafile_specification + : DATAFILE + (','? datafile_tempfile_spec) + ; + +tempfile_specification + : TEMPFILE + (','? datafile_tempfile_spec) + ; + +datafile_tempfile_spec + : CHAR_STRING? (SIZE size_clause)? REUSE? autoextend_clause? + ; + +redo_log_file_spec + : ( filename + | '(' filename (',' filename)* ')' + ) + (SIZE size_clause)? + (BLOCKSIZE size_clause)? + REUSE? + ; + +autoextend_clause + : AUTOEXTEND (OFF | ON (NEXT size_clause)? maxsize_clause? ) + ; + +maxsize_clause + : MAXSIZE (UNLIMITED | size_clause) + ; + +build_clause + : BUILD (IMMEDIATE | DEFERRED) + ; + +partial_index_clause + : INDEXING (PARTIAL | FULL) + ; + +parallel_clause + : NOPARALLEL + | PARALLEL parallel_count=UNSIGNED_INTEGER? + ; + +alter_materialized_view + : ALTER MATERIALIZED VIEW tableview_name + ( physical_attributes_clause + | modify_mv_column_clause + | table_compression + | lob_storage_clause (',' lob_storage_clause)* + | modify_lob_storage_clause (',' modify_lob_storage_clause)* +//TODO | alter_table_partitioning + | parallel_clause + | logging_clause + | allocate_extent_clause + | deallocate_unused_clause + | shrink_clause + | (cache_or_nocache) + )? + alter_iot_clauses? + (USING INDEX physical_attributes_clause)? + alter_mv_option1? + ( enable_or_disable QUERY REWRITE + | COMPILE + | CONSIDER FRESH + )? + ';' + ; + +alter_mv_option1 + : alter_mv_refresh +//TODO | MODIFY scoped_table_ref_constraint + ; + +alter_mv_refresh + : REFRESH ( FAST + | COMPLETE + | FORCE + | ON (DEMAND | COMMIT) + | START WITH expression + | NEXT expression + | WITH PRIMARY KEY + | USING DEFAULT? MASTER ROLLBACK SEGMENT rollback_segment? + | USING (ENFORCED | TRUSTED) CONSTRAINTS + )+ + ; + +rollback_segment + : regular_id + ; + +modify_mv_column_clause + : MODIFY '(' column_name (ENCRYPT encryption_spec | DECRYPT)? ')' + ; + +alter_materialized_view_log + : ALTER MATERIALIZED VIEW LOG FORCE? ON tableview_name + ( physical_attributes_clause + | add_mv_log_column_clause +//TODO | alter_table_partitioning + | parallel_clause + | logging_clause + | allocate_extent_clause + | shrink_clause + | move_mv_log_clause + | cache_or_nocache + )? + mv_log_augmentation? mv_log_purge_clause? + ';' + ; +add_mv_log_column_clause + : ADD '(' column_name ')' + ; + +move_mv_log_clause + : MOVE segment_attributes_clause parallel_clause? + ; + +mv_log_augmentation + : ADD ( ( OBJECT ID + | PRIMARY KEY + | ROWID + | SEQUENCE + ) + ('(' column_name (',' column_name)* ')')? + + | '(' column_name (',' column_name)* ')' + ) + new_values_clause? + ; + +// Should bound this to just date/time expr +datetime_expr + : expression + ; + +// Should bound this to just interval expr +interval_expr + : expression + ; + +synchronous_or_asynchronous + : SYNCHRONOUS + | ASYNCHRONOUS + ; + +including_or_excluding + : INCLUDING + | EXCLUDING + ; + + +create_materialized_view_log + : CREATE MATERIALIZED VIEW LOG ON tableview_name + ( ( physical_attributes_clause + | TABLESPACE tablespace_name=id_expression + | logging_clause + | (CACHE | NOCACHE) + )+ + )? + parallel_clause? + // table_partitioning_clauses TODO + ( WITH + ( ','? + ( OBJECT ID + | PRIMARY KEY + | ROWID + | SEQUENCE + | COMMIT SCN + ) + )* + ('(' ( ','? regular_id )+ ')' new_values_clause? )? + mv_log_purge_clause? + )* + ; + +new_values_clause + : (INCLUDING | EXCLUDING ) NEW VALUES + ; + +mv_log_purge_clause + : PURGE + ( IMMEDIATE (SYNCHRONOUS | ASYNCHRONOUS)? + // |START WITH CLAUSES TODO + ) + ; + +create_materialized_zonemap + : CREATE MATERIALIZED ZONEMAP zonemap_name (LEFT_PAREN column_list RIGHT_PAREN)? zonemap_attributes? zonemap_refresh_clause? + ((ENABLE | DISABLE) PRUNING)? (create_zonemap_on_table | create_zonemap_as_subquery) + ; + +alter_materialized_zonemap + : ALTER MATERIALIZED ZONEMAP zonemap_name + ( zonemap_attributes | zonemap_refresh_clause| (ENABLE | DISABLE) PRUNING | COMPILE | REBUILD | UNUSABLE + ) + ; + +drop_materialized_zonemap + : DROP MATERIALIZED ZONEMAP zonemap_name + ; + +zonemap_refresh_clause + : REFRESH (FAST | COMPILE | FORCE)? (ON (DEMAND | COMMIT | LOAD | DATA MOVEMENT | LOAD DATA MOVEMENT))? + ; + +zonemap_attributes + : (PCTFREE numeric | PCTUSED numeric | SCALE numeric | TABLESPACE tablespace | (CACHE | NOCACHE))+ + ; + +zonemap_name + : identifier ('.' id_expression)? + ; + +operator_name + : identifier ('.' id_expression)? + ; + +operator_function_name + : identifier ('.' id_expression)* + ; + +create_zonemap_on_table + : ON tableview_name LEFT_PAREN column_list RIGHT_PAREN + ; + +create_zonemap_as_subquery + : AS subquery + ; + +alter_operator + : ALTER OPERATOR operator_name (add_binding_clause | drop_binding_clause | COMPILE) + ; + +drop_operator + : DROP OPERATOR operator_name FORCE? + ; + +create_operator + : CREATE (OR REPLACE)? OPERATOR operator_name BINDING binding_clause (COMMA binding_clause)* + (SHARING '=' (METADATA | NONE))? + ; + +binding_clause + : LEFT_PAREN datatype (COMMA datatype)* RIGHT_PAREN + RETURN LEFT_PAREN? datatype RIGHT_PAREN? implementation_clause? using_function_clause + ; + +add_binding_clause + : ADD BINDING binding_clause + ; + +implementation_clause + : ANCILLARY TO primary_operator_list + | operator_context_clause + ; + +primary_operator_list + : primary_operator_item (COMMA primary_operator_item)* + ; + +primary_operator_item + : schema_object_name LEFT_PAREN datatype (COMMA datatype)* RIGHT_PAREN + ; + +operator_context_clause + : WITH INDEX CONTEXT COMMA SCAN CONTEXT implementation_type_name (COMPUTE ANCILLARY DATA)? + (WITH COLUMN CONTEXT)? + ; + +using_function_clause + : USING operator_function_name + ; + +drop_binding_clause + : DROP BINDING LEFT_PAREN datatype (COMMA datatype)* RIGHT_PAREN FORCE? + ; + +create_materialized_view + : CREATE MATERIALIZED VIEW tableview_name + (OF type_name )? + ( '(' (scoped_table_ref_constraint | mv_column_alias) (',' (scoped_table_ref_constraint | mv_column_alias))* ')' )? + ( ON PREBUILT TABLE ( (WITH | WITHOUT) REDUCED PRECISION)? + | physical_properties? (CACHE | NOCACHE)? parallel_clause? build_clause? + ) + ( USING INDEX ( (physical_attributes_clause | TABLESPACE mv_tablespace=id_expression)+ )* + | USING NO INDEX + )? + create_mv_refresh? + (FOR UPDATE)? + ( (DISABLE | ENABLE) QUERY REWRITE )? + AS select_only_statement + ';' + ; + +scoped_table_ref_constraint + : SCOPE FOR '(' ref_column_or_attribute=identifier ')' IS (schema_name '.')? scope_table_name_or_c_alias=identifier + ; + +mv_column_alias + : (identifier | quoted_string) (ENCRYPT encryption_spec)? + ; + +create_mv_refresh + : ( NEVER REFRESH + | REFRESH + ( (FAST | COMPLETE | FORCE) + | ON (DEMAND | COMMIT) + | (START WITH | NEXT) //date goes here TODO + | WITH (PRIMARY KEY | ROWID) + | USING + ( DEFAULT (MASTER | LOCAL)? ROLLBACK SEGMENT + | (MASTER | LOCAL)? ROLLBACK SEGMENT rb_segment=REGULAR_ID + ) + | USING (ENFORCED | TRUSTED) CONSTRAINTS + )+ + ) + ; + +drop_materialized_view + : DROP MATERIALIZED VIEW tableview_name (PRESERVE TABLE)? + ';' + ; + +create_context + : CREATE (OR REPLACE)? CONTEXT oracle_namespace USING (schema_object_name '.')? package_name + (INITIALIZED (EXTERNALLY | GLOBALLY) + | ACCESSED GLOBALLY + )? + ';' + ; + +oracle_namespace + : id_expression + ; + +//https://docs.oracle.com/cd/E11882_01/server.112/e41084/statements_5001.htm#SQLRF01201 +create_cluster + : CREATE CLUSTER cluster_name '(' column_name datatype SORT? (',' column_name datatype SORT?)* ')' + ( physical_attributes_clause + | SIZE size_clause + | TABLESPACE tablespace + | INDEX + | (SINGLE TABLE)? HASHKEYS UNSIGNED_INTEGER (HASH IS expression)? + )* + parallel_clause? (ROWDEPENDENCIES | NOROWDEPENDENCIES)? + (CACHE | NOCACHE)? + ';' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-PROFILE.html +create_profile + : CREATE MANDATORY? PROFILE p=id_expression + LIMIT (resource_parameters | password_parameters)+ + container_clause? + ; + +resource_parameters + : ( SESSIONS_PER_USER + | CPU_PER_SESSION + | CPU_PER_CALL + | CONNECT_TIME + | IDLE_TIME + | LOGICAL_READS_PER_SESSION + | LOGICAL_READS_PER_CALL + | COMPOSITE_LIMIT + ) (UNSIGNED_INTEGER | UNLIMITED | DEFAULT) + | PRIVATE_SGA (size_clause | UNLIMITED | DEFAULT) + ; + +password_parameters + : ( FAILED_LOGIN_ATTEMPTS + | PASSWORD_LIFE_TIME + | PASSWORD_REUSE_TIME + | PASSWORD_REUSE_MAX + | PASSWORD_LOCK_TIME + | PASSWORD_GRACE_TIME + | INACTIVE_ACCOUNT_TIME + ) (expression | UNLIMITED | DEFAULT) + | PASSWORD_VERIFY_FUNCTION (function_name | NULL_ | DEFAULT) + | PASSWORD_ROLLOVER_TIME (expression | DEFAULT) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-LOCKDOWN-PROFILE.html +create_lockdown_profile + : CREATE LOCKDOWN PROFILE id_expression (static_base_profile | dynamic_base_profile)? + ; + +static_base_profile + : FROM bp=id_expression + ; + +dynamic_base_profile + : INCLUDING bp=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-OUTLINE.html +create_outline + : CREATE (OR REPLACE)? (PUBLIC | PRIVATE)? OUTLINE (o=id_expression)? + (FROM (PUBLIC | PRIVATE)? so=id_expression)? + (FOR CATEGORY c=id_expression)? + (ON statement)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-RESTORE-POINT.html +create_restore_point + : CREATE CLEAN? RESTORE POINT rp=id_expression (FOR PLUGGABLE DATABASE pdb=id_expression)? + (AS OF (TIMESTAMP | SCN) expression)? + (PRESERVE | GUARANTEE FLASHBACK DATABASE)? + ; + +create_role + : CREATE ROLE role_name role_identified_clause? container_clause? + ; + +create_table + : CREATE + ( (GLOBAL | PRIVATE) TEMPORARY + | SHARDED + | DUPLICATED + | IMMUTABLE? BLOCKCHAIN + | IMMUTABLE + )? + TABLE (schema_name '.')? table_name + (SHARING '=' (METADATA | EXTENDED? DATA | NONE))? + (relational_table | object_table | xmltype_table) + (MEMOPTIMIZE FOR READ)? + (MEMOPTIMIZE FOR WRITE)? + (PARENT tableview_name)? + ';' + ; + +xmltype_table + : OF XMLTYPE ('(' object_properties ')')? + (XMLTYPE xmltype_storage)? + xmlschema_spec? + xmltype_virtual_columns? + (ON COMMIT (DELETE | PRESERVE) ROWS)? + oid_clause? + oid_index_clause? + physical_properties? + table_properties + ; + +xmltype_virtual_columns + : VIRTUAL COLUMNS '(' column_name AS '(' expression ')' (',' column_name AS '(' expression ')')* ')' + ; + +xmltype_column_properties + : XMLTYPE COLUMN? column_name xmltype_storage? xmlschema_spec? + ; + +xmltype_storage + : STORE AS ( OBJECT RELATIONAL + | (SECUREFILE | BASICFILE)? (CLOB | BINARY XML) (lob_segname ('(' lob_parameters ')')? | '(' lob_parameters ')')? + ) + | STORE VARRAYS AS (LOBS | TABLES) + ; + +xmlschema_spec + : (XMLSCHEMA DELIMITED_ID)? ELEMENT DELIMITED_ID + (allow_or_disallow NONSCHEMA)? + (allow_or_disallow ANYSCHEMA)? + ; + +object_table + : OF (schema_name '.')? object_type + object_table_substitution? + ('(' object_properties (',' object_properties)* ')')? + (ON COMMIT (DELETE | PRESERVE) ROWS)? + oid_clause? + oid_index_clause? + physical_properties? + table_properties + ; + +object_type + : regular_id + ; + +oid_index_clause + : OIDINDEX index_name? '(' (physical_attributes_clause | TABLESPACE tablespace)+ ')' + ; + +oid_clause + : OBJECT IDENTIFIER IS (SYSTEM GENERATED | PRIMARY KEY) + ; + +object_properties + : (column_name | attribute_name) (DEFAULT expression)? (inline_constraint (',' inline_constraint)* | inline_ref_constraint)? + | out_of_line_constraint + | out_of_line_ref_constraint + | supplemental_logging_props + ; + +object_table_substitution + : NOT? SUBSTITUTABLE AT ALL LEVELS + ; + +relational_table + : ('(' relational_property (',' relational_property)* ')')? + immutable_table_clauses + blockchain_table_clauses? + (DEFAULT COLLATION collation_name)? + (ON COMMIT (DROP | PRESERVE) DEFINITION)? + (ON COMMIT (DELETE | PRESERVE) ROWS)? + physical_properties? + table_properties + ; + +immutable_table_clauses + : immutable_table_no_drop_clause? immutable_table_no_delete_clause? + ; + +immutable_table_no_drop_clause + : NO DROP (UNTIL numeric DAYS IDLE)? + ; + +immutable_table_no_delete_clause + : NO DELETE (LOCKED? | UNTIL numeric DAYS AFTER INSERT LOCKED?) + ; + +blockchain_table_clauses + : blockchain_drop_table_clause blockchain_row_retention_clause blockchain_hash_and_data_format_clause + ; + +blockchain_drop_table_clause + : NO DROP (UNTIL numeric DAYS IDLE)? + ; + +blockchain_row_retention_clause + : NO DELETE (LOCKED? | UNTIL numeric DAYS AFTER INSERT LOCKED?) + ; + +blockchain_hash_and_data_format_clause + : HASHING USING SHA2_512_Q VERSION V1_Q + ; + +collation_name + : identifier + ; + +table_properties + : column_properties? + read_only_clause? + indexing_clause? + table_partitioning_clauses? + attribute_clustering_clause? + (CACHE | NOCACHE)? + result_cache_clause? + parallel_clause? + (ROWDEPENDENCIES | NOROWDEPENDENCIES)? + enable_disable_clause* + row_movement_clause? + logical_replication_clause? + flashback_archive_clause? + physical_properties? + (ROW ARCHIVAL)? + (AS select_only_statement | FOR EXCHANGE WITH TABLE (schema_name '.')? table_name)? + ; + +read_only_clause + : READ (ONLY | WRITE) + ; + +indexing_clause + : INDEXING (ON | OFF) + ; + +attribute_clustering_clause + : CLUSTERING + clustering_join? + cluster_clause + (yes_no? ON LOAD)? + (yes_no? ON DATA MOVEMENT)? + zonemap_clause? + ; + +clustering_join + : (schema_name '.')? table_name clustering_join_item (',' clustering_join_item)* + ; + +clustering_join_item + : JOIN (schema_name '.')? table_name ON '(' equijoin_condition ')' + ; + +equijoin_condition + : expression + ; + +cluster_clause + : BY (LINEAR | INTERLEAVED)? ORDER clustering_columns + ; + +clustering_columns + : clustering_column_group + | '(' clustering_column_group (',' clustering_column_group)* ')' + ; + +clustering_column_group + : '(' column_name (',' column_name)* ')' + ; + +yes_no + : YES + | NO + ; + +zonemap_clause + : WITH MATERIALIZED ZONEMAP ('(' zonemap_name ')')? + | WITHOUT MATERIALIZED ZONEMAP + ; + +logical_replication_clause + : DISABLE LOGICAL REPLICATION + | ENABLE LOGICAL REPLICATION ((ALL | ALLOW NOVALIDATE) KEYS)? + ; + +table_name + : identifier + ; + +relational_property + : column_definition + | virtual_column_definition + | period_definition + | out_of_line_constraint + | out_of_line_ref_constraint + | supplemental_logging_props + ; + +table_partitioning_clauses + : range_partitions + | list_partitions + | hash_partitions + | composite_range_partitions + | composite_list_partitions + | composite_hash_partitions + | reference_partitioning + | system_partitioning + ; + +range_partitions + : PARTITION BY RANGE '(' column_name (',' column_name)* ')' + (INTERVAL '(' expression ')' (STORE IN '(' tablespace (',' tablespace)* ')' )? )? + '(' PARTITION partition_name? range_values_clause table_partition_description (',' PARTITION partition_name? range_values_clause table_partition_description)* ')' + ; + +list_partitions + : PARTITION BY LIST '(' column_name ')' + '(' PARTITION partition_name? list_values_clause table_partition_description (',' PARTITION partition_name? list_values_clause table_partition_description )* ')' + ; + +hash_partitions + : PARTITION BY HASH '(' column_name (',' column_name)* ')' + (individual_hash_partitions | hash_partitions_by_quantity) + ; + +individual_hash_partitions + : '(' PARTITION partition_name? partitioning_storage_clause? (',' PARTITION partition_name? partitioning_storage_clause?)* ')' + ; + +hash_partitions_by_quantity + : PARTITIONS hash_partition_quantity + (STORE IN '(' tablespace (',' tablespace)* ')')? + (table_compression | key_compression)? + (OVERFLOW STORE IN '(' tablespace (',' tablespace)* ')' )? + ; + +hash_partition_quantity + : UNSIGNED_INTEGER + ; + +composite_range_partitions + : PARTITION BY RANGE '(' column_name (',' column_name)* ')' + (INTERVAL '(' expression ')' (STORE IN '(' tablespace (',' tablespace)* ')' )? )? + (subpartition_by_range | subpartition_by_list | subpartition_by_hash) + '(' range_partition_desc (',' range_partition_desc)* ')' + ; + +composite_list_partitions + : PARTITION BY LIST '(' column_name ')' + (subpartition_by_range | subpartition_by_list | subpartition_by_hash) + '(' list_partition_desc (',' list_partition_desc)* ')' + ; + +composite_hash_partitions + : PARTITION BY HASH '(' (',' column_name)+ ')' + (subpartition_by_range | subpartition_by_list | subpartition_by_hash) + (individual_hash_partitions | hash_partitions_by_quantity) + ; + +reference_partitioning + : PARTITION BY REFERENCE '(' regular_id ')' + ('(' reference_partition_desc (',' reference_partition_desc)* ')')? + ; + +reference_partition_desc + : PARTITION partition_name? table_partition_description + ; + +system_partitioning + : PARTITION BY SYSTEM + (PARTITIONS UNSIGNED_INTEGER | reference_partition_desc (',' reference_partition_desc)*)? + ; + +range_partition_desc + : PARTITION partition_name? range_values_clause table_partition_description + ( ( '(' ( range_subpartition_desc (',' range_subpartition_desc)* + | list_subpartition_desc (',' list_subpartition_desc)* + | individual_hash_subparts (',' individual_hash_subparts)* + ) + ')' + | hash_subparts_by_quantity + ) + )? + ; + +list_partition_desc + : PARTITION partition_name? list_values_clause table_partition_description + ( ( '(' ( range_subpartition_desc (',' range_subpartition_desc)* + | list_subpartition_desc (',' list_subpartition_desc)* + | individual_hash_subparts (',' individual_hash_subparts)* + ) + ')' + | hash_subparts_by_quantity + ) + )? + ; + +subpartition_template + : SUBPARTITION TEMPLATE + ( ( '(' ( range_subpartition_desc (',' range_subpartition_desc)* + | list_subpartition_desc (',' list_subpartition_desc)* + | individual_hash_subparts (',' individual_hash_subparts)* + ) + ')' + | hash_subpartition_quantity + ) + ) + ; + +hash_subpartition_quantity + : UNSIGNED_INTEGER + ; + +subpartition_by_range + : SUBPARTITION BY RANGE '(' column_name (',' column_name)* ')' subpartition_template? + ; + +subpartition_by_list + : SUBPARTITION BY LIST '(' column_name ')' subpartition_template? + ; + +subpartition_by_hash + : SUBPARTITION BY HASH '(' column_name (',' column_name)* ')' + (SUBPARTITIONS UNSIGNED_INTEGER (STORE IN '(' tablespace (',' tablespace)* ')' )? + | subpartition_template + )? + ; + +subpartition_name + : partition_name + ; + +range_subpartition_desc + : SUBPARTITION subpartition_name? range_values_clause partitioning_storage_clause? + ; + +list_subpartition_desc + : SUBPARTITION subpartition_name? list_values_clause partitioning_storage_clause? + ; + +individual_hash_subparts + : SUBPARTITION subpartition_name? partitioning_storage_clause? + ; + +hash_subparts_by_quantity + : SUBPARTITIONS UNSIGNED_INTEGER (STORE IN '(' tablespace (',' tablespace)* ')' )? + ; + +range_values_clause + : VALUES LESS THAN '(' literal (',' literal)* ')' + ; + +list_values_clause + : VALUES '(' (literal (',' literal)* | TIMESTAMP literal (',' TIMESTAMP literal)* | DEFAULT) ')' + ; + +table_partition_description + : deferred_segment_creation? segment_attributes_clause? + (table_compression | key_compression)? + (OVERFLOW segment_attributes_clause? )? + (lob_storage_clause | varray_col_properties | nested_table_col_properties)* + ; + +partitioning_storage_clause + : ( TABLESPACE tablespace + | OVERFLOW (TABLESPACE tablespace)? + | table_compression + | key_compression + | lob_partitioning_storage + | VARRAY varray_item STORE AS (BASICFILE | SECUREFILE)? LOB lob_segname + )+ + ; + +lob_partitioning_storage + : LOB '(' lob_item ')' + STORE AS (BASICFILE | SECUREFILE)? + (lob_segname ('(' TABLESPACE tablespace ')' )? + | '(' TABLESPACE tablespace ')' + ) + ; + +datatype_null_enable + : column_name datatype + SORT? (DEFAULT expression)? (ENCRYPT ( USING CHAR_STRING )? (IDENTIFIED BY REGULAR_ID)? CHAR_STRING? ( NO? SALT )? )? + (NOT NULL_)? (ENABLE | DISABLE)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/size_clause.html +// Technically, this should only allow 'K' | 'M' | 'G' | 'T' | 'P' | 'E' +// but having issues with examples/numbers01.sql line 11 "sysdate -1m" +size_clause + : UNSIGNED_INTEGER (K_LETTER | M_LETTER | G_LETTER | T_LETTER | P_LETTER | E_LETTER)? + ; + + +table_compression + : COMPRESS + ( BASIC + | FOR ( OLTP + | (QUERY | ARCHIVE) (LOW | HIGH)? + ) + )? + | NOCOMPRESS + ; + +// avoid to match an empty string in +inmemory_table_clause + : inmemory_column_clause+ + | (INMEMORY inmemory_attributes? | NO INMEMORY) inmemory_column_clause* + ; + +// avoid to match an empty string in +inmemory_attributes + : inmemory_memcompress inmemory_priority? inmemory_distribute? inmemory_duplicate? + | inmemory_priority inmemory_distribute? inmemory_duplicate? + | inmemory_distribute inmemory_duplicate? + | inmemory_duplicate + ; + +inmemory_memcompress + : MEMCOMPRESS FOR (DML | (QUERY | CAPACITY) (LOW | HIGH)?) + | NO MEMCOMPRESS + ; + +inmemory_priority + : PRIORITY (NONE | LOW | MEDIUM | HIGH | CRITICAL) + ; + +inmemory_distribute + : DISTRIBUTE + (AUTO | BY (ROWID RANGE | PARTITION | SUBPARTITION))? + (FOR SERVICE (DEFAULT | ALL | identifier | NONE))? + ; + +inmemory_duplicate + : DUPLICATE ALL? + | NO DUPLICATE + ; + +inmemory_column_clause + : (INMEMORY inmemory_memcompress? | NO INMEMORY) '(' column_list ')' + ; + +physical_attributes_clause + : (PCTFREE pctfree=UNSIGNED_INTEGER + | PCTUSED pctused=UNSIGNED_INTEGER + | INITRANS inittrans=UNSIGNED_INTEGER + | MAXTRANS maxtrans=UNSIGNED_INTEGER + | COMPUTE STATISTICS + | storage_clause + | compute_clauses + )+ + ; + +storage_clause + : STORAGE '(' + (INITIAL initial_size=size_clause + | NEXT next_size=size_clause + | MINEXTENTS minextents=(UNSIGNED_INTEGER | UNLIMITED) + | MAXEXTENTS minextents=(UNSIGNED_INTEGER | UNLIMITED) + | PCTINCREASE pctincrease=UNSIGNED_INTEGER + | FREELISTS freelists=UNSIGNED_INTEGER + | FREELIST GROUPS freelist_groups=UNSIGNED_INTEGER + | OPTIMAL (size_clause | NULL_ ) + | BUFFER_POOL (KEEP | RECYCLE | DEFAULT) + | FLASH_CACHE (KEEP | NONE | DEFAULT) + | CELL_FLASH_CACHE (KEEP | NONE | DEFAULT) + | ENCRYPT + )+ + ')' + ; + +deferred_segment_creation + : SEGMENT CREATION (IMMEDIATE | DEFERRED) + ; + +segment_attributes_clause + : ( physical_attributes_clause + | TABLESPACE (tablespace_name=id_expression | SET? identifier) + | table_compression + | logging_clause + )+ + ; + +physical_properties + : deferred_segment_creation? segment_attributes_clause table_compression? inmemory_table_clause? ilm_clause? + | deferred_segment_creation? ( ORGANIZATION ( HEAP segment_attributes_clause? heap_org_table_clause + | INDEX segment_attributes_clause? index_org_table_clause + | EXTERNAL external_table_clause + ) + | EXTERNAL PARTITION ATTRIBUTES external_table_clause (REJECT LIMIT)? + ) + | CLUSTER cluster_name '(' column_name (',' column_name)* ')' + ; + +ilm_clause + : ILM ( ADD POLICY ilm_policy_clause + | (DELETE | ENABLE | DISABLE) POLICY ilm_policy_clause + | DELETE_ALL + | ENABLE_ALL + | DISABLE_ALL + ) + ; + +ilm_policy_clause + : ilm_compression_policy + | ilm_tiering_policy + | ilm_inmemory_policy + ; + +ilm_compression_policy + : table_compression segment_group ilm_after_on + | ((ROW | COLUMN) STORE COMPRESS (ADVANCED | FOR QUERY)) ROW AFTER ilm_time_period OF NO MODIFICATION + ; + +ilm_tiering_policy + : TIER TO tablespace ( segment_group? (ON function_name)? + | READ ONLY segment_group? ilm_after_on + ) + ; + +ilm_after_on + : AFTER ilm_time_period OF (NO (ACCESS | MODIFICATION) | CREATION) + | ON function_name + ; + +segment_group + : SEGMENT + | GROUP + ; + +ilm_inmemory_policy + : ( SET INMEMORY inmemory_attributes? + | MODIFY INMEMORY inmemory_memcompress + | NO INMEMORY + ) SEGMENT? ilm_after_on + ; + +ilm_time_period + : numeric ( DAY + | DAYS + | MONTH + | MONTHS + | YEAR + | YEARS + ) + ; + +heap_org_table_clause + : table_compression? inmemory_table_clause? ilm_clause? + ; + +external_table_clause + : '(' (TYPE access_driver_type)? external_table_data_props ')' (REJECT LIMIT (numeric | UNLIMITED))? inmemory_table_clause? + ; + +access_driver_type + : ORACLE_LOADER + | ORACLE_DATAPUMP + | ORACLE_HDFS + | ORACLE_HIVE + ; + +external_table_data_props + : (DEFAULT DIRECTORY directory_name)? + (ACCESS PARAMETERS ( '(' CHAR_STRING ')' + | '(' opaque_format_spec ')' + | USING CLOB select_only_statement + ))? + (LOCATION '(' directory_name COLON CHAR_STRING (',' directory_name COLON CHAR_STRING)* ')' )? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/oracle-external-tables.html +opaque_format_spec + : record_format_info? field_definitions? column_transforms? + ; + +record_format_info + : RECORDS ( + (FIXED | VARIABLE) UNSIGNED_INTEGER + | DELIMITED BY (DETECTED? NEWLINE_ | CHAR_STRING) + | XMLTAG CHAR_STRING + ) et_record_spec_options? + ; + +// The string for external table data properties. +// Reference: https://docs.oracle.com/en/database/oracle/oracle-database/21/sutil/oracle_loader-access-driver.html#GUID-03FD7309-EAE9-4880-9BD1-945B32311478 +et_string + : CHAR_STRING + | DELIMITED_ID + | HEX_STRING_LIT + ; + +et_record_spec_options + : et_record_spec_option+ + ; + +et_record_spec_option + : CHARACTERSET char_set_name + | PREPROCESSOR (directory_spec COLON)? file_spec + | (LANGUAGE | TERRITORY) CHAR_STRING + | DATA IS (LITTLE | BIG) ENDIAN + | BYTEORDERMARK (CHECK | NOCHECK) + | STRING SIZES ARE IN (BYTES | CHARACTERS) + | LOAD WHEN condition + | et_output_files + | READSIZE UNSIGNED_INTEGER + | DISABLE_DIRECTORY_LINK_CHECK + | (DATE_CACHE | SKIP_) UNSIGNED_INTEGER + | FIELD_NAMES ( + FIRST FILE IGNORE? + | ALL FILES IGNORE? + | NONE + ) + | IO_OPTIONS '(' (DIRECTIO | NODIRECTIO) ')' + | (DNFS_ENABLE | DNFS_DISABLE) + | DNFS_READBUFFERS UNSIGNED_INTEGER + ; + +et_output_files + : et_output_file+ + ; + +et_output_file + : NOBADFILE + | BADFILE (directory_spec COLON)? file_spec? + | NODISCARDFILE + | DISCARDFILE (directory_spec COLON)? file_spec? + | NOLOGFILE + | LOGFILE (directory_spec COLON)? file_spec? + ; + +directory_spec + : directory_name + ; + +file_spec + : CHAR_STRING + ; + +field_definitions + : FIELDS field_options? field_list? + ; + +field_options + : field_option+ + ; + +field_option + : IGNORE_CHARS_AFTER_EOR + | CSV ((WITH | WITHOUT) EMBEDDED)? + | delim_spec + | trim_spec + | ALL FIELDS OVERRIDE THESE FIELDS + | MISSING FIELD VALUES ARE NULL_ + | REJECT ROWS WITH ALL NULL_ FIELDS + | field_date_format+ + | (NULLIF | NONULLIF) + ; + +field_list + : '(' field_item (',' field_item)* ')' + ; + +field_item + : field_name pos_spec? datatype_spec? init_spec? lls_clause? + ; + +field_name + : column_name + ; + +pos_spec + : POSITION? '(' (pos_start | '*' ('+' | '-') pos_increment) ((':' | '-') (pos_end | pos_length))? ')' + ; + +pos_start + : UNSIGNED_INTEGER + ; + +pos_increment + : UNSIGNED_INTEGER + ; + +pos_end + : UNSIGNED_INTEGER + ; + +pos_length + : UNSIGNED_INTEGER + ; + +datatype_spec + : UNSIGNED? INTEGER EXTERNAL? ('(' UNSIGNED_INTEGER ')')? delim_spec? + | (DECIMAL | ZONED) ( + EXTERNAL ('(' UNSIGNED_INTEGER ')')? delim_spec? + | precision_part + )? + | ORACLE_DATE + | ORACLE_NUMBER COUNTED? + | FLOAT EXTERNAL? ('(' UNSIGNED_INTEGER ')')? delim_spec? + | DOUBLE + | BINARY_FLOAT EXTERNAL? ('(' UNSIGNED_INTEGER ')')? delim_spec? + | BINARY_DOUBLE + | RAW ('(' UNSIGNED_INTEGER ')')? + | CHAR ('(' UNSIGNED_INTEGER ')')? delim_spec? trim_spec? field_date_format? + | ( + VARCHAR + | VARRAW + | VARCHARC + | VARRAWC + ) '(' (numeric ',')? numeric ')' + ; + +init_spec + : (DEFAULTIF | NULLIF) condition + ; + +lls_clause + : LLS (directory_spec COLON)? file_spec? + ; + +delim_spec + : ENCLOSED BY et_string (AND et_string)? + | TERMINATED BY (et_string | WHITESPACE) (OPTIONALLY? ENCLOSED BY et_string (AND et_string)? )? + ; + +trim_spec + : LRTRIM + | NOTRIM + | LTRIM + | RTRIM + | LDRTRIM + ; + +field_date_format + : DATE_FORMAT (DATE | TIMESTAMP)? MASK datetime_expr + ; + +column_transforms + : COLUMN TRANSFORMS '(' transform (',' transform)* ')' + ; + +transform + : column_name FROM ( + NULL_ + | CONSTANT CHAR_STRING + | CONCAT '(' concat_item (',' concat_item)* ')' + | LOBFILE '(' lobfile_item (',' lobfile_item)* ')' lobfile_attr_list? + | STARTOF source_field '(' UNSIGNED_INTEGER ')' + ) + ; + +source_field + : column_name + ; + +lobfile_item + : column_name + | CONSTANT CHAR_STRING COLON + ; + +lobfile_attr_list + : FROM '(' (directory_spec COLON)? file_spec? (',' (directory_spec COLON)? file_spec?)* ')' + | CLOB + | BLOB + | CHARACTERSET '=' char_set_name + ; + +concat_item + : column_name + | CONSTANT CHAR_STRING + ; + +row_movement_clause + : (ENABLE | DISABLE)? ROW MOVEMENT + ; + +flashback_archive_clause + : FLASHBACK ARCHIVE fa=id_expression? + | NO FLASHBACK ARCHIVE + ; + +log_grp + : UNSIGNED_INTEGER + ; + +supplemental_table_logging + : ADD SUPPLEMENTAL LOG (supplemental_log_grp_clause | supplemental_id_key_clause) + (',' SUPPLEMENTAL LOG (supplemental_log_grp_clause | supplemental_id_key_clause) )* + | DROP SUPPLEMENTAL LOG (supplemental_id_key_clause | GROUP log_grp) + (',' SUPPLEMENTAL LOG (supplemental_id_key_clause | GROUP log_grp) )* + ; + +supplemental_log_grp_clause + : GROUP log_grp '(' regular_id (NO LOG)? (',' regular_id (NO LOG)?)* ')' ALWAYS? + ; + +supplemental_id_key_clause + : DATA '('( ','? ( ALL + | PRIMARY KEY + | UNIQUE + | FOREIGN KEY + ) + )+ + ')' + COLUMNS + ; + +allocate_extent_clause + : ALLOCATE EXTENT + ( '(' ( SIZE size_clause + | DATAFILE datafile=CHAR_STRING + | INSTANCE inst_num=UNSIGNED_INTEGER + )+ + ')' + )? + ; + +deallocate_unused_clause + : DEALLOCATE UNUSED (KEEP size_clause)? + ; + +shrink_clause + : SHRINK SPACE_KEYWORD COMPACT? CASCADE? + ; + +records_per_block_clause + : (MINIMIZE | NOMINIMIZE)? RECORDS_PER_BLOCK + ; + +upgrade_table_clause + : UPGRADE (NOT? INCLUDING DATA) column_properties + ; + +truncate_table + : TRUNCATE TABLE tableview_name PURGE? SEMICOLON + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-TABLE.html +drop_table + : DROP TABLE tableview_name (CASCADE CONSTRAINTS)? PURGE? SEMICOLON + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-TABLESPACE.html +drop_tablespace + : DROP TABLESPACE ts=id_expression ((DROP | KEEP) QUOTA?)? + including_contents_clause? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-TABLESPACE-SET.html +drop_tablespace_set + : DROP TABLESPACE SET tss=id_expression + including_contents_clause? + ; + +including_contents_clause + : INCLUDING CONTENTS ((AND | KEEP) DATAFILES)? (CASCADE CONSTRAINTS)? + ; + +drop_view + : DROP VIEW tableview_name (CASCADE CONSTRAINT)? SEMICOLON + ; + +comment_on_column + : COMMENT ON COLUMN column_name IS quoted_string + ; + +enable_or_disable + : ENABLE + | DISABLE + ; +allow_or_disallow + : ALLOW + | DISALLOW + ; + +// Synonym DDL Clauses + +alter_synonym + : ALTER PUBLIC? SYNONYM (schema_name '.')? synonym_name (EDITIONABLE | NONEDITIONABLE | COMPILE) + ; + +create_synonym + // Synonym's schema cannot be specified for public synonyms + : CREATE (OR REPLACE)? PUBLIC SYNONYM synonym_name FOR (schema_name PERIOD)? schema_object_name (AT_SIGN link_name)? + | CREATE (OR REPLACE)? SYNONYM (schema_name PERIOD)? synonym_name FOR (schema_name PERIOD)? schema_object_name (AT_SIGN link_name)? + ; + +drop_synonym + : DROP PUBLIC? SYNONYM (schema_name '.')? synonym_name FORCE? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-SPFILE.html +create_spfile + : CREATE SPFILE ('=' spfile_name)? + FROM (PFILE ('=' pfile_name)? (AS COPY)? | MEMORY) + ; + +spfile_name + : CHAR_STRING + ; + +pfile_name + : CHAR_STRING + ; + +comment_on_table + : COMMENT ON TABLE tableview_name IS quoted_string + ; + +comment_on_materialized + : COMMENT ON MATERIALIZED VIEW tableview_name IS quoted_string + ; + +alter_analytic_view + : ALTER ANALYTIC VIEW (schema_name '.')? av=id_expression + ( RENAME TO id_expression + | COMPILE + | alter_add_cache_clause + | alter_drop_cache_clause + ) + ; + +alter_add_cache_clause + : ADD CACHE MEASURE GROUP '(' (ALL | measure_list)? ')' + LEVELS '(' levels_item (',' levels_item)* ')' + ; + +levels_item + : ((d=id_expression '.')? h=id_expression '.')? l=id_expression + ; + +measure_list + : id_expression (',' id_expression)* + ; + +alter_drop_cache_clause + : DROP CACHE MEASURE GROUP '(' (ALL | measure_list)? ')' + LEVELS '(' levels_item (',' levels_item)* ')' + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-ATTRIBUTE-DIMENSION.html +alter_attribute_dimension + : ALTER ATTRIBUTE DIMENSION (schema_name '.')? ad=id_expression + (RENAME TO nad=id_expression | COMPILE) + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-AUDIT-POLICY-Unified-Auditing.html +alter_audit_policy + : ALTER AUDIT POLICY p=id_expression + ADD? (privilege_audit_clause? action_audit_clause? role_audit_clause? | (ONLY TOPLEVEL)?) + DROP? (privilege_audit_clause? action_audit_clause? role_audit_clause? | (ONLY TOPLEVEL)?) + (CONDITION ( DROP + | CHAR_STRING EVALUATE PER (STATEMENT | SESSION | INSTANCE)) + )? + ; + +alter_cluster + : ALTER CLUSTER cluster_name + ( physical_attributes_clause + | SIZE size_clause + | allocate_extent_clause + | deallocate_unused_clause + | cache_or_nocache + )+ + parallel_clause? + ';' + ; + +drop_analytic_view + : DROP ANALYTIC VIEW (schema_name '.')? av=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-ATTRIBUTE-DIMENSION.html +drop_attribute_dimension + : DROP ATTRIBUTE DIMENSION (schema_name '.')? ad=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-AUDIT-POLICY-Unified-Auditing.html +drop_audit_policy + : DROP AUDIT POLICY p=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-FLASHBACK-ARCHIVE.html +drop_flashback_archive + : DROP FLASHBACK ARCHIVE fa=id_expression + ; + +drop_cluster + : DROP CLUSTER cluster_name (INCLUDING TABLES (CASCADE CONSTRAINTS)?)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-CONTEXT.html +drop_context + : DROP CONTEXT ns=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-DIRECTORY.html +drop_directory + : DROP DIRECTORY dn=id_expression + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-DISKGROUP.html +drop_diskgroup + : DROP DISKGROUP dgn=id_expression ((FORCE? INCLUDING | EXCLUDING) CONTENTS)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-EDITION.html +drop_edition + : DROP EDITION e=id_expression CASCADE? + ; + +truncate_cluster + : TRUNCATE CLUSTER cluster_name ((DROP | REUSE) STORAGE)? + ; + +cache_or_nocache + : CACHE + | NOCACHE + ; + +database_name + : regular_id + ; + +alter_database + : ALTER database_clause + ( startup_clauses + | recovery_clauses + | database_file_clauses + | logfile_clauses + | controlfile_clauses + | standby_database_clauses + | default_settings_clause + | instance_clauses + | security_clause + | prepare_clause + | drop_mirror_clause + | lost_write_protection + | cdb_fleet_clauses + | property_clauses + | replay_upgrade_clauses + ) + ';' + ; + +database_clause + : PLUGGABLE? DATABASE database_name? + ; + +startup_clauses + : MOUNT ((STANDBY | CLONE) DATABASE)? + | OPEN (READ WRITE)? resetlogs_or_noresetlogs? upgrade_or_downgrade? + | OPEN READ ONLY + ; + +resetlogs_or_noresetlogs + : RESETLOGS + | NORESETLOGS + ; + +upgrade_or_downgrade + : UPGRADE + | DOWNGRADE + ; + +recovery_clauses + : general_recovery + | managed_standby_recovery + | begin_or_end BACKUP + ; + +begin_or_end + : BEGIN + | END + ; + +general_recovery + : RECOVER AUTOMATIC? (FROM CHAR_STRING)? + ( (full_database_recovery | partial_database_recovery | LOGFILE CHAR_STRING )? + ((TEST | ALLOW UNSIGNED_INTEGER CORRUPTION | parallel_clause)+ )? + | CONTINUE DEFAULT? + | CANCEL + ) + ; + +//Need to come back to +full_database_recovery + : STANDBY? DATABASE + ((UNTIL (CANCEL |TIME CHAR_STRING | CHANGE UNSIGNED_INTEGER | CONSISTENT) + | USING BACKUP CONTROLFILE + | SNAPSHOT TIME CHAR_STRING + )+ + )? + ; + +partial_database_recovery + : TABLESPACE tablespace (',' tablespace)* + | DATAFILE CHAR_STRING | filenumber (',' CHAR_STRING | filenumber)* + | partial_database_recovery_10g + ; + +partial_database_recovery_10g + : {p.isVersion10()}? STANDBY + ( TABLESPACE tablespace (',' tablespace)* + | DATAFILE CHAR_STRING | filenumber (',' CHAR_STRING | filenumber)* + ) + UNTIL (CONSISTENT WITH)? CONTROLFILE + ; + + +managed_standby_recovery + : RECOVER (MANAGED STANDBY DATABASE + ((USING CURRENT LOGFILE + | DISCONNECT (FROM SESSION)? + | NODELAY + | UNTIL CHANGE UNSIGNED_INTEGER + | UNTIL CONSISTENT + | parallel_clause + )+ + | FINISH + | CANCEL + )? + | TO LOGICAL STANDBY (db_name | KEEP IDENTITY) + ) + ; + +db_name + : regular_id + ; +database_file_clauses + : RENAME FILE filename (',' filename)* TO filename + | create_datafile_clause + | alter_datafile_clause + | alter_tempfile_clause + | move_datafile_clause + ; + +create_datafile_clause + : CREATE DATAFILE (filename | filenumber) (',' (filename | filenumber) )* + (AS (//TODO (','? file_specification)+ | + NEW) )? + ; + +alter_datafile_clause + : DATAFILE (filename | filenumber) (',' (filename | filenumber) )* + ( ONLINE + | OFFLINE (FOR DROP)? + | RESIZE size_clause + | autoextend_clause + | END BACKUP + ) + ; + +alter_tempfile_clause + : TEMPFILE (filename | filenumber) (',' (filename | filenumber) )* + ( RESIZE size_clause + | autoextend_clause + | DROP (INCLUDING DATAFILES) + | ONLINE + | OFFLINE + ) + ; + +move_datafile_clause + : MOVE DATAFILE (filename | filenumber) (',' (filename | filenumber) )* + (TO filename)? REUSE? KEEP? + ; + +logfile_clauses + : (ARCHIVELOG MANUAL? | NOARCHIVELOG) + | NO? FORCE LOGGING + | SET STANDBY NOLOGGING FOR (DATA AVAILABILITY | LOAD PERFORMANCE) + | RENAME FILE filename (',' filename)* TO filename + | CLEAR UNARCHIVED? LOGFILE logfile_descriptor (',' logfile_descriptor)* (UNRECOVERABLE DATAFILE)? + | add_logfile_clauses + | drop_logfile_clauses + | switch_logfile_clause + | supplemental_db_logging + ; + +add_logfile_clauses + : ADD STANDBY? LOGFILE + ( (INSTANCE CHAR_STRING | THREAD UNSIGNED_INTEGER)? group_redo_logfile+ + | MEMBER filename REUSE? (',' filename REUSE?)* TO logfile_descriptor (',' logfile_descriptor)* + ) + ; + +group_redo_logfile + : (GROUP UNSIGNED_INTEGER)? redo_log_file_spec + ; + +drop_logfile_clauses + : DROP STANDBY? + LOGFILE (logfile_descriptor (',' logfile_descriptor)* + | MEMBER filename (',' filename)* + ) + ; + +switch_logfile_clause + : SWITCH ALL LOGFILES TO BLOCKSIZE UNSIGNED_INTEGER + ; + +supplemental_db_logging + : add_or_drop + SUPPLEMENTAL LOG (DATA + | supplemental_id_key_clause + | supplemental_plsql_clause + ) + ; + +add_or_drop + : ADD + | DROP + ; + +supplemental_plsql_clause + : DATA FOR PROCEDURAL REPLICATION + ; + +logfile_descriptor + : GROUP UNSIGNED_INTEGER + | '(' filename (',' filename)* ')' + | filename + ; + +controlfile_clauses + : CREATE (LOGICAL | PHYSICAL)? STANDBY CONTROLFILE AS filename REUSE? + | BACKUP CONTROLFILE TO (filename REUSE? | trace_file_clause) + ; + +trace_file_clause + : TRACE (AS filename REUSE?)? (RESETLOGS|NORESETLOGS)? + ; + +standby_database_clauses + : ( activate_standby_db_clause + | maximize_standby_db_clause + | register_logfile_clause + | commit_switchover_clause + | start_standby_clause + | stop_standby_clause + | convert_database_clause + ) + parallel_clause? + ; + +activate_standby_db_clause + : ACTIVATE (PHYSICAL | LOGICAL)? STANDBY DATABASE (FINISH APPLY)? + ; + +maximize_standby_db_clause + : SET STANDBY DATABASE TO MAXIMIZE (PROTECTION | AVAILABILITY | PERFORMANCE) + ; + +register_logfile_clause + : REGISTER (OR REPLACE)? (PHYSICAL | LOGICAL) LOGFILE //TODO (','? file_specification)+ + //TODO (FOR logminer_session_name)? + ; + +commit_switchover_clause + : (PREPARE | COMMIT) TO SWITCHOVER + ((TO (((PHYSICAL | LOGICAL)? PRIMARY | PHYSICAL? STANDBY) + ((WITH | WITHOUT)? SESSION SHUTDOWN (WAIT | NOWAIT) )? + | LOGICAL STANDBY + ) + | LOGICAL STANDBY + ) + | CANCEL + )? + ; + +start_standby_clause + : START LOGICAL STANDBY APPLY IMMEDIATE? NODELAY? + ( NEW PRIMARY regular_id + | INITIAL scn_value=UNSIGNED_INTEGER? + | SKIP_ FAILED TRANSACTION + | FINISH + )? + ; + +stop_standby_clause + : (STOP | ABORT) LOGICAL STANDBY APPLY + ; + +convert_database_clause + : CONVERT TO (PHYSICAL | SNAPSHOT) STANDBY + ; + +default_settings_clause + : DEFAULT EDITION EQUALS_OP edition_name + | SET DEFAULT (BIGFILE | SMALLFILE) TABLESPACE + | DEFAULT TABLESPACE tablespace + | DEFAULT TEMPORARY TABLESPACE (tablespace | tablespace_group_name) + | RENAME GLOBAL_NAME TO database ('.' domain)+ + | ENABLE BLOCK CHANGE TRACKING (USING FILE filename REUSE?)? + | DISABLE BLOCK CHANGE TRACKING + | flashback_mode_clause + | set_time_zone_clause + ; + +set_time_zone_clause + : SET TIMEZONE EQUALS_OP CHAR_STRING + ; + +instance_clauses + : enable_or_disable INSTANCE CHAR_STRING + ; + +security_clause + : GUARD (ALL | STANDBY | NONE) + ; + +domain + : regular_id + ; + +database + : regular_id + ; + +edition_name + : regular_id + ; + +filenumber + : UNSIGNED_INTEGER + ; + +filename + : CHAR_STRING + ; + +prepare_clause + : PREPARE MIRROR COPY c=id_expression (WITH (UNPROTECTED | MIRROR | HIGH) REDUNDANCY)? + (FOR DATABASE id_expression)? + ; + +drop_mirror_clause + : DROP MIRROR COPY mn=id_expression + ; + +lost_write_protection + : (ENABLE | DISABLE | REMOVE | SUSPEND) LOST WRITE PROTECTION + ; + +cdb_fleet_clauses + : lead_cdb_clause + | lead_cdb_uri_clause + ; + +lead_cdb_clause + : SET LEAD_CDB '=' (TRUE | FALSE) + ; + +lead_cdb_uri_clause + : SET LEAD_CDB_URI '=' CHAR_STRING + ; + +property_clauses + : PROPERTY (SET | REMOVE) DEFAULT_CREDENTIAL '=' qcn=id_expression + ; + +replay_upgrade_clauses + : UPGRADE SYNC (ON | OFF) + ; + +alter_database_link + : ALTER SHARED? PUBLIC? DATABASE LINK link_name (CONNECT TO user_object_name IDENTIFIED BY password_value link_authentication? | link_authentication) + ; + +password_value + : id_expression + | numeric + ; + +link_authentication + : AUTHENTICATED BY user_object_name IDENTIFIED BY password_value + ; + +// added by zrh +create_database + : CREATE DATABASE database_name + ( USER (SYS | SYSTEM) IDENTIFIED BY password_value + | CONTROLFILE REUSE + | (MAXDATAFILES | MAXINSTANCES) UNSIGNED_INTEGER + | NATIONAL? CHARACTER SET char_set_name + | SET DEFAULT (BIGFILE | SMALLFILE) TABLESPACE + | database_logging_clauses + | tablespace_clauses + | set_time_zone_clause + | (BIGFILE | SMALLFILE)? USER_DATA TABLESPACE tablespace_group_name DATAFILE datafile_tempfile_spec (',' datafile_tempfile_spec)* + | enable_pluggable_database + )+ + ; + +database_logging_clauses + : LOGFILE database_logging_sub_clause (',' database_logging_sub_clause)* + | (MAXLOGFILES | MAXLOGMEMBERS | MAXLOGHISTORY) UNSIGNED_INTEGER + | ARCHIVELOG + | NOARCHIVELOG + | FORCE LOGGING + ; + +database_logging_sub_clause + : (GROUP UNSIGNED_INTEGER)? file_specification + ; + +tablespace_clauses + : EXTENT MANAGEMENT LOCAL + | SYSAUX? DATAFILE file_specification (',' file_specification)* + | default_tablespace + | default_temp_tablespace + | undo_tablespace + ; + +enable_pluggable_database + : ENABLE PLUGGABLE DATABASE (SEED file_name_convert? (SYSTEM tablespace_datafile_clauses)? (SYSAUX tablespace_datafile_clauses)? )? undo_mode_clause? + ; + +file_name_convert + : FILE_NAME_CONVERT EQUALS_OP ( '(' filename_convert_sub_clause (',' filename_convert_sub_clause)* ')' | NONE) + ; + +filename_convert_sub_clause + : CHAR_STRING (',' CHAR_STRING)? + ; + +tablespace_datafile_clauses + : DATAFILES (SIZE size_clause | autoextend_clause)+ + ; + +undo_mode_clause + : LOCAL UNDO (ON | OFF) + ; + +default_tablespace + : DEFAULT TABLESPACE tablespace (DATAFILE datafile_tempfile_spec)? extent_management_clause? + ; + +default_temp_tablespace + : (BIGFILE | SMALLFILE)? DEFAULT (TEMPORARY TABLESPACE | LOCAL TEMPORARY TABLESPACE FOR (ALL | LEAF)) tablespace + (TEMPFILE file_specification (',' file_specification)*)? extent_management_clause? + ; + +undo_tablespace + : (BIGFILE | SMALLFILE)? UNDO TABLESPACE tablespace (DATAFILE file_specification (',' file_specification)*)? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/DROP-DATABASE.html +drop_database + : DROP DATABASE (INCLUDING BACKUPS)? NOPROMPT? + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-DATABASE-LINK.html +create_database_link + : CREATE SHARED? PUBLIC? DATABASE LINK dblink ( CONNECT TO ( CURRENT_USER + | user_object_name IDENTIFIED BY password_value link_authentication? + ) + | link_authentication + )* (USING CHAR_STRING)? + ; + +dblink + : database_name ('.' d=id_expression)* ('@' cq=id_expression)? + ; + +drop_database_link + : DROP PUBLIC? DATABASE LINK dblink + ; + +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/ALTER-TABLESPACE-SET.html +alter_tablespace_set + : ALTER TABLESPACE SET tss=id_expression alter_tablespace_attrs + ; + +alter_tablespace_attrs + : default_tablespace_params + | MINIMUM EXTENT size_clause + | RESIZE size_clause + | COALESCE + | SHRINK SPACE_KEYWORD (KEEP size_clause)? + | RENAME TO nts=id_expression + | (BEGIN | END) BACKUP + | datafile_tempfile_clauses + | tablespace_logging_clauses + | tablespace_group_clause + | tablespace_state_clauses + | autoextend_clause + | flashback_mode_clause + | tablespace_retention_clause + | alter_tablespace_encryption + | lost_write_protection + ; + +alter_tablespace_encryption + : ENCRYPTION ( OFFLINE (tablespace_encryption_spec? ENCRYPT | DECRYPT) + | ONLINE (tablespace_encryption_spec? (ENCRYPT | REKEY) | DECRYPT) ts_file_name_convert? + | FINISH (ENCRYPT | REKEY | DECRYPT) ts_file_name_convert? + ) + ; + +ts_file_name_convert + : FILE_NAME_CONVERT '=' '(' CHAR_STRING ',' CHAR_STRING (',' CHAR_STRING ',' CHAR_STRING)* ')' KEEP? + ; + +alter_role + : ALTER ROLE role_name role_identified_clause container_clause? + ; + +role_identified_clause + : NOT IDENTIFIED + | IDENTIFIED ( BY identifier + | USING identifier ('.' id_expression)? + | EXTERNALLY + | GLOBALLY (AS CHAR_STRING)? + ) + ; + +alter_table + : ALTER TABLE tableview_name memoptimize_read_write_clause* + ( + | alter_table_properties + | constraint_clauses + | column_clauses + | alter_table_partitioning +//TODO | alter_external_table + | move_table_clause + ) + ((enable_disable_clause | enable_or_disable (TABLE LOCK | ALL TRIGGERS) )+)? + ';' + ; + +memoptimize_read_write_clause + : NO? MEMOPTIMIZE FOR (READ | WRITE) + ; + +alter_table_properties + : alter_table_properties_1 + | RENAME TO tableview_name + | shrink_clause + | READ ONLY + | READ WRITE + | REKEY CHAR_STRING + ; + +alter_table_partitioning + : add_table_partition + | drop_table_partition + | merge_table_partition + | modify_table_partition + | split_table_partition + | truncate_table_partition + | exchange_table_partition + | coalesce_table_partition + | alter_interval_partition + ; + + +add_table_partition + : ADD ( range_partition_desc + | list_partition_desc + | PARTITION partition_name? (TABLESPACE tablespace)? key_compression? UNUSABLE? + ) + ; + +drop_table_partition + : DROP (partition_extended_names | subpartition_extended_names) (update_index_clauses parallel_clause?)? + ; + +merge_table_partition + : MERGE PARTITION partition_name AND partition_name INTO PARTITION partition_name + ; + +modify_table_partition + : MODIFY + ( + | table_partitioning_clauses + | (PARTITION partition_name ((ADD | DROP) list_values_clause)? (ADD range_subpartition_desc)? (REBUILD? UNUSABLE LOCAL INDEXES)?) + ) + (ONLINE)? + (update_index_clauses parallel_clause?)? + ; + +split_table_partition + : SPLIT PARTITION partition_name INTO '(' + (range_partition_desc (',' range_partition_desc)* + | list_partition_desc (',' list_partition_desc)* ) + ')' + ; + +truncate_table_partition + : TRUNCATE (partition_extended_names | subpartition_extended_names) + ((DROP ALL? | REUSE)? STORAGE)? CASCADE? (update_index_clauses parallel_clause?)? + ; + +exchange_table_partition + : EXCHANGE PARTITION partition_name WITH TABLE tableview_name + ((INCLUDING | EXCLUDING) INDEXES)? + ((WITH | WITHOUT) VALIDATION)? + ; + +coalesce_table_partition + : COALESCE PARTITION parallel_clause? (allow_or_disallow CLUSTERING)? + ; + +alter_interval_partition + : SET INTERVAL '(' (constant | expression)? ')' + ; + + +partition_extended_names + : (PARTITION | PARTITIONS) ( partition_name + | '(' partition_name (',' partition_name)* ')' + | FOR '('? partition_key_value (',' partition_key_value)* ')'? ) + ; + +subpartition_extended_names + : (SUBPARTITION | SUBPARTITIONS) ( partition_name (UPDATE INDEXES)? + | '(' partition_name (',' partition_name)* ')' + | FOR '('? subpartition_key_value (',' subpartition_key_value)* ')'? ) + ; + +alter_table_properties_1 + : ( physical_attributes_clause + | logging_clause + | table_compression + | inmemory_table_clause + | supplemental_table_logging + | allocate_extent_clause + | deallocate_unused_clause + | (CACHE | NOCACHE) + | RESULT_CACHE '(' MODE (DEFAULT | FORCE) ')' + | upgrade_table_clause + | records_per_block_clause + | parallel_clause + | row_movement_clause + | flashback_archive_clause + )+ + alter_iot_clauses? + ; + +alter_iot_clauses + : index_org_table_clause + | alter_overflow_clause + | alter_mapping_table_clause + | COALESCE + ; + +alter_mapping_table_clause + : MAPPING TABLE (allocate_extent_clause | deallocate_unused_clause) + ; + +alter_overflow_clause + : add_overflow_clause + | OVERFLOW (segment_attributes_clause | allocate_extent_clause | shrink_clause | deallocate_unused_clause)+ + ; + +add_overflow_clause + : ADD OVERFLOW segment_attributes_clause? ('(' PARTITION segment_attributes_clause? (',' PARTITION segment_attributes_clause?)* ')' )? + ; + + +update_index_clauses + : update_global_index_clause + | update_all_indexes_clause + ; + +update_global_index_clause + : (UPDATE | INVALIDATE) GLOBAL INDEXES + ; + +update_all_indexes_clause + : UPDATE INDEXES ('(' update_all_indexes_index_clause ')')? + ; + +update_all_indexes_index_clause + : index_name '(' (update_index_partition | update_index_subpartition) ')' (',' update_all_indexes_clause)* + ; + +update_index_partition + : index_partition_description index_subpartition_clause? (',' update_index_partition)* + ; + +update_index_subpartition + : SUBPARTITION subpartition_name? (TABLESPACE tablespace)? (',' update_index_subpartition)* + ; + +enable_disable_clause + : (ENABLE | DISABLE) (VALIDATE | NOVALIDATE)? + (UNIQUE '(' column_name (',' column_name)* ')' + | PRIMARY KEY + | CONSTRAINT constraint_name + ) using_index_clause? exceptions_clause? + CASCADE? ((KEEP | DROP) INDEX)? + ; + +using_index_clause + : USING INDEX (index_name | '(' create_index ')' | index_attributes )? + ; + +index_attributes + : ( physical_attributes_clause + | logging_clause + | ONLINE + | TABLESPACE (tablespace | DEFAULT) + | key_compression + | sort_or_nosort + | REVERSE + | visible_or_invisible + | partial_index_clause + | parallel_clause + )+ + ; + +sort_or_nosort + : SORT + | NOSORT + ; + +exceptions_clause + : EXCEPTIONS INTO tableview_name + ; + +move_table_clause + : MOVE ONLINE? + segment_attributes_clause? + table_compression? + index_org_table_clause? + (lob_storage_clause | varray_col_properties)* + parallel_clause? + ; + +index_org_table_clause + : (mapping_table_clause | PCTTHRESHOLD UNSIGNED_INTEGER | key_compression)+ index_org_overflow_clause? + | index_org_overflow_clause // rule move_table_clause contains an optional block with at least one alternative that can match an empty string + ; + +mapping_table_clause + : MAPPING TABLE + | NOMAPPING + ; + +key_compression + : NOCOMPRESS + | COMPRESS UNSIGNED_INTEGER + ; + +index_org_overflow_clause + : (INCLUDING column_name)? OVERFLOW segment_attributes_clause? + ; + +column_clauses + : add_modify_drop_column_clauses + | rename_column_clause + | modify_collection_retrieval + | modify_lob_storage_clause + ; + +modify_collection_retrieval + : MODIFY NESTED TABLE collection_item RETURN AS (LOCATOR | VALUE) + ; + +collection_item + : tableview_name + ; + +rename_column_clause + : RENAME COLUMN old_column_name TO new_column_name + ; + +old_column_name + : column_name + ; + +new_column_name + : column_name + ; + +add_modify_drop_column_clauses + : (constraint_clauses + |add_column_clause + |modify_column_clauses + |drop_column_clause + )+ + ; + +drop_column_clause + : SET UNUSED (COLUMN column_name| ('(' column_name (',' column_name)* ')' )) (CASCADE CONSTRAINTS | INVALIDATE)* + | DROP (COLUMN column_name | '(' column_name (',' column_name)* ')' ) (CASCADE CONSTRAINTS | INVALIDATE)* (CHECKPOINT UNSIGNED_INTEGER)? + | DROP (UNUSED COLUMNS | COLUMNS CONTINUE) (CHECKPOINT UNSIGNED_INTEGER) + ; + +modify_column_clauses + : MODIFY ('(' modify_col_properties (',' modify_col_properties)* ')' + | '(' modify_col_visibility (',' modify_col_visibility) ')' + | modify_col_properties + | modify_col_visibility + | modify_col_substitutable + ) + ; + +modify_col_visibility + : column_name (VISIBLE | INVISIBLE) + ; + +modify_col_properties + : column_name datatype? (COLLATE column_collation_name)? (DEFAULT (ON NULL_)? expression)? (ENCRYPT encryption_spec | DECRYPT)? inline_constraint* lob_storage_clause? //TODO alter_xmlschema_clause + ; + +modify_col_substitutable + : COLUMN column_name NOT? SUBSTITUTABLE AT ALL LEVELS FORCE? + ; + +add_column_clause + : ADD ('(' (column_definition | virtual_column_definition) (',' (column_definition + | virtual_column_definition) + )* + ')' + | ( column_definition | virtual_column_definition )) + column_properties? +//TODO (','? out_of_line_part_storage ) + ; + +alter_varray_col_properties + : MODIFY VARRAY varray_item '(' modify_lob_parameters ')' + ; + +varray_col_properties + : VARRAY varray_item ( substitutable_column_clause? varray_storage_clause + | substitutable_column_clause + ) + ; + +varray_storage_clause + : STORE AS (SECUREFILE|BASICFILE)? LOB ( lob_segname? '(' lob_storage_parameters ')' + | lob_segname + ) + ; + +lob_segname + : regular_id + ; + +lob_item + : regular_id + | quoted_string + ; + +lob_storage_parameters + : TABLESPACE tablespace_name=id_expression | (lob_parameters storage_clause? ) + | storage_clause + ; + +lob_storage_clause + : LOB ( '(' lob_item (',' lob_item)* ')' STORE AS ( (SECUREFILE|BASICFILE) | '(' lob_storage_parameters* ')' )+ + | '(' lob_item ')' STORE AS ( (SECUREFILE | BASICFILE) | lob_segname | '(' lob_storage_parameters* ')' )+ + ) + ; + +modify_lob_storage_clause + : MODIFY LOB '(' lob_item ')' '(' modify_lob_parameters ')' + ; + +modify_lob_parameters + : ( storage_clause + | (PCTVERSION | FREEPOOLS) UNSIGNED_INTEGER + | REBUILD FREEPOOLS + | lob_retention_clause + | lob_deduplicate_clause + | lob_compression_clause + | ENCRYPT encryption_spec + | DECRYPT + | CACHE + | (CACHE | NOCACHE | CACHE READS) logging_clause? + | allocate_extent_clause + | shrink_clause + | deallocate_unused_clause + )+ + ; + +lob_parameters + : ( (ENABLE | DISABLE) STORAGE IN ROW + | CHUNK UNSIGNED_INTEGER + | PCTVERSION UNSIGNED_INTEGER + | FREEPOOLS UNSIGNED_INTEGER + | lob_retention_clause + | lob_deduplicate_clause + | lob_compression_clause + | ENCRYPT encryption_spec + | DECRYPT + | (CACHE | NOCACHE | CACHE READS) logging_clause? + )+ + ; + +lob_deduplicate_clause + : DEDUPLICATE + | KEEP_DUPLICATES + ; + +lob_compression_clause + : NOCOMPRESS + | COMPRESS (HIGH | MEDIUM | LOW)? + ; + +lob_retention_clause + : RETENTION (MAX | MIN UNSIGNED_INTEGER | AUTO | NONE)? + ; + +encryption_spec + : (USING CHAR_STRING)? + (IDENTIFIED BY REGULAR_ID)? + CHAR_STRING? (NO? SALT)? + ; +tablespace + : id_expression + ; + +varray_item + : (id_expression '.')? (id_expression '.')? id_expression + ; + +column_properties + : (object_type_col_properties + | nested_table_col_properties + | (varray_col_properties | lob_storage_clause) ('(' lob_partition_storage (',' lob_partition_storage)* ')')? //TODO '(' ( ','? lob_partition_storage)+ ')' + | xmltype_column_properties)+ + ; + +lob_partition_storage + : LOB ('(' lob_item (',' lob_item) ')' STORE AS ((SECUREFILE | BASICFILE) | '(' lob_storage_parameters ')')+ + | '(' lob_item ')' STORE AS ((SECUREFILE | BASICFILE) | lob_segname | '(' lob_storage_parameters ')')+ + ) + ; + +period_definition + : {p.isVersion12()}? PERIOD FOR column_name + ( '(' start_time_column ',' end_time_column ')' )? + ; + +start_time_column + : column_name + ; + +end_time_column + : column_name + ; + +column_definition + : column_name + ( (datatype | regular_id) (COLLATE column_collation_name)?)? + SORT? + (VISIBLE | INVISIBLE)? + (DEFAULT (ON NULL_)? expression | identity_clause)? + (ENCRYPT encryption_spec)? + (inline_constraint+ | inline_ref_constraint)? + ; + +column_collation_name + : id_expression + ; + +identity_clause + : GENERATED (ALWAYS | BY DEFAULT (ON NULL_)?)? AS IDENTITY identity_options_parentheses? + ; + +//https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-TABLE.html#GUID-F9CE0CC3-13AE-4744-A43C-EAC7A71AAAB6 +// NOTE to identity options +// according to the SQL Reference, identity_options be nested in parentheses. +// But statements without parentheses can also be executed successfully on a oracle database. +// See this issue for more details: https://github.com/antlr/grammars-v4/issues/3183 +identity_options_parentheses + : identity_options+ + | '(' identity_options+ ')' + ; + +identity_options + : START WITH (numeric | LIMIT VALUE) + | INCREMENT BY numeric + | MAXVALUE numeric + | NOMAXVALUE + | MINVALUE numeric + | NOMINVALUE + | CYCLE + | NOCYCLE + | CACHE numeric + | NOCACHE + | ORDER + | NOORDER + ; + +virtual_column_definition + : column_name (datatype COLLATE column_collation_name)? + (VISIBLE | INVISIBLE)? + autogenerated_sequence_definition? + VIRTUAL? + evaluation_edition_clause? + (UNUSABLE BEFORE (CURRENT EDITION | EDITION edition_name))? + (UNUSABLE BEGINNING WITH ((CURRENT | NULL_) EDITION | EDITION edition_name))? + inline_constraint* + ; + +autogenerated_sequence_definition + : GENERATED (ALWAYS | BY DEFAULT (ON NULL_)?)? AS IDENTITY ( '(' (sequence_start_clause | sequence_spec)* ')' )? + ; + +evaluation_edition_clause + : EVALUATE USING ((CURRENT | NULL_) EDITION | EDITION edition_name) + ; + +out_of_line_part_storage + : PARTITION partition_name + ; + +nested_table_col_properties + : NESTED TABLE (nested_item | COLUMN_VALUE) substitutable_column_clause? (LOCAL | GLOBAL)? + STORE AS tableview_name ( '(' ( '(' object_properties ')' + | physical_properties + | column_properties + )+ + ')' + )? + (RETURN AS? (LOCATOR | VALUE) )? + ; + +nested_item + : regular_id + ; + +substitutable_column_clause + : ELEMENT? IS OF TYPE? '(' type_name ')' + | NOT? SUBSTITUTABLE AT ALL LEVELS + ; + +partition_name + : regular_id + | DELIMITED_ID + ; + +supplemental_logging_props + : SUPPLEMENTAL LOG (supplemental_log_grp_clause | supplemental_id_key_clause) + ; + +column_or_attribute + : regular_id + ; + +object_type_col_properties + : COLUMN column=regular_id substitutable_column_clause + ; + +constraint_clauses + : ADD '(' (out_of_line_constraint* | out_of_line_ref_constraint) ')' + | ADD (out_of_line_constraint* | out_of_line_ref_constraint) + | MODIFY (CONSTRAINT constraint_name | PRIMARY KEY | UNIQUE '(' column_name (',' column_name)* ')') constraint_state CASCADE? + | RENAME CONSTRAINT old_constraint_name TO new_constraint_name + | drop_constraint_clause+ + ; + +old_constraint_name + : constraint_name + ; + +new_constraint_name + : constraint_name + ; + +drop_constraint_clause + : DROP drop_primary_key_or_unique_or_generic_clause + ; + +drop_primary_key_or_unique_or_generic_clause + : (PRIMARY KEY | UNIQUE '(' column_name (',' column_name)* ')') CASCADE? (KEEP | DROP)? + | CONSTRAINT constraint_name CASCADE? + ; + +add_constraint + : ADD (CONSTRAINT constraint_name)? add_constraint_clause (',' (CONSTRAINT constraint_name)? add_constraint_clause)+ + ; + +add_constraint_clause + : primary_key_clause + | foreign_key_clause + | unique_key_clause + | check_constraint + ; + +check_constraint + : CHECK '(' condition ')' DISABLE? + ; + +drop_constraint + : DROP CONSTRAINT constraint_name + ; + +enable_constraint + : ENABLE CONSTRAINT constraint_name + ; + +disable_constraint + : DISABLE CONSTRAINT constraint_name + ; + +foreign_key_clause + : FOREIGN KEY paren_column_list references_clause on_delete_clause? + ; + +references_clause + : REFERENCES tableview_name paren_column_list? (ON DELETE (CASCADE | SET NULL_))? + ; + +on_delete_clause + : ON DELETE (CASCADE | SET NULL_) + ; + +unique_key_clause + : UNIQUE paren_column_list using_index_clause? + ; + +primary_key_clause + : PRIMARY KEY paren_column_list using_index_clause? + ; + +// Anonymous PL/SQL code block + +anonymous_block + : (DECLARE seq_of_declare_specs)? BEGIN seq_of_statements (EXCEPTION exception_handler+)? END SEMICOLON + ; + +// Common DDL Clauses + +invoker_rights_clause + : AUTHID (CURRENT_USER | DEFINER) + ; + +call_spec + : LANGUAGE (java_spec | c_spec) + ; + +// Call Spec Specific Clauses + +java_spec + : JAVA NAME CHAR_STRING + ; + +c_spec + : C_LETTER (NAME CHAR_STRING)? LIBRARY identifier c_agent_in_clause? (WITH CONTEXT)? c_parameters_clause? + ; + +c_agent_in_clause + : AGENT IN '(' expressions ')' + ; + +c_parameters_clause + : PARAMETERS '(' (expressions | '.' '.' '.') ')' + ; + +parameter + : parameter_name (IN | OUT | INOUT | NOCOPY)* type_spec? default_value_part? + ; + +default_value_part + : (ASSIGN_OP | DEFAULT) expression + ; + +// Elements Declarations + +seq_of_declare_specs + : declare_spec+ + ; + +declare_spec + : pragma_declaration + | exception_declaration + | variable_declaration + | subtype_declaration + | cursor_declaration + | type_declaration + | procedure_spec + | function_spec + | procedure_body + | function_body + ; + +// incorporates constant_declaration +variable_declaration + : identifier CONSTANT? type_spec (NOT NULL_)? default_value_part? ';' + ; + +subtype_declaration + : SUBTYPE identifier IS type_spec (RANGE expression '..' expression)? (NOT NULL_)? ';' + ; + +// cursor_declaration incorportates curscursor_body and cursor_spec + +cursor_declaration + : CURSOR identifier ('(' parameter_spec (',' parameter_spec)* ')' )? (RETURN type_spec)? (IS select_statement)? ';' + ; + +parameter_spec + : parameter_name (IN? type_spec)? default_value_part? + ; + +exception_declaration + : identifier EXCEPTION ';' + ; + +pragma_declaration + : PRAGMA (SERIALLY_REUSABLE + | AUTONOMOUS_TRANSACTION + | EXCEPTION_INIT '(' exception_name ',' numeric_negative ')' + | INLINE '(' id1=identifier ',' expression ')' + | RESTRICT_REFERENCES '(' (identifier | DEFAULT) (',' identifier)+ ')') ';' + ; + +// Record Declaration Specific Clauses + +// incorporates ref_cursor_type_definition + +record_type_def + : RECORD '(' field_spec (',' field_spec)* ')' + ; + +field_spec + : column_name type_spec? (NOT NULL_)? default_value_part? + ; + +ref_cursor_type_def + : REF CURSOR (RETURN type_spec)? + ; + +type_declaration + : TYPE identifier IS (table_type_def | varray_type_def | record_type_def | ref_cursor_type_def) ';' + ; + +table_type_def + : TABLE OF type_spec table_indexed_by_part? (NOT NULL_)? + ; + +table_indexed_by_part + : (idx1=INDEXED | idx2=INDEX) BY type_spec + ; + +varray_type_def + : (VARRAY | VARYING ARRAY) '(' expression ')' OF type_spec (NOT NULL_)? + ; + +// Statements + +seq_of_statements + : (statement (';' | EOF) | label_declaration)+ + ; + +label_declaration + : ltp1= '<' '<' label_name '>' '>' + ; + +statement + : body + | block + | assignment_statement + | continue_statement + | exit_statement + | goto_statement + | if_statement + | loop_statement + | forall_statement + | null_statement + | raise_statement + | return_statement + | case_statement + | sql_statement + | pipe_row_statement + | call_statement // put call statement after others. + ; + +swallow_to_semi + : ~';'+ + ; + +assignment_statement + : (general_element | bind_variable) ASSIGN_OP expression + ; + +continue_statement + : CONTINUE label_name? (WHEN condition)? + ; + +exit_statement + : EXIT label_name? (WHEN condition)? + ; + +goto_statement + : GOTO label_name + ; + +if_statement + : IF condition THEN seq_of_statements elsif_part* else_part? END IF + ; + +elsif_part + : ELSIF condition THEN seq_of_statements + ; + +else_part + : ELSE seq_of_statements + ; + +loop_statement + : label_declaration? (WHILE condition | FOR cursor_loop_param)? LOOP seq_of_statements END LOOP label_name? + ; + +// Loop Specific Clause + +cursor_loop_param + : index_name IN REVERSE? lower_bound range_separator='..' upper_bound + | record_name IN (cursor_name ('(' expressions? ')')? | '(' select_statement ')') + ; + +forall_statement + : FORALL index_name IN bounds_clause sql_statement (SAVE EXCEPTIONS)? + ; + +bounds_clause + : lower_bound '..' upper_bound + | INDICES OF collection_name between_bound? + | VALUES OF index_name + ; + +between_bound + : BETWEEN lower_bound AND upper_bound + ; + +lower_bound + : concatenation + ; + +upper_bound + : concatenation + ; + +null_statement + : NULL_ + ; + +raise_statement + : RAISE exception_name? + ; + +return_statement + : RETURN expression? + ; + +call_statement + : CALL? routine_name function_argument? (INTO bind_variable)? + ; + +pipe_row_statement + : PIPE ROW '(' expression ')'; + +body + : BEGIN seq_of_statements (EXCEPTION exception_handler+)? END label_name? + ; + +// Body Specific Clause + +exception_handler + : WHEN exception_name (OR exception_name)* THEN seq_of_statements + ; + +trigger_block + : (DECLARE declare_spec*)? body + ; + +block + : DECLARE? declare_spec+ body + ; + +// SQL Statements + +sql_statement + : execute_immediate + | data_manipulation_language_statements + | cursor_manipulation_statements + | transaction_control_statements + ; + +execute_immediate + : EXECUTE IMMEDIATE expression (into_clause using_clause? | using_clause dynamic_returning_clause? | dynamic_returning_clause)? + ; + +// Execute Immediate Specific Clause + +dynamic_returning_clause + : (RETURNING | RETURN) into_clause + ; + +// DML Statements + +data_manipulation_language_statements + : merge_statement + | lock_table_statement + | select_statement + | update_statement + | delete_statement + | insert_statement + | explain_statement + ; + +// Cursor Manipulation Statements + +cursor_manipulation_statements + : close_statement + | open_statement + | fetch_statement + | open_for_statement + ; + +close_statement + : CLOSE cursor_name + ; + +open_statement + : OPEN cursor_name ('(' expressions? ')')? + ; + +fetch_statement + : FETCH cursor_name (it1=INTO variable_name (',' variable_name)* | BULK COLLECT INTO variable_name (',' variable_name)* (LIMIT (numeric | variable_name))?) + ; + +open_for_statement + : OPEN variable_name FOR (select_statement | expression) using_clause? + ; + +// Transaction Control SQL Statements + +transaction_control_statements + : set_transaction_command + | set_constraint_command + | commit_statement + | rollback_statement + | savepoint_statement + ; + +set_transaction_command + : SET TRANSACTION + (READ (ONLY | WRITE) | ISOLATION LEVEL (SERIALIZABLE | READ COMMITTED) | USE ROLLBACK SEGMENT rollback_segment_name)? + (NAME quoted_string)? + ; + +set_constraint_command + : SET (CONSTRAINT | CONSTRAINTS) (ALL | constraint_name (',' constraint_name)*) (IMMEDIATE | DEFERRED) + ; + +// https://docs.oracle.com/cd/E18283_01/server.112/e17118/statements_4010.htm#SQLRF01110 +// https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/COMMIT.html +commit_statement + : COMMIT WORK? + ( COMMENT CHAR_STRING write_clause? + | FORCE ( CHAR_STRING (',' numeric)? + | CORRUPT_XID CHAR_STRING + | CORRUPT_XID_ALL + ) + )? + ; + +write_clause + : WRITE (WAIT | NOWAIT)? (IMMEDIATE | BATCH)? + ; + +rollback_statement + : ROLLBACK WORK? (TO SAVEPOINT? savepoint_name | FORCE quoted_string)? + ; + +savepoint_statement + : SAVEPOINT savepoint_name + ; + +// Dml + +/* TODO +//SHOULD BE OVERRIDEN! +compilation_unit + : seq_of_statements* EOF + ; + +//SHOULD BE OVERRIDEN! +seq_of_statements + : select_statement + | update_statement + | delete_statement + | insert_statement + | lock_table_statement + | merge_statement + | explain_statement +// | case_statement[true] + ; +*/ + +explain_statement + : EXPLAIN PLAN (SET STATEMENT_ID '=' quoted_string)? (INTO tableview_name)? + FOR (select_statement | update_statement | delete_statement | insert_statement | merge_statement) + ; + +select_only_statement + : subquery + ; + +select_statement + : select_only_statement (for_update_clause | order_by_clause | offset_clause | fetch_clause)* + ; + +// Select Specific Clauses + +subquery_factoring_clause + : WITH factoring_element (',' factoring_element)* + ; + +factoring_element + : query_name paren_column_list? AS '(' subquery order_by_clause? ')' + search_clause? cycle_clause? + ; + +search_clause + : SEARCH (DEPTH | BREADTH) FIRST BY column_name ASC? DESC? (NULLS FIRST)? (NULLS LAST)? + (',' column_name ASC? DESC? (NULLS FIRST)? (NULLS LAST)?)* SET column_name + ; + +cycle_clause + : CYCLE column_list SET column_name TO expression DEFAULT expression + ; + +subquery + : subquery_basic_elements subquery_operation_part* + ; + +subquery_basic_elements + : query_block + | '(' subquery ')' + ; + +subquery_operation_part + : (UNION ALL? | INTERSECT | MINUS) subquery_basic_elements + ; + +query_block + : subquery_factoring_clause? SELECT (DISTINCT | UNIQUE | ALL)? selected_list + into_clause? from_clause where_clause? hierarchical_query_clause? group_by_clause? model_clause? order_by_clause? fetch_clause? + ; + +selected_list + : '*' + | select_list_elements (',' select_list_elements)* + ; + +from_clause + : FROM table_ref_list + ; + +select_list_elements + : table_wild + | expression column_alias? + ; + +table_wild + : tableview_name '.' ASTERISK + ; + +table_ref_list + : table_ref (',' table_ref)* + ; + +// NOTE to PIVOT clause +// according the SQL reference this should not be possible +// according to he reality it is. Here we probably apply pivot/unpivot onto whole join clause +// eventhough it is not enclosed in parenthesis. See pivot examples 09,10,11 + +table_ref + : table_ref_aux join_clause* (pivot_clause | unpivot_clause)? + ; + +table_ref_aux + : table_ref_aux_internal flashback_query_clause* ({p.IsTableAlias()}? table_alias)? + ; + +table_ref_aux_internal + : dml_table_expression_clause (pivot_clause | unpivot_clause)? # table_ref_aux_internal_one + | '(' table_ref subquery_operation_part* ')' (pivot_clause | unpivot_clause)? # table_ref_aux_internal_two + | ONLY '(' dml_table_expression_clause ')' # table_ref_aux_internal_three + ; + +join_clause + : query_partition_clause? (CROSS | NATURAL)? (INNER | outer_join_type)? + JOIN table_ref_aux query_partition_clause? (join_on_part | join_using_part)* + ; + +join_on_part + : ON condition + ; + +join_using_part + : USING paren_column_list + ; + +outer_join_type + : (FULL | LEFT | RIGHT) OUTER? + ; + +query_partition_clause + : PARTITION BY (('(' (subquery | expressions)? ')') | expressions) + ; + +flashback_query_clause + : VERSIONS BETWEEN (SCN | TIMESTAMP) expression + | AS OF (SCN | TIMESTAMP | SNAPSHOT) expression + ; + +pivot_clause + : PIVOT XML? '(' pivot_element (',' pivot_element)* pivot_for_clause pivot_in_clause ')' + ; + +pivot_element + : aggregate_function_name '(' expression ')' column_alias? + ; + +pivot_for_clause + : FOR (column_name | paren_column_list) + ; + +pivot_in_clause + : IN '(' (subquery | ANY (',' ANY)* | pivot_in_clause_element (',' pivot_in_clause_element)*) ')' + ; + +pivot_in_clause_element + : pivot_in_clause_elements column_alias? + ; + +pivot_in_clause_elements + : expression + | '(' expressions? ')' + ; + +unpivot_clause + : UNPIVOT ((INCLUDE | EXCLUDE) NULLS)? + '(' (column_name | paren_column_list) pivot_for_clause unpivot_in_clause ')' + ; + +unpivot_in_clause + : IN '(' unpivot_in_elements (',' unpivot_in_elements)* ')' + ; + +unpivot_in_elements + : (column_name | paren_column_list) + (AS (constant | '(' constant (',' constant)* ')'))? + ; + +hierarchical_query_clause + : CONNECT BY NOCYCLE? condition start_part? + | start_part CONNECT BY NOCYCLE? condition + ; + +start_part + : START WITH condition + ; + +group_by_clause + : GROUP BY group_by_elements (',' group_by_elements)* having_clause? + | having_clause (GROUP BY group_by_elements (',' group_by_elements)*)? + ; + +group_by_elements + : grouping_sets_clause + | rollup_cube_clause + | expression + ; + +rollup_cube_clause + : (ROLLUP | CUBE) '(' grouping_sets_elements (',' grouping_sets_elements)* ')' + ; + +grouping_sets_clause + : GROUPING SETS '(' grouping_sets_elements (',' grouping_sets_elements)* ')' + ; + +grouping_sets_elements + : rollup_cube_clause + | '(' expressions? ')' + | expression + ; + +having_clause + : HAVING condition + ; + +model_clause + : MODEL cell_reference_options* return_rows_clause? reference_model* main_model + ; + +cell_reference_options + : (IGNORE | KEEP) NAV + | UNIQUE (DIMENSION | SINGLE REFERENCE) + ; + +return_rows_clause + : RETURN (UPDATED | ALL) ROWS + ; + +reference_model + : REFERENCE reference_model_name ON '(' subquery ')' model_column_clauses cell_reference_options* + ; + +main_model + : (MAIN main_model_name)? model_column_clauses cell_reference_options* model_rules_clause + ; + +model_column_clauses + : model_column_partition_part? DIMENSION BY model_column_list MEASURES model_column_list + ; + +model_column_partition_part + : PARTITION BY model_column_list + ; + +model_column_list + : '(' model_column (',' model_column)* ')' + ; + +model_column + : (expression | query_block) column_alias? + ; + +model_rules_clause + : model_rules_part? '(' (model_rules_element (',' model_rules_element)*)? ')' + ; + +model_rules_part + : RULES (UPDATE | UPSERT ALL?)? ((AUTOMATIC | SEQUENTIAL) ORDER)? model_iterate_clause? + ; + +model_rules_element + : (UPDATE | UPSERT ALL?)? cell_assignment order_by_clause? '=' expression + ; + +cell_assignment + : model_expression + ; + +model_iterate_clause + : ITERATE '(' expression ')' until_part? + ; + +until_part + : UNTIL '(' condition ')' + ; + +order_by_clause + : ORDER SIBLINGS? BY order_by_elements (',' order_by_elements)* + ; + +order_by_elements + : expression (ASC | DESC)? (NULLS (FIRST | LAST))? + ; + +offset_clause + : OFFSET expression (ROW | ROWS) + ; + +fetch_clause + : FETCH (FIRST | NEXT) (expression PERCENT_KEYWORD?)? (ROW | ROWS) (ONLY | WITH TIES) + ; + +for_update_clause + : FOR UPDATE for_update_of_part? for_update_options? + ; + +for_update_of_part + : OF column_list + ; + +for_update_options + : SKIP_ LOCKED + | NOWAIT + | WAIT expression + ; + +update_statement + : UPDATE general_table_ref update_set_clause where_clause? static_returning_clause? error_logging_clause? + ; + +// Update Specific Clauses + +update_set_clause + : SET + (column_based_update_set_clause (',' column_based_update_set_clause)* | VALUE '(' identifier ')' '=' expression) + ; + +column_based_update_set_clause + : column_name '=' expression + | paren_column_list '=' subquery + | '(' column_name ')' '=' expression + ; + +delete_statement + : DELETE FROM? general_table_ref where_clause? static_returning_clause? error_logging_clause? + ; + +insert_statement + : INSERT (single_table_insert | multi_table_insert) + ; + +// Insert Specific Clauses + +single_table_insert + : insert_into_clause (values_clause static_returning_clause? | select_statement) error_logging_clause? + ; + +multi_table_insert + : (ALL multi_table_element+ | conditional_insert_clause) select_statement + ; + +multi_table_element + : insert_into_clause values_clause? error_logging_clause? + ; + +conditional_insert_clause + : (ALL | FIRST)? conditional_insert_when_part+ conditional_insert_else_part? + ; + +conditional_insert_when_part + : WHEN condition THEN multi_table_element+ + ; + +conditional_insert_else_part + : ELSE multi_table_element+ + ; + +insert_into_clause + : INTO general_table_ref paren_column_list? + ; + +values_clause + : VALUES (expression | '(' expressions ')') + ; + +merge_statement + : MERGE INTO selected_tableview USING selected_tableview ON '(' condition ')' + (merge_update_clause merge_insert_clause? | merge_insert_clause merge_update_clause?)? + error_logging_clause? + ; + +// Merge Specific Clauses + +merge_update_clause + : WHEN MATCHED THEN UPDATE SET merge_element (',' merge_element)* where_clause? merge_update_delete_part? + ; + +merge_element + : column_name '=' expression + ; + +merge_update_delete_part + : DELETE where_clause + ; + +merge_insert_clause + : WHEN NOT MATCHED THEN INSERT paren_column_list? + values_clause where_clause? + ; + +selected_tableview + : (tableview_name | '(' select_statement ')') table_alias? + ; + +lock_table_statement + : LOCK TABLE lock_table_element (',' lock_table_element)* IN lock_mode MODE wait_nowait_part? + ; + +wait_nowait_part + : WAIT expression + | NOWAIT + ; + +// Lock Specific Clauses + +lock_table_element + : tableview_name partition_extension_clause? + ; + +lock_mode + : ROW SHARE + | ROW EXCLUSIVE + | SHARE UPDATE? + | SHARE ROW EXCLUSIVE + | EXCLUSIVE + ; + +// Common DDL Clauses + +general_table_ref + : (dml_table_expression_clause | ONLY '(' dml_table_expression_clause ')') table_alias? + ; + +static_returning_clause + : (RETURNING | RETURN) expressions into_clause + ; + +error_logging_clause + : LOG ERRORS error_logging_into_part? expression? error_logging_reject_part? + ; + +error_logging_into_part + : INTO tableview_name + ; + +error_logging_reject_part + : REJECT LIMIT (UNLIMITED | expression) + ; + +dml_table_expression_clause + : table_collection_expression + | '(' select_statement subquery_restriction_clause? ')' + | tableview_name sample_clause? + | json_table_clause (AS identifier)? + ; + +table_collection_expression + : (TABLE | THE) ('(' subquery ')' | '(' expression ')' outer_join_sign?) + ; + +subquery_restriction_clause + : WITH (READ ONLY | CHECK OPTION (CONSTRAINT constraint_name)?) + ; + +sample_clause + : SAMPLE BLOCK? '(' expression (',' expression)? ')' seed_part? + ; + +seed_part + : SEED '(' expression ')' + ; + +// Expression & Condition + +condition + : expression + | json_condition + ; + +json_condition + : column_name IS NOT? JSON (FORMAT JSON)? (STRICT|LAX)? ((WITH|WITHOUT) UNIQUE KEYS)? + | JSON_EQUAL '(' expressions ')' + ; + +expressions + : expression (',' expression)* + ; + +expression + : cursor_expression + | logical_expression + ; + +cursor_expression + : CURSOR '(' subquery ')' + ; + +logical_expression + : unary_logical_expression + | logical_expression AND logical_expression + | logical_expression OR logical_expression + ; + +unary_logical_expression + : NOT? multiset_expression (IS NOT? logical_operation)* + ; + +logical_operation: + ( NULL_ + | NAN | PRESENT + | INFINITE | A_LETTER SET | EMPTY + | OF TYPE? '(' ONLY? type_spec (',' type_spec)* ')' + ) + ; + +multiset_expression + : relational_expression (multiset_type=(MEMBER | SUBMULTISET) OF? concatenation)? + ; + +relational_expression + : relational_expression relational_operator relational_expression + | compound_expression + ; + +compound_expression + : concatenation + (NOT? ( IN in_elements + | BETWEEN between_elements + | like_type=(LIKE | LIKEC | LIKE2 | LIKE4) concatenation (ESCAPE concatenation)?))? + ; + +relational_operator + : '=' + | (NOT_EQUAL_OP | '<' '>' | '!' '=' | '^' '=') + | ('<' | '>') '='? + ; + +in_elements + : '(' subquery ')' + | '(' concatenation (',' concatenation)* ')' + | constant + | bind_variable + | general_element + ; + +between_elements + : concatenation AND concatenation + ; + +concatenation + : model_expression + (AT (LOCAL | TIME ZONE concatenation) | interval_expression)? + (ON OVERFLOW (TRUNCATE | ERROR))? + | concatenation op=(ASTERISK | SOLIDUS) concatenation + | concatenation op=(PLUS_SIGN | MINUS_SIGN) concatenation + | concatenation BAR BAR concatenation + ; + +interval_expression + : DAY ('(' concatenation ')')? TO SECOND ('(' concatenation ')')? + | YEAR ('(' concatenation ')')? TO MONTH + | concatenation (SECOND | DAY | MONTH | YEAR) + ; + +model_expression + : unary_expression ('[' model_expression_element ']')? + ; + +model_expression_element + : (ANY | expression) (',' (ANY | expression))* + | single_column_for_loop (',' single_column_for_loop)* + | multi_column_for_loop + ; + +single_column_for_loop + : FOR column_name + ( IN '(' expressions? ')' + | (LIKE expression)? FROM fromExpr=expression TO toExpr=expression + action_type=(INCREMENT | DECREMENT) action_expr=expression) + ; + +multi_column_for_loop + : FOR paren_column_list + IN '(' (subquery | '(' expressions? ')') ')' + ; + +unary_expression + : ('-' | '+') unary_expression + | PRIOR unary_expression + | CONNECT_BY_ROOT unary_expression + | /*TODO {input.LT(1).getText().equalsIgnoreCase("new") && !input.LT(2).getText().equals(".")}?*/ NEW unary_expression + | DISTINCT unary_expression + | ALL unary_expression + | /*TODO{(input.LA(1) == CASE || input.LA(2) == CASE)}?*/ case_statement/*[false]*/ + | quantified_expression + | standard_function + | atom + ; + +case_statement /*TODO [boolean isStatementParameter] +TODO scope { + boolean isStatement; +} +@init {$case_statement::isStatement = $isStatementParameter;}*/ + : searched_case_statement + | simple_case_statement + ; + +// CASE + +simple_case_statement + : label_name? ck1=CASE expression simple_case_when_part+ case_else_part? END CASE? label_name? + ; + +simple_case_when_part + : WHEN expression THEN (/*TODO{$case_statement::isStatement}?*/ seq_of_statements | expression) + ; + +searched_case_statement + : label_name? ck1=CASE searched_case_when_part+ case_else_part? END CASE? label_name? + ; + +searched_case_when_part + : WHEN expression THEN (/*TODO{$case_statement::isStatement}?*/ seq_of_statements | expression) + ; + +case_else_part + : ELSE (/*{$case_statement::isStatement}?*/ seq_of_statements | expression) + ; + +atom + : table_element outer_join_sign + | bind_variable + | constant_without_variable + | general_element + | '(' subquery ')' subquery_operation_part* + | '(' expressions ')' + ; + +quantified_expression + : (SOME | EXISTS | ALL | ANY) ('(' select_only_statement ')' | '(' expression ')') + ; + +string_function + : SUBSTR '(' expression ',' expression (',' expression)? ')' + | TO_CHAR '(' (table_element | standard_function | expression) + (',' quoted_string)? (',' quoted_string)? ')' + | DECODE '(' expressions ')' + | CHR '(' concatenation USING NCHAR_CS ')' + | NVL '(' expression ',' expression ')' + | TRIM '(' ((LEADING | TRAILING | BOTH)? quoted_string? FROM)? concatenation ')' + | TO_DATE '(' (table_element | standard_function | expression) + (DEFAULT concatenation ON CONVERSION ERROR)? (',' quoted_string (',' quoted_string)? )? ')' + ; + +standard_function + : string_function + | numeric_function_wrapper + | json_function + | other_function + ; + +//see as https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/JSON_ARRAY.html#GUID-46CDB3AF-5795-455B-85A8-764528CEC43B +json_function + : JSON_ARRAY '(' json_array_element ( ',' json_array_element)* json_on_null_clause? json_return_clause? STRICT? ')' + | JSON_ARRAYAGG '(' expression (FORMAT JSON)? order_by_clause? json_on_null_clause? json_return_clause? STRICT? ')' + | JSON_OBJECT '(' json_object_content ')' + | JSON_OBJECTAGG '(' KEY? expression VALUE expression ((NULL_ | ABSENT) ON NULL_)? (RETURNING ( VARCHAR2 ('(' UNSIGNED_INTEGER ( BYTE | CHAR )? ')')? | CLOB | BLOB ))? STRICT? (WITH UNIQUE KEYS)?')' + | JSON_QUERY '(' expression (FORMAT JSON)? ',' CHAR_STRING json_query_returning_clause? json_query_wrapper_clause? json_query_on_error_clause? json_query_on_empty_clause? ')' + | JSON_SERIALIZE '(' CHAR_STRING (RETURNING json_query_return_type)? PRETTY? ASCII? TRUNCATE? ((NULL_ | ERROR | EMPTY (ARRAY | OBJECT)) ON ERROR)? ')' + | JSON_TRANSFORM '(' expression ',' json_transform_op (',' json_transform_op)* ')' + | JSON_VALUE '(' expression (FORMAT JSON)? (',' CHAR_STRING? json_value_return_clause? ((ERROR | NULL_ | DEFAULT literal)? ON ERROR)? ((ERROR | NULL_ | DEFAULT literal)? ON EMPTY)? json_value_on_mismatch_clause?')')? + ; + +json_object_content + : (json_object_entry (',' json_object_entry)* | '*') json_on_null_clause? json_return_clause? STRICT? (WITH UNIQUE KEYS)? + ; + +json_object_entry + : KEY? expression (VALUE | IS)? expression + | expression ':' expression (FORMAT JSON)? + | identifier + ; + +json_table_clause + : JSON_TABLE '(' expression (FORMAT JSON)? (',' CHAR_STRING)? ((ERROR | NULL_) ON ERROR)? ((EMPTY | NULL_) ON EMPTY)? json_column_clause? ')' + ; + +json_array_element + : (expression | CHAR_STRING | NULL_ | UNSIGNED_INTEGER | json_function) (FORMAT JSON)? + ; + +json_on_null_clause + : (NULL_ | ABSENT) ON NULL_ + ; + +json_return_clause + : RETURNING ( VARCHAR2 ('(' UNSIGNED_INTEGER ( BYTE | CHAR )? ')')? | CLOB | BLOB ) + ; + +json_transform_op + : REMOVE CHAR_STRING ((IGNORE | ERROR)? ON MISSING)? + | INSERT CHAR_STRING '=' CHAR_STRING ((REPLACE | IGNORE | ERROR) ON EXISTING)? ((NULL_ | IGNORE | ERROR | REMOVE)? ON NULL_)? + | REPLACE CHAR_STRING '=' CHAR_STRING ((CREATE | IGNORE | ERROR) ON MISSING)? ((NULL_ | IGNORE | ERROR)? ON NULL_)? + | expression (FORMAT JSON)? + | APPEND CHAR_STRING '=' CHAR_STRING ((CREATE | IGNORE | ERROR) ON MISSING)? ((NULL_ | IGNORE | ERROR)? ON NULL_)? + | SET CHAR_STRING '=' expression (FORMAT JSON)? ((REPLACE | IGNORE | ERROR) ON EXISTING)? ((CREATE | IGNORE | ERROR) ON MISSING)? ((NULL_ | IGNORE | ERROR)? ON NULL_)? + ; + +json_column_clause + : COLUMNS '(' json_column_definition (',' json_column_definition)* ')' + ; + +json_column_definition + : expression json_value_return_type? (EXISTS? PATH CHAR_STRING | TRUNCATE (PATH CHAR_STRING)?)? json_query_on_error_clause? json_query_on_empty_clause? + | expression json_query_return_type? TRUNCATE? FORMAT JSON json_query_wrapper_clause? PATH CHAR_STRING + | NESTED PATH? expression ('[' ASTERISK ']')? json_column_clause + | expression FOR ORDINALITY + ; + +json_query_returning_clause + : (RETURNING json_query_return_type)? PRETTY? ASCII? + ; + +json_query_return_type + : VARCHAR2 ('(' UNSIGNED_INTEGER ( BYTE | CHAR )? ')')? | CLOB | BLOB + ; + +json_query_wrapper_clause + : (WITHOUT ARRAY? WRAPPER) | (WITH (UNCONDITIONAL | CONDITIONAL)? ARRAY? WRAPPER) + ; + +json_query_on_error_clause + : (ERROR | NULL_ | EMPTY | EMPTY ARRAY | EMPTY OBJECT)? ON ERROR + ; + +json_query_on_empty_clause + : (ERROR | NULL_ | EMPTY | EMPTY ARRAY | EMPTY OBJECT)? ON EMPTY + ; + +json_value_return_clause + : RETURNING json_value_return_type? ASCII? + ; + +json_value_return_type + : VARCHAR2 ('(' UNSIGNED_INTEGER ( BYTE | CHAR )? ')')? TRUNCATE? + | CLOB + | DATE + | NUMBER '(' INTEGER (',' INTEGER)? ')' + | TIMESTAMP (WITH TIMEZONE)? + | SDO_GEOMETRY + | expression (USING CASESENSITIVE MAPPING)? + ; + +json_value_on_mismatch_clause + : (IGNORE | ERROR | NULL_) ON MISMATCH ('(' MISSING DATA | EXTRA DATA | TYPE ERROR ')')? + ; + +literal + : CHAR_STRING + | string_function + | numeric + | MAXVALUE + ; + +numeric_function_wrapper + : numeric_function (single_column_for_loop | multi_column_for_loop)? + ; + +numeric_function + : SUM '(' (DISTINCT | ALL)? expression ')' + | COUNT '(' ( ASTERISK | ((DISTINCT | UNIQUE | ALL)? concatenation)? ) ')' over_clause? + | ROUND '(' expression (',' UNSIGNED_INTEGER)? ')' + | AVG '(' (DISTINCT | ALL)? expression ')' + | MAX '(' (DISTINCT | ALL)? expression ')' + | LEAST '(' expressions ')' + | GREATEST '(' expressions ')' + ; + +listagg_overflow_clause + : ON OVERFLOW (ERROR | TRUNCATE) CHAR_STRING? ((WITH | WITHOUT) COUNT)? + ; + +other_function + : over_clause_keyword function_argument_analytic over_clause? + | /*TODO stantard_function_enabling_using*/ regular_id function_argument_modeling using_clause? + | COUNT '(' ( ASTERISK | (DISTINCT | UNIQUE | ALL)? concatenation) ')' over_clause? + | (CAST | XMLCAST) '(' (MULTISET '(' subquery ')' | concatenation) AS type_spec + (DEFAULT concatenation ON CONVERSION ERROR)? (',' quoted_string (',' quoted_string)? )? ')' + | COALESCE '(' table_element (',' (numeric | quoted_string))? ')' + | COLLECT '(' (DISTINCT | UNIQUE)? concatenation collect_order_by_part? ')' + | within_or_over_clause_keyword function_argument within_or_over_part+ + | LISTAGG '(' (ALL | DISTINCT | UNIQUE)? argument (',' CHAR_STRING)? listagg_overflow_clause? ')' + (WITHIN GROUP '(' order_by_clause ')')? over_clause? + | cursor_name ( PERCENT_ISOPEN | PERCENT_FOUND | PERCENT_NOTFOUND | PERCENT_ROWCOUNT ) + | DECOMPOSE '(' concatenation (CANONICAL | COMPATIBILITY)? ')' + | EXTRACT '(' regular_id FROM concatenation ')' + | (FIRST_VALUE | LAST_VALUE) function_argument_analytic respect_or_ignore_nulls? over_clause + | standard_prediction_function_keyword + '(' expressions cost_matrix_clause? using_clause? ')' + | (TO_BINARY_DOUBLE | TO_BINARY_FLOAT | TO_NUMBER | TO_TIMESTAMP | TO_TIMESTAMP_TZ) + '(' concatenation (DEFAULT concatenation ON CONVERSION ERROR)? (',' quoted_string (',' quoted_string)? )? ')' + | (TO_DSINTERVAL | TO_YMINTERVAL) '(' concatenation (DEFAULT concatenation ON CONVERSION ERROR)? ')' + | TRANSLATE '(' expression (USING (CHAR_CS | NCHAR_CS))? (',' expression)* ')' + | TREAT '(' expression AS REF? type_spec ')' + | TRIM '(' ((LEADING | TRAILING | BOTH)? quoted_string? FROM)? concatenation ')' + | VALIDATE_CONVERSION '(' concatenation AS type_spec (',' quoted_string (',' quoted_string)? )? ')' + | XMLAGG '(' expression order_by_clause? ')' ('.' general_element)? + | (XMLCOLATTVAL | XMLFOREST) + '(' xml_multiuse_expression_element (',' xml_multiuse_expression_element)* ')' ('.' general_element)? + | XMLELEMENT + '(' (ENTITYESCAPING | NOENTITYESCAPING)? (NAME | EVALNAME)? expression + (/*TODO{input.LT(2).getText().equalsIgnoreCase("xmlattributes")}?*/ ',' xml_attributes_clause)? + (',' expression column_alias?)* ')' ('.' general_element)? + | XMLEXISTS '(' expression xml_passing_clause? ')' + | XMLPARSE '(' (DOCUMENT | CONTENT) concatenation WELLFORMED? ')' ('.' general_element)? + | XMLPI + '(' (NAME identifier | EVALNAME concatenation) (',' concatenation)? ')' ('.' general_element)? + | XMLQUERY + '(' concatenation xml_passing_clause? RETURNING CONTENT (NULL_ ON EMPTY)? ')' ('.' general_element)? + | XMLROOT + '(' concatenation (',' xmlroot_param_version_part)? (',' xmlroot_param_standalone_part)? ')' ('.' general_element)? + | XMLSERIALIZE + '(' (DOCUMENT | CONTENT) concatenation (AS type_spec)? + xmlserialize_param_enconding_part? xmlserialize_param_version_part? xmlserialize_param_ident_part? ((HIDE | SHOW) DEFAULTS)? ')' + ('.' general_element)? + | TIME CHAR_STRING + | xmltable + ; + +over_clause_keyword + : AVG + | CORR + | LAG + | LAG_DIFF + | LAG_DIFF_PERCENT + | LEAD + | MAX + | MEDIAN + | MIN + | NTILE + | RATIO_TO_REPORT + | ROW_NUMBER + | SUM + | VARIANCE + | REGR_ + | STDDEV + | VAR_ + | COVAR_ + ; + +within_or_over_clause_keyword + : CUME_DIST + | DENSE_RANK + | PERCENT_RANK + | PERCENTILE_CONT + | PERCENTILE_DISC + | RANK + ; + +standard_prediction_function_keyword + : PREDICTION + | PREDICTION_BOUNDS + | PREDICTION_COST + | PREDICTION_DETAILS + | PREDICTION_PROBABILITY + | PREDICTION_SET + ; + +over_clause + : OVER '(' ( query_partition_clause? (order_by_clause windowing_clause?)? + | HIERARCHY th=id_expression OFFSET numeric (ACROSS ANCESTOR AT LEVEL id_expression)? + ) + ')' + ; + +windowing_clause + : windowing_type + (BETWEEN windowing_elements AND windowing_elements | windowing_elements) + ; + +windowing_type + : ROWS + | RANGE + ; + +windowing_elements + : UNBOUNDED PRECEDING + | CURRENT ROW + | concatenation (PRECEDING | FOLLOWING) + ; + +using_clause + : USING (ASTERISK | using_element (',' using_element)*) + ; + +using_element + : (IN OUT? | OUT)? select_list_elements + ; + +collect_order_by_part + : ORDER BY concatenation + ; + +within_or_over_part + : WITHIN GROUP '(' order_by_clause ')' + | over_clause + ; + +cost_matrix_clause + : COST (MODEL AUTO? | '(' cost_class_name (',' cost_class_name)* ')' VALUES '(' expressions? ')') + ; + +xml_passing_clause + : PASSING (BY VALUE)? expression column_alias? (',' expression column_alias?)* + ; + +xml_attributes_clause + : XMLATTRIBUTES + '(' (ENTITYESCAPING | NOENTITYESCAPING)? (SCHEMACHECK | NOSCHEMACHECK)? + xml_multiuse_expression_element (',' xml_multiuse_expression_element)* ')' + ; + +xml_namespaces_clause + : XMLNAMESPACES + '(' (concatenation column_alias)? (',' concatenation column_alias)* xml_general_default_part? ')' + ; + +xml_table_column + : xml_column_name + (FOR ORDINALITY | type_spec (PATH concatenation)? xml_general_default_part?) + ; + +xml_general_default_part + : DEFAULT concatenation + ; + +xml_multiuse_expression_element + : expression (AS (id_expression | EVALNAME concatenation))? + ; + +xmlroot_param_version_part + : VERSION (NO VALUE | expression) + ; + +xmlroot_param_standalone_part + : STANDALONE (YES | NO VALUE?) + ; + +xmlserialize_param_enconding_part + : ENCODING concatenation + ; + +xmlserialize_param_version_part + : VERSION concatenation + ; + +xmlserialize_param_ident_part + : NO INDENT + | INDENT (SIZE '=' concatenation)? + ; + +// SqlPlus + +sql_plus_command + : '/' + | EXIT + | PROMPT_MESSAGE + | SHOW (ERR | ERRORS) + | START_CMD + | whenever_command + | set_command + | timing_command + ; + +whenever_command + : WHENEVER (SQLERROR | OSERROR) + ( EXIT (SUCCESS | FAILURE | WARNING | variable_name | numeric) (COMMIT | ROLLBACK)? + | CONTINUE (COMMIT | ROLLBACK | NONE)?) + ; + +set_command + : SET regular_id (CHAR_STRING | ON | OFF | /*EXACT_NUM_LIT*/numeric | regular_id) + ; + +timing_command + : TIMING (START timing_text=id_expression* | SHOW | STOP)? + ; + +// Common + +partition_extension_clause + : (SUBPARTITION | PARTITION) FOR? '(' expressions? ')' + ; + +column_alias + : AS? (identifier | quoted_string) + | AS + ; + +table_alias + : identifier + | quoted_string + ; + +where_clause + : WHERE (CURRENT OF cursor_name | expression | quantitative_where_stmt) + ; + +quantitative_where_stmt + : expression relational_operator (SOME | ALL | ANY) '(' expression (',' expression)* ')' + ; + +into_clause + : (BULK COLLECT)? INTO (general_element | bind_variable) (',' (general_element | bind_variable))* + ; + +// Common Named Elements + +xml_column_name + : identifier + | quoted_string + ; + +cost_class_name + : identifier + ; + +attribute_name + : identifier + ; + +savepoint_name + : identifier + ; + +rollback_segment_name + : identifier + ; + +table_var_name + : identifier + ; + +schema_name + : identifier + ; + +routine_name + : identifier ('.' id_expression)* ('@' link_name)? + ; + +package_name + : identifier + ; + +implementation_type_name + : identifier ('.' id_expression)? + ; + +parameter_name + : identifier + ; + +reference_model_name + : identifier + ; + +main_model_name + : identifier + ; + +container_tableview_name + : identifier ('.' id_expression)? + ; + +aggregate_function_name + : identifier ('.' id_expression)* + ; + +query_name + : identifier + ; + +grantee_name + : id_expression identified_by? + ; + +role_name + : id_expression + | CONNECT + | RESOURCE + ; + +constraint_name + : identifier ('.' id_expression)* ('@' link_name)? + ; + +label_name + : id_expression + ; + +type_name + : id_expression ('.' id_expression)* + ; + +sequence_name + : id_expression ('.' id_expression)* + ; + +exception_name + : identifier ('.' id_expression)* + ; + +function_name + : identifier ('.' id_expression)? + ; + +procedure_name + : identifier ('.' id_expression)? + ; + +trigger_name + : identifier ('.' id_expression)? + ; + +variable_name + : (INTRODUCER char_set_name)? id_expression ('.' id_expression)? + | bind_variable + ; + +index_name + : identifier ('.' id_expression)? + ; + +cursor_name + : general_element + | bind_variable + ; + +record_name + : identifier + | bind_variable + ; + +collection_name + : identifier ('.' id_expression)? + ; + +link_name + : identifier + ; + +column_name + : identifier ('.' id_expression)* + ; + +tableview_name + : identifier ('.' id_expression)? + (AT_SIGN link_name (PERIOD link_name)* | /*TODO{!(input.LA(2) == BY)}?*/ partition_extension_clause)? + | xmltable outer_join_sign? + ; + +xmltable + : XMLTABLE '(' (xml_namespaces_clause ',')? concatenation xml_passing_clause? (COLUMNS xml_table_column (',' xml_table_column)*)? ')' ('.' general_element)? + ; + +char_set_name + : id_expression ('.' id_expression)* + ; + +synonym_name + : identifier + ; + +// Represents a valid DB object name in DDL commands which are valid for several DB (or schema) objects. +// For instance, create synonym ... for , or rename to . +// Both are valid for sequences, tables, views, etc. +schema_object_name + : id_expression + ; + +dir_object_name + : id_expression + ; + +user_object_name + : id_expression + ; + +grant_object_name + : tableview_name + | USER user_object_name (',' user_object_name)* + | DIRECTORY dir_object_name + | EDITION schema_object_name + | MINING MODEL schema_object_name + | JAVA (SOURCE | RESOURCE) schema_object_name + | SQL TRANSLATION PROFILE schema_object_name + ; + +column_list + : column_name (',' column_name)* + ; + +paren_column_list + : LEFT_PAREN column_list RIGHT_PAREN + ; + +// PL/SQL Specs + +// NOTE: In reality this applies to aggregate functions only +keep_clause + : KEEP '(' DENSE_RANK (FIRST | LAST) order_by_clause ')' over_clause? + ; + +function_argument + : '(' (argument (',' argument)*)? ')' keep_clause? + ; + +function_argument_analytic + : '(' (argument respect_or_ignore_nulls? (',' argument respect_or_ignore_nulls?)*)? ')' keep_clause? + ; + +function_argument_modeling + : '(' column_name (',' (numeric | NULL_) (',' (numeric | NULL_))?)? + USING (tableview_name '.' ASTERISK | ASTERISK | expression column_alias? (',' expression column_alias?)*) + ')' keep_clause? + ; + +respect_or_ignore_nulls + : (RESPECT | IGNORE) NULLS + ; + +argument + : (identifier '=' '>')? expression + ; + +type_spec + : datatype + | REF? type_name (PERCENT_ROWTYPE | PERCENT_TYPE)? + ; + +datatype + : native_datatype_element precision_part? (WITH LOCAL? TIME ZONE | CHARACTER SET char_set_name)? + | INTERVAL (YEAR | DAY) ('(' expression ')')? TO (MONTH | SECOND) ('(' expression ')')? + ; + +precision_part + : '(' (numeric | ASTERISK) (',' (numeric | numeric_negative))? (CHAR | BYTE)? ')' + ; + +native_datatype_element + : BINARY_INTEGER + | PLS_INTEGER + | NATURAL + | BINARY_FLOAT + | BINARY_DOUBLE + | NATURALN + | POSITIVE + | POSITIVEN + | SIGNTYPE + | SIMPLE_INTEGER + | NVARCHAR2 + | DEC + | INTEGER + | INT + | NUMERIC + | SMALLINT + | NUMBER + | DECIMAL + | DOUBLE PRECISION? + | FLOAT + | REAL + | NCHAR + | LONG RAW? + | CHAR + | CHARACTER + | VARCHAR2 + | VARCHAR + | STRING + | RAW + | BOOLEAN + | DATE + | ROWID + | UROWID + | YEAR + | MONTH + | DAY + | HOUR + | MINUTE + | SECOND + | TIMEZONE_HOUR + | TIMEZONE_MINUTE + | TIMEZONE_REGION + | TIMEZONE_ABBR + | TIMESTAMP + | TIMESTAMP_UNCONSTRAINED + | TIMESTAMP_TZ_UNCONSTRAINED + | TIMESTAMP_LTZ_UNCONSTRAINED + | YMINTERVAL_UNCONSTRAINED + | DSINTERVAL_UNCONSTRAINED + | BFILE + | BLOB + | CLOB + | NCLOB + | MLSLABEL + ; + +bind_variable + : (BINDVAR | ':' UNSIGNED_INTEGER) + // Pro*C/C++ indicator variables + (INDICATOR? (BINDVAR | ':' UNSIGNED_INTEGER))? + ('.' general_element)? + ; + +general_element + : general_element_part ('.' general_element_part)* + ; + +// general_element_part contains the variable_name rule. +general_element_part + : (INTRODUCER char_set_name)? id_expression ('@' link_name)? function_argument? + ; + +table_element + : (INTRODUCER char_set_name)? id_expression ('.' id_expression)* + ; + +object_privilege + : ALL PRIVILEGES? + | ALTER + | DEBUG + | DELETE + | EXECUTE + | FLASHBACK ARCHIVE + | INDEX + | INHERIT PRIVILEGES + | INSERT + | KEEP SEQUENCE + | MERGE VIEW + | ON COMMIT REFRESH + | QUERY REWRITE + | READ + | REFERENCES + | SELECT + | TRANSLATE SQL + | UNDER + | UPDATE + | USE + | WRITE + ; + +//Ordered by type rather than alphabetically +system_privilege + : ALL PRIVILEGES + | ADVISOR + | ADMINISTER ANY? SQL TUNING SET + | (ALTER | CREATE | DROP) ANY SQL PROFILE + | ADMINISTER SQL MANAGEMENT OBJECT + | CREATE ANY? CLUSTER + | (ALTER | DROP) ANY CLUSTER + | (CREATE | DROP) ANY CONTEXT + | EXEMPT REDACTION POLICY + | ALTER DATABASE + | (ALTER | CREATE) PUBLIC? DATABASE LINK + | DROP PUBLIC DATABASE LINK + | DEBUG CONNECT SESSION + | DEBUG ANY PROCEDURE + | ANALYZE ANY DICTIONARY + | CREATE ANY? DIMENSION + | (ALTER | DROP) ANY DIMENSION + | (CREATE | DROP) ANY DIRECTORY + | (CREATE | DROP) ANY EDITION + | FLASHBACK (ARCHIVE ADMINISTER | ANY TABLE) + | (ALTER | CREATE | DROP) ANY INDEX + | CREATE ANY? INDEXTYPE + | (ALTER | DROP | EXECUTE) ANY INDEXTYPE + | CREATE (ANY | EXTERNAL)? JOB + | EXECUTE ANY (CLASS | PROGRAM) + | MANAGE SCHEDULER + | ADMINISTER KEY MANAGEMENT + | CREATE ANY? LIBRARY + | (ALTER | DROP | EXECUTE) ANY LIBRARY + | LOGMINING + | CREATE ANY? MATERIALIZED VIEW + | (ALTER | DROP) ANY MATERIALIZED VIEW + | GLOBAL? QUERY REWRITE + | ON COMMIT REFRESH + | CREATE ANY? MINING MODEL + | (ALTER | DROP | SELECT | COMMENT) ANY MINING MODEL + | CREATE ANY? CUBE + | (ALTER | DROP | SELECT | UPDATE) ANY CUBE + | CREATE ANY? MEASURE FOLDER + | (DELETE | DROP | INSERT) ANY MEASURE FOLDER + | CREATE ANY? CUBE DIMENSION + | (ALTER | DELETE | DROP | INSERT | SELECT | UPDATE) ANY CUBE DIMENSION + | CREATE ANY? CUBE BUILD PROCESS + | (DROP | UPDATE) ANY CUBE BUILD PROCESS + | CREATE ANY? OPERATOR + | (ALTER | DROP | EXECUTE) ANY OPERATOR + | (CREATE | ALTER | DROP) ANY OUTLINE + | CREATE PLUGGABLE DATABASE + | SET CONTAINER + | CREATE ANY? PROCEDURE + | (ALTER | DROP | EXECUTE) ANY PROCEDURE + | (CREATE | ALTER | DROP ) PROFILE + | CREATE ROLE + | (ALTER | DROP | GRANT) ANY ROLE + | (CREATE | ALTER | DROP) ROLLBACK SEGMENT + | CREATE ANY? SEQUENCE + | (ALTER | DROP | SELECT) ANY SEQUENCE + | (ALTER | CREATE | RESTRICTED) SESSION + | ALTER RESOURCE COST + | CREATE ANY? SQL TRANSLATION PROFILE + | (ALTER | DROP | USE) ANY SQL TRANSLATION PROFILE + | TRANSLATE ANY SQL + | CREATE ANY? SYNONYM + | DROP ANY SYNONYM + | (CREATE | DROP) PUBLIC SYNONYM + | CREATE ANY? TABLE + | (ALTER | BACKUP | COMMENT | DELETE | DROP | INSERT | LOCK | READ | SELECT | UPDATE) ANY TABLE + | (CREATE | ALTER | DROP | MANAGE | UNLIMITED) TABLESPACE + | CREATE ANY? TRIGGER + | (ALTER | DROP) ANY TRIGGER + | ADMINISTER DATABASE TRIGGER + | CREATE ANY? TYPE + | (ALTER | DROP | EXECUTE | UNDER) ANY TYPE + | (CREATE | ALTER | DROP) USER + | CREATE ANY? VIEW + | (DROP | UNDER | MERGE) ANY VIEW + | (ANALYZE | AUDIT) ANY + | BECOME USER + | CHANGE NOTIFICATION + | EXEMPT ACCESS POLICY + | FORCE ANY? TRANSACTION + | GRANT ANY OBJECT? PRIVILEGE + | INHERIT ANY PRIVILEGES + | KEEP DATE TIME + | KEEP SYSGUID + | PURGE DBA_RECYCLEBIN + | RESUMABLE + | SELECT ANY (DICTIONARY | TRANSACTION) + | SYSBACKUP + | SYSDBA + | SYSDG + | SYSKM + | SYSOPER + ; + +// $> + +// $ false ); +end; +/ + +begin + green_tools.print_green_info( p_with_brackets => true ); +end; +/ diff --git a/plsql/examples-sql-script/in_out_parameters.pks b/plsql/examples-sql-script/in_out_parameters.pks new file mode 100644 index 0000000..56193cb --- /dev/null +++ b/plsql/examples-sql-script/in_out_parameters.pks @@ -0,0 +1,15 @@ +create or replace package in_out_parameters +is + + procedure some_procedure( p_string varchar2 ); + + procedure some_in_procedure( p_string in varchar2 ); + + procedure some_out_procedure( p_string out varchar2 ); + + procedure some_in_out_procedure( p_string in out varchar2 ); + + procedure some_in_out_nocopy_procedure( p_string in out nocopy varchar2 ); + +end in_out_parameters; +/ diff --git a/plsql/examples-sql-script/key_word_as_param.pkb b/plsql/examples-sql-script/key_word_as_param.pkb new file mode 100644 index 0000000..407fc44 --- /dev/null +++ b/plsql/examples-sql-script/key_word_as_param.pkb @@ -0,0 +1,13 @@ +create or replace package body login +as + +function fun return varchar2 +as + raw_key2 raw(128); + raw_userpass raw(128); + raw_encrypted raw(2048); +begin + dbms_obfuscation_toolkit.desencrypt(input => raw_userpass, key => raw_key2, encrypted_data => raw_encrypted); +end fun; + +end; \ No newline at end of file diff --git a/plsql/examples-sql-script/package_body_null.pkb b/plsql/examples-sql-script/package_body_null.pkb new file mode 100644 index 0000000..3bf16ed --- /dev/null +++ b/plsql/examples-sql-script/package_body_null.pkb @@ -0,0 +1,5 @@ +create or replace package body pkgtest is +begin + null; +end; +/ diff --git a/plsql/examples-sql-script/package_with_cursor.sql b/plsql/examples-sql-script/package_with_cursor.sql new file mode 100644 index 0000000..1915089 --- /dev/null +++ b/plsql/examples-sql-script/package_with_cursor.sql @@ -0,0 +1,34 @@ +create or replace package pkgtest is + + cursor cuData is + select * from dual; + + procedure main; +end; +/ + +create or replace package body pkgtest is + procedure main is + sbData varchar2(100); + begin + open pkgtest.cuData; + fetch cuData into sbData; + close cuData; + + if cuData%isopen then + dbms_output.put_line('should work'); + end if; + + if sql%rowcount > 0 then + dbms_output.put_line('should work too'); + end if; + end; + + function GETPOS_TEMPLATE_DEF_ID return VARCHAR2 is + LVS_ID VARCHAR2(4000 CHAR); + BEGIN + LVS_ID := TRIM(BOTH SF_FORM_EXT_CONSTANTS.GETSOMETHING FROM LVS_ID); + return LVS_ID; + end GETPOS_TEMPLATE_DEF_ID; +end; +/ diff --git a/plsql/examples-sql-script/package_with_schema.pkb b/plsql/examples-sql-script/package_with_schema.pkb new file mode 100644 index 0000000..1ff4505 --- /dev/null +++ b/plsql/examples-sql-script/package_with_schema.pkb @@ -0,0 +1,8 @@ +CREATE OR REPLACE PACKAGE BODY HR.PACK +AS +PROCEDURE PROC1 +AS +BEGIN + NULL; +END; +END; \ No newline at end of file diff --git a/plsql/examples-sql-script/package_with_schema.pks b/plsql/examples-sql-script/package_with_schema.pks new file mode 100644 index 0000000..8f612d9 --- /dev/null +++ b/plsql/examples-sql-script/package_with_schema.pks @@ -0,0 +1,4 @@ +CREATE OR REPLACE PACKAGE HR.PACK +AS +PROCEDURE PROC1; +END; \ No newline at end of file diff --git a/plsql/examples-sql-script/pipe_row.pkb b/plsql/examples-sql-script/pipe_row.pkb new file mode 100644 index 0000000..011d8eb --- /dev/null +++ b/plsql/examples-sql-script/pipe_row.pkb @@ -0,0 +1,25 @@ +create or replace package body pipe_row_test as + +function fun return t_tab pipelined +as + vRow t_tab_row; +begin + for rec in ( select Id from tbl ) + loop + vrow.Id := rec.Id; + pipe row (vrow); + end loop; + +end; + + +function prodfunc(n number) return mytabletype pipelined is +begin + <> + for i in 1 .. 5 loop + pipe row (myobjectformat(n,sysdate+i,'row '||i)); + end loop pipes; + return; +end; + +end; \ No newline at end of file diff --git a/plsql/examples-sql-script/pltables.sql b/plsql/examples-sql-script/pltables.sql new file mode 100644 index 0000000..85a13d9 --- /dev/null +++ b/plsql/examples-sql-script/pltables.sql @@ -0,0 +1,14 @@ +declare + TYPE tyrcmessage IS RECORD (id number, message varchar2(100)); + TYPE tytbMessages IS TABLE OF tyrcmessage INDEX BY BINARY_INTEGER; + + tbmessages tytbMessages; + nuidx number; + +begin + nuidx := tbmessages.first; + while nuidx is not null loop + nuidx := tbmessages.next(nuidx); + end loop; +end; +/ diff --git a/plsql/examples-sql-script/pragma_autonomous_transaction.sql b/plsql/examples-sql-script/pragma_autonomous_transaction.sql new file mode 100644 index 0000000..60aff3f --- /dev/null +++ b/plsql/examples-sql-script/pragma_autonomous_transaction.sql @@ -0,0 +1,6 @@ +declare + pragma autonomous_transaction; +begin + commit; +end; +/ diff --git a/plsql/examples-sql-script/pragma_exception_init.pks b/plsql/examples-sql-script/pragma_exception_init.pks new file mode 100644 index 0000000..cca9d75 --- /dev/null +++ b/plsql/examples-sql-script/pragma_exception_init.pks @@ -0,0 +1,8 @@ +create or replace package pragma_exception_init +is + + some_exception exception; + pragma exception_init (some_exception, -20001); + +end pragma_exception_init; +/ diff --git a/plsql/examples-sql-script/proc_over_dblink_as_nvl_param.pkb b/plsql/examples-sql-script/proc_over_dblink_as_nvl_param.pkb new file mode 100644 index 0000000..8f5dd36 --- /dev/null +++ b/plsql/examples-sql-script/proc_over_dblink_as_nvl_param.pkb @@ -0,0 +1,14 @@ +create or replace package body pack as + +procedure test(inId number) +as + vSum number; + vPaymentsDate number; +begin + + vSum := nvl(pack_1.getSum@dblink(inId=>inId, vPaymentsDate => pack_2.getLastDay(4, 3)), 0); + +end; + + +end; \ No newline at end of file diff --git a/plsql/examples-sql-script/procedure_with_cursor_and_limit.sql b/plsql/examples-sql-script/procedure_with_cursor_and_limit.sql new file mode 100644 index 0000000..da0f163 --- /dev/null +++ b/plsql/examples-sql-script/procedure_with_cursor_and_limit.sql @@ -0,0 +1,42 @@ +CREATE OR REPLACE PROCEDURE SF_JOB_CLEANUP_SHOWCASES_START (FPN_ANZ_ZUM_VERARBEITEN NUMBER DEFAULT 10000, FPN_BULK_LIMIT NUMBER DEFAULT 5000) AS + + TYPE T_BULK_TAB IS RECORD ( + SC_ID SALESFRONT.SF_SHOWCASE.ID%TYPE, + JOBLIST_ID SF_JOB_CLEANUP_SHOWCASES_SCLIST.ID%TYPE + ); + TYPE T_BULK_COLLECT_TAB IS TABLE OF T_BULK_TAB; + + LNC_ID_LIST T_BULK_COLLECT_TAB; + + COUNTER PLS_INTEGER := 0; + LVNEXISTS PLS_INTEGER := 0; + LVSERRORMSG VARCHAR2(4000); + + CURSOR C_DEL_SC(C_MAX_ROW NUMBER) IS + SELECT SC.ID SC_ID , SL.ID JOBLIST_ID FROM SF_JOB_CLEANUP_SHOWCASES_SCLIST SL + INNER JOIN SALESFRONT.SF_SHOWCASE SC ON SC.ID = SL.SF_SHOWCASE_ID + WHERE SL.VERARBEITEN = 1 + AND VERARBEITET_AM IS NULL + AND ROWNUM < C_MAX_ROW; + +BEGIN + EXECUTE IMMEDIATE 'SELECT COUNT(*) FROM USER_SCHEDULER_JOBS JO WHERE JOB_NAME=''SF_START_TOURENEXPORT'' AND JO.STATE = ''RUNNING''' + INTO LVNEXISTS; + + IF LVNEXISTS = 0 THEN + OPEN C_DEL_SC(FPN_ANZ_ZUM_VERARBEITEN); + LOOP + --IN BLÖCKEN AUS PERFORMANCE GRÜNDEN + FETCH C_DEL_SC BULK COLLECT INTO LNC_ID_LIST LIMIT FPN_BULK_LIMIT; + COUNTER := COUNTER + LNC_ID_LIST.COUNT; + EXIT WHEN C_DEL_SC%NOTFOUND; + + COMMIT; + END LOOP; + CLOSE C_DEL_SC; + END IF; + +EXCEPTION WHEN OTHERS THEN + LVSERRORMSG := SQLERRM || ' BACKTRACE: ' || DBMS_UTILITY.FORMAT_ERROR_BACKTRACE; + ROLLBACK; +END; \ No newline at end of file diff --git a/plsql/examples-sql-script/result_cache_function.pks b/plsql/examples-sql-script/result_cache_function.pks new file mode 100644 index 0000000..84213d1 --- /dev/null +++ b/plsql/examples-sql-script/result_cache_function.pks @@ -0,0 +1,7 @@ +create or replace package result_cache_function +is + + function some_function( p_string in varchar2 ) return varchar2 result_cache; + +end result_cache_function; +/ diff --git a/plsql/examples-sql-script/select_into.sql b/plsql/examples-sql-script/select_into.sql new file mode 100644 index 0000000..6c2e5e5 --- /dev/null +++ b/plsql/examples-sql-script/select_into.sql @@ -0,0 +1,21 @@ +DECLARE + TYPE T2 IS RECORD (C NUMBER); + TYPE T1 IS RECORD (B T2); + A T1; + + TYPE T3 IS TABLE OF NUMBER INDEX BY BINARY_INTEGER; + D T3; +BEGIN + SELECT 1 + INTO A.B.C + FROM DUAL; + + SELECT 1 + INTO D(1) + FROM DUAL; + + SELECT 1 + INTO :BLOCK.ITEM + FROM DUAL; +END; +/ diff --git a/plsql/examples-sql-script/show_errors.pks b/plsql/examples-sql-script/show_errors.pks new file mode 100644 index 0000000..d400b7e --- /dev/null +++ b/plsql/examples-sql-script/show_errors.pks @@ -0,0 +1,19 @@ +create or replace package show_errors +is + + procedure some_procedure; + +end show_errors; +/ + +show errors + +create or replace package show_errors +is + + procedure some_procedure; + +end show_errors; +/ + +show err diff --git a/plsql/examples-sql-script/substr_as_regular_id.pkb b/plsql/examples-sql-script/substr_as_regular_id.pkb new file mode 100644 index 0000000..7a018dc --- /dev/null +++ b/plsql/examples-sql-script/substr_as_regular_id.pkb @@ -0,0 +1,10 @@ +create or replace package body testPack as + +function blob_to_clob (blob_in in blob) return clob +as +begin + utl_raw.cast_to_varchar2(dbms_lob.substr(a, b, c)); + return null; +end blob_to_clob; + +end testPack; \ No newline at end of file diff --git a/plsql/examples-sql-script/synonym_with_database_link.sql b/plsql/examples-sql-script/synonym_with_database_link.sql new file mode 100644 index 0000000..1875acc --- /dev/null +++ b/plsql/examples-sql-script/synonym_with_database_link.sql @@ -0,0 +1 @@ +create or replace synonym rs_customer2Prs for SCHEMANAME.CUSTOMER2PRS@SCHEMANAME.LINKNAME; \ No newline at end of file diff --git a/plsql/examples-sql-script/trigger_examples.sql b/plsql/examples-sql-script/trigger_examples.sql new file mode 100644 index 0000000..f0ff953 --- /dev/null +++ b/plsql/examples-sql-script/trigger_examples.sql @@ -0,0 +1,12 @@ +create or replace trigger trg_status_tick + after insert or update or delete on status for each row +declare +begin + if inserting then + tp_ticket_util.fire('status', tp_ticket_const.cinsert, :new.id); + elsif updating then + tp_ticket_util.fire('status', tp_ticket_const.cupdate, :new.id); + elsif deleting then + tp_ticket_util.fire('status', tp_ticket_const.cdelete, :old.id); + end if; +end; \ No newline at end of file diff --git a/plsql/examples-sql-script/type_body_elements.sql b/plsql/examples-sql-script/type_body_elements.sql new file mode 100644 index 0000000..d2394dc --- /dev/null +++ b/plsql/examples-sql-script/type_body_elements.sql @@ -0,0 +1,32 @@ +create or replace type type_body_elements +as object +( + some_string varchar2(64), + member function function_one + return varchar2, + member function function_two + return varchar2 +); +/ + +create or replace type body type_body_elements +is + + member function function_one + return varchar2 + is + begin + return 'the function_one result'; + end function_one; + + member function function_two + return varchar2 + is + begin + return 'the function_two result'; + end function_two; + +end; +/ +create or replace TYPE CLNOBJREPORTCOLUMN force is table of varchar2(4000); +/ \ No newline at end of file diff --git a/plsql/examples-sql-script/user.sql b/plsql/examples-sql-script/user.sql new file mode 100644 index 0000000..4f0e83e --- /dev/null +++ b/plsql/examples-sql-script/user.sql @@ -0,0 +1,9 @@ +CREATE USER scott + IDENTIFIED BY tiger + DEFAULT TABLESPACE USERS + TEMPORARY TABLESPACE TEMP + PROFILE SCOTT_PROFILE + ACCOUNT UNLOCK; + +-- 1 Tablespace Quota for scott +ALTER USER scott QUOTA 5000M ON USERS; diff --git a/plsql/examples-sql-script/with_clause_in_exists_block_in_procedure.sql b/plsql/examples-sql-script/with_clause_in_exists_block_in_procedure.sql new file mode 100644 index 0000000..dee8fb2 --- /dev/null +++ b/plsql/examples-sql-script/with_clause_in_exists_block_in_procedure.sql @@ -0,0 +1,18 @@ +CREATE OR REPLACE PROCEDURE PROCESS_QUEUE(FPN_DATENQUELLE_ID NUMBER DEFAULT NULL) IS + BEGIN + DELETE + FROM TP_TICKET_RAW DEL_T + WHERE EXISTS ( + WITH BASIS AS (SELECT * FROM TP_TICKET_RAW TT) + SELECT NULL + FROM BASIS BA + WHERE EXISTS (SELECT NULL + FROM BASIS BE + WHERE BE.TABLE_NAME = BA.TABLE_NAME + AND BE.TP_TICKET_ART_ID = BA.TP_TICKET_ART_ID + AND BE.REF_ID = BA.REF_ID + AND BA.CREATION_DATE > BE.CREATION_DATE) + AND DEL_T.ID = BA.ID + ); + COMMIT; + END PROCESS_QUEUE; \ No newline at end of file diff --git a/plsql/examples/administer_key_management.sql b/plsql/examples/administer_key_management.sql new file mode 100644 index 0000000..5432145 --- /dev/null +++ b/plsql/examples/administer_key_management.sql @@ -0,0 +1,133 @@ +ADMINISTER KEY MANAGEMENT MOVE KEYS +TO NEW KEYSTORE '$ORACLE_BASE/admin/orcl/wallet' +IDENTIFIED BY "pass" +FROM FORCE KEYSTORE +IDENTIFIED BY "pass" +WITH IDENTIFIER IN +(SELECT KEY_ID FROM V$ENCRYPTION_KEYS WHERE ROWNUM < 2); + +ADMINISTER KEY MANAGEMENT + SWITCHOVER TO LIBRARY 'updated_fully_qualified_file_name_of_library' FOR ALL CONTAINERS; + +ADMINISTER KEY MANAGEMENT + CREATE KEYSTORE '/etc/ORACLE/WALLETS/orcl' + IDENTIFIED BY "pass"; + +ADMINISTER KEY MANAGEMENT + CREATE AUTO_LOGIN KEYSTORE FROM KEYSTORE '/etc/ORACLE/WALLETS/orcl' + IDENTIFIED BY "pass"; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE OPEN + IDENTIFIED BY "pass"; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE OPEN + IDENTIFIED BY "pass" + CONTAINER = CURRENT; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE OPEN + IDENTIFIED BY "user_id:password"; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE OPEN + IDENTIFIED BY EXTERNAL STORE; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE CLOSE + IDENTIFIED BY "pass"; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE CLOSE; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE CLOSE + IDENTIFIED BY "user_id:password"; + +ADMINISTER KEY MANAGEMENT +SET KEYSTORE CLOSE + IDENTIFIED BY EXTERNAL STORE; + +ADMINISTER KEY MANAGEMENT + BACKUP KEYSTORE USING 'hr.emp_keystore' + IDENTIFIED BY "password" + TO '/etc/ORACLE/KEYSTORE/DB1/'; + +ADMINISTER KEY MANAGEMENT + ALTER KEYSTORE PASSWORD IDENTIFIED BY "old_password" +SET "new_password" WITH BACKUP USING 'pwd_change'; + +ADMINISTER KEY MANAGEMENT +MERGE KEYSTORE '/etc/ORACLE/KEYSTORE/DB1' + AND KEYSTORE '/etc/ORACLE/KEYSTORE/DB2' + IDENTIFIED BY "old-pass" +INTO NEW KEYSTORE '/etc/ORACLE/KEYSTORE/DB3' + IDENTIFIED BY "new-pass"; + +ADMINISTER KEY MANAGEMENT +MERGE KEYSTORE '/etc/ORACLE/KEYSTORE/DB1' +INTO EXISTING KEYSTORE '/etc/ORACLE/KEYSTORE/DB2' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT +SET KEY USING ALGORITHM 'SEED128' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT + CREATE KEY USING TAG 'mykey1' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT +USE KEY 'ARgEtzPxpE/Nv8WdPu8LJJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT +SET TAG 'mykey2' FOR 'ARgEtzPxpE/Nv8WdPu8LJJUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + FORCE KEYSTORE + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT + EXPORT KEYS WITH SECRET "my_secret" + TO '/etc/TDE/export.exp' + IDENTIFIED BY "password" +WITH IDENTIFIER IN 'AdoxnJ0uH08cv7xkz83ovwsAAAAAAAAAAAAAAAAAAAAAAAAAAAAA', + 'AW5z3CoyKE/yv3cNT5CWCXUAAAAAAAAAAAAAAAAAAAAAAAAAAAAA'; + +ADMINISTER KEY MANAGEMENT + EXPORT KEYS WITH SECRET "my_secret" + TO '/etc/TDE/export.exp' + IDENTIFIED BY "pass" +WITH IDENTIFIER IN +(SELECT KEY_ID FROM V$ENCRYPTION_KEYS WHERE TAG IN ('mytag1', 'mytag2')); + +ADMINISTER KEY MANAGEMENT + EXPORT KEYS WITH SECRET "my_secret" + TO '/etc/TDE/export.exp' + IDENTIFIED BY "pass"; + +ADMINISTER KEY MANAGEMENT + IMPORT KEYS WITH SECRET "my_secret" + FROM '/etc/TDE/export.exp' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT +SET ENCRYPTION KEY IDENTIFIED BY "software_keystore_password" + REVERSE MIGRATE USING "user_id:password"; + +ADMINISTER KEY MANAGEMENT + ADD SECRET 'secret1' FOR CLIENT 'client1' + USING TAG 'My first secret' + IDENTIFIED BY "pass" +WITH BACKUP; + +ADMINISTER KEY MANAGEMENT + ADD SECRET 'secret2' FOR CLIENT 'client2' + USING TAG 'My second secret' + IDENTIFIED BY "user_id:password"; diff --git a/plsql/examples/alter_analytic_view.sql b/plsql/examples/alter_analytic_view.sql new file mode 100644 index 0000000..39ed0c8 --- /dev/null +++ b/plsql/examples/alter_analytic_view.sql @@ -0,0 +1,5 @@ +ALTER ANALYTIC VIEW sales_av RENAME TO mysales_av; + +ALTER ANALYTIC VIEW TKHCSGL308_UNITS_AVIEW_CACHE ADD CACHE + MEASURE GROUP (sales, units, cost) + LEVELS (TIME.FISCAL.FISCAL_QUARTER, WAREHOUSE); diff --git a/plsql/examples/alter_attribute_dimension.sql b/plsql/examples/alter_attribute_dimension.sql new file mode 100644 index 0000000..8334715 --- /dev/null +++ b/plsql/examples/alter_attribute_dimension.sql @@ -0,0 +1 @@ +ALTER ATTRIBUTE DIMENSION product_attr_dim RENAME TO my_product_attr_dim; diff --git a/plsql/examples/alter_audit_policy.sql b/plsql/examples/alter_audit_policy.sql new file mode 100644 index 0000000..311a416 --- /dev/null +++ b/plsql/examples/alter_audit_policy.sql @@ -0,0 +1,34 @@ +ALTER AUDIT POLICY hr_audit_policy ADD ONLY TOPLEVEL; +ALTER AUDIT POLICY hr_audit_policy DROP ONLY TOPLEVEL; +ALTER AUDIT POLICY dml_pol + ADD PRIVILEGES CREATE ANY TABLE, DROP ANY TABLE; +ALTER AUDIT POLICY java_pol + ADD ACTIONS CREATE JAVA, ALTER JAVA, DROP JAVA; +ALTER AUDIT POLICY table_pol + ADD ROLES dba; +ALTER AUDIT POLICY security_pol + ADD PRIVILEGES CREATE ANY LIBRARY, DROP ANY LIBRARY + ACTIONS DELETE on hr.employees, +INSERT on hr.employees, +UPDATE on hr.employees, + ALL on hr.departments + ROLES dba, connect; +ALTER AUDIT POLICY table_pol + DROP PRIVILEGES CREATE ANY TABLE; +ALTER AUDIT POLICY dml_pol + DROP ACTIONS INSERT on hr.employees, +UPDATE on hr.employees; +ALTER AUDIT POLICY java_pol + DROP ROLES java_deploy; +ALTER AUDIT POLICY hr_admin_pol + DROP PRIVILEGES CREATE ANY TABLE + ACTIONS LOCK TABLE + ROLES audit_viewer; +ALTER AUDIT POLICY dp_actions_pol + ADD ACTIONS COMPONENT = datapump EXPORT + DROP ACTIONS COMPONENT = datapump IMPORT; +ALTER AUDIT POLICY order_updates_pol + CONDITION DROP; +ALTER AUDIT POLICY emp_updates_pol + CONDITION 'UID = 102' + EVALUATE PER STATEMENT; diff --git a/plsql/examples/alter_database.sql b/plsql/examples/alter_database.sql new file mode 100644 index 0000000..0317dff --- /dev/null +++ b/plsql/examples/alter_database.sql @@ -0,0 +1,49 @@ +ALTER DATABASE testdb + DATAFILE '+dgroup_01/testdb/datafile/system.261.1' ONLINE; +ALTER DATABASE OPEN READ ONLY; +ALTER DATABASE + RECOVER TABLESPACE tbs_03 + PARALLEL; +ALTER DATABASE + ADD LOGFILE GROUP 3 + ('diska:log3.log' , + 'diskb:log3.log') SIZE 50K; +ALTER DATABASE + ADD LOGFILE THREAD 5 GROUP 4 + ('diska:log4.log', + 'diskb:log4:log'); +ALTER DATABASE + ADD LOGFILE MEMBER 'diskc:log3.log' + TO GROUP 3; +ALTER DATABASE + DROP LOGFILE MEMBER 'diskb:log3.log'; +ALTER DATABASE DROP LOGFILE GROUP 3; +ALTER DATABASE + RENAME FILE 'diskc:log3.log' TO 'diskb:log3.log'; +ALTER DATABASE + SET DEFAULT BIGFILE TABLESPACE; +ALTER DATABASE + DEFAULT TEMPORARY TABLESPACE tbs_05; +ALTER DATABASE TEMPFILE 'temp02.dbf' OFFLINE; +ALTER DATABASE RENAME FILE 'temp02.dbf' TO 'temp03.dbf'; +ALTER DATABASE + RENAME GLOBAL_NAME TO demo.world.oracle.com; +ALTER DATABASE + ENABLE BLOCK CHANGE TRACKING + USING FILE 'tracking_file' REUSE; +ALTER DATABASE + DISABLE BLOCK CHANGE TRACKING; +ALTER DATABASE + DATAFILE 'diskb:tbs_f5.dat' RESIZE 10 M; +ALTER DATABASE + CLEAR LOGFILE 'diskc:log3.log'; +ALTER DATABASE + RECOVER AUTOMATIC DATABASE; +ALTER DATABASE + RECOVER LOGFILE 'diskc:log3.log'; +--TODO: fix grammar +--ALTER DATABASE +-- RECOVER STANDBY DATAFILE '/finance/stbs_21.f' +-- UNTIL CONTROLFILE; +ALTER DATABASE + RECOVER MANAGED STANDBY DATABASE; diff --git a/plsql/examples/alter_dimension.sql b/plsql/examples/alter_dimension.sql new file mode 100644 index 0000000..9e8bd78 --- /dev/null +++ b/plsql/examples/alter_dimension.sql @@ -0,0 +1,5 @@ +ALTER DIMENSION customers_dim DROP ATTRIBUTE country; + +ALTER DIMENSION customers_dim + ADD LEVEL zone IS customers.cust_postal_code + ADD ATTRIBUTE zone DETERMINES (cust_city); \ No newline at end of file diff --git a/plsql/examples/alter_diskgroup.sql b/plsql/examples/alter_diskgroup.sql new file mode 100644 index 0000000..0d50697 --- /dev/null +++ b/plsql/examples/alter_diskgroup.sql @@ -0,0 +1,53 @@ +ALTER DISKGROUP hmdg ADD FILEGROUP fgtem TEMPLATE SET 'datafile.redundancy'='unprotected'; + +ALTER DISKGROUP hmdg ADD FILEGROUP fgdb DATABASE NONE FROM TEMPLATE fgtem; + +ALTER DISKGROUP hmdg ADD FILEGROUP fgtem2 TEMPLATE + CREATE TABLESPACE tbs1 datafile '+hmdg(fg$fgtem2)/dbs/tbs1.f' size 1M; + +ALTER DISKGROUP dgroup_01 + ADD DISK '/devices/disks/d100'; + +ALTER DISKGROUP dgroup_01 + DROP DISK dgroup_01_0000; + +ALTER DISKGROUP dgroup_01 +UNDROP DISKS; + +ALTER DISKGROUP dgroup_01 + RESIZE ALL + SIZE 36G; + +ALTER DISKGROUP dgroup_01 + REBALANCE POWER 11 WAIT; + +ALTER DISKGROUP dgroup_01 + CHECK ALL + REPAIR; + +ALTER DISKGROUP dgroup_01 + ADD TEMPLATE template_01 + ATTRIBUTES (UNPROTECTED COARSE); + +ALTER DISKGROUP dgroup_01 + MODIFY TEMPLATE template_01 + ATTRIBUTES (FINE); + +ALTER DISKGROUP dgroup_01 + DROP TEMPLATE template_01; + +ALTER DISKGROUP dgroup_01 + ADD DIRECTORY '+dgroup_01/alias_dir'; + +ALTER DISKGROUP dgroup_01 + ADD ALIAS '+dgroup_01/alias_dir/datafile.dbf' + FOR '+dgroup_01.261.1'; + +ALTER DISKGROUP dgroup_01 + SCRUB REPAIR WAIT; + +ALTER DISKGROUP dgroup_01 + DISMOUNT FORCE; + +ALTER DISKGROUP dgroup_01 + MOUNT; diff --git a/plsql/examples/alter_flashback_archive.sql b/plsql/examples/alter_flashback_archive.sql new file mode 100644 index 0000000..faca66e --- /dev/null +++ b/plsql/examples/alter_flashback_archive.sql @@ -0,0 +1,8 @@ +ALTER FLASHBACK ARCHIVE test_archive1 + MODIFY RETENTION 1 MONTH; + +ALTER TABLE oe.customers + FLASHBACK ARCHIVE; + +ALTER TABLE oe.orders + FLASHBACK ARCHIVE test_archive2; diff --git a/plsql/examples/alter_hierarchy.sql b/plsql/examples/alter_hierarchy.sql new file mode 100644 index 0000000..bc7b1b4 --- /dev/null +++ b/plsql/examples/alter_hierarchy.sql @@ -0,0 +1 @@ +ALTER HIERARCHY product_hier RENAME TO myproduct_hier; diff --git a/plsql/examples/alter_inmemory_join_group.sql b/plsql/examples/alter_inmemory_join_group.sql new file mode 100644 index 0000000..9c2cdbf --- /dev/null +++ b/plsql/examples/alter_inmemory_join_group.sql @@ -0,0 +1,5 @@ +ALTER INMEMORY JOIN GROUP prod_id1 + ADD(product_descriptions(product_id)); + +ALTER INMEMORY JOIN GROUP prod_id1 +REMOVE(product_descriptions(product_id)); diff --git a/plsql/examples/alter_java.sql b/plsql/examples/alter_java.sql new file mode 100644 index 0000000..3bdf2d0 --- /dev/null +++ b/plsql/examples/alter_java.sql @@ -0,0 +1,3 @@ +ALTER JAVA CLASS "Agent" + RESOLVER (("/usr/bin/bfile_dir/*" pm)(* public)) + RESOLVE; diff --git a/plsql/examples/alter_library.sql b/plsql/examples/alter_library.sql new file mode 100644 index 0000000..da27d94 --- /dev/null +++ b/plsql/examples/alter_library.sql @@ -0,0 +1 @@ +ALTER LIBRARY hr.my_ext_lib COMPILE; diff --git a/plsql/examples/alter_lockdown_profile.sql b/plsql/examples/alter_lockdown_profile.sql new file mode 100644 index 0000000..5ddea40 --- /dev/null +++ b/plsql/examples/alter_lockdown_profile.sql @@ -0,0 +1,68 @@ +ALTER LOCKDOWN PROFILE hr_prof + DISABLE FEATURE = ('NETWORK_ACCESS'); + +ALTER LOCKDOWN PROFILE hr_prof + DISABLE FEATURE = ('LOB_FILE_ACCESS', 'TRACE_VIEW_ACCESS'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE FEATURE ALL EXCEPT = ('COMMON_USER_LOCAL_SCHEMA_ACCESS', 'LOCAL_USER_COMMON_SCHEMA_ACCESS'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE FEATURE ALL; + ALTER LOCKDOWN PROFILE hr_prof + ENABLE FEATURE = ('UTL_HTTP', 'UTL_SMTP', 'OS_ACCESS'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE FEATURE ALL EXCEPT = ('AQ_PROTOCOLS', 'CTX_PROTOCOLS'); + ALTER LOCKDOWN PROFILE hr_prof + ENABLE FEATURE ALL; +ALTER LOCKDOWN PROFILE hr_prof + DISABLE OPTION = ('DATABASE QUEUING'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE OPTION = ('PARTITIONING'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE OPTION = ('DATABASE QUEUING'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE OPTION ALL; +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER DATABASE'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SYSTEM') + CLAUSE = ('SUSPEND', 'RESUME'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER PLUGGABLE DATABASE') + CLAUSE ALL EXCEPT = ('DEFAULT TABLESPACE', 'DEFAULT TEMPORARY TABLESPACE'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SESSION') + CLAUSE = ('SET') + OPTION = ('COMMIT_WAIT', 'CURSOR_SHARING'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SYSTEM') + CLAUSE = ('SET') + OPTION = ('PDB_FILE_NAME_CONVERT') + VALUE = ('cdb1_pdb0', 'cdb1_pdb1'); +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SYSTEM') + CLAUSE = ('SET') + OPTION = ('CPU_COUNT') + MINVALUE = '8'; +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SYSTEM') + CLAUSE = ('SET') + OPTION = ('CPU_COUNT') + MAXVALUE = '2'; +ALTER LOCKDOWN PROFILE hr_prof + DISABLE STATEMENT = ('ALTER SYSTEM') + CLAUSE = ('SET') + OPTION = ('CPU_COUNT') + MINVALUE = '2' + MAXVALUE = '6'; +ALTER LOCKDOWN PROFILE hr_prof + ENABLE STATEMENT ALL EXCEPT = ('ALTER DATABASE'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE STATEMENT = ('ALTER DATABASE') + CLAUSE = ('MOUNT', 'OPEN'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE STATEMENT = ('ALTER PLUGGABLE DATABASE') + CLAUSE ALL EXCEPT = ('DEFAULT TABLESPACE', 'DEFAULT TEMPORARY TABLESPACE'); +ALTER LOCKDOWN PROFILE hr_prof + ENABLE STATEMENT = ('ALTER SESSION') + CLAUSE = ('SET') + OPTION = ('COMMIT_WAIT', 'CURSOR_SHARING'); diff --git a/plsql/examples/alter_materialized_zonemap.sql b/plsql/examples/alter_materialized_zonemap.sql new file mode 100644 index 0000000..d782458 --- /dev/null +++ b/plsql/examples/alter_materialized_zonemap.sql @@ -0,0 +1,6 @@ +ALTER MATERIALIZED ZONEMAP sales_zmap PCTFREE 20 PCTUSED 50 NOCACHE; +ALTER MATERIALIZED ZONEMAP sales_zmap REFRESH FAST ON COMMIT; +ALTER MATERIALIZED ZONEMAP sales_zmap DISABLE PRUNING; +ALTER MATERIALIZED ZONEMAP sales_zmap COMPILE; +ALTER MATERIALIZED ZONEMAP sales_zmap REBUILD; +ALTER MATERIALIZED ZONEMAP sales_zmap UNUSABLE; \ No newline at end of file diff --git a/plsql/examples/alter_mv.sql b/plsql/examples/alter_mv.sql new file mode 100644 index 0000000..07c43e2 --- /dev/null +++ b/plsql/examples/alter_mv.sql @@ -0,0 +1,16 @@ +ALTER MATERIALIZED VIEW sales_by_month_by_state + REFRESH FAST; + +ALTER MATERIALIZED VIEW sales_by_month_by_state + REFRESH NEXT SYSDATE+7; +ALTER MATERIALIZED VIEW sales_by_month_by_state CONSIDER FRESH; + +ALTER MATERIALIZED VIEW emp_data + REFRESH COMPLETE + START WITH TRUNC(SYSDATE+1) + 9/24 + NEXT SYSDATE+7; +ALTER MATERIALIZED VIEW emp_data + ENABLE QUERY REWRITE; +ALTER MATERIALIZED VIEW order_data + REFRESH WITH PRIMARY KEY; +ALTER MATERIALIZED VIEW order_data COMPILE; diff --git a/plsql/examples/alter_mv_log.sql b/plsql/examples/alter_mv_log.sql new file mode 100644 index 0000000..410a9da --- /dev/null +++ b/plsql/examples/alter_mv_log.sql @@ -0,0 +1,5 @@ +ALTER MATERIALIZED VIEW LOG ON order_items ADD ROWID; + +ALTER MATERIALIZED VIEW LOG ON employees + ADD (commission_pct) + EXCLUDING NEW VALUES; diff --git a/plsql/examples/alter_operator.sql b/plsql/examples/alter_operator.sql new file mode 100644 index 0000000..2176427 --- /dev/null +++ b/plsql/examples/alter_operator.sql @@ -0,0 +1 @@ +ALTER OPERATOR eq_op COMPILE; diff --git a/plsql/examples/alter_outline.sql b/plsql/examples/alter_outline.sql new file mode 100644 index 0000000..67d6aa7 --- /dev/null +++ b/plsql/examples/alter_outline.sql @@ -0,0 +1 @@ +ALTER OUTLINE salaries REBUILD; diff --git a/plsql/examples/alter_partition.sql b/plsql/examples/alter_partition.sql new file mode 100644 index 0000000..47903be --- /dev/null +++ b/plsql/examples/alter_partition.sql @@ -0,0 +1,4 @@ +ALTER TABLE table1 MODIFY PARTITION BY LIST(color)( + partition RED VALUES ('RED'), + partition BLUE VALUES ('BLUE') +); \ No newline at end of file diff --git a/plsql/examples/alter_pmem_filestore.sql b/plsql/examples/alter_pmem_filestore.sql new file mode 100644 index 0000000..bb987a3 --- /dev/null +++ b/plsql/examples/alter_pmem_filestore.sql @@ -0,0 +1,6 @@ +ALTER PMEM FILESTORE cloud_db_1 RESIZE 5T; + +ALTER PMEM FILESTORE cloud_db_1 MOUNT MOUNTPOINT '/corp/db/cloud_db_1' + BACKINGFILE '/var/pmem/foo_1'; + +ALTER PMEM FILESTORE cloud_db_1 DISMOUNT; diff --git a/plsql/examples/alter_resource_cost.sql b/plsql/examples/alter_resource_cost.sql new file mode 100644 index 0000000..662ad6f --- /dev/null +++ b/plsql/examples/alter_resource_cost.sql @@ -0,0 +1,7 @@ +ALTER RESOURCE COST +CPU_PER_SESSION 100 +CONNECT_TIME 1; + +ALTER RESOURCE COST +LOGICAL_READS_PER_SESSION 2 +CONNECT_TIME 0; diff --git a/plsql/examples/alter_role.sql b/plsql/examples/alter_role.sql new file mode 100644 index 0000000..dde455c --- /dev/null +++ b/plsql/examples/alter_role.sql @@ -0,0 +1,14 @@ +alter role TEST_ROLE_AAA NOT IDENTIFIED; + +alter role TEST_ROLE_AAA IDENTIFIED BY data; + +alter role TEST_ROLE_AAA IDENTIFIED EXTERNALLY; + +ALTER ROLE TEST_ROLE_AAA IDENTIFIED USING hr.admin; + +alter role TEST_ROLE_AAA IDENTIFIED GLOBALLY; + + +ALTER ROLE dw_manager IDENTIFIED GLOBALLY AS 'domain_name_of_directory_group' ; +ALTER ROLE warehouse_user NOT IDENTIFIED CONTAINER = CURRENT; +ALTER ROLE warehouse_user NOT IDENTIFIED CONTAINER = ALL; diff --git a/plsql/examples/alter_rollback_segment.sql b/plsql/examples/alter_rollback_segment.sql new file mode 100644 index 0000000..2d15af6 --- /dev/null +++ b/plsql/examples/alter_rollback_segment.sql @@ -0,0 +1,2 @@ +ALTER ROLLBACK SEGMENT rbs_one ONLINE; +ALTER ROLLBACK SEGMENT rbs_one SHRINK TO 100M; \ No newline at end of file diff --git a/plsql/examples/alter_session.sql b/plsql/examples/alter_session.sql new file mode 100644 index 0000000..42e12e5 --- /dev/null +++ b/plsql/examples/alter_session.sql @@ -0,0 +1,15 @@ +ALTER SESSION + SET QUERY_REWRITE_ENABLED = TRUE; + +ALTER SESSION + SET NLS_SORT = XSpanish; + +ALTER SESSION + SET NLS_LANGUAGE = FRENCH; + +ALTER SESSION SET NLS_CURRENCY = 'FF'; + +ALTER SESSION + ADVISE COMMIT; + +ALTER SESSION ENABLE PARALLEL DML; diff --git a/plsql/examples/alter_synonym01.sql b/plsql/examples/alter_synonym01.sql new file mode 100644 index 0000000..7d7ec02 --- /dev/null +++ b/plsql/examples/alter_synonym01.sql @@ -0,0 +1,4 @@ +alter synonym emp compile; +alter public synonym emp compile; +alter public synonym emp noneditionable; +alter public synonym sch.emp editionable; diff --git a/plsql/examples/alter_table.sql b/plsql/examples/alter_table.sql new file mode 100644 index 0000000..b3b19a3 --- /dev/null +++ b/plsql/examples/alter_table.sql @@ -0,0 +1,179 @@ +alter table hr.employees + add constraint emp_fk foreign key (department_id) + references hr.departments (department_id) + on delete cascade; + +alter table hr.employees + add foreign key (department_id) + references hr.departments (department_id) + on delete set null; + +alter table hr.employees + add constraint emp_fk foreign key (department_id, employee_id) + references hr.some_table (department_id, employee_id); + +alter table employees + add primary key (employee_id); + +alter table hr.employees + add constraint emp_complex_pk primary key (employee_id, department_id); + +alter table hr.employees + add constraint emp_uq unique (employee_id, email); + +alter table employees + add unique (employee_id); + +ALTER TABLE suppliers +ADD CONSTRAINT check_supplier_name + CHECK (supplier_name IN ('IBM', 'Microsoft', 'NVIDIA')); + +ALTER TABLE suppliers + DROP CONSTRAINT check_supplier_id; + +ALTER TABLE suppliers + ENABLE CONSTRAINT check_supplier_id; + +ALTER TABLE suppliers + DISABLE CONSTRAINT check_supplier_id; + +ALTER TABLE customers + PARALLEL; + +ALTER TABLE employees + DEALLOCATE UNUSED; + +ALTER TABLE countries_demo INITRANS 4; + +ALTER TABLE employees + PCTFREE 30 + PCTUSED 60; + +ALTER TABLE employees + ALLOCATE EXTENT (SIZE 5K INSTANCE 4); + +ALTER TABLE customers + ADD (online_acct_pw VARCHAR2(8) ENCRYPT 'NOMAC' NO SALT ); + +ALTER TABLE employees ADD (resume CLOB) + LOB (resume) STORE AS resume_seg (TABLESPACE example); + +ALTER TABLE employees ADD (resume CLOB) +LOB (resume) STORE AS SECUREFILE resume_seg (TABLESPACE auto_seg_ts); + +ALTER TABLE employees ADD (skills number) + NESTED TABLE skills STORE AS nested_skill_table; + +ALTER TABLE employees + ENABLE VALIDATE CONSTRAINT emp_manager_fk + EXCEPTIONS INTO exceptions; + +ALTER TABLE print_media MODIFY NESTED TABLE ad_textdocs_ntab + RETURN AS VALUE; + +ALTER TABLE employees + ENABLE NOVALIDATE PRIMARY KEY + ENABLE NOVALIDATE CONSTRAINT emp_last_name_nn; + +ALTER TABLE locations + MODIFY PRIMARY KEY DISABLE CASCADE; + +ALTER TABLE employees ADD CONSTRAINT check_comp + CHECK (salary + (commission_pct*salary) <= 5000) + DISABLE; + +ALTER TABLE employees + ENABLE ALL TRIGGERS; + +ALTER TABLE employees + DEALLOCATE UNUSED; + +ALTER TABLE customers + RENAME COLUMN credit_limit TO credit_amount; + +ALTER TABLE t1 DROP (pk) CASCADE CONSTRAINTS; + +ALTER TABLE t1 DROP (pk, fk, c1); +ALTER TABLE customers + MODIFY (online_acct_pw DECRYPT); + +ALTER TABLE departments + DROP PRIMARY KEY CASCADE; + +ALTER TABLE employees + DROP UNIQUE (email); + +ALTER TABLE employees MODIFY LOB (resume) (CACHE); + +ALTER TABLE employees MODIFY LOB (resume) (NOCACHE); + +ALTER TABLE employees MODIFY LOB (resume) (NOCACHE); + +alter TABLE employee add ( constraint employee_pk UNique ( a , b ) ) ; + +alter table employee + add constraint emp_fk foreign key (col1, col2) references other; + +alter table employee + add constraint emp_fk foreign key (col1, col2) references other on delete set null; + +alter table employee + add constraint emp_fk foreign key (col1, col2) references other on delete cascade; + +ALTER TABLE TABLE_A + ADD TABLE_B_ID NUMBER(5) + ADD FOREIGN KEY (TABLE_B_ID) REFERENCES TABLE_B (ID); + +ALTER TABLE S.PRODUCTS + DROP PARTITION + FOR 101; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + UPDATE GLOBAL INDEXES; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + INVALIDATE GLOBAL INDEXES; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + UPDATE INDEXES; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + UPDATE GLOBAL INDEXES NOPARALLEL; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + INVALIDATE GLOBAL INDEXES NOPARALLEL; + +ALTER TABLE S.PRODUCTS + DROP PARTITION p0 + UPDATE INDEXES NOPARALLEL; + +ALTER TABLE B.EXCHANGE_LOG + DROP PARTITION + FOR (TIMESTAMP '2022-01-28 00:00:00') + UPDATE GLOBAL INDEXES ; + +ALTER TABLE mesg_perf_stat + TRUNCATE PARTITION SYS_P1221396 + DROP STORAGE CASCADE UPDATE INDEXES; + +ALTER TABLE employees MEMOPTIMIZE FOR READ + ENABLE VALIDATE CONSTRAINT emp_manager_fk + EXCEPTIONS INTO exceptions; + +ALTER TABLE employees NO MEMOPTIMIZE FOR READ + ENABLE VALIDATE CONSTRAINT emp_manager_fk + EXCEPTIONS INTO exceptions; + +ALTER TABLE employees MEMOPTIMIZE FOR WRITE + ENABLE VALIDATE CONSTRAINT emp_manager_fk + EXCEPTIONS INTO exceptions; + +ALTER TABLE employees NO MEMOPTIMIZE FOR WRITE + ENABLE VALIDATE CONSTRAINT emp_manager_fk + EXCEPTIONS INTO exceptions; + diff --git a/plsql/examples/alter_table_inmemory.sql b/plsql/examples/alter_table_inmemory.sql new file mode 100644 index 0000000..a5d326c --- /dev/null +++ b/plsql/examples/alter_table_inmemory.sql @@ -0,0 +1,53 @@ +-- inmemory_table_clause +ALTER TABLE customer INMEMORY; + +ALTER TABLE customer NO INMEMORY; + +-- inmemory_memcompress +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR DML; + +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR QUERY; +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR QUERY LOW; +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR QUERY HIGH; + +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR CAPACITY; +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR CAPACITY LOW; +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR CAPACITY HIGH; + +ALTER TABLE customer INMEMORY NO MEMCOMPRESS; + +-- inmemory_priority +ALTER TABLE customer INMEMORY PRIORITY NONE; +ALTER TABLE customer INMEMORY PRIORITY LOW; +ALTER TABLE customer INMEMORY PRIORITY MEDIUM; +ALTER TABLE customer INMEMORY PRIORITY HIGH; +ALTER TABLE customer INMEMORY PRIORITY CRITICAL; + +-- inmemory_distribute +ALTER TABLE customer INMEMORY DISTRIBUTE; +ALTER TABLE customer INMEMORY DISTRIBUTE AUTO; +ALTER TABLE customer INMEMORY DISTRIBUTE BY ROWID RANGE; +ALTER TABLE customer INMEMORY DISTRIBUTE BY PARTITION; +ALTER TABLE customer INMEMORY DISTRIBUTE BY SUBPARTITION; + +ALTER TABLE customer INMEMORY DISTRIBUTE FOR SERVICE DEFAULT; +ALTER TABLE customer INMEMORY DISTRIBUTE FOR SERVICE ALL; +ALTER TABLE customer INMEMORY DISTRIBUTE FOR SERVICE some_service; +ALTER TABLE customer INMEMORY DISTRIBUTE FOR SERVICE NONE; + +ALTER TABLE customer INMEMORY DISTRIBUTE BY ROWID RANGE FOR SERVICE DEFAULT; + +-- inmemory_duplicate +ALTER TABLE customer INMEMORY DUPLICATE; +ALTER TABLE customer INMEMORY DUPLICATE ALL; +ALTER TABLE customer INMEMORY NO DUPLICATE; + +-- inmemory_column_clause +ALTER TABLE customer INMEMORY INMEMORY (customer_name); +ALTER TABLE customer INMEMORY (customer_name, customer_id); +ALTER TABLE customer INMEMORY (name) INMEMORY (customer_id); +ALTER TABLE customer INMEMORY (name) NO INMEMORY (customer_id); +ALTER TABLE customer INMEMORY MEMCOMPRESS FOR QUERY LOW (name) NO INMEMORY (customer_id); + +-- verify usage of ... as regular id +CREATE TABLE vendor (SERVICE VARCHAR2(100)); diff --git a/plsql/examples/alter_tablespace_set.sql b/plsql/examples/alter_tablespace_set.sql new file mode 100644 index 0000000..319f453 --- /dev/null +++ b/plsql/examples/alter_tablespace_set.sql @@ -0,0 +1,2 @@ +ALTER TABLESPACE SET ts1 + FORCE LOGGING; diff --git a/plsql/examples/alter_tablespaces.sql b/plsql/examples/alter_tablespaces.sql new file mode 100644 index 0000000..abc84af --- /dev/null +++ b/plsql/examples/alter_tablespaces.sql @@ -0,0 +1,36 @@ +ALTER TABLESPACE tbs_01 + BEGIN BACKUP; +ALTER TABLESPACE tbs_01 + END BACKUP; + +ALTER TABLESPACE tbs_02 OFFLINE NORMAL; + +ALTER TABLESPACE tbs_02 + RENAME DATAFILE 'diskb:tbs_f5.dbf' + TO 'diska:tbs_f5.dbf'; + +ALTER TABLESPACE tbs_02 ONLINE; + +ALTER TABLESPACE tbs_03 + ADD DATAFILE 'tbs_f04.dbf' + SIZE 100K + AUTOEXTEND ON + NEXT 10K + MAXSIZE 100K; + +ALTER TABLESPACE tbs_03 + DROP DATAFILE 'tbs_f04.dbf'; + +ALTER TABLESPACE temp_demo ADD TEMPFILE 'temp05.dbf' SIZE 5 AUTOEXTEND ON; + +ALTER TABLESPACE temp_demo DROP TEMPFILE 'temp05.dbf'; + +ALTER TABLESPACE temp_demo SHRINK SPACE; + +ALTER TABLESPACE omf_ts1 ADD DATAFILE; + +ALTER TABLESPACE tbs_03 NOLOGGING; +ALTER TABLESPACE undots1 + RETENTION NOGUARANTEE; +ALTER TABLESPACE undots1 + RETENTION GUARANTEE; diff --git a/plsql/examples/alter_view.sql b/plsql/examples/alter_view.sql new file mode 100644 index 0000000..8d5ef07 --- /dev/null +++ b/plsql/examples/alter_view.sql @@ -0,0 +1,5 @@ +ALTER VIEW customer_ro + COMPILE; +ALTER VIEW customer_ro + EDITIONABLE; + diff --git a/plsql/examples/analytic_query.sql b/plsql/examples/analytic_query.sql new file mode 100644 index 0000000..98edd8e --- /dev/null +++ b/plsql/examples/analytic_query.sql @@ -0,0 +1,101 @@ +select time_id, product + , last_value(quantity ignore nulls) over (partition by product order by time_id) quantity + , last_value(quantity respect nulls) over (partition by product order by time_id) quantity + from ( select times.time_id, product, quantity + from inventory partition by (product) + right outer join times on (times.time_id = inventory.time_id) + where times.time_id between to_date('01/04/01', 'dd/mm/yy') + and to_date('06/04/01', 'dd/mm/yy')) + order by 2,1; + +select times.time_id, product, quantity from inventory + partition by (product) + right outer join times on (times.time_id = inventory.time_id) + where times.time_id between to_date('01/04/01', 'dd/mm/yy') + and to_date('06/04/01', 'dd/mm/yy') + order by 2,1; + +select deptno + , ename + , hiredate + , listagg(ename, ',') within group (order by hiredate) over (partition by deptno) as employees +from emp; + +select deptno + , ename + , hiredate + , listagg(ename, ',' ON OVERFLOW ERROR) within group (order by hiredate) over (partition by deptno) as employees +from emp; + +select deptno + , ename + , hiredate + , listagg(ename, ',' ON OVERFLOW TRUNCATE) within group (order by hiredate) over (partition by deptno) as employees +from emp; + +select deptno + , ename + , hiredate + , listagg(UNIQUE ename, ',' ON OVERFLOW TRUNCATE) within group (order by hiredate) over (partition by deptno) as employees + , listagg(UNIQUE edepartment, ',' ON OVERFLOW TRUNCATE) within group (order by hiredate) over (partition by deptno) as edepartments +from emp; + + select metric_id ,bsln_guid ,timegroup ,obs_value as obs_value + , cume_dist () over (partition by metric_id, bsln_guid, timegroup order by obs_value ) as cume_dist + , count(1) over (partition by metric_id, bsln_guid, timegroup ) as n + , row_number () over (partition by metric_id, bsln_guid, timegroup order by obs_value) as rrank + , percentile_disc(:b7 ) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as mid_tail_value + , max(obs_value) over (partition by metric_id, bsln_guid, timegroup ) as max_val + , min(obs_value) over (partition by metric_id, bsln_guid, timegroup ) as min_val + , avg(obs_value) over (partition by metric_id, bsln_guid, timegroup ) as avg_val + , stddev(obs_value) over (partition by metric_id, bsln_guid, timegroup ) as sdev_val + , percentile_cont(0.25) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_25 + , percentile_cont(0.5) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_50 + , percentile_cont(0.75) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_75 + , percentile_cont(0.90) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_90 + , percentile_cont(0.95) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_95 + , percentile_cont(0.99) within group (order by obs_value asc) over (partition by metric_id, bsln_guid, timegroup) as pctile_99 + from timegrouped_rawdata d; + +select trim(both ' ' from ' a ') from dual where trim(:a) is not null; + +with +clus_tab as ( +select id, +a.attribute_name aname, +a.conditional_operator op, +nvl(a.attribute_str_value, +round(decode(a.attribute_name, n.col, +a.attribute_num_value * n.scale + n.shift, +a.attribute_num_value),4)) val, +a.attribute_support support, +a.attribute_confidence confidence +from table(dbms_data_mining.get_model_details_km('km_sh_clus_sample')) t, +table(t.rule.antecedent) a, +km_sh_sample_norm n +where a.attribute_name = n.col (+) and a.attribute_confidence > 0.55 +), +clust as ( +select id, +cast(collect(cattr(aname, op, to_char(val), support, confidence)) as cattrs) cl_attrs +from clus_tab +group by id +), +custclus as ( +select t.cust_id, s.cluster_id, s.probability +from (select +cust_id +, cluster_set(km_sh_clus_sample, null, 0.2 using *) pset +from km_sh_sample_apply_prepared +where cust_id = 101362) t, +table(t.pset) s +) +select a.probability prob, a.cluster_id cl_id, +b.attr, b.op, b.val, b.supp, b.conf +from custclus a, +(select t.id, c.* +from clust t, +table(t.cl_attrs) c) b +where a.cluster_id = b.id +order by prob desc, cl_id asc, conf desc, attr asc, val asc; + diff --git a/plsql/examples/analyze.sql b/plsql/examples/analyze.sql new file mode 100644 index 0000000..915091f --- /dev/null +++ b/plsql/examples/analyze.sql @@ -0,0 +1,9 @@ +ANALYZE TABLE orders DELETE STATISTICS; +ANALYZE INDEX inv_product_ix VALIDATE STRUCTURE; +ANALYZE TABLE employees VALIDATE STRUCTURE CASCADE; +ANALYZE TABLE customers VALIDATE REF UPDATE; +ANALYZE TABLE customers VALIDATE STRUCTURE ONLINE; +ANALYZE CLUSTER personnel + VALIDATE STRUCTURE CASCADE; +ANALYZE TABLE orders + LIST CHAINED ROWS INTO chained_rows; diff --git a/plsql/examples/associate_statistics.sql b/plsql/examples/associate_statistics.sql new file mode 100644 index 0000000..7ef49ad --- /dev/null +++ b/plsql/examples/associate_statistics.sql @@ -0,0 +1,2 @@ +ASSOCIATE STATISTICS WITH PACKAGES emp_mgmt DEFAULT SELECTIVITY 10; +ASSOCIATE STATISTICS WITH INDEXES salary_index DEFAULT COST (100,5,0); diff --git a/plsql/examples/audit.sql b/plsql/examples/audit.sql new file mode 100644 index 0000000..2f4a723 --- /dev/null +++ b/plsql/examples/audit.sql @@ -0,0 +1,27 @@ +AUDIT ROLE; +AUDIT ROLE + WHENEVER SUCCESSFUL; +AUDIT ROLE + WHENEVER NOT SUCCESSFUL; +AUDIT SELECT TABLE, UPDATE TABLE; +AUDIT SELECT TABLE, UPDATE TABLE + BY hr, oe; +AUDIT DELETE ANY TABLE; +AUDIT CREATE ANY DIRECTORY; +AUDIT DIRECTORY; +AUDIT READ ON DIRECTORY bfile_dir; +AUDIT SELECT + ON hr.employees; +AUDIT SELECT + ON hr.employees + WHENEVER SUCCESSFUL; +AUDIT SELECT + ON hr.employees + WHENEVER NOT SUCCESSFUL; +AUDIT INSERT, UPDATE + ON oe.customers; +AUDIT ALL + ON hr.employees_seq; +AUDIT ALTER, GRANT, INSERT, UPDATE, DELETE + ON DEFAULT; + diff --git a/plsql/examples/bindvar01.sql b/plsql/examples/bindvar01.sql new file mode 100644 index 0000000..2192adb --- /dev/null +++ b/plsql/examples/bindvar01.sql @@ -0,0 +1,14 @@ +insert into p +( +a1, +b2, +c3, +d4, +e5, +f6, +g7, +h8 +) +values +( :b1, :b2, :b3, :b4, :5, :6, :7, :8) + diff --git a/plsql/examples/bindvar02.sql b/plsql/examples/bindvar02.sql new file mode 100644 index 0000000..bd3132d --- /dev/null +++ b/plsql/examples/bindvar02.sql @@ -0,0 +1,6 @@ +select * +from a +where a=:3 +and b= : 4 +and c= :5and :a = :b + diff --git a/plsql/examples/bindvar03.sql b/plsql/examples/bindvar03.sql new file mode 100644 index 0000000..c27dde8 --- /dev/null +++ b/plsql/examples/bindvar03.sql @@ -0,0 +1,18 @@ +select count(*), max(scn) +from +( + select sp.bo#, sp.pmoptype, sp.scn, sp.flags + from sumpartlog$ sp, sumdep$ sd + where sd.sumobj# = :1 and sd.p_obj# = sp.bo# + group by sp.bo#, sp.pmoptype, sp.scn, sp.flags + minus + select sp.bo#, sp.pmoptype, sp.scn, sp.flags + from sumpartlog$ sp + where sp.bo# not in + ( + select sk.detailobj# from sumkey$ sk where sk.sumobj# = :1 and sk.detailcolfunction in (2,3) + ) + and bitand(sp.flags, 2) != 2 and sp.pmoptype in (2,3,5,7) + group by sp.bo#, sp.pmoptype, sp.scn, sp.flags +) +where scn > : 2 diff --git a/plsql/examples/bindvar04.sql b/plsql/examples/bindvar04.sql new file mode 100644 index 0000000..fc0f825 --- /dev/null +++ b/plsql/examples/bindvar04.sql @@ -0,0 +1,7 @@ +select * +from +( + select * + from "rme" "rm" + where "rm".a-interval:"sys_b_07" day(:"sys_b_08") to second(:"sys_b_09") +) diff --git a/plsql/examples/bindvar05.sql b/plsql/examples/bindvar05.sql new file mode 100644 index 0000000..92b3e25 --- /dev/null +++ b/plsql/examples/bindvar05.sql @@ -0,0 +1,14 @@ +select object_name, object_id, + decode(status, 'INVALID', 'TRUE', 'FALSE') invalid, + 'TRUE' runnable, + plsql_debug +from sys.dba_objects o, dba_plsql_object_settings s +where o.owner = :schema +and s.owner = :schema +and s.name = o.object_name +and s.type = 'PACKAGE' +and object_type = 'PACKAGE' +and subobject_name is null +and object_id not in ( select purge_object from recyclebin ) +and upper(object_name) in upper(:name) + \ No newline at end of file diff --git a/plsql/examples/bulk_collect_fetch_clause01.sql b/plsql/examples/bulk_collect_fetch_clause01.sql new file mode 100644 index 0000000..766c719 --- /dev/null +++ b/plsql/examples/bulk_collect_fetch_clause01.sql @@ -0,0 +1,21 @@ +declare + cursor cur_div is + select rid, code from tmp_data_item_value_euro; + lvnCount number := 0; + type cCurDiv_t is table of cur_div%Rowtype; + lvaCurDiv cCurDiv_t; +begin + open cur_div; + + loop + fetch cur_div bulk collect into lvaCurDiv limit 100000; + exit when lvaCurDiv.count = 0; + + forall i in lvaCurDiv.first .. lvaCurDiv.last + update data_item_value set unit_code = lvaCurDiv(i).code where rowid = lvaCurDiv(i).rid; + + commit; + end loop; + close cur_div; + commit; +end; \ No newline at end of file diff --git a/plsql/examples/call.sql b/plsql/examples/call.sql new file mode 100644 index 0000000..544ec57 --- /dev/null +++ b/plsql/examples/call.sql @@ -0,0 +1,9 @@ +CALL my_procedure(arg1 => 3, arg2 => 4) ; + +CALL my_procedure(3, 4) ; + +CALL my_procedure(3, arg2 => 4) ; + +CALL emp_mgmt.remove_dept(162); + +CALL warehouse_typ(456, 'Warehouse 456', 2236).ret_name() INTO :x; \ No newline at end of file diff --git a/plsql/examples/case_when01.sql b/plsql/examples/case_when01.sql new file mode 100644 index 0000000..357eb37 --- /dev/null +++ b/plsql/examples/case_when01.sql @@ -0,0 +1,9 @@ +select +ROOT,LEV,OBJ,LinK,PaTH,cycle, + case + when (LEV - LEaD(LEV) over (order by orD)) < 0 then 0 + else 1 + end is_LEaF +from T + + diff --git a/plsql/examples/case_when02.sql b/plsql/examples/case_when02.sql new file mode 100644 index 0000000..a307d2c --- /dev/null +++ b/plsql/examples/case_when02.sql @@ -0,0 +1,32 @@ +select + STaLENESS, OSIZE, OBJ#, TYPE#, + case + when STaLENESS > .5 then 128 + when STaLENESS > .1 then 256 + else 0 + end + aFLaGS aFLaGS, + STaTUS, + SID, + SERIaL#, + PaRT#, + BO# + , + case + when is_FULL_EVENTS_HisTorY = 1 then SRC.Bor_LasT_STaTUS_TIME + else + case GREaTEST (NVL (WP.Bor_LasT_STaT_TIME, date '1900-01-01'), NVL (SRC.Bor_LasT_STaTUS_TIME, date '1900-01-01')) + when date '1900-01-01' then null + when WP.Bor_LasT_STaT_TIME then WP.Bor_LasT_STaT_TIME + when SRC.Bor_LasT_STaTUS_TIME then SRC.Bor_LasT_STaTUS_TIME + else null + end + end + , + case GREaTEST (NVL (WP.Bor_LasT_STaT_TIME, date '1900-01-01'), NVL (SRC.Bor_LasT_STaTUS_TIME, date '1900-01-01')) + when date '1900-01-01' then null + when WP.Bor_LasT_STaT_TIME then WP.Bor_LasT_STaT_TIME + when SRC.Bor_LasT_STaTUS_TIME then SRC.Bor_LasT_STaTUS_TIME + else null + end +from X + diff --git a/plsql/examples/case_when03.sql b/plsql/examples/case_when03.sql new file mode 100644 index 0000000..6bb753e --- /dev/null +++ b/plsql/examples/case_when03.sql @@ -0,0 +1,9 @@ +select +case (STaTUS) +when 'N' then 1 +when 'B' then 2 +when 'a' then 3 +end as STaTE +from VaLUE +where KID=:B2 and RID=:B1 + diff --git a/plsql/examples/case_when04.sql b/plsql/examples/case_when04.sql new file mode 100644 index 0000000..92c4761 --- /dev/null +++ b/plsql/examples/case_when04.sql @@ -0,0 +1,3 @@ +select +case when row_number() over (partition by bo# order by staleness, osize, obj#) = 1 then 32 else 0 end + 64 aflags +from f diff --git a/plsql/examples/case_when05.sql b/plsql/examples/case_when05.sql new file mode 100644 index 0000000..60cca13 --- /dev/null +++ b/plsql/examples/case_when05.sql @@ -0,0 +1,12 @@ +select staleness +, osize, obj# +, type# +, case when row_number() over (partition by bo# order by staleness, osize, obj#) = 1 then 64 else 0 end + + + case when row_number() over (partition by (select tcp0.bo# from tabcompart$ tcp0 where tcp0.obj#=st0.bo#) order by staleness, osize, obj#) = 1 then 32 + else 0 end aflags +, 0 status +, :b3 sid +, :b2 serial# +, part#, bo# +from st0 \ No newline at end of file diff --git a/plsql/examples/case_when06.sql b/plsql/examples/case_when06.sql new file mode 100644 index 0000000..a8e2029 --- /dev/null +++ b/plsql/examples/case_when06.sql @@ -0,0 +1,8 @@ +SELECT +case + when STaLENESS > .5 then 128 + when STaLENESS > .1 then 256 + else 0 + end aFLaGS + FROM employees + \ No newline at end of file diff --git a/plsql/examples/case_when07.sql b/plsql/examples/case_when07.sql new file mode 100644 index 0000000..504e794 --- /dev/null +++ b/plsql/examples/case_when07.sql @@ -0,0 +1,6 @@ +SELECT h1.CRTYPE , +CASE 'month' + WHEN 'week' THEN TO_CHAR(h1.DateFrom, 'YYYYIW') + ELSE to_char(h1.DateFrom,'YYYYMM') +END +FROM CQ_CHANGEREQUESTS h1 \ No newline at end of file diff --git a/plsql/examples/cast.sql b/plsql/examples/cast.sql new file mode 100644 index 0000000..91b664b --- /dev/null +++ b/plsql/examples/cast.sql @@ -0,0 +1,9 @@ +select + raw_value, + cast(raw_value as date, 'YYYY-MM-DD'), + cast(raw_value as date, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN'), + cast(raw_value as number default null on conversion error), + cast(raw_value as number default 9999 on conversion error), + cast(raw_value as date default null on conversion error, 'YYYY-MM-DD'), + cast(raw_value as date default null on conversion error, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/cast_multiset01.sql b/plsql/examples/cast_multiset01.sql new file mode 100644 index 0000000..bc68388 --- /dev/null +++ b/plsql/examples/cast_multiset01.sql @@ -0,0 +1,7 @@ +select t1.department_id, t2.* + from hr_info t1, table(cast(multiset( + select t3.last_name, t3.department_id, t3.salary + from people t3 + where t3.department_id = t1.department_id) + as people_tab_typ)) t2 + diff --git a/plsql/examples/cast_multiset02.sql b/plsql/examples/cast_multiset02.sql new file mode 100644 index 0000000..cb9631c --- /dev/null +++ b/plsql/examples/cast_multiset02.sql @@ -0,0 +1,6 @@ + select title + from + table(select courses from department where name = 'history') + where name like '%etruscan%' + + diff --git a/plsql/examples/cast_multiset03.sql b/plsql/examples/cast_multiset03.sql new file mode 100644 index 0000000..412af23 --- /dev/null +++ b/plsql/examples/cast_multiset03.sql @@ -0,0 +1,7 @@ + select + 1 + , cursor(select 1 from dual) c1 + , cursor(select 2, 3 from dual) as c2 + from + table(select 1 from dual) + diff --git a/plsql/examples/cast_multiset04.sql b/plsql/examples/cast_multiset04.sql new file mode 100644 index 0000000..6fa8a9d --- /dev/null +++ b/plsql/examples/cast_multiset04.sql @@ -0,0 +1,3 @@ +select e1.last_name from employees e1 + where f( cursor(select e2.hire_date from employees e2 where e1.employee_id = e2.manager_id), e1.hire_date) = 1 +order by last_name \ No newline at end of file diff --git a/plsql/examples/cast_multiset05.sql b/plsql/examples/cast_multiset05.sql new file mode 100644 index 0000000..2985d82 --- /dev/null +++ b/plsql/examples/cast_multiset05.sql @@ -0,0 +1,6 @@ +select * +from + table + ( + function_name() + ) diff --git a/plsql/examples/cast_multiset06.sql b/plsql/examples/cast_multiset06.sql new file mode 100644 index 0000000..d2cee88 --- /dev/null +++ b/plsql/examples/cast_multiset06.sql @@ -0,0 +1,4 @@ +select + cast(collect(cattr(aname, op, to_char(val), support, confidence)) as cattrs) cl_attrs +from a + diff --git a/plsql/examples/cast_multiset08.sql b/plsql/examples/cast_multiset08.sql new file mode 100644 index 0000000..efa1707 --- /dev/null +++ b/plsql/examples/cast_multiset08.sql @@ -0,0 +1 @@ +select * from table (cast (f_int_date_varchar2() as table_int_date_varchar2)) diff --git a/plsql/examples/cluster.sql b/plsql/examples/cluster.sql new file mode 100644 index 0000000..95098fb --- /dev/null +++ b/plsql/examples/cluster.sql @@ -0,0 +1,19 @@ +CREATE CLUSTER personnel + (department NUMBER(4)) +SIZE 512 +STORAGE (initial 100K next 50K); + +CREATE INDEX idx_personnel ON CLUSTER personnel; + +CREATE CLUSTER language (cust_language VARCHAR2(3)) + SIZE 512 HASHKEYS 10 + STORAGE (INITIAL 100k next 50k); + +CREATE CLUSTER address + (postal_code NUMBER, country_id CHAR(2)) + HASHKEYS 20 + HASH IS MOD(postal_code + country_id, 101); + +CREATE CLUSTER cust_orders (customer_id NUMBER(6)) + SIZE 512 SINGLE TABLE HASHKEYS 100; + diff --git a/plsql/examples/columns01.sql b/plsql/examples/columns01.sql new file mode 100644 index 0000000..0600b26 --- /dev/null +++ b/plsql/examples/columns01.sql @@ -0,0 +1,7 @@ +select a, b, +a d, +ddd as ddd, +ddd as "dfdf", +x as +from dual + diff --git a/plsql/examples/comment_on.sql b/plsql/examples/comment_on.sql new file mode 100644 index 0000000..1b25d3b --- /dev/null +++ b/plsql/examples/comment_on.sql @@ -0,0 +1,26 @@ +-- column + +comment on column employees.employee_id is 'Primary key of employees table.'; + +comment on column hr.employees.employee_id is 'Multiline +comment on column.'; + +comment on column "hr"."employees"."employee_id" is 'Primary key of employees table.'; + + +-- add example: fix when comment on column with schema, the parser is report syntax error +comment on column s.a.c1 is 'comment'; + +-- table + +comment on table employees is 'employees table. Contains 107 rows.'; + +comment on table hr.employees is 'employees table. Contains 107 rows.'; + +comment on table "hr"."employees" is 'employees table. Contains 107 rows.'; + +comment on table "my schema"."my table" is 'Some demo table with space in its name +and a multiline comment.'; + +COMMENT ON MATERIALIZED VIEW "MONITOR"."SQL_ALERT_LOG_ERRORS" IS +'snapshot table for snapshot MONITOR.SQL_ALERT_LOG_ERRORS'; \ No newline at end of file diff --git a/plsql/examples/comments.sql b/plsql/examples/comments.sql new file mode 100644 index 0000000..764a1f6 --- /dev/null +++ b/plsql/examples/comments.sql @@ -0,0 +1,8 @@ +-- com1 +select * /* +com2 */ +from dual -- com3 + +Rem Copyright (c) All Rights Reserved. + +prompt . ## Hello world \ No newline at end of file diff --git a/plsql/examples/commit.sql b/plsql/examples/commit.sql new file mode 100644 index 0000000..1c16221 --- /dev/null +++ b/plsql/examples/commit.sql @@ -0,0 +1,7 @@ +COMMIT; +COMMIT WORK; +COMMIT WRITE BATCH; +COMMIT COMMENT 'TEST' WRITE NOWAIT IMMEDIATE; +COMMIT WORK COMMENT 'TEXT'; +COMMIT FORCE '22.57.53'; +COMMIT WORK FORCE '22.57.53'; diff --git a/plsql/examples/condition01.sql b/plsql/examples/condition01.sql new file mode 100644 index 0000000..df5362c --- /dev/null +++ b/plsql/examples/condition01.sql @@ -0,0 +1,7 @@ +select department_id, last_name, salary + from employees x + where salary > (select avg(salary) + from employees + where x.department_id = department_id) + order by department_id + diff --git a/plsql/examples/condition02.sql b/plsql/examples/condition02.sql new file mode 100644 index 0000000..07188ef --- /dev/null +++ b/plsql/examples/condition02.sql @@ -0,0 +1,8 @@ +select * + from employees x + where salary > (select avg(salary) from x) + and 1 = 1 + and hiredate = sysdate + and to_yminterval('01-00') < sysdate + and to_yminterval('01-00') + x < sysdate + diff --git a/plsql/examples/condition03.sql b/plsql/examples/condition03.sql new file mode 100644 index 0000000..5aa4cba --- /dev/null +++ b/plsql/examples/condition03.sql @@ -0,0 +1,10 @@ +select * + from employees x + where salary > (select avg(salary) from x) + and 1 = 1 + and hiredate = sysdate + and to_yminterval('01-00') < sysdate + and to_yminterval('01-00') + x < sysdate + or a=b + and d=e + diff --git a/plsql/examples/condition04.sql b/plsql/examples/condition04.sql new file mode 100644 index 0000000..e5463cb --- /dev/null +++ b/plsql/examples/condition04.sql @@ -0,0 +1,36 @@ +select * +from t +where +( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( + ( type = '2' ) or ( type = '3' ) + ) and ( t.cde < 20 ) + ) and ( t.se = 'xxx' ) + ) and ( t.id = '000000000002' ) + ) and ( ( t.attr_1 is null ) or ( t.attr_1 = '*' ) ) + ) and ( ( t.attr_2 is null ) or ( t.attr_2 = '*' ) ) + ) and ( ( t.attr_3 is null ) or ( t.attr_3 = '*' ) ) + ) and ( ( t.attr_4 is null ) or ( t.attr_4 = '*' ) ) + ) and ( ( t.attr_5 is null ) or ( t.attr_5 = '*' ) ) + ) and ( ( t.itype is null ) or ( t.itype = '*' ) ) + ) and ( ( t.inbr is null ) or ( t.inbr = '*' ) ) + ) and ( ( t.stat = '01' ) or ( t.stat = '*' ) ) + ) and ( ( t.orgn is null ) or ( t.orgn = '*' ) ) + ) and ( t.mbr = '0000000000001' ) + ) and ( t.nbr is null ) +) + + diff --git a/plsql/examples/condition05.sql b/plsql/examples/condition05.sql new file mode 100644 index 0000000..e9bb864 --- /dev/null +++ b/plsql/examples/condition05.sql @@ -0,0 +1,20 @@ +select * +from t +where + ( t.type = '2' ) or ( t.type = '3' ) + and t.cde < 20 + and t.se = 'xxx' + and t.id = '000000000002' + and ( ( t.sku_attr_1 is null ) or ( t.sku_attr_1 = '*' ) ) + and ( ( t.sku_attr_2 is null ) or ( t.sku_attr_2 = '*' ) ) + and ( ( t.sku_attr_3 is null ) or ( t.sku_attr_3 = '*' ) ) + and ( ( t.sku_attr_4 is null ) or ( t.sku_attr_4 = '*' ) ) + and ( ( t.sku_attr_5 is null ) or ( t.sku_attr_5 = '*' ) ) + and ( ( t.itype is null ) or ( t.itype = '*' ) ) + and ( ( t.bnbr is null ) or ( t.bnbr = '*' ) ) + and ( ( t.stat = '01' ) or ( t.stat = '*' ) ) + and ( ( t.orgn is null ) or ( t.orgn = '*' ) ) + and ( t.mbr = '0000000000001' ) + and ( t.nbr is null ) + + diff --git a/plsql/examples/condition06.sql b/plsql/examples/condition06.sql new file mode 100644 index 0000000..fccc0f9 --- /dev/null +++ b/plsql/examples/condition06.sql @@ -0,0 +1,14 @@ + select * +from t1, t2 +where (trunc(t1.timestamp) between to_date('110226','yymmdd') and to_date('110326','yymmdd')) +and t1.code(+) = 'cn' +and t1.id(+)=t2.id +and t1.cid=t2.cid +and t1.mid = 1245714070376993504 +and t1.tmst >= to_date('110226','yymmdd') +-- note: this is possible too "column_spec outer_join_sign conditional_operator +and shipper.alt_party_code(+) is null +and t2.code(+) = 'sh' +and t1.sid(+)=t2.sid +and ( ( t1.scode like 'mmm' and t2.scode like 'xax' ) ) + diff --git a/plsql/examples/condition07.sql b/plsql/examples/condition07.sql new file mode 100644 index 0000000..769a772 --- /dev/null +++ b/plsql/examples/condition07.sql @@ -0,0 +1,5 @@ +select * +from append +where +-- note space between '>' and '=' +(length(w.numer) > = 8) diff --git a/plsql/examples/condition08.sql b/plsql/examples/condition08.sql new file mode 100644 index 0000000..80a0cca --- /dev/null +++ b/plsql/examples/condition08.sql @@ -0,0 +1,5 @@ +select * +from "p" +where +-- note there are no parens around 231092 +( ( "p"."id" in 231092 ) ) diff --git a/plsql/examples/condition09.sql b/plsql/examples/condition09.sql new file mode 100644 index 0000000..4d1f738 --- /dev/null +++ b/plsql/examples/condition09.sql @@ -0,0 +1,16 @@ +select + sum(nvl(pl.qty,0)) + from + oline ol, + pline pl, + blocation bl + where + ol.id = pl.id + and pl.no = pl.no + and bl.id = pl.id + and + ( + (select count(*) from la.sa where pl.id like sa.bid) > 0 + or + (select count(*) from la.sa where bl.id like sa.id) > 0 + ) diff --git a/plsql/examples/condition10.sql b/plsql/examples/condition10.sql new file mode 100644 index 0000000..4b73949 --- /dev/null +++ b/plsql/examples/condition10.sql @@ -0,0 +1,15 @@ +select department_id, last_name, salary + from employees x + where + 1 = 1 + and + ( + ( + HI + ) + > + ( + .1 * T.ROWCNT + ) + ) + diff --git a/plsql/examples/condition11.sql b/plsql/examples/condition11.sql new file mode 100644 index 0000000..d93cfbd --- /dev/null +++ b/plsql/examples/condition11.sql @@ -0,0 +1,7 @@ +select distinct X +from X,Y,Z +where + X.id = Z.id (+) +and nvl(X.cid, '^') = nvl(Y.clientid (+), '^') +and 0 = Lib.SKU(X.sid, nvl(Z.cid, '^')) + diff --git a/plsql/examples/condition12.sql b/plsql/examples/condition12.sql new file mode 100644 index 0000000..71a5428 --- /dev/null +++ b/plsql/examples/condition12.sql @@ -0,0 +1,11 @@ +select * from v.e +where + cid <> rid + and rid not in + ( + (select distinct rid from v.s ) + union + (select distinct rid from v.p ) + ) + and "timestamp" <= 1298505600000 + diff --git a/plsql/examples/condition14.sql b/plsql/examples/condition14.sql new file mode 100644 index 0000000..bff0216 --- /dev/null +++ b/plsql/examples/condition14.sql @@ -0,0 +1,2 @@ +select * from dual where trim(sxhnode_key) is not null + diff --git a/plsql/examples/condition15.sql b/plsql/examples/condition15.sql new file mode 100644 index 0000000..a7c1513 --- /dev/null +++ b/plsql/examples/condition15.sql @@ -0,0 +1,13 @@ +select + "a3"."r_id" "r_id" +from + "pe" "a3", + "me" "a2" +where + "a3"."m_id"="a2"."m_id" + and "a2"."mi_t" = + any + ((( + select "a4"."sys$"."id" + from t "a4" + ))) diff --git a/plsql/examples/condition16.sql b/plsql/examples/condition16.sql new file mode 100644 index 0000000..dd711ee --- /dev/null +++ b/plsql/examples/condition16.sql @@ -0,0 +1,3 @@ +select * from persons p + where value(p) is of type(only employee_t) + \ No newline at end of file diff --git a/plsql/examples/connect_by01.sql b/plsql/examples/connect_by01.sql new file mode 100644 index 0000000..2dd3cd1 --- /dev/null +++ b/plsql/examples/connect_by01.sql @@ -0,0 +1,20 @@ +with o as +( + select 'a' obj, 'b' link from dual union all + select 'a', 'c' from dual union all + select 'c', 'd' from dual union all + select 'd', 'c' from dual union all + select 'd', 'e' from dual union all + select 'e', 'e' from dual +) +select + connect_by_root obj root, + level, + obj,link, + sys_connect_by_path(obj||'->'||link,','), + connect_by_iscycle, + connect_by_isleaf +from o +connect by nocycle obj=prior link +start with obj='a' + diff --git a/plsql/examples/connect_by02.sql b/plsql/examples/connect_by02.sql new file mode 100644 index 0000000..f960c52 --- /dev/null +++ b/plsql/examples/connect_by02.sql @@ -0,0 +1,6 @@ +select lpad(' ',2*(level-1)) || last_name org_chart, +employee_id, manager_id, job_id + from employees + start with job_id = 'ad_pres' + connect by prior employee_id = manager_id and level <= 2 + diff --git a/plsql/examples/connect_by03.sql b/plsql/examples/connect_by03.sql new file mode 100644 index 0000000..2f8d7d3 --- /dev/null +++ b/plsql/examples/connect_by03.sql @@ -0,0 +1,7 @@ +select lpad(' ',2*(level-1)) || last_name org_chart, + employee_id, manager_id, job_id + from employees + where job_id != 'fi_mgr' + start with job_id = 'ad_vp' + connect by prior employee_id = manager_id + diff --git a/plsql/examples/connect_by04.sql b/plsql/examples/connect_by04.sql new file mode 100644 index 0000000..e4b8299 --- /dev/null +++ b/plsql/examples/connect_by04.sql @@ -0,0 +1,7 @@ +select lpad(' ',2*(level-1)) || last_name org_chart, + employee_id, manager_id, job_id + from employees + start with job_id = 'ad_vp' + connect by prior employee_id = manager_id + + diff --git a/plsql/examples/connect_by05.sql b/plsql/examples/connect_by05.sql new file mode 100644 index 0000000..72e565a --- /dev/null +++ b/plsql/examples/connect_by05.sql @@ -0,0 +1,9 @@ +with liste as ( + select substr(:liste, instr(','||:liste||',', ',', 1, rn), + instr(','||:liste||',', ',', 1, rn+1) - + instr(','||:liste||',', ',', 1, rn)-1) valeur +from ( + select rownum rn from dual + connect by level<=length(:liste) - length(replace(:liste,',',''))+1)) +select trim(valeur) +from liste diff --git a/plsql/examples/context.sql b/plsql/examples/context.sql new file mode 100644 index 0000000..6672d1e --- /dev/null +++ b/plsql/examples/context.sql @@ -0,0 +1,3 @@ +CREATE CONTEXT hr_context USING emp_mgmt; + + diff --git a/plsql/examples/create_analytic_view.sql b/plsql/examples/create_analytic_view.sql new file mode 100644 index 0000000..8c5f83d --- /dev/null +++ b/plsql/examples/create_analytic_view.sql @@ -0,0 +1,75 @@ +CREATE OR REPLACE ANALYTIC VIEW sales_av +USING sales_fact +DIMENSION BY + (time_attr_dim -- An attribute dimension of time data + KEY month_id REFERENCES month_id + HIERARCHIES ( + time_hier DEFAULT), + product_attr_dim -- An attribute dimension of product data + KEY category_id REFERENCES category_id + HIERARCHIES ( + product_hier DEFAULT), + geography_attr_dim -- An attribute dimension of store data + KEY state_province_id + REFERENCES state_province_id HIERARCHIES ( + geography_hier DEFAULT) + ) +MEASURES( + sales FACT sales, -- A base measure + units FACT units, -- A base measure + -- Calculated measures + sales_prior_period AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1)), + sales_year_ago AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL year)), + chg_sales_year_ago AS (LAG_DIFF(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL year)), + pct_chg_sales_year_ago AS (LAG_DIFF_PERCENT(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL year)), + sales_qtr_ago AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL quarter)), + chg_sales_qtr_ago AS (LAG_DIFF(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL quarter)), + pct_chg_sales_qtr_ago AS (LAG_DIFF_PERCENT(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL quarter)) +) +DEFAULT MEASURE SALES; + +CREATE OR REPLACE ANALYTIC VIEW sales_av +USING av.sales_fact +DIMENSION BY + (time_attr_dim + KEY month_id REFERENCES month_id + HIERARCHIES ( + time_hier DEFAULT), + product_attr_dim + KEY category_id REFERENCES category_id + HIERARCHIES ( + product_hier DEFAULT), + geography_attr_dim + KEY state_province_id + REFERENCES state_province_id + HIERARCHIES ( + geography_hier DEFAULT) + ) +MEASURES + (sales FACT sales, + sales_year_ago AS (LAG(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL year)), + sales_pct_chg_year_ago AS (ROUND(LAG_DIFF_PERCENT(sales) OVER (HIERARCHY time_hier OFFSET 1 ACROSS ANCESTOR AT LEVEL year),2)), + units FACT units + ) +DEFAULT MEASURE SALES; + +CREATE OR REPLACE ANALYTIC VIEW sales_av +USING av.sales_fact +DIMENSION BY + (time_attr_dim + KEY month_id REFERENCES month_id + HIERARCHIES ( + time_hier DEFAULT)) +MEASURES + (sales FACT sales, + avg_sales FACT sales AGGREGATE BY AVG, + count_sales FACT sales AGGREGATE BY COUNT, + max_sales FACT sales AGGREGATE BY MAX, + min_sales FACT sales AGGREGATE BY MIN, + stddev_sales FACT sales AGGREGATE BY STDDEV, + variance_sales FACT sales AGGREGATE BY VARIANCE, + units FACT units, + avg_units FACT units AGGREGATE BY AVG + ) +DEFAULT MEASURE SALES +DEFAULT AGGREGATE BY SUM; diff --git a/plsql/examples/create_attribute_dimension.sql b/plsql/examples/create_attribute_dimension.sql new file mode 100644 index 0000000..68528f2 --- /dev/null +++ b/plsql/examples/create_attribute_dimension.sql @@ -0,0 +1,152 @@ +CREATE OR REPLACE ATTRIBUTE DIMENSION time_attr_dim +DIMENSION TYPE TIME +USING time_dim +ATTRIBUTES + (year_id + CLASSIFICATION caption VALUE 'YEAR_ID' + CLASSIFICATION description VALUE 'YEAR ID', + year_name + CLASSIFICATION caption VALUE 'YEAR_NAME' + CLASSIFICATION description VALUE 'Year', + year_end_date + CLASSIFICATION caption VALUE 'YEAR_END_DATE' + CLASSIFICATION description VALUE 'Year End Date', + quarter_id + CLASSIFICATION caption VALUE 'QUARTER_ID' + CLASSIFICATION description VALUE 'QUARTER ID', + quarter_name + CLASSIFICATION caption VALUE 'QUARTER_NAME' + CLASSIFICATION description VALUE 'Quarter', + quarter_end_date + CLASSIFICATION caption VALUE 'QUARTER_END_DATE' + CLASSIFICATION description VALUE 'Quarter End Date', + quarter_of_year + CLASSIFICATION caption VALUE 'QUARTER_OF_YEAR' + CLASSIFICATION description VALUE 'Quarter of Year', + month_id + CLASSIFICATION caption VALUE 'MONTH_ID' + CLASSIFICATION description VALUE 'MONTH ID', + month_name + CLASSIFICATION caption VALUE 'MONTH_NAME' + CLASSIFICATION description VALUE 'Month', + month_long_name + CLASSIFICATION caption VALUE 'MONTH_LONG_NAME' + CLASSIFICATION description VALUE 'Month Long Name', + month_end_date + CLASSIFICATION caption VALUE 'MONTH_END_DATE' + CLASSIFICATION description VALUE 'Month End Date', + month_of_quarter + CLASSIFICATION caption VALUE 'MONTH_OF_QUARTER' + CLASSIFICATION description VALUE 'Month of Quarter', + month_of_year + CLASSIFICATION caption VALUE 'MONTH_OF_YEAR' + CLASSIFICATION description VALUE 'Month of Year', + season + CLASSIFICATION caption VALUE 'SEASON' + CLASSIFICATION description VALUE 'Season', + season_order + CLASSIFICATION caption VALUE 'SEASON_ORDER' + CLASSIFICATION description VALUE 'Season Order') +LEVEL month + LEVEL TYPE MONTHS + CLASSIFICATION caption VALUE 'MONTH' + CLASSIFICATION description VALUE 'Month' + KEY month_id + MEMBER NAME month_name + MEMBER CAPTION month_name + MEMBER DESCRIPTION month_long_name + ORDER BY month_end_date + DETERMINES (month_end_date, + quarter_id, + season, + season_order, + month_of_year, + month_of_quarter) +LEVEL quarter + LEVEL TYPE QUARTERS + CLASSIFICATION caption VALUE 'QUARTER' + CLASSIFICATION description VALUE 'Quarter' + KEY quarter_id + MEMBER NAME quarter_name + MEMBER CAPTION quarter_name + MEMBER DESCRIPTION quarter_name + ORDER BY quarter_end_date + DETERMINES (quarter_end_date, + quarter_of_year, + year_id) +LEVEL year + LEVEL TYPE YEARS + CLASSIFICATION caption VALUE 'YEAR' + CLASSIFICATION description VALUE 'Year' + KEY year_id + MEMBER NAME year_name + MEMBER CAPTION year_name + MEMBER DESCRIPTION year_name + ORDER BY year_end_date + DETERMINES (year_end_date) +LEVEL season + LEVEL TYPE QUARTERS + CLASSIFICATION caption VALUE 'SEASON' + CLASSIFICATION description VALUE 'Season' + KEY season + MEMBER NAME season + MEMBER CAPTION season + MEMBER DESCRIPTION season +LEVEL month_of_quarter + LEVEL TYPE MONTHS + CLASSIFICATION caption VALUE 'MONTH_OF_QUARTER' + CLASSIFICATION description VALUE 'Month of Quarter' + KEY month_of_quarter; + +CREATE OR REPLACE ATTRIBUTE DIMENSION product_attr_dim +USING product_dim +ATTRIBUTES + (department_id, + department_name, + category_id, + category_name) +LEVEL DEPARTMENT + KEY department_id + ALTERNATE KEY department_name + MEMBER NAME department_name + MEMBER CAPTION department_name + ORDER BY department_name +LEVEL CATEGORY + KEY category_id + ALTERNATE KEY category_name + MEMBER NAME category_name + MEMBER CAPTION category_name + ORDER BY category_name + DETERMINES(department_id) +ALL MEMBER NAME 'ALL PRODUCTS'; + +CREATE OR REPLACE ATTRIBUTE DIMENSION geography_attr_dim +USING geography_dim +ATTRIBUTES + (region_id, + region_name, + country_id, + country_name, + state_province_id, + state_province_name) +LEVEL REGION + KEY region_id + ALTERNATE KEY region_name + MEMBER NAME region_name + MEMBER CAPTION region_name + ORDER BY region_name +LEVEL COUNTRY + KEY country_id + ALTERNATE KEY country_name + MEMBER NAME country_name + MEMBER CAPTION country_name + ORDER BY country_name + DETERMINES(region_id) +LEVEL STATE_PROVINCE + KEY state_province_id + ALTERNATE KEY state_province_name + MEMBER NAME state_province_name + MEMBER CAPTION state_province_name + ORDER BY state_province_name + DETERMINES(country_id) +ALL MEMBER NAME 'ALL CUSTOMERS'; diff --git a/plsql/examples/create_audit_policy.sql b/plsql/examples/create_audit_policy.sql new file mode 100644 index 0000000..fdcf6cf --- /dev/null +++ b/plsql/examples/create_audit_policy.sql @@ -0,0 +1,51 @@ +CREATE AUDIT POLICY table_pol + PRIVILEGES CREATE ANY TABLE, DROP ANY TABLE; + +CREATE AUDIT POLICY dml_pol + ACTIONS DELETE on hr.employees, +INSERT on hr.employees, +UPDATE on hr.employees, + ALL on hr.departments; +CREATE AUDIT POLICY security_pol + ACTIONS ADMINISTER KEY MANAGEMENT; + +CREATE AUDIT POLICY dir_pol + ACTIONS READ DIRECTORY, WRITE DIRECTORY, EXECUTE DIRECTORY; + +CREATE AUDIT POLICY all_actions_pol + ACTIONS ALL; + +CREATE AUDIT POLICY dp_actions_pol + ACTIONS COMPONENT = datapump IMPORT; + +CREATE AUDIT POLICY java_pol + ROLES java_admin, java_deploy; + +CREATE AUDIT POLICY hr_admin_pol + PRIVILEGES CREATE ANY TABLE, DROP ANY TABLE + ACTIONS DELETE on hr.employees, +INSERT on hr.employees, +UPDATE on hr.employees, + ALL on hr.departments, + LOCK TABLE + ROLES audit_admin, audit_viewer; + +CREATE AUDIT POLICY order_updates_pol + ACTIONS UPDATE ON oe.orders + WHEN 'SYS_CONTEXT(''USERENV'', ''IDENTIFICATION_TYPE'') = ''EXTERNAL''' + EVALUATE PER SESSION; + +CREATE AUDIT POLICY emp_updates_pol + ACTIONS DELETE on hr.employees, +INSERT on hr.employees, +UPDATE on hr.employees + WHEN 'UID NOT IN (100, 105, 107)' + EVALUATE PER STATEMENT; + +CREATE AUDIT POLICY local_table_pol + PRIVILEGES CREATE ANY TABLE, DROP ANY TABLE + CONTAINER = CURRENT; + +CREATE AUDIT POLICY common_role1_pol + ROLES c##role1 + CONTAINER = ALL; diff --git a/plsql/examples/create_controlfile.sql b/plsql/examples/create_controlfile.sql new file mode 100644 index 0000000..23872d8 --- /dev/null +++ b/plsql/examples/create_controlfile.sql @@ -0,0 +1,9 @@ +CREATE CONTROLFILE DATABASE "demo" +LOGFILE + GROUP 1 '/path/oracle/dbs/t_log1.f' SIZE 500K, + GROUP 2 '/path/oracle/dbs/t_log2.f' SIZE 500K +RESETLOGS +datafile + '/path/file' +FORCE LOGGING ARCHIVELOG +CHARACTER SET WE8DEC diff --git a/plsql/examples/create_database.sql b/plsql/examples/create_database.sql new file mode 100644 index 0000000..710b2df --- /dev/null +++ b/plsql/examples/create_database.sql @@ -0,0 +1,22 @@ +CREATE DATABASE myoracle + LOGFILE GROUP 1 ('diska:log1.log', 'diskb:log1.log') SIZE 50K, + GROUP 2 ('diska:log2.log', 'diskb:log2.log') SIZE 50K + DATAFILE 'diskc:dbone.dbf' SIZE 30M; + +CREATE DATABASE sample + CONTROLFILE REUSE + LOGFILE + GROUP 1 ('diskx:log1.log', 'disky:log1.log') SIZE 50K, + GROUP 2 ('diskx:log2.log', 'disky:log2.log') SIZE 50K + MAXLOGFILES 5 + MAXLOGHISTORY 100 + MAXDATAFILES 10 + MAXINSTANCES 2 + ARCHIVELOG + CHARACTER SET AL32UTF8 + NATIONAL CHARACTER SET AL16UTF16 + DATAFILE + 'disk1:df1.dbf' AUTOEXTEND ON, + 'disk2:df2.dbf' AUTOEXTEND ON NEXT 10M MAXSIZE UNLIMITED + DEFAULT TEMPORARY TABLESPACE temp_ts + UNDO TABLESPACE undo_ts ; diff --git a/plsql/examples/create_dimension.sql b/plsql/examples/create_dimension.sql new file mode 100644 index 0000000..2787812 --- /dev/null +++ b/plsql/examples/create_dimension.sql @@ -0,0 +1,22 @@ +CREATE DIMENSION customers_dim + LEVEL customer IS (customers.cust_id) + LEVEL city IS (customers.cust_city) + LEVEL state IS (customers.cust_state_province) + LEVEL country IS (countries.country_id) + LEVEL subregion IS (countries.country_subregion) + LEVEL region IS (countries.country_region) + HIERARCHY geog_rollup ( + customer CHILD OF + city CHILD OF + state CHILD OF + country CHILD OF + subregion CHILD OF + region + JOIN KEY (customers.country_id) REFERENCES country + ) + ATTRIBUTE customer DETERMINES + (cust_first_name, cust_last_name, cust_gender, + cust_marital_status, cust_year_of_birth, + cust_income_level, cust_credit_limit) + ATTRIBUTE country DETERMINES (countries.country_name) +; \ No newline at end of file diff --git a/plsql/examples/create_directory.sql b/plsql/examples/create_directory.sql new file mode 100644 index 0000000..4e51e94 --- /dev/null +++ b/plsql/examples/create_directory.sql @@ -0,0 +1,3 @@ +CREATE DIRECTORY mydir AS '/scratch/data/file_data'; +CREATE OR REPLACE DIRECTORY bfile_dir AS '/usr/bin/bfile_dir'; +CREATE OR REPLACE DIRECTORY bfile_dir SHARING = NONE AS '/usr/bin/bfile_dir'; diff --git a/plsql/examples/create_diskgroup.sql b/plsql/examples/create_diskgroup.sql new file mode 100644 index 0000000..c2c2ca0 --- /dev/null +++ b/plsql/examples/create_diskgroup.sql @@ -0,0 +1,3 @@ +CREATE DISKGROUP dgroup_01 + EXTERNAL REDUNDANCY + DISK '/devices/disks/c*'; diff --git a/plsql/examples/create_edition.sql b/plsql/examples/create_edition.sql new file mode 100644 index 0000000..817e088 --- /dev/null +++ b/plsql/examples/create_edition.sql @@ -0,0 +1 @@ +CREATE EDITION test_ed; diff --git a/plsql/examples/create_flashback_archive.sql b/plsql/examples/create_flashback_archive.sql new file mode 100644 index 0000000..9c490ab --- /dev/null +++ b/plsql/examples/create_flashback_archive.sql @@ -0,0 +1,9 @@ +CREATE FLASHBACK ARCHIVE DEFAULT test_archive1 + TABLESPACE example + QUOTA 1 M + RETENTION 1 DAY; + +CREATE FLASHBACK ARCHIVE test_archive2 + TABLESPACE example + QUOTA 1 M + RETENTION 1 DAY; diff --git a/plsql/examples/create_hierarchy.sql b/plsql/examples/create_hierarchy.sql new file mode 100644 index 0000000..0e1ed68 --- /dev/null +++ b/plsql/examples/create_hierarchy.sql @@ -0,0 +1,16 @@ +CREATE OR REPLACE HIERARCHY time_hier -- Hierarchy name +USING time_attr_dim -- Refers to TIME_ATTR_DIM attribute dimension + (month CHILD OF -- Months in the attribute dimension + quarter CHILD OF + year); + +CREATE OR REPLACE HIERARCHY product_hier +USING product_attr_dim + (category + CHILD OF department); + +CREATE OR REPLACE HIERARCHY geography_hier +USING geography_attr_dim + (state_province + CHILD OF country + CHILD OF region); diff --git a/plsql/examples/create_index.sql b/plsql/examples/create_index.sql new file mode 100644 index 0000000..7b104cf --- /dev/null +++ b/plsql/examples/create_index.sql @@ -0,0 +1,13 @@ +CREATE INDEX "NORTHWIND"."IDX_CUSTOMERS_REGION" ON "NORTHWIND"."CUSTOMERS" ("REGION") + PCTFREE 10 INITRANS 2 MAXTRANS 255 COMPUTE STATISTICS + STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "USERS" ; + +CREATE INDEX INDEX_SYS_LOG_YEAR ON SYS_LOG (YEAR) + GLOBAL PARTITION BY RANGE (YEAR) + (PARTITION p1 VALUES LESS THAN (1970), + PARTITION p2 VALUES LESS THAN (2000), + PARTITION p2 VALUES LESS THAN (2030), + PARTITION p3 VALUES LESS THAN (MAXVALUE)); diff --git a/plsql/examples/create_inmemory_join_group.sql b/plsql/examples/create_inmemory_join_group.sql new file mode 100644 index 0000000..e8dd4da --- /dev/null +++ b/plsql/examples/create_inmemory_join_group.sql @@ -0,0 +1,4 @@ +CREATE INMEMORY JOIN GROUP prod_id1 + (inventories(product_id), order_items(product_id)); +CREATE INMEMORY JOIN GROUP prod_id2 + (inventories(product_id), pm.online_media(product_id)); diff --git a/plsql/examples/create_java.sql b/plsql/examples/create_java.sql new file mode 100644 index 0000000..4976719 --- /dev/null +++ b/plsql/examples/create_java.sql @@ -0,0 +1,11 @@ +CREATE JAVA CLASS USING BFILE (java_dir, 'Agent.class') +; +-- requires / as a stmt delimiter +-- CREATE JAVA SOURCE NAMED "Welcome" AS +-- public class Welcome { +-- public static String welcome() { +-- return "Welcome World"; } } +-- / +CREATE JAVA RESOURCE NAMED "appText" + USING BFILE (java_dir, 'textBundle.dat') +; diff --git a/plsql/examples/create_library.sql b/plsql/examples/create_library.sql new file mode 100644 index 0000000..9e01e1e --- /dev/null +++ b/plsql/examples/create_library.sql @@ -0,0 +1,5 @@ +CREATE LIBRARY ext_lib AS 'ddl_1' IN ddl_dir; +CREATE OR REPLACE LIBRARY ext_lib AS 'ddl_1' IN ddl_dir CREDENTIAL ddl_cred; +CREATE LIBRARY ext_lib AS '/OR/lib/ext_lib.so'; +CREATE OR REPLACE LIBRARY ext_lib IS '/OR/newlib/ext_lib.so'; +CREATE LIBRARY app_lib as '${ORACLE_HOME}/lib/app_lib.so' AGENT 'sales.hq.example.com'; \ No newline at end of file diff --git a/plsql/examples/create_lockdown_profile.sql b/plsql/examples/create_lockdown_profile.sql new file mode 100644 index 0000000..8d40c66 --- /dev/null +++ b/plsql/examples/create_lockdown_profile.sql @@ -0,0 +1 @@ +CREATE LOCKDOWN PROFILE hr_prof INCLUDING PRIVATE_DBAAS; diff --git a/plsql/examples/create_materialized_zonemap.sql b/plsql/examples/create_materialized_zonemap.sql new file mode 100644 index 0000000..8d73695 --- /dev/null +++ b/plsql/examples/create_materialized_zonemap.sql @@ -0,0 +1,42 @@ +CREATE MATERIALIZED ZONEMAP sales_zmap + ON sales(cust_id, prod_id); + +CREATE MATERIALIZED ZONEMAP sales_zmap + AS SELECT SYS_OP_ZONE_ID(rowid), + MIN(cust_id), MAX(cust_id), + MIN(prod_id), MAX(prod_id) + FROM sales + GROUP BY SYS_OP_ZONE_ID(rowid); + +CREATE MATERIALIZED ZONEMAP sales_zmap + AS SELECT SYS_OP_ZONE_ID(s.rowid), + MIN(cust_state_province), MAX(cust_state_province), + MIN(cust_city), MAX(cust_city) + FROM sales s + LEFT OUTER JOIN customers c ON s.cust_id = c.cust_id + GROUP BY SYS_OP_ZONE_ID(s.rowid); + +CREATE MATERIALIZED ZONEMAP sales_zmap + AS SELECT SYS_OP_ZONE_ID(s.rowid), + MIN(prod_category), MAX(prod_category), + MIN(prod_subcategory), MAX(prod_subcategory), + MIN(country_id), MAX(country_id), + MIN(cust_state_province), MAX(cust_state_province), + MIN(cust_city), MAX(cust_city) + FROM sales s + LEFT OUTER JOIN products p ON s.prod_id = p.prod_id + LEFT OUTER JOIN customers c ON s.cust_id = c.cust_id + GROUP BY sys_op_zone_id(s.rowid); + +CREATE MATERIALIZED ZONEMAP sales_zmap + AS SELECT SYS_OP_ZONE_ID(s.rowid), + MIN(prod_category), MAX(prod_category), + MIN(prod_subcategory), MAX(prod_subcategory), + MIN(country_id), MAX(country_id), + MIN(cust_state_province), MAX(cust_state_province), + MIN(cust_city), MAX(cust_city) + FROM sales s, products p, customers c + WHERE s.prod_id = p.prod_id(+) AND + s.cust_id = c.cust_id(+) + GROUP BY sys_op_zone_id(s.rowid); + diff --git a/plsql/examples/create_operator.sql b/plsql/examples/create_operator.sql new file mode 100644 index 0000000..c8db0f4 --- /dev/null +++ b/plsql/examples/create_operator.sql @@ -0,0 +1,4 @@ +CREATE OPERATOR eq_op + BINDING (VARCHAR2, VARCHAR2) + RETURN NUMBER + USING eq_f; diff --git a/plsql/examples/create_outline.sql b/plsql/examples/create_outline.sql new file mode 100644 index 0000000..4a116ff --- /dev/null +++ b/plsql/examples/create_outline.sql @@ -0,0 +1,6 @@ +CREATE OUTLINE salaries FOR CATEGORY special + ON SELECT last_name, salary FROM employees; +CREATE OR REPLACE PRIVATE OUTLINE my_salaries + FROM salaries; +CREATE OR REPLACE OUTLINE public_salaries + FROM PRIVATE my_salaries; diff --git a/plsql/examples/create_package.sql b/plsql/examples/create_package.sql new file mode 100644 index 0000000..c81476b --- /dev/null +++ b/plsql/examples/create_package.sql @@ -0,0 +1,5 @@ +CREATE PACKAGE EMP_BONUS AS +LOCAL_PARAM NUMBER; +USER_EXCEPTION EXCEPTION; +PROCEDURE CALC_BONUS (DATE_HIRED DATE); +END EMP_BONUS; \ No newline at end of file diff --git a/plsql/examples/create_package.sql.tree b/plsql/examples/create_package.sql.tree new file mode 100644 index 0000000..5d2f278 --- /dev/null +++ b/plsql/examples/create_package.sql.tree @@ -0,0 +1 @@ +(sql_script (unit_statement (create_package CREATE PACKAGE (package_name (identifier (id_expression (regular_id EMP_BONUS)))) AS (package_obj_spec (variable_declaration (identifier (id_expression (regular_id LOCAL_PARAM))) (type_spec (datatype (native_datatype_element NUMBER))) ;)) (package_obj_spec (exception_declaration (identifier (id_expression (regular_id USER_EXCEPTION))) EXCEPTION ;)) (package_obj_spec (procedure_spec PROCEDURE (identifier (id_expression (regular_id CALC_BONUS))) ( (parameter (parameter_name (identifier (id_expression (regular_id DATE_HIRED)))) (type_spec (datatype (native_datatype_element DATE)))) ) ;)) END (package_name (identifier (id_expression (regular_id EMP_BONUS)))) ;)) ) \ No newline at end of file diff --git a/plsql/examples/create_pmem_filestore.sql b/plsql/examples/create_pmem_filestore.sql new file mode 100644 index 0000000..d9316f6 --- /dev/null +++ b/plsql/examples/create_pmem_filestore.sql @@ -0,0 +1,3 @@ +CREATE PMEM FILESTORE cloud_db_1 MOUNTPOINT '/corp/db/cloud_db_1' + BACKINGFILE '/var/pmem/foo_1.' SIZE 2T BLOCKSIZE 8K + AUTOEXTEND ON NEXT 10G MAXSIZE 3T diff --git a/plsql/examples/create_procedure.sql b/plsql/examples/create_procedure.sql new file mode 100644 index 0000000..4bc1d19 --- /dev/null +++ b/plsql/examples/create_procedure.sql @@ -0,0 +1,7 @@ +CREATE OR REPLACE PROCEDURE PROC(PARAM NUMBER) +IS +LOCAL_PARAM NUMBER; +USER_EXCEPTION EXCEPTION; +BEGIN +LOCAL_PARAM:=0; +END; \ No newline at end of file diff --git a/plsql/examples/create_procedure.sql.tree b/plsql/examples/create_procedure.sql.tree new file mode 100644 index 0000000..8759760 --- /dev/null +++ b/plsql/examples/create_procedure.sql.tree @@ -0,0 +1 @@ +(sql_script (unit_statement (create_procedure_body CREATE OR REPLACE PROCEDURE (procedure_name (identifier (id_expression (regular_id PROC)))) ( (parameter (parameter_name (identifier (id_expression (regular_id (non_reserved_keywords_pre12c PARAM))))) (type_spec (datatype (native_datatype_element NUMBER)))) ) IS (seq_of_declare_specs (declare_spec (variable_declaration (identifier (id_expression (regular_id LOCAL_PARAM))) (type_spec (datatype (native_datatype_element NUMBER))) ;)) (declare_spec (exception_declaration (identifier (id_expression (regular_id USER_EXCEPTION))) EXCEPTION ;))) (body BEGIN (seq_of_statements (statement (assignment_statement (general_element (general_element_part (id_expression (regular_id LOCAL_PARAM)))) := (expression (logical_expression (unary_logical_expression (multiset_expression (relational_expression (compound_expression (concatenation (model_expression (unary_expression (atom (constant (numeric 0)))))))))))))) ;) END) ;)) ) \ No newline at end of file diff --git a/plsql/examples/create_profile.sql b/plsql/examples/create_profile.sql new file mode 100644 index 0000000..14401e1 --- /dev/null +++ b/plsql/examples/create_profile.sql @@ -0,0 +1,3 @@ +CREATE MANDATORY PROFILE c##cdb_profile +LIMIT PASSWORD_VERIFY_FUNCTION my_mandatory_function +CONTAINER = ALL; diff --git a/plsql/examples/create_restore_point.sql b/plsql/examples/create_restore_point.sql new file mode 100644 index 0000000..7ed7c25 --- /dev/null +++ b/plsql/examples/create_restore_point.sql @@ -0,0 +1,3 @@ +CREATE RESTORE POINT good_data; +CREATE RESTORE POINT rp2 for pluggable database pdb; +CREATE RESTORE POINT rp2 for pluggable database pdb preserve; diff --git a/plsql/examples/create_role.sql b/plsql/examples/create_role.sql new file mode 100644 index 0000000..56a9f8f --- /dev/null +++ b/plsql/examples/create_role.sql @@ -0,0 +1,11 @@ +create role TEST_ROLE_AAA ; + +create role TEST_ROLE_BBB NOT IDENTIFIED ; + +create role TEST_ROLE_CCC IDENTIFIED BY TEST_ROLE_AAA; + +create role TEST_ROLE_DDD IDENTIFIED EXTERNALLY; + +create role TEST_ROLE_EEE IDENTIFIED GLOBALLY; + + diff --git a/plsql/examples/create_rollback_segment.sql b/plsql/examples/create_rollback_segment.sql new file mode 100644 index 0000000..4fc0138 --- /dev/null +++ b/plsql/examples/create_rollback_segment.sql @@ -0,0 +1,8 @@ +CREATE ROLLBACK SEGMENT rbs_one TABLESPACE rbs_ts; + +CREATE ROLLBACK SEGMENT rbs_one + TABLESPACE rbs_ts + STORAGE + ( INITIAL 10K + NEXT 10K + MAXEXTENTS UNLIMITED ); \ No newline at end of file diff --git a/plsql/examples/create_spfile.sql b/plsql/examples/create_spfile.sql new file mode 100644 index 0000000..1d75512 --- /dev/null +++ b/plsql/examples/create_spfile.sql @@ -0,0 +1,11 @@ +CREATE SPFILE + FROM PFILE = '$ORACLE_HOME/work/t_init1.ora'; + +CREATE SPFILE = 's_params.ora' + FROM PFILE = '$ORACLE_HOME/work/t_init1.ora'; + +CREATE SPFILE = 's_params.ora' + FROM PFILE = '$ORACLE_HOME/work/t_init1.ora' AS COPY; + +CREATE SPFILE = 's_params.ora' + FROM MEMORY; diff --git a/plsql/examples/create_synonym01.sql b/plsql/examples/create_synonym01.sql new file mode 100644 index 0000000..d0a5938 --- /dev/null +++ b/plsql/examples/create_synonym01.sql @@ -0,0 +1 @@ +create public synonym emp for hr.employees diff --git a/plsql/examples/create_synonym02.sql b/plsql/examples/create_synonym02.sql new file mode 100644 index 0000000..03a3486 --- /dev/null +++ b/plsql/examples/create_synonym02.sql @@ -0,0 +1 @@ +create synonym hr.chicago_employees for hr.employees@chicago_db \ No newline at end of file diff --git a/plsql/examples/create_synonym03.sql b/plsql/examples/create_synonym03.sql new file mode 100644 index 0000000..648f617 --- /dev/null +++ b/plsql/examples/create_synonym03.sql @@ -0,0 +1 @@ +create or replace public synonym depts for departments \ No newline at end of file diff --git a/plsql/examples/create_table.sql b/plsql/examples/create_table.sql new file mode 100644 index 0000000..58dd31d --- /dev/null +++ b/plsql/examples/create_table.sql @@ -0,0 +1,396 @@ +CREATE TABLE employee ( + first_name VARCHAR2(128), + last_name VARCHAR2(128), + empID NUMBER, + salary NUMBER(6) ENCRYPT +); +CREATE TABLE employee ( + first_name VARCHAR2(128), + last_name VARCHAR2(128), + empID NUMBER ENCRYPT NO SALT, + salary NUMBER(6) ENCRYPT USING '3DES168' +); + +CREATE TABLE persons OF person + ( homeaddress NOT NULL, + UNIQUE (homeaddress.phone), + CHECK (homeaddress.zip IS NOT NULL), + CHECK (homeaddress.city <> 'San Francisco') ); + +CREATE TABLE purchaseorder_as_table OF XMLType + XMLSCHEMA "http://xmlns.oracle.com/xdb/documentation/purchaseOrder.xsd" + ELEMENT "PurchaseOrder"; + +CREATE TABLE purchaseorder_as_column OF XMLType + XMLTYPE COLUMN xml_document + ELEMENT + "http://xmlns.oracle.com/xdb/documentation/purchaseOrder.xsd#PurchaseOrder"; + +CREATE TABLE po_binaryxml OF XMLType + XMLTYPE STORE AS BINARY XML + VIRTUAL COLUMNS + (DATE_COL AS (XMLCast(XMLQuery('/PurchaseOrder/@orderDate' + PASSING OBJECT_VALUE RETURNING CONTENT) + AS DATE))) ; + + +create table junk ( + me date, + primary key (me) +); + +CREATE TABLE TEST + AS + WITH TESTCTE AS ( + SELECT 1 ONE FROM DUAL + ) + SELECT 'A', 'B', 'C' + FROM DUAL + JOIN TESTCTE; + +CREATE TABLE DEMO ( + ID NUMBER GENERATED BY DEFAULT AS IDENTITY, + TEST VARCHAR2(100) NOT NULL +); + +CREATE TABLE DEMO ( + ID NUMBER GENERATED BY DEFAULT ON NULL AS IDENTITY, + TEST VARCHAR2(100) NOT NULL +); + +CREATE TABLE DEMO ( + ID NUMBER GENERATED ALWAYS AS IDENTITY, + TEST VARCHAR2(100) NOT NULL +); + +CREATE TABLE products ( + id NUMBER(4) GENERATED BY DEFAULT ON NULL AS IDENTITY (START WITH 101) NOT NULL PRIMARY KEY, + name VARCHAR2(255) NOT NULL, + description VARCHAR2(512), + weight FLOAT, + PRICE NUMERIC(10,-2) +); + +CREATE TABLE products ( + id NUMBER(4) GENERATED BY DEFAULT ON NULL AS IDENTITY (START WITH 101 INCREMENT BY 1 CYCLE CACHE 200) NOT NULL PRIMARY KEY, + name VARCHAR2(255) NOT NULL, + description VARCHAR2(512), + weight FLOAT, + PRICE NUMERIC(10,-2) +); + +create table "DVSADM".CMP3$58238005 nocompress tablespace "DVS_PROOF" nologging lob (VALUE) store as (tablespace "DVS_PROOF" enable storage in row nocache nologging) as select /*+ DYNAMIC_SAMPLING(0) FULL("DVSADM"."DVS_ARCHIVE") */ * from "DVSADM"."DVS_ARCHIVE" sample block( 6.734) mytab; + +CREATE TABLE "APPLSYS"."FND_SEC_GUIDELINES_TL" ( + "CODE" VARCHAR2(20) NOT NULL ENABLE, + "TITLE" VARCHAR2(100) NOT NULL ENABLE, + "DESCRIPTION" VARCHAR2(2000) NOT NULL ENABLE, + "INFO" CLOB NOT NULL ENABLE, + "LANGUAGE" VARCHAR2(30) NOT NULL ENABLE, + "SOURCE_LANG" VARCHAR2(4) NOT NULL ENABLE, + "CREATED_BY" VARCHAR2(30) NOT NULL ENABLE, + "CREATION_DATE" DATE NOT NULL ENABLE, + "LAST_UPDATED_BY" NUMBER(15,0) NOT NULL ENABLE, + "LAST_UPDATE_DATE" DATE NOT NULL ENABLE, + "LAST_UPDATE_LOGIN" NUMBER(15,0)) + PCTFREE 10 PCTUSED 40 INITRANS 10 MAXTRANS 255 LOGGING + STORAGE( + INITIAL 4096 + NEXT 131072 + MINEXTENTS 1 + MAXEXTENTS 2147483645 + PCTINCREASE 0 + FREELISTS 4 + FREELIST GROUPS 4 + BUFFER_POOL DEFAULT) + TABLESPACE "APPS_TS_TX_DATA" + LOB ("INFO") + STORE AS ( + TABLESPACE "APPS_TS_TX_DATA" ENABLE STORAGE IN ROW CHUNK 8192 PCTVERSION 10 + NOCACHE + STORAGE( + INITIAL 4096 + NEXT 131072 + MINEXTENTS 1 + MAXEXTENTS 2147483645 + PCTINCREASE 0 + FREELISTS 4 + FREELIST GROUPS 4 + BUFFER_POOL DEFAULT)) +; + +CREATE TABLE CATEGORIES ( + "CATEGORY_ID" NUMBER(9,0), + "CATEGORY_NAME" VARCHAR2(15 BYTE), + "DESCRIPTION" VARCHAR2(2000 BYTE), + "PICTURE" VARCHAR2(255 BYTE) +) SEGMENT CREATION IMMEDIATE PCTFREE 10 PCTUSED 40 INITRANS 1 MAXTRANS 255 NOCOMPRESS LOGGING STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) TABLESPACE "USERS" ; + +CREATE TABLE "t_ddl_0027"( + "PID" INT, + "FID" INT, + "NAME" VARCHAR(50) DEFAULT 'Tom', + "ADDRESS" VARCHAR(50) NOT NULL, + "DEPT" VARCHAR(50), + CONSTRAINT "PK_ID" PRIMARY KEY("PID"), + CONSTRAINT "CK_DEPT" CHECK ("DEPT" IN('IT', 'SALES', 'MANAGER'))); + +CREATE TABLE "C##RCUSER"."JSON_TRANS"( + "ID" NUMBER(8,0) NOT NULL ENABLE, + "TRANS_MSG" CLOB, + CONSTRAINT "CHECK_JSON" CHECK (trans_msg is json) ENABLE, + PRIMARY KEY ("ID") USING INDEX ENABLE, + SUPPLEMENTAL LOG DATA (ALL) COLUMNS); + +CREATE TABLE "ASEDBUSR"."ECLAIMPROCESS" +( "PKEY" NUMBER(12,0) NOT NULL ENABLE, + "BOID" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "METABO" NUMBER(12,0) NOT NULL ENABLE, + "LASTUPDATE" TIMESTAMP (9) NOT NULL ENABLE, + "PROCESSID" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ROWCOMMENT" VARCHAR2(15 CHAR), + "CREATED" TIMESTAMP (9) NOT NULL ENABLE, + "CREATEDUSER" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "REPLACED" TIMESTAMP (9) NOT NULL ENABLE, + "REPLACEDUSER" VARCHAR2(40 CHAR), + "ITSPROCSUMPKOGU" VARCHAR2(40 CHAR), + "ITSPROCSUMINVOICE" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "IMPORTDATE" DATE NOT NULL ENABLE, + "BATCHIMPORTSTATUS" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSECLAIMPROCVERS" VARCHAR2(40 CHAR), + "ITSECLAIMPROCPAT" VARCHAR2(40 CHAR), + "ITSPROCVERANLASSLE" VARCHAR2(40 CHAR), + "ITSPROCAUSFUEHRLE" VARCHAR2(40 CHAR), + "ITSPROCRECHSTELLER" VARCHAR2(40 CHAR), + "ITSPROCBEARBOE" VARCHAR2(40 CHAR), + "ITSPROCBEARBUSER" VARCHAR2(40 CHAR), + "ITSSUMPROCZAHLER" VARCHAR2(40 CHAR), + "ITSECLAIMSCHADEN" VARCHAR2(40 CHAR), + "ITSECPLSTABRTYP" VARCHAR2(40 CHAR), + "ITSECLAIMLSTFALL" VARCHAR2(40 CHAR), + "ITSECLAIMFDOSSIER" VARCHAR2(40 CHAR), + "VERARBEITUNGCOUNT" NUMBER(12,0), + "ITSPROCBATCHLAUF" VARCHAR2(40 CHAR), + "VORBEHALTOVR" NUMBER(12,0) NOT NULL ENABLE, + "LSTSPERRENOVR" NUMBER(12,0) NOT NULL ENABLE, + "SISTIERUNGOVR" NUMBER(12,0) NOT NULL ENABLE, + "RUECKWEISUNGTEXT" VARCHAR2(350 CHAR), + "FEHLERTEXT" VARCHAR2(1024 CHAR), + "PROVSTATUS" VARCHAR2(40 CHAR), + "ECLAIMSTATUS" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "SBENTSCHEID" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSSUMPROCLSTABR" VARCHAR2(40 CHAR), + "RESPONSE" VARCHAR2(4000 CHAR), + "MODIFIALLOWED" VARCHAR2(40 CHAR), + "LSTAUFSCHUBOVR" NUMBER(12,0) NOT NULL ENABLE, + "ISEXTERNALSTORED" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSPROCGBEREICH" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSPROCECLAIMMAND" VARCHAR2(40 CHAR), + "HABEGRUENDUNG" VARCHAR2(40 CHAR), + "ITSKUERZUNG" VARCHAR2(40 CHAR), + "KUERZUNGPROZENT" NUMBER(9,2), + "ITSSUMPROCKOGU" VARCHAR2(40 CHAR), + "EKOGURUECKWCODE" VARCHAR2(40 CHAR), + "EKOGUERLEDIGTCODE" VARCHAR2(40 CHAR), + "SECONDOPINION" VARCHAR2(40 CHAR), + "ITSTHERAPIEMETHODE" VARCHAR2(40 CHAR), + "ITSPROCSUMKOGU" VARCHAR2(40 CHAR), + "ITSLERBMELDUNG" VARCHAR2(40 CHAR), + "PROCBEHANDORTOVR" NUMBER(12,0) NOT NULL ENABLE, + "ITSAUSZAHLUNGSTYP" VARCHAR2(40 CHAR), + "AUSZAHLTYPOVR" NUMBER(12,0) NOT NULL ENABLE, + "VERARBEITSTATUS" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "FOREIGNCURRACTIV" NUMBER(12,0) NOT NULL ENABLE, + "PROCRECHSTOVR" NUMBER(12,0) NOT NULL ENABLE, + "ISESR" VARCHAR2(40 CHAR), + "ITSKSKTARKOST" VARCHAR2(40 CHAR), + "ITSPROCBEHANDORT" VARCHAR2(40 CHAR), + "STATUS" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ERFREVISION" NUMBER(12,0) NOT NULL ENABLE, + "ITSXMLSTORE" VARCHAR2(40 CHAR), + "ITSANNULXMLSTORE" VARCHAR2(40 CHAR), + "VORBESCHEXPFREIG" VARCHAR2(40 CHAR), + "EINFEXPFREIG" VARCHAR2(40 CHAR), + "SANKTIONSTUFEFLAG" VARCHAR2(40 CHAR), + "SANKTIONSTUFEOVR" NUMBER(12,0) NOT NULL ENABLE, + "BESTDATNOTENKURS" DATE, + "RKOPFCOMMENT" VARCHAR2(255 CHAR), + "INTERNCOMMENT" VARCHAR2(4000 CHAR), + "OVRINTERNCOMMENT" NUMBER(12,0) NOT NULL ENABLE, + "COMMENTLERB" VARCHAR2(4000 CHAR), + "COMMENTLERBOVR" VARCHAR2(4000 CHAR), + "COMMENTLERBKOPF" VARCHAR2(1000 CHAR), + "COMMENTLERBKOPFPOS" VARCHAR2(40 CHAR), + "OVRCOMMENTLERB" NUMBER(12,0) NOT NULL ENABLE, + "OVRCOMMENTLERBKOPF" NUMBER(12,0) NOT NULL ENABLE, + "COMMENTVERS" VARCHAR2(4000 CHAR), + "COMMENTVERSOVR" VARCHAR2(4000 CHAR), + "OVRCOMMENTVERS" NUMBER(12,0) NOT NULL ENABLE, + "OVRCOMMENTVERSKOPF" NUMBER(12,0) NOT NULL ENABLE, + "COMMENTVERSKOPF" VARCHAR2(1000 CHAR), + "COMMENTVERSKOPFPOS" VARCHAR2(40 CHAR), + "USEESRREDBANKINFO" VARCHAR2(40 CHAR), + "ISKOGU" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSBEHANDLUNG" VARCHAR2(40 CHAR), + "ITSSTORNOECLPROC" VARCHAR2(40 CHAR), + "KOPIERT" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "STORNOCODE" VARCHAR2(40 CHAR), + "MCDINVOICESTATUS" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ITSMCDXMLSTORE" VARCHAR2(40 CHAR), + "TARIFGRPMDC" VARCHAR2(35 CHAR), + "SUMPOTEINSPARUNG" NUMBER(14,4) NOT NULL ENABLE, + "ABSCHLUSSDAT" TIMESTAMP (9), + "PROCESSDATE" DATE, + "LSTABRDATE" DATE, + "LSTABRSTORNODATE" DATE, + "REGELVARIABLE1" VARCHAR2(255 CHAR), + "TREATMENTBEGIN" DATE, + "TREATMENTEND" DATE, + "ITSECLAIMPROCINS" VARCHAR2(40 CHAR), + "ITSABTRGERKLG" VARCHAR2(40 CHAR), + "ITSPROCCOPYFROM" VARCHAR2(40 CHAR), + "ARCHIVETAG" VARCHAR2(40 CHAR), + "ECLSABEDRGSTATUS" VARCHAR2(40 CHAR), + "RECHNUNGSTYP" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "MCDVISIBLEDATE" TIMESTAMP (9), + "ITSSENDUNG" VARCHAR2(40 CHAR), + "MDBID" VARCHAR2(255 CHAR), + "LSTZAHLUNGAN" VARCHAR2(40 CHAR), + "LSTFORDERUNGAN" VARCHAR2(40 CHAR), + "LSTZAHLUNGANOVR" NUMBER(12,0) NOT NULL ENABLE, + "LSTFORDERUNGANOVR" NUMBER(12,0) NOT NULL ENABLE, + "FRISTBEGINN" DATE DEFAULT NULL NOT NULL ENABLE, + "EXTPRUEFSYSSTATUS" VARCHAR2(40 CHAR) DEFAULT NULL, + "EXTPRUEFSYSDATE" DATE DEFAULT NULL, + SUPPLEMENTAL LOG DATA (ALL) COLUMNS + ) PCTFREE 10 PCTUSED 40 INITRANS 40 MAXTRANS 255 LOGGING + STORAGE( + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT" + PARTITION BY LIST ("REPLACED") + (PARTITION "P_CURR" VALUES (TIMESTAMP '3000-01-01 00:00:00') SEGMENT CREATION IMMEDIATE + PCTFREE 10 PCTUSED 40 INITRANS 40 MAXTRANS 255 + NOCOMPRESS LOGGING + STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT" , + PARTITION "P_ARCH" VALUES (DEFAULT) SEGMENT CREATION IMMEDIATE + PCTFREE 10 PCTUSED 40 INITRANS 40 MAXTRANS 255 + NOCOMPRESS LOGGING + STORAGE(INITIAL 8388608 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT" ) ENABLE ROW MOVEMENT; + CREATE UNIQUE INDEX "ASEDBUSR"."PK1019008" ON "ASEDBUSR"."ECLAIMPROCESS" ("PKEY") + PCTFREE 10 INITRANS 80 MAXTRANS 255 COMPUTE STATISTICS + STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT"; + ALTER TABLE "ASEDBUSR"."ECLAIMPROCESS" ADD CONSTRAINT "PK1019008" PRIMARY KEY ("PKEY") + USING INDEX "ASEDBUSR"."PK1019008" ENABLE; + +CREATE TABLE "ASEDBUSR"."DOCBESTPARAMATTR" +( "PKEY" NUMBER(12,0) NOT NULL ENABLE, + "BOID" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "METABO" NUMBER(12,0) NOT NULL ENABLE, + "LASTUPDATE" TIMESTAMP (9) NOT NULL ENABLE, + "PROCESSID" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "ROWCOMMENT" VARCHAR2(15 CHAR), + "CREATED" TIMESTAMP (9) NOT NULL ENABLE, + "CREATEDUSER" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "REPLACED" TIMESTAMP (9) NOT NULL ENABLE, + "REPLACEDUSER" VARCHAR2(40 CHAR), + "ARCHIVETAG" VARCHAR2(40 CHAR), + "GUELTAB" DATE NOT NULL ENABLE, + "GUELTBIS" DATE NOT NULL ENABLE, + "ITSPARAMATTRDEF" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "CODEVALUE" VARCHAR2(40 CHAR), + "ITSBOVALUE" VARCHAR2(40 CHAR), + "CLSBOVALUE" NUMBER(12,0), + "INTVALUE" NUMBER(12,0), + "DECVALUE" NUMBER(18,6), + "TEXTVALUE" VARCHAR2(4000 CHAR), + "DATEVALUE" DATE, + "ITSDOCBESTELLUNG" VARCHAR2(40 CHAR) NOT NULL ENABLE, + "MDBID" VARCHAR2(255 CHAR), + "BIGTEXTVALUE" CLOB, + "CK_CODEVALUE" VARCHAR2(40 CHAR), + CONSTRAINT "PK500332" PRIMARY KEY ("PKEY") + USING INDEX PCTFREE 10 INITRANS 80 MAXTRANS 255 COMPUTE STATISTICS + STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT" ENABLE, + SUPPLEMENTAL LOG DATA (ALL) COLUMNS + ) SEGMENT CREATION IMMEDIATE + PCTFREE 10 PCTUSED 40 INITRANS 40 MAXTRANS 255 + NOCOMPRESS LOGGING + STORAGE(INITIAL 65536 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 FREELISTS 1 FREELIST GROUPS 1 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT) + TABLESPACE "ASEDBUSR_DAT" + LOB ("BIGTEXTVALUE") STORE AS SECUREFILE ( + TABLESPACE "ASEDBUSR_DAT" ENABLE STORAGE IN ROW CHUNK 8192 + NOCACHE LOGGING NOCOMPRESS KEEP_DUPLICATES + STORAGE(INITIAL 106496 NEXT 1048576 MINEXTENTS 1 MAXEXTENTS 2147483645 + PCTINCREASE 0 + BUFFER_POOL DEFAULT FLASH_CACHE DEFAULT CELL_FLASH_CACHE DEFAULT)) ; + +CREATE TABLE t_order +(SYS_ID VARCHAR2(32 CHAR) VISIBLE NOT NULL, +ATTACHMENT_NAME VARCHAR2(1024 BYTE) INVISIBLE DEFAULT ''); + +CREATE TABLE "A"."B" ( "FIELD1" NUMBER(19,0) NOT NULL ENABLE, "FIELD2" NUMBER(19,0) NOT NULL ENABLE, PRIMARY KEY ("FIELD1") ENABLE ) +ORGANIZATION INDEX NOCOMPRESS ; + +CREATE BLOCKCHAIN TABLE bank_ledger (bank VARCHAR2(128), deposit_date DATE, deposit_amount NUMBER) +NO DROP UNTIL 31 DAYS IDLE +NO DELETE LOCKED +HASHING USING "SHA2_512" VERSION "v1"; + +CREATE BLOCKCHAIN TABLE bctab_part (trans_id number primary key, sender varchar2(50), recipient varchar2(50), trans_date DATE, amount number) + NO DROP UNTIL 16 DAYS IDLE + NO DELETE UNTIL 25 DAYS AFTER INSERT + HASHING USING "SHA2_512" VERSION "v1" + PARTITION BY RANGE(trans_date) + (PARTITION p1 VALUES LESS THAN (TO_DATE('30-09-2019','dd-mm-yyyy')), + PARTITION p2 VALUES LESS THAN (TO_DATE('31-12-2019','dd-mm-yyyy')), + PARTITION p3 VALUES LESS THAN (TO_DATE('31-03-2020','dd-mm-yyyy')), + PARTITION p4 VALUES LESS THAN (TO_DATE('30-06-2020','dd-mm-yyyy')) + ); + +CREATE TABLE T_ORDER +( + ORDER_ID NUMBER(10) GENERATED BY DEFAULT AS IDENTITY START WITH 1 MAXVALUE 100, + STATUS VARCHAR2(10), + COLUMN1 VARCHAR2(10) +); + +-- see as https://docs.oracle.com/en/database/oracle/oracle-database/21/sqlrf/CREATE-TABLE.html#GUID-F9CE0CC3-13AE-4744-A43C-EAC7A71AAAB6 +CREATE TABLE print_media_demo +( product_id NUMBER(6) + , ad_id NUMBER(6) + , ad_composite BLOB + , ad_sourcetext CLOB + , ad_finaltext CLOB + , ad_fltextn NCLOB + , ad_textdocs_ntab textdoc_tab + , ad_photo BLOB + , ad_graphic BFILE + , ad_header adheader_typ +) NESTED TABLE ad_textdocs_ntab STORE AS textdocs_nestedtab_demo + LOB (ad_composite, ad_photo, ad_finaltext) + STORE AS(STORAGE (INITIAL 20M)) + PARTITION BY RANGE (product_id) + (PARTITION p1 VALUES LESS THAN (3000) TABLESPACE tbs_01 + LOB (ad_composite, ad_photo) + STORE AS (TABLESPACE tbs_02 STORAGE (INITIAL 10M)) + NESTED TABLE ad_textdocs_ntab STORE AS nt_p1 (TABLESPACE example), + PARTITION P2 VALUES LESS THAN (MAXVALUE) + LOB (ad_composite, ad_finaltext) + STORE AS SECUREFILE (TABLESPACE auto_seg_ts) + NESTED TABLE ad_textdocs_ntab STORE AS nt_p2 + ) + TABLESPACE tbs_03; diff --git a/plsql/examples/create_tablespace.sql b/plsql/examples/create_tablespace.sql new file mode 100644 index 0000000..ee55506 --- /dev/null +++ b/plsql/examples/create_tablespace.sql @@ -0,0 +1,57 @@ +CREATE BIGFILE TABLESPACE bigtbs_01 + DATAFILE 'bigtbs_f1.dbf' + SIZE 20M AUTOEXTEND ON; + +CREATE UNDO TABLESPACE undots1 + DATAFILE 'undotbs_1a.dbf' + SIZE 10M AUTOEXTEND ON + RETENTION GUARANTEE; + +CREATE TEMPORARY TABLESPACE temp_demo + TEMPFILE 'temp01.dbf' SIZE 5M AUTOEXTEND ON; + +CREATE TEMPORARY TABLESPACE tbs_05; + +CREATE TEMPORARY TABLESPACE tbs_05 TABLESPACE GROUP ''; + +CREATE TEMPORARY TABLESPACE tbs_temp_02 + TEMPFILE 'temp02.dbf' SIZE 5M AUTOEXTEND ON + TABLESPACE GROUP tbs_grp_01; + +CREATE TABLESPACE tbs_01 + DATAFILE 'tbs_f2.dbf' SIZE 40M + ONLINE; + +CREATE TABLESPACE tbs_03 + DATAFILE 'tbs_f03.dbf' SIZE 20M + LOGGING; + +CREATE TABLESPACE tbs_02 + DATAFILE 'diskb:tbs_f5.dbf' SIZE 500K REUSE + AUTOEXTEND ON NEXT 500K MAXSIZE 100M; + +CREATE TABLESPACE tbs_02 + DATAFILE 'diskb:tbs_f5.dbf' SIZE 500K REUSE + AUTOEXTEND ON NEXT 500K MAXSIZE 100M; + +CREATE TABLESPACE tbs_04 DATAFILE 'file_1.dbf' SIZE 10M + EXTENT MANAGEMENT LOCAL UNIFORM SIZE 128K; + +CREATE TABLESPACE lmt1 DATAFILE 'lmt_file2.dbf' SIZE 100m REUSE + EXTENT MANAGEMENT LOCAL UNIFORM SIZE 1M; + +CREATE TABLESPACE lmt2 DATAFILE 'lmt_file3.dbf' SIZE 100m REUSE + EXTENT MANAGEMENT LOCAL; + +CREATE TABLESPACE encrypt_ts + DATAFILE '$ORACLE_HOME/dbs/encrypt_df.dbf' SIZE 1M + ENCRYPTION USING 'AES256' ; + +CREATE TABLESPACE auto_seg_ts DATAFILE 'file_2.dbf' SIZE 1M + EXTENT MANAGEMENT LOCAL + SEGMENT SPACE MANAGEMENT AUTO; + +CREATE TABLESPACE omf_ts1; + +CREATE TABLESPACE omf_ts2 DATAFILE AUTOEXTEND OFF; + diff --git a/plsql/examples/create_tablespace_set.sql b/plsql/examples/create_tablespace_set.sql new file mode 100644 index 0000000..f0a56ed --- /dev/null +++ b/plsql/examples/create_tablespace_set.sql @@ -0,0 +1,7 @@ +CREATE TABLESPACE SET ts1 + IN SHARDSPACE sgr1 + USING TEMPLATE + ( DATAFILE SIZE 100m + EXTENT MANAGEMENT LOCAL + SEGMENT SPACE MANAGEMENT AUTO + ); diff --git a/plsql/examples/create_type.sql b/plsql/examples/create_type.sql new file mode 100644 index 0000000..98ba5a9 --- /dev/null +++ b/plsql/examples/create_type.sql @@ -0,0 +1,15 @@ +CREATE TYPE address_t AS OBJECT + ( hno NUMBER, + street VARCHAR2(40), + city VARCHAR2(20), + zip VARCHAR2(5), + phone VARCHAR2(10) ); + + +CREATE TYPE person AS OBJECT + ( name VARCHAR2(40), + dateofbirth DATE, + homeaddress address_t, + manager REF person ); +; + diff --git a/plsql/examples/create_view.sql b/plsql/examples/create_view.sql new file mode 100644 index 0000000..f3871fa --- /dev/null +++ b/plsql/examples/create_view.sql @@ -0,0 +1,30 @@ +CREATE OR REPLACE VIEW VIEW_TEST_ROLE AS +SELECT ID, NAME || '-' ALIAS_NAME +FROM TEST_ROLE +WHERE ID < 6 with check option; + +CREATE OR REPLACE FORCE VIEW VIEW_TEST_ROLE AS +SELECT ID, NAME || '-' ALIAS_NAME +FROM TEST_ROLE +WHERE ID < 7 with check option; + +CREATE OR REPLACE NO FORCE VIEW VIEW_TEST_ROLE AS +SELECT ID, NAME || '-' ALIAS_NAME +FROM TEST_ROLE +WHERE ID < 8 with check option; + +CREATE VIEW warehouse_view OF XMLTYPE + XMLSCHEMA "http://www.example.com/xwarehouses.xsd" + ELEMENT "Warehouse" + WITH OBJECT ID + (extract(OBJECT_VALUE, '/Warehouse/Area/text()').getnumberval()) +AS SELECT XMLELEMENT("Warehouse", + XMLFOREST(WarehouseID as "Building", + area as "Area", + docks as "Docks", + docktype as "DockType", + wateraccess as "WaterAccess", + railaccess as "RailAccess", + parking as "Parking", + VClearance as "VClearance")) + FROM warehouse_table; diff --git a/plsql/examples/ctas.sql b/plsql/examples/ctas.sql new file mode 100644 index 0000000..45682af --- /dev/null +++ b/plsql/examples/ctas.sql @@ -0,0 +1,3 @@ +create table junk as select sysdate from dual; + +create table junk1 INITRANS 10 as select sysdate from dual; diff --git a/plsql/examples/datetime01.sql b/plsql/examples/datetime01.sql new file mode 100644 index 0000000..2d9e99d --- /dev/null +++ b/plsql/examples/datetime01.sql @@ -0,0 +1 @@ +select from_tz(cast(to_date('1999-12-01 11:00:00','yyyy-mm-dd hh:mi:ss') as timestamp), 'america/new_york') at time zone 'america/los_angeles' "west coast time" from dual diff --git a/plsql/examples/datetime03.sql b/plsql/examples/datetime03.sql new file mode 100644 index 0000000..1c9ccf5 --- /dev/null +++ b/plsql/examples/datetime03.sql @@ -0,0 +1,3 @@ +select +timestamp '2009-10-29 01:30:00' at time zone 'us/pacific'from dual + diff --git a/plsql/examples/datetime04.sql b/plsql/examples/datetime04.sql new file mode 100644 index 0000000..aae6733 --- /dev/null +++ b/plsql/examples/datetime04.sql @@ -0,0 +1,4 @@ +select +timestamp '2009-10-29 01:30:00' +from dual + diff --git a/plsql/examples/datetime05.sql b/plsql/examples/datetime05.sql new file mode 100644 index 0000000..4529544 --- /dev/null +++ b/plsql/examples/datetime05.sql @@ -0,0 +1 @@ +select date '1900-01-01' from dual diff --git a/plsql/examples/dblink.sql b/plsql/examples/dblink.sql new file mode 100644 index 0000000..ecc9bb6 --- /dev/null +++ b/plsql/examples/dblink.sql @@ -0,0 +1,10 @@ +CREATE PUBLIC DATABASE LINK remote USING 'remote'; +CREATE DATABASE LINK local CONNECT TO hr IDENTIFIED BY p4ssword USING 'local'; +CREATE DATABASE LINK remote.us.example.com CONNECT TO CURRENT_USER USING 'remote'; + +ALTER DATABASE LINK private_link CONNECT TO hr IDENTIFIED BY hr_new_password; +ALTER PUBLIC DATABASE LINK public_link CONNECT TO scott IDENTIFIED BY scott_new_password; +ALTER SHARED PUBLIC DATABASE LINK shared_pub_link CONNECT TO scott IDENTIFIED BY scott_new_password AUTHENTICATED BY hr IDENTIFIED BY hr_new_password; + +DROP PUBLIC DATABASE LINK remote; +DROP DATABASE LINK private_link_name; diff --git a/plsql/examples/dblink01.sql b/plsql/examples/dblink01.sql new file mode 100644 index 0000000..07d2e75 --- /dev/null +++ b/plsql/examples/dblink01.sql @@ -0,0 +1,5 @@ +select last_name, department_name + from employees@remote, departments + where employees.department_id = departments.department_id; + +SELECT * FROM scott.emp@hq.acme.com; diff --git a/plsql/examples/directory.sql b/plsql/examples/directory.sql new file mode 100644 index 0000000..d12fc29 --- /dev/null +++ b/plsql/examples/directory.sql @@ -0,0 +1,3 @@ +CREATE DIRECTORY mydir AS '/scratch/data/file_data'; + +CREATE OR REPLACE DIRECTORY bfile_dir AS '/usr/bin/bfile_dir'; diff --git a/plsql/examples/disassociate_statistics.sql b/plsql/examples/disassociate_statistics.sql new file mode 100644 index 0000000..1713b25 --- /dev/null +++ b/plsql/examples/disassociate_statistics.sql @@ -0,0 +1,2 @@ +DISASSOCIATE STATISTICS FROM COLUMNS hr.emp_mgmt.col1 FORCE; +DISASSOCIATE STATISTICS FROM PACKAGES hr.emp_mgmt; diff --git a/plsql/examples/drop_analytic_view.sql b/plsql/examples/drop_analytic_view.sql new file mode 100644 index 0000000..254136d --- /dev/null +++ b/plsql/examples/drop_analytic_view.sql @@ -0,0 +1,2 @@ +DROP ANALYTIC VIEW sales_av; +DROP ANALYTIC VIEW sch.sales_av; diff --git a/plsql/examples/drop_attribute_dimension.sql b/plsql/examples/drop_attribute_dimension.sql new file mode 100644 index 0000000..e669291 --- /dev/null +++ b/plsql/examples/drop_attribute_dimension.sql @@ -0,0 +1 @@ +DROP ATTRIBUTE DIMENSION product_attr_dim; diff --git a/plsql/examples/drop_audit_policy.sql b/plsql/examples/drop_audit_policy.sql new file mode 100644 index 0000000..a543e78 --- /dev/null +++ b/plsql/examples/drop_audit_policy.sql @@ -0,0 +1 @@ +DROP AUDIT POLICY table_pol; diff --git a/plsql/examples/drop_cluster.sql b/plsql/examples/drop_cluster.sql new file mode 100644 index 0000000..3da0aa6 --- /dev/null +++ b/plsql/examples/drop_cluster.sql @@ -0,0 +1,3 @@ +DROP CLUSTER language; +DROP CLUSTER sch.language; +DROP CLUSTER personnel INCLUDING TABLES CASCADE CONSTRAINTS; \ No newline at end of file diff --git a/plsql/examples/drop_context.sql b/plsql/examples/drop_context.sql new file mode 100644 index 0000000..89593c1 --- /dev/null +++ b/plsql/examples/drop_context.sql @@ -0,0 +1 @@ +DROP CONTEXT hr_context; \ No newline at end of file diff --git a/plsql/examples/drop_database.sql b/plsql/examples/drop_database.sql new file mode 100644 index 0000000..a6fba61 --- /dev/null +++ b/plsql/examples/drop_database.sql @@ -0,0 +1,2 @@ +DROP DATABASE ; +DROP DATABASE INCLUDING BACKUPS NOPROMPT ; diff --git a/plsql/examples/drop_directory.sql b/plsql/examples/drop_directory.sql new file mode 100644 index 0000000..2027aa9 --- /dev/null +++ b/plsql/examples/drop_directory.sql @@ -0,0 +1 @@ +DROP DIRECTORY bfile_dir; diff --git a/plsql/examples/drop_diskgroup.sql b/plsql/examples/drop_diskgroup.sql new file mode 100644 index 0000000..9c0df68 --- /dev/null +++ b/plsql/examples/drop_diskgroup.sql @@ -0,0 +1 @@ +DROP DISKGROUP dgroup_01 INCLUDING CONTENTS; diff --git a/plsql/examples/drop_edition.sql b/plsql/examples/drop_edition.sql new file mode 100644 index 0000000..a0cca7e --- /dev/null +++ b/plsql/examples/drop_edition.sql @@ -0,0 +1 @@ +DROP EDITION TEST_ED; diff --git a/plsql/examples/drop_flashback_archive.sql b/plsql/examples/drop_flashback_archive.sql new file mode 100644 index 0000000..da990fd --- /dev/null +++ b/plsql/examples/drop_flashback_archive.sql @@ -0,0 +1 @@ +DROP FLASHBACK ARCHIVE test_archive2; diff --git a/plsql/examples/drop_hierarchy.sql b/plsql/examples/drop_hierarchy.sql new file mode 100644 index 0000000..b59ab71 --- /dev/null +++ b/plsql/examples/drop_hierarchy.sql @@ -0,0 +1 @@ +DROP HIERARCHY product_hier; diff --git a/plsql/examples/drop_indextype.sql b/plsql/examples/drop_indextype.sql new file mode 100644 index 0000000..4367113 --- /dev/null +++ b/plsql/examples/drop_indextype.sql @@ -0,0 +1,2 @@ +DROP INDEXTYPE position_indextype FORCE; +DROP INDEXTYPE position_indextype; \ No newline at end of file diff --git a/plsql/examples/drop_inmemory_join_group.sql b/plsql/examples/drop_inmemory_join_group.sql new file mode 100644 index 0000000..3315eef --- /dev/null +++ b/plsql/examples/drop_inmemory_join_group.sql @@ -0,0 +1 @@ +DROP INMEMORY JOIN GROUP prod_id1; diff --git a/plsql/examples/drop_java.sql b/plsql/examples/drop_java.sql new file mode 100644 index 0000000..07de662 --- /dev/null +++ b/plsql/examples/drop_java.sql @@ -0,0 +1 @@ +DROP JAVA CLASS "Agent"; diff --git a/plsql/examples/drop_library.sql b/plsql/examples/drop_library.sql new file mode 100644 index 0000000..bb362e5 --- /dev/null +++ b/plsql/examples/drop_library.sql @@ -0,0 +1 @@ +DROP LIBRARY ext_lib; \ No newline at end of file diff --git a/plsql/examples/drop_lockdown_profile.sql b/plsql/examples/drop_lockdown_profile.sql new file mode 100644 index 0000000..8da76b2 --- /dev/null +++ b/plsql/examples/drop_lockdown_profile.sql @@ -0,0 +1 @@ +DROP LOCKDOWN PROFILE hr_prof; diff --git a/plsql/examples/drop_materialized_view.sql b/plsql/examples/drop_materialized_view.sql new file mode 100644 index 0000000..ae766ef --- /dev/null +++ b/plsql/examples/drop_materialized_view.sql @@ -0,0 +1,3 @@ +DROP MATERIALIZED VIEW mv1; + +DROP MATERIALIZED VIEW mv2 PRESERVE TABLE; diff --git a/plsql/examples/drop_materialized_view.sql.tree b/plsql/examples/drop_materialized_view.sql.tree new file mode 100644 index 0000000..81009e8 --- /dev/null +++ b/plsql/examples/drop_materialized_view.sql.tree @@ -0,0 +1 @@ +(sql_script (unit_statement (drop_materialized_view DROP MATERIALIZED VIEW (tableview_name (identifier (id_expression (regular_id mv1)))) ;)) (unit_statement (drop_materialized_view DROP MATERIALIZED VIEW (tableview_name (identifier (id_expression (regular_id mv2)))) PRESERVE TABLE ;)) ) \ No newline at end of file diff --git a/plsql/examples/drop_materialized_zonemap.sql b/plsql/examples/drop_materialized_zonemap.sql new file mode 100644 index 0000000..292f54e --- /dev/null +++ b/plsql/examples/drop_materialized_zonemap.sql @@ -0,0 +1 @@ +DROP MATERIALIZED ZONEMAP sales_zmap; \ No newline at end of file diff --git a/plsql/examples/drop_operator.sql b/plsql/examples/drop_operator.sql new file mode 100644 index 0000000..952e7c3 --- /dev/null +++ b/plsql/examples/drop_operator.sql @@ -0,0 +1 @@ +DROP OPERATOR eq_op; diff --git a/plsql/examples/drop_outline.sql b/plsql/examples/drop_outline.sql new file mode 100644 index 0000000..8232774 --- /dev/null +++ b/plsql/examples/drop_outline.sql @@ -0,0 +1 @@ +DROP OUTLINE salaries; diff --git a/plsql/examples/drop_pmem_filestore.sql b/plsql/examples/drop_pmem_filestore.sql new file mode 100644 index 0000000..a3aa4f2 --- /dev/null +++ b/plsql/examples/drop_pmem_filestore.sql @@ -0,0 +1 @@ +DROP PMEM FILESTORE cloud_db_1 EXCLUDING CONTENTS; diff --git a/plsql/examples/drop_restore_point.sql b/plsql/examples/drop_restore_point.sql new file mode 100644 index 0000000..a955e93 --- /dev/null +++ b/plsql/examples/drop_restore_point.sql @@ -0,0 +1,2 @@ +DROP RESTORE POINT good_data; +DROP RESTORE POINT rp for pluggable database pdb; diff --git a/plsql/examples/drop_role.sql b/plsql/examples/drop_role.sql new file mode 100644 index 0000000..0e64311 --- /dev/null +++ b/plsql/examples/drop_role.sql @@ -0,0 +1 @@ +drop role TEST_ROLE_AAA; diff --git a/plsql/examples/drop_rollback_segment.sql b/plsql/examples/drop_rollback_segment.sql new file mode 100644 index 0000000..b6b9dda --- /dev/null +++ b/plsql/examples/drop_rollback_segment.sql @@ -0,0 +1 @@ +DROP ROLLBACK SEGMENT rbs_one; \ No newline at end of file diff --git a/plsql/examples/drop_synonym01.sql b/plsql/examples/drop_synonym01.sql new file mode 100644 index 0000000..c88e5d7 --- /dev/null +++ b/plsql/examples/drop_synonym01.sql @@ -0,0 +1,4 @@ +drop synonym emp ; +drop public synonym emp ; +drop public synonym emp force; +drop public synonym sch.emp force; diff --git a/plsql/examples/drop_table.sql b/plsql/examples/drop_table.sql new file mode 100644 index 0000000..659816d --- /dev/null +++ b/plsql/examples/drop_table.sql @@ -0,0 +1,4 @@ +DROP TABLE employee; +DROP TABLE employee PURGE; +DROP TABLE employee CASCADE CONSTRAINTS; +DROP TABLE employee CASCADE CONSTRAINTS PURGE; \ No newline at end of file diff --git a/plsql/examples/drop_tablespace.sql b/plsql/examples/drop_tablespace.sql new file mode 100644 index 0000000..e58e9e0 --- /dev/null +++ b/plsql/examples/drop_tablespace.sql @@ -0,0 +1,5 @@ +DROP TABLESPACE tbs_01 + INCLUDING CONTENTS + CASCADE CONSTRAINTS; +DROP TABLESPACE tbs_02 + INCLUDING CONTENTS AND DATAFILES; diff --git a/plsql/examples/drop_tablespace_set.sql b/plsql/examples/drop_tablespace_set.sql new file mode 100644 index 0000000..9e79bb8 --- /dev/null +++ b/plsql/examples/drop_tablespace_set.sql @@ -0,0 +1 @@ +DROP TABLESPACE SET ts1; diff --git a/plsql/examples/drop_user.sql b/plsql/examples/drop_user.sql new file mode 100644 index 0000000..02fdc66 --- /dev/null +++ b/plsql/examples/drop_user.sql @@ -0,0 +1,2 @@ +DROP USER sidney; +DROP USER sidney CASCADE; \ No newline at end of file diff --git a/plsql/examples/drop_view.sql b/plsql/examples/drop_view.sql new file mode 100644 index 0000000..0638096 --- /dev/null +++ b/plsql/examples/drop_view.sql @@ -0,0 +1,2 @@ +DROP VIEW employee; +DROP VIEW employee CASCADE CONSTRAINT; diff --git a/plsql/examples/explain01.sql b/plsql/examples/explain01.sql new file mode 100644 index 0000000..49537cb --- /dev/null +++ b/plsql/examples/explain01.sql @@ -0,0 +1,8 @@ +explain plan + set statement_id = 'raise in tokyo' + into plan_table + for update employees + set salary = salary * 1.10 + where department_id = + (select department_id from departments + where location_id = 1700) diff --git a/plsql/examples/external_table01.sql b/plsql/examples/external_table01.sql new file mode 100644 index 0000000..9f46628 --- /dev/null +++ b/plsql/examples/external_table01.sql @@ -0,0 +1,154 @@ +create table AAAAAAAAA.BBBBBBBBBBBBBBBBBB +( + id NUMBER, + xys_sbxno VARCHAR2(50), + xys_sbxno VARCHAR2(50), + xys_sbxvin VARCHAR2(50), + xys_sbxmanufacturer VARCHAR2(64), + xys_sbxid VARCHAR2(40), + xys_sbxname VARCHAR2(128), + xys_sbxid VARCHAR2(40), + xys_sbxname VARCHAR2(128), + xys_sbxid VARCHAR2(64), + xys_sbxname VARCHAR2(256), + xys_sbxprice NUMBER, + xys_sbxprice NUMBER, + xys_sbxclass VARCHAR2(64), + xys_sbxtype VARCHAR2(64), + xys_sbxno VARCHAR2(200), + xys_sbxcolor VARCHAR2(40), + xys_sbxdate DATE, + xys_sbxdate DATE, + xys_sbxby VARCHAR2(50), + xys_sbxtime DATE, + xys_sbxby VARCHAR2(50), + xys_sbxtime DATE, + xys_sbxflag CHAR(1), + xys_sbxinternet VARCHAR2(2), + xys_sbxgreen VARCHAR2(64), + xys_sbxnum NUMBER, + configure VARCHAR2(200), + xys_sbxstyle VARCHAR2(20), + driver VARCHAR2(80), + blowoff VARCHAR2(64), + xys_sbxmain VARCHAR2(80), + xys_sbxdetail VARCHAR2(80), + xys_sbxtime DATE, + xys_sbxage VARCHAR2(20), + version NUMBER, + xys_sbxbusiness VARCHAR2(10), + xys_sbxnum VARCHAR2(80), + xys_sbxcertified VARCHAR2(20), + xys_sbxprice NUMBER, + xys_sbxtime DATE, + wight NUMBER, + xys_sbxflag VARCHAR2(20), + xys_sbxtype VARCHAR2(40), + xys_sbxparallel VARCHAR2(20), + xys_sbxstatus VARCHAR2(20), + xys_sbxlength NUMBER, + xys_sbxbase NUMBER, + xys_sbxvin VARCHAR2(50), + engine VARCHAR2(200), + xys_sbxdrive VARCHAR2(200), + xys_sbxlength NUMBER, + xys_sbxform VARCHAR2(200), + xys_sbxmodel VARCHAR2(200) +) +organization external +( + type ORACLE_LOADER + default directory EXTERNAL_NEW_SP + access parameters + ( + records delimited by newline + characterset UTF8 + nobadfile + nodiscardfile + nologfile + fields terminated by '<>' + MISSING FIELD VALUES ARE NULL + ( + id , + xys_sbxno , + xys_sbxno , + xys_sbxvin, + xys_sbxmanufacturer , + xys_sbxId , + xys_sbxname, + xys_sbxid , + xys_sbxname , + xys_sbxid , + xys_sbxname , + xys_sbxprice , + xys_sbxpassenger, + mileage , + xys_sbxprice , + xys_sbxbelongs , + xys_sbxno , + xys_sbxaddress, + xys_sbxplate , + xys_sbxappraiser , + xys_sbxprice , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS", + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS", + xys_sbxlicense , + xys_sbxprovince , + xys_sbxcity , + xys_sbxaddress , + xys_sbxid , + xys_sbxid , + xys_sbxname , + xys_sbxphone , + xys_sbxprovince , + xys_sbxcity , + xys_sbxcounty , + xys_sbxstreet , + xys_sbxaddress , + xys_sbxprovince , + xys_sbxcity , + xys_sbxnum , + xys_sbxnums , + xys_sbxtrans , + xys_sbxmortgage , + xys_sbxnum , + xys_sbxkind , + xys_sbxuse , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS", + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + xys_sbxby , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + xys_sbxby , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + xys_sbxflag , + xys_sbxmain , + xys_sbxdetail , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + xys_sbxage , + version , + xys_sbxbusiness , + xys_sbxnum , + xys_sbxcertified , + xys_sbxprice , + xys_sbx CHAR (19) DATE_FORMAT DATE MASK "YYYY-MM-DD HH24:MI:SS" , + wight , + xys_sbxflag , + xys_sbxtype , + xys_sbxparallel , + xys_sbxstatus , + xys_sbxlength, + xys_sbxtype , + xys_sbxtype , + xys_sbxphone , + xys_sbxtype , + xys_sbxplate , + xys_sbxprovince , + xys_sbxcity , + xys_sbxdate , + xys_sbxprovince + ) + ) + location (EXTERNAL_NEW_SP:'APPLY_CAR_DETAILS.csv') +) +reject limit UNLIMITED; diff --git a/plsql/examples/external_table02.sql b/plsql/examples/external_table02.sql new file mode 100644 index 0000000..690f3fd --- /dev/null +++ b/plsql/examples/external_table02.sql @@ -0,0 +1,20 @@ +CREATE TABLE T1_EXT1 ( + ID NUMBER(10), + NAME VARCHAR2(50), + DEPTNO NUMBER(2) +) +ORGANIZATION EXTERNAL ( + TYPE ORACLE_LOADER + DEFAULT DIRECTORY EXTERNAL_DIR + ACCESS PARAMETERS ( + RECORDS DELIMITED BY NEWLINE + FIELDS TERMINATED BY "," + ( + ID, + NAME, + DEPTNO + ) + ) + LOCATION (EXTERNAL_DIR:'t1_data.csv') +) +REJECT LIMIT UNLIMITED; diff --git a/plsql/examples/fetch_clause01.sql b/plsql/examples/fetch_clause01.sql new file mode 100644 index 0000000..e806399 --- /dev/null +++ b/plsql/examples/fetch_clause01.sql @@ -0,0 +1,4 @@ +Select * +fROM green_table +offset 1 rows +fetch FIRST 1 ROWS ONLY; diff --git a/plsql/examples/fetch_clause02.sql b/plsql/examples/fetch_clause02.sql new file mode 100644 index 0000000..d1c3922 --- /dev/null +++ b/plsql/examples/fetch_clause02.sql @@ -0,0 +1,4 @@ +Select * +fROM green_table +offset 1 rows +fetch NEXT 20 percent ROW ONLY diff --git a/plsql/examples/fetch_clause03.sql b/plsql/examples/fetch_clause03.sql new file mode 100644 index 0000000..3d43b83 --- /dev/null +++ b/plsql/examples/fetch_clause03.sql @@ -0,0 +1,5 @@ +select color, favorite +FROM green_table +order by color, favorite +offset 1 rows +fetch NEXT 20 ROW WITH TIES; diff --git a/plsql/examples/fetch_clause04.sql b/plsql/examples/fetch_clause04.sql new file mode 100644 index 0000000..46addda --- /dev/null +++ b/plsql/examples/fetch_clause04.sql @@ -0,0 +1,4 @@ +SELECT + (SELECT ID_ FROM TP_STUFF WHERE TEST='1' FETCH FIRST ROW ONLY) AS MWST_ID +FROM ETL_MD_RAW_ADM ADM +WHERE ADM.STATUS_ART_ID = 0; \ No newline at end of file diff --git a/plsql/examples/flashback01.sql b/plsql/examples/flashback01.sql new file mode 100644 index 0000000..52f9459 --- /dev/null +++ b/plsql/examples/flashback01.sql @@ -0,0 +1 @@ +select value(p$) from "XDB"."XDB$SCHEMA" as of snapshot(:2) p$ where SYS_NC_OID$ = :1 diff --git a/plsql/examples/flashback_table.sql b/plsql/examples/flashback_table.sql new file mode 100644 index 0000000..9f9b5d9 --- /dev/null +++ b/plsql/examples/flashback_table.sql @@ -0,0 +1 @@ +FLASHBACK TABLE hr.employees TO TIMESTAMP TO_TIMESTAMP('29-DEC-20 01.26.29.000000000 PM'); \ No newline at end of file diff --git a/plsql/examples/for_update01.sql b/plsql/examples/for_update01.sql new file mode 100644 index 0000000..ad5980b --- /dev/null +++ b/plsql/examples/for_update01.sql @@ -0,0 +1,4 @@ +select employee_id from (select * from employees) + for update of employee_id + + diff --git a/plsql/examples/for_update02.sql b/plsql/examples/for_update02.sql new file mode 100644 index 0000000..6ea9a8d --- /dev/null +++ b/plsql/examples/for_update02.sql @@ -0,0 +1,4 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update + + diff --git a/plsql/examples/for_update03.sql b/plsql/examples/for_update03.sql new file mode 100644 index 0000000..27a7ae0 --- /dev/null +++ b/plsql/examples/for_update03.sql @@ -0,0 +1,4 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of employee_id + + diff --git a/plsql/examples/for_update04.sql b/plsql/examples/for_update04.sql new file mode 100644 index 0000000..d41b216 --- /dev/null +++ b/plsql/examples/for_update04.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of employee_id nowait + diff --git a/plsql/examples/for_update05.sql b/plsql/examples/for_update05.sql new file mode 100644 index 0000000..0b83ea8 --- /dev/null +++ b/plsql/examples/for_update05.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of employee_id wait 10 + diff --git a/plsql/examples/for_update06.sql b/plsql/examples/for_update06.sql new file mode 100644 index 0000000..06a8e6f --- /dev/null +++ b/plsql/examples/for_update06.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of employee_id skip locked + diff --git a/plsql/examples/for_update07.sql b/plsql/examples/for_update07.sql new file mode 100644 index 0000000..7736043 --- /dev/null +++ b/plsql/examples/for_update07.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of a, b.c, d skip locked + diff --git a/plsql/examples/for_update08.sql b/plsql/examples/for_update08.sql new file mode 100644 index 0000000..b1b2473 --- /dev/null +++ b/plsql/examples/for_update08.sql @@ -0,0 +1,5 @@ +select su.ttype ,su.cid ,su.s_id ,sessiontimezone +from sku su +where (nvl(su.up,'n')='n' and su.ttype=:b0) +for update of su.up +order by su.d diff --git a/plsql/examples/function01.sql b/plsql/examples/function01.sql new file mode 100644 index 0000000..4c80626 --- /dev/null +++ b/plsql/examples/function01.sql @@ -0,0 +1,2 @@ +select decode(decode(decode( (select count(1) from dual), a, 1, 0), 0, 1), 1, 0) from dual +-- select decode(decode(decode(decode(x, 0, 1) , 0, 1), 1, 0 ), 0, 1) from dual diff --git a/plsql/examples/function02.sql b/plsql/examples/function02.sql new file mode 100644 index 0000000..492cb9d --- /dev/null +++ b/plsql/examples/function02.sql @@ -0,0 +1 @@ +select set(x) from dual diff --git a/plsql/examples/function03.sql b/plsql/examples/function03.sql new file mode 100644 index 0000000..e8f8f02 --- /dev/null +++ b/plsql/examples/function03.sql @@ -0,0 +1,4 @@ +select trim(both from con.ke) +from dual + + diff --git a/plsql/examples/function04.sql b/plsql/examples/function04.sql new file mode 100644 index 0000000..c65722f --- /dev/null +++ b/plsql/examples/function04.sql @@ -0,0 +1 @@ +select lnnvl( 2 > 1) from dual diff --git a/plsql/examples/function05.sql b/plsql/examples/function05.sql new file mode 100644 index 0000000..105727c --- /dev/null +++ b/plsql/examples/function05.sql @@ -0,0 +1,3 @@ +select count(*) + from employees + where lnnvl(commission_pct >= .2) diff --git a/plsql/examples/function06.sql b/plsql/examples/function06.sql new file mode 100644 index 0000000..ed4e2eb --- /dev/null +++ b/plsql/examples/function06.sql @@ -0,0 +1 @@ +call dbms_scheduler.auto_purge ( ) diff --git a/plsql/examples/function07.sql b/plsql/examples/function07.sql new file mode 100644 index 0000000..e31f2f0 --- /dev/null +++ b/plsql/examples/function07.sql @@ -0,0 +1,9 @@ +create or replace function budget(job varchar2) return varchar2 SQL_MACRO is +begin + return q'{ + select deptno, sum(sal) budget + from emp + where job = budget.job + group by deptno + }'; +end; diff --git a/plsql/examples/groupby01.sql b/plsql/examples/groupby01.sql new file mode 100644 index 0000000..fb6f361 --- /dev/null +++ b/plsql/examples/groupby01.sql @@ -0,0 +1,9 @@ +select :b3 as l_snap_id , :b2 as p_dbid , :b1 as p_instance_number , nvl(pid, -9) pid , nvl(serial#, -9) serial# , decode(pid, null, null, max(spid)) spid , + decode(pid, null, null, max(program)) program , decode(pid, null, null, max(background)) background , sum(pga_used_mem) pga_used_mem , + sum(pga_alloc_mem) pga_alloc_mem , sum(pga_freeable_mem) pga_freeable_mem , max(pga_alloc_mem) max_pga_alloc_mem , max(pga_max_mem) max_pga_max_mem , + decode(pid, null, avg(pga_alloc_mem), null) avg_pga_alloc_mem , decode(pid, null, stddev(pga_alloc_mem), null) stddev_pga_alloc_mem , + decode(pid, null, count(pid), null) num_processes + from v$process + where program != 'pseudo' + group by grouping sets ( (pid, serial#), () ) + diff --git a/plsql/examples/groupby02.sql b/plsql/examples/groupby02.sql new file mode 100644 index 0000000..bb36a56 --- /dev/null +++ b/plsql/examples/groupby02.sql @@ -0,0 +1,11 @@ +select + decode(pid, null, null, max(program)) program , decode(pid, null, null, max(background)) background , sum(pga_used_mem) pga_used_mem , + sum(pga_alloc_mem) pga_alloc_mem , sum(pga_freeable_mem) pga_freeable_mem , max(pga_alloc_mem) max_pga_alloc_mem , max(pga_max_mem) max_pga_max_mem , + decode(pid, null, avg(pga_alloc_mem), null) avg_pga_alloc_mem , decode(pid, null, stddev(pga_alloc_mem), null) stddev_pga_alloc_mem , + decode(pid, null, count(pid), null) num_processes +from v$process +where program != 'pseudo' +group by grouping sets ( (), ((pid+1), serial#) ) + + + \ No newline at end of file diff --git a/plsql/examples/groupby03.sql b/plsql/examples/groupby03.sql new file mode 100644 index 0000000..64b1783 --- /dev/null +++ b/plsql/examples/groupby03.sql @@ -0,0 +1,4 @@ +select * from x +group by grouping sets +( a, 1 ) + diff --git a/plsql/examples/groupby04.sql b/plsql/examples/groupby04.sql new file mode 100644 index 0000000..1d37e20 --- /dev/null +++ b/plsql/examples/groupby04.sql @@ -0,0 +1,3 @@ +select * from x +group by grouping sets +( (a),1 ) diff --git a/plsql/examples/groupby05.sql b/plsql/examples/groupby05.sql new file mode 100644 index 0000000..6a9f76b --- /dev/null +++ b/plsql/examples/groupby05.sql @@ -0,0 +1,4 @@ +select * from x +group by grouping sets +( ((a),b), ((a),b) ) + diff --git a/plsql/examples/groupby06.sql b/plsql/examples/groupby06.sql new file mode 100644 index 0000000..04330a8 --- /dev/null +++ b/plsql/examples/groupby06.sql @@ -0,0 +1,15 @@ +select +prod_category, prod_subcategory, country_id, cust_city, count(*) + from products, sales, customers + where sales.prod_id = products.prod_id + and sales.cust_id=customers.cust_id + and sales.time_id = '01-oct-00' + and customers.cust_year_of_birth between 1960 and 1970 +group by grouping sets + ( + (prod_category, prod_subcategory, country_id, cust_city), + (prod_category, prod_subcategory, country_id), + (prod_category, prod_subcategory), + country_id + ) +order by prod_category, prod_subcategory, country_id, cust_city diff --git a/plsql/examples/groupby07.sql b/plsql/examples/groupby07.sql new file mode 100644 index 0000000..0c43829 --- /dev/null +++ b/plsql/examples/groupby07.sql @@ -0,0 +1,8 @@ +select decode((tt || tc), '56', count(distinct cn), '57', sum(nu)) as q +from t +where tt='500' + and tc in ('6','7') + and to_char(c,'mm') = '03' + having sum(nu) > 0 +group by tn, ui, (tt || tc) +order by 1 diff --git a/plsql/examples/index.sql b/plsql/examples/index.sql new file mode 100644 index 0000000..15064dd --- /dev/null +++ b/plsql/examples/index.sql @@ -0,0 +1,87 @@ +create index IDX on OBJ (CODE, DOCUMENT); + +ALTER INDEX supplier_idx + RENAME TO supplier_index_name; + +DROP INDEX index_name; + + +CREATE INDEX ord_customer_ix + ON orders (customer_id); + +CREATE INDEX ord_customer_ix_demo + ON orders (customer_id, sales_rep_id) + COMPRESS 1; + +CREATE INDEX ord_customer_ix_demo + ON orders (order_mode) + NOSORT + NOLOGGING; + +CREATE INDEX idx_emp_dept_id ON emp(department_id) PARALLEL 6 ONLINE; + +CREATE INDEX sales_local_idx ON SALES(product_id) LOCAL; + +CREATE INDEX idx_personnel ON CLUSTER personnel; + +CREATE INDEX upper_ix ON employees (UPPER(last_name)); + +CREATE INDEX income_ix + ON employees(salary + (salary*commission_pct)); + +CREATE INDEX src_idx ON print_media(text_length(ad_sourcetext)); + +CREATE INDEX area_idx ON rect_tab x (x.area()); + +CREATE INDEX cust_last_name_ix ON customers (cust_last_name) + GLOBAL PARTITION BY HASH (cust_last_name) + PARTITIONS 4; + +CREATE INDEX prod_idx ON hash_products(category_id) LOCAL + STORE IN (tbs_01, tbs_02); + +CREATE BITMAP INDEX product_bm_ix + ON hash_products(list_price) + TABLESPACE tbs_04; + +CREATE UNIQUE INDEX nested_tab_ix + ON textdocs_nestedtab(NESTED_TABLE_ID, document_typ); + +ALTER INDEX ord_customer_ix REBUILD REVERSE; + +ALTER INDEX ord_customer_ix REBUILD PARALLEL; + +ALTER INDEX oe.cust_lname_ix + INITRANS 5; + +ALTER INDEX upper_ix PARALLEL; + +ALTER INDEX upper_ix RENAME TO upper_name_ix; + +ALTER INDEX cost_ix + MODIFY PARTITION p2 UNUSABLE; + +ALTER INDEX cost_ix UNUSABLE; + +ALTER INDEX cost_ix + REBUILD PARTITION p2; + +ALTER INDEX cost_ix + REBUILD PARTITION p3 NOLOGGING; + +ALTER INDEX cost_ix MODIFY PARTITION p3 + STORAGE(MAXEXTENTS 30) LOGGING; + +ALTER INDEX cost_ix + RENAME PARTITION p3 TO p3_Q3; + +ALTER INDEX cost_ix + SPLIT PARTITION p2 AT (1500) + INTO ( PARTITION p2a TABLESPACE tbs_01 LOGGING, + PARTITION p2b TABLESPACE tbs_02); + +ALTER INDEX cost_ix + DROP PARTITION p1; + +ALTER INDEX prod_idx + MODIFY DEFAULT ATTRIBUTES INITRANS 5; diff --git a/plsql/examples/insert_statement.sql b/plsql/examples/insert_statement.sql new file mode 100644 index 0000000..34b3411 --- /dev/null +++ b/plsql/examples/insert_statement.sql @@ -0,0 +1,6 @@ +DECLARE + V_RECORD EVENT%ROWTYPE; +BEGIN + SELECT * INTO V_RECORD FROM EVENT WHERE ROWNUM=1; + INSERT INTO TMP_EVENT VALUES V_RECORD; +END; \ No newline at end of file diff --git a/plsql/examples/interval01.sql b/plsql/examples/interval01.sql new file mode 100644 index 0000000..e9ac9ec --- /dev/null +++ b/plsql/examples/interval01.sql @@ -0,0 +1,2 @@ +select (systimestamp - order_date) day(9) to second from orders +where order_id = 2458 diff --git a/plsql/examples/interval02.sql b/plsql/examples/interval02.sql new file mode 100644 index 0000000..1b82cc4 --- /dev/null +++ b/plsql/examples/interval02.sql @@ -0,0 +1 @@ +select interval '42' day from dual diff --git a/plsql/examples/interval03.sql b/plsql/examples/interval03.sql new file mode 100644 index 0000000..ce2f815 --- /dev/null +++ b/plsql/examples/interval03.sql @@ -0,0 +1,21 @@ +select + interval '4 5:12:10.222' day to second(3) +,interval '4 5:12' day to minute +,interval '400 5' day(3) to hour +,interval '400' day(3) +,interval '11:12:10.2222222' hour to second(7) +,interval '11:20' hour to minute +,interval '10' hour +,interval '10:22' minute to second +,interval '10' minute +,interval '4' day +,interval '25' hour +,interval '40' minute +,interval '120' hour(3) +,interval '30.12345' second(2,4) +,interval :a day + +,interval '1' year +,interval '1' month + +from dual diff --git a/plsql/examples/interval04.sql b/plsql/examples/interval04.sql new file mode 100644 index 0000000..e8b1e35 --- /dev/null +++ b/plsql/examples/interval04.sql @@ -0,0 +1 @@ +select interval'20' day - interval'240' hour from dual diff --git a/plsql/examples/join01.sql b/plsql/examples/join01.sql new file mode 100644 index 0000000..efee6ca --- /dev/null +++ b/plsql/examples/join01.sql @@ -0,0 +1,5 @@ +select d.department_id as d_dept_id, e.department_id as e_dept_id, e.last_name + from departments d full outer join employees e + on d.department_id = e.department_id + order by d.department_id, e.last_name + diff --git a/plsql/examples/join02.sql b/plsql/examples/join02.sql new file mode 100644 index 0000000..33df17c --- /dev/null +++ b/plsql/examples/join02.sql @@ -0,0 +1,6 @@ +select department_id as d_e_dept_id, e.last_name + from departments d full outer join employees e + using (department_id) + order by department_id, e.last_name + + diff --git a/plsql/examples/join03.sql b/plsql/examples/join03.sql new file mode 100644 index 0000000..3d779a4 --- /dev/null +++ b/plsql/examples/join03.sql @@ -0,0 +1,6 @@ +select d.department_id, e.last_name + from m.departments d right outer join n.employees e + on d.department_id = e.department_id + order by d.department_id, e.last_name + + diff --git a/plsql/examples/join04.sql b/plsql/examples/join04.sql new file mode 100644 index 0000000..e7f07cb --- /dev/null +++ b/plsql/examples/join04.sql @@ -0,0 +1,6 @@ +select d.department_id, e.last_name + from departments d, employees e + where d.department_id = e.department_id(+) + order by d.department_id, e.last_name + + diff --git a/plsql/examples/join05.sql b/plsql/examples/join05.sql new file mode 100644 index 0000000..24bd795 --- /dev/null +++ b/plsql/examples/join05.sql @@ -0,0 +1,8 @@ +select times.time_id, product, quantity from inventory + partition by (product) + right outer join times on (times.time_id = inventory.time_id) + where times.time_id between to_date('01/04/01', 'dd/mm/yy') + and to_date('06/04/01', 'dd/mm/yy') + order by 2,1 + + diff --git a/plsql/examples/join06.sql b/plsql/examples/join06.sql new file mode 100644 index 0000000..8a17093 --- /dev/null +++ b/plsql/examples/join06.sql @@ -0,0 +1,5 @@ +select * from dual d1 +join dual d2 on (d1.dummy = d2.dummy) +join dual d3 on(d1.dummy = d3.dummy) +join dual on(d1.dummy = dual.dummy) + diff --git a/plsql/examples/join07.sql b/plsql/examples/join07.sql new file mode 100644 index 0000000..5fcb6ee --- /dev/null +++ b/plsql/examples/join07.sql @@ -0,0 +1,5 @@ +select * from t1 +join t2 tt2 using(c) +join t3 tt3 using(d) +join t3 using(d) + diff --git a/plsql/examples/join08.sql b/plsql/examples/join08.sql new file mode 100644 index 0000000..cd1dc61 --- /dev/null +++ b/plsql/examples/join08.sql @@ -0,0 +1,8 @@ +select * from dual t1 +join (select * from dual) tt2 using(dummy) +join (select * from dual) using(dummy) +join (select * from dual) d on(d.dummy=tt3.dummy) +inner join (select * from dual) tt2 using(dummy) +inner join (select * from dual) using(dummy) +inner join (select * from dual) d on(d.dummy=t1.dummy) + diff --git a/plsql/examples/join09.sql b/plsql/examples/join09.sql new file mode 100644 index 0000000..07eb779 --- /dev/null +++ b/plsql/examples/join09.sql @@ -0,0 +1,8 @@ +select * from dual t1 +left outer join (select * from dual) tt2 using(dummy) +left outer join (select * from dual) using(dummy) +left outer join (select * from dual) d on(d.dummy=tt3.dummy) +inner join (select * from dual) tt2 using(dummy) +inner join (select * from dual) using(dummy) +inner join (select * from dual) d on(d.dummy=t1.dummy) + diff --git a/plsql/examples/join10.sql b/plsql/examples/join10.sql new file mode 100644 index 0000000..d0c8497 --- /dev/null +++ b/plsql/examples/join10.sql @@ -0,0 +1,5 @@ +select * from dual t1, + ( + dual left outer join (select * from dual) tt2 using(dummy) + ) + diff --git a/plsql/examples/join11.sql b/plsql/examples/join11.sql new file mode 100644 index 0000000..ca1db60 --- /dev/null +++ b/plsql/examples/join11.sql @@ -0,0 +1 @@ +select * from t1, ( t2 left outer join t3 using(dummy) ) diff --git a/plsql/examples/join12.sql b/plsql/examples/join12.sql new file mode 100644 index 0000000..8875651 --- /dev/null +++ b/plsql/examples/join12.sql @@ -0,0 +1,2 @@ +select * from dual,( dual left outer join tt2 using(dummy) ) + diff --git a/plsql/examples/join13.sql b/plsql/examples/join13.sql new file mode 100644 index 0000000..67fc99d --- /dev/null +++ b/plsql/examples/join13.sql @@ -0,0 +1,5 @@ +select * from t1, + (((( + t2 left outer join t3 using(dummy) + )))) + \ No newline at end of file diff --git a/plsql/examples/join14.sql b/plsql/examples/join14.sql new file mode 100644 index 0000000..89a995f --- /dev/null +++ b/plsql/examples/join14.sql @@ -0,0 +1,10 @@ +select * from dual t1, +( + ( + ( + dual t2 join dual t3 using(dummy) ) + left outer join dual t4 using(dummy) ) + left outer join dual t5 using(dummy) ) + + + \ No newline at end of file diff --git a/plsql/examples/join15.sql b/plsql/examples/join15.sql new file mode 100644 index 0000000..7a7f708 --- /dev/null +++ b/plsql/examples/join15.sql @@ -0,0 +1,4 @@ +select * from dual t1, ( dual t2 join dual t3 using(dummy)) left outer join dual t4 using (dummy) + + + \ No newline at end of file diff --git a/plsql/examples/join16.sql b/plsql/examples/join16.sql new file mode 100644 index 0000000..e1ef222 --- /dev/null +++ b/plsql/examples/join16.sql @@ -0,0 +1,5 @@ +select * from dual t1, + dual t2 join dual t3 using(dummy) + left outer join dual t4 using(dummy) + left outer join dual t5 using(dummy) + diff --git a/plsql/examples/join17.sql b/plsql/examples/join17.sql new file mode 100644 index 0000000..24cfc6f --- /dev/null +++ b/plsql/examples/join17.sql @@ -0,0 +1,7 @@ +select * +from hdr a +inner join sh s +inner join ca c +on c.id = s.id +on a.va = s.va + diff --git a/plsql/examples/join18.sql b/plsql/examples/join18.sql new file mode 100644 index 0000000..01aa0b4 --- /dev/null +++ b/plsql/examples/join18.sql @@ -0,0 +1,14 @@ +select department_id as d_e_dept_id, e.last_name + from departments + full outer join employees on (a=b) + left outer join employees on (a=b) + right outer join employees on (a=b) + join employees on (a=b) + inner join employees on (a=b) + cross join employees + natural join employees + + + + + diff --git a/plsql/examples/join19.sql b/plsql/examples/join19.sql new file mode 100644 index 0000000..6ac41ea --- /dev/null +++ b/plsql/examples/join19.sql @@ -0,0 +1 @@ +select d1.*, d2.* from dual d1 cross join dual d2 diff --git a/plsql/examples/join20.sql b/plsql/examples/join20.sql new file mode 100644 index 0000000..c95dfae --- /dev/null +++ b/plsql/examples/join20.sql @@ -0,0 +1 @@ +select d1.*, d2.* from dual cross join dual diff --git a/plsql/examples/join21.sql b/plsql/examples/join21.sql new file mode 100644 index 0000000..918212b --- /dev/null +++ b/plsql/examples/join21.sql @@ -0,0 +1,2 @@ +select * from sys.dual natural join sys.dual + diff --git a/plsql/examples/json_sql.sql b/plsql/examples/json_sql.sql new file mode 100644 index 0000000..812e740 --- /dev/null +++ b/plsql/examples/json_sql.sql @@ -0,0 +1,37 @@ +select 'A' | | 'B' from dual; + +SELECT JSON_OBJECT ( + KEY 'deptno' IS d.department_id, + KEY 'deptname' IS d.department_name + ) "Department Objects" +FROM departments d +ORDER BY d.department_id; + +SELECT JSON_OBJECT(KEY 'VALUE' VALUE COL), t.* FROM T t; + +SELECT JSON_ARRAY ( + JSON_OBJECT('percentage' VALUE .50), + JSON_ARRAY(1,2,3), + 100, + 'California', + null + NULL ON NULL + ) "JSON Array Example" +FROM DUAL; + +SELECT JSON_ARRAYAGG(id ORDER BY id RETURNING VARCHAR2(100)) ID_NUMBERS +FROM id_table; + +SELECT JSON_OBJECTAGG(KEY department_name VALUE department_id) "Department Numbers" +FROM departments +WHERE department_id <= 30; + +SELECT JSON_QUERY('{a:100, b:200, c:300}', '$') AS value +FROM DUAL; + +SELECT JSON_SERIALIZE ('{a:[1,2,3,4]}' RETURNING VARCHAR2(3) TRUNCATE ERROR ON ERROR) from dual; + +SELECT JSON_VALUE('{a:100}', '$.a') AS value FROM DUAL; + + + diff --git a/plsql/examples/keywordasidentifier01.sql b/plsql/examples/keywordasidentifier01.sql new file mode 100644 index 0000000..0628c08 --- /dev/null +++ b/plsql/examples/keywordasidentifier01.sql @@ -0,0 +1 @@ +select timestamp, avg, cume_dist from nulls diff --git a/plsql/examples/keywordasidentifier02.sql b/plsql/examples/keywordasidentifier02.sql new file mode 100644 index 0000000..a2b6c0a --- /dev/null +++ b/plsql/examples/keywordasidentifier02.sql @@ -0,0 +1 @@ +select m.model from model diff --git a/plsql/examples/keywordasidentifier03.sql b/plsql/examples/keywordasidentifier03.sql new file mode 100644 index 0000000..c05b256 --- /dev/null +++ b/plsql/examples/keywordasidentifier03.sql @@ -0,0 +1,24 @@ +select ind.index_owner,ind.index_name,ind.uniqueness + , ind.status,ind.index_type,ind.temporary, ind.partitioned,ind.funcidx_status + , ind.join_index,ind.columns,ie.column_expression + , ind.index_name sdev_link_name,'INDEX' sdev_link_type, ind.index_owner sdev_link_owner +from +( + select index_owner,table_owner,index_name,uniqueness, status,index_type,temporary, partitioned,funcidx_status, join_index + , max(decode(position,1 ,column_name))|| max(decode(position,2 ,', '||column_name))|| max(decode(position,3 ,', '||column_name))|| max(decode(position,4 ,', '||column_name))|| max(decode(position,5 ,', '||column_name))|| max(decode(position,6 ,', '||column_name))|| max(decode(position,7 ,', '||column_name))|| max(decode(position,8 ,', '||column_name))|| max(decode(position,9 ,', '||column_name))|| max(decode(position,10,', '||column_name)) columns + + from + ( + select di.owner index_owner,dc.table_owner,dc.index_name,di.uniqueness, di.status, di.index_type, di.temporary, di.partitioned,di.funcidx_status, di.join_index + , dc.column_name,dc.column_position position + from all_ind_columns dc,all_indexes di + where dc.table_owner = :OBJECT_OWNER + and dc.table_name = :OBJECT_NAME + and dc.index_name = di.index_name + and dc.index_owner = di.owner + ) + group by index_owner,table_owner,index_name,uniqueness, status, index_type, temporary, partitioned,funcidx_status, join_index +) ind, +ALL_IND_EXPRESSIONS ie +where ind.index_name = ie.index_name(+) +and ind.index_owner = ie.index_owner(+) diff --git a/plsql/examples/keywordasidentifier04.sql b/plsql/examples/keywordasidentifier04.sql new file mode 100644 index 0000000..009e71c --- /dev/null +++ b/plsql/examples/keywordasidentifier04.sql @@ -0,0 +1,6 @@ +select bs.keep keep, bs.keep_until keep_until +from v$backup_set bs +union all +select null keep, null keep_until +from v$backup_piece bp + diff --git a/plsql/examples/keywordasidentifier05.sql b/plsql/examples/keywordasidentifier05.sql new file mode 100644 index 0000000..87e8391 --- /dev/null +++ b/plsql/examples/keywordasidentifier05.sql @@ -0,0 +1 @@ +select exception from exception \ No newline at end of file diff --git a/plsql/examples/keywordasidentifier06.sql b/plsql/examples/keywordasidentifier06.sql new file mode 100644 index 0000000..8fc2119 --- /dev/null +++ b/plsql/examples/keywordasidentifier06.sql @@ -0,0 +1,7 @@ +SELECT * FROM PERIOD; +CREATE PROCEDURE TEST AS +BEGIN + IF A.EXISTS() THEN + NULL; + END IF; +END; diff --git a/plsql/examples/least_greatest.sql b/plsql/examples/least_greatest.sql new file mode 100644 index 0000000..e872787 --- /dev/null +++ b/plsql/examples/least_greatest.sql @@ -0,0 +1 @@ +SELECT LEAST(1), LEAST(1, 2), LEAST(1, 2, 3), GREATES(1), GREATEST(1, 2), GREATEST(1, 2, 3) FROM DUAL \ No newline at end of file diff --git a/plsql/examples/lexer01.sql b/plsql/examples/lexer01.sql new file mode 100644 index 0000000..f9eae8c --- /dev/null +++ b/plsql/examples/lexer01.sql @@ -0,0 +1,2 @@ +select * from dual where 1 < > 2 and 1 ! = 2 and 1 ^ /*aaa */ = 2 + diff --git a/plsql/examples/lexer02.sql b/plsql/examples/lexer02.sql new file mode 100644 index 0000000..15aaf84 --- /dev/null +++ b/plsql/examples/lexer02.sql @@ -0,0 +1,2 @@ +select 'A' | | 'B' from dual + diff --git a/plsql/examples/lexer03.sql b/plsql/examples/lexer03.sql new file mode 100644 index 0000000..488fba0 --- /dev/null +++ b/plsql/examples/lexer03.sql @@ -0,0 +1,2 @@ +select :1, :X, :1 + 1, 1 + :2 from A where A=:3 and b= : 4 and c= :5and :A = :b + diff --git a/plsql/examples/lexer04.sql b/plsql/examples/lexer04.sql new file mode 100644 index 0000000..c3931e0 --- /dev/null +++ b/plsql/examples/lexer04.sql @@ -0,0 +1 @@ +select tbl$or$idx$part$num("sys"."wrh$_seg_stat",0,4,0,"rowid") as c1 from t1 diff --git a/plsql/examples/lexer05.sql b/plsql/examples/lexer05.sql new file mode 100644 index 0000000..8dcc674 --- /dev/null +++ b/plsql/examples/lexer05.sql @@ -0,0 +1 @@ +select tbl$or$idx$part$num("sys"."wrh:_seg_stat",0,4,0,"rowid") as c1 from t1 diff --git a/plsql/examples/like01.sql b/plsql/examples/like01.sql new file mode 100644 index 0000000..5b41b6d --- /dev/null +++ b/plsql/examples/like01.sql @@ -0,0 +1,5 @@ +select last_name +from employees +where last_name +like '%a\_b%' escape '\' +order by last_name diff --git a/plsql/examples/materialized_views.sql b/plsql/examples/materialized_views.sql new file mode 100644 index 0000000..e65753b --- /dev/null +++ b/plsql/examples/materialized_views.sql @@ -0,0 +1,119 @@ +CREATE MATERIALIZED VIEW foreign_customers FOR UPDATE + AS SELECT * FROM sh.customers@remote cu + WHERE EXISTS + (SELECT * FROM sh.countries@remote co + WHERE co.country_id = cu.country_id); +CREATE MATERIALIZED VIEW sales_mv + BUILD IMMEDIATE + REFRESH FAST ON COMMIT + AS SELECT t.calendar_year, p.prod_id, + SUM(s.amount_sold) AS sum_sales + FROM times t, products p, sales s + WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id + GROUP BY t.calendar_year, p.prod_id; + +CREATE MATERIALIZED VIEW sales_by_month_by_state + TABLESPACE example + PARALLEL 4 + BUILD IMMEDIATE + REFRESH COMPLETE + ENABLE QUERY REWRITE + AS SELECT t.calendar_month_desc, c.cust_state_province, + SUM(s.amount_sold) AS sum_sales + FROM times t, sales s, customers c + WHERE s.time_id = t.time_id AND s.cust_id = c.cust_id + GROUP BY t.calendar_month_desc, c.cust_state_province; + +CREATE MATERIALIZED VIEW sales_sum_table + ON PREBUILT TABLE WITH REDUCED PRECISION + ENABLE QUERY REWRITE + AS SELECT t.calendar_month_desc AS month, + c.cust_state_province AS state, + SUM(s.amount_sold) AS sales + FROM times t, customers c, sales s + WHERE s.time_id = t.time_id AND s.cust_id = c.cust_id + GROUP BY t.calendar_month_desc, c.cust_state_province; + +CREATE MATERIALIZED VIEW order_data REFRESH WITH ROWID + AS SELECT * FROM orders; + +CREATE MATERIALIZED VIEW warranty_orders REFRESH FAST AS + SELECT order_id, line_item_id, product_id FROM order_items o + WHERE EXISTS + (SELECT * FROM inventories i WHERE o.product_id = i.product_id + AND i.quantity_on_hand IS NOT NULL) + UNION + SELECT order_id, line_item_id, product_id FROM order_items + WHERE quantity > 5; + +CREATE MATERIALIZED VIEW my_warranty_orders + AS SELECT w.order_id, w.line_item_id, o.order_date + FROM warranty_orders w, orders o + WHERE o.order_id = o.order_id + AND o.sales_rep_id = 165; + +CREATE MATERIALIZED VIEW LOG ON customers + PCTFREE 5 + TABLESPACE example + STORAGE (INITIAL 10K); + +CREATE MATERIALIZED VIEW LOG ON customers WITH PRIMARY KEY, ROWID; + +CREATE MATERIALIZED VIEW LOG ON sales + WITH ROWID, SEQUENCE(amount_sold, time_id, prod_id) + INCLUDING NEW VALUES; + +CREATE MATERIALIZED VIEW LOG ON order_items WITH (product_id); + +CREATE MATERIALIZED VIEW products_mv + REFRESH FAST ON COMMIT + AS SELECT SUM(list_price - min_price), category_id + FROM product_information + GROUP BY category_id; + +CREATE MATERIALIZED VIEW TEST + AS + WITH TESTCTE AS ( + SELECT 1 ONE FROM DUAL + ) + SELECT 'A', 'B', 'C' + FROM DUAL + JOIN TESTCTE; + +-- tests for column aliases +CREATE MATERIALIZED VIEW sales_mv (year, "prod") + BUILD IMMEDIATE + REFRESH FAST ON COMMIT + AS SELECT t.calendar_year, p.prod_id, + SUM(s.amount_sold) AS sum_sales + FROM times t, products p, sales s + WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id + GROUP BY t.calendar_year, p.prod_id; + +CREATE MATERIALIZED VIEW sales_mv (year ENCRYPT, prod) + BUILD IMMEDIATE + REFRESH FAST ON COMMIT + AS SELECT t.calendar_year, p.prod_id, + SUM(s.amount_sold) AS sum_sales + FROM times t, products p, sales s + WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id + GROUP BY t.calendar_year, p.prod_id; + +CREATE MATERIALIZED VIEW sales_mv (year ENCRYPT, prod ENCRYPT USING 'some_algorithm' IDENTIFIED BY pass 'int_algorithm' NO SALT) + BUILD IMMEDIATE + REFRESH FAST ON COMMIT + AS SELECT t.calendar_year, p.prod_id, + SUM(s.amount_sold) AS sum_sales + FROM times t, products p, sales s + WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id + GROUP BY t.calendar_year, p.prod_id; + +-- tests for scoped table ref constraints +CREATE MATERIALIZED VIEW sales_mv (year ENCRYPT, prod ENCRYPT, SCOPE FOR (ref_col) IS schema.table_or_alias) + BUILD IMMEDIATE + REFRESH FAST ON COMMIT + AS SELECT t.calendar_year, p.prod_id, + SUM(s.amount_sold) AS sum_sales + FROM times t, products p, sales s + WHERE t.time_id = s.time_id AND p.prod_id = s.prod_id + GROUP BY t.calendar_year, p.prod_id; diff --git a/plsql/examples/max_001.sql b/plsql/examples/max_001.sql new file mode 100644 index 0000000..b06bda8 --- /dev/null +++ b/plsql/examples/max_001.sql @@ -0,0 +1,6 @@ +SELECT + + MAX (DISTINCT miles), + MAX (ALL miles) + +FROM Flights \ No newline at end of file diff --git a/plsql/examples/merge01.sql b/plsql/examples/merge01.sql new file mode 100644 index 0000000..45ea0ca --- /dev/null +++ b/plsql/examples/merge01.sql @@ -0,0 +1,17 @@ +merge into bonuses d + using (select employee_id.* from employees) s + on (employee_id = a) + when matched then update set d.bonus = bonus + delete where (salary > 8000) + when not matched then insert (d.employee_id, d.bonus) + values (s.employee_id, s.salary) + where (s.salary <= 8000); + +merge into (select * from bonuses) d + using (select employee_id.* from employees) s + on (employee_id = a) + when matched then update set d.bonus = bonus + delete where (salary > 8000) + when not matched then insert (d.employee_id, d.bonus) + values (s.employee_id, s.salary) + where (s.salary <= 8000); \ No newline at end of file diff --git a/plsql/examples/merge02.sql b/plsql/examples/merge02.sql new file mode 100644 index 0000000..28baf2f --- /dev/null +++ b/plsql/examples/merge02.sql @@ -0,0 +1,9 @@ +merge into bonuses d + using (select employee_id.* from employees) s + on (employee_id = a) + when not matched then insert (d.employee_id, d.bonus) + values (s.employee_id, s.salary) + where (s.salary <= 8000) + when matched then update set d.bonus = bonus + delete where (salary > 8000) + diff --git a/plsql/examples/merge03.sql b/plsql/examples/merge03.sql new file mode 100644 index 0000000..c8756c5 --- /dev/null +++ b/plsql/examples/merge03.sql @@ -0,0 +1,17 @@ +merge /*+ dynamic_sampling(mm 4) dynamic_sampling_est_cdn(mm) + dynamic_sampling(m 4) dynamic_sampling_est_cdn(m) */ + +into sys.mon_mods_all$ mm +using +( + select decode(grouping_id(tp.bo#,tsp.pobj#,m.obj#),3,tp.bo#,1,tsp.pobj#,m.obj#) obj#, sum(m.inserts) inserts, sum(m.updates) updates, sum(m.deletes) deletes, + decode(sum(bitand(m.flags,1)),0,0,1) +decode(sum(bitand(m.flags,2)),0,0,2) +decode(sum(bitand(m.flags,4)),0,0,4) flags, sum(m.drop_segments) drop_segments + from sys.mon_mods$ m, sys.tabcompart$ tp, sys.tabsubpart$ tsp + where m.obj# = tsp.obj# and tp.obj# = tsp.pobj# + group by rollup(tp.bo#,tsp.pobj#,m.obj#) having grouping_id(tp.bo#,tsp.pobj#,m.obj#) < 7 +) v on +(mm.obj# = v.obj#) +when matched then +update set mm.inserts = mm.inserts + v.inserts, mm.updates = mm.updates + v.updates, mm.deletes = mm.deletes + v.deletes, +mm.flags = mm.flags + v.flags - bitand(mm.flags,v.flags) , mm.drop_segments = mm.drop_segments + v.drop_segments +when not matched then insert values (v.obj#, v.inserts, v.updates, v.deletes, sysdate, v.flags, v.drop_segments) diff --git a/plsql/examples/merge04.sql b/plsql/examples/merge04.sql new file mode 100644 index 0000000..53e3ccd --- /dev/null +++ b/plsql/examples/merge04.sql @@ -0,0 +1,18 @@ +merge /*+ dynamic_sampling(mm 4) dynamic_sampling_est_cdn(mm) + dynamic_sampling(m 4) dynamic_sampling_est_cdn(m) */ + +into sys.mon_mods_all$ mm +using +( + select decode(grouping_id(tp.bo#,tsp.pobj#,m.obj#),3,tp.bo#,1,tsp.pobj#,m.obj#) obj#, sum(m.inserts) inserts, sum(m.updates) updates, sum(m.deletes) deletes, + decode(sum(bitand(m.flags,1)),0,0,1) +decode(sum(bitand(m.flags,2)),0,0,2) +decode(sum(bitand(m.flags,4)),0,0,4) flags, sum(m.drop_segments) drop_segments + from sys.mon_mods$ m, sys.tabcompart$ tp, sys.tabsubpart$ tsp + where m.obj# = tsp.obj# and tp.obj# = tsp.pobj# + group by rollup(tp.bo#,tsp.pobj#,m.obj#) having grouping_id(tp.bo#,tsp.pobj#,m.obj#) < 7 + order by 1, 2, 3 +) v on +(mm.obj# = v.obj#) +when matched then +update set mm.inserts = mm.inserts + v.inserts, mm.updates = mm.updates + v.updates, mm.deletes = mm.deletes + v.deletes, +mm.flags = mm.flags + v.flags - bitand(mm.flags,v.flags) , mm.drop_segments = mm.drop_segments + v.drop_segments +when not matched then insert values (v.obj#, v.inserts, v.updates, v.deletes, sysdate, v.flags, v.drop_segments) diff --git a/plsql/examples/merge05.sql b/plsql/examples/merge05.sql new file mode 100644 index 0000000..d9ae4e9 --- /dev/null +++ b/plsql/examples/merge05.sql @@ -0,0 +1,8 @@ +-- MERGE INTO with a rowtype variable as "insert values" parameter +MERGE INTO salesfront.SF_FORM_REFERENCE_CHOICES_DEF target + USING (select null from dual) + ON (recChoicesDef.id = target.id) +WHEN MATCHED THEN + UPDATE SET target.source_id = recChoicesDef.source_id +WHEN NOT MATCHED THEN + INSERT VALUES recChoicesDef; \ No newline at end of file diff --git a/plsql/examples/model_clause01.sql b/plsql/examples/model_clause01.sql new file mode 100644 index 0000000..300b0f6 --- /dev/null +++ b/plsql/examples/model_clause01.sql @@ -0,0 +1,18 @@ +select country,prod,year,s +from sales_view_ref +model +partition by (country) +dimension by (prod, year) +measures (sale s) +ignore nav +-- cell_reference_options +unique dimension +-- here starts model_rules_clause +rules upsert sequential order +( +s[prod='mouse pad', year=2001] = s['mouse pad', 1999] + s['mouse pad', 2000], +s['standard mouse', 2002] = s['standard mouse', 2001] +) +order by country, prod, year + + diff --git a/plsql/examples/model_clause02.sql b/plsql/examples/model_clause02.sql new file mode 100644 index 0000000..7559ebb --- /dev/null +++ b/plsql/examples/model_clause02.sql @@ -0,0 +1,16 @@ +select country, year, sale, csum + from + (select country, year, sum(sale) sale + from sales_view_ref + group by country, year + ) + model dimension by (country, year) + measures (sale, 0 csum) + rules (csum[any, any]= + sum(sale) over (partition by country + order by year + rows unbounded preceding) + ) + order by country, year + + diff --git a/plsql/examples/model_clause03.sql b/plsql/examples/model_clause03.sql new file mode 100644 index 0000000..1459be9 --- /dev/null +++ b/plsql/examples/model_clause03.sql @@ -0,0 +1,15 @@ +select country,prod,year,s + from sales_view_ref + model + partition by (country) + dimension by (prod, year) + measures (sale s) + ignore nav + unique dimension + rules upsert sequential order + ( + s[prod='mouse pad'] = 1, + s['standard mouse'] = 2 + ) + order by country, prod, year + diff --git a/plsql/examples/model_clause04.sql b/plsql/examples/model_clause04.sql new file mode 100644 index 0000000..cc40f38 --- /dev/null +++ b/plsql/examples/model_clause04.sql @@ -0,0 +1,15 @@ +select country, year, sale, csum + from + (select country, year, salex sale + from sales_view_ref + group by country, year + ) + model dimension by (country, year) + measures (sale, 0 csum) + rules + ( + s['standard mouse'] = 2 + ) + order by country, year + + \ No newline at end of file diff --git a/plsql/examples/model_clause05.sql b/plsql/examples/model_clause05.sql new file mode 100644 index 0000000..bb3b96a --- /dev/null +++ b/plsql/examples/model_clause05.sql @@ -0,0 +1,14 @@ +select country, year, sale, csum + from + (select country, year, salex sale + from sales_view_ref + group by country, year + ) m + model dimension by (country, year) + measures (sale, 0 csum) + rules + ( + s['standard mouse'] = 2 + ) + order by country, year + diff --git a/plsql/examples/noaudit_statement.sql b/plsql/examples/noaudit_statement.sql new file mode 100644 index 0000000..b65c024 --- /dev/null +++ b/plsql/examples/noaudit_statement.sql @@ -0,0 +1,8 @@ +NOAUDIT ROLE; +NOAUDIT SELECT TABLE BY hr; +NOAUDIT DELETE ANY TABLE; +NOAUDIT SELECT + ON hr.employees; +NOAUDIT SELECT + ON hr.employees + WHENEVER SUCCESSFUL; diff --git a/plsql/examples/numbers01.sql b/plsql/examples/numbers01.sql new file mode 100644 index 0000000..04344c2 --- /dev/null +++ b/plsql/examples/numbers01.sql @@ -0,0 +1,13 @@ +select 25 +, +6.34 +, 0.5 +, 25e-03 +, -1 -- Here are some valid floating-point number literals: +, 25f +, +6.34F +, 0.5d +, -1D +, (sysdate -1d) -- here we subtract "one" in decimal format +, sysdate -1m -- here we subtract "one" and "m" is column's alias +, sysdate -1dm +from dual diff --git a/plsql/examples/nvl_001.sql b/plsql/examples/nvl_001.sql new file mode 100644 index 0000000..dc12104 --- /dev/null +++ b/plsql/examples/nvl_001.sql @@ -0,0 +1,4 @@ +SELECT last_name, +NVL(TO_CHAR(commission_pct), 'Not Applicable') "COMMISSION" FROM employees +WHERE last_name LIKE 'B%' +ORDER BY last_name \ No newline at end of file diff --git a/plsql/examples/object_access01.sql b/plsql/examples/object_access01.sql new file mode 100644 index 0000000..236c23b --- /dev/null +++ b/plsql/examples/object_access01.sql @@ -0,0 +1,18 @@ +select +extractvalue(value(t), '/select_list_item/pos') + 1 pos, +extractvalue(value(t), '/select_list_item/value') res, +extractvalue(value(t), '/select_list_item/nonnulls') nonnulls, +extractvalue(value(t), '/select_list_item/ndv') ndv, +extractvalue(value(t), '/select_list_item/split') split, +extractvalue(value(t), '/select_list_item/rsize') rsize, +extractvalue(value(t), '/select_list_item/rowcnt') rowcnt, +extract(value(t), '/select_list_item/hash_val').getclobval() hashval +from +table +( + xmlsequence + ( + extract(:b1 , '/process_result/select_list_item') + ) +) t + diff --git a/plsql/examples/offset_clause.sql b/plsql/examples/offset_clause.sql new file mode 100644 index 0000000..859196b --- /dev/null +++ b/plsql/examples/offset_clause.sql @@ -0,0 +1,3 @@ +Select * +fROM green_table +offset 1 row; diff --git a/plsql/examples/order_by01.sql b/plsql/examples/order_by01.sql new file mode 100644 index 0000000..ab2a794 --- /dev/null +++ b/plsql/examples/order_by01.sql @@ -0,0 +1 @@ +select * from dual order by 1 diff --git a/plsql/examples/order_by02.sql b/plsql/examples/order_by02.sql new file mode 100644 index 0000000..2abe954 --- /dev/null +++ b/plsql/examples/order_by02.sql @@ -0,0 +1 @@ +select * from dual order by 1 asc diff --git a/plsql/examples/order_by03.sql b/plsql/examples/order_by03.sql new file mode 100644 index 0000000..517b05a --- /dev/null +++ b/plsql/examples/order_by03.sql @@ -0,0 +1 @@ +select * from dual order by m.year, m.title, f(a) diff --git a/plsql/examples/order_by04.sql b/plsql/examples/order_by04.sql new file mode 100644 index 0000000..0c60c34 --- /dev/null +++ b/plsql/examples/order_by04.sql @@ -0,0 +1 @@ +select * from dual order by a nulls first, b nulls last diff --git a/plsql/examples/order_by05.sql b/plsql/examples/order_by05.sql new file mode 100644 index 0000000..5ae8f42 --- /dev/null +++ b/plsql/examples/order_by05.sql @@ -0,0 +1 @@ +select * from dual order siblings by a nulls first, b nulls last, c nulls last, d nulls last, e nulls last \ No newline at end of file diff --git a/plsql/examples/order_by06.sql b/plsql/examples/order_by06.sql new file mode 100644 index 0000000..9127e62 --- /dev/null +++ b/plsql/examples/order_by06.sql @@ -0,0 +1 @@ +with a as (select * from dual order by 1) select * from a diff --git a/plsql/examples/package_body.sql b/plsql/examples/package_body.sql new file mode 100644 index 0000000..d781ebd --- /dev/null +++ b/plsql/examples/package_body.sql @@ -0,0 +1,8 @@ +CREATE PACKAGE BODY EMP_BONUS AS +LOCAL_PARAM NUMBER; +USER_EXCEPTION EXCEPTION; +PROCEDURE CALC_BONUS (DATE_HIRED DATE) IS +BEGIN +LOCAL_PARAM:=0; +END; +END EMP_BONUS; \ No newline at end of file diff --git a/plsql/examples/package_body.sql.tree b/plsql/examples/package_body.sql.tree new file mode 100644 index 0000000..d850d98 --- /dev/null +++ b/plsql/examples/package_body.sql.tree @@ -0,0 +1 @@ +(sql_script (unit_statement (create_package_body CREATE PACKAGE BODY (package_name (identifier (id_expression (regular_id EMP_BONUS)))) AS (package_obj_body (variable_declaration (identifier (id_expression (regular_id LOCAL_PARAM))) (type_spec (datatype (native_datatype_element NUMBER))) ;)) (package_obj_body (exception_declaration (identifier (id_expression (regular_id USER_EXCEPTION))) EXCEPTION ;)) (package_obj_body (procedure_body PROCEDURE (identifier (id_expression (regular_id CALC_BONUS))) ( (parameter (parameter_name (identifier (id_expression (regular_id DATE_HIRED)))) (type_spec (datatype (native_datatype_element DATE)))) ) IS (body BEGIN (seq_of_statements (statement (assignment_statement (general_element (general_element_part (id_expression (regular_id LOCAL_PARAM)))) := (expression (logical_expression (unary_logical_expression (multiset_expression (relational_expression (compound_expression (concatenation (model_expression (unary_expression (atom (constant (numeric 0)))))))))))))) ;) END) ;)) END (package_name (identifier (id_expression (regular_id EMP_BONUS)))) ;)) ) \ No newline at end of file diff --git a/plsql/examples/packagebody_function.sql b/plsql/examples/packagebody_function.sql new file mode 100644 index 0000000..496d2e8 --- /dev/null +++ b/plsql/examples/packagebody_function.sql @@ -0,0 +1,12 @@ +-- Test for ignoring the order of DETERMINISTIC and PIPELINED keywords in function bodies +CREATE OR REPLACE PACKAGE BODY TEST AS + FUNCTION TEST_FUNC RETURN NUMBER PIPELINED DETERMINISTIC AS + BEGIN + RETURN NULL; + END TEST_FUNC; + + FUNCTION TEST_FUNC2 RETURN NUMBER DETERMINISTIC PIPELINED AS + BEGIN + RETURN NULL; + END TEST_FUNC2; +END TEST; diff --git a/plsql/examples/packagespec_function.sql b/plsql/examples/packagespec_function.sql new file mode 100644 index 0000000..8ba9d89 --- /dev/null +++ b/plsql/examples/packagespec_function.sql @@ -0,0 +1,4 @@ +-- Adding pipelined and deterministic keyword in one function spec +CREATE OR REPLACE PACKAGE TEST IS + FUNCTION TEST_FUNC RETURN NUMBER PIPELINED DETERMINISTIC; +END TEST; diff --git a/plsql/examples/partitioned_tables.sql b/plsql/examples/partitioned_tables.sql new file mode 100644 index 0000000..988d3bf --- /dev/null +++ b/plsql/examples/partitioned_tables.sql @@ -0,0 +1,154 @@ +-- https://docs.oracle.com/cd/E18283_01/server.112/e16541/part_admin001.htm +CREATE TABLE sales + ( prod_id NUMBER(6) + , cust_id NUMBER + , time_id DATE + , channel_id CHAR(1) + , promo_id NUMBER(6) + , quantity_sold NUMBER(3) + , amount_sold NUMBER(10,2) + ) + PARTITION BY RANGE (time_id) + ( PARTITION sales_q1_2006 VALUES LESS THAN (TO_DATE('01-APR-2006','dd-MON-yyyy')) + TABLESPACE tsa + , PARTITION sales_q2_2006 VALUES LESS THAN (TO_DATE('01-JUL-2006','dd-MON-yyyy')) + TABLESPACE tsb + , PARTITION sales_q3_2006 VALUES LESS THAN (TO_DATE('01-OCT-2006','dd-MON-yyyy')) + TABLESPACE tsc + , PARTITION sales_q4_2006 VALUES LESS THAN (TO_DATE('01-JAN-2007','dd-MON-yyyy')) + TABLESPACE tsd + ); + + +CREATE TABLE sales + ( prod_id NUMBER(6) + , cust_id NUMBER + , time_id DATE + , channel_id CHAR(1) + , promo_id NUMBER(6) + , quantity_sold NUMBER(3) + , amount_sold NUMBER(10,2) + ) + STORAGE (INITIAL 100K NEXT 50K) LOGGING + PARTITION BY RANGE (time_id) + ( PARTITION sales_q1_2006 VALUES LESS THAN (TO_DATE('01-APR-2006','dd-MON-yyyy')) + TABLESPACE tsa STORAGE (INITIAL 20K NEXT 10K) + , PARTITION sales_q2_2006 VALUES LESS THAN (TO_DATE('01-JUL-2006','dd-MON-yyyy')) + TABLESPACE tsb + , PARTITION sales_q3_2006 VALUES LESS THAN (TO_DATE('01-OCT-2006','dd-MON-yyyy')) + TABLESPACE tsc + , PARTITION sales_q4_2006 VALUES LESS THAN (TO_DATE('01-JAN-2007','dd-MON-yyyy')) + TABLESPACE tsd + ) + ENABLE ROW MOVEMENT; + + +CREATE TABLE interval_sales + ( prod_id NUMBER(6) + , cust_id NUMBER + , time_id DATE + , channel_id CHAR(1) + , promo_id NUMBER(6) + , quantity_sold NUMBER(3) + , amount_sold NUMBER(10,2) + ) + PARTITION BY RANGE (time_id) + INTERVAL(NUMTOYMINTERVAL(1, 'MONTH')) + ( PARTITION p0 VALUES LESS THAN (TO_DATE('1-1-2007', 'DD-MM-YYYY')), + PARTITION p1 VALUES LESS THAN (TO_DATE('1-1-2008', 'DD-MM-YYYY')), + PARTITION p2 VALUES LESS THAN (TO_DATE('1-7-2009', 'DD-MM-YYYY')), + PARTITION p3 VALUES LESS THAN (TO_DATE('1-1-2010', 'DD-MM-YYYY')) ); + +CREATE TABLE customers_demo ( + customer_id number(6), + cust_first_name varchar2(20), + cust_last_name varchar2(20), + credit_limit number(9,2)) +PARTITION BY RANGE (credit_limit) +INTERVAL (1000) +(PARTITION p1 VALUES LESS THAN (5001)); + +CREATE TABLE list_customers + ( customer_id NUMBER(6) + , cust_first_name VARCHAR2(20) + , cust_last_name VARCHAR2(20) + , cust_address CUST_ADDRESS_TYP + , nls_territory VARCHAR2(30) + , cust_email VARCHAR2(30)) + PARTITION BY LIST (nls_territory) ( + PARTITION asia VALUES ('CHINA', 'THAILAND'), + PARTITION europe VALUES ('GERMANY', 'ITALY', 'SWITZERLAND'), + PARTITION west VALUES ('AMERICA'), + PARTITION east VALUES ('INDIA'), + PARTITION rest VALUES (DEFAULT)); +CREATE TABLE hash_products + ( product_id NUMBER(6) PRIMARY KEY + , product_name VARCHAR2(50) + , product_description VARCHAR2(2000) + , category_id NUMBER(2) + , weight_class NUMBER(1) + , warranty_period INTERVAL YEAR TO MONTH + , supplier_id NUMBER(6) + , product_status VARCHAR2(20) + , list_price NUMBER(8,2) + , min_price NUMBER(8,2) + , catalog_url VARCHAR2(50) + , CONSTRAINT product_status_lov_demo + CHECK (product_status in ('orderable' + ,'planned' + ,'under development' + ,'obsolete') + ) ) + PARTITION BY HASH (product_id) + PARTITIONS 4 + STORE IN (tbs_01, tbs_02, tbs_03, tbs_04); + + +CREATE TABLE composite_sales + ( prod_id NUMBER(6) + , cust_id NUMBER + , time_id DATE + , channel_id CHAR(1) + , promo_id NUMBER(6) + , quantity_sold NUMBER(3) + , amount_sold NUMBER(10,2) + ) +PARTITION BY RANGE (time_id) +SUBPARTITION BY HASH (channel_id) + (PARTITION SALES_Q1_1998 VALUES LESS THAN (TO_DATE('01-APR-1998','DD-MON-YYYY')), + PARTITION SALES_Q2_1998 VALUES LESS THAN (TO_DATE('01-JUL-1998','DD-MON-YYYY')), + PARTITION SALES_Q3_1998 VALUES LESS THAN (TO_DATE('01-OCT-1998','DD-MON-YYYY')), + PARTITION SALES_Q4_1998 VALUES LESS THAN (TO_DATE('01-JAN-1999','DD-MON-YYYY')), + PARTITION SALES_Q1_1999 VALUES LESS THAN (TO_DATE('01-APR-1999','DD-MON-YYYY')), + PARTITION SALES_Q2_1999 VALUES LESS THAN (TO_DATE('01-JUL-1999','DD-MON-YYYY')), + PARTITION SALES_Q3_1999 VALUES LESS THAN (TO_DATE('01-OCT-1999','DD-MON-YYYY')), + PARTITION SALES_Q4_1999 VALUES LESS THAN (TO_DATE('01-JAN-2000','DD-MON-YYYY')), + PARTITION SALES_Q1_2000 VALUES LESS THAN (TO_DATE('01-APR-2000','DD-MON-YYYY')), + PARTITION SALES_Q2_2000 VALUES LESS THAN (TO_DATE('01-JUL-2000','DD-MON-YYYY')) + SUBPARTITIONS 8, + PARTITION SALES_Q3_2000 VALUES LESS THAN (TO_DATE('01-OCT-2000','DD-MON-YYYY')) + (SUBPARTITION ch_c, + SUBPARTITION ch_i, + SUBPARTITION ch_p, + SUBPARTITION ch_s, + SUBPARTITION ch_t), + PARTITION SALES_Q4_2000 VALUES LESS THAN (MAXVALUE) + SUBPARTITIONS 4) +; +CREATE TABLE customers_part ( + customer_id NUMBER(6), + cust_first_name VARCHAR2(20), + cust_last_name VARCHAR2(20), + nls_territory VARCHAR2(30), + credit_limit NUMBER(9,2)) + PARTITION BY RANGE (credit_limit) + SUBPARTITION BY LIST (nls_territory) + SUBPARTITION TEMPLATE + (SUBPARTITION east VALUES + ('CHINA', 'JAPAN', 'INDIA', 'THAILAND'), + SUBPARTITION west VALUES + ('AMERICA', 'GERMANY', 'ITALY', 'SWITZERLAND'), + SUBPARTITION other VALUES (DEFAULT)) + (PARTITION p1 VALUES LESS THAN (1000), + PARTITION p2 VALUES LESS THAN (2500), + PARTITION p3 VALUES LESS THAN (MAXVALUE)); diff --git a/plsql/examples/pivot01.sql b/plsql/examples/pivot01.sql new file mode 100644 index 0000000..98db574 --- /dev/null +++ b/plsql/examples/pivot01.sql @@ -0,0 +1,6 @@ +select * from pivot_table + unpivot (yearly_total for order_mode in (store as 'direct', + internet as 'online')) + order by year, order_mode + + diff --git a/plsql/examples/pivot02.sql b/plsql/examples/pivot02.sql new file mode 100644 index 0000000..a29895a --- /dev/null +++ b/plsql/examples/pivot02.sql @@ -0,0 +1,12 @@ +select * from ( + select times_purchased as "puchase frequency", state_code + from customers t + ) + pivot xml + ( + count(state_code) + for state_code in (select state_code from preferred_states) + ) + order by 1 + + \ No newline at end of file diff --git a/plsql/examples/pivot03.sql b/plsql/examples/pivot03.sql new file mode 100644 index 0000000..27c9121 --- /dev/null +++ b/plsql/examples/pivot03.sql @@ -0,0 +1,12 @@ +select * from ( + select times_purchased as "purchase frequency", state_code + from customers t + ) + pivot xml + ( + count(state_code) + for state_code in (any) + ) + order by 1 + + \ No newline at end of file diff --git a/plsql/examples/pivot04.sql b/plsql/examples/pivot04.sql new file mode 100644 index 0000000..899d212 --- /dev/null +++ b/plsql/examples/pivot04.sql @@ -0,0 +1,20 @@ +select value +from +( + ( + select + 'a' v1, + 'e' v2, + 'i' v3, + 'o' v4, + 'u' v5 + from dual + ) + unpivot + ( + value + for value_type in + (v1,v2,v3,v4,v5) + ) + ) + diff --git a/plsql/examples/pivot05.sql b/plsql/examples/pivot05.sql new file mode 100644 index 0000000..27c71a0 --- /dev/null +++ b/plsql/examples/pivot05.sql @@ -0,0 +1,5 @@ +select * +from (select customer_id, product_code, quantity + from pivot_test) +pivot xml (sum(quantity) as sum_quantity for (product_code) in (select distinct product_code + from pivot_test)) diff --git a/plsql/examples/pivot06.sql b/plsql/examples/pivot06.sql new file mode 100644 index 0000000..e261507 --- /dev/null +++ b/plsql/examples/pivot06.sql @@ -0,0 +1,6 @@ +select * +from (select product_code, quantity + from pivot_test) +pivot xml (sum(quantity) as sum_quantity for (product_code) in (select distinct product_code + from pivot_test + where id < 10)) \ No newline at end of file diff --git a/plsql/examples/pivot07.sql b/plsql/examples/pivot07.sql new file mode 100644 index 0000000..9ffa5ef --- /dev/null +++ b/plsql/examples/pivot07.sql @@ -0,0 +1,5 @@ +select * +from (select customer_id, product_code, quantity + from pivot_test) +pivot (sum(quantity) as sum_quantity for (product_code) in ('a' as a, 'b' as b, 'c' as c)) +order by customer_id diff --git a/plsql/examples/pivot08.sql b/plsql/examples/pivot08.sql new file mode 100644 index 0000000..28be798 --- /dev/null +++ b/plsql/examples/pivot08.sql @@ -0,0 +1,4 @@ +select * +from (select product_code, quantity + from pivot_test) +pivot (sum(quantity) as sum_quantity for (product_code) in ('a' as a, 'b' as b, 'c' as c)) \ No newline at end of file diff --git a/plsql/examples/pivot09.sql b/plsql/examples/pivot09.sql new file mode 100644 index 0000000..b1ebd96 --- /dev/null +++ b/plsql/examples/pivot09.sql @@ -0,0 +1,19 @@ + select * + from (s join d using(c)) + pivot + ( + max(c_c_p) as max_ccp + , max(d_c_p) max_dcp + , max(d_x_p) dxp + , count(1) cnt + for (i, p) in + ( + (1,1) as one_one, + (1,2) as one_two, + (1,3) as one_three, + (2,1) as two_one, + (2,2) as two_two, + (2,3) as two_three + ) + ) + where d_t = 'p' diff --git a/plsql/examples/pivot10.sql b/plsql/examples/pivot10.sql new file mode 100644 index 0000000..82bf635 --- /dev/null +++ b/plsql/examples/pivot10.sql @@ -0,0 +1,19 @@ + select * + from s join d using(c) + pivot + ( + max(c_c_p) as max_ccp + , max(d_c_p) max_dcp + , max(d_x_p) dxp + , count(1) cnt + for (i, p) in + ( + (1,1) as one_one, + (1,2) as one_two, + (1,3) as one_three, + (2,1) as two_one, + (2,2) as two_two, + (2,3) as two_three + ) + ) + where d_t = 'p' diff --git a/plsql/examples/pivot11.sql b/plsql/examples/pivot11.sql new file mode 100644 index 0000000..dd9dff6 --- /dev/null +++ b/plsql/examples/pivot11.sql @@ -0,0 +1,20 @@ + select * + from s + pivot + ( + max(c_c_p) as max_ccp + , max(d_c_p) max_dcp + , max(d_x_p) dxp + , count(1) cnt + for (i, p) in + ( + (1,1) as one_one, + (1,2) as one_two, + (1,3) as one_three, + (2,1) as two_one, + (2,2) as two_two, + (2,3) as two_three + ) + ) + join d using(c) + where d_t = 'p' diff --git a/plsql/examples/pivot12.sql b/plsql/examples/pivot12.sql new file mode 100644 index 0000000..79387a4 --- /dev/null +++ b/plsql/examples/pivot12.sql @@ -0,0 +1,18 @@ + select value from + ( + ( + select + 'a' v1, + 'e' v2, + 'i' v3, + 'o' v4, + 'u' v5 + from dual + ) + unpivot include nulls + ( + value + for value_type in + (v1, v2,v3,v4,v5) -- Also can give ANY here. + ) + ) \ No newline at end of file diff --git a/plsql/examples/purge_statement.sql b/plsql/examples/purge_statement.sql new file mode 100644 index 0000000..d85327c --- /dev/null +++ b/plsql/examples/purge_statement.sql @@ -0,0 +1,4 @@ +PURGE TABLE test; +PURGE TABLE RB$$33750$TABLE$0; +PURGE RECYCLEBIN; +PURGE TABLESPACE ts USER U; diff --git a/plsql/examples/query_factoring01.sql b/plsql/examples/query_factoring01.sql new file mode 100644 index 0000000..c1503f1 --- /dev/null +++ b/plsql/examples/query_factoring01.sql @@ -0,0 +1,16 @@ +with + reports_to_101 (eid, emp_last, mgr_id, reportlevel) as + ( + select employee_id, last_name, manager_id, 0 reportlevel + from employees + where employee_id = 101 + union all + select e.employee_id, e.last_name, e.manager_id, reportlevel+1 + from reports_to_101 r, employees e + where r.eid = e.manager_id + ) +select eid, emp_last, mgr_id, reportlevel +from reports_to_101 r, auto a +where r.c1 = a.c2 +order by reportlevel, eid + diff --git a/plsql/examples/query_factoring02.sql b/plsql/examples/query_factoring02.sql new file mode 100644 index 0000000..20cd2e5 --- /dev/null +++ b/plsql/examples/query_factoring02.sql @@ -0,0 +1,18 @@ +with + reports_to_101 (eid, emp_last, mgr_id, reportlevel, mgr_list) + as + ( + select employee_id, last_name, manager_id, 0 reportlevel + , cast(manager_id as varchar2(2000)) + from employees + where employee_id = 101 + union all + select e.employee_id, e.last_name, e.manager_id, reportlevel+1 + , cast(mgr_list || ',' || manager_id as varchar2(2000)) + from reports_to_101 r, employees e + where r.eid = e.manager_id + ) +select eid, emp_last, mgr_id, reportlevel, mgr_list +from reports_to_101 +order by reportlevel, eid + diff --git a/plsql/examples/query_factoring03.sql b/plsql/examples/query_factoring03.sql new file mode 100644 index 0000000..d735e43 --- /dev/null +++ b/plsql/examples/query_factoring03.sql @@ -0,0 +1,16 @@ +with + reports_to_101 (eid, emp_last, mgr_id, reportlevel) as + ( + select employee_id, last_name, manager_id, 0 reportlevel + from employees + where employee_id = 101 + union all + select e.employee_id, e.last_name, e.manager_id, reportlevel+1 + from reports_to_101 r, employees e + where r.eid = e.manager_id + ) +select eid, emp_last, mgr_id, reportlevel +from reports_to_101 +where reportlevel <= 1 +order by reportlevel, eid + diff --git a/plsql/examples/query_factoring04.sql b/plsql/examples/query_factoring04.sql new file mode 100644 index 0000000..cba5b5c --- /dev/null +++ b/plsql/examples/query_factoring04.sql @@ -0,0 +1,18 @@ +with + org_chart (eid, emp_last, mgr_id, reportlevel, salary, job_id) as + ( + select employee_id, last_name, manager_id, 0 reportlevel, salary, job_id + from employees + where manager_id is null + union all + select e.employee_id, e.last_name, e.manager_id, + r.reportlevel+1 reportlevel, e.salary, e.job_id + from org_chart r, employees e + where r.eid = e.manager_id + ) + search depth first by emp_last set order1 +select lpad(' ',2*reportlevel)||emp_last emp_name, eid, mgr_id, salary, job_id +from org_chart +order by order1 + + diff --git a/plsql/examples/query_factoring05.sql b/plsql/examples/query_factoring05.sql new file mode 100644 index 0000000..099548c --- /dev/null +++ b/plsql/examples/query_factoring05.sql @@ -0,0 +1,27 @@ +with +x1 as (select max(y1) from klm1), +x2 as (select max(y2) from klm2), +x3 as (select max(y3) from klm3), +x4 as (select max(y4) from klm4) +select + distinct + -1, + +1, + a + b * (a * d) as aaa, + t1.region_name, + t2.division_name, + t1.region_name as a, + t2.division_name as aaaa, + a.*, + sum(t3.amount), + sum(count(1)) + count(*) + , sum(1) + (select count(1) from ddd) a +from dual, fff +where a is null +or b is not null +and ( a like 'd') +and 1 = 0 +and a.b is a set +union +select a from dual + diff --git a/plsql/examples/query_factoring06.sql b/plsql/examples/query_factoring06.sql new file mode 100644 index 0000000..7858876 --- /dev/null +++ b/plsql/examples/query_factoring06.sql @@ -0,0 +1,15 @@ +with + dept_costs as ( + select department_name, sum(salary) dept_total + from employees e, departments d + where e.department_id = d.department_id + group by department_name), + avg_cost as ( + select sum(dept_total)/count(*) avg + from dept_costs) +select * from dept_costs + where dept_total > + (select avvg from avg_cost) + order by department_name + + diff --git a/plsql/examples/query_factoring08.sql b/plsql/examples/query_factoring08.sql new file mode 100644 index 0000000..ac42cc8 --- /dev/null +++ b/plsql/examples/query_factoring08.sql @@ -0,0 +1,10 @@ +with -- qf + x1 as ( select * from t1 ), + x2 as ( select * from t2 join t3 on (t2.a2 = t3.a3)) +select + * +from + x1 +join x2 on (x1.a1 = x2.a2) +join t4 on (x1.a1 = t4.a4) + diff --git a/plsql/examples/query_factoring09.sql b/plsql/examples/query_factoring09.sql new file mode 100644 index 0000000..b7a1f36 --- /dev/null +++ b/plsql/examples/query_factoring09.sql @@ -0,0 +1,8 @@ +with rn as ( + select rownum rn + from dual + connect by level <= (select max(cases) from t1)) +select pname +from t1, rn +where rn <= cases +order by pname diff --git a/plsql/examples/query_factoring10.sql b/plsql/examples/query_factoring10.sql new file mode 100644 index 0000000..c20131d --- /dev/null +++ b/plsql/examples/query_factoring10.sql @@ -0,0 +1,33 @@ +with o(obj,link) as +( +select 'a', 'b' from dual union all +select 'a', 'c' from dual union all +select 'c', 'd' from dual union all +select 'd', 'c' from dual union all +select 'd', 'e' from dual union all +select 'e', 'e' from dual +), +t(root,lev,obj,link,path) as ( +select obj,1,obj,link,cast(obj||'->'||link +as varchar2(4000)) +from o +where obj='a' -- start with +union all +select + t.root,t.lev+1,o.obj,o.link, + t.path||', '||o.obj|| + '->' + ||o.link +from t, o +where t.link=o.obj +) +search depth first by obj set ord +cycle obj set cycle to 1 default 0 +select root,lev,obj,link,path,cycle, + case + when (lev - lead(lev) over (order by ord)) < 0 + then 0 + else 1 + end is_leaf + from t + diff --git a/plsql/examples/query_factoring11.sql b/plsql/examples/query_factoring11.sql new file mode 100644 index 0000000..36b47aa --- /dev/null +++ b/plsql/examples/query_factoring11.sql @@ -0,0 +1,9 @@ +with col_generator as ( +select t1.batch_id, decode(t1.action, 'sent', t1.actdate) sent, +decode(t2.action,'recv', t2.actdate) received +from test t1, test t2 +where t2.batch_id(+) = t1.batch_id) +select batch_id, max(sent) sent, max(received) received +from col_generator +group by batch_id +order by 1 diff --git a/plsql/examples/rename_objects.sql b/plsql/examples/rename_objects.sql new file mode 100644 index 0000000..17da47e --- /dev/null +++ b/plsql/examples/rename_objects.sql @@ -0,0 +1,2 @@ +-- Test for RENAME statement of unit_statement (f.e. renaming Oracle jobs) +RENAME FOO TO BAR; diff --git a/plsql/examples/revoke_statement.sql b/plsql/examples/revoke_statement.sql new file mode 100644 index 0000000..1db61bf --- /dev/null +++ b/plsql/examples/revoke_statement.sql @@ -0,0 +1,20 @@ +REVOKE DROP ANY TABLE + FROM hr, oe; +REVOKE dw_manager + FROM sh; +REVOKE CREATE TABLESPACE + FROM dw_manager; +REVOKE dw_user + FROM dw_manager; +REVOKE DELETE + ON orders FROM hr; +REVOKE UPDATE + ON emp_details_view FROM public; +REVOKE INHERIT PRIVILEGES ON USER sh FROM hr; +REVOKE SELECT + ON hr.departments_seq FROM oe; +REVOKE REFERENCES + ON hr.employees + FROM oe + CASCADE CONSTRAINTS; +REVOKE READ ON DIRECTORY bfile_dir FROM hr; diff --git a/plsql/examples/round_001.sql b/plsql/examples/round_001.sql new file mode 100644 index 0000000..269816c --- /dev/null +++ b/plsql/examples/round_001.sql @@ -0,0 +1,8 @@ +SELECT +round( + decode( + a.attribute_name, n.col, + a.attribute_num_value * n.scale + n.shift, + a.attribute_num_value), 4 + ) + FROM employees \ No newline at end of file diff --git a/plsql/examples/round_decode_001.sql b/plsql/examples/round_decode_001.sql new file mode 100644 index 0000000..c29d8a3 --- /dev/null +++ b/plsql/examples/round_decode_001.sql @@ -0,0 +1,11 @@ + SELECT + nvl( + a.attribute_str_value, + round( + decode( + a.attribute_name, n.col, + a.attribute_num_value * n.scale + n.shift, + a.attribute_num_value), 4 + ) + ) val + from employees \ No newline at end of file diff --git a/plsql/examples/row_number_001.sql b/plsql/examples/row_number_001.sql new file mode 100644 index 0000000..b3e7473 --- /dev/null +++ b/plsql/examples/row_number_001.sql @@ -0,0 +1,4 @@ +SELECT department_id, last_name, employee_id, +ROW_NUMBER() +OVER (PARTITION BY department_id ORDER BY employee_id) AS emp_id +FROM employees diff --git a/plsql/examples/sample01.sql b/plsql/examples/sample01.sql new file mode 100644 index 0000000..605b033 --- /dev/null +++ b/plsql/examples/sample01.sql @@ -0,0 +1,4 @@ +select * from +( +select 1 as c1 from "sys"."obj$" sample block (14.285714 , 1) seed (1) "o" +) samplesub diff --git a/plsql/examples/select_all_some_any.sql b/plsql/examples/select_all_some_any.sql new file mode 100644 index 0000000..ebf2c54 --- /dev/null +++ b/plsql/examples/select_all_some_any.sql @@ -0,0 +1,6 @@ + +select * from "CW_ROLE" where role_id = some(1,5); +select * from "T_ROLE" where role_id = any(1,5); +select * from "T_ROLE" where role_id = all(1,5); + +select u.name, u.sex, u.age from sys.user u; diff --git a/plsql/examples/select_package_function.sql b/plsql/examples/select_package_function.sql new file mode 100644 index 0000000..38f5d51 --- /dev/null +++ b/plsql/examples/select_package_function.sql @@ -0,0 +1 @@ +SELECT DBMS_LOB.SUBSTR(FIELD_1,4000,1) AS FIELD_1, 'ABC' AS FIELD_2 FROM TABLE_1 \ No newline at end of file diff --git a/plsql/examples/select_time.sql b/plsql/examples/select_time.sql new file mode 100644 index 0000000..674664e --- /dev/null +++ b/plsql/examples/select_time.sql @@ -0,0 +1,3 @@ +SELECT TIME '19:00:00'+INTERVAL '9' HOUR, TIME '19:00:00'-INTERVAL '9' HOUR from dual; +SELECT TIME '19:00:00'+INTERVAL '9' DAY, TIME '19:00:00'-INTERVAL '9' DAY from dual; +SELECT TIME '19:00:00'+INTERVAL '9' SECOND, TIME '19:00:00'-INTERVAL '9' SECOND from dual; diff --git a/plsql/examples/simple02.sql b/plsql/examples/simple02.sql new file mode 100644 index 0000000..459fb20 --- /dev/null +++ b/plsql/examples/simple02.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update + diff --git a/plsql/examples/simple03.sql b/plsql/examples/simple03.sql new file mode 100644 index 0000000..3ca7d89 --- /dev/null +++ b/plsql/examples/simple03.sql @@ -0,0 +1,3 @@ +select employee_id from (select employee_id+1 as employee_id from employees) + for update of employee_id + diff --git a/plsql/examples/simple04.sql b/plsql/examples/simple04.sql new file mode 100644 index 0000000..07aacdc --- /dev/null +++ b/plsql/examples/simple04.sql @@ -0,0 +1,11 @@ +select * from +( + ( + select * from dual + ) + unpivot + ( + value for value_type in (dummy) + ) +) + diff --git a/plsql/examples/simple05.sql b/plsql/examples/simple05.sql new file mode 100644 index 0000000..b1d5077 --- /dev/null +++ b/plsql/examples/simple05.sql @@ -0,0 +1,9 @@ +select * from +( +select * from a + unpivot + ( + value for value_type in (dummy) + ) +) + diff --git a/plsql/examples/simple06.sql b/plsql/examples/simple06.sql new file mode 100644 index 0000000..3a44380 --- /dev/null +++ b/plsql/examples/simple06.sql @@ -0,0 +1,2 @@ +select * from (( select * from dual)) a + diff --git a/plsql/examples/simple07.sql b/plsql/examples/simple07.sql new file mode 100644 index 0000000..c5a6036 --- /dev/null +++ b/plsql/examples/simple07.sql @@ -0,0 +1,3 @@ +select * from dual for update +of dual + diff --git a/plsql/examples/simple08.sql b/plsql/examples/simple08.sql new file mode 100644 index 0000000..d9980f3 --- /dev/null +++ b/plsql/examples/simple08.sql @@ -0,0 +1,2 @@ +select a, b, c, d, e, 1, 2, f(a,b,c,1+1) from dual + diff --git a/plsql/examples/simple09.sql b/plsql/examples/simple09.sql new file mode 100644 index 0000000..d2637f4 --- /dev/null +++ b/plsql/examples/simple09.sql @@ -0,0 +1,7 @@ +select a||last_name, + employee_id + from employees + start with job_id = 'ad_vp' + connect by prior employee_id = manager_id + + diff --git a/plsql/examples/simple10.sql b/plsql/examples/simple10.sql new file mode 100644 index 0000000..753ad3a --- /dev/null +++ b/plsql/examples/simple10.sql @@ -0,0 +1 @@ +select a as over from over diff --git a/plsql/examples/simple11.sql b/plsql/examples/simple11.sql new file mode 100644 index 0000000..ed22053 --- /dev/null +++ b/plsql/examples/simple11.sql @@ -0,0 +1 @@ +select a.* from dual diff --git a/plsql/examples/simple12.sql b/plsql/examples/simple12.sql new file mode 100644 index 0000000..33f65c6 --- /dev/null +++ b/plsql/examples/simple12.sql @@ -0,0 +1,7 @@ +select + +1, + t2.division_name as aaaa, + a.*, + sum(t3.amount) +from dual + diff --git a/plsql/examples/simple13.sql b/plsql/examples/simple13.sql new file mode 100644 index 0000000..e09eef0 --- /dev/null +++ b/plsql/examples/simple13.sql @@ -0,0 +1 @@ +select * from (dual), (dual d), (dual) d diff --git a/plsql/examples/string01.sql b/plsql/examples/string01.sql new file mode 100644 index 0000000..12a8d44 --- /dev/null +++ b/plsql/examples/string01.sql @@ -0,0 +1,17 @@ +select + 'hello' +, 'oracle.dbs' +, 'jackie''s raincoat' +, '09-mar-98' +, '' +, '''' +, q'!name like '%dbms_%%'!' +, q'<'so,' she said, 'it's finished.'>' +, q'{select * from employees where last_name = 'smith'}' +, q'"name like '['"' +, q'#name like #smth #' +, q''name like 'smth '' +, q'(name like )) )' +, n'nchar literal' +from dual + diff --git a/plsql/examples/timing.sql b/plsql/examples/timing.sql new file mode 100644 index 0000000..5445120 --- /dev/null +++ b/plsql/examples/timing.sql @@ -0,0 +1,12 @@ +TIMING + +TIMING START +TIMING START one_word +TIMING START more than one word + +TIMING SHOW + +TIMING STOP + +-- verify that selecting a column named TIMING still work +SELECT timing FROM some_table; diff --git a/plsql/examples/timing.sql.tree b/plsql/examples/timing.sql.tree new file mode 100644 index 0000000..f635b69 --- /dev/null +++ b/plsql/examples/timing.sql.tree @@ -0,0 +1 @@ +(sql_script (sql_plus_command (timing_command TIMING)) (sql_plus_command (timing_command TIMING START)) (sql_plus_command (timing_command TIMING START (id_expression (regular_id one_word)))) (sql_plus_command (timing_command TIMING START (id_expression (regular_id more)) (id_expression (regular_id (non_reserved_keywords_pre12c than))) (id_expression (regular_id (non_reserved_keywords_in_12c one))) (id_expression (regular_id word)) (id_expression (regular_id (non_reserved_keywords_pre12c TIMING))) (id_expression (regular_id (non_reserved_keywords_pre12c SHOW))) (id_expression (regular_id (non_reserved_keywords_pre12c TIMING))) (id_expression (regular_id (non_reserved_keywords_pre12c STOP))))) (unit_statement (data_manipulation_language_statements (select_statement (select_only_statement (subquery (subquery_basic_elements (query_block SELECT (selected_list (select_list_elements (expression (logical_expression (unary_logical_expression (multiset_expression (relational_expression (compound_expression (concatenation (model_expression (unary_expression (atom (constant (quoted_string (variable_name (id_expression (regular_id (non_reserved_keywords_pre12c timing)))))))))))))))))) (from_clause FROM (table_ref_list (table_ref (table_ref_aux (table_ref_aux_internal (dml_table_expression_clause (tableview_name (identifier (id_expression (regular_id some_table))))))))))))))))) ; ) \ No newline at end of file diff --git a/plsql/examples/to_binary_double.sql b/plsql/examples/to_binary_double.sql new file mode 100644 index 0000000..be30304 --- /dev/null +++ b/plsql/examples/to_binary_double.sql @@ -0,0 +1,9 @@ +select + raw_value, + to_binary_double(raw_value), + to_binary_double(raw_value, '9990.9999'), + to_binary_double(raw_value, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_binary_double(raw_value default 0 on conversion error), + to_binary_double(raw_value default 0 on conversion error, '9990.9999'), + to_binary_double(raw_value default 0 on conversion error, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_binary_float.sql b/plsql/examples/to_binary_float.sql new file mode 100644 index 0000000..70d0978 --- /dev/null +++ b/plsql/examples/to_binary_float.sql @@ -0,0 +1,9 @@ +select + raw_value, + to_binary_float(raw_value), + to_binary_float(raw_value, '9990.9999'), + to_binary_float(raw_value, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_binary_float(raw_value default 0 on conversion error), + to_binary_float(raw_value default 0 on conversion error, '9990.9999'), + to_binary_float(raw_value default 0 on conversion error, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_char.sql b/plsql/examples/to_char.sql new file mode 100644 index 0000000..e3c54a1 --- /dev/null +++ b/plsql/examples/to_char.sql @@ -0,0 +1 @@ +SELECT TO_CHAR(SYSDATE), TO_CHAR(SYSDATE, 'D'), TO_CHAR(SYSDATE, 'D', 'NLS_DATE_LANGUAGE = RUSSIAN') FROM DUAL \ No newline at end of file diff --git a/plsql/examples/to_char_001.sql b/plsql/examples/to_char_001.sql new file mode 100644 index 0000000..58e5a13 --- /dev/null +++ b/plsql/examples/to_char_001.sql @@ -0,0 +1 @@ +SELECT TO_CHAR("date", 'YYYY-MM') || '-01' as "month" FROM employes \ No newline at end of file diff --git a/plsql/examples/to_char_002.sql b/plsql/examples/to_char_002.sql new file mode 100644 index 0000000..68afcbd --- /dev/null +++ b/plsql/examples/to_char_002.sql @@ -0,0 +1 @@ +select TO_CHAR(commission_pct) as "commission" from employees \ No newline at end of file diff --git a/plsql/examples/to_date.sql b/plsql/examples/to_date.sql new file mode 100644 index 0000000..55a9dcc --- /dev/null +++ b/plsql/examples/to_date.sql @@ -0,0 +1,21 @@ +SELECT TO_DATE('01.01.2012') FROM DUAL +SELECT TO_DATE('01.01.2012', 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE('01' || '.01.2012', 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE('01.' || (NQUATER*3 - 2) || '.' || NRYEAR, 'DD.MM.YYYY') FROM DUAL +SELECT LAST_DAY(TO_DATE('01.' || (NQUATER*3 - 2) || '.' || NRYEAR, 'DD.MM.YYYY')) FROM DUAL +SELECT TO_CHAR(LAST_DAY(TO_DATE('01.' || (NQUATER*3 - 2) || '.' || NRYEAR, 'DD.MM.YYYY')),'DD') FROM DUAL +SELECT TO_DATE("CHAR_COLUMN") FROM EMPLOYES +SELECT TO_DATE("CHAR_COLUMN",'DD.MM.YYYY') FROM EMPLOYES +SELECT TO_DATE(E."CHAR_COLUMN",'DD.MM.YYYY') FROM EMPLOYES E +SELECT TO_DATE('01.01.2012' DEFAULT NULL ON CONVERSION ERROR) FROM DUAL +SELECT TO_DATE('01.01.2012' DEFAULT NULL ON CONVERSION ERROR, 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE('01.01.2012' DEFAULT NULL ON CONVERSION ERROR, 'dd.mm.yyyy', 'NLS_DATE_LANGUAGE = RUSSIAN') FROM DUAL +SELECT TO_DATE('01.01.2012' DEFAULT '01.01.1970' ON CONVERSION ERROR) FROM DUAL +SELECT TO_DATE('01.01.2012' DEFAULT '01.01.1970' ON CONVERSION ERROR, 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE('01.01.2012' DEFAULT '01.01.1970' ON CONVERSION ERROR, 'dd.mm.yyyy', 'NLS_DATE_LANGUAGE = RUSSIAN') FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT NULL ON CONVERSION ERROR) FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT NULL ON CONVERSION ERROR, 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT NULL ON CONVERSION ERROR, 'dd.mm.yyyy', 'NLS_DATE_LANGUAGE = RUSSIAN') FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT '01.01.1970' ON CONVERSION ERROR) FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT '01.01.1970' ON CONVERSION ERROR, 'dd.mm.yyyy') FROM DUAL +SELECT TO_DATE("CHAR_COLUMN" DEFAULT '01.01.1970' ON CONVERSION ERROR, 'dd.mm.yyyy', 'NLS_DATE_LANGUAGE = RUSSIAN') FROM DUAL \ No newline at end of file diff --git a/plsql/examples/to_dsinterval.sql b/plsql/examples/to_dsinterval.sql new file mode 100644 index 0000000..9efc00a --- /dev/null +++ b/plsql/examples/to_dsinterval.sql @@ -0,0 +1,7 @@ +select + to_dsinterval('10 1:02:10'), + to_dsinterval('1o 1:02:10' default '10 8:00:00' on conversion error), + to_dsinterval(raw_value), + to_dsinterval(raw_value default '10 8:00:00' on conversion error), + to_dsinterval("RAW_VALUE" default '10 8:00:00' on conversion error) +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_number.sql b/plsql/examples/to_number.sql new file mode 100644 index 0000000..aea81f4 --- /dev/null +++ b/plsql/examples/to_number.sql @@ -0,0 +1,9 @@ +select + raw_value, + to_number(raw_value), + to_number(raw_value, '9990.9999'), + to_number(raw_value, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_number(raw_value default 0 on conversion error), + to_number(raw_value default 0 on conversion error, '9990.9999'), + to_number(raw_value default 0 on conversion error, '9990.9999', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_timestamp.sql b/plsql/examples/to_timestamp.sql new file mode 100644 index 0000000..5ce73c8 --- /dev/null +++ b/plsql/examples/to_timestamp.sql @@ -0,0 +1,11 @@ +select + raw_value, + to_timestamp(raw_value), + to_timestamp(raw_value, 'YYYY-MM-DD'), + to_timestamp(raw_value, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_timestamp(raw_value default '1970-01-01' on conversion error, 'YYYY-MM-DD'), + to_timestamp(raw_value default '1970-01-01' on conversion error, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_timestamp(raw_value default null on conversion error), + to_timestamp(raw_value default null on conversion error, 'YYYY-MM-DD'), + to_timestamp(raw_value default null on conversion error, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_timestamp_tz.sql b/plsql/examples/to_timestamp_tz.sql new file mode 100644 index 0000000..d50a021 --- /dev/null +++ b/plsql/examples/to_timestamp_tz.sql @@ -0,0 +1,11 @@ +select + raw_value, + to_timestamp_tz(raw_value), + to_timestamp_tz(raw_value, 'YYYY-MM-DD'), + to_timestamp_tz(raw_value, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_timestamp_tz(raw_value default '1970-01-01' on conversion error, 'YYYY-MM-DD'), + to_timestamp_tz(raw_value default '1970-01-01' on conversion error, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN'), + to_timestamp_tz(raw_value default null on conversion error), + to_timestamp_tz(raw_value default null on conversion error, 'YYYY-MM-DD'), + to_timestamp_tz(raw_value default null on conversion error, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/to_yminterval.sql b/plsql/examples/to_yminterval.sql new file mode 100644 index 0000000..5494fda --- /dev/null +++ b/plsql/examples/to_yminterval.sql @@ -0,0 +1,7 @@ +select + to_dsinterval('10-02'), + to_dsinterval('1x-02' default '00-00' on conversion error), + to_dsinterval(raw_value), + to_dsinterval(raw_value default '00-00' on conversion error), + to_dsinterval("RAW_VALUE" default '00-00' on conversion error) +from raw_values; \ No newline at end of file diff --git a/plsql/examples/truncate_cluster.sql b/plsql/examples/truncate_cluster.sql new file mode 100644 index 0000000..31952d3 --- /dev/null +++ b/plsql/examples/truncate_cluster.sql @@ -0,0 +1 @@ +TRUNCATE CLUSTER personnel REUSE STORAGE; diff --git a/plsql/examples/truncate_table.sql b/plsql/examples/truncate_table.sql new file mode 100644 index 0000000..3d7f0b9 --- /dev/null +++ b/plsql/examples/truncate_table.sql @@ -0,0 +1 @@ +truncate table test; \ No newline at end of file diff --git a/plsql/examples/unified.sql b/plsql/examples/unified.sql new file mode 100644 index 0000000..dd481ea --- /dev/null +++ b/plsql/examples/unified.sql @@ -0,0 +1,3 @@ +AUDIT POLICY table_pol; +AUDIT POLICY dml_pol BY hr, sh; + diff --git a/plsql/examples/union01.sql b/plsql/examples/union01.sql new file mode 100644 index 0000000..72afaeb --- /dev/null +++ b/plsql/examples/union01.sql @@ -0,0 +1,7 @@ +select 'a' obj, 'b' link from dual union all +select 'a', 'c' from dual union all +select 'c', 'd' from dual union all +select 'd', 'c' from dual union all +select 'd', 'e' from dual union all +select 'e', 'e' from dual + diff --git a/plsql/examples/union02.sql b/plsql/examples/union02.sql new file mode 100644 index 0000000..4165984 --- /dev/null +++ b/plsql/examples/union02.sql @@ -0,0 +1,4 @@ +select distinct job_id from hr.jobs +union all +select distinct job_id from hr.job_history + diff --git a/plsql/examples/union03.sql b/plsql/examples/union03.sql new file mode 100644 index 0000000..e119602 --- /dev/null +++ b/plsql/examples/union03.sql @@ -0,0 +1,6 @@ +select distinct job_id from hr.jobs +union all +( + select distinct job_id from hr.job_history +) + diff --git a/plsql/examples/union04.sql b/plsql/examples/union04.sql new file mode 100644 index 0000000..911f952 --- /dev/null +++ b/plsql/examples/union04.sql @@ -0,0 +1,45 @@ +( + select distinct job_id from hr.jobs +) +union all +( + select distinct job_id from hr.job_history + union all + (((( + select distinct job_id from hr.job_history + union all + ( + select distinct job_id from hr.job_history + ) + ))) + union all + select distinct job_id from hr.job_history + ) +) +union all +( + select distinct job_id from hr.job_history + union all + ( + select distinct job_id from hr.job_history + union all + ( + select distinct job_id from hr.job_history + ) + ) +) +union all +( + select distinct job_id from hr.job_history + union all + select distinct job_id from hr.job_history +) +union all + select distinct job_id from hr.job_history +union all + select distinct job_id from hr.job_history +union all + select distinct job_id from hr.job_history +union all + select distinct job_id from hr.job_history + diff --git a/plsql/examples/union05.sql b/plsql/examples/union05.sql new file mode 100644 index 0000000..04b1a85 --- /dev/null +++ b/plsql/examples/union05.sql @@ -0,0 +1,30 @@ +select * from dual +union all +( + select * from dual +) +union all +( + select * from dual +) +union all +( + select * from dual +) +union all +( + select * from dual +) +union all +( + select * from dual +) +union all +( + select * from dual +) +union all +( + select * from dual +) +order by 1 asc, 2 asc diff --git a/plsql/examples/union06.sql b/plsql/examples/union06.sql new file mode 100644 index 0000000..bc4a548 --- /dev/null +++ b/plsql/examples/union06.sql @@ -0,0 +1,35 @@ +( select "x"."r_no", + "x"."i_id", + "x"."ind", + "x"."item", + '0' "o" + from "x" + where ("x"."r_no" = :a) + minus + select "y"."r_no", + "y"."i_id", + "y"."ind", + "y"."item", + '0' "o" + from "y" + where ("y"."r_no" = :a) +) +union +( select "y"."r_no", + "y"."i_id", + "y"."ind", + "y"."item", + '1' "o" + from "y" + where ("y"."r_no" = :a) + minus + select "x"."r_no", + "x"."i_id", + "x"."ind", + "x"."item", + '1' "o" + from "x" + where ("x"."r_no" = :a) +) +order by 4,3,1 + diff --git a/plsql/examples/union07.sql b/plsql/examples/union07.sql new file mode 100644 index 0000000..32c3aa2 --- /dev/null +++ b/plsql/examples/union07.sql @@ -0,0 +1,47 @@ +-- +-- note: this query was copied from the druid project +-- http://code.alibabatech.com/wiki/display/druid/home +-- +select * from ( + select row_.*, rownum rownum_ + from ( + select * + from + ( + select results.*,row_number() over ( partition by results.object_id order by results.gmt_modified desc) rn + from + ( + ( + select sus.id id, sus.gmt_create gmt_create, + sus.gmt_modified gmt_modified, sus.company_id company_id, + sus.object_id object_id, sus.object_type object_type, + sus.confirm_type confirm_type, sus.operator operator, + sus.filter_type filter_type, sus.member_id member_id, + sus.member_fuc_q member_fuc_q, sus.risk_type risk_type , 'y' is_draft + from f_u_c_ sus , a_b_c_draft p , + member m + where 1=1 and p.company_id = m.company_id + and m.login_id=? + and p.sale_type in( ? ) + and p.id=sus.object_id + ) + union + ( + select sus.id id, sus.gmt_create gmt_create, + sus.gmt_modified gmt_modified, sus.company_id company_id, + sus.object_id object_id, sus.object_type object_type, + sus.confirm_type confirm_type, sus.operator operator, + sus.filter_type filter_type, sus.member_id member_id, + sus.member_fuc_q member_fuc_q, sus.risk_type risk_type , 'n' is_draft + from f_u_c_ sus , a_b_c p ,member m + where 1=1 + and p.company_id = m.company_id + and m.login_id=? + and p.sale_type in( ? ) + and p.id=sus.object_id + ) + ) results + ) where rn = 1 order by gmt_modified desc + )row_ where rownum <= ? + ) +where rownum_ >= ? diff --git a/plsql/examples/union08.sql b/plsql/examples/union08.sql new file mode 100644 index 0000000..97ed5d5 --- /dev/null +++ b/plsql/examples/union08.sql @@ -0,0 +1,5 @@ +select * from dual where exists ( + select * from dual + union all + select * from dual +) diff --git a/plsql/examples/union09.sql b/plsql/examples/union09.sql new file mode 100644 index 0000000..a63f499 --- /dev/null +++ b/plsql/examples/union09.sql @@ -0,0 +1,27 @@ +select * from ( + select row_.* + from ( + select * + from + ( + select results.*, 1 rn + from + ( + ( + select dummy + from dual + where 1=1 + ) + union + ( + select dummy + from dual + where 1=1 + ) + ) results + ) + where rn = 1 order by dummy desc + )row_ + where rownum <= 1 + ) +where rownum >= 1 diff --git a/plsql/examples/union10.sql b/plsql/examples/union10.sql new file mode 100644 index 0000000..a697a08 --- /dev/null +++ b/plsql/examples/union10.sql @@ -0,0 +1,14 @@ +select +( + ( + select 'y' from dual + where exists ( select 1 from dual where 1 = 0 ) + ) + union + ( + select 'n' from dual + where not exists ( select 1 from dual where 1 = 0 ) + ) +) +as yes_no +from dual diff --git a/plsql/examples/validate_conversion.sql b/plsql/examples/validate_conversion.sql new file mode 100644 index 0000000..aedac7d --- /dev/null +++ b/plsql/examples/validate_conversion.sql @@ -0,0 +1,6 @@ +select + raw_value, + validate_conversion(raw_value as number), + validate_conversion(raw_value as date, 'YYYY-MM-DD'), + validate_conversion(raw_value as date, 'YYYY-MM-DD', 'NLS_DATE_LANGUAGE = RUSSIAN') +from raw_values; \ No newline at end of file diff --git a/plsql/examples/views.sql b/plsql/examples/views.sql new file mode 100644 index 0000000..c2ff3c9 --- /dev/null +++ b/plsql/examples/views.sql @@ -0,0 +1,59 @@ +CREATE VIEW emp_view AS + SELECT last_name, salary*12 annual_salary + FROM employees + WHERE department_id = 20; + +CREATE EDITIONING VIEW ed_orders_view (o_id, o_date, o_status) + AS SELECT order_id, order_date, order_status FROM orders + WITH READ ONLY; + +CREATE VIEW emp_sal (emp_id, last_name, + email UNIQUE RELY DISABLE NOVALIDATE, + CONSTRAINT id_pk PRIMARY KEY (emp_id) RELY DISABLE NOVALIDATE) + AS SELECT employee_id, last_name, email FROM employees; + +CREATE VIEW clerk AS + SELECT employee_id, last_name, department_id, job_id + FROM employees + WHERE job_id = 'PU_CLERK' + or job_id = 'SH_CLERK' + or job_id = 'STA_CLERK'; + +CREATE VIEW clerk AS + SELECT employee_id, last_name, department_id, job_id + FROM employees + WHERE job_id = 'PU_CLERK' + or job_id = 'SH_CLERK' + or job_id = 'ST_CLERK' + WITH CHECK OPTION; + +CREATE VIEW locations_view AS + SELECT d.department_id, d.department_name, l.location_id, l.city + FROM departments d, locations l + WHERE d.location_id = l.location_id; + +CREATE VIEW customer_ro (name, language, credit) + AS SELECT cust_last_name, nls_language, credit_limit + FROM customers + WITH READ ONLY; + +CREATE OR REPLACE VIEW oc_inventories OF inventory_typ + WITH OBJECT ID (product_id) + AS SELECT i.product_id, + warehouse_typ(w.warehouse_id, w.warehouse_name, w.location_id), + i.quantity_on_hand + FROM inventories i, warehouses w + WHERE i.warehouse_id=w.warehouse_id; + +CREATE EDITIONABLE VIEW TEST (A, B, C) + AS SELECT 'A', 'B', 'C' + FROM DUAL; + +CREATE VIEW TEST (A, B, C) + AS + WITH TESTCTE AS ( + SELECT 1 ONE FROM DUAL + ) + SELECT 'A', 'B', 'C' + FROM DUAL + JOIN TESTCTE; diff --git a/plsql/examples/whenever_sqlerror.sql b/plsql/examples/whenever_sqlerror.sql new file mode 100644 index 0000000..d952cd2 --- /dev/null +++ b/plsql/examples/whenever_sqlerror.sql @@ -0,0 +1,10 @@ +WHENEVER SQLERROR CONTINUE; +WHENEVER SQLERROR CONTINUE COMMIT; +WHENEVER SQLERROR CONTINUE ROLLBACK; +WHENEVER SQLERROR CONTINUE NONE; + +WHENEVER SQLERROR EXIT SQL.SQLCODE; +WHENEVER SQLERROR EXIT SQL.SQLCODE COMMIT; +WHENEVER SQLERROR EXIT SQL.SQLCODE ROLLBACK; + +WHENEVER SQLERROR EXIT 1; diff --git a/plsql/examples/whenever_sqlerror.sql.tree b/plsql/examples/whenever_sqlerror.sql.tree new file mode 100644 index 0000000..940a8d4 --- /dev/null +++ b/plsql/examples/whenever_sqlerror.sql.tree @@ -0,0 +1 @@ +(sql_script (sql_plus_command (whenever_command WHENEVER SQLERROR CONTINUE)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR CONTINUE COMMIT)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR CONTINUE ROLLBACK)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR CONTINUE NONE)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR EXIT (variable_name (id_expression (regular_id (non_reserved_keywords_pre12c SQL))) . (id_expression (regular_id SQLCODE))))) ; (sql_plus_command (whenever_command WHENEVER SQLERROR EXIT (variable_name (id_expression (regular_id (non_reserved_keywords_pre12c SQL))) . (id_expression (regular_id SQLCODE))) COMMIT)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR EXIT (variable_name (id_expression (regular_id (non_reserved_keywords_pre12c SQL))) . (id_expression (regular_id SQLCODE))) ROLLBACK)) ; (sql_plus_command (whenever_command WHENEVER SQLERROR EXIT (numeric 1))) ; ) \ No newline at end of file diff --git a/plsql/examples/xml_function.sql b/plsql/examples/xml_function.sql new file mode 100644 index 0000000..8197d04 --- /dev/null +++ b/plsql/examples/xml_function.sql @@ -0,0 +1,43 @@ +SELECT + XMLAGG(XMLELEMENT(X,first_name, ',') + ORDER BY FIRST_NAME).extract('//text()').getClobVal() AS "NAMES" +FROM STUDENTS; + +SELECT + XMLCOLATTVAL(first_name,first_name, first_name).extract('//text()').getClobVal() +FROM STUDENTS; + +SELECT + XMLFOREST(first_name,first_name, first_name).extract('//text()').getClobVal() +FROM STUDENTS; + +SELECT + XMLELEMENT(TEST,first_name , ',').extract('//text()').getClobVal() +FROM STUDENTS; + +SELECT XMLPARSE(CONTENT '124 + Acme Enterprises + 32987457 + ' +WELLFORMED).extract('//text()').getClobVal() AS PO FROM DUAL; + +SELECT XMLPI(NAME "Order analysisComp", 'imported, reconfigured, disassembled').extract('//text()').getClobVal() + AS "XMLPI" FROM DUAL; + +SELECT warehouse_name, + EXTRACTVALUE(warehouse_spec, '/Warehouse/Area'), + XMLQuery( + 'for $i in /Warehouse + where $i/Area > 50000 + return
+ + + { + if ($i/RailAccess = "Y") then "true" else "false" + } + +
' PASSING warehouse_spec RETURNING CONTENT).extract('//text()').getClobVal() "Big_warehouses" +FROM warehouses; + +SELECT XMLROOT ( XMLType('143598'), VERSION '1.0', STANDALONE YES).extract('//text()').getClobVal() + AS "XMLROOT" FROM DUAL; diff --git a/plsql/examples/xmltable01.sql b/plsql/examples/xmltable01.sql new file mode 100644 index 0000000..aa5495f --- /dev/null +++ b/plsql/examples/xmltable01.sql @@ -0,0 +1,13 @@ +-- See https://docs.oracle.com/cd/B19306_01/server.102/b14200/functions228.htm + +SELECT warehouse_name warehouse, + warehouse2."Water", warehouse2."Rail", warehouse2."Box" + FROM warehouses, + XMLTABLE(xmlnamespaces ('http://www.example.com/xml/path' AS "a"), + '/Warehouse' + PASSING warehouses.warehouse_spec + COLUMNS + "Water" varchar2(6) PATH '/Warehouse/WaterAccess', + "Rail" varchar2(6) PATH '/Warehouse/RailAccess', + "Box" varchar2(6) PATH '/Warehouse/BoxAccess') + warehouse2; \ No newline at end of file diff --git a/plsql/examples/xmltable02.sql b/plsql/examples/xmltable02.sql new file mode 100644 index 0000000..c5f5440 --- /dev/null +++ b/plsql/examples/xmltable02.sql @@ -0,0 +1,2 @@ +select xmlelement("other_attrs", xmlelement("parsing_user_id", parsing_user_id)).getClobVal() other +from f diff --git a/plsql/examples/xmltable03.sql b/plsql/examples/xmltable03.sql new file mode 100644 index 0000000..bb3e7d0 --- /dev/null +++ b/plsql/examples/xmltable03.sql @@ -0,0 +1,17 @@ +-- XMLTable and outer join methods: http://anononxml.blogspot.com/2011/06/xmltable-and-outer-join-methods.html + +select master_id + ,details_id + ,sub_details_id + from demo4 s + ,XMLTable('master' + passing (s.xml) + columns master_id varchar2 (20) path 'id' + ,details XMLType path 'details/detail') mstr + ,XMLTable('detail' + passing (mstr.details) + columns details_id varchar2 (20) path 'id' + ,sub_details XMLType path 'sub_details/sub_detail')(+) dtl + ,XMLTable('sub_detail' + passing (dtl.sub_details) + columns sub_details_id varchar2 (20) path 'id')(+) sub_dtl; \ No newline at end of file diff --git a/plsql/keywords.go b/plsql/keywords.go new file mode 100644 index 0000000..c5f592b --- /dev/null +++ b/plsql/keywords.go @@ -0,0 +1,221 @@ +package plsql + +var ( + ReservedWords = map[string]bool{ + "ACCESS": true, + "ADD": true, + "ALL": true, + "ALTER": true, + "AND": true, + "ANY": true, + "ARRAY": true, + "AS": true, + "ASC": true, + "AT": true, + "AUDIT": true, + "AUTHID": true, + "AVG": true, + "BEGIN": true, + "BETWEEN": true, + "BINARY_INTEGER": true, + "BODY": true, + "BOOLEAN": true, + "BULK": true, + "BY": true, + "CHAR": true, + "CHAR_BASE": true, + "CHECK": true, + "CLOSE": true, + "CLUSTER": true, + "COALESCE": true, + "COLLECT": true, + "COLUMN": true, + "COMMENT": true, + "COMMIT": true, + "COMPRESS": true, + "CONNECT": true, + "CONSTANT": true, + "CREATE": true, + "CURRENT": true, + "CURRVAL": true, + "CURSOR": true, + "DATE": true, + "DAY": true, + "DECIMAL": true, + "DECLARE": true, + "DEFAULT": true, + "DELETE": true, + "DESC": true, + "DISTINCT": true, + "DO": true, + "DROP": true, + "ELSE": true, + "ELSIF": true, + "END": true, + "EXCEPTION": true, + "EXCLUSIVE": true, + "EXECUTE": true, + "EXISTS": true, + "EXIT": true, + "EXTENDS": true, + "EXTRACT": true, + "FALSE": true, + "FETCH": true, + "FILE": true, + "FLOAT": true, + "FOR": true, + "FORALL": true, + "FROM": true, + "FUNCTION": true, + "GOTO": true, + "GRANT": true, + "GROUP": true, + "HAVING": true, + "HEAP": true, + "HOUR": true, + "IDENTIFIED": true, + "IF": true, + "IMMEDIATE": true, + "IN": true, + "INCREMENT": true, + "INDEX": true, + "INDICATOR": true, + "INITIAL": true, + "INSERT": true, + "INTEGER": true, + "INTERFACE": true, + "INTERSECT": true, + "INTERVAL": true, + "INTO": true, + "IS": true, + "ISOLATION": true, + "JAVA": true, + "LEVEL": true, + "LIKE": true, + "LIMITED": true, + "LOCK": true, + "LONG": true, + "LOOP": true, + "MAX": true, + "MAXEXTENTS": true, + "MIN": true, + "MINUS": true, + "MINUTE": true, + "MLSLABEL": true, + "MOD": true, + "MODE": true, + "MODIFY": true, + "MONTH": true, + "NATURAL": true, + "NATURALN": true, + "NEW": true, + "NEXTVAL": true, + "NOAUDIT": true, + "NOCOMPRESS": true, + "NOCOPY": true, + "NOT": true, + "NOWAIT": true, + "NULL": true, + "NULLIF": true, + "NUMBER": true, + "NUMBER_BASE": true, + "OCIROWID": true, + "OF": true, + "OFFLINE": true, + "ON": true, + "ONLINE": true, + "OPAQUE": true, + "OPEN": true, + "OPERATOR": true, + "OPTION": true, + "OR": true, + "ORDER": true, + "ORGANIZATION": true, + "OTHERS": true, + "OUT": true, + "PACKAGE": true, + "PARTITION": true, + "PCTFREE": true, + "PLS_INTEGER": true, + "POSITIVE": true, + "POSITIVEN": true, + "PRAGMA": true, + "PRIOR": true, + "PRIVATE": true, + "PRIVILEGES": true, + "PROCEDURE": true, + "PUBLIC": true, + "RAISE": true, + "RANGE": true, + "RAW": true, + "REAL": true, + "RECORD": true, + "REF": true, + "RELEASE": true, + "RENAME": true, + "RESOURCE": true, + "RETURN": true, + "REVERSE": true, + "REVOKE": true, + "ROLLBACK": true, + "ROW": true, + "ROWID": true, + "ROWNUM": true, + "ROWS": true, + "ROWTYPE": true, + "SAVEPOINT": true, + "SECOND": true, + "SELECT": true, + "SEPERATE": true, + "SESSION": true, + "SET": true, + "SHARE": true, + "SIZE": true, + "SMALLINT": true, + "SPACE": true, + "SQL": true, + "SQLCODE": true, + "SQLERRM": true, + "START": true, + "STDDEV": true, + "SUBTYPE": true, + "SUCCESSFUL": true, + "SUM": true, + "SYNONYM": true, + "SYSDATE": true, + "TABLE": true, + "THEN": true, + "TIME": true, + "TIMESTAMP": true, + "TIMEZONE_ABBR": true, + "TIMEZONE_HOUR": true, + "TIMEZONE_MINUTE": true, + "TIMEZONE_REGION": true, + "TO": true, + "TRIGGER": true, + "TRUE": true, + "TYPE": true, + "UI": true, + "UID": true, + "UNION": true, + "UNIQUE": true, + "UPDATE": true, + "USE": true, + "USER": true, + "VALIDATE": true, + "VALUES": true, + "VARCHAR": true, + "VARCHAR2": true, + "VARIANCE": true, + "VIEW": true, + "WHEN": true, + "WHENEVER": true, + "WHERE": true, + "WHILE": true, + "WITH": true, + "WORK": true, + "WRITE": true, + "YEAR": true, + "ZONE": true, + } +) diff --git a/plsql/parser_test.go b/plsql/parser_test.go new file mode 100644 index 0000000..dd84875 --- /dev/null +++ b/plsql/parser_test.go @@ -0,0 +1,84 @@ +package plsql_test + +import ( + "os" + "path" + "strings" + "testing" + + "github.com/antlr4-go/antlr/v4" + plsql "github.com/bytebase/parser/plsql" + "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 TestPLSQLParser(t *testing.T) { + examples, err := os.ReadDir("examples") + require.NoError(t, err) + + examplesSQLScript, err := os.ReadDir("examples-sql-script") + require.NoError(t, err) + + files := append(examples, examplesSQLScript...) + + for i, file := range files { + if strings.HasSuffix(file.Name(), ".sql.tree") { + continue + } + var filePath string + if i < len(examples) { + filePath = path.Join("examples", file.Name()) + } else { + filePath = path.Join("examples-sql-script", file.Name()) + } + t.Run(filePath, func(t *testing.T) { + t.Parallel() + input, err := antlr.NewFileStream(filePath) + require.NoError(t, err) + + lexer := plsql.NewPlSqlLexer(input) + + stream := antlr.NewCommonTokenStream(lexer, 0) + p := plsql.NewPlSqlParser(stream) + p.SetVersion12(true) + + lexerErrors := &CustomErrorListener{} + lexer.RemoveErrorListeners() + lexer.AddErrorListener(lexerErrors) + + parserErrors := &CustomErrorListener{} + p.RemoveErrorListeners() + p.AddErrorListener(parserErrors) + + p.BuildParseTrees = true + _ = p.Sql_script() + + require.Equal(t, 0, lexerErrors.errors) + require.Equal(t, 0, parserErrors.errors) + }) + } +} diff --git a/plsql/plsql_lexer.go b/plsql/plsql_lexer.go new file mode 100644 index 0000000..6e280fb --- /dev/null +++ b/plsql/plsql_lexer.go @@ -0,0 +1,19292 @@ +// Code generated from PlSqlLexer.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql + +import ( + "fmt" + "github.com/antlr4-go/antlr/v4" + "sync" + "unicode" +) + +// Suppress unused import error +var _ = fmt.Printf +var _ = sync.Once{} +var _ = unicode.IsLetter + +type PlSqlLexer struct { + PlSqlLexerBase + channelNames []string + modeNames []string + // TODO: EOF string +} + +var PlSqlLexerLexerStaticData 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 plsqllexerLexerInit() { + staticData := &PlSqlLexerLexerStaticData + staticData.ChannelNames = []string{ + "DEFAULT_TOKEN_CHANNEL", "HIDDEN", + } + staticData.ModeNames = []string{ + "DEFAULT_MODE", + } + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", "'ACCOUNT'", + "'ACL'", "'ACOS'", "'ACROSS'", "'ACTION'", "'ACTIONS'", "'ACTIVATE'", + "'ACTIVE'", "'ACTIVE_COMPONENT'", "'ACTIVE_DATA'", "'ACTIVE_FUNCTION'", + "'ACTIVE_TAG'", "'ACTIVITY'", "'ADAPTIVE_PLAN'", "'ADD'", "'ADD_COLUMN'", + "'ADD_GROUP'", "'ADD_MONTHS'", "'ADJ_DATE'", "'ADMIN'", "'ADMINISTER'", + "'ADMINISTRATOR'", "'ADVANCED'", "'ADVISE'", "'ADVISOR'", "'AFD_DISKSTRING'", + "'AFTER'", "'AGENT'", "'AGGREGATE'", "'A'", "'ALIAS'", "'ALL'", "'ALLOCATE'", + "'ALLOW'", "'ALL_ROWS'", "'ALTER'", "'ALTERNATE'", "'ALWAYS'", "'ANALYTIC'", + "'ANALYZE'", "'ANCESTOR'", "'ANCILLARY'", "'AND'", "'AND_EQUAL'", "'ANOMALY'", + "'ANSI_REARCH'", "'ANTIJOIN'", "'ANY'", "'ANYSCHEMA'", "'APPEND'", "'APPENDCHILDXML'", + "'APPEND_VALUES'", "'APPLICATION'", "'APPLY'", "'APPROX_COUNT_DISTINCT'", + "'ARCHIVAL'", "'ARCHIVE'", "'ARCHIVED'", "'ARCHIVELOG'", "'ARRAY'", + "'AS'", "'ASC'", "'ASCII'", "'ASCIISTR'", "'ASIN'", "'ASIS'", "'ASSEMBLY'", + "'ASSIGN'", "'ASSOCIATE'", "'ASYNC'", "'ASYNCHRONOUS'", "'ATAN2'", "'ATAN'", + "'AT'", "'ATTRIBUTE'", "'ATTRIBUTES'", "'AUDIT'", "'AUTHENTICATED'", + "'AUTHENTICATION'", "'AUTHID'", "'AUTHORIZATION'", "'AUTOALLOCATE'", + "'AUTO'", "'AUTOEXTEND'", "'AUTO_LOGIN'", "'AUTOMATIC'", "'AUTONOMOUS_TRANSACTION'", + "'AUTO_REOPTIMIZE'", "'AVAILABILITY'", "'AVRO'", "'BACKGROUND'", "'BACKINGFILE'", + "'BACKUP'", "'BACKUPS'", "'BASIC'", "'BASICFILE'", "'BATCH'", "'BATCHSIZE'", + "'BATCH_TABLE_ACCESS_BY_ROWID'", "'BECOME'", "'BEFORE'", "'BEGIN'", + "'BEGINNING'", "'BEGIN_OUTLINE_DATA'", "'BEHALF'", "'BEQUEATH'", "'BETWEEN'", + "'BFILE'", "'BFILENAME'", "'BIGFILE'", "'BINARY'", "'BINARY_DOUBLE'", + "'BINARY_DOUBLE_INFINITY'", "'BINARY_DOUBLE_NAN'", "'BINARY_FLOAT'", + "'BINARY_FLOAT_INFINITY'", "'BINARY_FLOAT_NAN'", "'BINARY_INTEGER'", + "'BIND_AWARE'", "'BINDING'", "'BIN_TO_NUM'", "'BITAND'", "'BITMAP_AND'", + "'BITMAP'", "'BITMAPS'", "'BITMAP_TREE'", "'BITS'", "'BLOB'", "'BLOCK'", + "'BLOCK_RANGE'", "'BLOCKS'", "'BLOCKSIZE'", "'BODY'", "'BOOLEAN'", "'BOTH'", + "'BOUND'", "'BRANCH'", "'BREADTH'", "'BROADCAST'", "'BSON'", "'BUFFER'", + "'BUFFER_CACHE'", "'BUFFER_POOL'", "'BUILD'", "'BULK'", "'BY'", "'BYPASS_RECURSIVE_CHECK'", + "'BYPASS_UJVC'", "'BYTE'", "'CACHE'", "'CACHE_CB'", "'CACHE_INSTANCES'", + "'CACHE_TEMP_TABLE'", "'CACHING'", "'CALCULATED'", "'CALLBACK'", "'CALL'", + "'CANCEL'", "'CANONICAL'", "'CAPACITY'", "'CAPTION'", "'CARDINALITY'", + "'CASCADE'", "'CASE'", "'CAST'", "'CASE-SENSITIVE'", "'CATEGORY'", "'CDB$DEFAULT'", + "'CEIL'", "'CELL_FLASH_CACHE'", "'CERTIFICATE'", "'CFILE'", "'CHAINED'", + "'CHANGE'", "'CHANGE_DUPKEY_ERROR_INDEX'", "'CHARACTER'", "'CHAR'", + "'CHAR_CS'", "'CHARTOROWID'", "'CHECK_ACL_REWRITE'", "'CHECK'", "'CHECKPOINT'", + "'CHILD'", "'CHOOSE'", "'CHR'", "'CHUNK'", "'CLASS'", "'CLASSIFICATION'", + "'CLASSIFIER'", "'CLAUSE'", "'CLEAN'", "'CLEANUP'", "'CLEAR'", "'C'", + "'CLIENT'", "'CLOB'", "'CLONE'", "'CLOSE_CACHED_OPEN_CURSORS'", "'CLOSE'", + "'CLUSTER_BY_ROWID'", "'CLUSTER'", "'CLUSTER_DETAILS'", "'CLUSTER_DISTANCE'", + "'CLUSTER_ID'", "'CLUSTERING'", "'CLUSTERING_FACTOR'", "'CLUSTER_PROBABILITY'", + "'CLUSTER_SET'", "'COALESCE'", "'COALESCE_SQ'", "'COARSE'", "'CO_AUTH_IND'", + "'COLD'", "'COLLECT'", "'COLUMNAR'", "'COLUMN_AUTH_INDICATOR'", "'COLUMN'", + "'COLUMNS'", "'COLUMN_STATS'", "'COLUMN_VALUE'", "'COMMENT'", "'COMMIT'", + "'COMMITTED'", "'COMMON'", "'COMMON_DATA'", "'COMPACT'", "'COMPATIBILITY'", + "'COMPILE'", "'COMPLETE'", "'COMPLIANCE'", "'COMPONENT'", "'COMPONENTS'", + "'COMPOSE'", "'COMPOSITE'", "'COMPOSITE_LIMIT'", "'COMPOUND'", "'COMPRESS'", + "'COMPUTE'", "'CONCAT'", "'CON_DBID_TO_ID'", "'CONDITIONAL'", "'CONDITION'", + "'CONFIRM'", "'CONFORMING'", "'CON_GUID_TO_ID'", "'CON_ID'", "'CON_NAME_TO_ID'", + "'CONNECT_BY_CB_WHR_ONLY'", "'CONNECT_BY_COMBINE_SW'", "'CONNECT_BY_COST_BASED'", + "'CONNECT_BY_ELIM_DUPS'", "'CONNECT_BY_FILTERING'", "'CONNECT_BY_ISCYCLE'", + "'CONNECT_BY_ISLEAF'", "'CONNECT_BY_ROOT'", "'CONNECT'", "'CONNECT_TIME'", + "'CONSIDER'", "'CONSISTENT'", "'CONSTANT'", "'CONST'", "'CONSTRAINT'", + "'CONSTRAINTS'", "'CONSTRUCTOR'", "'CONTAINER'", "'CONTAINERS'", "'CONTAINERS_DEFAULT'", + "'CONTAINER_DATA'", "'CONTAINER_MAP'", "'CONTENT'", "'CONTENTS'", "'CONTEXT'", + "'CONTINUE'", "'CONTROLFILE'", "'CON_UID_TO_ID'", "'CONVERT'", "'CONVERSION'", + "'COOKIE'", "'COPY'", "'CORR_K'", "'CORR_S'", "'CORRUPTION'", "'CORRUPT_XID_ALL'", + "'CORRUPT_XID'", "'COS'", "'COSH'", "'COST'", "'COST_XML_QUERY_REWRITE'", + "'COUNT'", "'COVAR_POP'", "'COVAR_SAMP'", "'CPU_COSTING'", "'CPU_PER_CALL'", + "'CPU_PER_SESSION'", "'CRASH'", "'CREATE'", "'CREATE_FILE_DEST'", "'CREATE_STORED_OUTLINES'", + "'CREATION'", "'CREDENTIAL'", "'CRITICAL'", "'CROSS'", "'CROSSEDITION'", + "'CSCONVERT'", "'CUBE_AJ'", "'CUBE'", "'CUBE_GB'", "'CUBE_SJ'", "'CUME_DISTM'", + "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_SCHEMA'", "'CURRENT_TIME'", + "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'CURRENTV'", "'CURSOR'", "'CURSOR_SHARING_EXACT'", + "'CURSOR_SPECIFIC_SEGMENT'", "'CUSTOMDATUM'", "'CV'", "'CYCLE'", "'DANGLING'", + "'DATABASE'", "'DATA'", "'DATAFILE'", "'DATAFILES'", "'DATAMOVEMENT'", + "'DATAOBJNO'", "'DATAOBJ_TO_MAT_PARTITION'", "'DATAOBJ_TO_PARTITION'", + "'DATAPUMP'", "'DATA_SECURITY_REWRITE_LIMIT'", "'DATE'", "'DATE_MODE'", + "'DAY'", "'DAYS'", "'DBA'", "'DBA_RECYCLEBIN'", "'DBMS_STATS'", "'DB_ROLE_CHANGE'", + "'DBTIMEZONE'", "'DB_UNIQUE_NAME'", "'DB_VERSION'", "'DDL'", "'DEALLOCATE'", + "'DEBUG'", "'DEBUGGER'", "'DEC'", "'DECIMAL'", "'DECLARE'", "'DECOMPOSE'", + "'DECORRELATE'", "'DECR'", "'DECREMENT'", "'DECRYPT'", "'DEDUPLICATE'", + "'DEFAULT'", "'DEFAULTS'", "'DEFAULT_COLLATION'", "'DEFAULT_CREDENTIAL'", + "'DEFERRABLE'", "'DEFERRED'", "'DEFINED'", "'DEFINE'", "'DEFINER'", + "'DEGREE'", "'DELAY'", "'DELEGATE'", "'DELETE_ALL'", "'DELETE'", "'DELETEXML'", + "'DEMAND'", "'DENSE_RANKM'", "'DEPENDENT'", "'DEPTH'", "'DEQUEUE'", + "'DEREF'", "'DEREF_NO_REWRITE'", "'DESC'", "'DESCRIPTION'", "'DESTROY'", + "'DETACHED'", "'DETERMINES'", "'DETERMINISTIC'", "'DICTIONARY'", "'DIMENSION'", + "'DIMENSIONS'", "'DIRECT_LOAD'", "'DIRECTORY'", "'DIRECT_PATH'", "'DISABLE_ALL'", + "'DISABLE'", "'DISABLE_PARALLEL_DML'", "'DISABLE_PRESET'", "'DISABLE_RPKE'", + "'DISALLOW'", "'DISASSOCIATE'", "'DISCARD'", "'DISCONNECT'", "'DISK'", + "'DISKGROUP'", "'DISKS'", "'DISMOUNT'", "'DISTINCT'", "'DISTINGUISHED'", + "'DISTRIBUTED'", "'DISTRIBUTE'", "'DML'", "'DML_UPDATE'", "'DOCFIDELITY'", + "'DOCUMENT'", "'DOMAIN_INDEX_FILTER'", "'DOMAIN_INDEX_NO_SORT'", "'DOMAIN_INDEX_SORT'", + "'DOUBLE'", "'DOWNGRADE'", "'DRIVING_SITE'", "'DROP_COLUMN'", "'DROP'", + "'DROP_GROUP'", "'DSINTERVAL_UNCONSTRAINED'", "'DST_UPGRADE_INSERT_CONV'", + "'DUMP'", "'DUPLICATE'", "'DV'", "'DYNAMIC'", "'DYNAMIC_SAMPLING'", + "'DYNAMIC_SAMPLING_EST_CDN'", "'E'", "'EACH'", "'EDITIONABLE'", "'EDITION'", + "'EDITIONING'", "'EDITIONS'", "'ELEMENT'", "'ELIM_GROUPBY'", "'ELIMINATE_JOIN'", + "'ELIMINATE_OBY'", "'ELIMINATE_OUTER_JOIN'", "'ELSE'", "'ELSIF'", "'EM'", + "'EMPTY_BLOB'", "'EMPTY_CLOB'", "'EMPTY'", "'ENABLE_ALL'", "'ENABLE'", + "'ENABLE_PARALLEL_DML'", "'ENABLE_PRESET'", "'ENCODING'", "'ENCRYPT'", + "'ENCRYPTION'", "'END'", "'END_OUTLINE_DATA'", "'ENFORCED'", "'ENFORCE'", + "'ENQUEUE'", "'ENTERPRISE'", "'ENTITYESCAPING'", "'ENTRY'", "'EQUIPART'", + "'ERR'", "'ERROR_ARGUMENT'", "'ERROR'", "'ERROR_ON_OVERLAP_TIME'", "'ERRORS'", + "'ESCAPE'", "'ESTIMATE'", "'EVAL'", "'EVALNAME'", "'EVALUATE'", "'EVALUATION'", + "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCEPTION'", "'EXCEPTION_INIT'", + "'EXCEPTIONS'", "'EXCHANGE'", "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", + "'EXECUTE'", "'EXEMPT'", "'EXISTING'", "'EXISTS'", "'EXISTSNODE'", "'EXIT'", + "'EXPAND_GSET_TO_UNION'", "'EXPAND_TABLE'", "'EXP'", "'EXPIRE'", "'EXPLAIN'", + "'EXPLOSION'", "'EXPORT'", "'EXPR_CORR_CHECK'", "'EXPRESS'", "'EXTENDS'", + "'EXTENT'", "'EXTENTS'", "'EXTERNAL'", "'EXTERNALLY'", "'EXTRACTCLOBXML'", + "'EXTRACT'", "'EXTRACTVALUE'", "'EXTRA'", "'FACILITY'", "'FACT'", "'FACTOR'", + "'FACTORIZE_JOIN'", "'FAILED'", "'FAILED_LOGIN_ATTEMPTS'", "'FAILGROUP'", + "'FAILOVER'", "'FAILURE'", "'FALSE'", "'FAMILY'", "'FAR'", "'FAST'", + "'FASTSTART'", "'FBTSCAN'", "'FEATURE'", "'FEATURE_DETAILS'", "'FEATURE_ID'", + "'FEATURE_SET'", "'FEATURE_VALUE'", "'FETCH'", "'FILE'", "'FILE_NAME_CONVERT'", + "'FILEGROUP'", "'FILESTORE'", "'FILESYSTEM_LIKE_LOGGING'", "'FILTER'", + "'FINAL'", "'FINE'", "'FINISH'", "'FIRST'", "'FIRSTM'", "'FIRST_ROWS'", + "'FIRST_VALUE'", "'FIXED_VIEW_DATA'", "'FLAGGER'", "'FLASHBACK'", "'FLASH_CACHE'", + "'FLOAT'", "'FLOB'", "'FLEX'", "'FLOOR'", "'FLUSH'", "'FOLDER'", "'FOLLOWING'", + "'FOLLOWS'", "'FORALL'", "'FORCE'", "'FORCE_XML_QUERY_REWRITE'", "'FOREIGN'", + "'FOREVER'", "'FOR'", "'FORMAT'", "'FORWARD'", "'FRAGMENT_NUMBER'", + "'FREELIST'", "'FREELISTS'", "'FREEPOOLS'", "'FRESH'", "'FROM'", "'FROM_TZ'", + "'FULL'", "'FULL_OUTER_JOIN_TO_OUTER'", "'FUNCTION'", "'FUNCTIONS'", + "'FTP'", "'G'", "'GATHER_OPTIMIZER_STATISTICS'", "'GATHER_PLAN_STATISTICS'", + "'GBY_CONC_ROLLUP'", "'GBY_PUSHDOWN'", "'GENERATED'", "'GET'", "'GLOBAL'", + "'GLOBALLY'", "'GLOBAL_NAME'", "'GLOBAL_TOPIC_ENABLED'", "'GOTO'", "'GRANT'", + "'GROUP_BY'", "'GROUP'", "'GROUP_ID'", "'GROUPING'", "'GROUPING_ID'", + "'GROUPS'", "'GUARANTEED'", "'GUARANTEE'", "'GUARD'", "'HALF_YEARS'", + "'HASH_AJ'", "'HASH'", "'HASHKEYS'", "'HASH_SJ'", "'HAVING'", "'HEADER'", + "'HEAP'", "'HELP'", "'HEXTORAW'", "'HEXTOREF'", "'HIDDEN'", "'HIDE'", + "'HIER_ORDER'", "'HIERARCHICAL'", "'HIERARCHIES'", "'HIERARCHY'", "'HIGH'", + "'HINTSET_BEGIN'", "'HINTSET_END'", "'HOT'", "'HOUR'", "'HOURS'", "'HTTP'", + "'HWM_BROKERED'", "'HYBRID'", "'H'", "'IDENTIFIED'", "'IDENTIFIER'", + "'IDENTITY'", "'IDGENERATORS'", "'ID'", "'IDLE_TIME'", "'IF'", "'IGNORE'", + "'IGNORE_OPTIM_EMBEDDED_HINTS'", "'IGNORE_ROW_ON_DUPKEY_INDEX'", "'IGNORE_WHERE_CLAUSE'", + "'ILM'", "'IMMEDIATE'", "'IMPACT'", "'IMPORT'", "'INACTIVE'", "'INACTIVE_ACCOUNT_TIME'", + "'INCLUDE'", "'INCLUDE_VERSION'", "'INCLUDING'", "'INCREMENTAL'", "'INCREMENT'", + "'INCR'", "'INDENT'", "'INDEX_ASC'", "'INDEX_COMBINE'", "'INDEX_DESC'", + "'INDEXED'", "'INDEXES'", "'INDEX_FFS'", "'INDEX_FILTER'", "'INDEX'", + "'INDEXING'", "'INDEX_JOIN'", "'INDEX_ROWS'", "'INDEX_RRS'", "'INDEX_RS_ASC'", + "'INDEX_RS_DESC'", "'INDEX_RS'", "'INDEX_SCAN'", "'INDEX_SKIP_SCAN'", + "'INDEX_SS_ASC'", "'INDEX_SS_DESC'", "'INDEX_SS'", "'INDEX_STATS'", + "'INDEXTYPE'", "'INDEXTYPES'", "'INDICATOR'", "'INDICES'", "'INFINITE'", + "'INFORMATIONAL'", "'INHERIT'", "'IN'", "'INITCAP'", "'INITIAL'", "'INITIALIZED'", + "'INITIALLY'", "'INITRANS'", "'INLINE'", "'INLINE_XMLTYPE_NT'", "'INMEMORY'", + "'IN_MEMORY_METADATA'", "'INMEMORY_PRUNING'", "'INNER'", "'INOUT'", + "'INPLACE'", "'INSERTCHILDXMLAFTER'", "'INSERTCHILDXMLBEFORE'", "'INSERTCHILDXML'", + "'INSERT'", "'INSERTXMLAFTER'", "'INSERTXMLBEFORE'", "'INSTANCE'", "'INSTANCES'", + "'INSTANTIABLE'", "'INSTANTLY'", "'INSTEAD'", "'INSTR2'", "'INSTR4'", + "'INSTRB'", "'INSTRC'", "'INSTR'", "'INTEGER'", "'INTERLEAVED'", "'INTERMEDIATE'", + "'INTERNAL_CONVERT'", "'INTERNAL_USE'", "'INTERPRETED'", "'INTERSECT'", + "'INTERVAL'", "'INT'", "'INTO'", "'INVALIDATE'", "'INVISIBLE'", "'IN_XQUERY'", + "'IS'", "'IS_LEAF'", "'ISOLATION'", "'ISOLATION_LEVEL'", "'ITERATE'", + "'ITERATION_NUMBER'", "'JAVA'", "'JOB'", "'JOIN'", "'JSON_ARRAYAGG'", + "'JSON_ARRAY'", "'JSON_EQUAL'", "'JSON_EXISTS2'", "'JSON_EXISTS'", "'JSONGET'", + "'JSON'", "'JSON_OBJECTAGG'", "'JSON_OBJECT'", "'JSONPARSE'", "'JSON_QUERY'", + "'JSON_SERIALIZE'", "'JSON_TABLE'", "'JSON_TEXTCONTAINS2'", "'JSON_TEXTCONTAINS'", + "'JSON_TRANSFORM'", "'JSON_VALUE'", "'K'", "'KEEP_DUPLICATES'", "'KEEP'", + "'KERBEROS'", "'KEY'", "'KEY_LENGTH'", "'KEYSIZE'", "'KEYS'", "'KEYSTORE'", + "'KILL'", "'LABEL'", "'LANGUAGE'", "'LAST_DAY'", "'LAST'", "'LAST_VALUE'", + "'LATERAL'", "'LAX'", "'LAYER'", "'LDAP_REGISTRATION_ENABLED'", "'LDAP_REGISTRATION'", + "'LDAP_REG_SYNC_INTERVAL'", "'LEAF'", "'LEAD_CDB'", "'LEAD_CDB_URI'", + "'LEADING'", "'LEFT'", "'LENGTH2'", "'LENGTH4'", "'LENGTHB'", "'LENGTHC'", + "'LENGTH'", "'LESS'", "'LEVEL'", "'LEVEL_NAME'", "'LEVELS'", "'LIBRARY'", + "'LIFECYCLE'", "'LIFE'", "'LIFETIME'", "'LIKE2'", "'LIKE4'", "'LIKEC'", + "'LIKE_EXPAND'", "'LIKE'", "'LIMIT'", "'LINEAR'", "'LINK'", "'LIST'", + "'LN'", "'LNNVL'", "'LOAD'", "'LOB'", "'LOBNVL'", "'LOBS'", "'LOCAL_INDEXES'", + "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'LOCATION'", "'LOCATOR'", + "'LOCKDOWN'", "'LOCKED'", "'LOCKING'", "'LOCK'", "'LOGFILE'", "'LOGFILES'", + "'LOGGING'", "'LOGICAL'", "'LOGICAL_READS_PER_CALL'", "'LOGICAL_READS_PER_SESSION'", + "'LOG'", "'LOGMINING'", "'LOGOFF'", "'LOGON'", "'LOG_READ_ONLY_VIOLATIONS'", + "'LONG'", "'LOOP'", "'LOST'", "'LOWER'", "'LOW'", "'LPAD'", "'LTRIM'", + "'M'", "'MAIN'", "'MAKE_REF'", "'MANAGED'", "'MANAGE'", "'MANAGEMENT'", + "'MANAGER'", "'MANDATORY'", "'MANUAL'", "'MAP'", "'MAPPING'", "'MASTER'", + "'MATCHED'", "'MATCHES'", "'MATCH'", "'MATCH_NUMBER'", "'MATCH_RECOGNIZE'", + "'MATERIALIZED'", "'MATERIALIZE'", "'MAXARCHLOGS'", "'MAXDATAFILES'", + "'MAXEXTENTS'", "'MAXIMIZE'", "'MAXINSTANCES'", "'MAXLOGFILES'", "'MAXLOGHISTORY'", + "'MAXLOGMEMBERS'", "'MAX_SHARED_TEMP_SIZE'", "'MAXSIZE'", "'MAXTRANS'", + "'MAXVALUE'", "'MEASURE'", "'MEASURES'", "'MEDIUM'", "'MEMBER'", "'MEMBER_CAPTION'", + "'MEMBER_DESCRIPTION'", "'MEMBER_NAME'", "'MEMBER_UNIQUE_NAME'", "'MEMCOMPRESS'", + "'MEMORY'", "'MERGE$ACTIONS'", "'MERGE_AJ'", "'MERGE_CONST_ON'", "'MERGE'", + "'MERGE_SJ'", "'METADATA'", "'METHOD'", "'MIGRATE'", "'MIGRATION'", + "'MINEXTENTS'", "'MINIMIZE'", "'MINIMUM'", "'MINING'", "'MINUS'", "'MINUS_NULL'", + "'MINUTE'", "'MINUTES'", "'MINVALUE'", "'MIRRORCOLD'", "'MIRRORHOT'", + "'MIRROR'", "'MISSING'", "'MISMATCH'", "'MLSLABEL'", "'MODEL_COMPILE_SUBQUERY'", + "'MODEL_DONTVERIFY_UNIQUENESS'", "'MODEL_DYNAMIC_SUBQUERY'", "'MODEL_MIN_ANALYSIS'", + "'MODEL'", "'MODEL_NB'", "'MODEL_NO_ANALYSIS'", "'MODEL_PBY'", "'MODEL_PUSH_REF'", + "'MODEL_SV'", "'MODE'", "'MODIFICATION'", "'MODIFY_COLUMN_TYPE'", "'MODIFY'", + "'MOD'", "'MODULE'", "'MONITORING'", "'MONITOR'", "'MONTH'", "'MONTHS_BETWEEN'", + "'MONTHS'", "'MOUNT'", "'MOUNTPATH'", "'MOUNTPOINT'", "'MOVEMENT'", + "'MOVE'", "'MULTIDIMENSIONAL'", "'MULTISET'", "'MV_MERGE'", "'NAMED'", + "'NAME'", "'NAMESPACE'", "'NAN'", "'NANVL'", "'NATIONAL'", "'NATIVE_FULL_OUTER_JOIN'", + "'NATIVE'", "'NATURAL'", "'NATURALN'", "'NAV'", "'NCHAR_CS'", "'NCHAR'", + "'NCHR'", "'NCLOB'", "'NEEDED'", "'NEG'", "'NESTED'", "'NESTED_TABLE_FAST_INSERT'", + "'NESTED_TABLE_GET_REFS'", "'NESTED_TABLE_ID'", "'NESTED_TABLE_SET_REFS'", + "'NESTED_TABLE_SET_SETID'", "'NETWORK'", "'NEVER'", "'NEW'", "'NEW_TIME'", + "'NEXT_DAY'", "'NEXT'", "'NL_AJ'", "'NLJ_BATCHING'", "'NLJ_INDEX_FILTER'", + "'NLJ_INDEX_SCAN'", "'NLJ_PREFETCH'", "'NLS_CALENDAR'", "'NLS_CHARACTERSET'", + "'NLS_CHARSET_DECL_LEN'", "'NLS_CHARSET_ID'", "'NLS_CHARSET_NAME'", + "'NLS_COMP'", "'NLS_CURRENCY'", "'NLS_DATE_FORMAT'", "'NLS_DATE_LANGUAGE'", + "'NLS_INITCAP'", "'NLS_ISO_CURRENCY'", "'NL_SJ'", "'NLS_LANG'", "'NLS_LANGUAGE'", + "'NLS_LENGTH_SEMANTICS'", "'NLS_LOWER'", "'NLS_NCHAR_CONV_EXCP'", "'NLS_NUMERIC_CHARACTERS'", + "'NLS_SORT'", "'NLSSORT'", "'NLS_SPECIAL_CHARS'", "'NLS_TERRITORY'", + "'NLS_UPPER'", "'NO_ACCESS'", "'NO_ADAPTIVE_PLAN'", "'NO_ANSI_REARCH'", + "'NOAPPEND'", "'NOARCHIVELOG'", "'NOAUDIT'", "'NO_AUTO_REOPTIMIZE'", + "'NO_BASETABLE_MULTIMV_REWRITE'", "'NO_BATCH_TABLE_ACCESS_BY_ROWID'", + "'NO_BIND_AWARE'", "'NO_BUFFER'", "'NOCACHE'", "'NO_CARTESIAN'", "'NO_CHECK_ACL_REWRITE'", + "'NO_CLUSTER_BY_ROWID'", "'NO_CLUSTERING'", "'NO_COALESCE_SQ'", "'NO_COMMON_DATA'", + "'NOCOMPRESS'", "'NO_CONNECT_BY_CB_WHR_ONLY'", "'NO_CONNECT_BY_COMBINE_SW'", + "'NO_CONNECT_BY_COST_BASED'", "'NO_CONNECT_BY_ELIM_DUPS'", "'NO_CONNECT_BY_FILTERING'", + "'NOCOPY'", "'NO_COST_XML_QUERY_REWRITE'", "'NO_CPU_COSTING'", "'NOCPU_COSTING'", + "'NOCYCLE'", "'NO_DATA_SECURITY_REWRITE'", "'NO_DECORRELATE'", "'NODELAY'", + "'NO_DOMAIN_INDEX_FILTER'", "'NO_DST_UPGRADE_INSERT_CONV'", "'NO_ELIM_GROUPBY'", + "'NO_ELIMINATE_JOIN'", "'NO_ELIMINATE_OBY'", "'NO_ELIMINATE_OUTER_JOIN'", + "'NOENTITYESCAPING'", "'NO_EXPAND_GSET_TO_UNION'", "'NO_EXPAND'", "'NO_EXPAND_TABLE'", + "'NO_FACT'", "'NO_FACTORIZE_JOIN'", "'NO_FILTERING'", "'NOFORCE'", "'NO_FULL_OUTER_JOIN_TO_OUTER'", + "'NO_GATHER_OPTIMIZER_STATISTICS'", "'NO_GBY_PUSHDOWN'", "'NOGUARANTEE'", + "'NO_INDEX_FFS'", "'NO_INDEX'", "'NO_INDEX_SS'", "'NO_INMEMORY'", "'NO_INMEMORY_PRUNING'", + "'NOKEEP'", "'NO_LOAD'", "'NOLOCAL'", "'NOLOGGING'", "'NOMAPPING'", + "'NOMAXVALUE'", "'NO_MERGE'", "'NOMINIMIZE'", "'NOMINVALUE'", "'NO_MODEL_PUSH_REF'", + "'NO_MONITORING'", "'NOMONITORING'", "'NO_MONITOR'", "'NO_MULTIMV_REWRITE'", + "'NO_NATIVE_FULL_OUTER_JOIN'", "'NONBLOCKING'", "'NONEDITIONABLE'", + "'NONE'", "'NO_NLJ_BATCHING'", "'NO_NLJ_PREFETCH'", "'NO'", "'NONSCHEMA'", + "'NO_OBJECT_LINK'", "'NOORDER'", "'NO_ORDER_ROLLUPS'", "'NO_OUTER_JOIN_TO_ANTI'", + "'NO_OUTER_JOIN_TO_INNER'", "'NOOVERRIDE'", "'NO_PARALLEL_INDEX'", "'NOPARALLEL_INDEX'", + "'NO_PARALLEL'", "'NOPARALLEL'", "'NO_PARTIAL_COMMIT'", "'NO_PARTIAL_JOIN'", + "'NO_PARTIAL_ROLLUP_PUSHDOWN'", "'NOPARTITION'", "'NO_PLACE_DISTINCT'", + "'NO_PLACE_GROUP_BY'", "'NO_PQ_CONCURRENT_UNION'", "'NO_PQ_MAP'", "'NOPROMPT'", + "'NO_PQ_REPLICATE'", "'NO_PQ_SKEW'", "'NO_PRUNE_GSETS'", "'NO_PULL_PRED'", + "'NO_PUSH_PRED'", "'NO_PUSH_SUBQ'", "'NO_PX_FAULT_TOLERANCE'", "'NO_PX_JOIN_FILTER'", + "'NO_QKN_BUFF'", "'NO_QUERY_TRANSFORMATION'", "'NO_REF_CASCADE'", "'NORELOCATE'", + "'NORELY'", "'NOREPAIR'", "'NOREPLAY'", "'NORESETLOGS'", "'NO_RESULT_CACHE'", + "'NOREVERSE'", "'NO_REWRITE'", "'NOREWRITE'", "'NORMAL'", "'NO_ROOT_SW_FOR_LOCAL'", + "'NOROWDEPENDENCIES'", "'NOSCHEMACHECK'", "'NOSEGMENT'", "'NO_SEMIJOIN'", + "'NO_SEMI_TO_INNER'", "'NO_SET_TO_JOIN'", "'NOSORT'", "'NO_SQL_TRANSLATION'", + "'NO_SQL_TUNE'", "'NO_STAR_TRANSFORMATION'", "'NO_STATEMENT_QUEUING'", + "'NO_STATS_GSETS'", "'NOSTRICT'", "'NO_SUBQUERY_PRUNING'", "'NO_SUBSTRB_PAD'", + "'NO_SWAP_JOIN_INPUTS'", "'NOSWITCH'", "'NO_TABLE_LOOKUP_BY_NL'", "'NO_TEMP_TABLE'", + "'NOTHING'", "'NOTIFICATION'", "'NOT'", "'NO_TRANSFORM_DISTINCT_AGG'", + "'NO_UNNEST'", "'NO_USE_CUBE'", "'NO_USE_HASH_AGGREGATION'", "'NO_USE_HASH_GBY_FOR_PUSHDOWN'", + "'NO_USE_HASH'", "'NO_USE_INVISIBLE_INDEXES'", "'NO_USE_MERGE'", "'NO_USE_NL'", + "'NO_USE_VECTOR_AGGREGATION'", "'NOVALIDATE'", "'NO_VECTOR_TRANSFORM_DIMS'", + "'NO_VECTOR_TRANSFORM_FACT'", "'NO_VECTOR_TRANSFORM'", "'NOWAIT'", "'NO_XDB_FASTPATH_INSERT'", + "'NO_XML_DML_REWRITE'", "'NO_XMLINDEX_REWRITE_IN_SELECT'", "'NO_XMLINDEX_REWRITE'", + "'NO_XML_QUERY_REWRITE'", "'NO_ZONEMAP'", "'NTH_VALUE'", "'NULLIF'", + "'NULL'", "'NULLS'", "'NUMBER'", "'NUMERIC'", "'NUM_INDEX_KEYS'", "'NUMTODSINTERVAL'", + "'NUMTOYMINTERVAL'", "'NVARCHAR2'", "'NVL2'", "'OBJECT2XML'", "'OBJECT'", + "'OBJ_ID'", "'OBJNO'", "'OBJNO_REUSE'", "'OCCURENCES'", "'OFFLINE'", + "'OFF'", "'OFFSET'", "'OF'", "'OIDINDEX'", "'OID'", "'OLAP'", "'OLD'", + "'OLD_PUSH_PRED'", "'OLS'", "'OLTP'", "'OMIT'", "'ONE'", "'ONLINE'", + "'ONLY'", "'ON'", "'OPAQUE'", "'OPAQUE_TRANSFORM'", "'OPAQUE_XCANONICAL'", + "'OPCODE'", "'OPEN'", "'OPERATIONS'", "'OPERATOR'", "'OPT_ESTIMATE'", + "'OPTIMAL'", "'OPTIMIZE'", "'OPTIMIZER_FEATURES_ENABLE'", "'OPTIMIZER_GOAL'", + "'OPTION'", "'OPT_PARAM'", "'ORA_BRANCH'", "'ORA_CHECK_ACL'", "'ORA_CHECK_PRIVILEGE'", + "'ORA_CLUSTERING'", "'ORADATA'", "'ORADEBUG'", "'ORA_DST_AFFECTED'", + "'ORA_DST_CONVERT'", "'ORA_DST_ERROR'", "'ORA_GET_ACLIDS'", "'ORA_GET_PRIVILEGES'", + "'ORA_HASH'", "'ORA_INVOKING_USERID'", "'ORA_INVOKING_USER'", "'ORA_INVOKING_XS_USER_GUID'", + "'ORA_INVOKING_XS_USER'", "'ORA_RAWCOMPARE'", "'ORA_RAWCONCAT'", "'ORA_ROWSCN'", + "'ORA_ROWSCN_RAW'", "'ORA_ROWVERSION'", "'ORA_TABVERSION'", "'ORA_WRITE_TIME'", + "'ORDERED'", "'ORDERED_PREDICATES'", "'ORDER'", "'ORDINALITY'", "'OR_EXPAND'", + "'ORGANIZATION'", "'OR'", "'OR_PREDICATES'", "'OSERROR'", "'OTHER'", + "'OUTER_JOIN_TO_ANTI'", "'OUTER_JOIN_TO_INNER'", "'OUTER'", "'OUTLINE_LEAF'", + "'OUTLINE'", "'OUT_OF_LINE'", "'OUT'", "'OVERFLOW_NOMOVE'", "'OVERFLOW'", + "'OVERLAPS'", "'OVER'", "'OVERRIDING'", "'OWNER'", "'OWNERSHIP'", "'OWN'", + "'P'", "'PACKAGE'", "'PACKAGES'", "'PARALLEL_ENABLE'", "'PARALLEL_INDEX'", + "'PARALLEL'", "'PARAMETERS'", "'PARAM'", "'PARENT'", "'PARENT_LEVEL_NAME'", + "'PARENT_UNIQUE_NAME'", "'PARITY'", "'PARTIAL_JOIN'", "'PARTIALLY'", + "'PARTIAL'", "'PARTIAL_ROLLUP_PUSHDOWN'", "'PARTITION_HASH'", "'PARTITION_LIST'", + "'PARTITION'", "'PARTITION_RANGE'", "'PARTITIONS'", "'PART$NUM$INST'", + "'PASSING'", "'PASSWORD_GRACE_TIME'", "'PASSWORD_LIFE_TIME'", "'PASSWORD_LOCK_TIME'", + "'PASSWORD'", "'PASSWORD_REUSE_MAX'", "'PASSWORD_REUSE_TIME'", "'PASSWORD_ROLLOVER_TIME'", + "'PASSWORD_VERIFY_FUNCTION'", "'PAST'", "'PATCH'", "'PATH'", "'PATH_PREFIX'", + "'PATHS'", "'PATTERN'", "'PBL_HS_BEGIN'", "'PBL_HS_END'", "'PCTFREE'", + "'PCTINCREASE'", "'PCTTHRESHOLD'", "'PCTUSED'", "'PCTVERSION'", "'PENDING'", + "", "", "", "'PERCENT'", "'PERCENT_RANKM'", "", "", "", "'PERFORMANCE'", + "'PERIOD'", "'PERMANENT'", "'PERMISSION'", "'PERMUTE'", "'PER'", "'PFILE'", + "'PHYSICAL'", "'PIKEY'", "'PIPELINED'", "'PIPE'", "'PIV_GB'", "'PIVOT'", + "'PIV_SSF'", "'PLACE_DISTINCT'", "'PLACE_GROUP_BY'", "'PLAN'", "'PLSCOPE_SETTINGS'", + "'PLS_INTEGER'", "'PLSQL_CCFLAGS'", "'PLSQL_CODE_TYPE'", "'PLSQL_DEBUG'", + "'PLSQL_OPTIMIZE_LEVEL'", "'PLSQL_WARNINGS'", "'PLUGGABLE'", "'PMEM'", + "'POINT'", "'POLICY'", "'POOL_16K'", "'POOL_2K'", "'POOL_32K'", "'POOL_4K'", + "'POOL_8K'", "'POSITIVEN'", "'POSITIVE'", "'POST_TRANSACTION'", "'POWERMULTISET_BY_CARDINALITY'", + "'POWERMULTISET'", "'POWER'", "'PQ_CONCURRENT_UNION'", "'PQ_DISTRIBUTE'", + "'PQ_DISTRIBUTE_WINDOW'", "'PQ_FILTER'", "'PQ_MAP'", "'PQ_NOMAP'", "'PQ_REPLICATE'", + "'PQ_SKEW'", "'PRAGMA'", "'PREBUILT'", "'PRECEDES'", "'PRECEDING'", + "'PRECISION'", "'PRECOMPUTE_SUBQUERY'", "'PREDICATE_REORDERS'", "'PRELOAD'", + "'PREPARE'", "'PRESENTNNV'", "'PRESENT'", "'PRESENTV'", "'PRESERVE_OID'", + "'PRESERVE'", "'PRETTY'", "'PREVIOUS'", "'PREV'", "'PRIMARY'", "'PRINTBLOBTOCLOB'", + "'PRIORITY'", "'PRIOR'", "'PRIVATE'", "'PRIVATE_SGA'", "'PRIVILEGED'", + "'PRIVILEGE'", "'PRIVILEGES'", "'PROCEDURAL'", "'PROCEDURE'", "'PROCESS'", + "'PROFILE'", "'PROGRAM'", "'PROJECT'", "'PROPAGATE'", "'PROPERTY'", + "'PROTECTED'", "'PROTECTION'", "'PROTOCOL'", "'PROXY'", "'PRUNING'", + "'PUBLIC'", "'PULL_PRED'", "'PURGE'", "'PUSH_PRED'", "'PUSH_SUBQ'", + "'PX_FAULT_TOLERANCE'", "'PX_GRANULE'", "'PX_JOIN_FILTER'", "'QB_NAME'", + "'QUARTERS'", "'QUERY_BLOCK'", "'QUERY'", "'QUEUE_CURR'", "'QUEUE'", + "'QUEUE_ROWP'", "'QUIESCE'", "'QUORUM'", "'QUOTA'", "'QUOTAGROUP'", + "'RAISE'", "'RANDOM_LOCAL'", "'RANDOM'", "'RANGE'", "'RANKM'", "'RAPIDLY'", + "'RAW'", "'RAWTOHEX'", "'RAWTONHEX'", "'RBA'", "'RBO_OUTLINE'", "'RDBA'", + "'READ'", "'READS'", "'REALM'", "'REAL'", "'REBALANCE'", "'REBUILD'", + "'RECORD'", "'RECORDS_PER_BLOCK'", "'RECOVERABLE'", "'RECOVER'", "'RECOVERY'", + "'RECYCLEBIN'", "'RECYCLE'", "'REDACTION'", "'REDEFINE'", "'REDO'", + "'REDUCED'", "'REDUNDANCY'", "'REF_CASCADE_CURSOR'", "'REFERENCED'", + "'REFERENCE'", "'REFERENCES'", "'REFERENCING'", "'REF'", "'REFRESH'", + "'REFTOHEX'", "'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_REPLACE'", + "'REGEXP_SUBSTR'", "'REGISTER'", "'REGR_AVGX'", "'REGR_AVGY'", "'REGR_COUNT'", + "'REGR_INTERCEPT'", "'REGR_R2'", "'REGR_SLOPE'", "'REGR_SXX'", "'REGR_SXY'", + "'REGR_SYY'", "'REGULAR'", "'REJECT'", "'REKEY'", "'RELATIONAL'", "'RELIES_ON'", + "'RELOCATE'", "'RELY'", "'REMAINDER'", "'REMOTE'", "'REMOTE_MAPPED'", + "'REMOVE'", "'RENAME'", "'REPAIR'", "'REPEAT'", "'REPLACE'", "'REPLICATION'", + "'REQUIRED'", "'RESETLOGS'", "'RESET'", "'RESIZE'", "'RESOLVE'", "'RESOLVER'", + "'RESOURCE'", "'RESPECT'", "'RESTART'", "'RESTORE_AS_INTERVALS'", "'RESTORE'", + "'RESTRICT_ALL_REF_CONS'", "'RESTRICTED'", "'RESTRICT_REFERENCES'", + "'RESTRICT'", "'RESULT_CACHE'", "'RESULT'", "'RESUMABLE'", "'RESUME'", + "'RETENTION'", "'RETRY_ON_ROW_CHANGE'", "'RETURNING'", "'RETURN'", "'REUSE'", + "'REVERSE'", "'REVOKE'", "'REWRITE_OR_ERROR'", "'REWRITE'", "'RIGHT'", + "'ROLE'", "'ROLESET'", "'ROLES'", "'ROLLBACK'", "'ROLLING'", "'ROLLUP'", + "'ROWDEPENDENCIES'", "'ROWID_MAPPING_TABLE'", "'ROWID'", "'ROWIDTOCHAR'", + "'ROWIDTONCHAR'", "'ROW_LENGTH'", "'ROWNUM'", "'ROW'", "'ROWS'", "'RPAD'", + "'RTRIM'", "'RULE'", "'RULES'", "'RUNNING'", "'SALT'", "'SAMPLE'", "'SAVE_AS_INTERVALS'", + "'SAVEPOINT'", "'SAVE'", "'SB4'", "'SCALE_ROWS'", "'SCALE'", "'SCAN_INSTANCES'", + "'SCAN'", "'SCHEDULER'", "'SCHEMACHECK'", "'SCHEMA'", "'SCN_ASCENDING'", + "'SCN'", "'SCOPE'", "'SCRUB'", "'SD_ALL'", "'SD_INHIBIT'", "'SDO_GEOM_MBR'", + "'SDO_GEOMETRY'", "'SD_SHOW'", "'SEARCH'", "'SECOND'", "'SECONDS'", + "'SECRET'", "'SECUREFILE_DBA'", "'SECUREFILE'", "'SECURITY'", "'SEED'", + "'SEG_BLOCK'", "'SEG_FILE'", "'SEGMENT'", "'SELECTIVITY'", "'SELECT'", + "'SELF'", "'SEMIJOIN_DRIVER'", "'SEMIJOIN'", "'SEMI_TO_INNER'", "'SEQUENCED'", + "'SEQUENCE'", "'SEQUENTIAL'", "'SERIALIZABLE'", "'SERIALLY_REUSABLE'", + "'SERIAL'", "'SERVERERROR'", "'SERVICE_NAME_CONVERT'", "'SERVICE'", + "'SERVICES'", "'SESSION_CACHED_CURSORS'", "'SESSION'", "'SESSIONS_PER_USER'", + "'SESSIONTIMEZONE'", "'SESSIONTZNAME'", "'SET'", "'SETS'", "'SETTINGS'", + "'SET_TO_JOIN'", "'SEVERE'", "'SHARDSPACE'", "'SHARED_POOL'", "'SHARED'", + "'SHARE'", "'SHARING'", "'SHELFLIFE'", "'SHOW'", "'SHRINK'", "'SHUTDOWN'", + "'SIBLINGS'", "'SID'", "'SITE'", "'SIGNAL_COMPONENT'", "'SIGNAL_FUNCTION'", + "'SIGN'", "'SIGNTYPE'", "'SIMPLE_INTEGER'", "'SIMPLE'", "'SINGLE'", + "'SINGLETASK'", "'SINH'", "'SIN'", "'SIZE'", "'SKIP_EXT_OPTIMIZER'", + "'SKIP'", "'SKIP_UNQ_UNUSABLE_IDX'", "'SKIP_UNUSABLE_INDEXES'", "'SMALLFILE'", + "'SMALLINT'", "'SNAPSHOT'", "'SOME'", "'SORT'", "'SOUNDEX'", "'SOURCE_FILE_DIRECTORY'", + "'SOURCE_FILE_NAME_CONVERT'", "'SOURCE'", "'SPACE'", "'SPECIFICATION'", + "'SPFILE'", "'SPLIT'", "'SPREADSHEET'", "'SQLDATA'", "'SQLERROR'", "'SQLLDR'", + "'SQL'", "'SQL_MACRO'", "'SQL_TRACE'", "'SQL_TRANSLATION_PROFILE'", + "'SQRT'", "'STALE'", "'STANDALONE'", "'STANDARD'", "'STANDARD_HASH'", + "'STANDBY_MAX_DATA_DELAY'", "'STANDBYS'", "'STANDBY'", "'STAR'", "'STAR_TRANSFORMATION'", + "'START'", "'STARTUP'", "'STATEMENT_ID'", "'STATEMENT_QUEUING'", "'STATEMENTS'", + "'STATEMENT'", "'STATE'", "'STATIC'", "'STATISTICS'", "'STATS_BINOMIAL_TEST'", + "'STATS_CROSSTAB'", "'STATS_F_TEST'", "'STATS_KS_TEST'", "'STATS_MODE'", + "'STATS_MW_TEST'", "'STATS_ONE_WAY_ANOVA'", "'STATS_T_TEST_INDEP'", + "'STATS_T_TEST_INDEPU'", "'STATS_T_TEST_ONE'", "'STATS_T_TEST_PAIRED'", + "'STATS_WSR_TEST'", "'STDDEV_POP'", "'STDDEV_SAMP'", "'STOP'", "'STORAGE'", + "'STORE'", "'STREAMS'", "'STREAM'", "'STRICT'", "'STRING'", "'STRIPE_COLUMNS'", + "'STRIPE_WIDTH'", "'STRIP'", "'STRUCTURE'", "'SUBMULTISET'", "'SUBPARTITION_REL'", + "'SUBPARTITIONS'", "'SUBPARTITION'", "'SUBQUERIES'", "'SUBQUERY_PRUNING'", + "'SUBSCRIBE'", "'SUBSET'", "'SUBSTITUTABLE'", "'SUBSTR2'", "'SUBSTR4'", + "'SUBSTRB'", "'SUBSTRC'", "'SUBTYPE'", "'SUCCESSFUL'", "'SUCCESS'", + "'SUMMARY'", "'SUPPLEMENTAL'", "'SUSPEND'", "'SWAP_JOIN_INPUTS'", "'SWITCHOVER'", + "'SWITCH'", "'SYNCHRONOUS'", "'SYNC'", "'SYNONYM'", "'SYS'", "'SYSASM'", + "'SYS_AUDIT'", "'SYSAUX'", "'SYSBACKUP'", "'SYS_CHECKACL'", "'SYS_CHECK_PRIVILEGE'", + "'SYS_CONNECT_BY_PATH'", "'SYS_CONTEXT'", "'SYSDATE'", "'SYSDBA'", "'SYS_DBURIGEN'", + "'SYSDG'", "'SYS_DL_CURSOR'", "'SYS_DM_RXFORM_CHR'", "'SYS_DM_RXFORM_NUM'", + "'SYS_DOM_COMPARE'", "'SYS_DST_PRIM2SEC'", "'SYS_DST_SEC2PRIM'", "'SYS_ET_BFILE_TO_RAW'", + "'SYS_ET_BLOB_TO_IMAGE'", "'SYS_ET_IMAGE_TO_BLOB'", "'SYS_ET_RAW_TO_BFILE'", + "'SYS_EXTPDTXT'", "'SYS_EXTRACT_UTC'", "'SYS_FBT_INSDEL'", "'SYS_FILTER_ACLS'", + "'SYS_FNMATCHES'", "'SYS_FNREPLACE'", "'SYS_GET_ACLIDS'", "'SYS_GET_COL_ACLIDS'", + "'SYS_GET_PRIVILEGES'", "'SYS_GETTOKENID'", "'SYS_GETXTIVAL'", "'SYS_GUID'", + "'SYSGUID'", "'SYSKM'", "'SYS_MAKE_XMLNODEID'", "'SYS_MAKEXML'", "'SYS_MKXMLATTR'", + "'SYS_MKXTI'", "'SYSOBJ'", "'SYS_OP_ADT2BIN'", "'SYS_OP_ADTCONS'", "'SYS_OP_ALSCRVAL'", + "'SYS_OP_ATG'", "'SYS_OP_BIN2ADT'", "'SYS_OP_BITVEC'", "'SYS_OP_BL2R'", + "'SYS_OP_BLOOM_FILTER_LIST'", "'SYS_OP_BLOOM_FILTER'", "'SYS_OP_C2C'", + "'SYS_OP_CAST'", "'SYS_OP_CEG'", "'SYS_OP_CL2C'", "'SYS_OP_COMBINED_HASH'", + "'SYS_OP_COMP'", "'SYS_OP_CONVERT'", "'SYS_OP_COUNTCHG'", "'SYS_OP_CSCONV'", + "'SYS_OP_CSCONVTEST'", "'SYS_OP_CSR'", "'SYS_OP_CSX_PATCH'", "'SYS_OP_CYCLED_SEQ'", + "'SYS_OP_DECOMP'", "'SYS_OP_DESCEND'", "'SYS_OP_DISTINCT'", "'SYS_OP_DRA'", + "'SYS_OP_DUMP'", "'SYS_OP_DV_CHECK'", "'SYS_OP_ENFORCE_NOT_NULL$'", + "'SYSOPER'", "'SYS_OP_EXTRACT'", "'SYS_OP_GROUPING'", "'SYS_OP_GUID'", + "'SYS_OP_HASH'", "'SYS_OP_IIX'", "'SYS_OP_ITR'", "'SYS_OP_KEY_VECTOR_CREATE'", + "'SYS_OP_KEY_VECTOR_FILTER_LIST'", "'SYS_OP_KEY_VECTOR_FILTER'", "'SYS_OP_KEY_VECTOR_SUCCEEDED'", + "'SYS_OP_KEY_VECTOR_USE'", "'SYS_OP_LBID'", "'SYS_OP_LOBLOC2BLOB'", + "'SYS_OP_LOBLOC2CLOB'", "'SYS_OP_LOBLOC2ID'", "'SYS_OP_LOBLOC2NCLOB'", + "'SYS_OP_LOBLOC2TYP'", "'SYS_OP_LSVI'", "'SYS_OP_LVL'", "'SYS_OP_MAKEOID'", + "'SYS_OP_MAP_NONNULL'", "'SYS_OP_MSR'", "'SYS_OP_NICOMBINE'", "'SYS_OP_NIEXTRACT'", + "'SYS_OP_NII'", "'SYS_OP_NIX'", "'SYS_OP_NOEXPAND'", "'SYS_OP_NTCIMG$'", + "'SYS_OP_NUMTORAW'", "'SYS_OP_OIDVALUE'", "'SYS_OP_OPNSIZE'", "'SYS_OP_PAR_1'", + "'SYS_OP_PARGID_1'", "'SYS_OP_PARGID'", "'SYS_OP_PAR'", "'SYS_OP_PART_ID'", + "'SYS_OP_PIVOT'", "'SYS_OP_R2O'", "'SYS_OP_RAWTONUM'", "'SYS_OP_RDTM'", + "'SYS_OP_REF'", "'SYS_OP_RMTD'", "'SYS_OP_ROWIDTOOBJ'", "'SYS_OP_RPB'", + "'SYS_OPTLOBPRBSC'", "'SYS_OP_TOSETID'", "'SYS_OP_TPR'", "'SYS_OP_TRTB'", + "'SYS_OPTXICMP'", "'SYS_OPTXQCASTASNQ'", "'SYS_OP_UNDESCEND'", "'SYS_OP_VECAND'", + "'SYS_OP_VECBIT'", "'SYS_OP_VECOR'", "'SYS_OP_VECXOR'", "'SYS_OP_VERSION'", + "'SYS_OP_VREF'", "'SYS_OP_VVD'", "'SYS_OP_XMLCONS_FOR_CSX'", "'SYS_OP_XPTHATG'", + "'SYS_OP_XPTHIDX'", "'SYS_OP_XPTHOP'", "'SYS_OP_XTXT2SQLT'", "'SYS_OP_ZONE_ID'", + "'SYS_ORDERKEY_DEPTH'", "'SYS_ORDERKEY_MAXCHILD'", "'SYS_ORDERKEY_PARENT'", + "'SYS_PARALLEL_TXN'", "'SYS_PATHID_IS_ATTR'", "'SYS_PATHID_IS_NMSPC'", + "'SYS_PATHID_LASTNAME'", "'SYS_PATHID_LASTNMSPC'", "'SYS_PATH_REVERSE'", + "'SYS_PXQEXTRACT'", "'SYS_RAW_TO_XSID'", "'SYS_RID_ORDER'", "'SYS_ROW_DELTA'", + "'SYS_SC_2_XMLT'", "'SYS_SYNRCIREDO'", "'SYSTEM_DEFINED'", "'SYSTEM'", + "'SYSTIMESTAMP'", "'SYS_TYPEID'", "'SYS_UMAKEXML'", "'SYS_XMLANALYZE'", + "'SYS_XMLCONTAINS'", "'SYS_XMLCONV'", "'SYS_XMLEXNSURI'", "'SYS_XMLGEN'", + "'SYS_XMLI_LOC_ISNODE'", "'SYS_XMLI_LOC_ISTEXT'", "'SYS_XMLINSTR'", + "'SYS_XMLLOCATOR_GETSVAL'", "'SYS_XMLNODEID_GETCID'", "'SYS_XMLNODEID_GETLOCATOR'", + "'SYS_XMLNODEID_GETOKEY'", "'SYS_XMLNODEID_GETPATHID'", "'SYS_XMLNODEID_GETPTRID'", + "'SYS_XMLNODEID_GETRID'", "'SYS_XMLNODEID_GETSVAL'", "'SYS_XMLNODEID_GETTID'", + "'SYS_XMLNODEID'", "'SYS_XMLT_2_SC'", "'SYS_XMLTRANSLATE'", "'SYS_XMLTYPE2SQL'", + "'SYS_XQ_ASQLCNV'", "'SYS_XQ_ATOMCNVCHK'", "'SYS_XQBASEURI'", "'SYS_XQCASTABLEERRH'", + "'SYS_XQCODEP2STR'", "'SYS_XQCODEPEQ'", "'SYS_XQCON2SEQ'", "'SYS_XQCONCAT'", + "'SYS_XQDELETE'", "'SYS_XQDFLTCOLATION'", "'SYS_XQDOC'", "'SYS_XQDOCURI'", + "'SYS_XQDURDIV'", "'SYS_XQED4URI'", "'SYS_XQENDSWITH'", "'SYS_XQERRH'", + "'SYS_XQERR'", "'SYS_XQESHTMLURI'", "'SYS_XQEXLOBVAL'", "'SYS_XQEXSTWRP'", + "'SYS_XQEXTRACT'", "'SYS_XQEXTRREF'", "'SYS_XQEXVAL'", "'SYS_XQFB2STR'", + "'SYS_XQFNBOOL'", "'SYS_XQFNCMP'", "'SYS_XQFNDATIM'", "'SYS_XQFNLNAME'", + "'SYS_XQFNNM'", "'SYS_XQFNNSURI'", "'SYS_XQFNPREDTRUTH'", "'SYS_XQFNQNM'", + "'SYS_XQFNROOT'", "'SYS_XQFORMATNUM'", "'SYS_XQFTCONTAIN'", "'SYS_XQFUNCR'", + "'SYS_XQGETCONTENT'", "'SYS_XQINDXOF'", "'SYS_XQINSERT'", "'SYS_XQINSPFX'", + "'SYS_XQIRI2URI'", "'SYS_XQLANG'", "'SYS_XQLLNMFRMQNM'", "'SYS_XQMKNODEREF'", + "'SYS_XQNILLED'", "'SYS_XQNODENAME'", "'SYS_XQNORMSPACE'", "'SYS_XQNORMUCODE'", + "'SYS_XQ_NRNG'", "'SYS_XQNSP4PFX'", "'SYS_XQNSPFRMQNM'", "'SYS_XQPFXFRMQNM'", + "'SYS_XQ_PKSQL2XML'", "'SYS_XQPOLYABS'", "'SYS_XQPOLYADD'", "'SYS_XQPOLYCEL'", + "'SYS_XQPOLYCSTBL'", "'SYS_XQPOLYCST'", "'SYS_XQPOLYDIV'", "'SYS_XQPOLYFLR'", + "'SYS_XQPOLYMOD'", "'SYS_XQPOLYMUL'", "'SYS_XQPOLYRND'", "'SYS_XQPOLYSQRT'", + "'SYS_XQPOLYSUB'", "'SYS_XQPOLYUMUS'", "'SYS_XQPOLYUPLS'", "'SYS_XQPOLYVEQ'", + "'SYS_XQPOLYVGE'", "'SYS_XQPOLYVGT'", "'SYS_XQPOLYVLE'", "'SYS_XQPOLYVLT'", + "'SYS_XQPOLYVNE'", "'SYS_XQREF2VAL'", "'SYS_XQRENAME'", "'SYS_XQREPLACE'", + "'SYS_XQRESVURI'", "'SYS_XQRNDHALF2EVN'", "'SYS_XQRSLVQNM'", "'SYS_XQRYENVPGET'", + "'SYS_XQRYVARGET'", "'SYS_XQRYWRP'", "'SYS_XQSEQ2CON4XC'", "'SYS_XQSEQ2CON'", + "'SYS_XQSEQDEEPEQ'", "'SYS_XQSEQINSB'", "'SYS_XQSEQRM'", "'SYS_XQSEQRVS'", + "'SYS_XQSEQSUB'", "'SYS_XQSEQTYPMATCH'", "'SYS_XQSTARTSWITH'", "'SYS_XQSTATBURI'", + "'SYS_XQSTR2CODEP'", "'SYS_XQSTRJOIN'", "'SYS_XQSUBSTRAFT'", "'SYS_XQSUBSTRBEF'", + "'SYS_XQTOKENIZE'", "'SYS_XQTREATAS'", "'SYS_XQ_UPKXML2SQL'", "'SYS_XQXFORM'", + "'SYS_XSID_TO_RAW'", "'SYS_ZMAP_FILTER'", "'SYS_ZMAP_REFRESH'", "'T'", + "'TABLE_LOOKUP_BY_NL'", "'TABLESPACE_NO'", "'TABLESPACE'", "'TABLES'", + "'TABLE_STATS'", "'TABLE'", "'TABNO'", "'TAG'", "'TANH'", "'TAN'", "'TBL$OR$IDX$PART$NUM'", + "'TEMPFILE'", "'TEMPLATE'", "'TEMPORARY'", "'TEMP_TABLE'", "'TEST'", + "'TEXT'", "'THAN'", "'THEN'", "'THE'", "'THREAD'", "'THROUGH'", "'TIER'", + "'TIES'", "'TIMEOUT'", "'TIMESTAMP_LTZ_UNCONSTRAINED'", "'TIMESTAMP'", + "'TIMESTAMP_TZ_UNCONSTRAINED'", "'TIMESTAMP_UNCONSTRAINED'", "'TIMES'", + "'TIME'", "'TIMEZONE'", "'TIMEZONE_ABBR'", "'TIMEZONE_HOUR'", "'TIMEZONE_MINUTE'", + "'TIMEZONE_OFFSET'", "'TIMEZONE_REGION'", "'TIME_ZONE'", "'TIMING'", + "'TIV_GB'", "'TIV_SSF'", "'TO_ACLID'", "'TO_BINARY_DOUBLE'", "'TO_BINARY_FLOAT'", + "'TO_BLOB'", "'TO_CLOB'", "'TO_DSINTERVAL'", "'TO_LOB'", "'TO_MULTI_BYTE'", + "'TO_NCHAR'", "'TO_NCLOB'", "'TO_NUMBER'", "'TOPLEVEL'", "'TO_SINGLE_BYTE'", + "'TO_TIMESTAMP'", "'TO_TIMESTAMP_TZ'", "'TO_TIME'", "'TO_TIME_TZ'", + "'TO'", "'TO_YMINTERVAL'", "'TRACE'", "'TRACING'", "'TRACKING'", "'TRAILING'", + "'TRANSACTION'", "'TRANSFORM'", "'TRANSFORM_DISTINCT_AGG'", "'TRANSITIONAL'", + "'TRANSITION'", "'TRANSLATE'", "'TRANSLATION'", "'TREAT'", "'TRIGGERS'", + "'TRIGGER'", "'TRUE'", "'TRUNCATE'", "'TRUNC'", "'TRUSTED'", "'TRUST'", + "'TUNING'", "'TX'", "'TYPES'", "'TYPE'", "'TZ_OFFSET'", "'UB2'", "'UBA'", + "'UCS2'", "'UID'", "'UNARCHIVED'", "'UNBOUNDED'", "'UNBOUND'", "'UNCONDITIONAL'", + "'UNDER'", "'UNDO'", "'UNDROP'", "'UNIFORM'", "'UNION'", "'UNIQUE'", + "'UNISTR'", "'UNLIMITED'", "'UNLOAD'", "'UNLOCK'", "'UNMATCHED'", "'UNNEST_INNERJ_DISTINCT_VIEW'", + "'UNNEST_NOSEMIJ_NODISTINCTVIEW'", "'UNNEST_SEMIJ_VIEW'", "'UNNEST'", + "'UNPACKED'", "'UNPIVOT'", "'UNPLUG'", "'UNPROTECTED'", "'UNQUIESCE'", + "'UNRECOVERABLE'", "'UNRESTRICTED'", "'UNSUBSCRIBE'", "'UNTIL'", "'UNUSABLE'", + "'UNUSED'", "'UPDATABLE'", "'UPDATED'", "'UPDATE'", "'UPDATEXML'", "'UPD_INDEXES'", + "'UPD_JOININDEX'", "'UPGRADE'", "'UPPER'", "'UPSERT'", "'UROWID'", "'USABLE'", + "'USAGE'", "'USE_ANTI'", "'USE_CONCAT'", "'USE_CUBE'", "'USE_HASH_AGGREGATION'", + "'USE_HASH_GBY_FOR_PUSHDOWN'", "'USE_HASH'", "'USE_HIDDEN_PARTITIONS'", + "'USE_INVISIBLE_INDEXES'", "'USE_MERGE_CARTESIAN'", "'USE_MERGE'", "'USE_NL'", + "'USE_NL_WITH_INDEX'", "'USE_PRIVATE_OUTLINES'", "'USER_DATA'", "'USER_DEFINED'", + "'USERENV'", "'USERGROUP'", "'USER_RECYCLEBIN'", "'USERS'", "'USER_TABLESPACES'", + "'USER'", "'USE_SEMI'", "'USE_STORED_OUTLINES'", "'USE_TTT_FOR_GSETS'", + "'USE'", "'USE_VECTOR_AGGREGATION'", "'USE_WEAK_NAME_RESL'", "'USING_NO_EXPAND'", + "'USING'", "'UTF16BE'", "'UTF16LE'", "'UTF32'", "'UTF8'", "'V1'", "'V2'", + "'VALIDATE'", "'VALIDATE_CONVERSION'", "'VALIDATION'", "'VALID_TIME_END'", + "'VALUES'", "'VALUE'", "'VARCHAR2'", "'VARCHAR'", "'VARIABLE'", "'VAR_POP'", + "'VARRAYS'", "'VARRAY'", "'VAR_SAMP'", "'VARYING'", "'VECTOR_READ_TRACE'", + "'VECTOR_READ'", "'VECTOR_TRANSFORM_DIMS'", "'VECTOR_TRANSFORM_FACT'", + "'VECTOR_TRANSFORM'", "'VERIFIER'", "'VERIFY'", "'VERSIONING'", "'VERSIONS_ENDSCN'", + "'VERSIONS_ENDTIME'", "'VERSIONS_OPERATION'", "'VERSIONS_STARTSCN'", + "'VERSIONS_STARTTIME'", "'VERSIONS'", "'VERSIONS_XID'", "'VERSION'", + "'VIEW'", "'VIOLATION'", "'VIRTUAL'", "'VISIBILITY'", "'VISIBLE'", "'VOLUME'", + "'VSIZE'", "'WAIT'", "'WALLET'", "'WARNING'", "'WEEKS'", "'WEEK'", "'WELLFORMED'", + "'WHENEVER'", "'WHEN'", "'WHERE'", "'WHILE'", "'WHITESPACE'", "'WIDTH_BUCKET'", + "'WITHIN'", "'WITHOUT'", "'WITH_PLSQL'", "'WITH'", "'WORK'", "'WRAPPED'", + "'WRAPPER'", "'WRITE'", "'XDB_FASTPATH_INSERT'", "'XDB'", "'X_DYN_PRUNE'", + "'XID'", "'XML2OBJECT'", "'XMLAGG'", "'XMLATTRIBUTES'", "'XMLCAST'", + "'XMLCDATA'", "'XMLCOLATTVAL'", "'XMLCOMMENT'", "'XMLCONCAT'", "'XMLDIFF'", + "'XML_DML_RWT_STMT'", "'XMLELEMENT'", "'XMLEXISTS2'", "'XMLEXISTS'", + "'XMLFOREST'", "'XMLINDEX'", "'XMLINDEX_REWRITE_IN_SELECT'", "'XMLINDEX_REWRITE'", + "'XMLINDEX_SEL_IDX_TBL'", "'XMLISNODE'", "'XMLISVALID'", "'XMLNAMESPACES'", + "'XMLPARSE'", "'XMLPATCH'", "'XMLPI'", "'XMLQUERYVAL'", "'XMLQUERY'", + "'XMLROOT'", "'XMLSCHEMA'", "'XMLSERIALIZE'", "'XMLTABLE'", "'XMLTRANSFORMBLOB'", + "'XMLTRANSFORM'", "'XMLTYPE'", "'XML'", "'XPATHTABLE'", "'XS_SYS_CONTEXT'", + "'XS'", "'YEARS'", "'YEAR'", "'YES'", "'YMINTERVAL_UNCONSTRAINED'", + "'ZONEMAP'", "'ZONE'", "'PREDICTION'", "'PREDICTION_BOUNDS'", "'PREDICTION_COST'", + "'PREDICTION_DETAILS'", "'PREDICTION_PROBABILITY'", "'PREDICTION_SET'", + "'BLOCKCHAIN'", "'COLLATE'", "'COLLATION'", "'DEFINITION'", "'DUPLICATED'", + "'EXTENDED'", "'HASHING'", "'IDLE'", "'IMMUTABLE'", "'ORACLE_DATAPUMP'", + "'ORACLE_HDFS'", "'ORACLE_HIVE'", "'ORACLE_LOADER'", "'\"SHA2_512\"'", + "'SHARDED'", "'\"V1\"'", "'ISOLATE'", "'ROOT'", "'UNITE'", "'ALGORITHM'", + "'CUME_DIST'", "'DENSE_RANK'", "'LISTAGG'", "'PERCENT_RANK'", "'PERCENTILE_CONT'", + "'PERCENTILE_DISC'", "'RANK'", "'AVG'", "'CORR'", "'COVAR_'", "'DECODE'", + "'LAG'", "'LAG_DIFF'", "'LAG_DIFF_PERCENT'", "'LEAD'", "'MAX'", "'MEDIAN'", + "'MEMOPTIMIZE'", "'MIN'", "'NTILE'", "'NVL'", "'RATIO_TO_REPORT'", "'REGR_'", + "'ROUND'", "'ROW_NUMBER'", "'SUBSTR'", "'TO_CHAR'", "'TRIM'", "'SUM'", + "'STDDEV'", "'VAR_'", "'VARIANCE'", "'LEAST'", "'GREATEST'", "'TO_DATE'", + "'DEFAULTIF'", "'LLS'", "'ENCLOSED'", "'TERMINATED'", "'OPTIONALLY'", + "'LRTRIM'", "'NOTRIM'", "'LDRTRIM'", "'DATE_FORMAT'", "'MASK'", "'TRANSFORMS'", + "'LOBFILE'", "'STARTOF'", "'CHARACTERSET'", "'RECORDS'", "'FIXED'", + "'DELIMITED'", "'XMLTAG'", "'PREPROCESSOR'", "'TERRITORY'", "'LITTLE'", + "'BIG'", "'ENDIAN'", "'BYTEORDERMARK'", "'NOCHECK'", "'SIZES'", "'ARE'", + "'BYTES'", "'CHARACTERS'", "'READSIZE'", "'DISABLE_DIRECTORY_LINK_CHECK'", + "'DATE_CACHE'", "'FIELD_NAMES'", "'FILES'", "'IO_OPTIONS'", "'DIRECTIO'", + "'NODIRECTIO'", "'DNFS_ENABLE'", "'DNFS_DISABLE'", "'DNFS_READBUFFERS'", + "'NOBADFILE'", "'BADFILE'", "'NODISCARDFILE'", "'DISCARDFILE'", "'NOLOGFILE'", + "'FIELDS'", "'IGNORE_CHARS_AFTER_EOR'", "'CSV'", "'EMBEDDED'", "'OVERRIDE'", + "'THESE'", "'FIELD'", "'NONULLIF'", "'POSITION'", "'NEWLINE'", "'DETECTED'", + "'UNSIGNED'", "'ZONED'", "'ORACLE_DATE'", "'ORACLE_NUMBER'", "'COUNTED'", + "'VARRAW'", "'VARCHARC'", "'VARRAWC'", "", "", "", "'..'", "'.'", "", + "", "", "", "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", + "','", "'/'", "'@'", "':='", "'#'", "'''", "", "", "'^'", "'~'", "'!'", + "'>'", "'<'", "':'", "';'", "'|'", "'='", "'['", "']'", "'_'", + } + staticData.SymbolicNames = []string{ + "", "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCOUNT", "ACL", + "ACOS", "ACROSS", "ACTION", "ACTIONS", "ACTIVATE", "ACTIVE", "ACTIVE_COMPONENT", + "ACTIVE_DATA", "ACTIVE_FUNCTION", "ACTIVE_TAG", "ACTIVITY", "ADAPTIVE_PLAN", + "ADD", "ADD_COLUMN", "ADD_GROUP", "ADD_MONTHS", "ADJ_DATE", "ADMIN", + "ADMINISTER", "ADMINISTRATOR", "ADVANCED", "ADVISE", "ADVISOR", "AFD_DISKSTRING", + "AFTER", "AGENT", "AGGREGATE", "A_LETTER", "ALIAS", "ALL", "ALLOCATE", + "ALLOW", "ALL_ROWS", "ALTER", "ALTERNATE", "ALWAYS", "ANALYTIC", "ANALYZE", + "ANCESTOR", "ANCILLARY", "AND", "AND_EQUAL", "ANOMALY", "ANSI_REARCH", + "ANTIJOIN", "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", + "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", + "ARCHIVED", "ARCHIVELOG", "ARRAY", "AS", "ASC", "ASCII", "ASCIISTR", + "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", "ASYNCHRONOUS", + "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", "AUDIT", "AUTHENTICATED", + "AUTHENTICATION", "AUTHID", "AUTHORIZATION", "AUTOALLOCATE", "AUTO", + "AUTOEXTEND", "AUTO_LOGIN", "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", + "AVAILABILITY", "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", + "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", + "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", "BEHALF", + "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIGFILE", "BINARY", "BINARY_DOUBLE", + "BINARY_DOUBLE_INFINITY", "BINARY_DOUBLE_NAN", "BINARY_FLOAT", "BINARY_FLOAT_INFINITY", + "BINARY_FLOAT_NAN", "BINARY_INTEGER", "BIND_AWARE", "BINDING", "BIN_TO_NUM", + "BITAND", "BITMAP_AND", "BITMAP", "BITMAPS", "BITMAP_TREE", "BITS", + "BLOB", "BLOCK", "BLOCK_RANGE", "BLOCKS", "BLOCKSIZE", "BODY", "BOOLEAN", + "BOTH", "BOUND", "BRANCH", "BREADTH", "BROADCAST", "BSON", "BUFFER", + "BUFFER_CACHE", "BUFFER_POOL", "BUILD", "BULK", "BY", "BYPASS_RECURSIVE_CHECK", + "BYPASS_UJVC", "BYTE", "CACHE", "CACHE_CB", "CACHE_INSTANCES", "CACHE_TEMP_TABLE", + "CACHING", "CALCULATED", "CALLBACK", "CALL", "CANCEL", "CANONICAL", + "CAPACITY", "CAPTION", "CARDINALITY", "CASCADE", "CASE", "CAST", "CASESENSITIVE", + "CATEGORY", "CDBDEFAULT", "CEIL", "CELL_FLASH_CACHE", "CERTIFICATE", + "CFILE", "CHAINED", "CHANGE", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", + "CHAR", "CHAR_CS", "CHARTOROWID", "CHECK_ACL_REWRITE", "CHECK", "CHECKPOINT", + "CHILD", "CHOOSE", "CHR", "CHUNK", "CLASS", "CLASSIFICATION", "CLASSIFIER", + "CLAUSE", "CLEAN", "CLEANUP", "CLEAR", "C_LETTER", "CLIENT", "CLOB", + "CLONE", "CLOSE_CACHED_OPEN_CURSORS", "CLOSE", "CLUSTER_BY_ROWID", "CLUSTER", + "CLUSTER_DETAILS", "CLUSTER_DISTANCE", "CLUSTER_ID", "CLUSTERING", "CLUSTERING_FACTOR", + "CLUSTER_PROBABILITY", "CLUSTER_SET", "COALESCE", "COALESCE_SQ", "COARSE", + "CO_AUTH_IND", "COLD", "COLLECT", "COLUMNAR", "COLUMN_AUTH_INDICATOR", + "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", "COMMIT", + "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBILITY", "COMPILE", + "COMPLETE", "COMPLIANCE", "COMPONENT", "COMPONENTS", "COMPOSE", "COMPOSITE", + "COMPOSITE_LIMIT", "COMPOUND", "COMPRESS", "COMPUTE", "CONCAT", "CON_DBID_TO_ID", + "CONDITIONAL", "CONDITION", "CONFIRM", "CONFORMING", "CON_GUID_TO_ID", + "CON_ID", "CON_NAME_TO_ID", "CONNECT_BY_CB_WHR_ONLY", "CONNECT_BY_COMBINE_SW", + "CONNECT_BY_COST_BASED", "CONNECT_BY_ELIM_DUPS", "CONNECT_BY_FILTERING", + "CONNECT_BY_ISCYCLE", "CONNECT_BY_ISLEAF", "CONNECT_BY_ROOT", "CONNECT", + "CONNECT_TIME", "CONSIDER", "CONSISTENT", "CONSTANT", "CONST", "CONSTRAINT", + "CONSTRAINTS", "CONSTRUCTOR", "CONTAINER", "CONTAINERS", "CONTAINERS_DEFAULT", + "CONTAINER_DATA", "CONTAINER_MAP", "CONTENT", "CONTENTS", "CONTEXT", + "CONTINUE", "CONTROLFILE", "CON_UID_TO_ID", "CONVERT", "CONVERSION", + "COOKIE", "COPY", "CORR_K", "CORR_S", "CORRUPTION", "CORRUPT_XID_ALL", + "CORRUPT_XID", "COS", "COSH", "COST", "COST_XML_QUERY_REWRITE", "COUNT", + "COVAR_POP", "COVAR_SAMP", "CPU_COSTING", "CPU_PER_CALL", "CPU_PER_SESSION", + "CRASH", "CREATE", "CREATE_FILE_DEST", "CREATE_STORED_OUTLINES", "CREATION", + "CREDENTIAL", "CRITICAL", "CROSS", "CROSSEDITION", "CSCONVERT", "CUBE_AJ", + "CUBE", "CUBE_GB", "CUBE_SJ", "CUME_DISTM", "CURRENT", "CURRENT_DATE", + "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "CURRENTV", "CURSOR", "CURSOR_SHARING_EXACT", "CURSOR_SPECIFIC_SEGMENT", + "CUSTOMDATUM", "CV", "CYCLE", "DANGLING", "DATABASE", "DATA", "DATAFILE", + "DATAFILES", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", + "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", "DATE", + "DATE_MODE", "DAY", "DAYS", "DBA", "DBA_RECYCLEBIN", "DBMS_STATS", "DB_ROLE_CHANGE", + "DBTIMEZONE", "DB_UNIQUE_NAME", "DB_VERSION", "DDL", "DEALLOCATE", "DEBUG", + "DEBUGGER", "DEC", "DECIMAL", "DECLARE", "DECOMPOSE", "DECORRELATE", + "DECR", "DECREMENT", "DECRYPT", "DEDUPLICATE", "DEFAULT", "DEFAULTS", + "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", "DEFERRABLE", "DEFERRED", + "DEFINED", "DEFINE", "DEFINER", "DEGREE", "DELAY", "DELEGATE", "DELETE_ALL", + "DELETE", "DELETEXML", "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPTH", + "DEQUEUE", "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", + "DETACHED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", + "DIMENSIONS", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", "DISABLE_ALL", + "DISABLE", "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", + "DISALLOW", "DISASSOCIATE", "DISCARD", "DISCONNECT", "DISK", "DISKGROUP", + "DISKS", "DISMOUNT", "DISTINCT", "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", + "DML", "DML_UPDATE", "DOCFIDELITY", "DOCUMENT", "DOMAIN_INDEX_FILTER", + "DOMAIN_INDEX_NO_SORT", "DOMAIN_INDEX_SORT", "DOUBLE", "DOWNGRADE", + "DRIVING_SITE", "DROP_COLUMN", "DROP", "DROP_GROUP", "DSINTERVAL_UNCONSTRAINED", + "DST_UPGRADE_INSERT_CONV", "DUMP", "DUPLICATE", "DV", "DYNAMIC", "DYNAMIC_SAMPLING", + "DYNAMIC_SAMPLING_EST_CDN", "E_LETTER", "EACH", "EDITIONABLE", "EDITION", + "EDITIONING", "EDITIONS", "ELEMENT", "ELIM_GROUPBY", "ELIMINATE_JOIN", + "ELIMINATE_OBY", "ELIMINATE_OUTER_JOIN", "ELSE", "ELSIF", "EM", "EMPTY_BLOB", + "EMPTY_CLOB", "EMPTY", "ENABLE_ALL", "ENABLE", "ENABLE_PARALLEL_DML", + "ENABLE_PRESET", "ENCODING", "ENCRYPT", "ENCRYPTION", "END", "END_OUTLINE_DATA", + "ENFORCED", "ENFORCE", "ENQUEUE", "ENTERPRISE", "ENTITYESCAPING", "ENTRY", + "EQUIPART", "ERR", "ERROR_ARGUMENT", "ERROR", "ERROR_ON_OVERLAP_TIME", + "ERRORS", "ESCAPE", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", "EVALUATION", + "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", "EXCEPTIONS", + "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXEMPT", + "EXISTING", "EXISTS", "EXISTSNODE", "EXIT", "EXPAND_GSET_TO_UNION", + "EXPAND_TABLE", "EXP", "EXPIRE", "EXPLAIN", "EXPLOSION", "EXPORT", "EXPR_CORR_CHECK", + "EXPRESS", "EXTENDS", "EXTENT", "EXTENTS", "EXTERNAL", "EXTERNALLY", + "EXTRACTCLOBXML", "EXTRACT", "EXTRACTVALUE", "EXTRA", "FACILITY", "FACT", + "FACTOR", "FACTORIZE_JOIN", "FAILED", "FAILED_LOGIN_ATTEMPTS", "FAILGROUP", + "FAILOVER", "FAILURE", "FALSE", "FAMILY", "FAR", "FAST", "FASTSTART", + "FBTSCAN", "FEATURE", "FEATURE_DETAILS", "FEATURE_ID", "FEATURE_SET", + "FEATURE_VALUE", "FETCH", "FILE", "FILE_NAME_CONVERT", "FILEGROUP", + "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", "FINE", "FINISH", + "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", "FIXED_VIEW_DATA", "FLAGGER", + "FLASHBACK", "FLASH_CACHE", "FLOAT", "FLOB", "FLEX", "FLOOR", "FLUSH", + "FOLDER", "FOLLOWING", "FOLLOWS", "FORALL", "FORCE", "FORCE_XML_QUERY_REWRITE", + "FOREIGN", "FOREVER", "FOR", "FORMAT", "FORWARD", "FRAGMENT_NUMBER", + "FREELIST", "FREELISTS", "FREEPOOLS", "FRESH", "FROM", "FROM_TZ", "FULL", + "FULL_OUTER_JOIN_TO_OUTER", "FUNCTION", "FUNCTIONS", "FTP", "G_LETTER", + "GATHER_OPTIMIZER_STATISTICS", "GATHER_PLAN_STATISTICS", "GBY_CONC_ROLLUP", + "GBY_PUSHDOWN", "GENERATED", "GET", "GLOBAL", "GLOBALLY", "GLOBAL_NAME", + "GLOBAL_TOPIC_ENABLED", "GOTO", "GRANT", "GROUP_BY", "GROUP", "GROUP_ID", + "GROUPING", "GROUPING_ID", "GROUPS", "GUARANTEED", "GUARANTEE", "GUARD", + "HALF_YEARS", "HASH_AJ", "HASH", "HASHKEYS", "HASH_SJ", "HAVING", "HEADER", + "HEAP", "HELP", "HEXTORAW", "HEXTOREF", "HIDDEN_KEYWORD", "HIDE", "HIER_ORDER", + "HIERARCHICAL", "HIERARCHIES", "HIERARCHY", "HIGH", "HINTSET_BEGIN", + "HINTSET_END", "HOT", "HOUR", "HOURS", "HTTP", "HWM_BROKERED", "HYBRID", + "H_LETTER", "IDENTIFIED", "IDENTIFIER", "IDENTITY", "IDGENERATORS", + "ID", "IDLE_TIME", "IF", "IGNORE", "IGNORE_OPTIM_EMBEDDED_HINTS", "IGNORE_ROW_ON_DUPKEY_INDEX", + "IGNORE_WHERE_CLAUSE", "ILM", "IMMEDIATE", "IMPACT", "IMPORT", "INACTIVE", + "INACTIVE_ACCOUNT_TIME", "INCLUDE", "INCLUDE_VERSION", "INCLUDING", + "INCREMENTAL", "INCREMENT", "INCR", "INDENT", "INDEX_ASC", "INDEX_COMBINE", + "INDEX_DESC", "INDEXED", "INDEXES", "INDEX_FFS", "INDEX_FILTER", "INDEX", + "INDEXING", "INDEX_JOIN", "INDEX_ROWS", "INDEX_RRS", "INDEX_RS_ASC", + "INDEX_RS_DESC", "INDEX_RS", "INDEX_SCAN", "INDEX_SKIP_SCAN", "INDEX_SS_ASC", + "INDEX_SS_DESC", "INDEX_SS", "INDEX_STATS", "INDEXTYPE", "INDEXTYPES", + "INDICATOR", "INDICES", "INFINITE", "INFORMATIONAL", "INHERIT", "IN", + "INITCAP", "INITIAL", "INITIALIZED", "INITIALLY", "INITRANS", "INLINE", + "INLINE_XMLTYPE_NT", "INMEMORY", "IN_MEMORY_METADATA", "INMEMORY_PRUNING", + "INNER", "INOUT", "INPLACE", "INSERTCHILDXMLAFTER", "INSERTCHILDXMLBEFORE", + "INSERTCHILDXML", "INSERT", "INSERTXMLAFTER", "INSERTXMLBEFORE", "INSTANCE", + "INSTANCES", "INSTANTIABLE", "INSTANTLY", "INSTEAD", "INSTR2", "INSTR4", + "INSTRB", "INSTRC", "INSTR", "INTEGER", "INTERLEAVED", "INTERMEDIATE", + "INTERNAL_CONVERT", "INTERNAL_USE", "INTERPRETED", "INTERSECT", "INTERVAL", + "INT", "INTO", "INVALIDATE", "INVISIBLE", "IN_XQUERY", "IS", "IS_LEAF", + "ISOLATION", "ISOLATION_LEVEL", "ITERATE", "ITERATION_NUMBER", "JAVA", + "JOB", "JOIN", "JSON_ARRAYAGG", "JSON_ARRAY", "JSON_EQUAL", "JSON_EXISTS2", + "JSON_EXISTS", "JSONGET", "JSON", "JSON_OBJECTAGG", "JSON_OBJECT", "JSONPARSE", + "JSON_QUERY", "JSON_SERIALIZE", "JSON_TABLE", "JSON_TEXTCONTAINS2", + "JSON_TEXTCONTAINS", "JSON_TRANSFORM", "JSON_VALUE", "K_LETTER", "KEEP_DUPLICATES", + "KEEP", "KERBEROS", "KEY", "KEY_LENGTH", "KEYSIZE", "KEYS", "KEYSTORE", + "KILL", "LABEL", "LANGUAGE", "LAST_DAY", "LAST", "LAST_VALUE", "LATERAL", + "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", + "LEAF", "LEAD_CDB", "LEAD_CDB_URI", "LEADING", "LEFT", "LENGTH2", "LENGTH4", + "LENGTHB", "LENGTHC", "LENGTH", "LESS", "LEVEL", "LEVEL_NAME", "LEVELS", + "LIBRARY", "LIFECYCLE", "LIFE", "LIFETIME", "LIKE2", "LIKE4", "LIKEC", + "LIKE_EXPAND", "LIKE", "LIMIT", "LINEAR", "LINK", "LIST", "LN", "LNNVL", + "LOAD", "LOB", "LOBNVL", "LOBS", "LOCAL_INDEXES", "LOCAL", "LOCALTIME", + "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCKDOWN", "LOCKED", "LOCKING", + "LOCK", "LOGFILE", "LOGFILES", "LOGGING", "LOGICAL", "LOGICAL_READS_PER_CALL", + "LOGICAL_READS_PER_SESSION", "LOG", "LOGMINING", "LOGOFF", "LOGON", + "LOG_READ_ONLY_VIOLATIONS", "LONG", "LOOP", "LOST", "LOWER", "LOW", + "LPAD", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", "MANAGE", + "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", "MAPPING", "MASTER", + "MATCHED", "MATCHES", "MATCH", "MATCH_NUMBER", "MATCH_RECOGNIZE", "MATERIALIZED", + "MATERIALIZE", "MAXARCHLOGS", "MAXDATAFILES", "MAXEXTENTS", "MAXIMIZE", + "MAXINSTANCES", "MAXLOGFILES", "MAXLOGHISTORY", "MAXLOGMEMBERS", "MAX_SHARED_TEMP_SIZE", + "MAXSIZE", "MAXTRANS", "MAXVALUE", "MEASURE", "MEASURES", "MEDIUM", + "MEMBER", "MEMBER_CAPTION", "MEMBER_DESCRIPTION", "MEMBER_NAME", "MEMBER_UNIQUE_NAME", + "MEMCOMPRESS", "MEMORY", "MERGEACTIONS", "MERGE_AJ", "MERGE_CONST_ON", + "MERGE", "MERGE_SJ", "METADATA", "METHOD", "MIGRATE", "MIGRATION", "MINEXTENTS", + "MINIMIZE", "MINIMUM", "MINING", "MINUS", "MINUS_NULL", "MINUTE", "MINUTES", + "MINVALUE", "MIRRORCOLD", "MIRRORHOT", "MIRROR", "MISSING", "MISMATCH", + "MLSLABEL", "MODEL_COMPILE_SUBQUERY", "MODEL_DONTVERIFY_UNIQUENESS", + "MODEL_DYNAMIC_SUBQUERY", "MODEL_MIN_ANALYSIS", "MODEL", "MODEL_NB", + "MODEL_NO_ANALYSIS", "MODEL_PBY", "MODEL_PUSH_REF", "MODEL_SV", "MODE", + "MODIFICATION", "MODIFY_COLUMN_TYPE", "MODIFY", "MOD", "MODULE", "MONITORING", + "MONITOR", "MONTH", "MONTHS_BETWEEN", "MONTHS", "MOUNT", "MOUNTPATH", + "MOUNTPOINT", "MOVEMENT", "MOVE", "MULTIDIMENSIONAL", "MULTISET", "MV_MERGE", + "NAMED", "NAME", "NAMESPACE", "NAN", "NANVL", "NATIONAL", "NATIVE_FULL_OUTER_JOIN", + "NATIVE", "NATURAL", "NATURALN", "NAV", "NCHAR_CS", "NCHAR", "NCHR", + "NCLOB", "NEEDED", "NEG", "NESTED", "NESTED_TABLE_FAST_INSERT", "NESTED_TABLE_GET_REFS", + "NESTED_TABLE_ID", "NESTED_TABLE_SET_REFS", "NESTED_TABLE_SET_SETID", + "NETWORK", "NEVER", "NEW", "NEW_TIME", "NEXT_DAY", "NEXT", "NL_AJ", + "NLJ_BATCHING", "NLJ_INDEX_FILTER", "NLJ_INDEX_SCAN", "NLJ_PREFETCH", + "NLS_CALENDAR", "NLS_CHARACTERSET", "NLS_CHARSET_DECL_LEN", "NLS_CHARSET_ID", + "NLS_CHARSET_NAME", "NLS_COMP", "NLS_CURRENCY", "NLS_DATE_FORMAT", "NLS_DATE_LANGUAGE", + "NLS_INITCAP", "NLS_ISO_CURRENCY", "NL_SJ", "NLS_LANG", "NLS_LANGUAGE", + "NLS_LENGTH_SEMANTICS", "NLS_LOWER", "NLS_NCHAR_CONV_EXCP", "NLS_NUMERIC_CHARACTERS", + "NLS_SORT", "NLSSORT", "NLS_SPECIAL_CHARS", "NLS_TERRITORY", "NLS_UPPER", + "NO_ACCESS", "NO_ADAPTIVE_PLAN", "NO_ANSI_REARCH", "NOAPPEND", "NOARCHIVELOG", + "NOAUDIT", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", "NO_BATCH_TABLE_ACCESS_BY_ROWID", + "NO_BIND_AWARE", "NO_BUFFER", "NOCACHE", "NO_CARTESIAN", "NO_CHECK_ACL_REWRITE", + "NO_CLUSTER_BY_ROWID", "NO_CLUSTERING", "NO_COALESCE_SQ", "NO_COMMON_DATA", + "NOCOMPRESS", "NO_CONNECT_BY_CB_WHR_ONLY", "NO_CONNECT_BY_COMBINE_SW", + "NO_CONNECT_BY_COST_BASED", "NO_CONNECT_BY_ELIM_DUPS", "NO_CONNECT_BY_FILTERING", + "NOCOPY", "NO_COST_XML_QUERY_REWRITE", "NO_CPU_COSTING", "NOCPU_COSTING", + "NOCYCLE", "NO_DATA_SECURITY_REWRITE", "NO_DECORRELATE", "NODELAY", + "NO_DOMAIN_INDEX_FILTER", "NO_DST_UPGRADE_INSERT_CONV", "NO_ELIM_GROUPBY", + "NO_ELIMINATE_JOIN", "NO_ELIMINATE_OBY", "NO_ELIMINATE_OUTER_JOIN", + "NOENTITYESCAPING", "NO_EXPAND_GSET_TO_UNION", "NO_EXPAND", "NO_EXPAND_TABLE", + "NO_FACT", "NO_FACTORIZE_JOIN", "NO_FILTERING", "NOFORCE", "NO_FULL_OUTER_JOIN_TO_OUTER", + "NO_GATHER_OPTIMIZER_STATISTICS", "NO_GBY_PUSHDOWN", "NOGUARANTEE", + "NO_INDEX_FFS", "NO_INDEX", "NO_INDEX_SS", "NO_INMEMORY", "NO_INMEMORY_PRUNING", + "NOKEEP", "NO_LOAD", "NOLOCAL", "NOLOGGING", "NOMAPPING", "NOMAXVALUE", + "NO_MERGE", "NOMINIMIZE", "NOMINVALUE", "NO_MODEL_PUSH_REF", "NO_MONITORING", + "NOMONITORING", "NO_MONITOR", "NO_MULTIMV_REWRITE", "NO_NATIVE_FULL_OUTER_JOIN", + "NONBLOCKING", "NONEDITIONABLE", "NONE", "NO_NLJ_BATCHING", "NO_NLJ_PREFETCH", + "NO", "NONSCHEMA", "NO_OBJECT_LINK", "NOORDER", "NO_ORDER_ROLLUPS", + "NO_OUTER_JOIN_TO_ANTI", "NO_OUTER_JOIN_TO_INNER", "NOOVERRIDE", "NO_PARALLEL_INDEX", + "NOPARALLEL_INDEX", "NO_PARALLEL", "NOPARALLEL", "NO_PARTIAL_COMMIT", + "NO_PARTIAL_JOIN", "NO_PARTIAL_ROLLUP_PUSHDOWN", "NOPARTITION", "NO_PLACE_DISTINCT", + "NO_PLACE_GROUP_BY", "NO_PQ_CONCURRENT_UNION", "NO_PQ_MAP", "NOPROMPT", + "NO_PQ_REPLICATE", "NO_PQ_SKEW", "NO_PRUNE_GSETS", "NO_PULL_PRED", "NO_PUSH_PRED", + "NO_PUSH_SUBQ", "NO_PX_FAULT_TOLERANCE", "NO_PX_JOIN_FILTER", "NO_QKN_BUFF", + "NO_QUERY_TRANSFORMATION", "NO_REF_CASCADE", "NORELOCATE", "NORELY", + "NOREPAIR", "NOREPLAY", "NORESETLOGS", "NO_RESULT_CACHE", "NOREVERSE", + "NO_REWRITE", "NOREWRITE", "NORMAL", "NO_ROOT_SW_FOR_LOCAL", "NOROWDEPENDENCIES", + "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", + "NOSORT", "NO_SQL_TRANSLATION", "NO_SQL_TUNE", "NO_STAR_TRANSFORMATION", + "NO_STATEMENT_QUEUING", "NO_STATS_GSETS", "NOSTRICT", "NO_SUBQUERY_PRUNING", + "NO_SUBSTRB_PAD", "NO_SWAP_JOIN_INPUTS", "NOSWITCH", "NO_TABLE_LOOKUP_BY_NL", + "NO_TEMP_TABLE", "NOTHING", "NOTIFICATION", "NOT", "NO_TRANSFORM_DISTINCT_AGG", + "NO_UNNEST", "NO_USE_CUBE", "NO_USE_HASH_AGGREGATION", "NO_USE_HASH_GBY_FOR_PUSHDOWN", + "NO_USE_HASH", "NO_USE_INVISIBLE_INDEXES", "NO_USE_MERGE", "NO_USE_NL", + "NO_USE_VECTOR_AGGREGATION", "NOVALIDATE", "NO_VECTOR_TRANSFORM_DIMS", + "NO_VECTOR_TRANSFORM_FACT", "NO_VECTOR_TRANSFORM", "NOWAIT", "NO_XDB_FASTPATH_INSERT", + "NO_XML_DML_REWRITE", "NO_XMLINDEX_REWRITE_IN_SELECT", "NO_XMLINDEX_REWRITE", + "NO_XML_QUERY_REWRITE", "NO_ZONEMAP", "NTH_VALUE", "NULLIF", "NULL_", + "NULLS", "NUMBER", "NUMERIC", "NUM_INDEX_KEYS", "NUMTODSINTERVAL", "NUMTOYMINTERVAL", + "NVARCHAR2", "NVL2", "OBJECT2XML", "OBJECT", "OBJ_ID", "OBJNO", "OBJNO_REUSE", + "OCCURENCES", "OFFLINE", "OFF", "OFFSET", "OF", "OIDINDEX", "OID", "OLAP", + "OLD", "OLD_PUSH_PRED", "OLS", "OLTP", "OMIT", "ONE", "ONLINE", "ONLY", + "ON", "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", + "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", "OPTIMIZER_FEATURES_ENABLE", + "OPTIMIZER_GOAL", "OPTION", "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", + "ORA_CHECK_PRIVILEGE", "ORA_CLUSTERING", "ORADATA", "ORADEBUG", "ORA_DST_AFFECTED", + "ORA_DST_CONVERT", "ORA_DST_ERROR", "ORA_GET_ACLIDS", "ORA_GET_PRIVILEGES", + "ORA_HASH", "ORA_INVOKING_USERID", "ORA_INVOKING_USER", "ORA_INVOKING_XS_USER_GUID", + "ORA_INVOKING_XS_USER", "ORA_RAWCOMPARE", "ORA_RAWCONCAT", "ORA_ROWSCN", + "ORA_ROWSCN_RAW", "ORA_ROWVERSION", "ORA_TABVERSION", "ORA_WRITE_TIME", + "ORDERED", "ORDERED_PREDICATES", "ORDER", "ORDINALITY", "OR_EXPAND", + "ORGANIZATION", "OR", "OR_PREDICATES", "OSERROR", "OTHER", "OUTER_JOIN_TO_ANTI", + "OUTER_JOIN_TO_INNER", "OUTER", "OUTLINE_LEAF", "OUTLINE", "OUT_OF_LINE", + "OUT", "OVERFLOW_NOMOVE", "OVERFLOW", "OVERLAPS", "OVER", "OVERRIDING", + "OWNER", "OWNERSHIP", "OWN", "P_LETTER", "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", + "PARALLEL_INDEX", "PARALLEL", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", + "PARENT_UNIQUE_NAME", "PARITY", "PARTIAL_JOIN", "PARTIALLY", "PARTIAL", + "PARTIAL_ROLLUP_PUSHDOWN", "PARTITION_HASH", "PARTITION_LIST", "PARTITION", + "PARTITION_RANGE", "PARTITIONS", "PARTNUMINST", "PASSING", "PASSWORD_GRACE_TIME", + "PASSWORD_LIFE_TIME", "PASSWORD_LOCK_TIME", "PASSWORD", "PASSWORD_REUSE_MAX", + "PASSWORD_REUSE_TIME", "PASSWORD_ROLLOVER_TIME", "PASSWORD_VERIFY_FUNCTION", + "PAST", "PATCH", "PATH", "PATH_PREFIX", "PATHS", "PATTERN", "PBL_HS_BEGIN", + "PBL_HS_END", "PCTFREE", "PCTINCREASE", "PCTTHRESHOLD", "PCTUSED", "PCTVERSION", + "PENDING", "PERCENT_FOUND", "PERCENT_ISOPEN", "PERCENT_NOTFOUND", "PERCENT_KEYWORD", + "PERCENT_RANKM", "PERCENT_ROWCOUNT", "PERCENT_ROWTYPE", "PERCENT_TYPE", + "PERFORMANCE", "PERIOD_KEYWORD", "PERMANENT", "PERMISSION", "PERMUTE", + "PER", "PFILE", "PHYSICAL", "PIKEY", "PIPELINED", "PIPE", "PIV_GB", + "PIVOT", "PIV_SSF", "PLACE_DISTINCT", "PLACE_GROUP_BY", "PLAN", "PLSCOPE_SETTINGS", + "PLS_INTEGER", "PLSQL_CCFLAGS", "PLSQL_CODE_TYPE", "PLSQL_DEBUG", "PLSQL_OPTIMIZE_LEVEL", + "PLSQL_WARNINGS", "PLUGGABLE", "PMEM", "POINT", "POLICY", "POOL_16K", + "POOL_2K", "POOL_32K", "POOL_4K", "POOL_8K", "POSITIVEN", "POSITIVE", + "POST_TRANSACTION", "POWERMULTISET_BY_CARDINALITY", "POWERMULTISET", + "POWER", "PQ_CONCURRENT_UNION", "PQ_DISTRIBUTE", "PQ_DISTRIBUTE_WINDOW", + "PQ_FILTER", "PQ_MAP", "PQ_NOMAP", "PQ_REPLICATE", "PQ_SKEW", "PRAGMA", + "PREBUILT", "PRECEDES", "PRECEDING", "PRECISION", "PRECOMPUTE_SUBQUERY", + "PREDICATE_REORDERS", "PRELOAD", "PREPARE", "PRESENTNNV", "PRESENT", + "PRESENTV", "PRESERVE_OID", "PRESERVE", "PRETTY", "PREVIOUS", "PREV", + "PRIMARY", "PRINTBLOBTOCLOB", "PRIORITY", "PRIOR", "PRIVATE", "PRIVATE_SGA", + "PRIVILEGED", "PRIVILEGE", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROCESS", "PROFILE", "PROGRAM", "PROJECT", "PROPAGATE", "PROPERTY", + "PROTECTED", "PROTECTION", "PROTOCOL", "PROXY", "PRUNING", "PUBLIC", + "PULL_PRED", "PURGE", "PUSH_PRED", "PUSH_SUBQ", "PX_FAULT_TOLERANCE", + "PX_GRANULE", "PX_JOIN_FILTER", "QB_NAME", "QUARTERS", "QUERY_BLOCK", + "QUERY", "QUEUE_CURR", "QUEUE", "QUEUE_ROWP", "QUIESCE", "QUORUM", "QUOTA", + "QUOTAGROUP", "RAISE", "RANDOM_LOCAL", "RANDOM", "RANGE", "RANKM", "RAPIDLY", + "RAW", "RAWTOHEX", "RAWTONHEX", "RBA", "RBO_OUTLINE", "RDBA", "READ", + "READS", "REALM", "REAL", "REBALANCE", "REBUILD", "RECORD", "RECORDS_PER_BLOCK", + "RECOVERABLE", "RECOVER", "RECOVERY", "RECYCLEBIN", "RECYCLE", "REDACTION", + "REDEFINE", "REDO", "REDUCED", "REDUNDANCY", "REF_CASCADE_CURSOR", "REFERENCED", + "REFERENCE", "REFERENCES", "REFERENCING", "REF", "REFRESH", "REFTOHEX", + "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", "REGEXP_REPLACE", "REGEXP_SUBSTR", + "REGISTER", "REGR_AVGX", "REGR_AVGY", "REGR_COUNT", "REGR_INTERCEPT", + "REGR_R2", "REGR_SLOPE", "REGR_SXX", "REGR_SXY", "REGR_SYY", "REGULAR", + "REJECT", "REKEY", "RELATIONAL", "RELIES_ON", "RELOCATE", "RELY", "REMAINDER", + "REMOTE", "REMOTE_MAPPED", "REMOVE", "RENAME", "REPAIR", "REPEAT", "REPLACE", + "REPLICATION", "REQUIRED", "RESETLOGS", "RESET", "RESIZE", "RESOLVE", + "RESOLVER", "RESOURCE", "RESPECT", "RESTART", "RESTORE_AS_INTERVALS", + "RESTORE", "RESTRICT_ALL_REF_CONS", "RESTRICTED", "RESTRICT_REFERENCES", + "RESTRICT", "RESULT_CACHE", "RESULT", "RESUMABLE", "RESUME", "RETENTION", + "RETRY_ON_ROW_CHANGE", "RETURNING", "RETURN", "REUSE", "REVERSE", "REVOKE", + "REWRITE_OR_ERROR", "REWRITE", "RIGHT", "ROLE", "ROLESET", "ROLES", + "ROLLBACK", "ROLLING", "ROLLUP", "ROWDEPENDENCIES", "ROWID_MAPPING_TABLE", + "ROWID", "ROWIDTOCHAR", "ROWIDTONCHAR", "ROW_LENGTH", "ROWNUM", "ROW", + "ROWS", "RPAD", "RTRIM", "RULE", "RULES", "RUNNING", "SALT", "SAMPLE", + "SAVE_AS_INTERVALS", "SAVEPOINT", "SAVE", "SB4", "SCALE_ROWS", "SCALE", + "SCAN_INSTANCES", "SCAN", "SCHEDULER", "SCHEMACHECK", "SCHEMA", "SCN_ASCENDING", + "SCN", "SCOPE", "SCRUB", "SD_ALL", "SD_INHIBIT", "SDO_GEOM_MBR", "SDO_GEOMETRY", + "SD_SHOW", "SEARCH", "SECOND", "SECONDS", "SECRET", "SECUREFILE_DBA", + "SECUREFILE", "SECURITY", "SEED", "SEG_BLOCK", "SEG_FILE", "SEGMENT", + "SELECTIVITY", "SELECT", "SELF", "SEMIJOIN_DRIVER", "SEMIJOIN", "SEMI_TO_INNER", + "SEQUENCED", "SEQUENCE", "SEQUENTIAL", "SERIALIZABLE", "SERIALLY_REUSABLE", + "SERIAL", "SERVERERROR", "SERVICE_NAME_CONVERT", "SERVICE", "SERVICES", + "SESSION_CACHED_CURSORS", "SESSION", "SESSIONS_PER_USER", "SESSIONTIMEZONE", + "SESSIONTZNAME", "SET", "SETS", "SETTINGS", "SET_TO_JOIN", "SEVERE", + "SHARDSPACE", "SHARED_POOL", "SHARED", "SHARE", "SHARING", "SHELFLIFE", + "SHOW", "SHRINK", "SHUTDOWN", "SIBLINGS", "SID", "SITE", "SIGNAL_COMPONENT", + "SIGNAL_FUNCTION", "SIGN", "SIGNTYPE", "SIMPLE_INTEGER", "SIMPLE", "SINGLE", + "SINGLETASK", "SINH", "SIN", "SIZE", "SKIP_EXT_OPTIMIZER", "SKIP_", + "SKIP_UNQ_UNUSABLE_IDX", "SKIP_UNUSABLE_INDEXES", "SMALLFILE", "SMALLINT", + "SNAPSHOT", "SOME", "SORT", "SOUNDEX", "SOURCE_FILE_DIRECTORY", "SOURCE_FILE_NAME_CONVERT", + "SOURCE", "SPACE_KEYWORD", "SPECIFICATION", "SPFILE", "SPLIT", "SPREADSHEET", + "SQLDATA", "SQLERROR", "SQLLDR", "SQL", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", + "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", + "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTUP", + "STATEMENT_ID", "STATEMENT_QUEUING", "STATEMENTS", "STATEMENT", "STATE", + "STATIC", "STATISTICS", "STATS_BINOMIAL_TEST", "STATS_CROSSTAB", "STATS_F_TEST", + "STATS_KS_TEST", "STATS_MODE", "STATS_MW_TEST", "STATS_ONE_WAY_ANOVA", + "STATS_T_TEST_INDEP", "STATS_T_TEST_INDEPU", "STATS_T_TEST_ONE", "STATS_T_TEST_PAIRED", + "STATS_WSR_TEST", "STDDEV_POP", "STDDEV_SAMP", "STOP", "STORAGE", "STORE", + "STREAMS", "STREAM", "STRICT", "STRING", "STRIPE_COLUMNS", "STRIPE_WIDTH", + "STRIP", "STRUCTURE", "SUBMULTISET", "SUBPARTITION_REL", "SUBPARTITIONS", + "SUBPARTITION", "SUBQUERIES", "SUBQUERY_PRUNING", "SUBSCRIBE", "SUBSET", + "SUBSTITUTABLE", "SUBSTR2", "SUBSTR4", "SUBSTRB", "SUBSTRC", "SUBTYPE", + "SUCCESSFUL", "SUCCESS", "SUMMARY", "SUPPLEMENTAL", "SUSPEND", "SWAP_JOIN_INPUTS", + "SWITCHOVER", "SWITCH", "SYNCHRONOUS", "SYNC", "SYNONYM", "SYS", "SYSASM", + "SYS_AUDIT", "SYSAUX", "SYSBACKUP", "SYS_CHECKACL", "SYS_CHECK_PRIVILEGE", + "SYS_CONNECT_BY_PATH", "SYS_CONTEXT", "SYSDATE", "SYSDBA", "SYS_DBURIGEN", + "SYSDG", "SYS_DL_CURSOR", "SYS_DM_RXFORM_CHR", "SYS_DM_RXFORM_NUM", + "SYS_DOM_COMPARE", "SYS_DST_PRIM2SEC", "SYS_DST_SEC2PRIM", "SYS_ET_BFILE_TO_RAW", + "SYS_ET_BLOB_TO_IMAGE", "SYS_ET_IMAGE_TO_BLOB", "SYS_ET_RAW_TO_BFILE", + "SYS_EXTPDTXT", "SYS_EXTRACT_UTC", "SYS_FBT_INSDEL", "SYS_FILTER_ACLS", + "SYS_FNMATCHES", "SYS_FNREPLACE", "SYS_GET_ACLIDS", "SYS_GET_COL_ACLIDS", + "SYS_GET_PRIVILEGES", "SYS_GETTOKENID", "SYS_GETXTIVAL", "SYS_GUID", + "SYSGUID", "SYSKM", "SYS_MAKE_XMLNODEID", "SYS_MAKEXML", "SYS_MKXMLATTR", + "SYS_MKXTI", "SYSOBJ", "SYS_OP_ADT2BIN", "SYS_OP_ADTCONS", "SYS_OP_ALSCRVAL", + "SYS_OP_ATG", "SYS_OP_BIN2ADT", "SYS_OP_BITVEC", "SYS_OP_BL2R", "SYS_OP_BLOOM_FILTER_LIST", + "SYS_OP_BLOOM_FILTER", "SYS_OP_C2C", "SYS_OP_CAST", "SYS_OP_CEG", "SYS_OP_CL2C", + "SYS_OP_COMBINED_HASH", "SYS_OP_COMP", "SYS_OP_CONVERT", "SYS_OP_COUNTCHG", + "SYS_OP_CSCONV", "SYS_OP_CSCONVTEST", "SYS_OP_CSR", "SYS_OP_CSX_PATCH", + "SYS_OP_CYCLED_SEQ", "SYS_OP_DECOMP", "SYS_OP_DESCEND", "SYS_OP_DISTINCT", + "SYS_OP_DRA", "SYS_OP_DUMP", "SYS_OP_DV_CHECK", "SYS_OP_ENFORCE_NOT_NULL", + "SYSOPER", "SYS_OP_EXTRACT", "SYS_OP_GROUPING", "SYS_OP_GUID", "SYS_OP_HASH", + "SYS_OP_IIX", "SYS_OP_ITR", "SYS_OP_KEY_VECTOR_CREATE", "SYS_OP_KEY_VECTOR_FILTER_LIST", + "SYS_OP_KEY_VECTOR_FILTER", "SYS_OP_KEY_VECTOR_SUCCEEDED", "SYS_OP_KEY_VECTOR_USE", + "SYS_OP_LBID", "SYS_OP_LOBLOC2BLOB", "SYS_OP_LOBLOC2CLOB", "SYS_OP_LOBLOC2ID", + "SYS_OP_LOBLOC2NCLOB", "SYS_OP_LOBLOC2TYP", "SYS_OP_LSVI", "SYS_OP_LVL", + "SYS_OP_MAKEOID", "SYS_OP_MAP_NONNULL", "SYS_OP_MSR", "SYS_OP_NICOMBINE", + "SYS_OP_NIEXTRACT", "SYS_OP_NII", "SYS_OP_NIX", "SYS_OP_NOEXPAND", "SYS_OP_NTCIMG", + "SYS_OP_NUMTORAW", "SYS_OP_OIDVALUE", "SYS_OP_OPNSIZE", "SYS_OP_PAR_1", + "SYS_OP_PARGID_1", "SYS_OP_PARGID", "SYS_OP_PAR", "SYS_OP_PART_ID", + "SYS_OP_PIVOT", "SYS_OP_R2O", "SYS_OP_RAWTONUM", "SYS_OP_RDTM", "SYS_OP_REF", + "SYS_OP_RMTD", "SYS_OP_ROWIDTOOBJ", "SYS_OP_RPB", "SYS_OPTLOBPRBSC", + "SYS_OP_TOSETID", "SYS_OP_TPR", "SYS_OP_TRTB", "SYS_OPTXICMP", "SYS_OPTXQCASTASNQ", + "SYS_OP_UNDESCEND", "SYS_OP_VECAND", "SYS_OP_VECBIT", "SYS_OP_VECOR", + "SYS_OP_VECXOR", "SYS_OP_VERSION", "SYS_OP_VREF", "SYS_OP_VVD", "SYS_OP_XMLCONS_FOR_CSX", + "SYS_OP_XPTHATG", "SYS_OP_XPTHIDX", "SYS_OP_XPTHOP", "SYS_OP_XTXT2SQLT", + "SYS_OP_ZONE_ID", "SYS_ORDERKEY_DEPTH", "SYS_ORDERKEY_MAXCHILD", "SYS_ORDERKEY_PARENT", + "SYS_PARALLEL_TXN", "SYS_PATHID_IS_ATTR", "SYS_PATHID_IS_NMSPC", "SYS_PATHID_LASTNAME", + "SYS_PATHID_LASTNMSPC", "SYS_PATH_REVERSE", "SYS_PXQEXTRACT", "SYS_RAW_TO_XSID", + "SYS_RID_ORDER", "SYS_ROW_DELTA", "SYS_SC_2_XMLT", "SYS_SYNRCIREDO", + "SYSTEM_DEFINED", "SYSTEM", "SYSTIMESTAMP", "SYS_TYPEID", "SYS_UMAKEXML", + "SYS_XMLANALYZE", "SYS_XMLCONTAINS", "SYS_XMLCONV", "SYS_XMLEXNSURI", + "SYS_XMLGEN", "SYS_XMLI_LOC_ISNODE", "SYS_XMLI_LOC_ISTEXT", "SYS_XMLINSTR", + "SYS_XMLLOCATOR_GETSVAL", "SYS_XMLNODEID_GETCID", "SYS_XMLNODEID_GETLOCATOR", + "SYS_XMLNODEID_GETOKEY", "SYS_XMLNODEID_GETPATHID", "SYS_XMLNODEID_GETPTRID", + "SYS_XMLNODEID_GETRID", "SYS_XMLNODEID_GETSVAL", "SYS_XMLNODEID_GETTID", + "SYS_XMLNODEID", "SYS_XMLT_2_SC", "SYS_XMLTRANSLATE", "SYS_XMLTYPE2SQL", + "SYS_XQ_ASQLCNV", "SYS_XQ_ATOMCNVCHK", "SYS_XQBASEURI", "SYS_XQCASTABLEERRH", + "SYS_XQCODEP2STR", "SYS_XQCODEPEQ", "SYS_XQCON2SEQ", "SYS_XQCONCAT", + "SYS_XQDELETE", "SYS_XQDFLTCOLATION", "SYS_XQDOC", "SYS_XQDOCURI", "SYS_XQDURDIV", + "SYS_XQED4URI", "SYS_XQENDSWITH", "SYS_XQERRH", "SYS_XQERR", "SYS_XQESHTMLURI", + "SYS_XQEXLOBVAL", "SYS_XQEXSTWRP", "SYS_XQEXTRACT", "SYS_XQEXTRREF", + "SYS_XQEXVAL", "SYS_XQFB2STR", "SYS_XQFNBOOL", "SYS_XQFNCMP", "SYS_XQFNDATIM", + "SYS_XQFNLNAME", "SYS_XQFNNM", "SYS_XQFNNSURI", "SYS_XQFNPREDTRUTH", + "SYS_XQFNQNM", "SYS_XQFNROOT", "SYS_XQFORMATNUM", "SYS_XQFTCONTAIN", + "SYS_XQFUNCR", "SYS_XQGETCONTENT", "SYS_XQINDXOF", "SYS_XQINSERT", "SYS_XQINSPFX", + "SYS_XQIRI2URI", "SYS_XQLANG", "SYS_XQLLNMFRMQNM", "SYS_XQMKNODEREF", + "SYS_XQNILLED", "SYS_XQNODENAME", "SYS_XQNORMSPACE", "SYS_XQNORMUCODE", + "SYS_XQ_NRNG", "SYS_XQNSP4PFX", "SYS_XQNSPFRMQNM", "SYS_XQPFXFRMQNM", + "SYS_XQ_PKSQL2XML", "SYS_XQPOLYABS", "SYS_XQPOLYADD", "SYS_XQPOLYCEL", + "SYS_XQPOLYCSTBL", "SYS_XQPOLYCST", "SYS_XQPOLYDIV", "SYS_XQPOLYFLR", + "SYS_XQPOLYMOD", "SYS_XQPOLYMUL", "SYS_XQPOLYRND", "SYS_XQPOLYSQRT", + "SYS_XQPOLYSUB", "SYS_XQPOLYUMUS", "SYS_XQPOLYUPLS", "SYS_XQPOLYVEQ", + "SYS_XQPOLYVGE", "SYS_XQPOLYVGT", "SYS_XQPOLYVLE", "SYS_XQPOLYVLT", + "SYS_XQPOLYVNE", "SYS_XQREF2VAL", "SYS_XQRENAME", "SYS_XQREPLACE", "SYS_XQRESVURI", + "SYS_XQRNDHALF2EVN", "SYS_XQRSLVQNM", "SYS_XQRYENVPGET", "SYS_XQRYVARGET", + "SYS_XQRYWRP", "SYS_XQSEQ2CON4XC", "SYS_XQSEQ2CON", "SYS_XQSEQDEEPEQ", + "SYS_XQSEQINSB", "SYS_XQSEQRM", "SYS_XQSEQRVS", "SYS_XQSEQSUB", "SYS_XQSEQTYPMATCH", + "SYS_XQSTARTSWITH", "SYS_XQSTATBURI", "SYS_XQSTR2CODEP", "SYS_XQSTRJOIN", + "SYS_XQSUBSTRAFT", "SYS_XQSUBSTRBEF", "SYS_XQTOKENIZE", "SYS_XQTREATAS", + "SYS_XQ_UPKXML2SQL", "SYS_XQXFORM", "SYS_XSID_TO_RAW", "SYS_ZMAP_FILTER", + "SYS_ZMAP_REFRESH", "T_LETTER", "TABLE_LOOKUP_BY_NL", "TABLESPACE_NO", + "TABLESPACE", "TABLES", "TABLE_STATS", "TABLE", "TABNO", "TAG", "TANH", + "TAN", "TBLORIDXPARTNUM", "TEMPFILE", "TEMPLATE", "TEMPORARY", "TEMP_TABLE", + "TEST", "TEXT", "THAN", "THEN", "THE", "THREAD", "THROUGH", "TIER", + "TIES", "TIMEOUT", "TIMESTAMP_LTZ_UNCONSTRAINED", "TIMESTAMP", "TIMESTAMP_TZ_UNCONSTRAINED", + "TIMESTAMP_UNCONSTRAINED", "TIMES", "TIME", "TIMEZONE", "TIMEZONE_ABBR", + "TIMEZONE_HOUR", "TIMEZONE_MINUTE", "TIMEZONE_OFFSET", "TIMEZONE_REGION", + "TIME_ZONE", "TIMING", "TIV_GB", "TIV_SSF", "TO_ACLID", "TO_BINARY_DOUBLE", + "TO_BINARY_FLOAT", "TO_BLOB", "TO_CLOB", "TO_DSINTERVAL", "TO_LOB", + "TO_MULTI_BYTE", "TO_NCHAR", "TO_NCLOB", "TO_NUMBER", "TOPLEVEL", "TO_SINGLE_BYTE", + "TO_TIMESTAMP", "TO_TIMESTAMP_TZ", "TO_TIME", "TO_TIME_TZ", "TO", "TO_YMINTERVAL", + "TRACE", "TRACING", "TRACKING", "TRAILING", "TRANSACTION", "TRANSFORM", + "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", + "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", "TRUNC", + "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", "UB2", + "UBA", "UCS2", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", "UNCONDITIONAL", + "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", "UNIQUE", "UNISTR", "UNLIMITED", + "UNLOAD", "UNLOCK", "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", + "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", "UNPROTECTED", + "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSUBSCRIBE", "UNTIL", + "UNUSABLE", "UNUSED", "UPDATABLE", "UPDATED", "UPDATE", "UPDATEXML", + "UPD_INDEXES", "UPD_JOININDEX", "UPGRADE", "UPPER", "UPSERT", "UROWID", + "USABLE", "USAGE", "USE_ANTI", "USE_CONCAT", "USE_CUBE", "USE_HASH_AGGREGATION", + "USE_HASH_GBY_FOR_PUSHDOWN", "USE_HASH", "USE_HIDDEN_PARTITIONS", "USE_INVISIBLE_INDEXES", + "USE_MERGE_CARTESIAN", "USE_MERGE", "USE_NL", "USE_NL_WITH_INDEX", "USE_PRIVATE_OUTLINES", + "USER_DATA", "USER_DEFINED", "USERENV", "USERGROUP", "USER_RECYCLEBIN", + "USERS", "USER_TABLESPACES", "USER", "USE_SEMI", "USE_STORED_OUTLINES", + "USE_TTT_FOR_GSETS", "USE", "USE_VECTOR_AGGREGATION", "USE_WEAK_NAME_RESL", + "USING_NO_EXPAND", "USING", "UTF16BE", "UTF16LE", "UTF32", "UTF8", "V1", + "V2", "VALIDATE", "VALIDATE_CONVERSION", "VALIDATION", "VALID_TIME_END", + "VALUES", "VALUE", "VARCHAR2", "VARCHAR", "VARIABLE", "VAR_POP", "VARRAYS", + "VARRAY", "VAR_SAMP", "VARYING", "VECTOR_READ_TRACE", "VECTOR_READ", + "VECTOR_TRANSFORM_DIMS", "VECTOR_TRANSFORM_FACT", "VECTOR_TRANSFORM", + "VERIFIER", "VERIFY", "VERSIONING", "VERSIONS_ENDSCN", "VERSIONS_ENDTIME", + "VERSIONS_OPERATION", "VERSIONS_STARTSCN", "VERSIONS_STARTTIME", "VERSIONS", + "VERSIONS_XID", "VERSION", "VIEW", "VIOLATION", "VIRTUAL", "VISIBILITY", + "VISIBLE", "VOLUME", "VSIZE", "WAIT", "WALLET", "WARNING", "WEEKS", + "WEEK", "WELLFORMED", "WHENEVER", "WHEN", "WHERE", "WHILE", "WHITESPACE", + "WIDTH_BUCKET", "WITHIN", "WITHOUT", "WITH_PLSQL", "WITH", "WORK", "WRAPPED", + "WRAPPER", "WRITE", "XDB_FASTPATH_INSERT", "XDB", "X_DYN_PRUNE", "XID", + "XML2OBJECT", "XMLAGG", "XMLATTRIBUTES", "XMLCAST", "XMLCDATA", "XMLCOLATTVAL", + "XMLCOMMENT", "XMLCONCAT", "XMLDIFF", "XML_DML_RWT_STMT", "XMLELEMENT", + "XMLEXISTS2", "XMLEXISTS", "XMLFOREST", "XMLINDEX", "XMLINDEX_REWRITE_IN_SELECT", + "XMLINDEX_REWRITE", "XMLINDEX_SEL_IDX_TBL", "XMLISNODE", "XMLISVALID", + "XMLNAMESPACES", "XMLPARSE", "XMLPATCH", "XMLPI", "XMLQUERYVAL", "XMLQUERY", + "XMLROOT", "XMLSCHEMA", "XMLSERIALIZE", "XMLTABLE", "XMLTRANSFORMBLOB", + "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", "XS", + "YEARS", "YEAR", "YES", "YMINTERVAL_UNCONSTRAINED", "ZONEMAP", "ZONE", + "PREDICTION", "PREDICTION_BOUNDS", "PREDICTION_COST", "PREDICTION_DETAILS", + "PREDICTION_PROBABILITY", "PREDICTION_SET", "BLOCKCHAIN", "COLLATE", + "COLLATION", "DEFINITION", "DUPLICATED", "EXTENDED", "HASHING", "IDLE", + "IMMUTABLE", "ORACLE_DATAPUMP", "ORACLE_HDFS", "ORACLE_HIVE", "ORACLE_LOADER", + "SHA2_512_Q", "SHARDED", "V1_Q", "ISOLATE", "ROOT", "UNITE", "ALGORITHM", + "CUME_DIST", "DENSE_RANK", "LISTAGG", "PERCENT_RANK", "PERCENTILE_CONT", + "PERCENTILE_DISC", "RANK", "AVG", "CORR", "COVAR_", "DECODE", "LAG", + "LAG_DIFF", "LAG_DIFF_PERCENT", "LEAD", "MAX", "MEDIAN", "MEMOPTIMIZE", + "MIN", "NTILE", "NVL", "RATIO_TO_REPORT", "REGR_", "ROUND", "ROW_NUMBER", + "SUBSTR", "TO_CHAR", "TRIM", "SUM", "STDDEV", "VAR_", "VARIANCE", "LEAST", + "GREATEST", "TO_DATE", "DEFAULTIF", "LLS", "ENCLOSED", "TERMINATED", + "OPTIONALLY", "LRTRIM", "NOTRIM", "LDRTRIM", "DATE_FORMAT", "MASK", + "TRANSFORMS", "LOBFILE", "STARTOF", "CHARACTERSET", "RECORDS", "FIXED", + "DELIMITED", "XMLTAG", "PREPROCESSOR", "TERRITORY", "LITTLE", "BIG", + "ENDIAN", "BYTEORDERMARK", "NOCHECK", "SIZES", "ARE", "BYTES", "CHARACTERS", + "READSIZE", "DISABLE_DIRECTORY_LINK_CHECK", "DATE_CACHE", "FIELD_NAMES", + "FILES", "IO_OPTIONS", "DIRECTIO", "NODIRECTIO", "DNFS_ENABLE", "DNFS_DISABLE", + "DNFS_READBUFFERS", "NOBADFILE", "BADFILE", "NODISCARDFILE", "DISCARDFILE", + "NOLOGFILE", "FIELDS", "IGNORE_CHARS_AFTER_EOR", "CSV", "EMBEDDED", + "OVERRIDE", "THESE", "FIELD", "NONULLIF", "POSITION", "NEWLINE_", "DETECTED", + "UNSIGNED", "ZONED", "ORACLE_DATE", "ORACLE_NUMBER", "COUNTED", "VARRAW", + "VARCHARC", "VARRAWC", "NATIONAL_CHAR_STRING_LIT", "BIT_STRING_LIT", + "HEX_STRING_LIT", "DOUBLE_PERIOD", "PERIOD", "UNSIGNED_INTEGER", "APPROXIMATE_NUM_LIT", + "CHAR_STRING", "DELIMITED_ID", "PERCENT", "AMPERSAND", "LEFT_PAREN", + "RIGHT_PAREN", "DOUBLE_ASTERISK", "ASTERISK", "PLUS_SIGN", "MINUS_SIGN", + "COMMA", "SOLIDUS", "AT_SIGN", "ASSIGN_OP", "HASH_OP", "SQ", "BINDVAR", + "NOT_EQUAL_OP", "CARRET_OPERATOR_PART", "TILDE_OPERATOR_PART", "EXCLAMATION_OPERATOR_PART", + "GREATER_THAN_OP", "LESS_THAN_OP", "COLON", "SEMICOLON", "BAR", "EQUALS_OP", + "LEFT_BRACKET", "RIGHT_BRACKET", "INTRODUCER", "SINGLE_LINE_COMMENT", + "MULTI_LINE_COMMENT", "REMARK_COMMENT", "PROMPT_MESSAGE", "START_CMD", + "REGULAR_ID", "SPACES", + } + staticData.RuleNames = []string{ + "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCOUNT", "ACL", "ACOS", + "ACROSS", "ACTION", "ACTIONS", "ACTIVATE", "ACTIVE", "ACTIVE_COMPONENT", + "ACTIVE_DATA", "ACTIVE_FUNCTION", "ACTIVE_TAG", "ACTIVITY", "ADAPTIVE_PLAN", + "ADD", "ADD_COLUMN", "ADD_GROUP", "ADD_MONTHS", "ADJ_DATE", "ADMIN", + "ADMINISTER", "ADMINISTRATOR", "ADVANCED", "ADVISE", "ADVISOR", "AFD_DISKSTRING", + "AFTER", "AGENT", "AGGREGATE", "A_LETTER", "ALIAS", "ALL", "ALLOCATE", + "ALLOW", "ALL_ROWS", "ALTER", "ALTERNATE", "ALWAYS", "ANALYTIC", "ANALYZE", + "ANCESTOR", "ANCILLARY", "AND", "AND_EQUAL", "ANOMALY", "ANSI_REARCH", + "ANTIJOIN", "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", + "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", + "ARCHIVED", "ARCHIVELOG", "ARRAY", "AS", "ASC", "ASCII", "ASCIISTR", + "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", "ASYNCHRONOUS", + "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", "AUDIT", "AUTHENTICATED", + "AUTHENTICATION", "AUTHID", "AUTHORIZATION", "AUTOALLOCATE", "AUTO", + "AUTOEXTEND", "AUTO_LOGIN", "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", + "AVAILABILITY", "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", + "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", + "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", "BEHALF", + "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIGFILE", "BINARY", "BINARY_DOUBLE", + "BINARY_DOUBLE_INFINITY", "BINARY_DOUBLE_NAN", "BINARY_FLOAT", "BINARY_FLOAT_INFINITY", + "BINARY_FLOAT_NAN", "BINARY_INTEGER", "BIND_AWARE", "BINDING", "BIN_TO_NUM", + "BITAND", "BITMAP_AND", "BITMAP", "BITMAPS", "BITMAP_TREE", "BITS", + "BLOB", "BLOCK", "BLOCK_RANGE", "BLOCKS", "BLOCKSIZE", "BODY", "BOOLEAN", + "BOTH", "BOUND", "BRANCH", "BREADTH", "BROADCAST", "BSON", "BUFFER", + "BUFFER_CACHE", "BUFFER_POOL", "BUILD", "BULK", "BY", "BYPASS_RECURSIVE_CHECK", + "BYPASS_UJVC", "BYTE", "CACHE", "CACHE_CB", "CACHE_INSTANCES", "CACHE_TEMP_TABLE", + "CACHING", "CALCULATED", "CALLBACK", "CALL", "CANCEL", "CANONICAL", + "CAPACITY", "CAPTION", "CARDINALITY", "CASCADE", "CASE", "CAST", "CASESENSITIVE", + "CATEGORY", "CDBDEFAULT", "CEIL", "CELL_FLASH_CACHE", "CERTIFICATE", + "CFILE", "CHAINED", "CHANGE", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", + "CHAR", "CHAR_CS", "CHARTOROWID", "CHECK_ACL_REWRITE", "CHECK", "CHECKPOINT", + "CHILD", "CHOOSE", "CHR", "CHUNK", "CLASS", "CLASSIFICATION", "CLASSIFIER", + "CLAUSE", "CLEAN", "CLEANUP", "CLEAR", "C_LETTER", "CLIENT", "CLOB", + "CLONE", "CLOSE_CACHED_OPEN_CURSORS", "CLOSE", "CLUSTER_BY_ROWID", "CLUSTER", + "CLUSTER_DETAILS", "CLUSTER_DISTANCE", "CLUSTER_ID", "CLUSTERING", "CLUSTERING_FACTOR", + "CLUSTER_PROBABILITY", "CLUSTER_SET", "COALESCE", "COALESCE_SQ", "COARSE", + "CO_AUTH_IND", "COLD", "COLLECT", "COLUMNAR", "COLUMN_AUTH_INDICATOR", + "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", "COMMIT", + "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBILITY", "COMPILE", + "COMPLETE", "COMPLIANCE", "COMPONENT", "COMPONENTS", "COMPOSE", "COMPOSITE", + "COMPOSITE_LIMIT", "COMPOUND", "COMPRESS", "COMPUTE", "CONCAT", "CON_DBID_TO_ID", + "CONDITIONAL", "CONDITION", "CONFIRM", "CONFORMING", "CON_GUID_TO_ID", + "CON_ID", "CON_NAME_TO_ID", "CONNECT_BY_CB_WHR_ONLY", "CONNECT_BY_COMBINE_SW", + "CONNECT_BY_COST_BASED", "CONNECT_BY_ELIM_DUPS", "CONNECT_BY_FILTERING", + "CONNECT_BY_ISCYCLE", "CONNECT_BY_ISLEAF", "CONNECT_BY_ROOT", "CONNECT", + "CONNECT_TIME", "CONSIDER", "CONSISTENT", "CONSTANT", "CONST", "CONSTRAINT", + "CONSTRAINTS", "CONSTRUCTOR", "CONTAINER", "CONTAINERS", "CONTAINERS_DEFAULT", + "CONTAINER_DATA", "CONTAINER_MAP", "CONTENT", "CONTENTS", "CONTEXT", + "CONTINUE", "CONTROLFILE", "CON_UID_TO_ID", "CONVERT", "CONVERSION", + "COOKIE", "COPY", "CORR_K", "CORR_S", "CORRUPTION", "CORRUPT_XID_ALL", + "CORRUPT_XID", "COS", "COSH", "COST", "COST_XML_QUERY_REWRITE", "COUNT", + "COVAR_POP", "COVAR_SAMP", "CPU_COSTING", "CPU_PER_CALL", "CPU_PER_SESSION", + "CRASH", "CREATE", "CREATE_FILE_DEST", "CREATE_STORED_OUTLINES", "CREATION", + "CREDENTIAL", "CRITICAL", "CROSS", "CROSSEDITION", "CSCONVERT", "CUBE_AJ", + "CUBE", "CUBE_GB", "CUBE_SJ", "CUME_DISTM", "CURRENT", "CURRENT_DATE", + "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "CURRENTV", "CURSOR", "CURSOR_SHARING_EXACT", "CURSOR_SPECIFIC_SEGMENT", + "CUSTOMDATUM", "CV", "CYCLE", "DANGLING", "DATABASE", "DATA", "DATAFILE", + "DATAFILES", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", + "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", "DATE", + "DATE_MODE", "DAY", "DAYS", "DBA", "DBA_RECYCLEBIN", "DBMS_STATS", "DB_ROLE_CHANGE", + "DBTIMEZONE", "DB_UNIQUE_NAME", "DB_VERSION", "DDL", "DEALLOCATE", "DEBUG", + "DEBUGGER", "DEC", "DECIMAL", "DECLARE", "DECOMPOSE", "DECORRELATE", + "DECR", "DECREMENT", "DECRYPT", "DEDUPLICATE", "DEFAULT", "DEFAULTS", + "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", "DEFERRABLE", "DEFERRED", + "DEFINED", "DEFINE", "DEFINER", "DEGREE", "DELAY", "DELEGATE", "DELETE_ALL", + "DELETE", "DELETEXML", "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPTH", + "DEQUEUE", "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", + "DETACHED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", + "DIMENSIONS", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", "DISABLE_ALL", + "DISABLE", "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", + "DISALLOW", "DISASSOCIATE", "DISCARD", "DISCONNECT", "DISK", "DISKGROUP", + "DISKS", "DISMOUNT", "DISTINCT", "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", + "DML", "DML_UPDATE", "DOCFIDELITY", "DOCUMENT", "DOMAIN_INDEX_FILTER", + "DOMAIN_INDEX_NO_SORT", "DOMAIN_INDEX_SORT", "DOUBLE", "DOWNGRADE", + "DRIVING_SITE", "DROP_COLUMN", "DROP", "DROP_GROUP", "DSINTERVAL_UNCONSTRAINED", + "DST_UPGRADE_INSERT_CONV", "DUMP", "DUPLICATE", "DV", "DYNAMIC", "DYNAMIC_SAMPLING", + "DYNAMIC_SAMPLING_EST_CDN", "E_LETTER", "EACH", "EDITIONABLE", "EDITION", + "EDITIONING", "EDITIONS", "ELEMENT", "ELIM_GROUPBY", "ELIMINATE_JOIN", + "ELIMINATE_OBY", "ELIMINATE_OUTER_JOIN", "ELSE", "ELSIF", "EM", "EMPTY_BLOB", + "EMPTY_CLOB", "EMPTY", "ENABLE_ALL", "ENABLE", "ENABLE_PARALLEL_DML", + "ENABLE_PRESET", "ENCODING", "ENCRYPT", "ENCRYPTION", "END", "END_OUTLINE_DATA", + "ENFORCED", "ENFORCE", "ENQUEUE", "ENTERPRISE", "ENTITYESCAPING", "ENTRY", + "EQUIPART", "ERR", "ERROR_ARGUMENT", "ERROR", "ERROR_ON_OVERLAP_TIME", + "ERRORS", "ESCAPE", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", "EVALUATION", + "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", "EXCEPTIONS", + "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXEMPT", + "EXISTING", "EXISTS", "EXISTSNODE", "EXIT", "EXPAND_GSET_TO_UNION", + "EXPAND_TABLE", "EXP", "EXPIRE", "EXPLAIN", "EXPLOSION", "EXPORT", "EXPR_CORR_CHECK", + "EXPRESS", "EXTENDS", "EXTENT", "EXTENTS", "EXTERNAL", "EXTERNALLY", + "EXTRACTCLOBXML", "EXTRACT", "EXTRACTVALUE", "EXTRA", "FACILITY", "FACT", + "FACTOR", "FACTORIZE_JOIN", "FAILED", "FAILED_LOGIN_ATTEMPTS", "FAILGROUP", + "FAILOVER", "FAILURE", "FALSE", "FAMILY", "FAR", "FAST", "FASTSTART", + "FBTSCAN", "FEATURE", "FEATURE_DETAILS", "FEATURE_ID", "FEATURE_SET", + "FEATURE_VALUE", "FETCH", "FILE", "FILE_NAME_CONVERT", "FILEGROUP", + "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", "FINE", "FINISH", + "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", "FIXED_VIEW_DATA", "FLAGGER", + "FLASHBACK", "FLASH_CACHE", "FLOAT", "FLOB", "FLEX", "FLOOR", "FLUSH", + "FOLDER", "FOLLOWING", "FOLLOWS", "FORALL", "FORCE", "FORCE_XML_QUERY_REWRITE", + "FOREIGN", "FOREVER", "FOR", "FORMAT", "FORWARD", "FRAGMENT_NUMBER", + "FREELIST", "FREELISTS", "FREEPOOLS", "FRESH", "FROM", "FROM_TZ", "FULL", + "FULL_OUTER_JOIN_TO_OUTER", "FUNCTION", "FUNCTIONS", "FTP", "G_LETTER", + "GATHER_OPTIMIZER_STATISTICS", "GATHER_PLAN_STATISTICS", "GBY_CONC_ROLLUP", + "GBY_PUSHDOWN", "GENERATED", "GET", "GLOBAL", "GLOBALLY", "GLOBAL_NAME", + "GLOBAL_TOPIC_ENABLED", "GOTO", "GRANT", "GROUP_BY", "GROUP", "GROUP_ID", + "GROUPING", "GROUPING_ID", "GROUPS", "GUARANTEED", "GUARANTEE", "GUARD", + "HALF_YEARS", "HASH_AJ", "HASH", "HASHKEYS", "HASH_SJ", "HAVING", "HEADER", + "HEAP", "HELP", "HEXTORAW", "HEXTOREF", "HIDDEN_KEYWORD", "HIDE", "HIER_ORDER", + "HIERARCHICAL", "HIERARCHIES", "HIERARCHY", "HIGH", "HINTSET_BEGIN", + "HINTSET_END", "HOT", "HOUR", "HOURS", "HTTP", "HWM_BROKERED", "HYBRID", + "H_LETTER", "IDENTIFIED", "IDENTIFIER", "IDENTITY", "IDGENERATORS", + "ID", "IDLE_TIME", "IF", "IGNORE", "IGNORE_OPTIM_EMBEDDED_HINTS", "IGNORE_ROW_ON_DUPKEY_INDEX", + "IGNORE_WHERE_CLAUSE", "ILM", "IMMEDIATE", "IMPACT", "IMPORT", "INACTIVE", + "INACTIVE_ACCOUNT_TIME", "INCLUDE", "INCLUDE_VERSION", "INCLUDING", + "INCREMENTAL", "INCREMENT", "INCR", "INDENT", "INDEX_ASC", "INDEX_COMBINE", + "INDEX_DESC", "INDEXED", "INDEXES", "INDEX_FFS", "INDEX_FILTER", "INDEX", + "INDEXING", "INDEX_JOIN", "INDEX_ROWS", "INDEX_RRS", "INDEX_RS_ASC", + "INDEX_RS_DESC", "INDEX_RS", "INDEX_SCAN", "INDEX_SKIP_SCAN", "INDEX_SS_ASC", + "INDEX_SS_DESC", "INDEX_SS", "INDEX_STATS", "INDEXTYPE", "INDEXTYPES", + "INDICATOR", "INDICES", "INFINITE", "INFORMATIONAL", "INHERIT", "IN", + "INITCAP", "INITIAL", "INITIALIZED", "INITIALLY", "INITRANS", "INLINE", + "INLINE_XMLTYPE_NT", "INMEMORY", "IN_MEMORY_METADATA", "INMEMORY_PRUNING", + "INNER", "INOUT", "INPLACE", "INSERTCHILDXMLAFTER", "INSERTCHILDXMLBEFORE", + "INSERTCHILDXML", "INSERT", "INSERTXMLAFTER", "INSERTXMLBEFORE", "INSTANCE", + "INSTANCES", "INSTANTIABLE", "INSTANTLY", "INSTEAD", "INSTR2", "INSTR4", + "INSTRB", "INSTRC", "INSTR", "INTEGER", "INTERLEAVED", "INTERMEDIATE", + "INTERNAL_CONVERT", "INTERNAL_USE", "INTERPRETED", "INTERSECT", "INTERVAL", + "INT", "INTO", "INVALIDATE", "INVISIBLE", "IN_XQUERY", "IS", "IS_LEAF", + "ISOLATION", "ISOLATION_LEVEL", "ITERATE", "ITERATION_NUMBER", "JAVA", + "JOB", "JOIN", "JSON_ARRAYAGG", "JSON_ARRAY", "JSON_EQUAL", "JSON_EXISTS2", + "JSON_EXISTS", "JSONGET", "JSON", "JSON_OBJECTAGG", "JSON_OBJECT", "JSONPARSE", + "JSON_QUERY", "JSON_SERIALIZE", "JSON_TABLE", "JSON_TEXTCONTAINS2", + "JSON_TEXTCONTAINS", "JSON_TRANSFORM", "JSON_VALUE", "K_LETTER", "KEEP_DUPLICATES", + "KEEP", "KERBEROS", "KEY", "KEY_LENGTH", "KEYSIZE", "KEYS", "KEYSTORE", + "KILL", "LABEL", "LANGUAGE", "LAST_DAY", "LAST", "LAST_VALUE", "LATERAL", + "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", + "LEAF", "LEAD_CDB", "LEAD_CDB_URI", "LEADING", "LEFT", "LENGTH2", "LENGTH4", + "LENGTHB", "LENGTHC", "LENGTH", "LESS", "LEVEL", "LEVEL_NAME", "LEVELS", + "LIBRARY", "LIFECYCLE", "LIFE", "LIFETIME", "LIKE2", "LIKE4", "LIKEC", + "LIKE_EXPAND", "LIKE", "LIMIT", "LINEAR", "LINK", "LIST", "LN", "LNNVL", + "LOAD", "LOB", "LOBNVL", "LOBS", "LOCAL_INDEXES", "LOCAL", "LOCALTIME", + "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCKDOWN", "LOCKED", "LOCKING", + "LOCK", "LOGFILE", "LOGFILES", "LOGGING", "LOGICAL", "LOGICAL_READS_PER_CALL", + "LOGICAL_READS_PER_SESSION", "LOG", "LOGMINING", "LOGOFF", "LOGON", + "LOG_READ_ONLY_VIOLATIONS", "LONG", "LOOP", "LOST", "LOWER", "LOW", + "LPAD", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", "MANAGE", + "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", "MAPPING", "MASTER", + "MATCHED", "MATCHES", "MATCH", "MATCH_NUMBER", "MATCH_RECOGNIZE", "MATERIALIZED", + "MATERIALIZE", "MAXARCHLOGS", "MAXDATAFILES", "MAXEXTENTS", "MAXIMIZE", + "MAXINSTANCES", "MAXLOGFILES", "MAXLOGHISTORY", "MAXLOGMEMBERS", "MAX_SHARED_TEMP_SIZE", + "MAXSIZE", "MAXTRANS", "MAXVALUE", "MEASURE", "MEASURES", "MEDIUM", + "MEMBER", "MEMBER_CAPTION", "MEMBER_DESCRIPTION", "MEMBER_NAME", "MEMBER_UNIQUE_NAME", + "MEMCOMPRESS", "MEMORY", "MERGEACTIONS", "MERGE_AJ", "MERGE_CONST_ON", + "MERGE", "MERGE_SJ", "METADATA", "METHOD", "MIGRATE", "MIGRATION", "MINEXTENTS", + "MINIMIZE", "MINIMUM", "MINING", "MINUS", "MINUS_NULL", "MINUTE", "MINUTES", + "MINVALUE", "MIRRORCOLD", "MIRRORHOT", "MIRROR", "MISSING", "MISMATCH", + "MLSLABEL", "MODEL_COMPILE_SUBQUERY", "MODEL_DONTVERIFY_UNIQUENESS", + "MODEL_DYNAMIC_SUBQUERY", "MODEL_MIN_ANALYSIS", "MODEL", "MODEL_NB", + "MODEL_NO_ANALYSIS", "MODEL_PBY", "MODEL_PUSH_REF", "MODEL_SV", "MODE", + "MODIFICATION", "MODIFY_COLUMN_TYPE", "MODIFY", "MOD", "MODULE", "MONITORING", + "MONITOR", "MONTH", "MONTHS_BETWEEN", "MONTHS", "MOUNT", "MOUNTPATH", + "MOUNTPOINT", "MOVEMENT", "MOVE", "MULTIDIMENSIONAL", "MULTISET", "MV_MERGE", + "NAMED", "NAME", "NAMESPACE", "NAN", "NANVL", "NATIONAL", "NATIVE_FULL_OUTER_JOIN", + "NATIVE", "NATURAL", "NATURALN", "NAV", "NCHAR_CS", "NCHAR", "NCHR", + "NCLOB", "NEEDED", "NEG", "NESTED", "NESTED_TABLE_FAST_INSERT", "NESTED_TABLE_GET_REFS", + "NESTED_TABLE_ID", "NESTED_TABLE_SET_REFS", "NESTED_TABLE_SET_SETID", + "NETWORK", "NEVER", "NEW", "NEW_TIME", "NEXT_DAY", "NEXT", "NL_AJ", + "NLJ_BATCHING", "NLJ_INDEX_FILTER", "NLJ_INDEX_SCAN", "NLJ_PREFETCH", + "NLS_CALENDAR", "NLS_CHARACTERSET", "NLS_CHARSET_DECL_LEN", "NLS_CHARSET_ID", + "NLS_CHARSET_NAME", "NLS_COMP", "NLS_CURRENCY", "NLS_DATE_FORMAT", "NLS_DATE_LANGUAGE", + "NLS_INITCAP", "NLS_ISO_CURRENCY", "NL_SJ", "NLS_LANG", "NLS_LANGUAGE", + "NLS_LENGTH_SEMANTICS", "NLS_LOWER", "NLS_NCHAR_CONV_EXCP", "NLS_NUMERIC_CHARACTERS", + "NLS_SORT", "NLSSORT", "NLS_SPECIAL_CHARS", "NLS_TERRITORY", "NLS_UPPER", + "NO_ACCESS", "NO_ADAPTIVE_PLAN", "NO_ANSI_REARCH", "NOAPPEND", "NOARCHIVELOG", + "NOAUDIT", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", "NO_BATCH_TABLE_ACCESS_BY_ROWID", + "NO_BIND_AWARE", "NO_BUFFER", "NOCACHE", "NO_CARTESIAN", "NO_CHECK_ACL_REWRITE", + "NO_CLUSTER_BY_ROWID", "NO_CLUSTERING", "NO_COALESCE_SQ", "NO_COMMON_DATA", + "NOCOMPRESS", "NO_CONNECT_BY_CB_WHR_ONLY", "NO_CONNECT_BY_COMBINE_SW", + "NO_CONNECT_BY_COST_BASED", "NO_CONNECT_BY_ELIM_DUPS", "NO_CONNECT_BY_FILTERING", + "NOCOPY", "NO_COST_XML_QUERY_REWRITE", "NO_CPU_COSTING", "NOCPU_COSTING", + "NOCYCLE", "NO_DATA_SECURITY_REWRITE", "NO_DECORRELATE", "NODELAY", + "NO_DOMAIN_INDEX_FILTER", "NO_DST_UPGRADE_INSERT_CONV", "NO_ELIM_GROUPBY", + "NO_ELIMINATE_JOIN", "NO_ELIMINATE_OBY", "NO_ELIMINATE_OUTER_JOIN", + "NOENTITYESCAPING", "NO_EXPAND_GSET_TO_UNION", "NO_EXPAND", "NO_EXPAND_TABLE", + "NO_FACT", "NO_FACTORIZE_JOIN", "NO_FILTERING", "NOFORCE", "NO_FULL_OUTER_JOIN_TO_OUTER", + "NO_GATHER_OPTIMIZER_STATISTICS", "NO_GBY_PUSHDOWN", "NOGUARANTEE", + "NO_INDEX_FFS", "NO_INDEX", "NO_INDEX_SS", "NO_INMEMORY", "NO_INMEMORY_PRUNING", + "NOKEEP", "NO_LOAD", "NOLOCAL", "NOLOGGING", "NOMAPPING", "NOMAXVALUE", + "NO_MERGE", "NOMINIMIZE", "NOMINVALUE", "NO_MODEL_PUSH_REF", "NO_MONITORING", + "NOMONITORING", "NO_MONITOR", "NO_MULTIMV_REWRITE", "NO_NATIVE_FULL_OUTER_JOIN", + "NONBLOCKING", "NONEDITIONABLE", "NONE", "NO_NLJ_BATCHING", "NO_NLJ_PREFETCH", + "NO", "NONSCHEMA", "NO_OBJECT_LINK", "NOORDER", "NO_ORDER_ROLLUPS", + "NO_OUTER_JOIN_TO_ANTI", "NO_OUTER_JOIN_TO_INNER", "NOOVERRIDE", "NO_PARALLEL_INDEX", + "NOPARALLEL_INDEX", "NO_PARALLEL", "NOPARALLEL", "NO_PARTIAL_COMMIT", + "NO_PARTIAL_JOIN", "NO_PARTIAL_ROLLUP_PUSHDOWN", "NOPARTITION", "NO_PLACE_DISTINCT", + "NO_PLACE_GROUP_BY", "NO_PQ_CONCURRENT_UNION", "NO_PQ_MAP", "NOPROMPT", + "NO_PQ_REPLICATE", "NO_PQ_SKEW", "NO_PRUNE_GSETS", "NO_PULL_PRED", "NO_PUSH_PRED", + "NO_PUSH_SUBQ", "NO_PX_FAULT_TOLERANCE", "NO_PX_JOIN_FILTER", "NO_QKN_BUFF", + "NO_QUERY_TRANSFORMATION", "NO_REF_CASCADE", "NORELOCATE", "NORELY", + "NOREPAIR", "NOREPLAY", "NORESETLOGS", "NO_RESULT_CACHE", "NOREVERSE", + "NO_REWRITE", "NOREWRITE", "NORMAL", "NO_ROOT_SW_FOR_LOCAL", "NOROWDEPENDENCIES", + "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", + "NOSORT", "NO_SQL_TRANSLATION", "NO_SQL_TUNE", "NO_STAR_TRANSFORMATION", + "NO_STATEMENT_QUEUING", "NO_STATS_GSETS", "NOSTRICT", "NO_SUBQUERY_PRUNING", + "NO_SUBSTRB_PAD", "NO_SWAP_JOIN_INPUTS", "NOSWITCH", "NO_TABLE_LOOKUP_BY_NL", + "NO_TEMP_TABLE", "NOTHING", "NOTIFICATION", "NOT", "NO_TRANSFORM_DISTINCT_AGG", + "NO_UNNEST", "NO_USE_CUBE", "NO_USE_HASH_AGGREGATION", "NO_USE_HASH_GBY_FOR_PUSHDOWN", + "NO_USE_HASH", "NO_USE_INVISIBLE_INDEXES", "NO_USE_MERGE", "NO_USE_NL", + "NO_USE_VECTOR_AGGREGATION", "NOVALIDATE", "NO_VECTOR_TRANSFORM_DIMS", + "NO_VECTOR_TRANSFORM_FACT", "NO_VECTOR_TRANSFORM", "NOWAIT", "NO_XDB_FASTPATH_INSERT", + "NO_XML_DML_REWRITE", "NO_XMLINDEX_REWRITE_IN_SELECT", "NO_XMLINDEX_REWRITE", + "NO_XML_QUERY_REWRITE", "NO_ZONEMAP", "NTH_VALUE", "NULLIF", "NULL_", + "NULLS", "NUMBER", "NUMERIC", "NUM_INDEX_KEYS", "NUMTODSINTERVAL", "NUMTOYMINTERVAL", + "NVARCHAR2", "NVL2", "OBJECT2XML", "OBJECT", "OBJ_ID", "OBJNO", "OBJNO_REUSE", + "OCCURENCES", "OFFLINE", "OFF", "OFFSET", "OF", "OIDINDEX", "OID", "OLAP", + "OLD", "OLD_PUSH_PRED", "OLS", "OLTP", "OMIT", "ONE", "ONLINE", "ONLY", + "ON", "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", + "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", "OPTIMIZER_FEATURES_ENABLE", + "OPTIMIZER_GOAL", "OPTION", "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", + "ORA_CHECK_PRIVILEGE", "ORA_CLUSTERING", "ORADATA", "ORADEBUG", "ORA_DST_AFFECTED", + "ORA_DST_CONVERT", "ORA_DST_ERROR", "ORA_GET_ACLIDS", "ORA_GET_PRIVILEGES", + "ORA_HASH", "ORA_INVOKING_USERID", "ORA_INVOKING_USER", "ORA_INVOKING_XS_USER_GUID", + "ORA_INVOKING_XS_USER", "ORA_RAWCOMPARE", "ORA_RAWCONCAT", "ORA_ROWSCN", + "ORA_ROWSCN_RAW", "ORA_ROWVERSION", "ORA_TABVERSION", "ORA_WRITE_TIME", + "ORDERED", "ORDERED_PREDICATES", "ORDER", "ORDINALITY", "OR_EXPAND", + "ORGANIZATION", "OR", "OR_PREDICATES", "OSERROR", "OTHER", "OUTER_JOIN_TO_ANTI", + "OUTER_JOIN_TO_INNER", "OUTER", "OUTLINE_LEAF", "OUTLINE", "OUT_OF_LINE", + "OUT", "OVERFLOW_NOMOVE", "OVERFLOW", "OVERLAPS", "OVER", "OVERRIDING", + "OWNER", "OWNERSHIP", "OWN", "P_LETTER", "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", + "PARALLEL_INDEX", "PARALLEL", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", + "PARENT_UNIQUE_NAME", "PARITY", "PARTIAL_JOIN", "PARTIALLY", "PARTIAL", + "PARTIAL_ROLLUP_PUSHDOWN", "PARTITION_HASH", "PARTITION_LIST", "PARTITION", + "PARTITION_RANGE", "PARTITIONS", "PARTNUMINST", "PASSING", "PASSWORD_GRACE_TIME", + "PASSWORD_LIFE_TIME", "PASSWORD_LOCK_TIME", "PASSWORD", "PASSWORD_REUSE_MAX", + "PASSWORD_REUSE_TIME", "PASSWORD_ROLLOVER_TIME", "PASSWORD_VERIFY_FUNCTION", + "PAST", "PATCH", "PATH", "PATH_PREFIX", "PATHS", "PATTERN", "PBL_HS_BEGIN", + "PBL_HS_END", "PCTFREE", "PCTINCREASE", "PCTTHRESHOLD", "PCTUSED", "PCTVERSION", + "PENDING", "PERCENT_FOUND", "PERCENT_ISOPEN", "PERCENT_NOTFOUND", "PERCENT_KEYWORD", + "PERCENT_RANKM", "PERCENT_ROWCOUNT", "PERCENT_ROWTYPE", "PERCENT_TYPE", + "PERFORMANCE", "PERIOD_KEYWORD", "PERMANENT", "PERMISSION", "PERMUTE", + "PER", "PFILE", "PHYSICAL", "PIKEY", "PIPELINED", "PIPE", "PIV_GB", + "PIVOT", "PIV_SSF", "PLACE_DISTINCT", "PLACE_GROUP_BY", "PLAN", "PLSCOPE_SETTINGS", + "PLS_INTEGER", "PLSQL_CCFLAGS", "PLSQL_CODE_TYPE", "PLSQL_DEBUG", "PLSQL_OPTIMIZE_LEVEL", + "PLSQL_WARNINGS", "PLUGGABLE", "PMEM", "POINT", "POLICY", "POOL_16K", + "POOL_2K", "POOL_32K", "POOL_4K", "POOL_8K", "POSITIVEN", "POSITIVE", + "POST_TRANSACTION", "POWERMULTISET_BY_CARDINALITY", "POWERMULTISET", + "POWER", "PQ_CONCURRENT_UNION", "PQ_DISTRIBUTE", "PQ_DISTRIBUTE_WINDOW", + "PQ_FILTER", "PQ_MAP", "PQ_NOMAP", "PQ_REPLICATE", "PQ_SKEW", "PRAGMA", + "PREBUILT", "PRECEDES", "PRECEDING", "PRECISION", "PRECOMPUTE_SUBQUERY", + "PREDICATE_REORDERS", "PRELOAD", "PREPARE", "PRESENTNNV", "PRESENT", + "PRESENTV", "PRESERVE_OID", "PRESERVE", "PRETTY", "PREVIOUS", "PREV", + "PRIMARY", "PRINTBLOBTOCLOB", "PRIORITY", "PRIOR", "PRIVATE", "PRIVATE_SGA", + "PRIVILEGED", "PRIVILEGE", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROCESS", "PROFILE", "PROGRAM", "PROJECT", "PROPAGATE", "PROPERTY", + "PROTECTED", "PROTECTION", "PROTOCOL", "PROXY", "PRUNING", "PUBLIC", + "PULL_PRED", "PURGE", "PUSH_PRED", "PUSH_SUBQ", "PX_FAULT_TOLERANCE", + "PX_GRANULE", "PX_JOIN_FILTER", "QB_NAME", "QUARTERS", "QUERY_BLOCK", + "QUERY", "QUEUE_CURR", "QUEUE", "QUEUE_ROWP", "QUIESCE", "QUORUM", "QUOTA", + "QUOTAGROUP", "RAISE", "RANDOM_LOCAL", "RANDOM", "RANGE", "RANKM", "RAPIDLY", + "RAW", "RAWTOHEX", "RAWTONHEX", "RBA", "RBO_OUTLINE", "RDBA", "READ", + "READS", "REALM", "REAL", "REBALANCE", "REBUILD", "RECORD", "RECORDS_PER_BLOCK", + "RECOVERABLE", "RECOVER", "RECOVERY", "RECYCLEBIN", "RECYCLE", "REDACTION", + "REDEFINE", "REDO", "REDUCED", "REDUNDANCY", "REF_CASCADE_CURSOR", "REFERENCED", + "REFERENCE", "REFERENCES", "REFERENCING", "REF", "REFRESH", "REFTOHEX", + "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", "REGEXP_REPLACE", "REGEXP_SUBSTR", + "REGISTER", "REGR_AVGX", "REGR_AVGY", "REGR_COUNT", "REGR_INTERCEPT", + "REGR_R2", "REGR_SLOPE", "REGR_SXX", "REGR_SXY", "REGR_SYY", "REGULAR", + "REJECT", "REKEY", "RELATIONAL", "RELIES_ON", "RELOCATE", "RELY", "REMAINDER", + "REMOTE", "REMOTE_MAPPED", "REMOVE", "RENAME", "REPAIR", "REPEAT", "REPLACE", + "REPLICATION", "REQUIRED", "RESETLOGS", "RESET", "RESIZE", "RESOLVE", + "RESOLVER", "RESOURCE", "RESPECT", "RESTART", "RESTORE_AS_INTERVALS", + "RESTORE", "RESTRICT_ALL_REF_CONS", "RESTRICTED", "RESTRICT_REFERENCES", + "RESTRICT", "RESULT_CACHE", "RESULT", "RESUMABLE", "RESUME", "RETENTION", + "RETRY_ON_ROW_CHANGE", "RETURNING", "RETURN", "REUSE", "REVERSE", "REVOKE", + "REWRITE_OR_ERROR", "REWRITE", "RIGHT", "ROLE", "ROLESET", "ROLES", + "ROLLBACK", "ROLLING", "ROLLUP", "ROWDEPENDENCIES", "ROWID_MAPPING_TABLE", + "ROWID", "ROWIDTOCHAR", "ROWIDTONCHAR", "ROW_LENGTH", "ROWNUM", "ROW", + "ROWS", "RPAD", "RTRIM", "RULE", "RULES", "RUNNING", "SALT", "SAMPLE", + "SAVE_AS_INTERVALS", "SAVEPOINT", "SAVE", "SB4", "SCALE_ROWS", "SCALE", + "SCAN_INSTANCES", "SCAN", "SCHEDULER", "SCHEMACHECK", "SCHEMA", "SCN_ASCENDING", + "SCN", "SCOPE", "SCRUB", "SD_ALL", "SD_INHIBIT", "SDO_GEOM_MBR", "SDO_GEOMETRY", + "SD_SHOW", "SEARCH", "SECOND", "SECONDS", "SECRET", "SECUREFILE_DBA", + "SECUREFILE", "SECURITY", "SEED", "SEG_BLOCK", "SEG_FILE", "SEGMENT", + "SELECTIVITY", "SELECT", "SELF", "SEMIJOIN_DRIVER", "SEMIJOIN", "SEMI_TO_INNER", + "SEQUENCED", "SEQUENCE", "SEQUENTIAL", "SERIALIZABLE", "SERIALLY_REUSABLE", + "SERIAL", "SERVERERROR", "SERVICE_NAME_CONVERT", "SERVICE", "SERVICES", + "SESSION_CACHED_CURSORS", "SESSION", "SESSIONS_PER_USER", "SESSIONTIMEZONE", + "SESSIONTZNAME", "SET", "SETS", "SETTINGS", "SET_TO_JOIN", "SEVERE", + "SHARDSPACE", "SHARED_POOL", "SHARED", "SHARE", "SHARING", "SHELFLIFE", + "SHOW", "SHRINK", "SHUTDOWN", "SIBLINGS", "SID", "SITE", "SIGNAL_COMPONENT", + "SIGNAL_FUNCTION", "SIGN", "SIGNTYPE", "SIMPLE_INTEGER", "SIMPLE", "SINGLE", + "SINGLETASK", "SINH", "SIN", "SIZE", "SKIP_EXT_OPTIMIZER", "SKIP_", + "SKIP_UNQ_UNUSABLE_IDX", "SKIP_UNUSABLE_INDEXES", "SMALLFILE", "SMALLINT", + "SNAPSHOT", "SOME", "SORT", "SOUNDEX", "SOURCE_FILE_DIRECTORY", "SOURCE_FILE_NAME_CONVERT", + "SOURCE", "SPACE_KEYWORD", "SPECIFICATION", "SPFILE", "SPLIT", "SPREADSHEET", + "SQLDATA", "SQLERROR", "SQLLDR", "SQL", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", + "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", + "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTUP", + "STATEMENT_ID", "STATEMENT_QUEUING", "STATEMENTS", "STATEMENT", "STATE", + "STATIC", "STATISTICS", "STATS_BINOMIAL_TEST", "STATS_CROSSTAB", "STATS_F_TEST", + "STATS_KS_TEST", "STATS_MODE", "STATS_MW_TEST", "STATS_ONE_WAY_ANOVA", + "STATS_T_TEST_INDEP", "STATS_T_TEST_INDEPU", "STATS_T_TEST_ONE", "STATS_T_TEST_PAIRED", + "STATS_WSR_TEST", "STDDEV_POP", "STDDEV_SAMP", "STOP", "STORAGE", "STORE", + "STREAMS", "STREAM", "STRICT", "STRING", "STRIPE_COLUMNS", "STRIPE_WIDTH", + "STRIP", "STRUCTURE", "SUBMULTISET", "SUBPARTITION_REL", "SUBPARTITIONS", + "SUBPARTITION", "SUBQUERIES", "SUBQUERY_PRUNING", "SUBSCRIBE", "SUBSET", + "SUBSTITUTABLE", "SUBSTR2", "SUBSTR4", "SUBSTRB", "SUBSTRC", "SUBTYPE", + "SUCCESSFUL", "SUCCESS", "SUMMARY", "SUPPLEMENTAL", "SUSPEND", "SWAP_JOIN_INPUTS", + "SWITCHOVER", "SWITCH", "SYNCHRONOUS", "SYNC", "SYNONYM", "SYS", "SYSASM", + "SYS_AUDIT", "SYSAUX", "SYSBACKUP", "SYS_CHECKACL", "SYS_CHECK_PRIVILEGE", + "SYS_CONNECT_BY_PATH", "SYS_CONTEXT", "SYSDATE", "SYSDBA", "SYS_DBURIGEN", + "SYSDG", "SYS_DL_CURSOR", "SYS_DM_RXFORM_CHR", "SYS_DM_RXFORM_NUM", + "SYS_DOM_COMPARE", "SYS_DST_PRIM2SEC", "SYS_DST_SEC2PRIM", "SYS_ET_BFILE_TO_RAW", + "SYS_ET_BLOB_TO_IMAGE", "SYS_ET_IMAGE_TO_BLOB", "SYS_ET_RAW_TO_BFILE", + "SYS_EXTPDTXT", "SYS_EXTRACT_UTC", "SYS_FBT_INSDEL", "SYS_FILTER_ACLS", + "SYS_FNMATCHES", "SYS_FNREPLACE", "SYS_GET_ACLIDS", "SYS_GET_COL_ACLIDS", + "SYS_GET_PRIVILEGES", "SYS_GETTOKENID", "SYS_GETXTIVAL", "SYS_GUID", + "SYSGUID", "SYSKM", "SYS_MAKE_XMLNODEID", "SYS_MAKEXML", "SYS_MKXMLATTR", + "SYS_MKXTI", "SYSOBJ", "SYS_OP_ADT2BIN", "SYS_OP_ADTCONS", "SYS_OP_ALSCRVAL", + "SYS_OP_ATG", "SYS_OP_BIN2ADT", "SYS_OP_BITVEC", "SYS_OP_BL2R", "SYS_OP_BLOOM_FILTER_LIST", + "SYS_OP_BLOOM_FILTER", "SYS_OP_C2C", "SYS_OP_CAST", "SYS_OP_CEG", "SYS_OP_CL2C", + "SYS_OP_COMBINED_HASH", "SYS_OP_COMP", "SYS_OP_CONVERT", "SYS_OP_COUNTCHG", + "SYS_OP_CSCONV", "SYS_OP_CSCONVTEST", "SYS_OP_CSR", "SYS_OP_CSX_PATCH", + "SYS_OP_CYCLED_SEQ", "SYS_OP_DECOMP", "SYS_OP_DESCEND", "SYS_OP_DISTINCT", + "SYS_OP_DRA", "SYS_OP_DUMP", "SYS_OP_DV_CHECK", "SYS_OP_ENFORCE_NOT_NULL", + "SYSOPER", "SYS_OP_EXTRACT", "SYS_OP_GROUPING", "SYS_OP_GUID", "SYS_OP_HASH", + "SYS_OP_IIX", "SYS_OP_ITR", "SYS_OP_KEY_VECTOR_CREATE", "SYS_OP_KEY_VECTOR_FILTER_LIST", + "SYS_OP_KEY_VECTOR_FILTER", "SYS_OP_KEY_VECTOR_SUCCEEDED", "SYS_OP_KEY_VECTOR_USE", + "SYS_OP_LBID", "SYS_OP_LOBLOC2BLOB", "SYS_OP_LOBLOC2CLOB", "SYS_OP_LOBLOC2ID", + "SYS_OP_LOBLOC2NCLOB", "SYS_OP_LOBLOC2TYP", "SYS_OP_LSVI", "SYS_OP_LVL", + "SYS_OP_MAKEOID", "SYS_OP_MAP_NONNULL", "SYS_OP_MSR", "SYS_OP_NICOMBINE", + "SYS_OP_NIEXTRACT", "SYS_OP_NII", "SYS_OP_NIX", "SYS_OP_NOEXPAND", "SYS_OP_NTCIMG", + "SYS_OP_NUMTORAW", "SYS_OP_OIDVALUE", "SYS_OP_OPNSIZE", "SYS_OP_PAR_1", + "SYS_OP_PARGID_1", "SYS_OP_PARGID", "SYS_OP_PAR", "SYS_OP_PART_ID", + "SYS_OP_PIVOT", "SYS_OP_R2O", "SYS_OP_RAWTONUM", "SYS_OP_RDTM", "SYS_OP_REF", + "SYS_OP_RMTD", "SYS_OP_ROWIDTOOBJ", "SYS_OP_RPB", "SYS_OPTLOBPRBSC", + "SYS_OP_TOSETID", "SYS_OP_TPR", "SYS_OP_TRTB", "SYS_OPTXICMP", "SYS_OPTXQCASTASNQ", + "SYS_OP_UNDESCEND", "SYS_OP_VECAND", "SYS_OP_VECBIT", "SYS_OP_VECOR", + "SYS_OP_VECXOR", "SYS_OP_VERSION", "SYS_OP_VREF", "SYS_OP_VVD", "SYS_OP_XMLCONS_FOR_CSX", + "SYS_OP_XPTHATG", "SYS_OP_XPTHIDX", "SYS_OP_XPTHOP", "SYS_OP_XTXT2SQLT", + "SYS_OP_ZONE_ID", "SYS_ORDERKEY_DEPTH", "SYS_ORDERKEY_MAXCHILD", "SYS_ORDERKEY_PARENT", + "SYS_PARALLEL_TXN", "SYS_PATHID_IS_ATTR", "SYS_PATHID_IS_NMSPC", "SYS_PATHID_LASTNAME", + "SYS_PATHID_LASTNMSPC", "SYS_PATH_REVERSE", "SYS_PXQEXTRACT", "SYS_RAW_TO_XSID", + "SYS_RID_ORDER", "SYS_ROW_DELTA", "SYS_SC_2_XMLT", "SYS_SYNRCIREDO", + "SYSTEM_DEFINED", "SYSTEM", "SYSTIMESTAMP", "SYS_TYPEID", "SYS_UMAKEXML", + "SYS_XMLANALYZE", "SYS_XMLCONTAINS", "SYS_XMLCONV", "SYS_XMLEXNSURI", + "SYS_XMLGEN", "SYS_XMLI_LOC_ISNODE", "SYS_XMLI_LOC_ISTEXT", "SYS_XMLINSTR", + "SYS_XMLLOCATOR_GETSVAL", "SYS_XMLNODEID_GETCID", "SYS_XMLNODEID_GETLOCATOR", + "SYS_XMLNODEID_GETOKEY", "SYS_XMLNODEID_GETPATHID", "SYS_XMLNODEID_GETPTRID", + "SYS_XMLNODEID_GETRID", "SYS_XMLNODEID_GETSVAL", "SYS_XMLNODEID_GETTID", + "SYS_XMLNODEID", "SYS_XMLT_2_SC", "SYS_XMLTRANSLATE", "SYS_XMLTYPE2SQL", + "SYS_XQ_ASQLCNV", "SYS_XQ_ATOMCNVCHK", "SYS_XQBASEURI", "SYS_XQCASTABLEERRH", + "SYS_XQCODEP2STR", "SYS_XQCODEPEQ", "SYS_XQCON2SEQ", "SYS_XQCONCAT", + "SYS_XQDELETE", "SYS_XQDFLTCOLATION", "SYS_XQDOC", "SYS_XQDOCURI", "SYS_XQDURDIV", + "SYS_XQED4URI", "SYS_XQENDSWITH", "SYS_XQERRH", "SYS_XQERR", "SYS_XQESHTMLURI", + "SYS_XQEXLOBVAL", "SYS_XQEXSTWRP", "SYS_XQEXTRACT", "SYS_XQEXTRREF", + "SYS_XQEXVAL", "SYS_XQFB2STR", "SYS_XQFNBOOL", "SYS_XQFNCMP", "SYS_XQFNDATIM", + "SYS_XQFNLNAME", "SYS_XQFNNM", "SYS_XQFNNSURI", "SYS_XQFNPREDTRUTH", + "SYS_XQFNQNM", "SYS_XQFNROOT", "SYS_XQFORMATNUM", "SYS_XQFTCONTAIN", + "SYS_XQFUNCR", "SYS_XQGETCONTENT", "SYS_XQINDXOF", "SYS_XQINSERT", "SYS_XQINSPFX", + "SYS_XQIRI2URI", "SYS_XQLANG", "SYS_XQLLNMFRMQNM", "SYS_XQMKNODEREF", + "SYS_XQNILLED", "SYS_XQNODENAME", "SYS_XQNORMSPACE", "SYS_XQNORMUCODE", + "SYS_XQ_NRNG", "SYS_XQNSP4PFX", "SYS_XQNSPFRMQNM", "SYS_XQPFXFRMQNM", + "SYS_XQ_PKSQL2XML", "SYS_XQPOLYABS", "SYS_XQPOLYADD", "SYS_XQPOLYCEL", + "SYS_XQPOLYCSTBL", "SYS_XQPOLYCST", "SYS_XQPOLYDIV", "SYS_XQPOLYFLR", + "SYS_XQPOLYMOD", "SYS_XQPOLYMUL", "SYS_XQPOLYRND", "SYS_XQPOLYSQRT", + "SYS_XQPOLYSUB", "SYS_XQPOLYUMUS", "SYS_XQPOLYUPLS", "SYS_XQPOLYVEQ", + "SYS_XQPOLYVGE", "SYS_XQPOLYVGT", "SYS_XQPOLYVLE", "SYS_XQPOLYVLT", + "SYS_XQPOLYVNE", "SYS_XQREF2VAL", "SYS_XQRENAME", "SYS_XQREPLACE", "SYS_XQRESVURI", + "SYS_XQRNDHALF2EVN", "SYS_XQRSLVQNM", "SYS_XQRYENVPGET", "SYS_XQRYVARGET", + "SYS_XQRYWRP", "SYS_XQSEQ2CON4XC", "SYS_XQSEQ2CON", "SYS_XQSEQDEEPEQ", + "SYS_XQSEQINSB", "SYS_XQSEQRM", "SYS_XQSEQRVS", "SYS_XQSEQSUB", "SYS_XQSEQTYPMATCH", + "SYS_XQSTARTSWITH", "SYS_XQSTATBURI", "SYS_XQSTR2CODEP", "SYS_XQSTRJOIN", + "SYS_XQSUBSTRAFT", "SYS_XQSUBSTRBEF", "SYS_XQTOKENIZE", "SYS_XQTREATAS", + "SYS_XQ_UPKXML2SQL", "SYS_XQXFORM", "SYS_XSID_TO_RAW", "SYS_ZMAP_FILTER", + "SYS_ZMAP_REFRESH", "T_LETTER", "TABLE_LOOKUP_BY_NL", "TABLESPACE_NO", + "TABLESPACE", "TABLES", "TABLE_STATS", "TABLE", "TABNO", "TAG", "TANH", + "TAN", "TBLORIDXPARTNUM", "TEMPFILE", "TEMPLATE", "TEMPORARY", "TEMP_TABLE", + "TEST", "TEXT", "THAN", "THEN", "THE", "THREAD", "THROUGH", "TIER", + "TIES", "TIMEOUT", "TIMESTAMP_LTZ_UNCONSTRAINED", "TIMESTAMP", "TIMESTAMP_TZ_UNCONSTRAINED", + "TIMESTAMP_UNCONSTRAINED", "TIMES", "TIME", "TIMEZONE", "TIMEZONE_ABBR", + "TIMEZONE_HOUR", "TIMEZONE_MINUTE", "TIMEZONE_OFFSET", "TIMEZONE_REGION", + "TIME_ZONE", "TIMING", "TIV_GB", "TIV_SSF", "TO_ACLID", "TO_BINARY_DOUBLE", + "TO_BINARY_FLOAT", "TO_BLOB", "TO_CLOB", "TO_DSINTERVAL", "TO_LOB", + "TO_MULTI_BYTE", "TO_NCHAR", "TO_NCLOB", "TO_NUMBER", "TOPLEVEL", "TO_SINGLE_BYTE", + "TO_TIMESTAMP", "TO_TIMESTAMP_TZ", "TO_TIME", "TO_TIME_TZ", "TO", "TO_YMINTERVAL", + "TRACE", "TRACING", "TRACKING", "TRAILING", "TRANSACTION", "TRANSFORM", + "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", + "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", "TRUNC", + "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", "UB2", + "UBA", "UCS2", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", "UNCONDITIONAL", + "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", "UNIQUE", "UNISTR", "UNLIMITED", + "UNLOAD", "UNLOCK", "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", + "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", "UNPROTECTED", + "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSUBSCRIBE", "UNTIL", + "UNUSABLE", "UNUSED", "UPDATABLE", "UPDATED", "UPDATE", "UPDATEXML", + "UPD_INDEXES", "UPD_JOININDEX", "UPGRADE", "UPPER", "UPSERT", "UROWID", + "USABLE", "USAGE", "USE_ANTI", "USE_CONCAT", "USE_CUBE", "USE_HASH_AGGREGATION", + "USE_HASH_GBY_FOR_PUSHDOWN", "USE_HASH", "USE_HIDDEN_PARTITIONS", "USE_INVISIBLE_INDEXES", + "USE_MERGE_CARTESIAN", "USE_MERGE", "USE_NL", "USE_NL_WITH_INDEX", "USE_PRIVATE_OUTLINES", + "USER_DATA", "USER_DEFINED", "USERENV", "USERGROUP", "USER_RECYCLEBIN", + "USERS", "USER_TABLESPACES", "USER", "USE_SEMI", "USE_STORED_OUTLINES", + "USE_TTT_FOR_GSETS", "USE", "USE_VECTOR_AGGREGATION", "USE_WEAK_NAME_RESL", + "USING_NO_EXPAND", "USING", "UTF16BE", "UTF16LE", "UTF32", "UTF8", "V1", + "V2", "VALIDATE", "VALIDATE_CONVERSION", "VALIDATION", "VALID_TIME_END", + "VALUES", "VALUE", "VARCHAR2", "VARCHAR", "VARIABLE", "VAR_POP", "VARRAYS", + "VARRAY", "VAR_SAMP", "VARYING", "VECTOR_READ_TRACE", "VECTOR_READ", + "VECTOR_TRANSFORM_DIMS", "VECTOR_TRANSFORM_FACT", "VECTOR_TRANSFORM", + "VERIFIER", "VERIFY", "VERSIONING", "VERSIONS_ENDSCN", "VERSIONS_ENDTIME", + "VERSIONS_OPERATION", "VERSIONS_STARTSCN", "VERSIONS_STARTTIME", "VERSIONS", + "VERSIONS_XID", "VERSION", "VIEW", "VIOLATION", "VIRTUAL", "VISIBILITY", + "VISIBLE", "VOLUME", "VSIZE", "WAIT", "WALLET", "WARNING", "WEEKS", + "WEEK", "WELLFORMED", "WHENEVER", "WHEN", "WHERE", "WHILE", "WHITESPACE", + "WIDTH_BUCKET", "WITHIN", "WITHOUT", "WITH_PLSQL", "WITH", "WORK", "WRAPPED", + "WRAPPER", "WRITE", "XDB_FASTPATH_INSERT", "XDB", "X_DYN_PRUNE", "XID", + "XML2OBJECT", "XMLAGG", "XMLATTRIBUTES", "XMLCAST", "XMLCDATA", "XMLCOLATTVAL", + "XMLCOMMENT", "XMLCONCAT", "XMLDIFF", "XML_DML_RWT_STMT", "XMLELEMENT", + "XMLEXISTS2", "XMLEXISTS", "XMLFOREST", "XMLINDEX", "XMLINDEX_REWRITE_IN_SELECT", + "XMLINDEX_REWRITE", "XMLINDEX_SEL_IDX_TBL", "XMLISNODE", "XMLISVALID", + "XMLNAMESPACES", "XMLPARSE", "XMLPATCH", "XMLPI", "XMLQUERYVAL", "XMLQUERY", + "XMLROOT", "XMLSCHEMA", "XMLSERIALIZE", "XMLTABLE", "XMLTRANSFORMBLOB", + "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", "XS", + "YEARS", "YEAR", "YES", "YMINTERVAL_UNCONSTRAINED", "ZONEMAP", "ZONE", + "PREDICTION", "PREDICTION_BOUNDS", "PREDICTION_COST", "PREDICTION_DETAILS", + "PREDICTION_PROBABILITY", "PREDICTION_SET", "BLOCKCHAIN", "COLLATE", + "COLLATION", "DEFINITION", "DUPLICATED", "EXTENDED", "HASHING", "IDLE", + "IMMUTABLE", "ORACLE_DATAPUMP", "ORACLE_HDFS", "ORACLE_HIVE", "ORACLE_LOADER", + "SHA2_512_Q", "SHARDED", "V1_Q", "ISOLATE", "ROOT", "UNITE", "ALGORITHM", + "CUME_DIST", "DENSE_RANK", "LISTAGG", "PERCENT_RANK", "PERCENTILE_CONT", + "PERCENTILE_DISC", "RANK", "AVG", "CORR", "COVAR_", "DECODE", "LAG", + "LAG_DIFF", "LAG_DIFF_PERCENT", "LEAD", "MAX", "MEDIAN", "MEMOPTIMIZE", + "MIN", "NTILE", "NVL", "RATIO_TO_REPORT", "REGR_", "ROUND", "ROW_NUMBER", + "SUBSTR", "TO_CHAR", "TRIM", "SUM", "STDDEV", "VAR_", "VARIANCE", "LEAST", + "GREATEST", "TO_DATE", "DEFAULTIF", "LLS", "ENCLOSED", "TERMINATED", + "OPTIONALLY", "LRTRIM", "NOTRIM", "LDRTRIM", "DATE_FORMAT", "MASK", + "TRANSFORMS", "LOBFILE", "STARTOF", "CHARACTERSET", "RECORDS", "FIXED", + "DELIMITED", "XMLTAG", "PREPROCESSOR", "TERRITORY", "LITTLE", "BIG", + "ENDIAN", "BYTEORDERMARK", "NOCHECK", "SIZES", "ARE", "BYTES", "CHARACTERS", + "READSIZE", "DISABLE_DIRECTORY_LINK_CHECK", "DATE_CACHE", "FIELD_NAMES", + "FILES", "IO_OPTIONS", "DIRECTIO", "NODIRECTIO", "DNFS_ENABLE", "DNFS_DISABLE", + "DNFS_READBUFFERS", "NOBADFILE", "BADFILE", "NODISCARDFILE", "DISCARDFILE", + "NOLOGFILE", "FIELDS", "IGNORE_CHARS_AFTER_EOR", "CSV", "EMBEDDED", + "OVERRIDE", "THESE", "FIELD", "NONULLIF", "POSITION", "NEWLINE_", "DETECTED", + "UNSIGNED", "ZONED", "ORACLE_DATE", "ORACLE_NUMBER", "COUNTED", "VARRAW", + "VARCHARC", "VARRAWC", "NATIONAL_CHAR_STRING_LIT", "BIT_STRING_LIT", + "HEX_STRING_LIT", "DOUBLE_PERIOD", "PERIOD", "UNSIGNED_INTEGER", "APPROXIMATE_NUM_LIT", + "CHAR_STRING", "CHAR_STRING_PERL", "QS_ANGLE", "QS_BRACE", "QS_BRACK", + "QS_PAREN", "QS_EXCLAM", "QS_SHARP", "QS_QUOTE", "QS_DQUOTE", "QS_BACKSLASH", + "QS_AMPERSAND", "QS_ATSIGN", "QS_BACKTICK", "QS_CARET", "QS_COLON", + "QS_COMMA", "QS_ASTERISK", "QS_DOLLAR", "QS_EQUAL", "QS_MINUS", "QS_PERCENT", + "QS_PLUS", "QS_PERIOD", "QS_SEMICOLON", "QS_SLASH", "QS_UNDERSCORE", + "QS_PIPE", "QS_TILDE", "QS_QUESTION", "DELIMITED_ID", "PERCENT", "AMPERSAND", + "LEFT_PAREN", "RIGHT_PAREN", "DOUBLE_ASTERISK", "ASTERISK", "PLUS_SIGN", + "MINUS_SIGN", "COMMA", "SOLIDUS", "AT_SIGN", "ASSIGN_OP", "HASH_OP", + "SQ", "BINDVAR", "NOT_EQUAL_OP", "CARRET_OPERATOR_PART", "TILDE_OPERATOR_PART", + "EXCLAMATION_OPERATOR_PART", "GREATER_THAN_OP", "LESS_THAN_OP", "COLON", + "SEMICOLON", "BAR", "EQUALS_OP", "LEFT_BRACKET", "RIGHT_BRACKET", "INTRODUCER", + "SINGLE_LINE_COMMENT", "MULTI_LINE_COMMENT", "REMARK_COMMENT", "PROMPT_MESSAGE", + "START_CMD", "REGULAR_ID", "SPACES", "NEWLINE_EOF", "QUESTION_MARK", + "SIMPLE_LETTER", "FLOAT_FRAGMENT", "NEWLINE", "SPACE", "FULL_WIDTH_LETTER", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 0, 2408, 31783, 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, 2, 1125, 7, 1125, 2, 1126, 7, 1126, 2, 1127, + 7, 1127, 2, 1128, 7, 1128, 2, 1129, 7, 1129, 2, 1130, 7, 1130, 2, 1131, + 7, 1131, 2, 1132, 7, 1132, 2, 1133, 7, 1133, 2, 1134, 7, 1134, 2, 1135, + 7, 1135, 2, 1136, 7, 1136, 2, 1137, 7, 1137, 2, 1138, 7, 1138, 2, 1139, + 7, 1139, 2, 1140, 7, 1140, 2, 1141, 7, 1141, 2, 1142, 7, 1142, 2, 1143, + 7, 1143, 2, 1144, 7, 1144, 2, 1145, 7, 1145, 2, 1146, 7, 1146, 2, 1147, + 7, 1147, 2, 1148, 7, 1148, 2, 1149, 7, 1149, 2, 1150, 7, 1150, 2, 1151, + 7, 1151, 2, 1152, 7, 1152, 2, 1153, 7, 1153, 2, 1154, 7, 1154, 2, 1155, + 7, 1155, 2, 1156, 7, 1156, 2, 1157, 7, 1157, 2, 1158, 7, 1158, 2, 1159, + 7, 1159, 2, 1160, 7, 1160, 2, 1161, 7, 1161, 2, 1162, 7, 1162, 2, 1163, + 7, 1163, 2, 1164, 7, 1164, 2, 1165, 7, 1165, 2, 1166, 7, 1166, 2, 1167, + 7, 1167, 2, 1168, 7, 1168, 2, 1169, 7, 1169, 2, 1170, 7, 1170, 2, 1171, + 7, 1171, 2, 1172, 7, 1172, 2, 1173, 7, 1173, 2, 1174, 7, 1174, 2, 1175, + 7, 1175, 2, 1176, 7, 1176, 2, 1177, 7, 1177, 2, 1178, 7, 1178, 2, 1179, + 7, 1179, 2, 1180, 7, 1180, 2, 1181, 7, 1181, 2, 1182, 7, 1182, 2, 1183, + 7, 1183, 2, 1184, 7, 1184, 2, 1185, 7, 1185, 2, 1186, 7, 1186, 2, 1187, + 7, 1187, 2, 1188, 7, 1188, 2, 1189, 7, 1189, 2, 1190, 7, 1190, 2, 1191, + 7, 1191, 2, 1192, 7, 1192, 2, 1193, 7, 1193, 2, 1194, 7, 1194, 2, 1195, + 7, 1195, 2, 1196, 7, 1196, 2, 1197, 7, 1197, 2, 1198, 7, 1198, 2, 1199, + 7, 1199, 2, 1200, 7, 1200, 2, 1201, 7, 1201, 2, 1202, 7, 1202, 2, 1203, + 7, 1203, 2, 1204, 7, 1204, 2, 1205, 7, 1205, 2, 1206, 7, 1206, 2, 1207, + 7, 1207, 2, 1208, 7, 1208, 2, 1209, 7, 1209, 2, 1210, 7, 1210, 2, 1211, + 7, 1211, 2, 1212, 7, 1212, 2, 1213, 7, 1213, 2, 1214, 7, 1214, 2, 1215, + 7, 1215, 2, 1216, 7, 1216, 2, 1217, 7, 1217, 2, 1218, 7, 1218, 2, 1219, + 7, 1219, 2, 1220, 7, 1220, 2, 1221, 7, 1221, 2, 1222, 7, 1222, 2, 1223, + 7, 1223, 2, 1224, 7, 1224, 2, 1225, 7, 1225, 2, 1226, 7, 1226, 2, 1227, + 7, 1227, 2, 1228, 7, 1228, 2, 1229, 7, 1229, 2, 1230, 7, 1230, 2, 1231, + 7, 1231, 2, 1232, 7, 1232, 2, 1233, 7, 1233, 2, 1234, 7, 1234, 2, 1235, + 7, 1235, 2, 1236, 7, 1236, 2, 1237, 7, 1237, 2, 1238, 7, 1238, 2, 1239, + 7, 1239, 2, 1240, 7, 1240, 2, 1241, 7, 1241, 2, 1242, 7, 1242, 2, 1243, + 7, 1243, 2, 1244, 7, 1244, 2, 1245, 7, 1245, 2, 1246, 7, 1246, 2, 1247, + 7, 1247, 2, 1248, 7, 1248, 2, 1249, 7, 1249, 2, 1250, 7, 1250, 2, 1251, + 7, 1251, 2, 1252, 7, 1252, 2, 1253, 7, 1253, 2, 1254, 7, 1254, 2, 1255, + 7, 1255, 2, 1256, 7, 1256, 2, 1257, 7, 1257, 2, 1258, 7, 1258, 2, 1259, + 7, 1259, 2, 1260, 7, 1260, 2, 1261, 7, 1261, 2, 1262, 7, 1262, 2, 1263, + 7, 1263, 2, 1264, 7, 1264, 2, 1265, 7, 1265, 2, 1266, 7, 1266, 2, 1267, + 7, 1267, 2, 1268, 7, 1268, 2, 1269, 7, 1269, 2, 1270, 7, 1270, 2, 1271, + 7, 1271, 2, 1272, 7, 1272, 2, 1273, 7, 1273, 2, 1274, 7, 1274, 2, 1275, + 7, 1275, 2, 1276, 7, 1276, 2, 1277, 7, 1277, 2, 1278, 7, 1278, 2, 1279, + 7, 1279, 2, 1280, 7, 1280, 2, 1281, 7, 1281, 2, 1282, 7, 1282, 2, 1283, + 7, 1283, 2, 1284, 7, 1284, 2, 1285, 7, 1285, 2, 1286, 7, 1286, 2, 1287, + 7, 1287, 2, 1288, 7, 1288, 2, 1289, 7, 1289, 2, 1290, 7, 1290, 2, 1291, + 7, 1291, 2, 1292, 7, 1292, 2, 1293, 7, 1293, 2, 1294, 7, 1294, 2, 1295, + 7, 1295, 2, 1296, 7, 1296, 2, 1297, 7, 1297, 2, 1298, 7, 1298, 2, 1299, + 7, 1299, 2, 1300, 7, 1300, 2, 1301, 7, 1301, 2, 1302, 7, 1302, 2, 1303, + 7, 1303, 2, 1304, 7, 1304, 2, 1305, 7, 1305, 2, 1306, 7, 1306, 2, 1307, + 7, 1307, 2, 1308, 7, 1308, 2, 1309, 7, 1309, 2, 1310, 7, 1310, 2, 1311, + 7, 1311, 2, 1312, 7, 1312, 2, 1313, 7, 1313, 2, 1314, 7, 1314, 2, 1315, + 7, 1315, 2, 1316, 7, 1316, 2, 1317, 7, 1317, 2, 1318, 7, 1318, 2, 1319, + 7, 1319, 2, 1320, 7, 1320, 2, 1321, 7, 1321, 2, 1322, 7, 1322, 2, 1323, + 7, 1323, 2, 1324, 7, 1324, 2, 1325, 7, 1325, 2, 1326, 7, 1326, 2, 1327, + 7, 1327, 2, 1328, 7, 1328, 2, 1329, 7, 1329, 2, 1330, 7, 1330, 2, 1331, + 7, 1331, 2, 1332, 7, 1332, 2, 1333, 7, 1333, 2, 1334, 7, 1334, 2, 1335, + 7, 1335, 2, 1336, 7, 1336, 2, 1337, 7, 1337, 2, 1338, 7, 1338, 2, 1339, + 7, 1339, 2, 1340, 7, 1340, 2, 1341, 7, 1341, 2, 1342, 7, 1342, 2, 1343, + 7, 1343, 2, 1344, 7, 1344, 2, 1345, 7, 1345, 2, 1346, 7, 1346, 2, 1347, + 7, 1347, 2, 1348, 7, 1348, 2, 1349, 7, 1349, 2, 1350, 7, 1350, 2, 1351, + 7, 1351, 2, 1352, 7, 1352, 2, 1353, 7, 1353, 2, 1354, 7, 1354, 2, 1355, + 7, 1355, 2, 1356, 7, 1356, 2, 1357, 7, 1357, 2, 1358, 7, 1358, 2, 1359, + 7, 1359, 2, 1360, 7, 1360, 2, 1361, 7, 1361, 2, 1362, 7, 1362, 2, 1363, + 7, 1363, 2, 1364, 7, 1364, 2, 1365, 7, 1365, 2, 1366, 7, 1366, 2, 1367, + 7, 1367, 2, 1368, 7, 1368, 2, 1369, 7, 1369, 2, 1370, 7, 1370, 2, 1371, + 7, 1371, 2, 1372, 7, 1372, 2, 1373, 7, 1373, 2, 1374, 7, 1374, 2, 1375, + 7, 1375, 2, 1376, 7, 1376, 2, 1377, 7, 1377, 2, 1378, 7, 1378, 2, 1379, + 7, 1379, 2, 1380, 7, 1380, 2, 1381, 7, 1381, 2, 1382, 7, 1382, 2, 1383, + 7, 1383, 2, 1384, 7, 1384, 2, 1385, 7, 1385, 2, 1386, 7, 1386, 2, 1387, + 7, 1387, 2, 1388, 7, 1388, 2, 1389, 7, 1389, 2, 1390, 7, 1390, 2, 1391, + 7, 1391, 2, 1392, 7, 1392, 2, 1393, 7, 1393, 2, 1394, 7, 1394, 2, 1395, + 7, 1395, 2, 1396, 7, 1396, 2, 1397, 7, 1397, 2, 1398, 7, 1398, 2, 1399, + 7, 1399, 2, 1400, 7, 1400, 2, 1401, 7, 1401, 2, 1402, 7, 1402, 2, 1403, + 7, 1403, 2, 1404, 7, 1404, 2, 1405, 7, 1405, 2, 1406, 7, 1406, 2, 1407, + 7, 1407, 2, 1408, 7, 1408, 2, 1409, 7, 1409, 2, 1410, 7, 1410, 2, 1411, + 7, 1411, 2, 1412, 7, 1412, 2, 1413, 7, 1413, 2, 1414, 7, 1414, 2, 1415, + 7, 1415, 2, 1416, 7, 1416, 2, 1417, 7, 1417, 2, 1418, 7, 1418, 2, 1419, + 7, 1419, 2, 1420, 7, 1420, 2, 1421, 7, 1421, 2, 1422, 7, 1422, 2, 1423, + 7, 1423, 2, 1424, 7, 1424, 2, 1425, 7, 1425, 2, 1426, 7, 1426, 2, 1427, + 7, 1427, 2, 1428, 7, 1428, 2, 1429, 7, 1429, 2, 1430, 7, 1430, 2, 1431, + 7, 1431, 2, 1432, 7, 1432, 2, 1433, 7, 1433, 2, 1434, 7, 1434, 2, 1435, + 7, 1435, 2, 1436, 7, 1436, 2, 1437, 7, 1437, 2, 1438, 7, 1438, 2, 1439, + 7, 1439, 2, 1440, 7, 1440, 2, 1441, 7, 1441, 2, 1442, 7, 1442, 2, 1443, + 7, 1443, 2, 1444, 7, 1444, 2, 1445, 7, 1445, 2, 1446, 7, 1446, 2, 1447, + 7, 1447, 2, 1448, 7, 1448, 2, 1449, 7, 1449, 2, 1450, 7, 1450, 2, 1451, + 7, 1451, 2, 1452, 7, 1452, 2, 1453, 7, 1453, 2, 1454, 7, 1454, 2, 1455, + 7, 1455, 2, 1456, 7, 1456, 2, 1457, 7, 1457, 2, 1458, 7, 1458, 2, 1459, + 7, 1459, 2, 1460, 7, 1460, 2, 1461, 7, 1461, 2, 1462, 7, 1462, 2, 1463, + 7, 1463, 2, 1464, 7, 1464, 2, 1465, 7, 1465, 2, 1466, 7, 1466, 2, 1467, + 7, 1467, 2, 1468, 7, 1468, 2, 1469, 7, 1469, 2, 1470, 7, 1470, 2, 1471, + 7, 1471, 2, 1472, 7, 1472, 2, 1473, 7, 1473, 2, 1474, 7, 1474, 2, 1475, + 7, 1475, 2, 1476, 7, 1476, 2, 1477, 7, 1477, 2, 1478, 7, 1478, 2, 1479, + 7, 1479, 2, 1480, 7, 1480, 2, 1481, 7, 1481, 2, 1482, 7, 1482, 2, 1483, + 7, 1483, 2, 1484, 7, 1484, 2, 1485, 7, 1485, 2, 1486, 7, 1486, 2, 1487, + 7, 1487, 2, 1488, 7, 1488, 2, 1489, 7, 1489, 2, 1490, 7, 1490, 2, 1491, + 7, 1491, 2, 1492, 7, 1492, 2, 1493, 7, 1493, 2, 1494, 7, 1494, 2, 1495, + 7, 1495, 2, 1496, 7, 1496, 2, 1497, 7, 1497, 2, 1498, 7, 1498, 2, 1499, + 7, 1499, 2, 1500, 7, 1500, 2, 1501, 7, 1501, 2, 1502, 7, 1502, 2, 1503, + 7, 1503, 2, 1504, 7, 1504, 2, 1505, 7, 1505, 2, 1506, 7, 1506, 2, 1507, + 7, 1507, 2, 1508, 7, 1508, 2, 1509, 7, 1509, 2, 1510, 7, 1510, 2, 1511, + 7, 1511, 2, 1512, 7, 1512, 2, 1513, 7, 1513, 2, 1514, 7, 1514, 2, 1515, + 7, 1515, 2, 1516, 7, 1516, 2, 1517, 7, 1517, 2, 1518, 7, 1518, 2, 1519, + 7, 1519, 2, 1520, 7, 1520, 2, 1521, 7, 1521, 2, 1522, 7, 1522, 2, 1523, + 7, 1523, 2, 1524, 7, 1524, 2, 1525, 7, 1525, 2, 1526, 7, 1526, 2, 1527, + 7, 1527, 2, 1528, 7, 1528, 2, 1529, 7, 1529, 2, 1530, 7, 1530, 2, 1531, + 7, 1531, 2, 1532, 7, 1532, 2, 1533, 7, 1533, 2, 1534, 7, 1534, 2, 1535, + 7, 1535, 2, 1536, 7, 1536, 2, 1537, 7, 1537, 2, 1538, 7, 1538, 2, 1539, + 7, 1539, 2, 1540, 7, 1540, 2, 1541, 7, 1541, 2, 1542, 7, 1542, 2, 1543, + 7, 1543, 2, 1544, 7, 1544, 2, 1545, 7, 1545, 2, 1546, 7, 1546, 2, 1547, + 7, 1547, 2, 1548, 7, 1548, 2, 1549, 7, 1549, 2, 1550, 7, 1550, 2, 1551, + 7, 1551, 2, 1552, 7, 1552, 2, 1553, 7, 1553, 2, 1554, 7, 1554, 2, 1555, + 7, 1555, 2, 1556, 7, 1556, 2, 1557, 7, 1557, 2, 1558, 7, 1558, 2, 1559, + 7, 1559, 2, 1560, 7, 1560, 2, 1561, 7, 1561, 2, 1562, 7, 1562, 2, 1563, + 7, 1563, 2, 1564, 7, 1564, 2, 1565, 7, 1565, 2, 1566, 7, 1566, 2, 1567, + 7, 1567, 2, 1568, 7, 1568, 2, 1569, 7, 1569, 2, 1570, 7, 1570, 2, 1571, + 7, 1571, 2, 1572, 7, 1572, 2, 1573, 7, 1573, 2, 1574, 7, 1574, 2, 1575, + 7, 1575, 2, 1576, 7, 1576, 2, 1577, 7, 1577, 2, 1578, 7, 1578, 2, 1579, + 7, 1579, 2, 1580, 7, 1580, 2, 1581, 7, 1581, 2, 1582, 7, 1582, 2, 1583, + 7, 1583, 2, 1584, 7, 1584, 2, 1585, 7, 1585, 2, 1586, 7, 1586, 2, 1587, + 7, 1587, 2, 1588, 7, 1588, 2, 1589, 7, 1589, 2, 1590, 7, 1590, 2, 1591, + 7, 1591, 2, 1592, 7, 1592, 2, 1593, 7, 1593, 2, 1594, 7, 1594, 2, 1595, + 7, 1595, 2, 1596, 7, 1596, 2, 1597, 7, 1597, 2, 1598, 7, 1598, 2, 1599, + 7, 1599, 2, 1600, 7, 1600, 2, 1601, 7, 1601, 2, 1602, 7, 1602, 2, 1603, + 7, 1603, 2, 1604, 7, 1604, 2, 1605, 7, 1605, 2, 1606, 7, 1606, 2, 1607, + 7, 1607, 2, 1608, 7, 1608, 2, 1609, 7, 1609, 2, 1610, 7, 1610, 2, 1611, + 7, 1611, 2, 1612, 7, 1612, 2, 1613, 7, 1613, 2, 1614, 7, 1614, 2, 1615, + 7, 1615, 2, 1616, 7, 1616, 2, 1617, 7, 1617, 2, 1618, 7, 1618, 2, 1619, + 7, 1619, 2, 1620, 7, 1620, 2, 1621, 7, 1621, 2, 1622, 7, 1622, 2, 1623, + 7, 1623, 2, 1624, 7, 1624, 2, 1625, 7, 1625, 2, 1626, 7, 1626, 2, 1627, + 7, 1627, 2, 1628, 7, 1628, 2, 1629, 7, 1629, 2, 1630, 7, 1630, 2, 1631, + 7, 1631, 2, 1632, 7, 1632, 2, 1633, 7, 1633, 2, 1634, 7, 1634, 2, 1635, + 7, 1635, 2, 1636, 7, 1636, 2, 1637, 7, 1637, 2, 1638, 7, 1638, 2, 1639, + 7, 1639, 2, 1640, 7, 1640, 2, 1641, 7, 1641, 2, 1642, 7, 1642, 2, 1643, + 7, 1643, 2, 1644, 7, 1644, 2, 1645, 7, 1645, 2, 1646, 7, 1646, 2, 1647, + 7, 1647, 2, 1648, 7, 1648, 2, 1649, 7, 1649, 2, 1650, 7, 1650, 2, 1651, + 7, 1651, 2, 1652, 7, 1652, 2, 1653, 7, 1653, 2, 1654, 7, 1654, 2, 1655, + 7, 1655, 2, 1656, 7, 1656, 2, 1657, 7, 1657, 2, 1658, 7, 1658, 2, 1659, + 7, 1659, 2, 1660, 7, 1660, 2, 1661, 7, 1661, 2, 1662, 7, 1662, 2, 1663, + 7, 1663, 2, 1664, 7, 1664, 2, 1665, 7, 1665, 2, 1666, 7, 1666, 2, 1667, + 7, 1667, 2, 1668, 7, 1668, 2, 1669, 7, 1669, 2, 1670, 7, 1670, 2, 1671, + 7, 1671, 2, 1672, 7, 1672, 2, 1673, 7, 1673, 2, 1674, 7, 1674, 2, 1675, + 7, 1675, 2, 1676, 7, 1676, 2, 1677, 7, 1677, 2, 1678, 7, 1678, 2, 1679, + 7, 1679, 2, 1680, 7, 1680, 2, 1681, 7, 1681, 2, 1682, 7, 1682, 2, 1683, + 7, 1683, 2, 1684, 7, 1684, 2, 1685, 7, 1685, 2, 1686, 7, 1686, 2, 1687, + 7, 1687, 2, 1688, 7, 1688, 2, 1689, 7, 1689, 2, 1690, 7, 1690, 2, 1691, + 7, 1691, 2, 1692, 7, 1692, 2, 1693, 7, 1693, 2, 1694, 7, 1694, 2, 1695, + 7, 1695, 2, 1696, 7, 1696, 2, 1697, 7, 1697, 2, 1698, 7, 1698, 2, 1699, + 7, 1699, 2, 1700, 7, 1700, 2, 1701, 7, 1701, 2, 1702, 7, 1702, 2, 1703, + 7, 1703, 2, 1704, 7, 1704, 2, 1705, 7, 1705, 2, 1706, 7, 1706, 2, 1707, + 7, 1707, 2, 1708, 7, 1708, 2, 1709, 7, 1709, 2, 1710, 7, 1710, 2, 1711, + 7, 1711, 2, 1712, 7, 1712, 2, 1713, 7, 1713, 2, 1714, 7, 1714, 2, 1715, + 7, 1715, 2, 1716, 7, 1716, 2, 1717, 7, 1717, 2, 1718, 7, 1718, 2, 1719, + 7, 1719, 2, 1720, 7, 1720, 2, 1721, 7, 1721, 2, 1722, 7, 1722, 2, 1723, + 7, 1723, 2, 1724, 7, 1724, 2, 1725, 7, 1725, 2, 1726, 7, 1726, 2, 1727, + 7, 1727, 2, 1728, 7, 1728, 2, 1729, 7, 1729, 2, 1730, 7, 1730, 2, 1731, + 7, 1731, 2, 1732, 7, 1732, 2, 1733, 7, 1733, 2, 1734, 7, 1734, 2, 1735, + 7, 1735, 2, 1736, 7, 1736, 2, 1737, 7, 1737, 2, 1738, 7, 1738, 2, 1739, + 7, 1739, 2, 1740, 7, 1740, 2, 1741, 7, 1741, 2, 1742, 7, 1742, 2, 1743, + 7, 1743, 2, 1744, 7, 1744, 2, 1745, 7, 1745, 2, 1746, 7, 1746, 2, 1747, + 7, 1747, 2, 1748, 7, 1748, 2, 1749, 7, 1749, 2, 1750, 7, 1750, 2, 1751, + 7, 1751, 2, 1752, 7, 1752, 2, 1753, 7, 1753, 2, 1754, 7, 1754, 2, 1755, + 7, 1755, 2, 1756, 7, 1756, 2, 1757, 7, 1757, 2, 1758, 7, 1758, 2, 1759, + 7, 1759, 2, 1760, 7, 1760, 2, 1761, 7, 1761, 2, 1762, 7, 1762, 2, 1763, + 7, 1763, 2, 1764, 7, 1764, 2, 1765, 7, 1765, 2, 1766, 7, 1766, 2, 1767, + 7, 1767, 2, 1768, 7, 1768, 2, 1769, 7, 1769, 2, 1770, 7, 1770, 2, 1771, + 7, 1771, 2, 1772, 7, 1772, 2, 1773, 7, 1773, 2, 1774, 7, 1774, 2, 1775, + 7, 1775, 2, 1776, 7, 1776, 2, 1777, 7, 1777, 2, 1778, 7, 1778, 2, 1779, + 7, 1779, 2, 1780, 7, 1780, 2, 1781, 7, 1781, 2, 1782, 7, 1782, 2, 1783, + 7, 1783, 2, 1784, 7, 1784, 2, 1785, 7, 1785, 2, 1786, 7, 1786, 2, 1787, + 7, 1787, 2, 1788, 7, 1788, 2, 1789, 7, 1789, 2, 1790, 7, 1790, 2, 1791, + 7, 1791, 2, 1792, 7, 1792, 2, 1793, 7, 1793, 2, 1794, 7, 1794, 2, 1795, + 7, 1795, 2, 1796, 7, 1796, 2, 1797, 7, 1797, 2, 1798, 7, 1798, 2, 1799, + 7, 1799, 2, 1800, 7, 1800, 2, 1801, 7, 1801, 2, 1802, 7, 1802, 2, 1803, + 7, 1803, 2, 1804, 7, 1804, 2, 1805, 7, 1805, 2, 1806, 7, 1806, 2, 1807, + 7, 1807, 2, 1808, 7, 1808, 2, 1809, 7, 1809, 2, 1810, 7, 1810, 2, 1811, + 7, 1811, 2, 1812, 7, 1812, 2, 1813, 7, 1813, 2, 1814, 7, 1814, 2, 1815, + 7, 1815, 2, 1816, 7, 1816, 2, 1817, 7, 1817, 2, 1818, 7, 1818, 2, 1819, + 7, 1819, 2, 1820, 7, 1820, 2, 1821, 7, 1821, 2, 1822, 7, 1822, 2, 1823, + 7, 1823, 2, 1824, 7, 1824, 2, 1825, 7, 1825, 2, 1826, 7, 1826, 2, 1827, + 7, 1827, 2, 1828, 7, 1828, 2, 1829, 7, 1829, 2, 1830, 7, 1830, 2, 1831, + 7, 1831, 2, 1832, 7, 1832, 2, 1833, 7, 1833, 2, 1834, 7, 1834, 2, 1835, + 7, 1835, 2, 1836, 7, 1836, 2, 1837, 7, 1837, 2, 1838, 7, 1838, 2, 1839, + 7, 1839, 2, 1840, 7, 1840, 2, 1841, 7, 1841, 2, 1842, 7, 1842, 2, 1843, + 7, 1843, 2, 1844, 7, 1844, 2, 1845, 7, 1845, 2, 1846, 7, 1846, 2, 1847, + 7, 1847, 2, 1848, 7, 1848, 2, 1849, 7, 1849, 2, 1850, 7, 1850, 2, 1851, + 7, 1851, 2, 1852, 7, 1852, 2, 1853, 7, 1853, 2, 1854, 7, 1854, 2, 1855, + 7, 1855, 2, 1856, 7, 1856, 2, 1857, 7, 1857, 2, 1858, 7, 1858, 2, 1859, + 7, 1859, 2, 1860, 7, 1860, 2, 1861, 7, 1861, 2, 1862, 7, 1862, 2, 1863, + 7, 1863, 2, 1864, 7, 1864, 2, 1865, 7, 1865, 2, 1866, 7, 1866, 2, 1867, + 7, 1867, 2, 1868, 7, 1868, 2, 1869, 7, 1869, 2, 1870, 7, 1870, 2, 1871, + 7, 1871, 2, 1872, 7, 1872, 2, 1873, 7, 1873, 2, 1874, 7, 1874, 2, 1875, + 7, 1875, 2, 1876, 7, 1876, 2, 1877, 7, 1877, 2, 1878, 7, 1878, 2, 1879, + 7, 1879, 2, 1880, 7, 1880, 2, 1881, 7, 1881, 2, 1882, 7, 1882, 2, 1883, + 7, 1883, 2, 1884, 7, 1884, 2, 1885, 7, 1885, 2, 1886, 7, 1886, 2, 1887, + 7, 1887, 2, 1888, 7, 1888, 2, 1889, 7, 1889, 2, 1890, 7, 1890, 2, 1891, + 7, 1891, 2, 1892, 7, 1892, 2, 1893, 7, 1893, 2, 1894, 7, 1894, 2, 1895, + 7, 1895, 2, 1896, 7, 1896, 2, 1897, 7, 1897, 2, 1898, 7, 1898, 2, 1899, + 7, 1899, 2, 1900, 7, 1900, 2, 1901, 7, 1901, 2, 1902, 7, 1902, 2, 1903, + 7, 1903, 2, 1904, 7, 1904, 2, 1905, 7, 1905, 2, 1906, 7, 1906, 2, 1907, + 7, 1907, 2, 1908, 7, 1908, 2, 1909, 7, 1909, 2, 1910, 7, 1910, 2, 1911, + 7, 1911, 2, 1912, 7, 1912, 2, 1913, 7, 1913, 2, 1914, 7, 1914, 2, 1915, + 7, 1915, 2, 1916, 7, 1916, 2, 1917, 7, 1917, 2, 1918, 7, 1918, 2, 1919, + 7, 1919, 2, 1920, 7, 1920, 2, 1921, 7, 1921, 2, 1922, 7, 1922, 2, 1923, + 7, 1923, 2, 1924, 7, 1924, 2, 1925, 7, 1925, 2, 1926, 7, 1926, 2, 1927, + 7, 1927, 2, 1928, 7, 1928, 2, 1929, 7, 1929, 2, 1930, 7, 1930, 2, 1931, + 7, 1931, 2, 1932, 7, 1932, 2, 1933, 7, 1933, 2, 1934, 7, 1934, 2, 1935, + 7, 1935, 2, 1936, 7, 1936, 2, 1937, 7, 1937, 2, 1938, 7, 1938, 2, 1939, + 7, 1939, 2, 1940, 7, 1940, 2, 1941, 7, 1941, 2, 1942, 7, 1942, 2, 1943, + 7, 1943, 2, 1944, 7, 1944, 2, 1945, 7, 1945, 2, 1946, 7, 1946, 2, 1947, + 7, 1947, 2, 1948, 7, 1948, 2, 1949, 7, 1949, 2, 1950, 7, 1950, 2, 1951, + 7, 1951, 2, 1952, 7, 1952, 2, 1953, 7, 1953, 2, 1954, 7, 1954, 2, 1955, + 7, 1955, 2, 1956, 7, 1956, 2, 1957, 7, 1957, 2, 1958, 7, 1958, 2, 1959, + 7, 1959, 2, 1960, 7, 1960, 2, 1961, 7, 1961, 2, 1962, 7, 1962, 2, 1963, + 7, 1963, 2, 1964, 7, 1964, 2, 1965, 7, 1965, 2, 1966, 7, 1966, 2, 1967, + 7, 1967, 2, 1968, 7, 1968, 2, 1969, 7, 1969, 2, 1970, 7, 1970, 2, 1971, + 7, 1971, 2, 1972, 7, 1972, 2, 1973, 7, 1973, 2, 1974, 7, 1974, 2, 1975, + 7, 1975, 2, 1976, 7, 1976, 2, 1977, 7, 1977, 2, 1978, 7, 1978, 2, 1979, + 7, 1979, 2, 1980, 7, 1980, 2, 1981, 7, 1981, 2, 1982, 7, 1982, 2, 1983, + 7, 1983, 2, 1984, 7, 1984, 2, 1985, 7, 1985, 2, 1986, 7, 1986, 2, 1987, + 7, 1987, 2, 1988, 7, 1988, 2, 1989, 7, 1989, 2, 1990, 7, 1990, 2, 1991, + 7, 1991, 2, 1992, 7, 1992, 2, 1993, 7, 1993, 2, 1994, 7, 1994, 2, 1995, + 7, 1995, 2, 1996, 7, 1996, 2, 1997, 7, 1997, 2, 1998, 7, 1998, 2, 1999, + 7, 1999, 2, 2000, 7, 2000, 2, 2001, 7, 2001, 2, 2002, 7, 2002, 2, 2003, + 7, 2003, 2, 2004, 7, 2004, 2, 2005, 7, 2005, 2, 2006, 7, 2006, 2, 2007, + 7, 2007, 2, 2008, 7, 2008, 2, 2009, 7, 2009, 2, 2010, 7, 2010, 2, 2011, + 7, 2011, 2, 2012, 7, 2012, 2, 2013, 7, 2013, 2, 2014, 7, 2014, 2, 2015, + 7, 2015, 2, 2016, 7, 2016, 2, 2017, 7, 2017, 2, 2018, 7, 2018, 2, 2019, + 7, 2019, 2, 2020, 7, 2020, 2, 2021, 7, 2021, 2, 2022, 7, 2022, 2, 2023, + 7, 2023, 2, 2024, 7, 2024, 2, 2025, 7, 2025, 2, 2026, 7, 2026, 2, 2027, + 7, 2027, 2, 2028, 7, 2028, 2, 2029, 7, 2029, 2, 2030, 7, 2030, 2, 2031, + 7, 2031, 2, 2032, 7, 2032, 2, 2033, 7, 2033, 2, 2034, 7, 2034, 2, 2035, + 7, 2035, 2, 2036, 7, 2036, 2, 2037, 7, 2037, 2, 2038, 7, 2038, 2, 2039, + 7, 2039, 2, 2040, 7, 2040, 2, 2041, 7, 2041, 2, 2042, 7, 2042, 2, 2043, + 7, 2043, 2, 2044, 7, 2044, 2, 2045, 7, 2045, 2, 2046, 7, 2046, 2, 2047, + 7, 2047, 2, 2048, 7, 2048, 2, 2049, 7, 2049, 2, 2050, 7, 2050, 2, 2051, + 7, 2051, 2, 2052, 7, 2052, 2, 2053, 7, 2053, 2, 2054, 7, 2054, 2, 2055, + 7, 2055, 2, 2056, 7, 2056, 2, 2057, 7, 2057, 2, 2058, 7, 2058, 2, 2059, + 7, 2059, 2, 2060, 7, 2060, 2, 2061, 7, 2061, 2, 2062, 7, 2062, 2, 2063, + 7, 2063, 2, 2064, 7, 2064, 2, 2065, 7, 2065, 2, 2066, 7, 2066, 2, 2067, + 7, 2067, 2, 2068, 7, 2068, 2, 2069, 7, 2069, 2, 2070, 7, 2070, 2, 2071, + 7, 2071, 2, 2072, 7, 2072, 2, 2073, 7, 2073, 2, 2074, 7, 2074, 2, 2075, + 7, 2075, 2, 2076, 7, 2076, 2, 2077, 7, 2077, 2, 2078, 7, 2078, 2, 2079, + 7, 2079, 2, 2080, 7, 2080, 2, 2081, 7, 2081, 2, 2082, 7, 2082, 2, 2083, + 7, 2083, 2, 2084, 7, 2084, 2, 2085, 7, 2085, 2, 2086, 7, 2086, 2, 2087, + 7, 2087, 2, 2088, 7, 2088, 2, 2089, 7, 2089, 2, 2090, 7, 2090, 2, 2091, + 7, 2091, 2, 2092, 7, 2092, 2, 2093, 7, 2093, 2, 2094, 7, 2094, 2, 2095, + 7, 2095, 2, 2096, 7, 2096, 2, 2097, 7, 2097, 2, 2098, 7, 2098, 2, 2099, + 7, 2099, 2, 2100, 7, 2100, 2, 2101, 7, 2101, 2, 2102, 7, 2102, 2, 2103, + 7, 2103, 2, 2104, 7, 2104, 2, 2105, 7, 2105, 2, 2106, 7, 2106, 2, 2107, + 7, 2107, 2, 2108, 7, 2108, 2, 2109, 7, 2109, 2, 2110, 7, 2110, 2, 2111, + 7, 2111, 2, 2112, 7, 2112, 2, 2113, 7, 2113, 2, 2114, 7, 2114, 2, 2115, + 7, 2115, 2, 2116, 7, 2116, 2, 2117, 7, 2117, 2, 2118, 7, 2118, 2, 2119, + 7, 2119, 2, 2120, 7, 2120, 2, 2121, 7, 2121, 2, 2122, 7, 2122, 2, 2123, + 7, 2123, 2, 2124, 7, 2124, 2, 2125, 7, 2125, 2, 2126, 7, 2126, 2, 2127, + 7, 2127, 2, 2128, 7, 2128, 2, 2129, 7, 2129, 2, 2130, 7, 2130, 2, 2131, + 7, 2131, 2, 2132, 7, 2132, 2, 2133, 7, 2133, 2, 2134, 7, 2134, 2, 2135, + 7, 2135, 2, 2136, 7, 2136, 2, 2137, 7, 2137, 2, 2138, 7, 2138, 2, 2139, + 7, 2139, 2, 2140, 7, 2140, 2, 2141, 7, 2141, 2, 2142, 7, 2142, 2, 2143, + 7, 2143, 2, 2144, 7, 2144, 2, 2145, 7, 2145, 2, 2146, 7, 2146, 2, 2147, + 7, 2147, 2, 2148, 7, 2148, 2, 2149, 7, 2149, 2, 2150, 7, 2150, 2, 2151, + 7, 2151, 2, 2152, 7, 2152, 2, 2153, 7, 2153, 2, 2154, 7, 2154, 2, 2155, + 7, 2155, 2, 2156, 7, 2156, 2, 2157, 7, 2157, 2, 2158, 7, 2158, 2, 2159, + 7, 2159, 2, 2160, 7, 2160, 2, 2161, 7, 2161, 2, 2162, 7, 2162, 2, 2163, + 7, 2163, 2, 2164, 7, 2164, 2, 2165, 7, 2165, 2, 2166, 7, 2166, 2, 2167, + 7, 2167, 2, 2168, 7, 2168, 2, 2169, 7, 2169, 2, 2170, 7, 2170, 2, 2171, + 7, 2171, 2, 2172, 7, 2172, 2, 2173, 7, 2173, 2, 2174, 7, 2174, 2, 2175, + 7, 2175, 2, 2176, 7, 2176, 2, 2177, 7, 2177, 2, 2178, 7, 2178, 2, 2179, + 7, 2179, 2, 2180, 7, 2180, 2, 2181, 7, 2181, 2, 2182, 7, 2182, 2, 2183, + 7, 2183, 2, 2184, 7, 2184, 2, 2185, 7, 2185, 2, 2186, 7, 2186, 2, 2187, + 7, 2187, 2, 2188, 7, 2188, 2, 2189, 7, 2189, 2, 2190, 7, 2190, 2, 2191, + 7, 2191, 2, 2192, 7, 2192, 2, 2193, 7, 2193, 2, 2194, 7, 2194, 2, 2195, + 7, 2195, 2, 2196, 7, 2196, 2, 2197, 7, 2197, 2, 2198, 7, 2198, 2, 2199, + 7, 2199, 2, 2200, 7, 2200, 2, 2201, 7, 2201, 2, 2202, 7, 2202, 2, 2203, + 7, 2203, 2, 2204, 7, 2204, 2, 2205, 7, 2205, 2, 2206, 7, 2206, 2, 2207, + 7, 2207, 2, 2208, 7, 2208, 2, 2209, 7, 2209, 2, 2210, 7, 2210, 2, 2211, + 7, 2211, 2, 2212, 7, 2212, 2, 2213, 7, 2213, 2, 2214, 7, 2214, 2, 2215, + 7, 2215, 2, 2216, 7, 2216, 2, 2217, 7, 2217, 2, 2218, 7, 2218, 2, 2219, + 7, 2219, 2, 2220, 7, 2220, 2, 2221, 7, 2221, 2, 2222, 7, 2222, 2, 2223, + 7, 2223, 2, 2224, 7, 2224, 2, 2225, 7, 2225, 2, 2226, 7, 2226, 2, 2227, + 7, 2227, 2, 2228, 7, 2228, 2, 2229, 7, 2229, 2, 2230, 7, 2230, 2, 2231, + 7, 2231, 2, 2232, 7, 2232, 2, 2233, 7, 2233, 2, 2234, 7, 2234, 2, 2235, + 7, 2235, 2, 2236, 7, 2236, 2, 2237, 7, 2237, 2, 2238, 7, 2238, 2, 2239, + 7, 2239, 2, 2240, 7, 2240, 2, 2241, 7, 2241, 2, 2242, 7, 2242, 2, 2243, + 7, 2243, 2, 2244, 7, 2244, 2, 2245, 7, 2245, 2, 2246, 7, 2246, 2, 2247, + 7, 2247, 2, 2248, 7, 2248, 2, 2249, 7, 2249, 2, 2250, 7, 2250, 2, 2251, + 7, 2251, 2, 2252, 7, 2252, 2, 2253, 7, 2253, 2, 2254, 7, 2254, 2, 2255, + 7, 2255, 2, 2256, 7, 2256, 2, 2257, 7, 2257, 2, 2258, 7, 2258, 2, 2259, + 7, 2259, 2, 2260, 7, 2260, 2, 2261, 7, 2261, 2, 2262, 7, 2262, 2, 2263, + 7, 2263, 2, 2264, 7, 2264, 2, 2265, 7, 2265, 2, 2266, 7, 2266, 2, 2267, + 7, 2267, 2, 2268, 7, 2268, 2, 2269, 7, 2269, 2, 2270, 7, 2270, 2, 2271, + 7, 2271, 2, 2272, 7, 2272, 2, 2273, 7, 2273, 2, 2274, 7, 2274, 2, 2275, + 7, 2275, 2, 2276, 7, 2276, 2, 2277, 7, 2277, 2, 2278, 7, 2278, 2, 2279, + 7, 2279, 2, 2280, 7, 2280, 2, 2281, 7, 2281, 2, 2282, 7, 2282, 2, 2283, + 7, 2283, 2, 2284, 7, 2284, 2, 2285, 7, 2285, 2, 2286, 7, 2286, 2, 2287, + 7, 2287, 2, 2288, 7, 2288, 2, 2289, 7, 2289, 2, 2290, 7, 2290, 2, 2291, + 7, 2291, 2, 2292, 7, 2292, 2, 2293, 7, 2293, 2, 2294, 7, 2294, 2, 2295, + 7, 2295, 2, 2296, 7, 2296, 2, 2297, 7, 2297, 2, 2298, 7, 2298, 2, 2299, + 7, 2299, 2, 2300, 7, 2300, 2, 2301, 7, 2301, 2, 2302, 7, 2302, 2, 2303, + 7, 2303, 2, 2304, 7, 2304, 2, 2305, 7, 2305, 2, 2306, 7, 2306, 2, 2307, + 7, 2307, 2, 2308, 7, 2308, 2, 2309, 7, 2309, 2, 2310, 7, 2310, 2, 2311, + 7, 2311, 2, 2312, 7, 2312, 2, 2313, 7, 2313, 2, 2314, 7, 2314, 2, 2315, + 7, 2315, 2, 2316, 7, 2316, 2, 2317, 7, 2317, 2, 2318, 7, 2318, 2, 2319, + 7, 2319, 2, 2320, 7, 2320, 2, 2321, 7, 2321, 2, 2322, 7, 2322, 2, 2323, + 7, 2323, 2, 2324, 7, 2324, 2, 2325, 7, 2325, 2, 2326, 7, 2326, 2, 2327, + 7, 2327, 2, 2328, 7, 2328, 2, 2329, 7, 2329, 2, 2330, 7, 2330, 2, 2331, + 7, 2331, 2, 2332, 7, 2332, 2, 2333, 7, 2333, 2, 2334, 7, 2334, 2, 2335, + 7, 2335, 2, 2336, 7, 2336, 2, 2337, 7, 2337, 2, 2338, 7, 2338, 2, 2339, + 7, 2339, 2, 2340, 7, 2340, 2, 2341, 7, 2341, 2, 2342, 7, 2342, 2, 2343, + 7, 2343, 2, 2344, 7, 2344, 2, 2345, 7, 2345, 2, 2346, 7, 2346, 2, 2347, + 7, 2347, 2, 2348, 7, 2348, 2, 2349, 7, 2349, 2, 2350, 7, 2350, 2, 2351, + 7, 2351, 2, 2352, 7, 2352, 2, 2353, 7, 2353, 2, 2354, 7, 2354, 2, 2355, + 7, 2355, 2, 2356, 7, 2356, 2, 2357, 7, 2357, 2, 2358, 7, 2358, 2, 2359, + 7, 2359, 2, 2360, 7, 2360, 2, 2361, 7, 2361, 2, 2362, 7, 2362, 2, 2363, + 7, 2363, 2, 2364, 7, 2364, 2, 2365, 7, 2365, 2, 2366, 7, 2366, 2, 2367, + 7, 2367, 2, 2368, 7, 2368, 2, 2369, 7, 2369, 2, 2370, 7, 2370, 2, 2371, + 7, 2371, 2, 2372, 7, 2372, 2, 2373, 7, 2373, 2, 2374, 7, 2374, 2, 2375, + 7, 2375, 2, 2376, 7, 2376, 2, 2377, 7, 2377, 2, 2378, 7, 2378, 2, 2379, + 7, 2379, 2, 2380, 7, 2380, 2, 2381, 7, 2381, 2, 2382, 7, 2382, 2, 2383, + 7, 2383, 2, 2384, 7, 2384, 2, 2385, 7, 2385, 2, 2386, 7, 2386, 2, 2387, + 7, 2387, 2, 2388, 7, 2388, 2, 2389, 7, 2389, 2, 2390, 7, 2390, 2, 2391, + 7, 2391, 2, 2392, 7, 2392, 2, 2393, 7, 2393, 2, 2394, 7, 2394, 2, 2395, + 7, 2395, 2, 2396, 7, 2396, 2, 2397, 7, 2397, 2, 2398, 7, 2398, 2, 2399, + 7, 2399, 2, 2400, 7, 2400, 2, 2401, 7, 2401, 2, 2402, 7, 2402, 2, 2403, + 7, 2403, 2, 2404, 7, 2404, 2, 2405, 7, 2405, 2, 2406, 7, 2406, 2, 2407, + 7, 2407, 2, 2408, 7, 2408, 2, 2409, 7, 2409, 2, 2410, 7, 2410, 2, 2411, + 7, 2411, 2, 2412, 7, 2412, 2, 2413, 7, 2413, 2, 2414, 7, 2414, 2, 2415, + 7, 2415, 2, 2416, 7, 2416, 2, 2417, 7, 2417, 2, 2418, 7, 2418, 2, 2419, + 7, 2419, 2, 2420, 7, 2420, 2, 2421, 7, 2421, 2, 2422, 7, 2422, 2, 2423, + 7, 2423, 2, 2424, 7, 2424, 2, 2425, 7, 2425, 2, 2426, 7, 2426, 2, 2427, + 7, 2427, 2, 2428, 7, 2428, 2, 2429, 7, 2429, 2, 2430, 7, 2430, 2, 2431, + 7, 2431, 2, 2432, 7, 2432, 2, 2433, 7, 2433, 2, 2434, 7, 2434, 2, 2435, + 7, 2435, 2, 2436, 7, 2436, 2, 2437, 7, 2437, 2, 2438, 7, 2438, 2, 2439, + 7, 2439, 2, 2440, 7, 2440, 2, 2441, 7, 2441, 2, 2442, 7, 2442, 2, 2443, + 7, 2443, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 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, 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, 5, 1, 6, 1, 6, 1, 6, 1, 6, 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, 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, 11, 1, 11, 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, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, + 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, + 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, 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, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 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, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, + 20, 1, 20, 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, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 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, 23, 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, 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, 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, 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, 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, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, + 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 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, 39, + 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 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, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, + 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, + 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 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, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 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, 50, 1, 50, 1, 50, 1, 50, 1, 50, 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, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, + 53, 1, 53, 1, 53, 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, 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, 1, 55, 1, 56, + 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, + 56, 1, 56, 1, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, + 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 58, 1, + 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, 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, 61, + 1, 61, 1, 61, 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, 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, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 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, 69, 1, 69, 1, 69, 1, 69, 1, 69, 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, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, + 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 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, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, + 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 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, 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, 82, 1, 82, 1, 82, 1, 82, 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, 83, 1, 83, 1, 83, 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, 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, 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, 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, 91, + 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, + 91, 1, 91, 1, 91, 1, 91, 1, 91, 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, 92, 1, 92, 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, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 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, 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, 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, + 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, 101, 1, 101, 1, 101, + 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 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, 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, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, + 1, 105, 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, 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, 108, + 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, + 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 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, 113, 1, 113, 1, 113, 1, 114, 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, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, + 1, 116, 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, 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, 118, + 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, + 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 1, 120, 1, 120, 1, 120, 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, 121, 1, 121, 1, 121, 1, 121, 1, 121, + 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 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, 123, 1, 123, 1, 123, 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, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, + 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, 130, 1, 130, 1, 130, + 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, 1, 130, + 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, + 1, 132, 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, 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, 136, 1, 136, + 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, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 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, 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, 144, 1, 144, 1, 144, 1, 144, 1, 144, + 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, 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, 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, 151, 1, 151, 1, 151, 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, 152, + 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 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, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, + 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, + 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, 159, 1, 159, + 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, 160, + 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, 163, 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, 165, 1, 165, 1, 165, 1, 165, 1, 165, + 1, 165, 1, 165, 1, 165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, + 1, 166, 1, 166, 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, 168, 1, 168, 1, 168, 1, 168, + 1, 168, 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, 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, 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, 174, 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, 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, 175, 1, 175, 1, 175, 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, 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, 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, 180, 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, 183, 1, 183, 1, 183, 1, 183, 1, 183, 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, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, + 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, 185, 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, 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, 189, + 1, 189, 1, 189, 1, 189, 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, 192, 1, 192, 1, 192, + 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 192, + 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, + 1, 193, 1, 193, 1, 193, 1, 193, 1, 193, 1, 194, 1, 194, 1, 194, 1, 194, + 1, 194, 1, 194, 1, 194, 1, 195, 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, 197, + 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 198, 1, 198, 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, 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, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 1, 203, 1, 203, 1, 203, + 1, 203, 1, 203, 1, 203, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, 1, 204, + 1, 204, 1, 204, 1, 205, 1, 205, 1, 205, 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, 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, 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, 209, 1, 209, 1, 209, 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, 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, 211, 1, 211, 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, 212, 1, 212, 1, 212, 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, 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, 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, 219, 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, 220, 1, 220, 1, 220, 1, 220, + 1, 220, 1, 220, 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, 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, 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, 227, 1, 227, 1, 227, 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, 229, 1, 229, 1, 229, 1, 229, 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, 231, 1, 231, 1, 231, 1, 231, 1, 231, + 1, 231, 1, 231, 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, 232, 1, 232, 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, 234, 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, 235, 1, 236, 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, 238, 1, 238, 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, 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, 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, 242, 1, 242, + 1, 242, 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, 244, + 1, 244, 1, 244, 1, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, + 1, 245, 1, 245, 1, 245, 1, 245, 1, 245, 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, 247, 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, 248, 1, 248, 1, 248, 1, 248, 1, 248, + 1, 248, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, + 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 1, 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, 251, 1, 251, 1, 251, 1, 251, 1, 251, + 1, 251, 1, 251, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, + 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, + 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 252, 1, 253, 1, 253, + 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, + 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, 1, 253, + 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, + 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, 1, 254, + 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, 255, + 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, + 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, + 1, 256, 1, 256, 1, 256, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, + 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, + 1, 257, 1, 257, 1, 257, 1, 257, 1, 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, 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, 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, 263, 1, 263, 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, 265, 1, 265, 1, 266, 1, 266, 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, 268, 1, 268, 1, 268, 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, 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, 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, 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, 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, 276, + 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 276, 1, 277, 1, 277, + 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 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, 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, 281, 1, 281, 1, 281, 1, 281, + 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 1, 281, 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, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 284, 1, 285, + 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 286, 1, 286, 1, 286, + 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 286, 1, 287, + 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, 287, 1, 287, 1, 287, 1, 288, 1, 288, 1, 288, + 1, 288, 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, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 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, 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, 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, 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, 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, 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, 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, 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, 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, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 1, 309, 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, 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, 313, 1, 313, + 1, 313, 1, 313, 1, 313, 1, 313, 1, 314, 1, 314, 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, 316, 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, 316, 1, 316, 1, 317, 1, 317, 1, 317, 1, 317, 1, 317, + 1, 317, 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, 318, 1, 318, 1, 318, 1, 318, + 1, 318, 1, 318, 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, 319, 1, 319, 1, 320, 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, 321, 1, 321, + 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, + 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 1, 322, 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, 323, 1, 323, 1, 323, 1, 323, 1, 323, 1, 323, + 1, 323, 1, 323, 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, 324, + 1, 324, 1, 324, 1, 324, 1, 324, 1, 325, 1, 325, 1, 325, 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, 328, 1, 328, 1, 328, 1, 328, 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, 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, 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, 336, 1, 336, + 1, 336, 1, 336, 1, 336, 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, 337, + 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 1, 337, 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, 339, 1, 339, 1, 339, 1, 339, 1, 339, + 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, 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, 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, 346, 1, 346, 1, 346, 1, 346, + 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 346, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, 1, 347, + 1, 347, 1, 347, 1, 347, 1, 347, 1, 348, 1, 348, 1, 348, 1, 348, 1, 348, + 1, 348, 1, 348, 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, 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, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, 1, 352, + 1, 353, 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 1, 354, 1, 354, 1, 354, + 1, 354, 1, 354, 1, 354, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, 1, 355, + 1, 355, 1, 355, 1, 356, 1, 356, 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, 357, 1, 357, + 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 357, 1, 358, 1, 358, 1, 358, + 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 359, 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, 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, 363, 1, 363, 1, 363, 1, 363, 1, 363, + 1, 363, 1, 363, 1, 363, 1, 363, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, + 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, 1, 364, + 1, 364, 1, 364, 1, 364, 1, 364, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, + 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, + 1, 365, 1, 365, 1, 365, 1, 365, 1, 365, 1, 366, 1, 366, 1, 366, 1, 366, + 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, 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, 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, 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, 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, 376, 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, 378, 1, 378, 1, 378, + 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, + 1, 379, 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, 381, 1, 381, 1, 382, 1, 382, 1, 382, + 1, 382, 1, 382, 1, 382, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, 1, 383, + 1, 383, 1, 383, 1, 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, 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, 387, 1, 387, 1, 387, + 1, 388, 1, 388, 1, 388, 1, 388, 1, 388, 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, 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, 391, 1, 391, 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, 392, 1, 392, 1, 392, 1, 392, + 1, 392, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 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, 395, + 1, 395, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, 1, 396, + 1, 396, 1, 396, 1, 396, 1, 396, 1, 397, 1, 397, 1, 397, 1, 397, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, + 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 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, 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, 400, 1, 400, 1, 400, 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, 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, 405, 1, 405, 1, 405, 1, 405, 1, 405, 1, 406, + 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, 1, 406, + 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, 409, 1, 409, 1, 409, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 410, 1, 410, 1, 410, + 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, + 1, 410, 1, 410, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, + 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 1, 412, 1, 412, 1, 412, 1, 412, + 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, 1, 413, 1, 413, + 1, 413, 1, 413, 1, 414, 1, 414, 1, 414, 1, 414, 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, 415, 1, 416, 1, 416, + 1, 416, 1, 416, 1, 416, 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, 417, 1, 417, + 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, 418, 1, 418, 1, 418, + 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, 1, 418, + 1, 418, 1, 418, 1, 418, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, 1, 419, + 1, 419, 1, 419, 1, 419, 1, 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, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, + 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 423, 1, 423, 1, 423, + 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, + 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 425, 1, 425, 1, 425, 1, 425, + 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 425, 1, 426, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 427, 1, 427, 1, 427, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, + 1, 427, 1, 427, 1, 427, 1, 427, 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, 429, 1, 429, + 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 429, 1, 430, + 1, 430, 1, 430, 1, 431, 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, 432, 1, 432, 1, 432, + 1, 432, 1, 432, 1, 432, 1, 432, 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, 433, 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, 435, 1, 435, 1, 435, 1, 435, 1, 435, 1, 436, 1, 436, 1, 436, 1, 436, + 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 436, 1, 437, + 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 437, 1, 438, 1, 438, + 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, 1, 438, + 1, 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, 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, 442, 1, 442, + 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, 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, 444, 1, 444, 1, 444, 1, 444, + 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 1, 444, 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, 446, 1, 446, 1, 446, 1, 446, 1, 446, + 1, 446, 1, 447, 1, 447, 1, 447, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, + 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 449, 1, 449, 1, 449, + 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 1, 449, 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, 451, 1, 451, 1, 451, 1, 452, 1, 452, + 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, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, + 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, 1, 454, 1, 454, + 1, 454, 1, 454, 1, 454, 1, 454, 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, 455, 1, 455, 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, 457, + 1, 457, 1, 457, 1, 457, 1, 457, 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, 459, 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, 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, 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, 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, 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, 468, 1, 468, 1, 468, 1, 468, + 1, 468, 1, 468, 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, 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, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, 473, + 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 1, 473, 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, 476, 1, 476, 1, 476, 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, 477, 1, 477, 1, 477, 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, 480, 1, 480, 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, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 482, 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, 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, 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, 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, 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, 491, 1, 491, 1, 492, 1, 492, 1, 492, 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, 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, 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, 495, 1, 495, 1, 495, 1, 495, 1, 495, + 1, 496, 1, 496, 1, 496, 1, 496, 1, 497, 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, 498, + 1, 498, 1, 499, 1, 499, 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, 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, 1, 501, 1, 501, 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, 504, 1, 504, 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, 506, 1, 506, 1, 506, 1, 506, + 1, 506, 1, 506, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 1, 507, 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, 508, 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, 509, + 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, + 1, 510, 1, 510, 1, 510, 1, 510, 1, 511, 1, 511, 1, 511, 1, 511, 1, 511, + 1, 511, 1, 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, 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, 515, 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, 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, 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, 518, 1, 518, 1, 518, 1, 518, 1, 519, 1, 519, 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, 520, 1, 520, 1, 521, 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, 523, 1, 523, + 1, 523, 1, 523, 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, 526, + 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 526, 1, 527, 1, 527, + 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, 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, 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, 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, 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, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, + 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 1, 537, 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, 539, 1, 539, 1, 539, 1, 539, 1, 539, + 1, 539, 1, 540, 1, 540, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, 1, 541, + 1, 541, 1, 541, 1, 541, 1, 541, 1, 542, 1, 542, 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, 544, 1, 544, + 1, 544, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 1, 545, 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, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, 1, 547, + 1, 547, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 1, 548, 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, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 552, 1, 552, + 1, 552, 1, 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, + 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 555, 1, 555, 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, 556, 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, 558, 1, 558, 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, 560, 1, 560, 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, 562, 1, 562, 1, 562, 1, 562, 1, 562, + 1, 562, 1, 562, 1, 562, 1, 563, 1, 563, 1, 563, 1, 563, 1, 564, 1, 564, + 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, 565, 1, 565, 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, 566, 1, 566, 1, 566, 1, 566, 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, 569, 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, 573, 1, 573, 1, 573, 1, 573, + 1, 573, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, 1, 574, + 1, 574, 1, 574, 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, 576, + 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, 1, 576, + 1, 577, 1, 577, 1, 577, 1, 577, 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, 579, + 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 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, 580, 1, 580, 1, 580, + 1, 580, 1, 580, 1, 580, 1, 580, 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, 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, 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, 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, 587, 1, 587, 1, 587, 1, 587, 1, 587, + 1, 587, 1, 587, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, + 1, 588, 1, 588, 1, 588, 1, 588, 1, 588, 1, 589, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 590, 1, 590, 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, 591, 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, 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, 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, 597, 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, 600, 1, 600, 1, 600, 1, 600, + 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 600, 1, 601, 1, 601, + 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 602, 1, 602, 1, 602, + 1, 602, 1, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, + 1, 603, 1, 603, 1, 604, 1, 604, 1, 604, 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, 606, + 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 1, 606, 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, 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, 611, 1, 611, + 1, 611, 1, 611, 1, 611, 1, 611, 1, 611, 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, 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, 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, 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, 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, 620, 1, 620, 1, 620, + 1, 620, 1, 621, 1, 621, 1, 621, 1, 621, 1, 621, 1, 622, 1, 622, 1, 622, + 1, 622, 1, 622, 1, 622, 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, 624, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, 1, 625, + 1, 625, 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, 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, 630, 1, 630, + 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, 1, 630, + 1, 630, 1, 630, 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, 632, 1, 633, 1, 633, 1, 633, + 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, 635, 1, 635, 1, 635, 1, 635, + 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, 1, 635, + 1, 635, 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, 636, 1, 636, 1, 636, 1, 636, + 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, + 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 636, 1, 637, + 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, + 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, 1, 637, + 1, 637, 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, 639, 1, 639, 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, 641, 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, 643, 1, 643, 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, 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, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, + 1, 646, 1, 646, 1, 646, 1, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, + 1, 647, 1, 647, 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, 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, 651, 1, 652, 1, 652, 1, 652, 1, 652, 1, 652, 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, 653, + 1, 653, 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, 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, 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, 659, 1, 660, 1, 660, 1, 660, 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, 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, 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, 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, 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, 668, 1, 668, 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, 670, 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, 672, 1, 672, 1, 672, 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, 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, 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, 676, + 1, 676, 1, 676, 1, 676, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, + 1, 677, 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, 679, 1, 679, + 1, 679, 1, 680, 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, 681, 1, 682, + 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, 683, 1, 683, 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, 686, 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, 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, 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, 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, 691, 1, 691, + 1, 691, 1, 691, 1, 691, 1, 691, 1, 692, 1, 692, 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, 693, 1, 693, 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, 694, 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, 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, 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, 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, 701, + 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 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, 702, 1, 702, 1, 702, 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, 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, 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, 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, 711, 1, 711, 1, 711, 1, 711, 1, 711, 1, 712, 1, 712, + 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 1, 712, 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, 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, 714, + 1, 714, 1, 714, 1, 714, 1, 714, 1, 715, 1, 715, 1, 715, 1, 715, 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, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, 1, 717, + 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, 719, 1, 719, 1, 720, 1, 720, + 1, 720, 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, 721, 1, 721, 1, 721, 1, 721, 1, 721, + 1, 722, 1, 722, 1, 722, 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, 724, 1, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, + 1, 725, 1, 725, 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, 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, 728, + 1, 728, 1, 728, 1, 728, 1, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 731, 1, 731, + 1, 731, 1, 731, 1, 731, 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, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, 1, 733, + 1, 733, 1, 733, 1, 733, 1, 733, 1, 734, 1, 734, 1, 734, 1, 734, 1, 734, + 1, 734, 1, 734, 1, 734, 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, 735, 1, 735, 1, 735, + 1, 735, 1, 735, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, 1, 736, + 1, 736, 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, 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, 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, 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, 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, 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, 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, 751, 1, 751, 1, 751, 1, 751, 1, 751, + 1, 751, 1, 751, 1, 751, 1, 751, 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, 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, 756, 1, 756, 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, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 758, 1, 759, 1, 759, + 1, 759, 1, 759, 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, 761, 1, 761, + 1, 761, 1, 761, 1, 761, 1, 762, 1, 762, 1, 762, 1, 762, 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, 764, 1, 764, 1, 764, 1, 764, 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, 766, 1, 766, 1, 766, 1, 766, 1, 766, + 1, 766, 1, 766, 1, 766, 1, 766, 1, 766, 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, 767, 1, 767, 1, 767, 1, 767, 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, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, + 1, 768, 1, 768, 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, 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, 771, 1, 771, 1, 771, 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, 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, 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, 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, 779, 1, 779, + 1, 779, 1, 779, 1, 779, 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, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, 1, 782, + 1, 783, 1, 783, 1, 783, 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, 784, 1, 784, + 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, 786, 1, 786, 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, 789, + 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, 790, 1, 790, 1, 790, 1, 791, + 1, 791, 1, 791, 1, 791, 1, 791, 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, 794, + 1, 794, 1, 794, 1, 794, 1, 794, 1, 795, 1, 795, 1, 795, 1, 795, 1, 795, + 1, 796, 1, 796, 1, 796, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 799, 1, 799, 1, 799, 1, 799, + 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, 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, + 1, 805, 1, 805, 1, 805, 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, 807, 1, 807, 1, 808, 1, 808, 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, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 1, 810, 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, 812, 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, 814, 1, 814, 1, 815, 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, 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, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, + 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, + 1, 817, 1, 817, 1, 817, 1, 817, 1, 817, 1, 818, 1, 818, 1, 818, 1, 818, + 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, + 1, 819, 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, 822, 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, + 1, 822, 1, 822, 1, 822, 1, 822, 1, 822, 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, 824, + 1, 824, 1, 824, 1, 824, 1, 824, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, + 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 826, 1, 827, 1, 827, 1, 827, + 1, 827, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 829, 1, 829, 1, 829, + 1, 829, 1, 829, 1, 829, 1, 830, 1, 830, 1, 831, 1, 831, 1, 831, 1, 831, + 1, 831, 1, 832, 1, 832, 1, 832, 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, 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, 836, 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, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 1, 838, 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, 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, 843, 1, 843, + 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, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, + 1, 845, 1, 845, 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, 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, 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, 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, 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, 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, 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, 855, 1, 855, 1, 855, 1, 855, + 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 855, 1, 856, 1, 856, 1, 856, + 1, 856, 1, 856, 1, 856, 1, 856, 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, 857, 1, 857, 1, 857, 1, 857, 1, 857, 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, 858, 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, 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, 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, 865, + 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 1, 865, 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, 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, 867, 1, 867, 1, 867, 1, 867, 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, 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, 869, 1, 869, 1, 869, 1, 869, 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, 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, 873, 1, 873, 1, 873, 1, 873, 1, 873, 1, 873, + 1, 873, 1, 873, 1, 873, 1, 873, 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, 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, 879, 1, 879, + 1, 879, 1, 879, 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, 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, 882, + 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, 885, 1, 885, 1, 885, 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, 886, 1, 886, 1, 886, 1, 887, 1, 887, 1, 887, 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, 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, 890, 1, 890, 1, 890, 1, 890, 1, 890, 1, 891, 1, 891, 1, 891, + 1, 891, 1, 891, 1, 891, 1, 891, 1, 892, 1, 892, 1, 892, 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, 894, 1, 894, 1, 894, 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, 895, 1, 895, 1, 895, 1, 895, 1, 895, 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, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, 1, 896, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 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, 901, 1, 901, 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, 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, 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, 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, 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, 907, 1, 907, 1, 907, + 1, 907, 1, 907, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 909, 1, 909, 1, 909, 1, 909, 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, 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, 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, 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, 917, 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, 920, 1, 920, 1, 920, 1, 920, 1, 920, + 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, + 1, 921, 1, 921, 1, 921, 1, 921, 1, 921, 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, 923, + 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, 924, 1, 924, 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, 926, 1, 927, 1, 927, 1, 927, 1, 927, 1, 928, 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, 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, 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, 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, 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, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 936, 1, 937, 1, 937, 1, 937, + 1, 937, 1, 937, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 938, 1, 939, + 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 940, 1, 940, 1, 940, + 1, 940, 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, 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, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, + 1, 943, 1, 943, 1, 943, 1, 943, 1, 943, 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, 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, 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, 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, 947, 1, 947, 1, 947, 1, 947, 1, 948, 1, 948, + 1, 948, 1, 948, 1, 948, 1, 948, 1, 949, 1, 949, 1, 949, 1, 949, 1, 950, + 1, 950, 1, 950, 1, 950, 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, 952, + 1, 952, 1, 952, 1, 952, 1, 952, 1, 953, 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, 955, 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, 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, 958, + 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 1, 958, 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, 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, 960, 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, 961, 1, 961, 1, 961, 1, 962, + 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, 1, 962, + 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, 963, 1, 964, 1, 964, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 964, 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, 965, 1, 965, 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, 966, + 1, 966, 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, 967, 1, 967, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, 1, 968, + 1, 968, 1, 968, 1, 968, 1, 968, 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, 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, 971, 1, 971, + 1, 971, 1, 971, 1, 971, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, + 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, 972, 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, 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, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, + 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, + 1, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, 976, 1, 976, 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, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, 1, 978, + 1, 978, 1, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, + 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, 1, 979, + 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, 1, 980, + 1, 980, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, 1, 981, + 1, 981, 1, 981, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, + 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, + 1, 982, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, 1, 983, + 1, 983, 1, 983, 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, 985, 1, 985, + 1, 985, 1, 985, 1, 985, 1, 985, 1, 985, 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, 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, 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, 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, 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, 991, 1, 991, 1, 991, 1, 991, 1, 991, + 1, 991, 1, 991, 1, 991, 1, 991, 1, 991, 1, 992, 1, 992, 1, 992, 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, 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, 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, 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, 996, 1, 996, 1, 996, 1, 996, + 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, 1, 997, + 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, 998, 1, 998, 1, 998, 1, 998, 1, 998, + 1, 998, 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, 1, 999, 1, 999, 1, 999, + 1, 999, 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, 1000, 1, 1000, + 1, 1000, 1, 1000, 1, 1000, 1, 1000, 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, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, 1, 1001, + 1, 1001, 1, 1001, 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, 1002, + 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, 1, 1002, + 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, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, 1, 1003, + 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, 1004, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, + 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, + 1, 1005, 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, 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, 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, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1008, 1, 1009, 1, 1009, + 1, 1009, 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, 1010, 1, 1010, 1, 1010, 1, 1010, 1, 1010, 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, 1011, 1, 1011, 1, 1011, 1, 1011, 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, 1013, 1, 1013, 1, 1013, + 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 1, 1013, 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, 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, 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, 1016, 1, 1016, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, + 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, + 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, 1, 1018, + 1, 1018, 1, 1018, 1, 1018, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, + 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 1, 1019, 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, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, + 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 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, 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, 1023, 1, 1023, + 1, 1023, 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, 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, 1025, 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, 1027, 1, 1027, 1, 1027, + 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, 1027, + 1, 1027, 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, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, + 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, 1, 1028, + 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, 1029, + 1, 1029, 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, 1030, 1, 1030, + 1, 1030, 1, 1030, 1, 1030, 1, 1030, 1, 1031, 1, 1031, 1, 1031, 1, 1031, + 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, 1, 1031, + 1, 1031, 1, 1032, 1, 1032, 1, 1032, 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, 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, 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, 1035, 1, 1035, 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, 1037, 1, 1037, 1, 1037, 1, 1038, 1, 1038, 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, 1039, 1, 1039, 1, 1040, + 1, 1040, 1, 1040, 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, 1041, 1, 1041, 1, 1041, 1, 1041, 1, 1042, 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, 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, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, + 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, + 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, 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, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, + 1, 1048, 1, 1048, 1, 1048, 1, 1048, 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, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 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, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 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, 1051, 1, 1051, 1, 1052, 1, 1052, 1, 1052, 1, 1052, + 1, 1052, 1, 1052, 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, 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, 1054, 1, 1054, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 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, 1057, 1, 1058, 1, 1058, 1, 1058, + 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 1, 1058, 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, 1060, 1, 1060, 1, 1060, 1, 1060, + 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 1, 1060, 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, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, + 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 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, 1062, 1, 1062, 1, 1062, 1, 1062, 1, 1062, + 1, 1062, 1, 1062, 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, 1063, 1, 1064, 1, 1064, 1, 1064, + 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 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, 1065, + 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, 1066, 1, 1066, 1, 1066, 1, 1066, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1068, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, 1, 1068, + 1, 1068, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 1, 1069, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1070, + 1, 1070, 1, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, 1, 1071, 1, 1071, + 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, 1071, + 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, + 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1072, + 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 1, 1073, 1, 1073, 1, 1073, 1, 1074, 1, 1074, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, + 1, 1074, 1, 1074, 1, 1074, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, + 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1076, 1, 1076, 1, 1076, + 1, 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1077, 1, 1077, + 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 1, 1077, 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, 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, 1079, 1, 1079, 1, 1079, 1, 1079, + 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 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, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, + 1, 1081, 1, 1081, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, + 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1082, 1, 1083, + 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, + 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1085, + 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 1, 1085, + 1, 1085, 1, 1085, 1, 1085, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, + 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, + 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, 1, 1086, + 1, 1086, 1, 1086, 1, 1086, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, + 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1088, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1090, 1, 1090, 1, 1090, 1, 1090, + 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1090, 1, 1091, 1, 1091, 1, 1091, + 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1091, 1, 1092, 1, 1092, + 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, 1, 1092, + 1, 1092, 1, 1092, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, + 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, + 1, 1093, 1, 1093, 1, 1094, 1, 1094, 1, 1094, 1, 1094, 1, 1094, 1, 1094, + 1, 1094, 1, 1094, 1, 1094, 1, 1094, 1, 1095, 1, 1095, 1, 1095, 1, 1095, + 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1095, 1, 1096, + 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, + 1, 1096, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, + 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, + 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, + 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1098, 1, 1099, 1, 1099, 1, 1099, + 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, + 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1100, 1, 1101, 1, 1101, 1, 1101, + 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1102, + 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, 1, 1102, + 1, 1102, 1, 1102, 1, 1102, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, + 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1103, + 1, 1103, 1, 1103, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 1, 1104, 1, 1104, 1, 1105, 1, 1105, 1, 1105, 1, 1105, 1, 1105, + 1, 1105, 1, 1105, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, + 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, + 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1106, 1, 1107, 1, 1107, 1, 1107, + 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, 1, 1107, + 1, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, + 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, + 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 1, 1108, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, + 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1109, 1, 1110, 1, 1110, 1, 1110, + 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1110, + 1, 1110, 1, 1110, 1, 1110, 1, 1110, 1, 1111, 1, 1111, 1, 1111, 1, 1111, + 1, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1111, 1, 1112, 1, 1112, 1, 1112, + 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, + 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, + 1, 1112, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, + 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, + 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, + 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, + 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1115, + 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, 1, 1116, + 1, 1116, 1, 1116, 1, 1116, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, + 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, 1, 1117, + 1, 1117, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, 1, 1118, + 1, 1118, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, + 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1119, 1, 1120, 1, 1120, + 1, 1120, 1, 1120, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, + 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1122, 1, 1122, 1, 1122, 1, 1122, + 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1122, 1, 1123, 1, 1123, + 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, 1, 1123, + 1, 1123, 1, 1123, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, + 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, + 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, 1, 1124, + 1, 1124, 1, 1124, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, + 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, + 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, + 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1125, 1, 1126, + 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, 1, 1126, + 1, 1126, 1, 1126, 1, 1126, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, + 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, + 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1127, + 1, 1127, 1, 1127, 1, 1127, 1, 1127, 1, 1128, 1, 1128, 1, 1128, 1, 1128, + 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, 1, 1128, + 1, 1128, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, 1, 1129, + 1, 1129, 1, 1129, 1, 1129, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, + 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1130, 1, 1131, 1, 1131, 1, 1131, + 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, 1, 1131, + 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, + 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, + 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, 1, 1132, + 1, 1132, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, + 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, + 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, 1, 1133, + 1, 1133, 1, 1133, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, + 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1134, 1, 1135, 1, 1135, + 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1135, 1, 1136, 1, 1136, 1, 1136, + 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, + 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1136, + 1, 1136, 1, 1136, 1, 1136, 1, 1136, 1, 1137, 1, 1137, 1, 1137, 1, 1137, + 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, + 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1137, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, + 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1138, 1, 1139, 1, 1139, 1, 1139, + 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, + 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, 1, 1139, + 1, 1139, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, + 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, + 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1140, 1, 1141, 1, 1141, + 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, 1, 1141, + 1, 1141, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, 1, 1142, + 1, 1142, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, 1143, 1, 1143, 1, 1143, + 1, 1143, 1, 1143, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1144, 1, 1145, + 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1145, 1, 1146, 1, 1146, 1, 1146, + 1, 1146, 1, 1146, 1, 1146, 1, 1146, 1, 1147, 1, 1147, 1, 1147, 1, 1147, + 1, 1147, 1, 1147, 1, 1147, 1, 1147, 1, 1148, 1, 1148, 1, 1148, 1, 1148, + 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, 1, 1148, + 1, 1148, 1, 1148, 1, 1148, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, + 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, 1, 1149, + 1, 1149, 1, 1149, 1, 1149, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, + 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, 1, 1150, + 1, 1150, 1, 1150, 1, 1150, 1, 1151, 1, 1151, 1, 1151, 1, 1151, 1, 1151, + 1, 1151, 1, 1151, 1, 1151, 1, 1151, 1, 1151, 1, 1152, 1, 1152, 1, 1152, + 1, 1152, 1, 1152, 1, 1153, 1, 1153, 1, 1153, 1, 1153, 1, 1153, 1, 1153, + 1, 1153, 1, 1153, 1, 1153, 1, 1153, 1, 1153, 1, 1154, 1, 1154, 1, 1154, + 1, 1154, 1, 1154, 1, 1154, 1, 1154, 1, 1155, 1, 1155, 1, 1155, 1, 1155, + 1, 1155, 1, 1155, 1, 1155, 1, 1156, 1, 1156, 1, 1156, 1, 1156, 1, 1156, + 1, 1156, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, + 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1158, 1, 1158, 1, 1158, + 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, 1, 1158, + 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, 1, 1159, + 1, 1160, 1, 1160, 1, 1160, 1, 1160, 1, 1161, 1, 1161, 1, 1161, 1, 1161, + 1, 1161, 1, 1161, 1, 1161, 1, 1162, 1, 1162, 1, 1162, 1, 1163, 1, 1163, + 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1164, + 1, 1164, 1, 1164, 1, 1164, 1, 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1165, + 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, 1167, 1, 1167, 1, 1167, 1, 1167, + 1, 1167, 1, 1167, 1, 1167, 1, 1167, 1, 1167, 1, 1167, 1, 1167, 1, 1167, + 1, 1167, 1, 1167, 1, 1168, 1, 1168, 1, 1168, 1, 1168, 1, 1169, 1, 1169, + 1, 1169, 1, 1169, 1, 1169, 1, 1170, 1, 1170, 1, 1170, 1, 1170, 1, 1170, + 1, 1171, 1, 1171, 1, 1171, 1, 1171, 1, 1172, 1, 1172, 1, 1172, 1, 1172, + 1, 1172, 1, 1172, 1, 1172, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, + 1, 1174, 1, 1174, 1, 1174, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, + 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, 1, 1176, + 1, 1176, 1, 1176, 1, 1176, 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, + 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, + 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1177, 1, 1178, 1, 1178, 1, 1178, + 1, 1178, 1, 1178, 1, 1178, 1, 1178, 1, 1179, 1, 1179, 1, 1179, 1, 1179, + 1, 1179, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, + 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1182, 1, 1182, 1, 1182, + 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, + 1, 1182, 1, 1182, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, + 1, 1183, 1, 1183, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, 1, 1184, + 1, 1184, 1, 1184, 1, 1184, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, + 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, + 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, + 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1185, 1, 1186, 1, 1186, 1, 1186, + 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1186, + 1, 1186, 1, 1186, 1, 1186, 1, 1186, 1, 1187, 1, 1187, 1, 1187, 1, 1187, + 1, 1187, 1, 1187, 1, 1187, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, + 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1188, 1, 1189, 1, 1189, 1, 1189, + 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, 1, 1189, + 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, + 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1190, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, + 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, 1, 1192, + 1, 1192, 1, 1193, 1, 1193, 1, 1193, 1, 1193, 1, 1193, 1, 1193, 1, 1193, + 1, 1193, 1, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1194, 1, 1194, + 1, 1194, 1, 1194, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, 1, 1195, + 1, 1195, 1, 1195, 1, 1195, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, 1, 1196, + 1, 1196, 1, 1196, 1, 1196, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, + 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, 1, 1197, + 1, 1197, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, + 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, 1, 1198, + 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, + 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, 1, 1199, + 1, 1199, 1, 1199, 1, 1199, 1, 1200, 1, 1200, 1, 1200, 1, 1200, 1, 1200, + 1, 1200, 1, 1200, 1, 1200, 1, 1200, 1, 1201, 1, 1201, 1, 1201, 1, 1201, + 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, + 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, 1, 1201, + 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, + 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, 1, 1202, + 1, 1202, 1, 1202, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, + 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, + 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1203, + 1, 1203, 1, 1203, 1, 1203, 1, 1203, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, 1, 1204, + 1, 1204, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, + 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, 1, 1205, + 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, + 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1206, 1, 1207, 1, 1207, + 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, 1, 1207, + 1, 1207, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, + 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, 1, 1208, + 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, + 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1209, 1, 1210, + 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, + 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1210, 1, 1211, 1, 1211, + 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1211, + 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1211, 1, 1212, 1, 1212, 1, 1212, + 1, 1212, 1, 1212, 1, 1212, 1, 1212, 1, 1212, 1, 1213, 1, 1213, 1, 1213, + 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, + 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, 1, 1213, + 1, 1214, 1, 1214, 1, 1214, 1, 1214, 1, 1214, 1, 1214, 1, 1215, 1, 1215, + 1, 1215, 1, 1215, 1, 1215, 1, 1215, 1, 1215, 1, 1215, 1, 1215, 1, 1215, + 1, 1215, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, 1, 1216, + 1, 1216, 1, 1216, 1, 1216, 1, 1217, 1, 1217, 1, 1217, 1, 1217, 1, 1217, + 1, 1217, 1, 1217, 1, 1217, 1, 1217, 1, 1217, 1, 1217, 1, 1217, 1, 1217, + 1, 1218, 1, 1218, 1, 1218, 1, 1219, 1, 1219, 1, 1219, 1, 1219, 1, 1219, + 1, 1219, 1, 1219, 1, 1219, 1, 1219, 1, 1219, 1, 1219, 1, 1219, 1, 1219, + 1, 1219, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, 1, 1220, + 1, 1220, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 1221, 1, 1222, + 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, + 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, 1, 1222, + 1, 1222, 1, 1222, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, + 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, + 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1223, 1, 1224, 1, 1224, + 1, 1224, 1, 1224, 1, 1224, 1, 1224, 1, 1225, 1, 1225, 1, 1225, 1, 1225, + 1, 1225, 1, 1225, 1, 1225, 1, 1225, 1, 1225, 1, 1225, 1, 1225, 1, 1225, + 1, 1225, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, 1, 1226, + 1, 1226, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, + 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1227, 1, 1228, 1, 1228, 1, 1228, + 1, 1228, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, + 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, 1, 1229, + 1, 1229, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, 1, 1230, + 1, 1230, 1, 1230, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, 1, 1231, + 1, 1231, 1, 1231, 1, 1231, 1, 1232, 1, 1232, 1, 1232, 1, 1232, 1, 1232, + 1, 1233, 1, 1233, 1, 1233, 1, 1233, 1, 1233, 1, 1233, 1, 1233, 1, 1233, + 1, 1233, 1, 1233, 1, 1233, 1, 1234, 1, 1234, 1, 1234, 1, 1234, 1, 1234, + 1, 1234, 1, 1235, 1, 1235, 1, 1235, 1, 1235, 1, 1235, 1, 1235, 1, 1235, + 1, 1235, 1, 1235, 1, 1235, 1, 1236, 1, 1236, 1, 1236, 1, 1236, 1, 1237, + 1, 1237, 1, 1238, 1, 1238, 1, 1238, 1, 1238, 1, 1238, 1, 1238, 1, 1238, + 1, 1238, 1, 1239, 1, 1239, 1, 1239, 1, 1239, 1, 1239, 1, 1239, 1, 1239, + 1, 1239, 1, 1239, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, + 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, 1, 1240, + 1, 1240, 1, 1240, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, + 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, 1, 1241, + 1, 1241, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, 1, 1242, + 1, 1242, 1, 1242, 1, 1243, 1, 1243, 1, 1243, 1, 1243, 1, 1243, 1, 1243, + 1, 1243, 1, 1243, 1, 1243, 1, 1243, 1, 1243, 1, 1244, 1, 1244, 1, 1244, + 1, 1244, 1, 1244, 1, 1244, 1, 1245, 1, 1245, 1, 1245, 1, 1245, 1, 1245, + 1, 1245, 1, 1245, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, + 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1246, + 1, 1246, 1, 1246, 1, 1246, 1, 1246, 1, 1247, 1, 1247, 1, 1247, 1, 1247, + 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, + 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1247, 1, 1248, + 1, 1248, 1, 1248, 1, 1248, 1, 1248, 1, 1248, 1, 1248, 1, 1249, 1, 1249, + 1, 1249, 1, 1249, 1, 1249, 1, 1249, 1, 1249, 1, 1249, 1, 1249, 1, 1249, + 1, 1249, 1, 1249, 1, 1249, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, + 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1250, 1, 1251, 1, 1251, 1, 1251, + 1, 1251, 1, 1251, 1, 1251, 1, 1251, 1, 1251, 1, 1252, 1, 1252, 1, 1252, + 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, + 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, + 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1252, 1, 1253, 1, 1253, 1, 1253, + 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1253, + 1, 1253, 1, 1253, 1, 1253, 1, 1253, 1, 1254, 1, 1254, 1, 1254, 1, 1254, + 1, 1254, 1, 1254, 1, 1254, 1, 1254, 1, 1254, 1, 1254, 1, 1254, 1, 1254, + 1, 1254, 1, 1254, 1, 1254, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, + 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1255, 1, 1256, 1, 1256, 1, 1256, + 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, + 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1256, 1, 1257, 1, 1257, 1, 1257, + 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, 1, 1257, + 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, + 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1258, 1, 1259, 1, 1259, + 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1259, 1, 1260, 1, 1260, + 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, + 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, 1, 1260, + 1, 1260, 1, 1260, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, + 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, + 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1261, 1, 1262, 1, 1262, 1, 1262, + 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, + 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, 1, 1262, + 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1263, 1, 1263, + 1, 1263, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, + 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1264, + 1, 1264, 1, 1264, 1, 1264, 1, 1264, 1, 1265, 1, 1265, 1, 1265, 1, 1265, + 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, + 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, 1, 1265, + 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, + 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, + 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1266, 1, 1267, + 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, + 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, + 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, 1, 1267, + 1, 1268, 1, 1268, 1, 1268, 1, 1268, 1, 1268, 1, 1269, 1, 1269, 1, 1269, + 1, 1269, 1, 1269, 1, 1269, 1, 1270, 1, 1270, 1, 1270, 1, 1270, 1, 1270, + 1, 1271, 1, 1271, 1, 1271, 1, 1271, 1, 1271, 1, 1271, 1, 1271, 1, 1271, + 1, 1271, 1, 1271, 1, 1271, 1, 1271, 1, 1272, 1, 1272, 1, 1272, 1, 1272, + 1, 1272, 1, 1272, 1, 1273, 1, 1273, 1, 1273, 1, 1273, 1, 1273, 1, 1273, + 1, 1273, 1, 1273, 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1274, + 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1274, 1, 1275, + 1, 1275, 1, 1275, 1, 1275, 1, 1275, 1, 1275, 1, 1275, 1, 1275, 1, 1275, + 1, 1275, 1, 1275, 1, 1276, 1, 1276, 1, 1276, 1, 1276, 1, 1276, 1, 1276, + 1, 1276, 1, 1276, 1, 1277, 1, 1277, 1, 1277, 1, 1277, 1, 1277, 1, 1277, + 1, 1277, 1, 1277, 1, 1277, 1, 1277, 1, 1277, 1, 1277, 1, 1278, 1, 1278, + 1, 1278, 1, 1278, 1, 1278, 1, 1278, 1, 1278, 1, 1278, 1, 1278, 1, 1278, + 1, 1278, 1, 1278, 1, 1278, 1, 1279, 1, 1279, 1, 1279, 1, 1279, 1, 1279, + 1, 1279, 1, 1279, 1, 1279, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, + 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1280, 1, 1281, 1, 1281, + 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1281, 1, 1282, 1, 1282, + 5, 1282, 18897, 8, 1282, 10, 1282, 12, 1282, 18900, 9, 1282, 1, 1282, 1, + 1282, 1, 1282, 1, 1282, 1, 1282, 1, 1282, 1, 1283, 1, 1283, 5, 1283, 18910, + 8, 1283, 10, 1283, 12, 1283, 18913, 9, 1283, 1, 1283, 1, 1283, 1, 1283, + 1, 1283, 1, 1283, 1, 1283, 1, 1283, 1, 1284, 1, 1284, 5, 1284, 18924, 8, + 1284, 10, 1284, 12, 1284, 18927, 9, 1284, 1, 1284, 1, 1284, 1, 1284, 1, + 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1284, 1, 1285, 1, 1285, 1, + 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1285, 1, 1286, 1, 1286, 1, + 1286, 1, 1286, 1, 1286, 1, 1286, 1, 1286, 1, 1286, 1, 1286, 1, 1286, 1, + 1286, 1, 1286, 1, 1286, 1, 1286, 1, 1287, 1, 1287, 5, 1287, 18962, 8, 1287, + 10, 1287, 12, 1287, 18965, 9, 1287, 1, 1287, 1, 1287, 1, 1287, 1, 1287, + 1, 1287, 1, 1287, 1, 1287, 1, 1287, 1, 1287, 1, 1288, 1, 1288, 5, 1288, + 18978, 8, 1288, 10, 1288, 12, 1288, 18981, 9, 1288, 1, 1288, 1, 1288, 1, + 1288, 1, 1288, 1, 1288, 1, 1288, 1, 1288, 1, 1288, 1, 1289, 1, 1289, 5, + 1289, 18993, 8, 1289, 10, 1289, 12, 1289, 18996, 9, 1289, 1, 1289, 1, 1289, + 1, 1289, 1, 1289, 1, 1289, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, + 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1290, 1, 1291, + 1, 1291, 1, 1291, 1, 1291, 1, 1291, 1, 1291, 1, 1291, 1, 1292, 1, 1292, + 1, 1292, 1, 1292, 1, 1292, 1, 1292, 1, 1292, 1, 1292, 1, 1292, 1, 1292, + 1, 1293, 1, 1293, 1, 1293, 1, 1293, 1, 1293, 1, 1293, 1, 1293, 1, 1293, + 1, 1293, 1, 1293, 1, 1293, 1, 1294, 1, 1294, 1, 1294, 1, 1294, 1, 1294, + 1, 1294, 1, 1294, 1, 1294, 1, 1295, 1, 1295, 1, 1295, 1, 1295, 1, 1296, + 1, 1296, 1, 1296, 1, 1296, 1, 1296, 1, 1296, 1, 1297, 1, 1297, 1, 1297, + 1, 1297, 1, 1297, 1, 1297, 1, 1297, 1, 1297, 1, 1297, 1, 1298, 1, 1298, + 1, 1298, 1, 1298, 1, 1298, 1, 1298, 1, 1299, 1, 1299, 1, 1299, 1, 1299, + 1, 1299, 1, 1299, 1, 1299, 1, 1299, 1, 1299, 1, 1299, 1, 1300, 1, 1300, + 1, 1300, 1, 1300, 1, 1300, 1, 1301, 1, 1301, 1, 1301, 1, 1301, 1, 1301, + 1, 1301, 1, 1301, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, 1, 1302, + 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, 1, 1303, + 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, + 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1304, 1, 1305, + 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, + 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1305, 1, 1306, 1, 1306, + 1, 1306, 1, 1306, 1, 1306, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, + 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1307, + 1, 1307, 1, 1307, 1, 1307, 1, 1307, 1, 1308, 1, 1308, 1, 1308, 1, 1308, + 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, 1, 1308, + 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, + 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1309, 1, 1310, 1, 1310, + 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, + 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1310, 1, 1311, 1, 1311, + 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, 1, 1311, + 1, 1311, 1, 1311, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, + 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, + 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1312, 1, 1313, + 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, + 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1313, 1, 1314, 1, 1314, + 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, 1, 1314, + 1, 1315, 1, 1315, 1, 1315, 1, 1315, 1, 1315, 1, 1316, 1, 1316, 1, 1316, + 1, 1316, 1, 1316, 1, 1316, 1, 1317, 1, 1317, 1, 1317, 1, 1317, 1, 1317, + 1, 1317, 1, 1317, 1, 1318, 1, 1318, 1, 1318, 1, 1318, 1, 1318, 1, 1318, + 1, 1318, 1, 1318, 1, 1318, 1, 1319, 1, 1319, 1, 1319, 1, 1319, 1, 1319, + 1, 1319, 1, 1319, 1, 1319, 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1320, + 1, 1320, 1, 1320, 1, 1320, 1, 1320, 1, 1321, 1, 1321, 1, 1321, 1, 1321, + 1, 1321, 1, 1321, 1, 1321, 1, 1321, 1, 1322, 1, 1322, 1, 1322, 1, 1322, + 1, 1322, 1, 1322, 1, 1322, 1, 1322, 1, 1323, 1, 1323, 1, 1323, 1, 1323, + 1, 1323, 1, 1323, 1, 1323, 1, 1323, 1, 1323, 1, 1323, 1, 1324, 1, 1324, + 1, 1324, 1, 1324, 1, 1324, 1, 1324, 1, 1324, 1, 1324, 1, 1324, 1, 1325, + 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, + 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, 1, 1325, + 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, + 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, + 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, + 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1326, 1, 1327, 1, 1327, 1, 1327, + 1, 1327, 1, 1327, 1, 1327, 1, 1327, 1, 1327, 1, 1327, 1, 1327, 1, 1327, + 1, 1327, 1, 1327, 1, 1327, 1, 1328, 1, 1328, 1, 1328, 1, 1328, 1, 1328, + 1, 1328, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, + 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, + 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1329, 1, 1330, 1, 1330, 1, 1330, + 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, 1, 1330, + 1, 1330, 1, 1330, 1, 1330, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, + 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, + 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, 1, 1331, + 1, 1332, 1, 1332, 1, 1332, 1, 1332, 1, 1332, 1, 1332, 1, 1332, 1, 1332, + 1, 1332, 1, 1332, 1, 1333, 1, 1333, 1, 1333, 1, 1333, 1, 1333, 1, 1333, + 1, 1333, 1, 1334, 1, 1334, 1, 1334, 1, 1334, 1, 1334, 1, 1334, 1, 1334, + 1, 1334, 1, 1334, 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1335, + 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1335, 1, 1336, + 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1336, 1, 1337, + 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1337, 1, 1338, 1, 1338, + 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1338, 1, 1339, + 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, 1, 1339, + 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, 1, 1340, + 1, 1340, 1, 1340, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1341, + 1, 1341, 1, 1341, 1, 1341, 1, 1341, 1, 1342, 1, 1342, 1, 1342, 1, 1342, + 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, + 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, 1, 1342, + 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, + 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, 1, 1343, + 1, 1343, 1, 1343, 1, 1343, 1, 1344, 1, 1344, 1, 1344, 1, 1344, 1, 1344, + 1, 1344, 1, 1344, 1, 1344, 1, 1345, 1, 1345, 1, 1345, 1, 1345, 1, 1345, + 1, 1345, 1, 1345, 1, 1345, 1, 1346, 1, 1346, 1, 1346, 1, 1346, 1, 1346, + 1, 1346, 1, 1346, 1, 1346, 1, 1346, 1, 1346, 1, 1346, 1, 1347, 1, 1347, + 1, 1347, 1, 1347, 1, 1347, 1, 1347, 1, 1347, 1, 1347, 1, 1348, 1, 1348, + 1, 1348, 1, 1348, 1, 1348, 1, 1348, 1, 1348, 1, 1348, 1, 1348, 1, 1349, + 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1349, + 1, 1349, 1, 1349, 1, 1349, 1, 1349, 1, 1350, 1, 1350, 1, 1350, 1, 1350, + 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1350, 1, 1351, 1, 1351, 1, 1351, + 1, 1351, 1, 1351, 1, 1351, 1, 1351, 1, 1352, 1, 1352, 1, 1352, 1, 1352, + 1, 1352, 1, 1352, 1, 1352, 1, 1352, 1, 1352, 1, 1353, 1, 1353, 1, 1353, + 1, 1353, 1, 1353, 1, 1354, 1, 1354, 1, 1354, 1, 1354, 1, 1354, 1, 1354, + 1, 1354, 1, 1354, 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, + 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, 1, 1355, + 1, 1355, 1, 1355, 1, 1356, 1, 1356, 1, 1356, 1, 1356, 1, 1356, 1, 1356, + 1, 1356, 1, 1356, 1, 1356, 1, 1357, 1, 1357, 1, 1357, 1, 1357, 1, 1357, + 1, 1357, 1, 1358, 1, 1358, 1, 1358, 1, 1358, 1, 1358, 1, 1358, 1, 1358, + 1, 1358, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, + 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1359, 1, 1360, 1, 1360, 1, 1360, + 1, 1360, 1, 1360, 1, 1360, 1, 1360, 1, 1360, 1, 1360, 1, 1360, 1, 1360, + 1, 1361, 1, 1361, 1, 1361, 1, 1361, 1, 1361, 1, 1361, 1, 1361, 1, 1361, + 1, 1361, 1, 1361, 1, 1362, 1, 1362, 1, 1362, 1, 1362, 1, 1362, 1, 1362, + 1, 1362, 1, 1362, 1, 1362, 1, 1362, 1, 1362, 1, 1363, 1, 1363, 1, 1363, + 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, 1, 1363, + 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, 1, 1364, + 1, 1364, 1, 1364, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, 1, 1365, + 1, 1365, 1, 1365, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, 1, 1366, + 1, 1366, 1, 1366, 1, 1367, 1, 1367, 1, 1367, 1, 1367, 1, 1367, 1, 1367, + 1, 1367, 1, 1367, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, 1, 1368, + 1, 1368, 1, 1368, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1369, + 1, 1369, 1, 1369, 1, 1369, 1, 1369, 1, 1370, 1, 1370, 1, 1370, 1, 1370, + 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1370, 1, 1371, 1, 1371, 1, 1371, + 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1371, 1, 1372, + 1, 1372, 1, 1372, 1, 1372, 1, 1372, 1, 1372, 1, 1372, 1, 1372, 1, 1372, + 1, 1372, 1, 1372, 1, 1373, 1, 1373, 1, 1373, 1, 1373, 1, 1373, 1, 1373, + 1, 1373, 1, 1373, 1, 1373, 1, 1374, 1, 1374, 1, 1374, 1, 1374, 1, 1374, + 1, 1374, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, 1, 1375, + 1, 1375, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, 1, 1376, + 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, 1, 1377, + 1, 1377, 1, 1377, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, 1, 1378, + 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, 1, 1379, + 1, 1379, 1, 1379, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1380, + 1, 1380, 1, 1380, 1, 1380, 1, 1380, 1, 1381, 1, 1381, 1, 1381, 1, 1381, + 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, + 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1381, 1, 1382, + 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, 1, 1382, + 1, 1382, 1, 1382, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, + 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, 1, 1383, + 1, 1383, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, 1, 1384, + 1, 1384, 1, 1385, 1, 1385, 1, 1385, 1, 1385, 1, 1385, 1, 1385, 1, 1385, + 1, 1385, 1, 1385, 1, 1386, 1, 1386, 1, 1386, 1, 1386, 1, 1386, 1, 1386, + 1, 1386, 1, 1386, 1, 1386, 1, 1386, 1, 1386, 1, 1386, 1, 1387, 1, 1387, + 1, 1387, 1, 1387, 1, 1387, 1, 1387, 1, 1388, 1, 1388, 1, 1388, 1, 1388, + 1, 1388, 1, 1388, 1, 1388, 1, 1388, 1, 1388, 1, 1388, 1, 1388, 1, 1389, + 1, 1389, 1, 1389, 1, 1389, 1, 1389, 1, 1389, 1, 1390, 1, 1390, 1, 1390, + 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, 1, 1390, + 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, 1, 1391, + 1, 1392, 1, 1392, 1, 1392, 1, 1392, 1, 1392, 1, 1392, 1, 1392, 1, 1393, + 1, 1393, 1, 1393, 1, 1393, 1, 1393, 1, 1393, 1, 1394, 1, 1394, 1, 1394, + 1, 1394, 1, 1394, 1, 1394, 1, 1394, 1, 1394, 1, 1394, 1, 1394, 1, 1394, + 1, 1395, 1, 1395, 1, 1395, 1, 1395, 1, 1395, 1, 1395, 1, 1396, 1, 1396, + 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, 1, 1396, + 1, 1396, 1, 1396, 1, 1396, 1, 1397, 1, 1397, 1, 1397, 1, 1397, 1, 1397, + 1, 1397, 1, 1397, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, 1, 1398, + 1, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1399, 1, 1400, 1, 1400, + 1, 1400, 1, 1400, 1, 1400, 1, 1400, 1, 1400, 1, 1400, 1, 1401, 1, 1401, + 1, 1401, 1, 1401, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, 1, 1402, + 1, 1402, 1, 1402, 1, 1402, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, + 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1403, 1, 1404, 1, 1404, 1, 1404, + 1, 1404, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, + 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1405, 1, 1406, 1, 1406, 1, 1406, + 1, 1406, 1, 1406, 1, 1407, 1, 1407, 1, 1407, 1, 1407, 1, 1407, 1, 1408, + 1, 1408, 1, 1408, 1, 1408, 1, 1408, 1, 1408, 1, 1409, 1, 1409, 1, 1409, + 1, 1409, 1, 1409, 1, 1409, 1, 1410, 1, 1410, 1, 1410, 1, 1410, 1, 1410, + 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, 1, 1411, + 1, 1411, 1, 1411, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, 1, 1412, + 1, 1412, 1, 1412, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, 1, 1413, + 1, 1413, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, + 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, 1, 1414, + 1, 1414, 1, 1414, 1, 1414, 1, 1415, 1, 1415, 1, 1415, 1, 1415, 1, 1415, + 1, 1415, 1, 1415, 1, 1415, 1, 1415, 1, 1415, 1, 1415, 1, 1415, 1, 1416, + 1, 1416, 1, 1416, 1, 1416, 1, 1416, 1, 1416, 1, 1416, 1, 1416, 1, 1417, + 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, 1, 1417, + 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, 1, 1418, + 1, 1418, 1, 1418, 1, 1418, 1, 1419, 1, 1419, 1, 1419, 1, 1419, 1, 1419, + 1, 1419, 1, 1419, 1, 1419, 1, 1420, 1, 1420, 1, 1420, 1, 1420, 1, 1420, + 1, 1420, 1, 1420, 1, 1420, 1, 1420, 1, 1420, 1, 1421, 1, 1421, 1, 1421, + 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1421, 1, 1422, 1, 1422, + 1, 1422, 1, 1422, 1, 1422, 1, 1423, 1, 1423, 1, 1423, 1, 1423, 1, 1423, + 1, 1423, 1, 1423, 1, 1423, 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1424, + 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1424, 1, 1425, 1, 1425, + 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, + 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, 1, 1425, + 1, 1425, 1, 1426, 1, 1426, 1, 1426, 1, 1426, 1, 1426, 1, 1426, 1, 1426, + 1, 1426, 1, 1426, 1, 1426, 1, 1426, 1, 1427, 1, 1427, 1, 1427, 1, 1427, + 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1427, 1, 1428, 1, 1428, + 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, 1, 1428, + 1, 1428, 1, 1429, 1, 1429, 1, 1429, 1, 1429, 1, 1429, 1, 1429, 1, 1429, + 1, 1429, 1, 1429, 1, 1429, 1, 1429, 1, 1429, 1, 1430, 1, 1430, 1, 1430, + 1, 1430, 1, 1431, 1, 1431, 1, 1431, 1, 1431, 1, 1431, 1, 1431, 1, 1431, + 1, 1431, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, 1, 1432, + 1, 1432, 1, 1432, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, + 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1433, 1, 1434, + 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1434, + 1, 1434, 1, 1434, 1, 1434, 1, 1434, 1, 1435, 1, 1435, 1, 1435, 1, 1435, + 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, 1, 1435, + 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, + 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1436, 1, 1437, + 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, + 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1437, 1, 1438, 1, 1438, 1, 1438, + 1, 1438, 1, 1438, 1, 1438, 1, 1438, 1, 1438, 1, 1438, 1, 1439, 1, 1439, + 1, 1439, 1, 1439, 1, 1439, 1, 1439, 1, 1439, 1, 1439, 1, 1439, 1, 1439, + 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, 1, 1440, + 1, 1440, 1, 1440, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, + 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1441, 1, 1442, 1, 1442, 1, 1442, + 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1442, + 1, 1442, 1, 1442, 1, 1442, 1, 1442, 1, 1443, 1, 1443, 1, 1443, 1, 1443, + 1, 1443, 1, 1443, 1, 1443, 1, 1443, 1, 1444, 1, 1444, 1, 1444, 1, 1444, + 1, 1444, 1, 1444, 1, 1444, 1, 1444, 1, 1444, 1, 1444, 1, 1444, 1, 1445, + 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, 1, 1445, + 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, 1, 1446, + 1, 1446, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, 1, 1447, + 1, 1447, 1, 1447, 1, 1448, 1, 1448, 1, 1448, 1, 1448, 1, 1448, 1, 1448, + 1, 1448, 1, 1448, 1, 1449, 1, 1449, 1, 1449, 1, 1449, 1, 1449, 1, 1449, + 1, 1449, 1, 1450, 1, 1450, 1, 1450, 1, 1450, 1, 1450, 1, 1450, 1, 1451, + 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, 1, 1451, + 1, 1451, 1, 1451, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1452, + 1, 1452, 1, 1452, 1, 1452, 1, 1452, 1, 1453, 1, 1453, 1, 1453, 1, 1453, + 1, 1453, 1, 1453, 1, 1453, 1, 1453, 1, 1453, 1, 1454, 1, 1454, 1, 1454, + 1, 1454, 1, 1454, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1455, + 1, 1455, 1, 1455, 1, 1455, 1, 1455, 1, 1456, 1, 1456, 1, 1456, 1, 1456, + 1, 1456, 1, 1456, 1, 1456, 1, 1457, 1, 1457, 1, 1457, 1, 1457, 1, 1457, + 1, 1457, 1, 1457, 1, 1457, 1, 1457, 1, 1457, 1, 1457, 1, 1457, 1, 1457, + 1, 1457, 1, 1458, 1, 1458, 1, 1458, 1, 1458, 1, 1458, 1, 1458, 1, 1458, + 1, 1459, 1, 1459, 1, 1459, 1, 1459, 1, 1459, 1, 1459, 1, 1459, 1, 1460, + 1, 1460, 1, 1460, 1, 1460, 1, 1460, 1, 1460, 1, 1460, 1, 1461, 1, 1461, + 1, 1461, 1, 1461, 1, 1461, 1, 1461, 1, 1461, 1, 1462, 1, 1462, 1, 1462, + 1, 1462, 1, 1462, 1, 1462, 1, 1462, 1, 1462, 1, 1463, 1, 1463, 1, 1463, + 1, 1463, 1, 1463, 1, 1463, 1, 1463, 1, 1463, 1, 1463, 1, 1463, 1, 1463, + 1, 1463, 1, 1464, 1, 1464, 1, 1464, 1, 1464, 1, 1464, 1, 1464, 1, 1464, + 1, 1464, 1, 1464, 1, 1465, 1, 1465, 1, 1465, 1, 1465, 1, 1465, 1, 1465, + 1, 1465, 1, 1465, 1, 1465, 1, 1465, 1, 1466, 1, 1466, 1, 1466, 1, 1466, + 1, 1466, 1, 1466, 1, 1467, 1, 1467, 1, 1467, 1, 1467, 1, 1467, 1, 1467, + 1, 1467, 1, 1468, 1, 1468, 1, 1468, 1, 1468, 1, 1468, 1, 1468, 1, 1468, + 1, 1468, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, 1, 1469, + 1, 1469, 1, 1469, 1, 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1470, 1, 1470, + 1, 1470, 1, 1470, 1, 1470, 1, 1471, 1, 1471, 1, 1471, 1, 1471, 1, 1471, + 1, 1471, 1, 1471, 1, 1471, 1, 1472, 1, 1472, 1, 1472, 1, 1472, 1, 1472, + 1, 1472, 1, 1472, 1, 1472, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, + 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, + 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, 1, 1473, + 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, 1, 1474, + 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, + 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, + 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1475, 1, 1476, 1, 1476, + 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, 1, 1476, + 1, 1476, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, + 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, + 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1477, 1, 1478, 1, 1478, 1, 1478, + 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1478, 1, 1479, 1, 1479, + 1, 1479, 1, 1479, 1, 1479, 1, 1479, 1, 1479, 1, 1479, 1, 1479, 1, 1479, + 1, 1479, 1, 1479, 1, 1479, 1, 1480, 1, 1480, 1, 1480, 1, 1480, 1, 1480, + 1, 1480, 1, 1480, 1, 1481, 1, 1481, 1, 1481, 1, 1481, 1, 1481, 1, 1481, + 1, 1481, 1, 1481, 1, 1481, 1, 1481, 1, 1482, 1, 1482, 1, 1482, 1, 1482, + 1, 1482, 1, 1482, 1, 1482, 1, 1483, 1, 1483, 1, 1483, 1, 1483, 1, 1483, + 1, 1483, 1, 1483, 1, 1483, 1, 1483, 1, 1483, 1, 1484, 1, 1484, 1, 1484, + 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, + 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, 1, 1484, + 1, 1484, 1, 1485, 1, 1485, 1, 1485, 1, 1485, 1, 1485, 1, 1485, 1, 1485, + 1, 1485, 1, 1485, 1, 1485, 1, 1486, 1, 1486, 1, 1486, 1, 1486, 1, 1486, + 1, 1486, 1, 1486, 1, 1487, 1, 1487, 1, 1487, 1, 1487, 1, 1487, 1, 1487, + 1, 1488, 1, 1488, 1, 1488, 1, 1488, 1, 1488, 1, 1488, 1, 1488, 1, 1488, + 1, 1489, 1, 1489, 1, 1489, 1, 1489, 1, 1489, 1, 1489, 1, 1489, 1, 1490, + 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, + 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, 1, 1490, + 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, 1, 1491, + 1, 1492, 1, 1492, 1, 1492, 1, 1492, 1, 1492, 1, 1492, 1, 1493, 1, 1493, + 1, 1493, 1, 1493, 1, 1493, 1, 1494, 1, 1494, 1, 1494, 1, 1494, 1, 1494, + 1, 1494, 1, 1494, 1, 1494, 1, 1495, 1, 1495, 1, 1495, 1, 1495, 1, 1495, + 1, 1495, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, 1, 1496, + 1, 1496, 1, 1496, 1, 1497, 1, 1497, 1, 1497, 1, 1497, 1, 1497, 1, 1497, + 1, 1497, 1, 1497, 1, 1498, 1, 1498, 1, 1498, 1, 1498, 1, 1498, 1, 1498, + 1, 1498, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, + 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, 1, 1499, + 1, 1499, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, + 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, + 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1500, 1, 1501, 1, 1501, 1, 1501, + 1, 1501, 1, 1501, 1, 1501, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, + 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1502, 1, 1503, + 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1503, + 1, 1503, 1, 1503, 1, 1503, 1, 1503, 1, 1504, 1, 1504, 1, 1504, 1, 1504, + 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1504, 1, 1505, + 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1505, 1, 1506, 1, 1506, + 1, 1506, 1, 1506, 1, 1507, 1, 1507, 1, 1507, 1, 1507, 1, 1507, 1, 1508, + 1, 1508, 1, 1508, 1, 1508, 1, 1508, 1, 1509, 1, 1509, 1, 1509, 1, 1509, + 1, 1509, 1, 1509, 1, 1510, 1, 1510, 1, 1510, 1, 1510, 1, 1510, 1, 1511, + 1, 1511, 1, 1511, 1, 1511, 1, 1511, 1, 1511, 1, 1512, 1, 1512, 1, 1512, + 1, 1512, 1, 1512, 1, 1512, 1, 1512, 1, 1512, 1, 1513, 1, 1513, 1, 1513, + 1, 1513, 1, 1513, 1, 1514, 1, 1514, 1, 1514, 1, 1514, 1, 1514, 1, 1514, + 1, 1514, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, + 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, 1, 1515, + 1, 1515, 1, 1515, 1, 1515, 1, 1516, 1, 1516, 1, 1516, 1, 1516, 1, 1516, + 1, 1516, 1, 1516, 1, 1516, 1, 1516, 1, 1516, 1, 1517, 1, 1517, 1, 1517, + 1, 1517, 1, 1517, 1, 1518, 1, 1518, 1, 1518, 1, 1518, 1, 1519, 1, 1519, + 1, 1519, 1, 1519, 1, 1519, 1, 1519, 1, 1519, 1, 1519, 1, 1519, 1, 1519, + 1, 1519, 1, 1520, 1, 1520, 1, 1520, 1, 1520, 1, 1520, 1, 1520, 1, 1521, + 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, + 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1521, 1, 1522, 1, 1522, + 1, 1522, 1, 1522, 1, 1522, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, + 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1523, 1, 1524, 1, 1524, 1, 1524, + 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, 1, 1524, + 1, 1524, 1, 1525, 1, 1525, 1, 1525, 1, 1525, 1, 1525, 1, 1525, 1, 1525, + 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, + 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1526, 1, 1527, 1, 1527, + 1, 1527, 1, 1527, 1, 1528, 1, 1528, 1, 1528, 1, 1528, 1, 1528, 1, 1528, + 1, 1529, 1, 1529, 1, 1529, 1, 1529, 1, 1529, 1, 1529, 1, 1530, 1, 1530, + 1, 1530, 1, 1530, 1, 1530, 1, 1530, 1, 1530, 1, 1531, 1, 1531, 1, 1531, + 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, 1, 1531, + 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, + 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1532, 1, 1533, 1, 1533, 1, 1533, + 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, 1, 1533, + 1, 1533, 1, 1533, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, 1, 1534, + 1, 1534, 1, 1534, 1, 1535, 1, 1535, 1, 1535, 1, 1535, 1, 1535, 1, 1535, + 1, 1535, 1, 1536, 1, 1536, 1, 1536, 1, 1536, 1, 1536, 1, 1536, 1, 1536, + 1, 1537, 1, 1537, 1, 1537, 1, 1537, 1, 1537, 1, 1537, 1, 1537, 1, 1537, + 1, 1538, 1, 1538, 1, 1538, 1, 1538, 1, 1538, 1, 1538, 1, 1538, 1, 1539, + 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, + 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1539, 1, 1540, 1, 1540, + 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, 1, 1540, + 1, 1540, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, 1, 1541, + 1, 1541, 1, 1541, 1, 1542, 1, 1542, 1, 1542, 1, 1542, 1, 1542, 1, 1543, + 1, 1543, 1, 1543, 1, 1543, 1, 1543, 1, 1543, 1, 1543, 1, 1543, 1, 1543, + 1, 1543, 1, 1544, 1, 1544, 1, 1544, 1, 1544, 1, 1544, 1, 1544, 1, 1544, + 1, 1544, 1, 1544, 1, 1545, 1, 1545, 1, 1545, 1, 1545, 1, 1545, 1, 1545, + 1, 1545, 1, 1545, 1, 1546, 1, 1546, 1, 1546, 1, 1546, 1, 1546, 1, 1546, + 1, 1546, 1, 1546, 1, 1546, 1, 1546, 1, 1546, 1, 1546, 1, 1547, 1, 1547, + 1, 1547, 1, 1547, 1, 1547, 1, 1547, 1, 1547, 1, 1548, 1, 1548, 1, 1548, + 1, 1548, 1, 1548, 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, + 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, 1, 1549, + 1, 1549, 1, 1549, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, 1, 1550, + 1, 1550, 1, 1550, 1, 1550, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, + 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, 1, 1551, + 1, 1551, 1, 1552, 1, 1552, 1, 1552, 1, 1552, 1, 1552, 1, 1552, 1, 1552, + 1, 1552, 1, 1552, 1, 1552, 1, 1553, 1, 1553, 1, 1553, 1, 1553, 1, 1553, + 1, 1553, 1, 1553, 1, 1553, 1, 1553, 1, 1554, 1, 1554, 1, 1554, 1, 1554, + 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1554, 1, 1555, + 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1555, + 1, 1555, 1, 1555, 1, 1555, 1, 1555, 1, 1556, 1, 1556, 1, 1556, 1, 1556, + 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, + 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1556, 1, 1557, 1, 1557, + 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1557, 1, 1558, 1, 1558, 1, 1558, + 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, 1, 1558, + 1, 1558, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, + 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, + 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1559, 1, 1560, 1, 1560, + 1, 1560, 1, 1560, 1, 1560, 1, 1560, 1, 1560, 1, 1560, 1, 1561, 1, 1561, + 1, 1561, 1, 1561, 1, 1561, 1, 1561, 1, 1561, 1, 1561, 1, 1561, 1, 1562, + 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, + 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, + 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1562, 1, 1563, 1, 1563, + 1, 1563, 1, 1563, 1, 1563, 1, 1563, 1, 1563, 1, 1563, 1, 1564, 1, 1564, + 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, + 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, 1, 1564, + 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, + 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, 1, 1565, + 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, + 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1566, 1, 1567, 1, 1567, + 1, 1567, 1, 1567, 1, 1568, 1, 1568, 1, 1568, 1, 1568, 1, 1568, 1, 1569, + 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, 1, 1569, + 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1570, + 1, 1570, 1, 1570, 1, 1570, 1, 1570, 1, 1571, 1, 1571, 1, 1571, 1, 1571, + 1, 1571, 1, 1571, 1, 1571, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, + 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1572, 1, 1573, 1, 1573, + 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, 1, 1573, + 1, 1573, 1, 1573, 1, 1574, 1, 1574, 1, 1574, 1, 1574, 1, 1574, 1, 1574, + 1, 1574, 1, 1575, 1, 1575, 1, 1575, 1, 1575, 1, 1575, 1, 1575, 1, 1576, + 1, 1576, 1, 1576, 1, 1576, 1, 1576, 1, 1576, 1, 1576, 1, 1576, 1, 1577, + 1, 1577, 1, 1577, 1, 1577, 1, 1577, 1, 1577, 1, 1577, 1, 1577, 1, 1577, + 1, 1577, 1, 1578, 1, 1578, 1, 1578, 1, 1578, 1, 1578, 1, 1579, 1, 1579, + 1, 1579, 1, 1579, 1, 1579, 1, 1579, 1, 1579, 1, 1580, 1, 1580, 1, 1580, + 1, 1580, 1, 1580, 1, 1580, 1, 1580, 1, 1580, 1, 1580, 1, 1581, 1, 1581, + 1, 1581, 1, 1581, 1, 1581, 1, 1581, 1, 1581, 1, 1581, 1, 1581, 1, 1582, + 1, 1582, 1, 1582, 1, 1582, 1, 1583, 1, 1583, 1, 1583, 1, 1583, 1, 1583, + 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, + 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, 1, 1584, + 1, 1584, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, + 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, 1, 1585, + 1, 1585, 1, 1586, 1, 1586, 1, 1586, 1, 1586, 1, 1586, 1, 1587, 1, 1587, + 1, 1587, 1, 1587, 1, 1587, 1, 1587, 1, 1587, 1, 1587, 1, 1587, 1, 1588, + 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, + 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1588, 1, 1589, 1, 1589, + 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1589, 1, 1590, 1, 1590, 1, 1590, + 1, 1590, 1, 1590, 1, 1590, 1, 1590, 1, 1591, 1, 1591, 1, 1591, 1, 1591, + 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1591, 1, 1592, + 1, 1592, 1, 1592, 1, 1592, 1, 1592, 1, 1593, 1, 1593, 1, 1593, 1, 1593, + 1, 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1594, 1, 1595, 1, 1595, 1, 1595, + 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, + 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, 1, 1595, + 1, 1596, 1, 1596, 1, 1596, 1, 1596, 1, 1596, 1, 1597, 1, 1597, 1, 1597, + 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, + 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, 1, 1597, + 1, 1597, 1, 1597, 1, 1597, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, + 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, + 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, 1, 1598, + 1, 1598, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, 1, 1599, + 1, 1599, 1, 1599, 1, 1599, 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1600, + 1, 1600, 1, 1600, 1, 1600, 1, 1600, 1, 1601, 1, 1601, 1, 1601, 1, 1601, + 1, 1601, 1, 1601, 1, 1601, 1, 1601, 1, 1601, 1, 1602, 1, 1602, 1, 1602, + 1, 1602, 1, 1602, 1, 1603, 1, 1603, 1, 1603, 1, 1603, 1, 1603, 1, 1604, + 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1604, 1, 1605, + 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, + 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, + 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1605, 1, 1606, 1, 1606, 1, 1606, + 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, + 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, + 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1606, 1, 1607, 1, 1607, + 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1607, 1, 1608, 1, 1608, 1, 1608, + 1, 1608, 1, 1608, 1, 1608, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, + 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, 1, 1609, + 1, 1609, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, 1, 1610, + 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1611, 1, 1612, 1, 1612, + 1, 1612, 1, 1612, 1, 1612, 1, 1612, 1, 1612, 1, 1612, 1, 1612, 1, 1612, + 1, 1612, 1, 1612, 1, 1613, 1, 1613, 1, 1613, 1, 1613, 1, 1613, 1, 1613, + 1, 1613, 1, 1613, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, 1, 1614, + 1, 1614, 1, 1614, 1, 1614, 1, 1615, 1, 1615, 1, 1615, 1, 1615, 1, 1615, + 1, 1615, 1, 1615, 1, 1616, 1, 1616, 1, 1616, 1, 1616, 1, 1617, 1, 1617, + 1, 1617, 1, 1617, 1, 1617, 1, 1617, 1, 1617, 1, 1617, 1, 1617, 1, 1617, + 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, 1, 1618, + 1, 1618, 1, 1618, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, + 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, + 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, 1, 1619, + 1, 1619, 1, 1619, 1, 1620, 1, 1620, 1, 1620, 1, 1620, 1, 1620, 1, 1621, + 1, 1621, 1, 1621, 1, 1621, 1, 1621, 1, 1621, 1, 1622, 1, 1622, 1, 1622, + 1, 1622, 1, 1622, 1, 1622, 1, 1622, 1, 1622, 1, 1622, 1, 1622, 1, 1622, + 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, 1, 1623, + 1, 1623, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, + 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1624, 1, 1625, + 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, + 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, + 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1625, 1, 1626, 1, 1626, + 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1626, 1, 1627, + 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1627, 1, 1628, + 1, 1628, 1, 1628, 1, 1628, 1, 1628, 1, 1629, 1, 1629, 1, 1629, 1, 1629, + 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, + 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, 1, 1629, + 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1630, 1, 1631, 1, 1631, + 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1631, 1, 1632, 1, 1632, + 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, 1, 1632, + 1, 1632, 1, 1632, 1, 1632, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, + 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, + 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1633, 1, 1634, 1, 1634, 1, 1634, + 1, 1634, 1, 1634, 1, 1634, 1, 1634, 1, 1634, 1, 1634, 1, 1634, 1, 1634, + 1, 1635, 1, 1635, 1, 1635, 1, 1635, 1, 1635, 1, 1635, 1, 1635, 1, 1635, + 1, 1635, 1, 1635, 1, 1636, 1, 1636, 1, 1636, 1, 1636, 1, 1636, 1, 1636, + 1, 1637, 1, 1637, 1, 1637, 1, 1637, 1, 1637, 1, 1637, 1, 1637, 1, 1638, + 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, 1, 1638, + 1, 1638, 1, 1638, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, + 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, + 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1639, 1, 1640, 1, 1640, + 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1640, + 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1640, 1, 1641, 1, 1641, 1, 1641, + 1, 1641, 1, 1641, 1, 1641, 1, 1641, 1, 1641, 1, 1641, 1, 1641, 1, 1641, + 1, 1641, 1, 1641, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, + 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, 1, 1642, + 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, 1, 1643, + 1, 1643, 1, 1643, 1, 1643, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, + 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, 1, 1644, + 1, 1644, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, + 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, + 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1645, 1, 1646, 1, 1646, 1, 1646, + 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, + 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, 1, 1646, + 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, + 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1647, + 1, 1647, 1, 1647, 1, 1647, 1, 1647, 1, 1648, 1, 1648, 1, 1648, 1, 1648, + 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, + 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1648, 1, 1649, 1, 1649, 1, 1649, + 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, + 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, 1, 1649, + 1, 1649, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, + 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, 1, 1650, + 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, 1, 1651, + 1, 1651, 1, 1651, 1, 1651, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, + 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1652, 1, 1653, + 1, 1653, 1, 1653, 1, 1653, 1, 1653, 1, 1654, 1, 1654, 1, 1654, 1, 1654, + 1, 1654, 1, 1654, 1, 1654, 1, 1654, 1, 1655, 1, 1655, 1, 1655, 1, 1655, + 1, 1655, 1, 1655, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1656, 1, 1656, + 1, 1656, 1, 1656, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, 1, 1657, + 1, 1657, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, 1, 1658, + 1, 1659, 1, 1659, 1, 1659, 1, 1659, 1, 1659, 1, 1659, 1, 1659, 1, 1660, + 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, + 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1660, 1, 1661, 1, 1661, + 1, 1661, 1, 1661, 1, 1661, 1, 1661, 1, 1661, 1, 1661, 1, 1661, 1, 1661, + 1, 1661, 1, 1661, 1, 1661, 1, 1662, 1, 1662, 1, 1662, 1, 1662, 1, 1662, + 1, 1662, 1, 1663, 1, 1663, 1, 1663, 1, 1663, 1, 1663, 1, 1663, 1, 1663, + 1, 1663, 1, 1663, 1, 1663, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, + 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1664, 1, 1665, + 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, + 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, 1, 1665, + 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, + 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1666, 1, 1667, 1, 1667, + 1, 1667, 1, 1667, 1, 1667, 1, 1667, 1, 1667, 1, 1667, 1, 1667, 1, 1667, + 1, 1667, 1, 1667, 1, 1667, 1, 1668, 1, 1668, 1, 1668, 1, 1668, 1, 1668, + 1, 1668, 1, 1668, 1, 1668, 1, 1668, 1, 1668, 1, 1668, 1, 1669, 1, 1669, + 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, + 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1669, 1, 1670, + 1, 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1670, 1, 1670, + 1, 1670, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, 1671, 1, 1671, + 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, + 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1672, 1, 1673, 1, 1673, + 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1673, 1, 1674, 1, 1674, + 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1674, 1, 1675, 1, 1675, + 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1675, 1, 1676, 1, 1676, + 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1676, 1, 1677, 1, 1677, + 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1677, 1, 1678, 1, 1678, + 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, 1, 1678, + 1, 1678, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, 1, 1679, + 1, 1679, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, 1, 1680, + 1, 1680, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, + 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1681, 1, 1682, 1, 1682, + 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1682, 1, 1683, 1, 1683, + 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, + 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1683, 1, 1684, + 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, 1, 1684, + 1, 1684, 1, 1684, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, 1, 1685, + 1, 1685, 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1686, + 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1686, 1, 1687, 1, 1687, 1, 1687, + 1, 1687, 1, 1687, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, 1, 1688, + 1, 1688, 1, 1688, 1, 1689, 1, 1689, 1, 1689, 1, 1689, 1, 1690, 1, 1690, + 1, 1690, 1, 1690, 1, 1690, 1, 1690, 1, 1690, 1, 1691, 1, 1691, 1, 1691, + 1, 1691, 1, 1691, 1, 1691, 1, 1691, 1, 1691, 1, 1691, 1, 1691, 1, 1692, + 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1692, 1, 1693, 1, 1693, + 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, 1, 1693, + 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, + 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1694, 1, 1695, 1, 1695, 1, 1695, + 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, + 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, 1, 1695, + 1, 1695, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, + 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, + 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1696, 1, 1697, 1, 1697, 1, 1697, + 1, 1697, 1, 1697, 1, 1697, 1, 1697, 1, 1697, 1, 1697, 1, 1697, 1, 1697, + 1, 1697, 1, 1698, 1, 1698, 1, 1698, 1, 1698, 1, 1698, 1, 1698, 1, 1698, + 1, 1698, 1, 1699, 1, 1699, 1, 1699, 1, 1699, 1, 1699, 1, 1699, 1, 1699, + 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, + 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1700, 1, 1701, 1, 1701, 1, 1701, + 1, 1701, 1, 1701, 1, 1701, 1, 1702, 1, 1702, 1, 1702, 1, 1702, 1, 1702, + 1, 1702, 1, 1702, 1, 1702, 1, 1702, 1, 1702, 1, 1702, 1, 1702, 1, 1702, + 1, 1702, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, + 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, 1, 1703, + 1, 1703, 1, 1703, 1, 1703, 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, + 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, + 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1704, 1, 1705, 1, 1705, 1, 1705, + 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1705, + 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1705, 1, 1706, 1, 1706, 1, 1706, + 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, + 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1706, 1, 1707, 1, 1707, + 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, + 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1707, 1, 1708, + 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, + 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, 1, 1708, + 1, 1708, 1, 1708, 1, 1708, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, + 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, + 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, 1, 1709, + 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, + 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, + 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1710, 1, 1711, 1, 1711, 1, 1711, + 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, + 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, 1, 1711, + 1, 1711, 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1712, + 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1712, 1, 1713, 1, 1713, + 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, + 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1713, 1, 1714, 1, 1714, + 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, + 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1714, 1, 1715, 1, 1715, 1, 1715, + 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, + 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1715, 1, 1716, 1, 1716, 1, 1716, + 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, 1, 1716, + 1, 1716, 1, 1716, 1, 1716, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, + 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, 1, 1717, + 1, 1717, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, + 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, 1, 1718, + 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, + 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, 1, 1719, + 1, 1719, 1, 1719, 1, 1719, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, + 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, + 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1720, 1, 1721, 1, 1721, + 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1721, + 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1721, 1, 1722, 1, 1722, 1, 1722, + 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, 1, 1722, + 1, 1722, 1, 1722, 1, 1722, 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1723, + 1, 1723, 1, 1723, 1, 1723, 1, 1723, 1, 1724, 1, 1724, 1, 1724, 1, 1724, + 1, 1724, 1, 1724, 1, 1724, 1, 1724, 1, 1725, 1, 1725, 1, 1725, 1, 1725, + 1, 1725, 1, 1725, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, + 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, + 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1726, 1, 1727, 1, 1727, 1, 1727, + 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, 1, 1727, + 1, 1727, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, + 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1728, 1, 1729, + 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, 1, 1729, + 1, 1729, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, 1, 1730, + 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, + 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1731, 1, 1732, + 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, + 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1732, 1, 1733, 1, 1733, + 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, + 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1733, 1, 1734, 1, 1734, + 1, 1734, 1, 1734, 1, 1734, 1, 1734, 1, 1734, 1, 1734, 1, 1734, 1, 1734, + 1, 1734, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, + 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, 1, 1735, + 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, + 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1736, 1, 1737, 1, 1737, + 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, 1, 1737, + 1, 1737, 1, 1737, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, + 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, + 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, 1, 1738, + 1, 1738, 1, 1738, 1, 1738, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, + 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, + 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1739, 1, 1740, + 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, 1, 1740, + 1, 1740, 1, 1740, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, + 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1741, 1, 1742, 1, 1742, + 1, 1742, 1, 1742, 1, 1742, 1, 1742, 1, 1742, 1, 1742, 1, 1742, 1, 1742, + 1, 1742, 1, 1743, 1, 1743, 1, 1743, 1, 1743, 1, 1743, 1, 1743, 1, 1743, + 1, 1743, 1, 1743, 1, 1743, 1, 1743, 1, 1743, 1, 1744, 1, 1744, 1, 1744, + 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, + 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, 1, 1744, + 1, 1744, 1, 1744, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, + 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1745, 1, 1746, 1, 1746, + 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, + 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1746, 1, 1747, 1, 1747, 1, 1747, + 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, + 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1747, 1, 1748, 1, 1748, 1, 1748, + 1, 1748, 1, 1748, 1, 1748, 1, 1748, 1, 1748, 1, 1748, 1, 1748, 1, 1748, + 1, 1748, 1, 1748, 1, 1748, 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, + 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, + 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1749, 1, 1750, 1, 1750, 1, 1750, + 1, 1750, 1, 1750, 1, 1750, 1, 1750, 1, 1750, 1, 1750, 1, 1750, 1, 1750, + 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, + 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, 1, 1751, + 1, 1751, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, + 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, 1, 1752, + 1, 1752, 1, 1752, 1, 1752, 1, 1753, 1, 1753, 1, 1753, 1, 1753, 1, 1753, + 1, 1753, 1, 1753, 1, 1753, 1, 1753, 1, 1753, 1, 1753, 1, 1753, 1, 1753, + 1, 1753, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, + 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, 1, 1754, + 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, + 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, 1, 1755, + 1, 1756, 1, 1756, 1, 1756, 1, 1756, 1, 1756, 1, 1756, 1, 1756, 1, 1756, + 1, 1756, 1, 1756, 1, 1756, 1, 1757, 1, 1757, 1, 1757, 1, 1757, 1, 1757, + 1, 1757, 1, 1757, 1, 1757, 1, 1757, 1, 1757, 1, 1757, 1, 1757, 1, 1758, + 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, + 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1758, 1, 1759, + 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, + 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, + 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, 1, 1759, + 1, 1760, 1, 1760, 1, 1760, 1, 1760, 1, 1760, 1, 1760, 1, 1760, 1, 1760, + 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, + 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1761, 1, 1762, + 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, + 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1762, 1, 1763, + 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, 1, 1763, + 1, 1763, 1, 1763, 1, 1763, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, + 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1764, 1, 1765, + 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, 1, 1765, + 1, 1765, 1, 1765, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, + 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1766, 1, 1767, 1, 1767, 1, 1767, + 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, + 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, + 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1767, 1, 1768, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1768, + 1, 1768, 1, 1768, 1, 1768, 1, 1768, 1, 1769, 1, 1769, 1, 1769, 1, 1769, + 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, + 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, + 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1769, 1, 1770, 1, 1770, 1, 1770, + 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, + 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, + 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, 1, 1770, + 1, 1770, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, + 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, + 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1771, 1, 1772, + 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, 1, 1772, + 1, 1772, 1, 1772, 1, 1772, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, + 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, + 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1773, 1, 1774, 1, 1774, + 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, + 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, 1, 1774, + 1, 1774, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, + 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, 1, 1775, + 1, 1775, 1, 1775, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, + 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, + 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1776, 1, 1777, 1, 1777, + 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, + 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, 1, 1777, + 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1778, + 1, 1778, 1, 1778, 1, 1778, 1, 1778, 1, 1779, 1, 1779, 1, 1779, 1, 1779, + 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1779, 1, 1780, + 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, + 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1780, 1, 1781, 1, 1781, + 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, + 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, 1, 1781, + 1, 1781, 1, 1782, 1, 1782, 1, 1782, 1, 1782, 1, 1782, 1, 1782, 1, 1782, + 1, 1782, 1, 1782, 1, 1782, 1, 1782, 1, 1783, 1, 1783, 1, 1783, 1, 1783, + 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1783, + 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1783, 1, 1784, 1, 1784, 1, 1784, + 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, + 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1784, 1, 1785, 1, 1785, + 1, 1785, 1, 1785, 1, 1785, 1, 1785, 1, 1785, 1, 1785, 1, 1785, 1, 1785, + 1, 1785, 1, 1786, 1, 1786, 1, 1786, 1, 1786, 1, 1786, 1, 1786, 1, 1786, + 1, 1786, 1, 1786, 1, 1786, 1, 1786, 1, 1787, 1, 1787, 1, 1787, 1, 1787, + 1, 1787, 1, 1787, 1, 1787, 1, 1787, 1, 1787, 1, 1787, 1, 1787, 1, 1787, + 1, 1787, 1, 1787, 1, 1787, 1, 1787, 1, 1788, 1, 1788, 1, 1788, 1, 1788, + 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, 1, 1788, + 1, 1788, 1, 1788, 1, 1788, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, + 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, 1, 1789, + 1, 1789, 1, 1789, 1, 1789, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, + 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, 1, 1790, + 1, 1790, 1, 1790, 1, 1790, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, + 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, 1, 1791, + 1, 1791, 1, 1791, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, + 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1792, 1, 1793, + 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, + 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1793, 1, 1794, + 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, + 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1794, 1, 1795, 1, 1795, 1, 1795, + 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, 1, 1795, + 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, + 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1796, 1, 1797, + 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1797, + 1, 1797, 1, 1797, 1, 1797, 1, 1797, 1, 1798, 1, 1798, 1, 1798, 1, 1798, + 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1798, 1, 1799, + 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, + 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1799, 1, 1800, + 1, 1800, 1, 1800, 1, 1800, 1, 1800, 1, 1800, 1, 1800, 1, 1800, 1, 1800, + 1, 1800, 1, 1800, 1, 1800, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, + 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1801, 1, 1802, 1, 1802, + 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, 1, 1802, + 1, 1802, 1, 1802, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, + 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1803, + 1, 1803, 1, 1803, 1, 1803, 1, 1803, 1, 1804, 1, 1804, 1, 1804, 1, 1804, + 1, 1804, 1, 1804, 1, 1804, 1, 1804, 1, 1804, 1, 1804, 1, 1804, 1, 1805, + 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, + 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1805, 1, 1806, + 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, + 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1806, 1, 1807, 1, 1807, + 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, 1, 1807, + 1, 1807, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, + 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1808, 1, 1809, 1, 1809, 1, 1809, + 1, 1809, 1, 1809, 1, 1809, 1, 1809, 1, 1809, 1, 1809, 1, 1809, 1, 1809, + 1, 1809, 1, 1809, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, + 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1810, + 1, 1810, 1, 1810, 1, 1810, 1, 1810, 1, 1811, 1, 1811, 1, 1811, 1, 1811, + 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, + 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1811, 1, 1812, 1, 1812, 1, 1812, + 1, 1812, 1, 1812, 1, 1812, 1, 1812, 1, 1812, 1, 1812, 1, 1812, 1, 1812, + 1, 1812, 1, 1812, 1, 1812, 1, 1813, 1, 1813, 1, 1813, 1, 1813, 1, 1813, + 1, 1813, 1, 1813, 1, 1813, 1, 1813, 1, 1813, 1, 1813, 1, 1813, 1, 1813, + 1, 1813, 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1814, + 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1814, 1, 1815, 1, 1815, + 1, 1815, 1, 1815, 1, 1815, 1, 1815, 1, 1815, 1, 1815, 1, 1815, 1, 1815, + 1, 1815, 1, 1815, 1, 1815, 1, 1815, 1, 1816, 1, 1816, 1, 1816, 1, 1816, + 1, 1816, 1, 1816, 1, 1816, 1, 1816, 1, 1816, 1, 1816, 1, 1816, 1, 1816, + 1, 1816, 1, 1816, 1, 1816, 1, 1817, 1, 1817, 1, 1817, 1, 1817, 1, 1817, + 1, 1817, 1, 1817, 1, 1817, 1, 1817, 1, 1817, 1, 1817, 1, 1817, 1, 1818, + 1, 1818, 1, 1818, 1, 1818, 1, 1818, 1, 1818, 1, 1818, 1, 1818, 1, 1818, + 1, 1818, 1, 1818, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, + 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, + 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, 1, 1819, + 1, 1819, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, + 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, 1, 1820, + 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, + 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1821, 1, 1822, + 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, + 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1822, 1, 1823, 1, 1823, 1, 1823, + 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, + 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1823, 1, 1824, 1, 1824, + 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, + 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1824, 1, 1825, 1, 1825, 1, 1825, + 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, + 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, 1, 1825, + 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, + 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, + 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1826, 1, 1827, 1, 1827, + 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, + 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, 1, 1827, + 1, 1827, 1, 1827, 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, + 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, 1, 1828, + 1, 1828, 1, 1828, 1, 1828, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, + 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, + 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1829, 1, 1830, 1, 1830, + 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, + 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, 1, 1830, + 1, 1830, 1, 1830, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, + 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, + 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1831, 1, 1832, 1, 1832, + 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, + 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, 1, 1832, + 1, 1832, 1, 1832, 1, 1832, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, + 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1833, + 1, 1833, 1, 1833, 1, 1833, 1, 1833, 1, 1834, 1, 1834, 1, 1834, 1, 1834, + 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, 1, 1834, + 1, 1834, 1, 1834, 1, 1834, 1, 1835, 1, 1835, 1, 1835, 1, 1835, 1, 1835, + 1, 1835, 1, 1835, 1, 1835, 1, 1835, 1, 1835, 1, 1835, 1, 1835, 1, 1835, + 1, 1835, 1, 1835, 1, 1835, 1, 1836, 1, 1836, 1, 1836, 1, 1836, 1, 1836, + 1, 1836, 1, 1836, 1, 1836, 1, 1836, 1, 1836, 1, 1836, 1, 1836, 1, 1836, + 1, 1836, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, + 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1837, 1, 1838, + 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, + 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1838, 1, 1839, 1, 1839, 1, 1839, + 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1839, + 1, 1839, 1, 1839, 1, 1839, 1, 1839, 1, 1840, 1, 1840, 1, 1840, 1, 1840, + 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, 1, 1840, + 1, 1840, 1, 1840, 1, 1840, 1, 1841, 1, 1841, 1, 1841, 1, 1841, 1, 1841, + 1, 1841, 1, 1841, 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1842, + 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1842, 1, 1843, + 1, 1843, 1, 1843, 1, 1843, 1, 1843, 1, 1843, 1, 1843, 1, 1843, 1, 1843, + 1, 1843, 1, 1843, 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1844, + 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1844, 1, 1845, + 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, + 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1845, 1, 1846, 1, 1846, + 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, + 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1846, 1, 1847, 1, 1847, + 1, 1847, 1, 1847, 1, 1847, 1, 1847, 1, 1847, 1, 1847, 1, 1847, 1, 1847, + 1, 1847, 1, 1847, 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, + 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, 1, 1848, + 1, 1848, 1, 1849, 1, 1849, 1, 1849, 1, 1849, 1, 1849, 1, 1849, 1, 1849, + 1, 1849, 1, 1849, 1, 1849, 1, 1849, 1, 1850, 1, 1850, 1, 1850, 1, 1850, + 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, + 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, 1, 1850, + 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, + 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1851, + 1, 1851, 1, 1851, 1, 1851, 1, 1851, 1, 1852, 1, 1852, 1, 1852, 1, 1852, + 1, 1852, 1, 1852, 1, 1852, 1, 1852, 1, 1852, 1, 1852, 1, 1852, 1, 1852, + 1, 1852, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, + 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, + 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, 1, 1853, + 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, + 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, + 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1854, 1, 1855, 1, 1855, 1, 1855, + 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, + 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, + 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1855, 1, 1856, 1, 1856, + 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, + 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1856, + 1, 1856, 1, 1856, 1, 1856, 1, 1856, 1, 1857, 1, 1857, 1, 1857, 1, 1857, + 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, + 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1857, + 1, 1857, 1, 1857, 1, 1857, 1, 1857, 1, 1858, 1, 1858, 1, 1858, 1, 1858, + 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, + 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, 1, 1858, + 1, 1858, 1, 1858, 1, 1858, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, + 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, + 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, 1, 1859, + 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, + 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, + 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1860, 1, 1861, 1, 1861, + 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, + 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, 1, 1861, + 1, 1861, 1, 1861, 1, 1861, 1, 1862, 1, 1862, 1, 1862, 1, 1862, 1, 1862, + 1, 1862, 1, 1862, 1, 1862, 1, 1862, 1, 1862, 1, 1862, 1, 1862, 1, 1862, + 1, 1862, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, + 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1863, 1, 1864, + 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, + 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, 1, 1864, + 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, + 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, 1, 1865, + 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, + 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1866, 1, 1867, + 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, + 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, 1, 1867, + 1, 1867, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, + 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1868, 1, 1869, + 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, + 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, 1, 1869, + 1, 1869, 1, 1869, 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, + 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, 1, 1870, + 1, 1870, 1, 1870, 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, + 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, 1, 1871, + 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, + 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1872, 1, 1873, 1, 1873, + 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, 1, 1873, + 1, 1873, 1, 1873, 1, 1873, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, + 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, 1, 1874, + 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, + 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, 1, 1875, + 1, 1875, 1, 1875, 1, 1875, 1, 1876, 1, 1876, 1, 1876, 1, 1876, 1, 1876, + 1, 1876, 1, 1876, 1, 1876, 1, 1876, 1, 1876, 1, 1877, 1, 1877, 1, 1877, + 1, 1877, 1, 1877, 1, 1877, 1, 1877, 1, 1877, 1, 1877, 1, 1877, 1, 1877, + 1, 1877, 1, 1877, 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1878, + 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1878, 1, 1879, + 1, 1879, 1, 1879, 1, 1879, 1, 1879, 1, 1879, 1, 1879, 1, 1879, 1, 1879, + 1, 1879, 1, 1879, 1, 1879, 1, 1879, 1, 1880, 1, 1880, 1, 1880, 1, 1880, + 1, 1880, 1, 1880, 1, 1880, 1, 1880, 1, 1880, 1, 1880, 1, 1880, 1, 1880, + 1, 1880, 1, 1880, 1, 1880, 1, 1881, 1, 1881, 1, 1881, 1, 1881, 1, 1881, + 1, 1881, 1, 1881, 1, 1881, 1, 1881, 1, 1881, 1, 1881, 1, 1882, 1, 1882, + 1, 1882, 1, 1882, 1, 1882, 1, 1882, 1, 1882, 1, 1882, 1, 1882, 1, 1882, + 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, + 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, 1, 1883, + 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, + 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1884, 1, 1885, + 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1885, + 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1885, 1, 1886, 1, 1886, 1, 1886, + 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, 1, 1886, + 1, 1886, 1, 1886, 1, 1886, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, + 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, 1, 1887, + 1, 1887, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, + 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1888, 1, 1889, 1, 1889, 1, 1889, + 1, 1889, 1, 1889, 1, 1889, 1, 1889, 1, 1889, 1, 1889, 1, 1889, 1, 1889, + 1, 1889, 1, 1889, 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1890, + 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1890, 1, 1891, + 1, 1891, 1, 1891, 1, 1891, 1, 1891, 1, 1891, 1, 1891, 1, 1891, 1, 1891, + 1, 1891, 1, 1891, 1, 1891, 1, 1892, 1, 1892, 1, 1892, 1, 1892, 1, 1892, + 1, 1892, 1, 1892, 1, 1892, 1, 1892, 1, 1892, 1, 1892, 1, 1892, 1, 1892, + 1, 1892, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, + 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1893, 1, 1894, + 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, 1, 1894, + 1, 1894, 1, 1894, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, + 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, 1, 1895, + 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, + 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, 1, 1896, + 1, 1896, 1, 1896, 1, 1897, 1, 1897, 1, 1897, 1, 1897, 1, 1897, 1, 1897, + 1, 1897, 1, 1897, 1, 1897, 1, 1897, 1, 1897, 1, 1897, 1, 1898, 1, 1898, + 1, 1898, 1, 1898, 1, 1898, 1, 1898, 1, 1898, 1, 1898, 1, 1898, 1, 1898, + 1, 1898, 1, 1898, 1, 1898, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, + 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, 1, 1899, + 1, 1899, 1, 1899, 1, 1899, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, + 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, 1, 1900, + 1, 1900, 1, 1900, 1, 1900, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, + 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1901, 1, 1902, + 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, + 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, 1, 1902, + 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1903, + 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1903, 1, 1904, 1, 1904, 1, 1904, + 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, 1, 1904, + 1, 1904, 1, 1904, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, + 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1905, 1, 1906, + 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, + 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1906, 1, 1907, 1, 1907, 1, 1907, + 1, 1907, 1, 1907, 1, 1907, 1, 1907, 1, 1907, 1, 1907, 1, 1907, 1, 1907, + 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, + 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, 1, 1908, + 1, 1908, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, + 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, 1, 1909, + 1, 1909, 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1910, + 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1910, 1, 1911, 1, 1911, + 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1911, + 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1911, 1, 1912, 1, 1912, 1, 1912, + 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, + 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1912, 1, 1913, 1, 1913, 1, 1913, + 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, + 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1913, 1, 1914, 1, 1914, 1, 1914, + 1, 1914, 1, 1914, 1, 1914, 1, 1914, 1, 1914, 1, 1914, 1, 1914, 1, 1914, + 1, 1914, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, + 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1915, 1, 1916, + 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, + 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1916, 1, 1917, + 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, + 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1917, 1, 1918, + 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, + 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, 1, 1918, + 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, + 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1919, 1, 1920, 1, 1920, + 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1920, + 1, 1920, 1, 1920, 1, 1920, 1, 1920, 1, 1921, 1, 1921, 1, 1921, 1, 1921, + 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, 1, 1921, + 1, 1921, 1, 1921, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, + 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, 1, 1922, + 1, 1922, 1, 1922, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, + 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, 1, 1923, + 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, + 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1924, 1, 1925, 1, 1925, + 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1925, + 1, 1925, 1, 1925, 1, 1925, 1, 1925, 1, 1926, 1, 1926, 1, 1926, 1, 1926, + 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, 1, 1926, + 1, 1926, 1, 1926, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, + 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, 1, 1927, + 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, + 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1928, 1, 1929, 1, 1929, + 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1929, + 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1929, 1, 1930, 1, 1930, 1, 1930, + 1, 1930, 1, 1930, 1, 1930, 1, 1930, 1, 1930, 1, 1930, 1, 1930, 1, 1930, + 1, 1930, 1, 1930, 1, 1930, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, + 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, 1, 1931, + 1, 1931, 1, 1931, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, + 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, 1, 1932, + 1, 1932, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, + 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1933, 1, 1934, + 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1934, + 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1934, 1, 1935, 1, 1935, 1, 1935, + 1, 1935, 1, 1935, 1, 1935, 1, 1935, 1, 1935, 1, 1935, 1, 1935, 1, 1935, + 1, 1935, 1, 1935, 1, 1935, 1, 1936, 1, 1936, 1, 1936, 1, 1936, 1, 1936, + 1, 1936, 1, 1936, 1, 1936, 1, 1936, 1, 1936, 1, 1936, 1, 1936, 1, 1936, + 1, 1936, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, + 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1937, 1, 1938, + 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1938, + 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1938, 1, 1939, 1, 1939, 1, 1939, + 1, 1939, 1, 1939, 1, 1939, 1, 1939, 1, 1939, 1, 1939, 1, 1939, 1, 1939, + 1, 1939, 1, 1939, 1, 1939, 1, 1940, 1, 1940, 1, 1940, 1, 1940, 1, 1940, + 1, 1940, 1, 1940, 1, 1940, 1, 1940, 1, 1940, 1, 1940, 1, 1940, 1, 1940, + 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, + 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1941, 1, 1942, 1, 1942, + 1, 1942, 1, 1942, 1, 1942, 1, 1942, 1, 1942, 1, 1942, 1, 1942, 1, 1942, + 1, 1942, 1, 1942, 1, 1942, 1, 1942, 1, 1943, 1, 1943, 1, 1943, 1, 1943, + 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, + 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1943, 1, 1944, 1, 1944, + 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1944, + 1, 1944, 1, 1944, 1, 1944, 1, 1944, 1, 1945, 1, 1945, 1, 1945, 1, 1945, + 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1945, + 1, 1945, 1, 1945, 1, 1945, 1, 1945, 1, 1946, 1, 1946, 1, 1946, 1, 1946, + 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, 1, 1946, + 1, 1946, 1, 1946, 1, 1946, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, + 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1947, 1, 1948, + 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, + 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, 1, 1948, + 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, + 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1949, 1, 1950, 1, 1950, + 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, + 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1950, 1, 1951, 1, 1951, + 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1951, + 1, 1951, 1, 1951, 1, 1951, 1, 1951, 1, 1952, 1, 1952, 1, 1952, 1, 1952, + 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, 1, 1952, + 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1953, + 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1953, 1, 1954, 1, 1954, 1, 1954, + 1, 1954, 1, 1954, 1, 1954, 1, 1954, 1, 1954, 1, 1954, 1, 1954, 1, 1954, + 1, 1954, 1, 1954, 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, + 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1955, + 1, 1955, 1, 1955, 1, 1955, 1, 1955, 1, 1956, 1, 1956, 1, 1956, 1, 1956, + 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1956, + 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1956, 1, 1957, 1, 1957, 1, 1957, + 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1957, + 1, 1957, 1, 1957, 1, 1957, 1, 1957, 1, 1958, 1, 1958, 1, 1958, 1, 1958, + 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1958, + 1, 1958, 1, 1958, 1, 1958, 1, 1958, 1, 1959, 1, 1959, 1, 1959, 1, 1959, + 1, 1959, 1, 1959, 1, 1959, 1, 1959, 1, 1959, 1, 1959, 1, 1959, 1, 1959, + 1, 1959, 1, 1959, 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, + 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, 1, 1960, + 1, 1960, 1, 1960, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, + 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, 1, 1961, + 1, 1961, 1, 1961, 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, + 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, 1, 1962, + 1, 1962, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, + 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1963, 1, 1964, + 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, + 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, 1, 1964, + 1, 1964, 1, 1965, 1, 1965, 1, 1965, 1, 1965, 1, 1965, 1, 1965, 1, 1965, + 1, 1965, 1, 1965, 1, 1965, 1, 1965, 1, 1965, 1, 1966, 1, 1966, 1, 1966, + 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1966, + 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1966, 1, 1967, 1, 1967, 1, 1967, + 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1967, + 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1967, 1, 1968, 1, 1968, 1, 1968, + 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, + 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1968, 1, 1969, 1, 1969, + 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, + 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, 1, 1970, + 1, 1970, 1, 1970, 1, 1970, 1, 1971, 1, 1971, 1, 1971, 1, 1971, 1, 1971, + 1, 1971, 1, 1971, 1, 1971, 1, 1971, 1, 1971, 1, 1971, 1, 1971, 1, 1971, + 1, 1971, 1, 1972, 1, 1972, 1, 1972, 1, 1972, 1, 1972, 1, 1972, 1, 1972, + 1, 1972, 1, 1972, 1, 1972, 1, 1972, 1, 1973, 1, 1973, 1, 1973, 1, 1973, + 1, 1973, 1, 1973, 1, 1973, 1, 1974, 1, 1974, 1, 1974, 1, 1974, 1, 1974, + 1, 1974, 1, 1974, 1, 1974, 1, 1974, 1, 1974, 1, 1974, 1, 1974, 1, 1975, + 1, 1975, 1, 1975, 1, 1975, 1, 1975, 1, 1975, 1, 1976, 1, 1976, 1, 1976, + 1, 1976, 1, 1976, 1, 1976, 1, 1977, 1, 1977, 1, 1977, 1, 1977, 1, 1978, + 1, 1978, 1, 1978, 1, 1978, 1, 1978, 1, 1979, 1, 1979, 1, 1979, 1, 1979, + 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, + 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1980, + 1, 1980, 1, 1980, 1, 1980, 1, 1980, 1, 1981, 1, 1981, 1, 1981, 1, 1981, + 1, 1981, 1, 1981, 1, 1981, 1, 1981, 1, 1981, 1, 1982, 1, 1982, 1, 1982, + 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1982, 1, 1983, 1, 1983, + 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, 1, 1983, + 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, 1, 1984, + 1, 1984, 1, 1984, 1, 1984, 1, 1985, 1, 1985, 1, 1985, 1, 1985, 1, 1985, + 1, 1986, 1, 1986, 1, 1986, 1, 1986, 1, 1986, 1, 1987, 1, 1987, 1, 1987, + 1, 1987, 1, 1987, 1, 1988, 1, 1988, 1, 1988, 1, 1988, 1, 1988, 1, 1989, + 1, 1989, 1, 1989, 1, 1989, 1, 1990, 1, 1990, 1, 1990, 1, 1990, 1, 1990, + 1, 1990, 1, 1990, 1, 1991, 1, 1991, 1, 1991, 1, 1991, 1, 1991, 1, 1991, + 1, 1991, 1, 1991, 1, 1992, 1, 1992, 1, 1992, 1, 1992, 1, 1992, 1, 1993, + 1, 1993, 1, 1993, 1, 1993, 1, 1993, 1, 1994, 1, 1994, 1, 1994, 1, 1994, + 1, 1994, 1, 1994, 1, 1994, 1, 1994, 1, 1995, 1, 1995, 1, 1995, 1, 1995, + 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, + 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, + 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, 1, 1995, + 1, 1996, 1, 1996, 1, 1996, 1, 1996, 1, 1996, 1, 1996, 1, 1996, 1, 1996, + 1, 1996, 1, 1996, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, + 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, + 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, + 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1997, 1, 1998, 1, 1998, 1, 1998, + 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, + 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, + 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1998, 1, 1999, 1, 1999, 1, 1999, + 1, 1999, 1, 1999, 1, 1999, 1, 2000, 1, 2000, 1, 2000, 1, 2000, 1, 2000, + 1, 2001, 1, 2001, 1, 2001, 1, 2001, 1, 2001, 1, 2001, 1, 2001, 1, 2001, + 1, 2001, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, + 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2002, 1, 2003, + 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, + 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2003, 1, 2004, 1, 2004, 1, 2004, + 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2004, + 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2004, 1, 2005, 1, 2005, 1, 2005, + 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, + 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2005, 1, 2006, 1, 2006, 1, 2006, + 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, + 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2006, 1, 2007, 1, 2007, 1, 2007, + 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2007, 1, 2008, + 1, 2008, 1, 2008, 1, 2008, 1, 2008, 1, 2008, 1, 2008, 1, 2009, 1, 2009, + 1, 2009, 1, 2009, 1, 2009, 1, 2009, 1, 2009, 1, 2010, 1, 2010, 1, 2010, + 1, 2010, 1, 2010, 1, 2010, 1, 2010, 1, 2010, 1, 2011, 1, 2011, 1, 2011, + 1, 2011, 1, 2011, 1, 2011, 1, 2011, 1, 2011, 1, 2011, 1, 2012, 1, 2012, + 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, + 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2012, 1, 2013, + 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, + 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2013, 1, 2014, + 1, 2014, 1, 2014, 1, 2014, 1, 2014, 1, 2014, 1, 2014, 1, 2014, 1, 2015, + 1, 2015, 1, 2015, 1, 2015, 1, 2015, 1, 2015, 1, 2015, 1, 2015, 1, 2016, + 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, + 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2016, 1, 2017, 1, 2017, 1, 2017, + 1, 2017, 1, 2017, 1, 2017, 1, 2017, 1, 2018, 1, 2018, 1, 2018, 1, 2018, + 1, 2018, 1, 2018, 1, 2018, 1, 2018, 1, 2018, 1, 2018, 1, 2018, 1, 2018, + 1, 2018, 1, 2018, 1, 2019, 1, 2019, 1, 2019, 1, 2019, 1, 2019, 1, 2019, + 1, 2019, 1, 2019, 1, 2019, 1, 2020, 1, 2020, 1, 2020, 1, 2020, 1, 2020, + 1, 2020, 1, 2020, 1, 2020, 1, 2020, 1, 2021, 1, 2021, 1, 2021, 1, 2021, + 1, 2021, 1, 2021, 1, 2021, 1, 2021, 1, 2021, 1, 2021, 1, 2022, 1, 2022, + 1, 2022, 1, 2022, 1, 2022, 1, 2022, 1, 2022, 1, 2022, 1, 2022, 1, 2023, + 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, + 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2023, 1, 2024, 1, 2024, + 1, 2024, 1, 2024, 1, 2024, 1, 2024, 1, 2024, 1, 2024, 1, 2024, 1, 2024, + 1, 2024, 1, 2024, 1, 2024, 1, 2025, 1, 2025, 1, 2025, 1, 2025, 1, 2025, + 1, 2025, 1, 2025, 1, 2025, 1, 2025, 1, 2025, 1, 2025, 1, 2025, 1, 2025, + 1, 2025, 1, 2025, 1, 2025, 1, 2026, 1, 2026, 1, 2026, 1, 2026, 1, 2026, + 1, 2026, 1, 2026, 1, 2026, 1, 2027, 1, 2027, 1, 2027, 1, 2027, 1, 2027, + 1, 2027, 1, 2027, 1, 2027, 1, 2027, 1, 2027, 1, 2027, 1, 2028, 1, 2028, + 1, 2028, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, + 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2029, 1, 2030, + 1, 2030, 1, 2030, 1, 2030, 1, 2030, 1, 2030, 1, 2031, 1, 2031, 1, 2031, + 1, 2031, 1, 2031, 1, 2031, 1, 2031, 1, 2031, 1, 2032, 1, 2032, 1, 2032, + 1, 2032, 1, 2032, 1, 2032, 1, 2032, 1, 2032, 1, 2032, 1, 2033, 1, 2033, + 1, 2033, 1, 2033, 1, 2033, 1, 2033, 1, 2033, 1, 2033, 1, 2033, 1, 2034, + 1, 2034, 1, 2034, 1, 2034, 1, 2034, 1, 2034, 1, 2034, 1, 2034, 1, 2034, + 1, 2034, 1, 2034, 1, 2034, 1, 2035, 1, 2035, 1, 2035, 1, 2035, 1, 2035, + 1, 2035, 1, 2035, 1, 2035, 1, 2035, 1, 2035, 1, 2036, 1, 2036, 1, 2036, + 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, + 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2036, + 1, 2036, 1, 2036, 1, 2036, 1, 2036, 1, 2037, 1, 2037, 1, 2037, 1, 2037, + 1, 2037, 1, 2037, 1, 2037, 1, 2037, 1, 2037, 1, 2037, 1, 2037, 1, 2037, + 1, 2037, 1, 2038, 1, 2038, 1, 2038, 1, 2038, 1, 2038, 1, 2038, 1, 2038, + 1, 2038, 1, 2038, 1, 2038, 1, 2038, 1, 2039, 1, 2039, 1, 2039, 1, 2039, + 1, 2039, 1, 2039, 1, 2039, 1, 2039, 1, 2039, 1, 2039, 1, 2040, 1, 2040, + 1, 2040, 1, 2040, 1, 2040, 1, 2040, 1, 2040, 1, 2040, 1, 2040, 1, 2040, + 1, 2040, 1, 2040, 1, 2041, 1, 2041, 1, 2041, 1, 2041, 1, 2041, 1, 2041, + 1, 2042, 1, 2042, 1, 2042, 1, 2042, 1, 2042, 1, 2042, 1, 2042, 1, 2042, + 1, 2042, 1, 2043, 1, 2043, 1, 2043, 1, 2043, 1, 2043, 1, 2043, 1, 2043, + 1, 2043, 1, 2044, 1, 2044, 1, 2044, 1, 2044, 1, 2044, 1, 2045, 1, 2045, + 1, 2045, 1, 2045, 1, 2045, 1, 2045, 1, 2045, 1, 2045, 1, 2045, 1, 2046, + 1, 2046, 1, 2046, 1, 2046, 1, 2046, 1, 2046, 1, 2047, 1, 2047, 1, 2047, + 1, 2047, 1, 2047, 1, 2047, 1, 2047, 1, 2047, 1, 2048, 1, 2048, 1, 2048, + 1, 2048, 1, 2048, 1, 2048, 1, 2049, 1, 2049, 1, 2049, 1, 2049, 1, 2049, + 1, 2049, 1, 2049, 1, 2050, 1, 2050, 1, 2050, 1, 2051, 1, 2051, 1, 2051, + 1, 2051, 1, 2051, 1, 2051, 1, 2052, 1, 2052, 1, 2052, 1, 2052, 1, 2052, + 1, 2053, 1, 2053, 1, 2053, 1, 2053, 1, 2053, 1, 2053, 1, 2053, 1, 2053, + 1, 2053, 1, 2053, 1, 2054, 1, 2054, 1, 2054, 1, 2054, 1, 2055, 1, 2055, + 1, 2055, 1, 2055, 1, 2056, 1, 2056, 1, 2056, 1, 2056, 1, 2056, 1, 2057, + 1, 2057, 1, 2057, 1, 2057, 1, 2058, 1, 2058, 1, 2058, 1, 2058, 1, 2058, + 1, 2058, 1, 2058, 1, 2058, 1, 2058, 1, 2058, 1, 2058, 1, 2059, 1, 2059, + 1, 2059, 1, 2059, 1, 2059, 1, 2059, 1, 2059, 1, 2059, 1, 2059, 1, 2059, + 1, 2060, 1, 2060, 1, 2060, 1, 2060, 1, 2060, 1, 2060, 1, 2060, 1, 2060, + 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, + 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2061, 1, 2062, 1, 2062, + 1, 2062, 1, 2062, 1, 2062, 1, 2062, 1, 2063, 1, 2063, 1, 2063, 1, 2063, + 1, 2063, 1, 2064, 1, 2064, 1, 2064, 1, 2064, 1, 2064, 1, 2064, 1, 2064, + 1, 2065, 1, 2065, 1, 2065, 1, 2065, 1, 2065, 1, 2065, 1, 2065, 1, 2065, + 1, 2066, 1, 2066, 1, 2066, 1, 2066, 1, 2066, 1, 2066, 1, 2067, 1, 2067, + 1, 2067, 1, 2067, 1, 2067, 1, 2067, 1, 2067, 1, 2068, 1, 2068, 1, 2068, + 1, 2068, 1, 2068, 1, 2068, 1, 2068, 1, 2069, 1, 2069, 1, 2069, 1, 2069, + 1, 2069, 1, 2069, 1, 2069, 1, 2069, 1, 2069, 1, 2069, 1, 2070, 1, 2070, + 1, 2070, 1, 2070, 1, 2070, 1, 2070, 1, 2070, 1, 2071, 1, 2071, 1, 2071, + 1, 2071, 1, 2071, 1, 2071, 1, 2071, 1, 2072, 1, 2072, 1, 2072, 1, 2072, + 1, 2072, 1, 2072, 1, 2072, 1, 2072, 1, 2072, 1, 2072, 1, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, 1, 2073, + 1, 2073, 1, 2073, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, + 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, + 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, + 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, 1, 2074, + 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, + 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, 1, 2075, + 1, 2075, 1, 2075, 1, 2076, 1, 2076, 1, 2076, 1, 2076, 1, 2076, 1, 2076, + 1, 2076, 1, 2077, 1, 2077, 1, 2077, 1, 2077, 1, 2077, 1, 2077, 1, 2077, + 1, 2077, 1, 2077, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, 1, 2078, + 1, 2078, 1, 2078, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, 1, 2079, + 1, 2079, 1, 2080, 1, 2080, 1, 2080, 1, 2080, 1, 2080, 1, 2080, 1, 2080, + 1, 2080, 1, 2080, 1, 2080, 1, 2080, 1, 2080, 1, 2081, 1, 2081, 1, 2081, + 1, 2081, 1, 2081, 1, 2081, 1, 2081, 1, 2081, 1, 2081, 1, 2081, 1, 2082, + 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2082, + 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2082, 1, 2083, 1, 2083, 1, 2083, + 1, 2083, 1, 2083, 1, 2083, 1, 2083, 1, 2083, 1, 2083, 1, 2083, 1, 2083, + 1, 2083, 1, 2083, 1, 2084, 1, 2084, 1, 2084, 1, 2084, 1, 2084, 1, 2084, + 1, 2084, 1, 2084, 1, 2084, 1, 2084, 1, 2084, 1, 2084, 1, 2085, 1, 2085, + 1, 2085, 1, 2085, 1, 2085, 1, 2085, 1, 2086, 1, 2086, 1, 2086, 1, 2086, + 1, 2086, 1, 2086, 1, 2086, 1, 2086, 1, 2086, 1, 2087, 1, 2087, 1, 2087, + 1, 2087, 1, 2087, 1, 2087, 1, 2087, 1, 2088, 1, 2088, 1, 2088, 1, 2088, + 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2088, 1, 2089, 1, 2089, + 1, 2089, 1, 2089, 1, 2089, 1, 2089, 1, 2089, 1, 2089, 1, 2090, 1, 2090, + 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2090, 1, 2091, 1, 2091, 1, 2091, + 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2091, 1, 2092, + 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, 1, 2092, + 1, 2092, 1, 2092, 1, 2092, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, + 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, 1, 2093, + 1, 2093, 1, 2094, 1, 2094, 1, 2094, 1, 2094, 1, 2094, 1, 2094, 1, 2094, + 1, 2094, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2095, 1, 2096, + 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2096, 1, 2097, 1, 2097, + 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2097, 1, 2098, 1, 2098, 1, 2098, + 1, 2098, 1, 2098, 1, 2098, 1, 2098, 1, 2099, 1, 2099, 1, 2099, 1, 2099, + 1, 2099, 1, 2099, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2100, 1, 2100, + 1, 2100, 1, 2100, 1, 2100, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, + 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2101, 1, 2102, 1, 2102, + 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2102, 1, 2103, + 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, + 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2103, + 1, 2103, 1, 2103, 1, 2103, 1, 2103, 1, 2104, 1, 2104, 1, 2104, 1, 2104, + 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, + 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, + 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2104, 1, 2105, 1, 2105, + 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2105, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, + 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2106, 1, 2107, 1, 2107, 1, 2107, + 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, + 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, 1, 2107, + 1, 2107, 1, 2107, 1, 2107, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, + 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, + 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2108, 1, 2109, + 1, 2109, 1, 2109, 1, 2109, 1, 2109, 1, 2109, 1, 2109, 1, 2109, 1, 2109, + 1, 2109, 1, 2110, 1, 2110, 1, 2110, 1, 2110, 1, 2110, 1, 2110, 1, 2110, + 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, + 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, 1, 2111, + 1, 2111, 1, 2111, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, + 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, + 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2112, 1, 2113, + 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, 1, 2113, + 1, 2113, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, + 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2114, 1, 2115, 1, 2115, + 1, 2115, 1, 2115, 1, 2115, 1, 2115, 1, 2115, 1, 2115, 1, 2116, 1, 2116, + 1, 2116, 1, 2116, 1, 2116, 1, 2116, 1, 2116, 1, 2116, 1, 2116, 1, 2116, + 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, + 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, 1, 2117, + 1, 2118, 1, 2118, 1, 2118, 1, 2118, 1, 2118, 1, 2118, 1, 2119, 1, 2119, + 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, + 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2119, 1, 2120, + 1, 2120, 1, 2120, 1, 2120, 1, 2120, 1, 2121, 1, 2121, 1, 2121, 1, 2121, + 1, 2121, 1, 2121, 1, 2121, 1, 2121, 1, 2121, 1, 2122, 1, 2122, 1, 2122, + 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, + 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, 1, 2122, + 1, 2122, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, + 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, 1, 2123, + 1, 2123, 1, 2123, 1, 2123, 1, 2124, 1, 2124, 1, 2124, 1, 2124, 1, 2125, + 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, + 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, + 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2125, 1, 2126, 1, 2126, + 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, + 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, 1, 2126, + 1, 2126, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, + 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, 1, 2127, + 1, 2127, 1, 2128, 1, 2128, 1, 2128, 1, 2128, 1, 2128, 1, 2128, 1, 2129, + 1, 2129, 1, 2129, 1, 2129, 1, 2129, 1, 2129, 1, 2129, 1, 2129, 1, 2130, + 1, 2130, 1, 2130, 1, 2130, 1, 2130, 1, 2130, 1, 2130, 1, 2130, 1, 2131, + 1, 2131, 1, 2131, 1, 2131, 1, 2131, 1, 2131, 1, 2132, 1, 2132, 1, 2132, + 1, 2132, 1, 2132, 1, 2133, 1, 2133, 1, 2133, 1, 2134, 1, 2134, 1, 2134, + 1, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, 1, 2135, + 1, 2135, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, + 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, + 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2136, 1, 2137, 1, 2137, 1, 2137, + 1, 2137, 1, 2137, 1, 2137, 1, 2137, 1, 2137, 1, 2137, 1, 2137, 1, 2137, + 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, + 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2138, 1, 2139, + 1, 2139, 1, 2139, 1, 2139, 1, 2139, 1, 2139, 1, 2139, 1, 2140, 1, 2140, + 1, 2140, 1, 2140, 1, 2140, 1, 2140, 1, 2141, 1, 2141, 1, 2141, 1, 2141, + 1, 2141, 1, 2141, 1, 2141, 1, 2141, 1, 2141, 1, 2142, 1, 2142, 1, 2142, + 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2142, 1, 2143, 1, 2143, 1, 2143, + 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2143, 1, 2144, 1, 2144, + 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2144, 1, 2145, 1, 2145, + 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2145, 1, 2146, 1, 2146, + 1, 2146, 1, 2146, 1, 2146, 1, 2146, 1, 2146, 1, 2147, 1, 2147, 1, 2147, + 1, 2147, 1, 2147, 1, 2147, 1, 2147, 1, 2147, 1, 2147, 1, 2148, 1, 2148, + 1, 2148, 1, 2148, 1, 2148, 1, 2148, 1, 2148, 1, 2148, 1, 2149, 1, 2149, + 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, + 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, 1, 2149, + 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2150, + 1, 2150, 1, 2150, 1, 2150, 1, 2150, 1, 2151, 1, 2151, 1, 2151, 1, 2151, + 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, + 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, 1, 2151, + 1, 2151, 1, 2151, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, + 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, + 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, 1, 2152, + 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, + 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, 1, 2153, + 1, 2153, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, 1, 2154, + 1, 2154, 1, 2154, 1, 2155, 1, 2155, 1, 2155, 1, 2155, 1, 2155, 1, 2155, + 1, 2155, 1, 2156, 1, 2156, 1, 2156, 1, 2156, 1, 2156, 1, 2156, 1, 2156, + 1, 2156, 1, 2156, 1, 2156, 1, 2156, 1, 2157, 1, 2157, 1, 2157, 1, 2157, + 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2157, + 1, 2157, 1, 2157, 1, 2157, 1, 2157, 1, 2158, 1, 2158, 1, 2158, 1, 2158, + 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, + 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2158, 1, 2159, 1, 2159, 1, 2159, + 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, + 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, 1, 2159, + 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, + 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, 1, 2160, + 1, 2160, 1, 2160, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, + 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, + 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2161, 1, 2162, 1, 2162, 1, 2162, + 1, 2162, 1, 2162, 1, 2162, 1, 2162, 1, 2162, 1, 2162, 1, 2163, 1, 2163, + 1, 2163, 1, 2163, 1, 2163, 1, 2163, 1, 2163, 1, 2163, 1, 2163, 1, 2163, + 1, 2163, 1, 2163, 1, 2163, 1, 2164, 1, 2164, 1, 2164, 1, 2164, 1, 2164, + 1, 2164, 1, 2164, 1, 2164, 1, 2165, 1, 2165, 1, 2165, 1, 2165, 1, 2165, + 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, 1, 2166, + 1, 2166, 1, 2166, 1, 2167, 1, 2167, 1, 2167, 1, 2167, 1, 2167, 1, 2167, + 1, 2167, 1, 2167, 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2168, + 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2168, 1, 2169, 1, 2169, 1, 2169, + 1, 2169, 1, 2169, 1, 2169, 1, 2169, 1, 2169, 1, 2170, 1, 2170, 1, 2170, + 1, 2170, 1, 2170, 1, 2170, 1, 2170, 1, 2171, 1, 2171, 1, 2171, 1, 2171, + 1, 2171, 1, 2171, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2172, 1, 2173, + 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2173, 1, 2174, 1, 2174, + 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2174, 1, 2175, 1, 2175, + 1, 2175, 1, 2175, 1, 2175, 1, 2175, 1, 2176, 1, 2176, 1, 2176, 1, 2176, + 1, 2176, 1, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2177, + 1, 2177, 1, 2177, 1, 2177, 1, 2177, 1, 2178, 1, 2178, 1, 2178, 1, 2178, + 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2178, 1, 2179, 1, 2179, 1, 2179, + 1, 2179, 1, 2179, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, 1, 2180, + 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2181, 1, 2182, 1, 2182, + 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, 1, 2182, + 1, 2182, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, + 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2183, 1, 2184, 1, 2184, + 1, 2184, 1, 2184, 1, 2184, 1, 2184, 1, 2184, 1, 2185, 1, 2185, 1, 2185, + 1, 2185, 1, 2185, 1, 2185, 1, 2185, 1, 2185, 1, 2186, 1, 2186, 1, 2186, + 1, 2186, 1, 2186, 1, 2186, 1, 2186, 1, 2186, 1, 2186, 1, 2186, 1, 2186, + 1, 2187, 1, 2187, 1, 2187, 1, 2187, 1, 2187, 1, 2188, 1, 2188, 1, 2188, + 1, 2188, 1, 2188, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, 1, 2189, + 1, 2189, 1, 2189, 1, 2190, 1, 2190, 1, 2190, 1, 2190, 1, 2190, 1, 2190, + 1, 2190, 1, 2190, 1, 2191, 1, 2191, 1, 2191, 1, 2191, 1, 2191, 1, 2191, + 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, + 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2192, + 1, 2192, 1, 2192, 1, 2192, 1, 2192, 1, 2193, 1, 2193, 1, 2193, 1, 2193, + 1, 2194, 1, 2194, 1, 2194, 1, 2194, 1, 2194, 1, 2194, 1, 2194, 1, 2194, + 1, 2194, 1, 2194, 1, 2194, 1, 2194, 1, 2195, 1, 2195, 1, 2195, 1, 2195, + 1, 2196, 1, 2196, 1, 2196, 1, 2196, 1, 2196, 1, 2196, 1, 2196, 1, 2196, + 1, 2196, 1, 2196, 1, 2196, 1, 2197, 1, 2197, 1, 2197, 1, 2197, 1, 2197, + 1, 2197, 1, 2197, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, + 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, 1, 2198, + 1, 2199, 1, 2199, 1, 2199, 1, 2199, 1, 2199, 1, 2199, 1, 2199, 1, 2199, + 1, 2200, 1, 2200, 1, 2200, 1, 2200, 1, 2200, 1, 2200, 1, 2200, 1, 2200, + 1, 2200, 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2201, + 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2201, 1, 2202, 1, 2202, + 1, 2202, 1, 2202, 1, 2202, 1, 2202, 1, 2202, 1, 2202, 1, 2202, 1, 2202, + 1, 2202, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, 1, 2203, + 1, 2203, 1, 2203, 1, 2203, 1, 2204, 1, 2204, 1, 2204, 1, 2204, 1, 2204, + 1, 2204, 1, 2204, 1, 2204, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, + 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2205, + 1, 2205, 1, 2205, 1, 2205, 1, 2205, 1, 2206, 1, 2206, 1, 2206, 1, 2206, + 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2206, 1, 2207, + 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, 1, 2207, + 1, 2207, 1, 2207, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2208, + 1, 2208, 1, 2208, 1, 2208, 1, 2208, 1, 2209, 1, 2209, 1, 2209, 1, 2209, + 1, 2209, 1, 2209, 1, 2209, 1, 2209, 1, 2209, 1, 2209, 1, 2210, 1, 2210, + 1, 2210, 1, 2210, 1, 2210, 1, 2210, 1, 2210, 1, 2210, 1, 2210, 1, 2211, + 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, + 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, + 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, 1, 2211, + 1, 2211, 1, 2211, 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, + 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, 1, 2212, + 1, 2212, 1, 2212, 1, 2212, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, + 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, + 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, 1, 2213, + 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, 1, 2214, + 1, 2214, 1, 2214, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, + 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2215, 1, 2216, 1, 2216, 1, 2216, + 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, 1, 2216, + 1, 2216, 1, 2216, 1, 2216, 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2217, + 1, 2217, 1, 2217, 1, 2217, 1, 2217, 1, 2218, 1, 2218, 1, 2218, 1, 2218, + 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2218, 1, 2219, 1, 2219, 1, 2219, + 1, 2219, 1, 2219, 1, 2219, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, + 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2220, 1, 2221, + 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, 1, 2221, + 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, 1, 2222, + 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, 1, 2223, + 1, 2223, 1, 2223, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, + 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2224, 1, 2225, + 1, 2225, 1, 2225, 1, 2225, 1, 2225, 1, 2225, 1, 2225, 1, 2225, 1, 2225, + 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, + 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, 1, 2226, + 1, 2226, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, + 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2227, 1, 2228, 1, 2228, + 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2228, 1, 2229, 1, 2229, + 1, 2229, 1, 2229, 1, 2230, 1, 2230, 1, 2230, 1, 2230, 1, 2230, 1, 2230, + 1, 2230, 1, 2230, 1, 2230, 1, 2230, 1, 2230, 1, 2231, 1, 2231, 1, 2231, + 1, 2231, 1, 2231, 1, 2231, 1, 2231, 1, 2231, 1, 2231, 1, 2231, 1, 2231, + 1, 2231, 1, 2231, 1, 2231, 1, 2231, 1, 2232, 1, 2232, 1, 2232, 1, 2233, + 1, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2233, 1, 2234, 1, 2234, 1, 2234, + 1, 2234, 1, 2234, 1, 2235, 1, 2235, 1, 2235, 1, 2235, 1, 2236, 1, 2236, + 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, + 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, + 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2236, 1, 2237, + 1, 2237, 1, 2237, 1, 2237, 1, 2237, 1, 2237, 1, 2237, 1, 2237, 1, 2238, + 1, 2238, 1, 2238, 1, 2238, 1, 2238, 1, 2239, 1, 2239, 1, 2239, 1, 2239, + 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2239, 1, 2240, + 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, + 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, 1, 2240, + 1, 2240, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, + 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, 1, 2241, + 1, 2241, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, + 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2242, + 1, 2242, 1, 2242, 1, 2242, 1, 2242, 1, 2243, 1, 2243, 1, 2243, 1, 2243, + 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, + 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, 1, 2243, + 1, 2243, 1, 2243, 1, 2243, 1, 2244, 1, 2244, 1, 2244, 1, 2244, 1, 2244, + 1, 2244, 1, 2244, 1, 2244, 1, 2244, 1, 2244, 1, 2244, 1, 2244, 1, 2244, + 1, 2244, 1, 2244, 1, 2245, 1, 2245, 1, 2245, 1, 2245, 1, 2245, 1, 2245, + 1, 2245, 1, 2245, 1, 2245, 1, 2245, 1, 2245, 1, 2246, 1, 2246, 1, 2246, + 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2246, 1, 2247, 1, 2247, 1, 2247, + 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2247, 1, 2248, + 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, 1, 2248, + 1, 2248, 1, 2248, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2249, + 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2249, 1, 2250, 1, 2250, 1, 2250, + 1, 2250, 1, 2250, 1, 2250, 1, 2250, 1, 2250, 1, 2250, 1, 2251, 1, 2251, + 1, 2251, 1, 2251, 1, 2251, 1, 2251, 1, 2251, 1, 2251, 1, 2252, 1, 2252, + 1, 2252, 1, 2252, 1, 2252, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, + 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2253, 1, 2254, 1, 2254, 1, 2254, + 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, + 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2254, 1, 2255, 1, 2255, 1, 2255, + 1, 2255, 1, 2255, 1, 2255, 1, 2255, 1, 2255, 1, 2255, 1, 2255, 1, 2255, + 1, 2255, 1, 2256, 1, 2256, 1, 2256, 1, 2256, 1, 2256, 1, 2256, 1, 2256, + 1, 2256, 1, 2256, 1, 2256, 1, 2256, 1, 2256, 1, 2257, 1, 2257, 1, 2257, + 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, 1, 2257, + 1, 2257, 1, 2257, 1, 2257, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, + 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2258, 1, 2259, 1, 2259, + 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2259, 1, 2260, 1, 2260, + 1, 2260, 1, 2260, 1, 2260, 1, 2261, 1, 2261, 1, 2261, 1, 2261, 1, 2261, + 1, 2261, 1, 2261, 1, 2261, 1, 2262, 1, 2262, 1, 2262, 1, 2262, 1, 2262, + 1, 2263, 1, 2263, 1, 2263, 1, 2263, 1, 2263, 1, 2263, 1, 2264, 1, 2264, + 1, 2264, 1, 2264, 1, 2264, 1, 2264, 1, 2264, 1, 2264, 1, 2264, 1, 2264, + 1, 2265, 1, 2265, 1, 2265, 1, 2265, 1, 2265, 1, 2265, 1, 2265, 1, 2265, + 1, 2265, 1, 2265, 1, 2266, 1, 2266, 1, 2266, 1, 2266, 1, 2266, 1, 2266, + 1, 2266, 1, 2266, 1, 2266, 1, 2266, 1, 2266, 1, 2267, 1, 2267, 1, 2267, + 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2267, 1, 2268, 1, 2268, 1, 2268, + 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, 1, 2268, + 1, 2268, 1, 2268, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, + 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, 1, 2269, + 1, 2269, 1, 2269, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, + 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, 1, 2270, + 1, 2270, 1, 2270, 1, 2271, 1, 2271, 1, 2271, 1, 2271, 1, 2271, 1, 2272, + 1, 2272, 1, 2272, 1, 2272, 1, 2273, 1, 2273, 1, 2273, 1, 2273, 1, 2273, + 1, 2274, 1, 2274, 1, 2274, 1, 2274, 1, 2274, 1, 2274, 1, 2274, 1, 2275, + 1, 2275, 1, 2275, 1, 2275, 1, 2275, 1, 2275, 1, 2275, 1, 2276, 1, 2276, + 1, 2276, 1, 2276, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, 1, 2277, + 1, 2277, 1, 2277, 1, 2277, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, + 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2278, + 1, 2278, 1, 2278, 1, 2278, 1, 2278, 1, 2279, 1, 2279, 1, 2279, 1, 2279, + 1, 2279, 1, 2280, 1, 2280, 1, 2280, 1, 2280, 1, 2281, 1, 2281, 1, 2281, + 1, 2281, 1, 2281, 1, 2281, 1, 2281, 1, 2282, 1, 2282, 1, 2282, 1, 2282, + 1, 2282, 1, 2282, 1, 2282, 1, 2282, 1, 2282, 1, 2282, 1, 2282, 1, 2282, + 1, 2283, 1, 2283, 1, 2283, 1, 2283, 1, 2284, 1, 2284, 1, 2284, 1, 2284, + 1, 2284, 1, 2284, 1, 2285, 1, 2285, 1, 2285, 1, 2285, 1, 2286, 1, 2286, + 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, + 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2286, 1, 2287, 1, 2287, + 1, 2287, 1, 2287, 1, 2287, 1, 2287, 1, 2288, 1, 2288, 1, 2288, 1, 2288, + 1, 2288, 1, 2288, 1, 2289, 1, 2289, 1, 2289, 1, 2289, 1, 2289, 1, 2289, + 1, 2289, 1, 2289, 1, 2289, 1, 2289, 1, 2289, 1, 2290, 1, 2290, 1, 2290, + 1, 2290, 1, 2290, 1, 2290, 1, 2290, 1, 2291, 1, 2291, 1, 2291, 1, 2291, + 1, 2291, 1, 2291, 1, 2291, 1, 2291, 1, 2292, 1, 2292, 1, 2292, 1, 2292, + 1, 2292, 1, 2293, 1, 2293, 1, 2293, 1, 2293, 1, 2294, 1, 2294, 1, 2294, + 1, 2294, 1, 2294, 1, 2294, 1, 2294, 1, 2295, 1, 2295, 1, 2295, 1, 2295, + 1, 2295, 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2296, 1, 2296, + 1, 2296, 1, 2296, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, 1, 2297, + 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, 1, 2298, + 1, 2298, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2299, 1, 2299, + 1, 2299, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2300, 1, 2300, + 1, 2300, 1, 2300, 1, 2300, 1, 2301, 1, 2301, 1, 2301, 1, 2301, 1, 2302, + 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, 1, 2302, + 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, 1, 2303, + 1, 2303, 1, 2303, 1, 2303, 1, 2304, 1, 2304, 1, 2304, 1, 2304, 1, 2304, + 1, 2304, 1, 2304, 1, 2304, 1, 2304, 1, 2304, 1, 2304, 1, 2305, 1, 2305, + 1, 2305, 1, 2305, 1, 2305, 1, 2305, 1, 2305, 1, 2306, 1, 2306, 1, 2306, + 1, 2306, 1, 2306, 1, 2306, 1, 2306, 1, 2307, 1, 2307, 1, 2307, 1, 2307, + 1, 2307, 1, 2307, 1, 2307, 1, 2307, 1, 2308, 1, 2308, 1, 2308, 1, 2308, + 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, 1, 2308, + 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2309, 1, 2310, 1, 2310, 1, 2310, + 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, 1, 2310, + 1, 2311, 1, 2311, 1, 2311, 1, 2311, 1, 2311, 1, 2311, 1, 2311, 1, 2311, + 1, 2312, 1, 2312, 1, 2312, 1, 2312, 1, 2312, 1, 2312, 1, 2312, 1, 2312, + 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, + 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2313, 1, 2314, 1, 2314, 1, 2314, + 1, 2314, 1, 2314, 1, 2314, 1, 2314, 1, 2314, 1, 2315, 1, 2315, 1, 2315, + 1, 2315, 1, 2315, 1, 2315, 1, 2316, 1, 2316, 1, 2316, 1, 2316, 1, 2316, + 1, 2316, 1, 2316, 1, 2316, 1, 2316, 1, 2316, 1, 2317, 1, 2317, 1, 2317, + 1, 2317, 1, 2317, 1, 2317, 1, 2317, 1, 2318, 1, 2318, 1, 2318, 1, 2318, + 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, 1, 2318, + 1, 2318, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, 1, 2319, + 1, 2319, 1, 2319, 1, 2319, 1, 2320, 1, 2320, 1, 2320, 1, 2320, 1, 2320, + 1, 2320, 1, 2320, 1, 2321, 1, 2321, 1, 2321, 1, 2321, 1, 2322, 1, 2322, + 1, 2322, 1, 2322, 1, 2322, 1, 2322, 1, 2322, 1, 2323, 1, 2323, 1, 2323, + 1, 2323, 1, 2323, 1, 2323, 1, 2323, 1, 2323, 1, 2323, 1, 2323, 1, 2323, + 1, 2323, 1, 2323, 1, 2323, 1, 2324, 1, 2324, 1, 2324, 1, 2324, 1, 2324, + 1, 2324, 1, 2324, 1, 2324, 1, 2325, 1, 2325, 1, 2325, 1, 2325, 1, 2325, + 1, 2325, 1, 2326, 1, 2326, 1, 2326, 1, 2326, 1, 2327, 1, 2327, 1, 2327, + 1, 2327, 1, 2327, 1, 2327, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, + 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2328, 1, 2329, 1, 2329, + 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2329, 1, 2330, + 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, + 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, + 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2330, + 1, 2330, 1, 2330, 1, 2330, 1, 2330, 1, 2331, 1, 2331, 1, 2331, 1, 2331, + 1, 2331, 1, 2331, 1, 2331, 1, 2331, 1, 2331, 1, 2331, 1, 2331, 1, 2332, + 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, 1, 2332, + 1, 2332, 1, 2332, 1, 2332, 1, 2333, 1, 2333, 1, 2333, 1, 2333, 1, 2333, + 1, 2333, 1, 2334, 1, 2334, 1, 2334, 1, 2334, 1, 2334, 1, 2334, 1, 2334, + 1, 2334, 1, 2334, 1, 2334, 1, 2334, 1, 2335, 1, 2335, 1, 2335, 1, 2335, + 1, 2335, 1, 2335, 1, 2335, 1, 2335, 1, 2335, 1, 2336, 1, 2336, 1, 2336, + 1, 2336, 1, 2336, 1, 2336, 1, 2336, 1, 2336, 1, 2336, 1, 2336, 1, 2336, + 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2337, + 1, 2337, 1, 2337, 1, 2337, 1, 2337, 1, 2338, 1, 2338, 1, 2338, 1, 2338, + 1, 2338, 1, 2338, 1, 2338, 1, 2338, 1, 2338, 1, 2338, 1, 2338, 1, 2338, + 1, 2338, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, + 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, 1, 2339, + 1, 2339, 1, 2339, 1, 2340, 1, 2340, 1, 2340, 1, 2340, 1, 2340, 1, 2340, + 1, 2340, 1, 2340, 1, 2340, 1, 2340, 1, 2341, 1, 2341, 1, 2341, 1, 2341, + 1, 2341, 1, 2341, 1, 2341, 1, 2341, 1, 2342, 1, 2342, 1, 2342, 1, 2342, + 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, 1, 2342, + 1, 2342, 1, 2342, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, + 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2343, 1, 2344, 1, 2344, + 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, 1, 2344, + 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2345, 1, 2346, + 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, + 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, + 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2346, 1, 2347, 1, 2347, + 1, 2347, 1, 2347, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, 1, 2348, + 1, 2348, 1, 2348, 1, 2348, 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2349, + 1, 2349, 1, 2349, 1, 2349, 1, 2349, 1, 2350, 1, 2350, 1, 2350, 1, 2350, + 1, 2350, 1, 2350, 1, 2351, 1, 2351, 1, 2351, 1, 2351, 1, 2351, 1, 2351, + 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, 1, 2352, + 1, 2352, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, 1, 2353, + 1, 2353, 1, 2353, 1, 2354, 1, 2354, 1, 2354, 1, 2354, 1, 2354, 1, 2354, + 1, 2354, 1, 2354, 1, 2355, 1, 2355, 1, 2355, 1, 2355, 1, 2355, 1, 2355, + 1, 2355, 1, 2355, 1, 2355, 1, 2356, 1, 2356, 1, 2356, 1, 2356, 1, 2356, + 1, 2356, 1, 2356, 1, 2356, 1, 2356, 1, 2357, 1, 2357, 1, 2357, 1, 2357, + 1, 2357, 1, 2357, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, + 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2358, 1, 2359, 1, 2359, + 1, 2359, 1, 2359, 1, 2359, 1, 2359, 1, 2359, 1, 2359, 1, 2359, 1, 2359, + 1, 2359, 1, 2359, 1, 2359, 1, 2359, 1, 2360, 1, 2360, 1, 2360, 1, 2360, + 1, 2360, 1, 2360, 1, 2360, 1, 2360, 1, 2361, 1, 2361, 1, 2361, 1, 2361, + 1, 2361, 1, 2361, 1, 2361, 1, 2362, 1, 2362, 1, 2362, 1, 2362, 1, 2362, + 1, 2362, 1, 2362, 1, 2362, 1, 2362, 1, 2363, 1, 2363, 1, 2363, 1, 2363, + 1, 2363, 1, 2363, 1, 2363, 1, 2363, 1, 2364, 1, 2364, 1, 2364, 1, 2364, + 1, 2364, 1, 2364, 5, 2364, 31202, 8, 2364, 10, 2364, 12, 2364, 31205, 9, + 2364, 1, 2364, 1, 2364, 1, 2365, 1, 2365, 1, 2365, 5, 2365, 31212, 8, 2365, + 10, 2365, 12, 2365, 31215, 9, 2365, 1, 2365, 4, 2365, 31218, 8, 2365, 11, + 2365, 12, 2365, 31219, 1, 2366, 1, 2366, 1, 2366, 5, 2366, 31225, 8, 2366, + 10, 2366, 12, 2366, 31228, 9, 2366, 1, 2366, 4, 2366, 31231, 8, 2366, 11, + 2366, 12, 2366, 31232, 1, 2367, 1, 2367, 1, 2367, 1, 2368, 1, 2368, 1, + 2369, 4, 2369, 31241, 8, 2369, 11, 2369, 12, 2369, 31242, 1, 2370, 1, 2370, + 1, 2370, 3, 2370, 31248, 8, 2370, 1, 2370, 1, 2370, 4, 2370, 31252, 8, + 2370, 11, 2370, 12, 2370, 31253, 3, 2370, 31256, 8, 2370, 3, 2370, 31258, + 8, 2370, 1, 2370, 3, 2370, 31261, 8, 2370, 1, 2371, 1, 2371, 1, 2371, 1, + 2371, 1, 2371, 5, 2371, 31268, 8, 2371, 10, 2371, 12, 2371, 31271, 9, 2371, + 1, 2371, 1, 2371, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, + 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, + 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, + 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, + 3, 2372, 31305, 8, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2372, 1, 2373, 1, + 2373, 5, 2373, 31313, 8, 2373, 10, 2373, 12, 2373, 31316, 9, 2373, 1, 2373, + 1, 2373, 1, 2374, 1, 2374, 5, 2374, 31322, 8, 2374, 10, 2374, 12, 2374, + 31325, 9, 2374, 1, 2374, 1, 2374, 1, 2375, 1, 2375, 5, 2375, 31331, 8, + 2375, 10, 2375, 12, 2375, 31334, 9, 2375, 1, 2375, 1, 2375, 1, 2376, 1, + 2376, 5, 2376, 31340, 8, 2376, 10, 2376, 12, 2376, 31343, 9, 2376, 1, 2376, + 1, 2376, 1, 2377, 1, 2377, 5, 2377, 31349, 8, 2377, 10, 2377, 12, 2377, + 31352, 9, 2377, 1, 2377, 1, 2377, 1, 2378, 1, 2378, 5, 2378, 31358, 8, + 2378, 10, 2378, 12, 2378, 31361, 9, 2378, 1, 2378, 1, 2378, 1, 2379, 1, + 2379, 5, 2379, 31367, 8, 2379, 10, 2379, 12, 2379, 31370, 9, 2379, 1, 2379, + 1, 2379, 1, 2380, 1, 2380, 5, 2380, 31376, 8, 2380, 10, 2380, 12, 2380, + 31379, 9, 2380, 1, 2380, 1, 2380, 1, 2381, 1, 2381, 5, 2381, 31385, 8, + 2381, 10, 2381, 12, 2381, 31388, 9, 2381, 1, 2381, 1, 2381, 1, 2382, 1, + 2382, 5, 2382, 31394, 8, 2382, 10, 2382, 12, 2382, 31397, 9, 2382, 1, 2382, + 1, 2382, 1, 2383, 1, 2383, 5, 2383, 31403, 8, 2383, 10, 2383, 12, 2383, + 31406, 9, 2383, 1, 2383, 1, 2383, 1, 2384, 1, 2384, 5, 2384, 31412, 8, + 2384, 10, 2384, 12, 2384, 31415, 9, 2384, 1, 2384, 1, 2384, 1, 2385, 1, + 2385, 5, 2385, 31421, 8, 2385, 10, 2385, 12, 2385, 31424, 9, 2385, 1, 2385, + 1, 2385, 1, 2386, 1, 2386, 5, 2386, 31430, 8, 2386, 10, 2386, 12, 2386, + 31433, 9, 2386, 1, 2386, 1, 2386, 1, 2387, 1, 2387, 5, 2387, 31439, 8, + 2387, 10, 2387, 12, 2387, 31442, 9, 2387, 1, 2387, 1, 2387, 1, 2388, 1, + 2388, 5, 2388, 31448, 8, 2388, 10, 2388, 12, 2388, 31451, 9, 2388, 1, 2388, + 1, 2388, 1, 2389, 1, 2389, 5, 2389, 31457, 8, 2389, 10, 2389, 12, 2389, + 31460, 9, 2389, 1, 2389, 1, 2389, 1, 2390, 1, 2390, 5, 2390, 31466, 8, + 2390, 10, 2390, 12, 2390, 31469, 9, 2390, 1, 2390, 1, 2390, 1, 2391, 1, + 2391, 5, 2391, 31475, 8, 2391, 10, 2391, 12, 2391, 31478, 9, 2391, 1, 2391, + 1, 2391, 1, 2392, 1, 2392, 5, 2392, 31484, 8, 2392, 10, 2392, 12, 2392, + 31487, 9, 2392, 1, 2392, 1, 2392, 1, 2393, 1, 2393, 5, 2393, 31493, 8, + 2393, 10, 2393, 12, 2393, 31496, 9, 2393, 1, 2393, 1, 2393, 1, 2394, 1, + 2394, 5, 2394, 31502, 8, 2394, 10, 2394, 12, 2394, 31505, 9, 2394, 1, 2394, + 1, 2394, 1, 2395, 1, 2395, 5, 2395, 31511, 8, 2395, 10, 2395, 12, 2395, + 31514, 9, 2395, 1, 2395, 1, 2395, 1, 2396, 1, 2396, 5, 2396, 31520, 8, + 2396, 10, 2396, 12, 2396, 31523, 9, 2396, 1, 2396, 1, 2396, 1, 2397, 1, + 2397, 5, 2397, 31529, 8, 2397, 10, 2397, 12, 2397, 31532, 9, 2397, 1, 2397, + 1, 2397, 1, 2398, 1, 2398, 5, 2398, 31538, 8, 2398, 10, 2398, 12, 2398, + 31541, 9, 2398, 1, 2398, 1, 2398, 1, 2399, 1, 2399, 5, 2399, 31547, 8, + 2399, 10, 2399, 12, 2399, 31550, 9, 2399, 1, 2399, 1, 2399, 1, 2400, 1, + 2400, 5, 2400, 31556, 8, 2400, 10, 2400, 12, 2400, 31559, 9, 2400, 1, 2400, + 1, 2400, 1, 2401, 1, 2401, 1, 2401, 1, 2401, 4, 2401, 31567, 8, 2401, 11, + 2401, 12, 2401, 31568, 1, 2401, 1, 2401, 1, 2402, 1, 2402, 1, 2403, 1, + 2403, 1, 2404, 1, 2404, 1, 2405, 1, 2405, 1, 2406, 1, 2406, 1, 2406, 1, + 2407, 1, 2407, 1, 2408, 1, 2408, 1, 2409, 1, 2409, 1, 2410, 1, 2410, 1, + 2411, 1, 2411, 1, 2412, 1, 2412, 1, 2413, 1, 2413, 1, 2413, 1, 2414, 1, + 2414, 1, 2415, 1, 2415, 1, 2416, 1, 2416, 1, 2416, 1, 2416, 5, 2416, 31607, + 8, 2416, 10, 2416, 12, 2416, 31610, 9, 2416, 1, 2416, 1, 2416, 1, 2416, + 1, 2416, 1, 2416, 3, 2416, 31617, 8, 2416, 1, 2417, 1, 2417, 1, 2417, 1, + 2417, 1, 2417, 1, 2417, 1, 2417, 1, 2417, 3, 2417, 31627, 8, 2417, 1, 2418, + 1, 2418, 1, 2419, 1, 2419, 1, 2420, 1, 2420, 1, 2421, 1, 2421, 1, 2422, + 1, 2422, 1, 2423, 1, 2423, 1, 2424, 1, 2424, 1, 2425, 1, 2425, 1, 2426, + 1, 2426, 1, 2427, 1, 2427, 1, 2428, 1, 2428, 1, 2429, 1, 2429, 1, 2430, + 1, 2430, 1, 2430, 1, 2430, 5, 2430, 31657, 8, 2430, 10, 2430, 12, 2430, + 31660, 9, 2430, 1, 2430, 1, 2430, 1, 2430, 1, 2430, 1, 2431, 1, 2431, 1, + 2431, 1, 2431, 5, 2431, 31670, 8, 2431, 10, 2431, 12, 2431, 31673, 9, 2431, + 1, 2431, 1, 2431, 1, 2431, 1, 2431, 1, 2431, 1, 2432, 1, 2432, 1, 2432, + 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 3, 2432, 31688, 8, 2432, 1, + 2432, 1, 2432, 5, 2432, 31692, 8, 2432, 10, 2432, 12, 2432, 31695, 9, 2432, + 3, 2432, 31697, 8, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2432, 1, 2433, 1, + 2433, 1, 2433, 1, 2433, 1, 2433, 1, 2433, 1, 2433, 1, 2433, 3, 2433, 31711, + 8, 2433, 1, 2433, 1, 2433, 5, 2433, 31715, 8, 2433, 10, 2433, 12, 2433, + 31718, 9, 2433, 3, 2433, 31720, 8, 2433, 1, 2433, 1, 2433, 1, 2434, 1, + 2434, 1, 2434, 3, 2434, 31727, 8, 2434, 1, 2434, 5, 2434, 31730, 8, 2434, + 10, 2434, 12, 2434, 31733, 9, 2434, 1, 2434, 1, 2434, 1, 2435, 1, 2435, + 3, 2435, 31739, 8, 2435, 1, 2435, 1, 2435, 1, 2435, 5, 2435, 31744, 8, + 2435, 10, 2435, 12, 2435, 31747, 9, 2435, 1, 2436, 1, 2436, 1, 2436, 1, + 2436, 1, 2437, 1, 2437, 3, 2437, 31755, 8, 2437, 1, 2438, 1, 2438, 1, 2439, + 1, 2439, 1, 2440, 5, 2440, 31762, 8, 2440, 10, 2440, 12, 2440, 31765, 9, + 2440, 1, 2440, 3, 2440, 31768, 8, 2440, 1, 2440, 4, 2440, 31771, 8, 2440, + 11, 2440, 12, 2440, 31772, 1, 2441, 3, 2441, 31776, 8, 2441, 1, 2441, 1, + 2441, 1, 2442, 1, 2442, 1, 2443, 1, 2443, 29, 31314, 31323, 31332, 31341, + 31350, 31359, 31368, 31377, 31386, 31395, 31404, 31413, 31422, 31431, 31440, + 31449, 31458, 31467, 31476, 31485, 31494, 31503, 31512, 31521, 31530, 31539, + 31548, 31557, 31671, 0, 2444, 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, 1088, 2177, + 1089, 2179, 1090, 2181, 1091, 2183, 1092, 2185, 1093, 2187, 1094, 2189, + 1095, 2191, 1096, 2193, 1097, 2195, 1098, 2197, 1099, 2199, 1100, 2201, + 1101, 2203, 1102, 2205, 1103, 2207, 1104, 2209, 1105, 2211, 1106, 2213, + 1107, 2215, 1108, 2217, 1109, 2219, 1110, 2221, 1111, 2223, 1112, 2225, + 1113, 2227, 1114, 2229, 1115, 2231, 1116, 2233, 1117, 2235, 1118, 2237, + 1119, 2239, 1120, 2241, 1121, 2243, 1122, 2245, 1123, 2247, 1124, 2249, + 1125, 2251, 1126, 2253, 1127, 2255, 1128, 2257, 1129, 2259, 1130, 2261, + 1131, 2263, 1132, 2265, 1133, 2267, 1134, 2269, 1135, 2271, 1136, 2273, + 1137, 2275, 1138, 2277, 1139, 2279, 1140, 2281, 1141, 2283, 1142, 2285, + 1143, 2287, 1144, 2289, 1145, 2291, 1146, 2293, 1147, 2295, 1148, 2297, + 1149, 2299, 1150, 2301, 1151, 2303, 1152, 2305, 1153, 2307, 1154, 2309, + 1155, 2311, 1156, 2313, 1157, 2315, 1158, 2317, 1159, 2319, 1160, 2321, + 1161, 2323, 1162, 2325, 1163, 2327, 1164, 2329, 1165, 2331, 1166, 2333, + 1167, 2335, 1168, 2337, 1169, 2339, 1170, 2341, 1171, 2343, 1172, 2345, + 1173, 2347, 1174, 2349, 1175, 2351, 1176, 2353, 1177, 2355, 1178, 2357, + 1179, 2359, 1180, 2361, 1181, 2363, 1182, 2365, 1183, 2367, 1184, 2369, + 1185, 2371, 1186, 2373, 1187, 2375, 1188, 2377, 1189, 2379, 1190, 2381, + 1191, 2383, 1192, 2385, 1193, 2387, 1194, 2389, 1195, 2391, 1196, 2393, + 1197, 2395, 1198, 2397, 1199, 2399, 1200, 2401, 1201, 2403, 1202, 2405, + 1203, 2407, 1204, 2409, 1205, 2411, 1206, 2413, 1207, 2415, 1208, 2417, + 1209, 2419, 1210, 2421, 1211, 2423, 1212, 2425, 1213, 2427, 1214, 2429, + 1215, 2431, 1216, 2433, 1217, 2435, 1218, 2437, 1219, 2439, 1220, 2441, + 1221, 2443, 1222, 2445, 1223, 2447, 1224, 2449, 1225, 2451, 1226, 2453, + 1227, 2455, 1228, 2457, 1229, 2459, 1230, 2461, 1231, 2463, 1232, 2465, + 1233, 2467, 1234, 2469, 1235, 2471, 1236, 2473, 1237, 2475, 1238, 2477, + 1239, 2479, 1240, 2481, 1241, 2483, 1242, 2485, 1243, 2487, 1244, 2489, + 1245, 2491, 1246, 2493, 1247, 2495, 1248, 2497, 1249, 2499, 1250, 2501, + 1251, 2503, 1252, 2505, 1253, 2507, 1254, 2509, 1255, 2511, 1256, 2513, + 1257, 2515, 1258, 2517, 1259, 2519, 1260, 2521, 1261, 2523, 1262, 2525, + 1263, 2527, 1264, 2529, 1265, 2531, 1266, 2533, 1267, 2535, 1268, 2537, + 1269, 2539, 1270, 2541, 1271, 2543, 1272, 2545, 1273, 2547, 1274, 2549, + 1275, 2551, 1276, 2553, 1277, 2555, 1278, 2557, 1279, 2559, 1280, 2561, + 1281, 2563, 1282, 2565, 1283, 2567, 1284, 2569, 1285, 2571, 1286, 2573, + 1287, 2575, 1288, 2577, 1289, 2579, 1290, 2581, 1291, 2583, 1292, 2585, + 1293, 2587, 1294, 2589, 1295, 2591, 1296, 2593, 1297, 2595, 1298, 2597, + 1299, 2599, 1300, 2601, 1301, 2603, 1302, 2605, 1303, 2607, 1304, 2609, + 1305, 2611, 1306, 2613, 1307, 2615, 1308, 2617, 1309, 2619, 1310, 2621, + 1311, 2623, 1312, 2625, 1313, 2627, 1314, 2629, 1315, 2631, 1316, 2633, + 1317, 2635, 1318, 2637, 1319, 2639, 1320, 2641, 1321, 2643, 1322, 2645, + 1323, 2647, 1324, 2649, 1325, 2651, 1326, 2653, 1327, 2655, 1328, 2657, + 1329, 2659, 1330, 2661, 1331, 2663, 1332, 2665, 1333, 2667, 1334, 2669, + 1335, 2671, 1336, 2673, 1337, 2675, 1338, 2677, 1339, 2679, 1340, 2681, + 1341, 2683, 1342, 2685, 1343, 2687, 1344, 2689, 1345, 2691, 1346, 2693, + 1347, 2695, 1348, 2697, 1349, 2699, 1350, 2701, 1351, 2703, 1352, 2705, + 1353, 2707, 1354, 2709, 1355, 2711, 1356, 2713, 1357, 2715, 1358, 2717, + 1359, 2719, 1360, 2721, 1361, 2723, 1362, 2725, 1363, 2727, 1364, 2729, + 1365, 2731, 1366, 2733, 1367, 2735, 1368, 2737, 1369, 2739, 1370, 2741, + 1371, 2743, 1372, 2745, 1373, 2747, 1374, 2749, 1375, 2751, 1376, 2753, + 1377, 2755, 1378, 2757, 1379, 2759, 1380, 2761, 1381, 2763, 1382, 2765, + 1383, 2767, 1384, 2769, 1385, 2771, 1386, 2773, 1387, 2775, 1388, 2777, + 1389, 2779, 1390, 2781, 1391, 2783, 1392, 2785, 1393, 2787, 1394, 2789, + 1395, 2791, 1396, 2793, 1397, 2795, 1398, 2797, 1399, 2799, 1400, 2801, + 1401, 2803, 1402, 2805, 1403, 2807, 1404, 2809, 1405, 2811, 1406, 2813, + 1407, 2815, 1408, 2817, 1409, 2819, 1410, 2821, 1411, 2823, 1412, 2825, + 1413, 2827, 1414, 2829, 1415, 2831, 1416, 2833, 1417, 2835, 1418, 2837, + 1419, 2839, 1420, 2841, 1421, 2843, 1422, 2845, 1423, 2847, 1424, 2849, + 1425, 2851, 1426, 2853, 1427, 2855, 1428, 2857, 1429, 2859, 1430, 2861, + 1431, 2863, 1432, 2865, 1433, 2867, 1434, 2869, 1435, 2871, 1436, 2873, + 1437, 2875, 1438, 2877, 1439, 2879, 1440, 2881, 1441, 2883, 1442, 2885, + 1443, 2887, 1444, 2889, 1445, 2891, 1446, 2893, 1447, 2895, 1448, 2897, + 1449, 2899, 1450, 2901, 1451, 2903, 1452, 2905, 1453, 2907, 1454, 2909, + 1455, 2911, 1456, 2913, 1457, 2915, 1458, 2917, 1459, 2919, 1460, 2921, + 1461, 2923, 1462, 2925, 1463, 2927, 1464, 2929, 1465, 2931, 1466, 2933, + 1467, 2935, 1468, 2937, 1469, 2939, 1470, 2941, 1471, 2943, 1472, 2945, + 1473, 2947, 1474, 2949, 1475, 2951, 1476, 2953, 1477, 2955, 1478, 2957, + 1479, 2959, 1480, 2961, 1481, 2963, 1482, 2965, 1483, 2967, 1484, 2969, + 1485, 2971, 1486, 2973, 1487, 2975, 1488, 2977, 1489, 2979, 1490, 2981, + 1491, 2983, 1492, 2985, 1493, 2987, 1494, 2989, 1495, 2991, 1496, 2993, + 1497, 2995, 1498, 2997, 1499, 2999, 1500, 3001, 1501, 3003, 1502, 3005, + 1503, 3007, 1504, 3009, 1505, 3011, 1506, 3013, 1507, 3015, 1508, 3017, + 1509, 3019, 1510, 3021, 1511, 3023, 1512, 3025, 1513, 3027, 1514, 3029, + 1515, 3031, 1516, 3033, 1517, 3035, 1518, 3037, 1519, 3039, 1520, 3041, + 1521, 3043, 1522, 3045, 1523, 3047, 1524, 3049, 1525, 3051, 1526, 3053, + 1527, 3055, 1528, 3057, 1529, 3059, 1530, 3061, 1531, 3063, 1532, 3065, + 1533, 3067, 1534, 3069, 1535, 3071, 1536, 3073, 1537, 3075, 1538, 3077, + 1539, 3079, 1540, 3081, 1541, 3083, 1542, 3085, 1543, 3087, 1544, 3089, + 1545, 3091, 1546, 3093, 1547, 3095, 1548, 3097, 1549, 3099, 1550, 3101, + 1551, 3103, 1552, 3105, 1553, 3107, 1554, 3109, 1555, 3111, 1556, 3113, + 1557, 3115, 1558, 3117, 1559, 3119, 1560, 3121, 1561, 3123, 1562, 3125, + 1563, 3127, 1564, 3129, 1565, 3131, 1566, 3133, 1567, 3135, 1568, 3137, + 1569, 3139, 1570, 3141, 1571, 3143, 1572, 3145, 1573, 3147, 1574, 3149, + 1575, 3151, 1576, 3153, 1577, 3155, 1578, 3157, 1579, 3159, 1580, 3161, + 1581, 3163, 1582, 3165, 1583, 3167, 1584, 3169, 1585, 3171, 1586, 3173, + 1587, 3175, 1588, 3177, 1589, 3179, 1590, 3181, 1591, 3183, 1592, 3185, + 1593, 3187, 1594, 3189, 1595, 3191, 1596, 3193, 1597, 3195, 1598, 3197, + 1599, 3199, 1600, 3201, 1601, 3203, 1602, 3205, 1603, 3207, 1604, 3209, + 1605, 3211, 1606, 3213, 1607, 3215, 1608, 3217, 1609, 3219, 1610, 3221, + 1611, 3223, 1612, 3225, 1613, 3227, 1614, 3229, 1615, 3231, 1616, 3233, + 1617, 3235, 1618, 3237, 1619, 3239, 1620, 3241, 1621, 3243, 1622, 3245, + 1623, 3247, 1624, 3249, 1625, 3251, 1626, 3253, 1627, 3255, 1628, 3257, + 1629, 3259, 1630, 3261, 1631, 3263, 1632, 3265, 1633, 3267, 1634, 3269, + 1635, 3271, 1636, 3273, 1637, 3275, 1638, 3277, 1639, 3279, 1640, 3281, + 1641, 3283, 1642, 3285, 1643, 3287, 1644, 3289, 1645, 3291, 1646, 3293, + 1647, 3295, 1648, 3297, 1649, 3299, 1650, 3301, 1651, 3303, 1652, 3305, + 1653, 3307, 1654, 3309, 1655, 3311, 1656, 3313, 1657, 3315, 1658, 3317, + 1659, 3319, 1660, 3321, 1661, 3323, 1662, 3325, 1663, 3327, 1664, 3329, + 1665, 3331, 1666, 3333, 1667, 3335, 1668, 3337, 1669, 3339, 1670, 3341, + 1671, 3343, 1672, 3345, 1673, 3347, 1674, 3349, 1675, 3351, 1676, 3353, + 1677, 3355, 1678, 3357, 1679, 3359, 1680, 3361, 1681, 3363, 1682, 3365, + 1683, 3367, 1684, 3369, 1685, 3371, 1686, 3373, 1687, 3375, 1688, 3377, + 1689, 3379, 1690, 3381, 1691, 3383, 1692, 3385, 1693, 3387, 1694, 3389, + 1695, 3391, 1696, 3393, 1697, 3395, 1698, 3397, 1699, 3399, 1700, 3401, + 1701, 3403, 1702, 3405, 1703, 3407, 1704, 3409, 1705, 3411, 1706, 3413, + 1707, 3415, 1708, 3417, 1709, 3419, 1710, 3421, 1711, 3423, 1712, 3425, + 1713, 3427, 1714, 3429, 1715, 3431, 1716, 3433, 1717, 3435, 1718, 3437, + 1719, 3439, 1720, 3441, 1721, 3443, 1722, 3445, 1723, 3447, 1724, 3449, + 1725, 3451, 1726, 3453, 1727, 3455, 1728, 3457, 1729, 3459, 1730, 3461, + 1731, 3463, 1732, 3465, 1733, 3467, 1734, 3469, 1735, 3471, 1736, 3473, + 1737, 3475, 1738, 3477, 1739, 3479, 1740, 3481, 1741, 3483, 1742, 3485, + 1743, 3487, 1744, 3489, 1745, 3491, 1746, 3493, 1747, 3495, 1748, 3497, + 1749, 3499, 1750, 3501, 1751, 3503, 1752, 3505, 1753, 3507, 1754, 3509, + 1755, 3511, 1756, 3513, 1757, 3515, 1758, 3517, 1759, 3519, 1760, 3521, + 1761, 3523, 1762, 3525, 1763, 3527, 1764, 3529, 1765, 3531, 1766, 3533, + 1767, 3535, 1768, 3537, 1769, 3539, 1770, 3541, 1771, 3543, 1772, 3545, + 1773, 3547, 1774, 3549, 1775, 3551, 1776, 3553, 1777, 3555, 1778, 3557, + 1779, 3559, 1780, 3561, 1781, 3563, 1782, 3565, 1783, 3567, 1784, 3569, + 1785, 3571, 1786, 3573, 1787, 3575, 1788, 3577, 1789, 3579, 1790, 3581, + 1791, 3583, 1792, 3585, 1793, 3587, 1794, 3589, 1795, 3591, 1796, 3593, + 1797, 3595, 1798, 3597, 1799, 3599, 1800, 3601, 1801, 3603, 1802, 3605, + 1803, 3607, 1804, 3609, 1805, 3611, 1806, 3613, 1807, 3615, 1808, 3617, + 1809, 3619, 1810, 3621, 1811, 3623, 1812, 3625, 1813, 3627, 1814, 3629, + 1815, 3631, 1816, 3633, 1817, 3635, 1818, 3637, 1819, 3639, 1820, 3641, + 1821, 3643, 1822, 3645, 1823, 3647, 1824, 3649, 1825, 3651, 1826, 3653, + 1827, 3655, 1828, 3657, 1829, 3659, 1830, 3661, 1831, 3663, 1832, 3665, + 1833, 3667, 1834, 3669, 1835, 3671, 1836, 3673, 1837, 3675, 1838, 3677, + 1839, 3679, 1840, 3681, 1841, 3683, 1842, 3685, 1843, 3687, 1844, 3689, + 1845, 3691, 1846, 3693, 1847, 3695, 1848, 3697, 1849, 3699, 1850, 3701, + 1851, 3703, 1852, 3705, 1853, 3707, 1854, 3709, 1855, 3711, 1856, 3713, + 1857, 3715, 1858, 3717, 1859, 3719, 1860, 3721, 1861, 3723, 1862, 3725, + 1863, 3727, 1864, 3729, 1865, 3731, 1866, 3733, 1867, 3735, 1868, 3737, + 1869, 3739, 1870, 3741, 1871, 3743, 1872, 3745, 1873, 3747, 1874, 3749, + 1875, 3751, 1876, 3753, 1877, 3755, 1878, 3757, 1879, 3759, 1880, 3761, + 1881, 3763, 1882, 3765, 1883, 3767, 1884, 3769, 1885, 3771, 1886, 3773, + 1887, 3775, 1888, 3777, 1889, 3779, 1890, 3781, 1891, 3783, 1892, 3785, + 1893, 3787, 1894, 3789, 1895, 3791, 1896, 3793, 1897, 3795, 1898, 3797, + 1899, 3799, 1900, 3801, 1901, 3803, 1902, 3805, 1903, 3807, 1904, 3809, + 1905, 3811, 1906, 3813, 1907, 3815, 1908, 3817, 1909, 3819, 1910, 3821, + 1911, 3823, 1912, 3825, 1913, 3827, 1914, 3829, 1915, 3831, 1916, 3833, + 1917, 3835, 1918, 3837, 1919, 3839, 1920, 3841, 1921, 3843, 1922, 3845, + 1923, 3847, 1924, 3849, 1925, 3851, 1926, 3853, 1927, 3855, 1928, 3857, + 1929, 3859, 1930, 3861, 1931, 3863, 1932, 3865, 1933, 3867, 1934, 3869, + 1935, 3871, 1936, 3873, 1937, 3875, 1938, 3877, 1939, 3879, 1940, 3881, + 1941, 3883, 1942, 3885, 1943, 3887, 1944, 3889, 1945, 3891, 1946, 3893, + 1947, 3895, 1948, 3897, 1949, 3899, 1950, 3901, 1951, 3903, 1952, 3905, + 1953, 3907, 1954, 3909, 1955, 3911, 1956, 3913, 1957, 3915, 1958, 3917, + 1959, 3919, 1960, 3921, 1961, 3923, 1962, 3925, 1963, 3927, 1964, 3929, + 1965, 3931, 1966, 3933, 1967, 3935, 1968, 3937, 1969, 3939, 1970, 3941, + 1971, 3943, 1972, 3945, 1973, 3947, 1974, 3949, 1975, 3951, 1976, 3953, + 1977, 3955, 1978, 3957, 1979, 3959, 1980, 3961, 1981, 3963, 1982, 3965, + 1983, 3967, 1984, 3969, 1985, 3971, 1986, 3973, 1987, 3975, 1988, 3977, + 1989, 3979, 1990, 3981, 1991, 3983, 1992, 3985, 1993, 3987, 1994, 3989, + 1995, 3991, 1996, 3993, 1997, 3995, 1998, 3997, 1999, 3999, 2000, 4001, + 2001, 4003, 2002, 4005, 2003, 4007, 2004, 4009, 2005, 4011, 2006, 4013, + 2007, 4015, 2008, 4017, 2009, 4019, 2010, 4021, 2011, 4023, 2012, 4025, + 2013, 4027, 2014, 4029, 2015, 4031, 2016, 4033, 2017, 4035, 2018, 4037, + 2019, 4039, 2020, 4041, 2021, 4043, 2022, 4045, 2023, 4047, 2024, 4049, + 2025, 4051, 2026, 4053, 2027, 4055, 2028, 4057, 2029, 4059, 2030, 4061, + 2031, 4063, 2032, 4065, 2033, 4067, 2034, 4069, 2035, 4071, 2036, 4073, + 2037, 4075, 2038, 4077, 2039, 4079, 2040, 4081, 2041, 4083, 2042, 4085, + 2043, 4087, 2044, 4089, 2045, 4091, 2046, 4093, 2047, 4095, 2048, 4097, + 2049, 4099, 2050, 4101, 2051, 4103, 2052, 4105, 2053, 4107, 2054, 4109, + 2055, 4111, 2056, 4113, 2057, 4115, 2058, 4117, 2059, 4119, 2060, 4121, + 2061, 4123, 2062, 4125, 2063, 4127, 2064, 4129, 2065, 4131, 2066, 4133, + 2067, 4135, 2068, 4137, 2069, 4139, 2070, 4141, 2071, 4143, 2072, 4145, + 2073, 4147, 2074, 4149, 2075, 4151, 2076, 4153, 2077, 4155, 2078, 4157, + 2079, 4159, 2080, 4161, 2081, 4163, 2082, 4165, 2083, 4167, 2084, 4169, + 2085, 4171, 2086, 4173, 2087, 4175, 2088, 4177, 2089, 4179, 2090, 4181, + 2091, 4183, 2092, 4185, 2093, 4187, 2094, 4189, 2095, 4191, 2096, 4193, + 2097, 4195, 2098, 4197, 2099, 4199, 2100, 4201, 2101, 4203, 2102, 4205, + 2103, 4207, 2104, 4209, 2105, 4211, 2106, 4213, 2107, 4215, 2108, 4217, + 2109, 4219, 2110, 4221, 2111, 4223, 2112, 4225, 2113, 4227, 2114, 4229, + 2115, 4231, 2116, 4233, 2117, 4235, 2118, 4237, 2119, 4239, 2120, 4241, + 2121, 4243, 2122, 4245, 2123, 4247, 2124, 4249, 2125, 4251, 2126, 4253, + 2127, 4255, 2128, 4257, 2129, 4259, 2130, 4261, 2131, 4263, 2132, 4265, + 2133, 4267, 2134, 4269, 2135, 4271, 2136, 4273, 2137, 4275, 2138, 4277, + 2139, 4279, 2140, 4281, 2141, 4283, 2142, 4285, 2143, 4287, 2144, 4289, + 2145, 4291, 2146, 4293, 2147, 4295, 2148, 4297, 2149, 4299, 2150, 4301, + 2151, 4303, 2152, 4305, 2153, 4307, 2154, 4309, 2155, 4311, 2156, 4313, + 2157, 4315, 2158, 4317, 2159, 4319, 2160, 4321, 2161, 4323, 2162, 4325, + 2163, 4327, 2164, 4329, 2165, 4331, 2166, 4333, 2167, 4335, 2168, 4337, + 2169, 4339, 2170, 4341, 2171, 4343, 2172, 4345, 2173, 4347, 2174, 4349, + 2175, 4351, 2176, 4353, 2177, 4355, 2178, 4357, 2179, 4359, 2180, 4361, + 2181, 4363, 2182, 4365, 2183, 4367, 2184, 4369, 2185, 4371, 2186, 4373, + 2187, 4375, 2188, 4377, 2189, 4379, 2190, 4381, 2191, 4383, 2192, 4385, + 2193, 4387, 2194, 4389, 2195, 4391, 2196, 4393, 2197, 4395, 2198, 4397, + 2199, 4399, 2200, 4401, 2201, 4403, 2202, 4405, 2203, 4407, 2204, 4409, + 2205, 4411, 2206, 4413, 2207, 4415, 2208, 4417, 2209, 4419, 2210, 4421, + 2211, 4423, 2212, 4425, 2213, 4427, 2214, 4429, 2215, 4431, 2216, 4433, + 2217, 4435, 2218, 4437, 2219, 4439, 2220, 4441, 2221, 4443, 2222, 4445, + 2223, 4447, 2224, 4449, 2225, 4451, 2226, 4453, 2227, 4455, 2228, 4457, + 2229, 4459, 2230, 4461, 2231, 4463, 2232, 4465, 2233, 4467, 2234, 4469, + 2235, 4471, 2236, 4473, 2237, 4475, 2238, 4477, 2239, 4479, 2240, 4481, + 2241, 4483, 2242, 4485, 2243, 4487, 2244, 4489, 2245, 4491, 2246, 4493, + 2247, 4495, 2248, 4497, 2249, 4499, 2250, 4501, 2251, 4503, 2252, 4505, + 2253, 4507, 2254, 4509, 2255, 4511, 2256, 4513, 2257, 4515, 2258, 4517, + 2259, 4519, 2260, 4521, 2261, 4523, 2262, 4525, 2263, 4527, 2264, 4529, + 2265, 4531, 2266, 4533, 2267, 4535, 2268, 4537, 2269, 4539, 2270, 4541, + 2271, 4543, 2272, 4545, 2273, 4547, 2274, 4549, 2275, 4551, 2276, 4553, + 2277, 4555, 2278, 4557, 2279, 4559, 2280, 4561, 2281, 4563, 2282, 4565, + 2283, 4567, 2284, 4569, 2285, 4571, 2286, 4573, 2287, 4575, 2288, 4577, + 2289, 4579, 2290, 4581, 2291, 4583, 2292, 4585, 2293, 4587, 2294, 4589, + 2295, 4591, 2296, 4593, 2297, 4595, 2298, 4597, 2299, 4599, 2300, 4601, + 2301, 4603, 2302, 4605, 2303, 4607, 2304, 4609, 2305, 4611, 2306, 4613, + 2307, 4615, 2308, 4617, 2309, 4619, 2310, 4621, 2311, 4623, 2312, 4625, + 2313, 4627, 2314, 4629, 2315, 4631, 2316, 4633, 2317, 4635, 2318, 4637, + 2319, 4639, 2320, 4641, 2321, 4643, 2322, 4645, 2323, 4647, 2324, 4649, + 2325, 4651, 2326, 4653, 2327, 4655, 2328, 4657, 2329, 4659, 2330, 4661, + 2331, 4663, 2332, 4665, 2333, 4667, 2334, 4669, 2335, 4671, 2336, 4673, + 2337, 4675, 2338, 4677, 2339, 4679, 2340, 4681, 2341, 4683, 2342, 4685, + 2343, 4687, 2344, 4689, 2345, 4691, 2346, 4693, 2347, 4695, 2348, 4697, + 2349, 4699, 2350, 4701, 2351, 4703, 2352, 4705, 2353, 4707, 2354, 4709, + 2355, 4711, 2356, 4713, 2357, 4715, 2358, 4717, 2359, 4719, 2360, 4721, + 2361, 4723, 2362, 4725, 2363, 4727, 2364, 4729, 2365, 4731, 2366, 4733, + 2367, 4735, 2368, 4737, 2369, 4739, 2370, 4741, 2371, 4743, 2372, 4745, + 0, 4747, 0, 4749, 0, 4751, 0, 4753, 0, 4755, 0, 4757, 0, 4759, 0, 4761, + 0, 4763, 0, 4765, 0, 4767, 0, 4769, 0, 4771, 0, 4773, 0, 4775, 0, 4777, + 0, 4779, 0, 4781, 0, 4783, 0, 4785, 0, 4787, 0, 4789, 0, 4791, 0, 4793, + 0, 4795, 0, 4797, 0, 4799, 0, 4801, 0, 4803, 2373, 4805, 2374, 4807, 2375, + 4809, 2376, 4811, 2377, 4813, 2378, 4815, 2379, 4817, 2380, 4819, 2381, + 4821, 2382, 4823, 2383, 4825, 2384, 4827, 2385, 4829, 2386, 4831, 2387, + 4833, 2388, 4835, 2389, 4837, 2390, 4839, 2391, 4841, 2392, 4843, 2393, + 4845, 2394, 4847, 2395, 4849, 2396, 4851, 2397, 4853, 2398, 4855, 2399, + 4857, 2400, 4859, 2401, 4861, 2402, 4863, 2403, 4865, 2404, 4867, 2405, + 4869, 2406, 4871, 2407, 4873, 2408, 4875, 0, 4877, 0, 4879, 0, 4881, 0, + 4883, 0, 4885, 0, 4887, 0, 1, 0, 40, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, + 98, 98, 2, 0, 79, 79, 111, 111, 2, 0, 82, 82, 114, 114, 2, 0, 84, 84, 116, + 116, 2, 0, 83, 83, 115, 115, 2, 0, 69, 69, 101, 101, 2, 0, 78, 78, 110, + 110, 2, 0, 67, 67, 99, 99, 2, 0, 68, 68, 100, 100, 2, 0, 85, 85, 117, 117, + 2, 0, 76, 76, 108, 108, 2, 0, 73, 73, 105, 105, 2, 0, 86, 86, 118, 118, + 2, 0, 77, 77, 109, 109, 2, 0, 80, 80, 112, 112, 2, 0, 70, 70, 102, 102, + 2, 0, 71, 71, 103, 103, 2, 0, 89, 89, 121, 121, 2, 0, 72, 72, 104, 104, + 2, 0, 74, 74, 106, 106, 2, 0, 75, 75, 107, 107, 2, 0, 87, 87, 119, 119, + 2, 0, 90, 90, 122, 122, 2, 0, 81, 81, 113, 113, 2, 0, 88, 88, 120, 120, + 3, 0, 10, 10, 13, 13, 39, 39, 1, 0, 48, 49, 3, 0, 48, 57, 65, 70, 97, 102, + 1, 0, 48, 57, 2, 0, 43, 43, 45, 45, 4, 0, 68, 68, 70, 70, 100, 100, 102, + 102, 3, 0, 10, 10, 13, 13, 34, 34, 2, 0, 48, 57, 95, 95, 2, 0, 10, 10, + 13, 13, 3, 0, 35, 36, 48, 57, 95, 95, 3, 0, 9, 10, 13, 13, 32, 32, 2, 0, + 65, 90, 97, 122, 2, 0, 9, 9, 32, 32, 10, 0, 192, 214, 216, 246, 248, 8191, + 11264, 12287, 12352, 12687, 13056, 13183, 13312, 16383, 19968, 55295, 63744, + 64255, 65280, 65520, 31853, 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, 2175, 1, 0, 0, 0, 0, 2177, 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, 0, 2243, + 1, 0, 0, 0, 0, 2245, 1, 0, 0, 0, 0, 2247, 1, 0, 0, 0, 0, 2249, 1, 0, 0, + 0, 0, 2251, 1, 0, 0, 0, 0, 2253, 1, 0, 0, 0, 0, 2255, 1, 0, 0, 0, 0, 2257, + 1, 0, 0, 0, 0, 2259, 1, 0, 0, 0, 0, 2261, 1, 0, 0, 0, 0, 2263, 1, 0, 0, + 0, 0, 2265, 1, 0, 0, 0, 0, 2267, 1, 0, 0, 0, 0, 2269, 1, 0, 0, 0, 0, 2271, + 1, 0, 0, 0, 0, 2273, 1, 0, 0, 0, 0, 2275, 1, 0, 0, 0, 0, 2277, 1, 0, 0, + 0, 0, 2279, 1, 0, 0, 0, 0, 2281, 1, 0, 0, 0, 0, 2283, 1, 0, 0, 0, 0, 2285, + 1, 0, 0, 0, 0, 2287, 1, 0, 0, 0, 0, 2289, 1, 0, 0, 0, 0, 2291, 1, 0, 0, + 0, 0, 2293, 1, 0, 0, 0, 0, 2295, 1, 0, 0, 0, 0, 2297, 1, 0, 0, 0, 0, 2299, + 1, 0, 0, 0, 0, 2301, 1, 0, 0, 0, 0, 2303, 1, 0, 0, 0, 0, 2305, 1, 0, 0, + 0, 0, 2307, 1, 0, 0, 0, 0, 2309, 1, 0, 0, 0, 0, 2311, 1, 0, 0, 0, 0, 2313, + 1, 0, 0, 0, 0, 2315, 1, 0, 0, 0, 0, 2317, 1, 0, 0, 0, 0, 2319, 1, 0, 0, + 0, 0, 2321, 1, 0, 0, 0, 0, 2323, 1, 0, 0, 0, 0, 2325, 1, 0, 0, 0, 0, 2327, + 1, 0, 0, 0, 0, 2329, 1, 0, 0, 0, 0, 2331, 1, 0, 0, 0, 0, 2333, 1, 0, 0, + 0, 0, 2335, 1, 0, 0, 0, 0, 2337, 1, 0, 0, 0, 0, 2339, 1, 0, 0, 0, 0, 2341, + 1, 0, 0, 0, 0, 2343, 1, 0, 0, 0, 0, 2345, 1, 0, 0, 0, 0, 2347, 1, 0, 0, + 0, 0, 2349, 1, 0, 0, 0, 0, 2351, 1, 0, 0, 0, 0, 2353, 1, 0, 0, 0, 0, 2355, + 1, 0, 0, 0, 0, 2357, 1, 0, 0, 0, 0, 2359, 1, 0, 0, 0, 0, 2361, 1, 0, 0, + 0, 0, 2363, 1, 0, 0, 0, 0, 2365, 1, 0, 0, 0, 0, 2367, 1, 0, 0, 0, 0, 2369, + 1, 0, 0, 0, 0, 2371, 1, 0, 0, 0, 0, 2373, 1, 0, 0, 0, 0, 2375, 1, 0, 0, + 0, 0, 2377, 1, 0, 0, 0, 0, 2379, 1, 0, 0, 0, 0, 2381, 1, 0, 0, 0, 0, 2383, + 1, 0, 0, 0, 0, 2385, 1, 0, 0, 0, 0, 2387, 1, 0, 0, 0, 0, 2389, 1, 0, 0, + 0, 0, 2391, 1, 0, 0, 0, 0, 2393, 1, 0, 0, 0, 0, 2395, 1, 0, 0, 0, 0, 2397, + 1, 0, 0, 0, 0, 2399, 1, 0, 0, 0, 0, 2401, 1, 0, 0, 0, 0, 2403, 1, 0, 0, + 0, 0, 2405, 1, 0, 0, 0, 0, 2407, 1, 0, 0, 0, 0, 2409, 1, 0, 0, 0, 0, 2411, + 1, 0, 0, 0, 0, 2413, 1, 0, 0, 0, 0, 2415, 1, 0, 0, 0, 0, 2417, 1, 0, 0, + 0, 0, 2419, 1, 0, 0, 0, 0, 2421, 1, 0, 0, 0, 0, 2423, 1, 0, 0, 0, 0, 2425, + 1, 0, 0, 0, 0, 2427, 1, 0, 0, 0, 0, 2429, 1, 0, 0, 0, 0, 2431, 1, 0, 0, + 0, 0, 2433, 1, 0, 0, 0, 0, 2435, 1, 0, 0, 0, 0, 2437, 1, 0, 0, 0, 0, 2439, + 1, 0, 0, 0, 0, 2441, 1, 0, 0, 0, 0, 2443, 1, 0, 0, 0, 0, 2445, 1, 0, 0, + 0, 0, 2447, 1, 0, 0, 0, 0, 2449, 1, 0, 0, 0, 0, 2451, 1, 0, 0, 0, 0, 2453, + 1, 0, 0, 0, 0, 2455, 1, 0, 0, 0, 0, 2457, 1, 0, 0, 0, 0, 2459, 1, 0, 0, + 0, 0, 2461, 1, 0, 0, 0, 0, 2463, 1, 0, 0, 0, 0, 2465, 1, 0, 0, 0, 0, 2467, + 1, 0, 0, 0, 0, 2469, 1, 0, 0, 0, 0, 2471, 1, 0, 0, 0, 0, 2473, 1, 0, 0, + 0, 0, 2475, 1, 0, 0, 0, 0, 2477, 1, 0, 0, 0, 0, 2479, 1, 0, 0, 0, 0, 2481, + 1, 0, 0, 0, 0, 2483, 1, 0, 0, 0, 0, 2485, 1, 0, 0, 0, 0, 2487, 1, 0, 0, + 0, 0, 2489, 1, 0, 0, 0, 0, 2491, 1, 0, 0, 0, 0, 2493, 1, 0, 0, 0, 0, 2495, + 1, 0, 0, 0, 0, 2497, 1, 0, 0, 0, 0, 2499, 1, 0, 0, 0, 0, 2501, 1, 0, 0, + 0, 0, 2503, 1, 0, 0, 0, 0, 2505, 1, 0, 0, 0, 0, 2507, 1, 0, 0, 0, 0, 2509, + 1, 0, 0, 0, 0, 2511, 1, 0, 0, 0, 0, 2513, 1, 0, 0, 0, 0, 2515, 1, 0, 0, + 0, 0, 2517, 1, 0, 0, 0, 0, 2519, 1, 0, 0, 0, 0, 2521, 1, 0, 0, 0, 0, 2523, + 1, 0, 0, 0, 0, 2525, 1, 0, 0, 0, 0, 2527, 1, 0, 0, 0, 0, 2529, 1, 0, 0, + 0, 0, 2531, 1, 0, 0, 0, 0, 2533, 1, 0, 0, 0, 0, 2535, 1, 0, 0, 0, 0, 2537, + 1, 0, 0, 0, 0, 2539, 1, 0, 0, 0, 0, 2541, 1, 0, 0, 0, 0, 2543, 1, 0, 0, + 0, 0, 2545, 1, 0, 0, 0, 0, 2547, 1, 0, 0, 0, 0, 2549, 1, 0, 0, 0, 0, 2551, + 1, 0, 0, 0, 0, 2553, 1, 0, 0, 0, 0, 2555, 1, 0, 0, 0, 0, 2557, 1, 0, 0, + 0, 0, 2559, 1, 0, 0, 0, 0, 2561, 1, 0, 0, 0, 0, 2563, 1, 0, 0, 0, 0, 2565, + 1, 0, 0, 0, 0, 2567, 1, 0, 0, 0, 0, 2569, 1, 0, 0, 0, 0, 2571, 1, 0, 0, + 0, 0, 2573, 1, 0, 0, 0, 0, 2575, 1, 0, 0, 0, 0, 2577, 1, 0, 0, 0, 0, 2579, + 1, 0, 0, 0, 0, 2581, 1, 0, 0, 0, 0, 2583, 1, 0, 0, 0, 0, 2585, 1, 0, 0, + 0, 0, 2587, 1, 0, 0, 0, 0, 2589, 1, 0, 0, 0, 0, 2591, 1, 0, 0, 0, 0, 2593, + 1, 0, 0, 0, 0, 2595, 1, 0, 0, 0, 0, 2597, 1, 0, 0, 0, 0, 2599, 1, 0, 0, + 0, 0, 2601, 1, 0, 0, 0, 0, 2603, 1, 0, 0, 0, 0, 2605, 1, 0, 0, 0, 0, 2607, + 1, 0, 0, 0, 0, 2609, 1, 0, 0, 0, 0, 2611, 1, 0, 0, 0, 0, 2613, 1, 0, 0, + 0, 0, 2615, 1, 0, 0, 0, 0, 2617, 1, 0, 0, 0, 0, 2619, 1, 0, 0, 0, 0, 2621, + 1, 0, 0, 0, 0, 2623, 1, 0, 0, 0, 0, 2625, 1, 0, 0, 0, 0, 2627, 1, 0, 0, + 0, 0, 2629, 1, 0, 0, 0, 0, 2631, 1, 0, 0, 0, 0, 2633, 1, 0, 0, 0, 0, 2635, + 1, 0, 0, 0, 0, 2637, 1, 0, 0, 0, 0, 2639, 1, 0, 0, 0, 0, 2641, 1, 0, 0, + 0, 0, 2643, 1, 0, 0, 0, 0, 2645, 1, 0, 0, 0, 0, 2647, 1, 0, 0, 0, 0, 2649, + 1, 0, 0, 0, 0, 2651, 1, 0, 0, 0, 0, 2653, 1, 0, 0, 0, 0, 2655, 1, 0, 0, + 0, 0, 2657, 1, 0, 0, 0, 0, 2659, 1, 0, 0, 0, 0, 2661, 1, 0, 0, 0, 0, 2663, + 1, 0, 0, 0, 0, 2665, 1, 0, 0, 0, 0, 2667, 1, 0, 0, 0, 0, 2669, 1, 0, 0, + 0, 0, 2671, 1, 0, 0, 0, 0, 2673, 1, 0, 0, 0, 0, 2675, 1, 0, 0, 0, 0, 2677, + 1, 0, 0, 0, 0, 2679, 1, 0, 0, 0, 0, 2681, 1, 0, 0, 0, 0, 2683, 1, 0, 0, + 0, 0, 2685, 1, 0, 0, 0, 0, 2687, 1, 0, 0, 0, 0, 2689, 1, 0, 0, 0, 0, 2691, + 1, 0, 0, 0, 0, 2693, 1, 0, 0, 0, 0, 2695, 1, 0, 0, 0, 0, 2697, 1, 0, 0, + 0, 0, 2699, 1, 0, 0, 0, 0, 2701, 1, 0, 0, 0, 0, 2703, 1, 0, 0, 0, 0, 2705, + 1, 0, 0, 0, 0, 2707, 1, 0, 0, 0, 0, 2709, 1, 0, 0, 0, 0, 2711, 1, 0, 0, + 0, 0, 2713, 1, 0, 0, 0, 0, 2715, 1, 0, 0, 0, 0, 2717, 1, 0, 0, 0, 0, 2719, + 1, 0, 0, 0, 0, 2721, 1, 0, 0, 0, 0, 2723, 1, 0, 0, 0, 0, 2725, 1, 0, 0, + 0, 0, 2727, 1, 0, 0, 0, 0, 2729, 1, 0, 0, 0, 0, 2731, 1, 0, 0, 0, 0, 2733, + 1, 0, 0, 0, 0, 2735, 1, 0, 0, 0, 0, 2737, 1, 0, 0, 0, 0, 2739, 1, 0, 0, + 0, 0, 2741, 1, 0, 0, 0, 0, 2743, 1, 0, 0, 0, 0, 2745, 1, 0, 0, 0, 0, 2747, + 1, 0, 0, 0, 0, 2749, 1, 0, 0, 0, 0, 2751, 1, 0, 0, 0, 0, 2753, 1, 0, 0, + 0, 0, 2755, 1, 0, 0, 0, 0, 2757, 1, 0, 0, 0, 0, 2759, 1, 0, 0, 0, 0, 2761, + 1, 0, 0, 0, 0, 2763, 1, 0, 0, 0, 0, 2765, 1, 0, 0, 0, 0, 2767, 1, 0, 0, + 0, 0, 2769, 1, 0, 0, 0, 0, 2771, 1, 0, 0, 0, 0, 2773, 1, 0, 0, 0, 0, 2775, + 1, 0, 0, 0, 0, 2777, 1, 0, 0, 0, 0, 2779, 1, 0, 0, 0, 0, 2781, 1, 0, 0, + 0, 0, 2783, 1, 0, 0, 0, 0, 2785, 1, 0, 0, 0, 0, 2787, 1, 0, 0, 0, 0, 2789, + 1, 0, 0, 0, 0, 2791, 1, 0, 0, 0, 0, 2793, 1, 0, 0, 0, 0, 2795, 1, 0, 0, + 0, 0, 2797, 1, 0, 0, 0, 0, 2799, 1, 0, 0, 0, 0, 2801, 1, 0, 0, 0, 0, 2803, + 1, 0, 0, 0, 0, 2805, 1, 0, 0, 0, 0, 2807, 1, 0, 0, 0, 0, 2809, 1, 0, 0, + 0, 0, 2811, 1, 0, 0, 0, 0, 2813, 1, 0, 0, 0, 0, 2815, 1, 0, 0, 0, 0, 2817, + 1, 0, 0, 0, 0, 2819, 1, 0, 0, 0, 0, 2821, 1, 0, 0, 0, 0, 2823, 1, 0, 0, + 0, 0, 2825, 1, 0, 0, 0, 0, 2827, 1, 0, 0, 0, 0, 2829, 1, 0, 0, 0, 0, 2831, + 1, 0, 0, 0, 0, 2833, 1, 0, 0, 0, 0, 2835, 1, 0, 0, 0, 0, 2837, 1, 0, 0, + 0, 0, 2839, 1, 0, 0, 0, 0, 2841, 1, 0, 0, 0, 0, 2843, 1, 0, 0, 0, 0, 2845, + 1, 0, 0, 0, 0, 2847, 1, 0, 0, 0, 0, 2849, 1, 0, 0, 0, 0, 2851, 1, 0, 0, + 0, 0, 2853, 1, 0, 0, 0, 0, 2855, 1, 0, 0, 0, 0, 2857, 1, 0, 0, 0, 0, 2859, + 1, 0, 0, 0, 0, 2861, 1, 0, 0, 0, 0, 2863, 1, 0, 0, 0, 0, 2865, 1, 0, 0, + 0, 0, 2867, 1, 0, 0, 0, 0, 2869, 1, 0, 0, 0, 0, 2871, 1, 0, 0, 0, 0, 2873, + 1, 0, 0, 0, 0, 2875, 1, 0, 0, 0, 0, 2877, 1, 0, 0, 0, 0, 2879, 1, 0, 0, + 0, 0, 2881, 1, 0, 0, 0, 0, 2883, 1, 0, 0, 0, 0, 2885, 1, 0, 0, 0, 0, 2887, + 1, 0, 0, 0, 0, 2889, 1, 0, 0, 0, 0, 2891, 1, 0, 0, 0, 0, 2893, 1, 0, 0, + 0, 0, 2895, 1, 0, 0, 0, 0, 2897, 1, 0, 0, 0, 0, 2899, 1, 0, 0, 0, 0, 2901, + 1, 0, 0, 0, 0, 2903, 1, 0, 0, 0, 0, 2905, 1, 0, 0, 0, 0, 2907, 1, 0, 0, + 0, 0, 2909, 1, 0, 0, 0, 0, 2911, 1, 0, 0, 0, 0, 2913, 1, 0, 0, 0, 0, 2915, + 1, 0, 0, 0, 0, 2917, 1, 0, 0, 0, 0, 2919, 1, 0, 0, 0, 0, 2921, 1, 0, 0, + 0, 0, 2923, 1, 0, 0, 0, 0, 2925, 1, 0, 0, 0, 0, 2927, 1, 0, 0, 0, 0, 2929, + 1, 0, 0, 0, 0, 2931, 1, 0, 0, 0, 0, 2933, 1, 0, 0, 0, 0, 2935, 1, 0, 0, + 0, 0, 2937, 1, 0, 0, 0, 0, 2939, 1, 0, 0, 0, 0, 2941, 1, 0, 0, 0, 0, 2943, + 1, 0, 0, 0, 0, 2945, 1, 0, 0, 0, 0, 2947, 1, 0, 0, 0, 0, 2949, 1, 0, 0, + 0, 0, 2951, 1, 0, 0, 0, 0, 2953, 1, 0, 0, 0, 0, 2955, 1, 0, 0, 0, 0, 2957, + 1, 0, 0, 0, 0, 2959, 1, 0, 0, 0, 0, 2961, 1, 0, 0, 0, 0, 2963, 1, 0, 0, + 0, 0, 2965, 1, 0, 0, 0, 0, 2967, 1, 0, 0, 0, 0, 2969, 1, 0, 0, 0, 0, 2971, + 1, 0, 0, 0, 0, 2973, 1, 0, 0, 0, 0, 2975, 1, 0, 0, 0, 0, 2977, 1, 0, 0, + 0, 0, 2979, 1, 0, 0, 0, 0, 2981, 1, 0, 0, 0, 0, 2983, 1, 0, 0, 0, 0, 2985, + 1, 0, 0, 0, 0, 2987, 1, 0, 0, 0, 0, 2989, 1, 0, 0, 0, 0, 2991, 1, 0, 0, + 0, 0, 2993, 1, 0, 0, 0, 0, 2995, 1, 0, 0, 0, 0, 2997, 1, 0, 0, 0, 0, 2999, + 1, 0, 0, 0, 0, 3001, 1, 0, 0, 0, 0, 3003, 1, 0, 0, 0, 0, 3005, 1, 0, 0, + 0, 0, 3007, 1, 0, 0, 0, 0, 3009, 1, 0, 0, 0, 0, 3011, 1, 0, 0, 0, 0, 3013, + 1, 0, 0, 0, 0, 3015, 1, 0, 0, 0, 0, 3017, 1, 0, 0, 0, 0, 3019, 1, 0, 0, + 0, 0, 3021, 1, 0, 0, 0, 0, 3023, 1, 0, 0, 0, 0, 3025, 1, 0, 0, 0, 0, 3027, + 1, 0, 0, 0, 0, 3029, 1, 0, 0, 0, 0, 3031, 1, 0, 0, 0, 0, 3033, 1, 0, 0, + 0, 0, 3035, 1, 0, 0, 0, 0, 3037, 1, 0, 0, 0, 0, 3039, 1, 0, 0, 0, 0, 3041, + 1, 0, 0, 0, 0, 3043, 1, 0, 0, 0, 0, 3045, 1, 0, 0, 0, 0, 3047, 1, 0, 0, + 0, 0, 3049, 1, 0, 0, 0, 0, 3051, 1, 0, 0, 0, 0, 3053, 1, 0, 0, 0, 0, 3055, + 1, 0, 0, 0, 0, 3057, 1, 0, 0, 0, 0, 3059, 1, 0, 0, 0, 0, 3061, 1, 0, 0, + 0, 0, 3063, 1, 0, 0, 0, 0, 3065, 1, 0, 0, 0, 0, 3067, 1, 0, 0, 0, 0, 3069, + 1, 0, 0, 0, 0, 3071, 1, 0, 0, 0, 0, 3073, 1, 0, 0, 0, 0, 3075, 1, 0, 0, + 0, 0, 3077, 1, 0, 0, 0, 0, 3079, 1, 0, 0, 0, 0, 3081, 1, 0, 0, 0, 0, 3083, + 1, 0, 0, 0, 0, 3085, 1, 0, 0, 0, 0, 3087, 1, 0, 0, 0, 0, 3089, 1, 0, 0, + 0, 0, 3091, 1, 0, 0, 0, 0, 3093, 1, 0, 0, 0, 0, 3095, 1, 0, 0, 0, 0, 3097, + 1, 0, 0, 0, 0, 3099, 1, 0, 0, 0, 0, 3101, 1, 0, 0, 0, 0, 3103, 1, 0, 0, + 0, 0, 3105, 1, 0, 0, 0, 0, 3107, 1, 0, 0, 0, 0, 3109, 1, 0, 0, 0, 0, 3111, + 1, 0, 0, 0, 0, 3113, 1, 0, 0, 0, 0, 3115, 1, 0, 0, 0, 0, 3117, 1, 0, 0, + 0, 0, 3119, 1, 0, 0, 0, 0, 3121, 1, 0, 0, 0, 0, 3123, 1, 0, 0, 0, 0, 3125, + 1, 0, 0, 0, 0, 3127, 1, 0, 0, 0, 0, 3129, 1, 0, 0, 0, 0, 3131, 1, 0, 0, + 0, 0, 3133, 1, 0, 0, 0, 0, 3135, 1, 0, 0, 0, 0, 3137, 1, 0, 0, 0, 0, 3139, + 1, 0, 0, 0, 0, 3141, 1, 0, 0, 0, 0, 3143, 1, 0, 0, 0, 0, 3145, 1, 0, 0, + 0, 0, 3147, 1, 0, 0, 0, 0, 3149, 1, 0, 0, 0, 0, 3151, 1, 0, 0, 0, 0, 3153, + 1, 0, 0, 0, 0, 3155, 1, 0, 0, 0, 0, 3157, 1, 0, 0, 0, 0, 3159, 1, 0, 0, + 0, 0, 3161, 1, 0, 0, 0, 0, 3163, 1, 0, 0, 0, 0, 3165, 1, 0, 0, 0, 0, 3167, + 1, 0, 0, 0, 0, 3169, 1, 0, 0, 0, 0, 3171, 1, 0, 0, 0, 0, 3173, 1, 0, 0, + 0, 0, 3175, 1, 0, 0, 0, 0, 3177, 1, 0, 0, 0, 0, 3179, 1, 0, 0, 0, 0, 3181, + 1, 0, 0, 0, 0, 3183, 1, 0, 0, 0, 0, 3185, 1, 0, 0, 0, 0, 3187, 1, 0, 0, + 0, 0, 3189, 1, 0, 0, 0, 0, 3191, 1, 0, 0, 0, 0, 3193, 1, 0, 0, 0, 0, 3195, + 1, 0, 0, 0, 0, 3197, 1, 0, 0, 0, 0, 3199, 1, 0, 0, 0, 0, 3201, 1, 0, 0, + 0, 0, 3203, 1, 0, 0, 0, 0, 3205, 1, 0, 0, 0, 0, 3207, 1, 0, 0, 0, 0, 3209, + 1, 0, 0, 0, 0, 3211, 1, 0, 0, 0, 0, 3213, 1, 0, 0, 0, 0, 3215, 1, 0, 0, + 0, 0, 3217, 1, 0, 0, 0, 0, 3219, 1, 0, 0, 0, 0, 3221, 1, 0, 0, 0, 0, 3223, + 1, 0, 0, 0, 0, 3225, 1, 0, 0, 0, 0, 3227, 1, 0, 0, 0, 0, 3229, 1, 0, 0, + 0, 0, 3231, 1, 0, 0, 0, 0, 3233, 1, 0, 0, 0, 0, 3235, 1, 0, 0, 0, 0, 3237, + 1, 0, 0, 0, 0, 3239, 1, 0, 0, 0, 0, 3241, 1, 0, 0, 0, 0, 3243, 1, 0, 0, + 0, 0, 3245, 1, 0, 0, 0, 0, 3247, 1, 0, 0, 0, 0, 3249, 1, 0, 0, 0, 0, 3251, + 1, 0, 0, 0, 0, 3253, 1, 0, 0, 0, 0, 3255, 1, 0, 0, 0, 0, 3257, 1, 0, 0, + 0, 0, 3259, 1, 0, 0, 0, 0, 3261, 1, 0, 0, 0, 0, 3263, 1, 0, 0, 0, 0, 3265, + 1, 0, 0, 0, 0, 3267, 1, 0, 0, 0, 0, 3269, 1, 0, 0, 0, 0, 3271, 1, 0, 0, + 0, 0, 3273, 1, 0, 0, 0, 0, 3275, 1, 0, 0, 0, 0, 3277, 1, 0, 0, 0, 0, 3279, + 1, 0, 0, 0, 0, 3281, 1, 0, 0, 0, 0, 3283, 1, 0, 0, 0, 0, 3285, 1, 0, 0, + 0, 0, 3287, 1, 0, 0, 0, 0, 3289, 1, 0, 0, 0, 0, 3291, 1, 0, 0, 0, 0, 3293, + 1, 0, 0, 0, 0, 3295, 1, 0, 0, 0, 0, 3297, 1, 0, 0, 0, 0, 3299, 1, 0, 0, + 0, 0, 3301, 1, 0, 0, 0, 0, 3303, 1, 0, 0, 0, 0, 3305, 1, 0, 0, 0, 0, 3307, + 1, 0, 0, 0, 0, 3309, 1, 0, 0, 0, 0, 3311, 1, 0, 0, 0, 0, 3313, 1, 0, 0, + 0, 0, 3315, 1, 0, 0, 0, 0, 3317, 1, 0, 0, 0, 0, 3319, 1, 0, 0, 0, 0, 3321, + 1, 0, 0, 0, 0, 3323, 1, 0, 0, 0, 0, 3325, 1, 0, 0, 0, 0, 3327, 1, 0, 0, + 0, 0, 3329, 1, 0, 0, 0, 0, 3331, 1, 0, 0, 0, 0, 3333, 1, 0, 0, 0, 0, 3335, + 1, 0, 0, 0, 0, 3337, 1, 0, 0, 0, 0, 3339, 1, 0, 0, 0, 0, 3341, 1, 0, 0, + 0, 0, 3343, 1, 0, 0, 0, 0, 3345, 1, 0, 0, 0, 0, 3347, 1, 0, 0, 0, 0, 3349, + 1, 0, 0, 0, 0, 3351, 1, 0, 0, 0, 0, 3353, 1, 0, 0, 0, 0, 3355, 1, 0, 0, + 0, 0, 3357, 1, 0, 0, 0, 0, 3359, 1, 0, 0, 0, 0, 3361, 1, 0, 0, 0, 0, 3363, + 1, 0, 0, 0, 0, 3365, 1, 0, 0, 0, 0, 3367, 1, 0, 0, 0, 0, 3369, 1, 0, 0, + 0, 0, 3371, 1, 0, 0, 0, 0, 3373, 1, 0, 0, 0, 0, 3375, 1, 0, 0, 0, 0, 3377, + 1, 0, 0, 0, 0, 3379, 1, 0, 0, 0, 0, 3381, 1, 0, 0, 0, 0, 3383, 1, 0, 0, + 0, 0, 3385, 1, 0, 0, 0, 0, 3387, 1, 0, 0, 0, 0, 3389, 1, 0, 0, 0, 0, 3391, + 1, 0, 0, 0, 0, 3393, 1, 0, 0, 0, 0, 3395, 1, 0, 0, 0, 0, 3397, 1, 0, 0, + 0, 0, 3399, 1, 0, 0, 0, 0, 3401, 1, 0, 0, 0, 0, 3403, 1, 0, 0, 0, 0, 3405, + 1, 0, 0, 0, 0, 3407, 1, 0, 0, 0, 0, 3409, 1, 0, 0, 0, 0, 3411, 1, 0, 0, + 0, 0, 3413, 1, 0, 0, 0, 0, 3415, 1, 0, 0, 0, 0, 3417, 1, 0, 0, 0, 0, 3419, + 1, 0, 0, 0, 0, 3421, 1, 0, 0, 0, 0, 3423, 1, 0, 0, 0, 0, 3425, 1, 0, 0, + 0, 0, 3427, 1, 0, 0, 0, 0, 3429, 1, 0, 0, 0, 0, 3431, 1, 0, 0, 0, 0, 3433, + 1, 0, 0, 0, 0, 3435, 1, 0, 0, 0, 0, 3437, 1, 0, 0, 0, 0, 3439, 1, 0, 0, + 0, 0, 3441, 1, 0, 0, 0, 0, 3443, 1, 0, 0, 0, 0, 3445, 1, 0, 0, 0, 0, 3447, + 1, 0, 0, 0, 0, 3449, 1, 0, 0, 0, 0, 3451, 1, 0, 0, 0, 0, 3453, 1, 0, 0, + 0, 0, 3455, 1, 0, 0, 0, 0, 3457, 1, 0, 0, 0, 0, 3459, 1, 0, 0, 0, 0, 3461, + 1, 0, 0, 0, 0, 3463, 1, 0, 0, 0, 0, 3465, 1, 0, 0, 0, 0, 3467, 1, 0, 0, + 0, 0, 3469, 1, 0, 0, 0, 0, 3471, 1, 0, 0, 0, 0, 3473, 1, 0, 0, 0, 0, 3475, + 1, 0, 0, 0, 0, 3477, 1, 0, 0, 0, 0, 3479, 1, 0, 0, 0, 0, 3481, 1, 0, 0, + 0, 0, 3483, 1, 0, 0, 0, 0, 3485, 1, 0, 0, 0, 0, 3487, 1, 0, 0, 0, 0, 3489, + 1, 0, 0, 0, 0, 3491, 1, 0, 0, 0, 0, 3493, 1, 0, 0, 0, 0, 3495, 1, 0, 0, + 0, 0, 3497, 1, 0, 0, 0, 0, 3499, 1, 0, 0, 0, 0, 3501, 1, 0, 0, 0, 0, 3503, + 1, 0, 0, 0, 0, 3505, 1, 0, 0, 0, 0, 3507, 1, 0, 0, 0, 0, 3509, 1, 0, 0, + 0, 0, 3511, 1, 0, 0, 0, 0, 3513, 1, 0, 0, 0, 0, 3515, 1, 0, 0, 0, 0, 3517, + 1, 0, 0, 0, 0, 3519, 1, 0, 0, 0, 0, 3521, 1, 0, 0, 0, 0, 3523, 1, 0, 0, + 0, 0, 3525, 1, 0, 0, 0, 0, 3527, 1, 0, 0, 0, 0, 3529, 1, 0, 0, 0, 0, 3531, + 1, 0, 0, 0, 0, 3533, 1, 0, 0, 0, 0, 3535, 1, 0, 0, 0, 0, 3537, 1, 0, 0, + 0, 0, 3539, 1, 0, 0, 0, 0, 3541, 1, 0, 0, 0, 0, 3543, 1, 0, 0, 0, 0, 3545, + 1, 0, 0, 0, 0, 3547, 1, 0, 0, 0, 0, 3549, 1, 0, 0, 0, 0, 3551, 1, 0, 0, + 0, 0, 3553, 1, 0, 0, 0, 0, 3555, 1, 0, 0, 0, 0, 3557, 1, 0, 0, 0, 0, 3559, + 1, 0, 0, 0, 0, 3561, 1, 0, 0, 0, 0, 3563, 1, 0, 0, 0, 0, 3565, 1, 0, 0, + 0, 0, 3567, 1, 0, 0, 0, 0, 3569, 1, 0, 0, 0, 0, 3571, 1, 0, 0, 0, 0, 3573, + 1, 0, 0, 0, 0, 3575, 1, 0, 0, 0, 0, 3577, 1, 0, 0, 0, 0, 3579, 1, 0, 0, + 0, 0, 3581, 1, 0, 0, 0, 0, 3583, 1, 0, 0, 0, 0, 3585, 1, 0, 0, 0, 0, 3587, + 1, 0, 0, 0, 0, 3589, 1, 0, 0, 0, 0, 3591, 1, 0, 0, 0, 0, 3593, 1, 0, 0, + 0, 0, 3595, 1, 0, 0, 0, 0, 3597, 1, 0, 0, 0, 0, 3599, 1, 0, 0, 0, 0, 3601, + 1, 0, 0, 0, 0, 3603, 1, 0, 0, 0, 0, 3605, 1, 0, 0, 0, 0, 3607, 1, 0, 0, + 0, 0, 3609, 1, 0, 0, 0, 0, 3611, 1, 0, 0, 0, 0, 3613, 1, 0, 0, 0, 0, 3615, + 1, 0, 0, 0, 0, 3617, 1, 0, 0, 0, 0, 3619, 1, 0, 0, 0, 0, 3621, 1, 0, 0, + 0, 0, 3623, 1, 0, 0, 0, 0, 3625, 1, 0, 0, 0, 0, 3627, 1, 0, 0, 0, 0, 3629, + 1, 0, 0, 0, 0, 3631, 1, 0, 0, 0, 0, 3633, 1, 0, 0, 0, 0, 3635, 1, 0, 0, + 0, 0, 3637, 1, 0, 0, 0, 0, 3639, 1, 0, 0, 0, 0, 3641, 1, 0, 0, 0, 0, 3643, + 1, 0, 0, 0, 0, 3645, 1, 0, 0, 0, 0, 3647, 1, 0, 0, 0, 0, 3649, 1, 0, 0, + 0, 0, 3651, 1, 0, 0, 0, 0, 3653, 1, 0, 0, 0, 0, 3655, 1, 0, 0, 0, 0, 3657, + 1, 0, 0, 0, 0, 3659, 1, 0, 0, 0, 0, 3661, 1, 0, 0, 0, 0, 3663, 1, 0, 0, + 0, 0, 3665, 1, 0, 0, 0, 0, 3667, 1, 0, 0, 0, 0, 3669, 1, 0, 0, 0, 0, 3671, + 1, 0, 0, 0, 0, 3673, 1, 0, 0, 0, 0, 3675, 1, 0, 0, 0, 0, 3677, 1, 0, 0, + 0, 0, 3679, 1, 0, 0, 0, 0, 3681, 1, 0, 0, 0, 0, 3683, 1, 0, 0, 0, 0, 3685, + 1, 0, 0, 0, 0, 3687, 1, 0, 0, 0, 0, 3689, 1, 0, 0, 0, 0, 3691, 1, 0, 0, + 0, 0, 3693, 1, 0, 0, 0, 0, 3695, 1, 0, 0, 0, 0, 3697, 1, 0, 0, 0, 0, 3699, + 1, 0, 0, 0, 0, 3701, 1, 0, 0, 0, 0, 3703, 1, 0, 0, 0, 0, 3705, 1, 0, 0, + 0, 0, 3707, 1, 0, 0, 0, 0, 3709, 1, 0, 0, 0, 0, 3711, 1, 0, 0, 0, 0, 3713, + 1, 0, 0, 0, 0, 3715, 1, 0, 0, 0, 0, 3717, 1, 0, 0, 0, 0, 3719, 1, 0, 0, + 0, 0, 3721, 1, 0, 0, 0, 0, 3723, 1, 0, 0, 0, 0, 3725, 1, 0, 0, 0, 0, 3727, + 1, 0, 0, 0, 0, 3729, 1, 0, 0, 0, 0, 3731, 1, 0, 0, 0, 0, 3733, 1, 0, 0, + 0, 0, 3735, 1, 0, 0, 0, 0, 3737, 1, 0, 0, 0, 0, 3739, 1, 0, 0, 0, 0, 3741, + 1, 0, 0, 0, 0, 3743, 1, 0, 0, 0, 0, 3745, 1, 0, 0, 0, 0, 3747, 1, 0, 0, + 0, 0, 3749, 1, 0, 0, 0, 0, 3751, 1, 0, 0, 0, 0, 3753, 1, 0, 0, 0, 0, 3755, + 1, 0, 0, 0, 0, 3757, 1, 0, 0, 0, 0, 3759, 1, 0, 0, 0, 0, 3761, 1, 0, 0, + 0, 0, 3763, 1, 0, 0, 0, 0, 3765, 1, 0, 0, 0, 0, 3767, 1, 0, 0, 0, 0, 3769, + 1, 0, 0, 0, 0, 3771, 1, 0, 0, 0, 0, 3773, 1, 0, 0, 0, 0, 3775, 1, 0, 0, + 0, 0, 3777, 1, 0, 0, 0, 0, 3779, 1, 0, 0, 0, 0, 3781, 1, 0, 0, 0, 0, 3783, + 1, 0, 0, 0, 0, 3785, 1, 0, 0, 0, 0, 3787, 1, 0, 0, 0, 0, 3789, 1, 0, 0, + 0, 0, 3791, 1, 0, 0, 0, 0, 3793, 1, 0, 0, 0, 0, 3795, 1, 0, 0, 0, 0, 3797, + 1, 0, 0, 0, 0, 3799, 1, 0, 0, 0, 0, 3801, 1, 0, 0, 0, 0, 3803, 1, 0, 0, + 0, 0, 3805, 1, 0, 0, 0, 0, 3807, 1, 0, 0, 0, 0, 3809, 1, 0, 0, 0, 0, 3811, + 1, 0, 0, 0, 0, 3813, 1, 0, 0, 0, 0, 3815, 1, 0, 0, 0, 0, 3817, 1, 0, 0, + 0, 0, 3819, 1, 0, 0, 0, 0, 3821, 1, 0, 0, 0, 0, 3823, 1, 0, 0, 0, 0, 3825, + 1, 0, 0, 0, 0, 3827, 1, 0, 0, 0, 0, 3829, 1, 0, 0, 0, 0, 3831, 1, 0, 0, + 0, 0, 3833, 1, 0, 0, 0, 0, 3835, 1, 0, 0, 0, 0, 3837, 1, 0, 0, 0, 0, 3839, + 1, 0, 0, 0, 0, 3841, 1, 0, 0, 0, 0, 3843, 1, 0, 0, 0, 0, 3845, 1, 0, 0, + 0, 0, 3847, 1, 0, 0, 0, 0, 3849, 1, 0, 0, 0, 0, 3851, 1, 0, 0, 0, 0, 3853, + 1, 0, 0, 0, 0, 3855, 1, 0, 0, 0, 0, 3857, 1, 0, 0, 0, 0, 3859, 1, 0, 0, + 0, 0, 3861, 1, 0, 0, 0, 0, 3863, 1, 0, 0, 0, 0, 3865, 1, 0, 0, 0, 0, 3867, + 1, 0, 0, 0, 0, 3869, 1, 0, 0, 0, 0, 3871, 1, 0, 0, 0, 0, 3873, 1, 0, 0, + 0, 0, 3875, 1, 0, 0, 0, 0, 3877, 1, 0, 0, 0, 0, 3879, 1, 0, 0, 0, 0, 3881, + 1, 0, 0, 0, 0, 3883, 1, 0, 0, 0, 0, 3885, 1, 0, 0, 0, 0, 3887, 1, 0, 0, + 0, 0, 3889, 1, 0, 0, 0, 0, 3891, 1, 0, 0, 0, 0, 3893, 1, 0, 0, 0, 0, 3895, + 1, 0, 0, 0, 0, 3897, 1, 0, 0, 0, 0, 3899, 1, 0, 0, 0, 0, 3901, 1, 0, 0, + 0, 0, 3903, 1, 0, 0, 0, 0, 3905, 1, 0, 0, 0, 0, 3907, 1, 0, 0, 0, 0, 3909, + 1, 0, 0, 0, 0, 3911, 1, 0, 0, 0, 0, 3913, 1, 0, 0, 0, 0, 3915, 1, 0, 0, + 0, 0, 3917, 1, 0, 0, 0, 0, 3919, 1, 0, 0, 0, 0, 3921, 1, 0, 0, 0, 0, 3923, + 1, 0, 0, 0, 0, 3925, 1, 0, 0, 0, 0, 3927, 1, 0, 0, 0, 0, 3929, 1, 0, 0, + 0, 0, 3931, 1, 0, 0, 0, 0, 3933, 1, 0, 0, 0, 0, 3935, 1, 0, 0, 0, 0, 3937, + 1, 0, 0, 0, 0, 3939, 1, 0, 0, 0, 0, 3941, 1, 0, 0, 0, 0, 3943, 1, 0, 0, + 0, 0, 3945, 1, 0, 0, 0, 0, 3947, 1, 0, 0, 0, 0, 3949, 1, 0, 0, 0, 0, 3951, + 1, 0, 0, 0, 0, 3953, 1, 0, 0, 0, 0, 3955, 1, 0, 0, 0, 0, 3957, 1, 0, 0, + 0, 0, 3959, 1, 0, 0, 0, 0, 3961, 1, 0, 0, 0, 0, 3963, 1, 0, 0, 0, 0, 3965, + 1, 0, 0, 0, 0, 3967, 1, 0, 0, 0, 0, 3969, 1, 0, 0, 0, 0, 3971, 1, 0, 0, + 0, 0, 3973, 1, 0, 0, 0, 0, 3975, 1, 0, 0, 0, 0, 3977, 1, 0, 0, 0, 0, 3979, + 1, 0, 0, 0, 0, 3981, 1, 0, 0, 0, 0, 3983, 1, 0, 0, 0, 0, 3985, 1, 0, 0, + 0, 0, 3987, 1, 0, 0, 0, 0, 3989, 1, 0, 0, 0, 0, 3991, 1, 0, 0, 0, 0, 3993, + 1, 0, 0, 0, 0, 3995, 1, 0, 0, 0, 0, 3997, 1, 0, 0, 0, 0, 3999, 1, 0, 0, + 0, 0, 4001, 1, 0, 0, 0, 0, 4003, 1, 0, 0, 0, 0, 4005, 1, 0, 0, 0, 0, 4007, + 1, 0, 0, 0, 0, 4009, 1, 0, 0, 0, 0, 4011, 1, 0, 0, 0, 0, 4013, 1, 0, 0, + 0, 0, 4015, 1, 0, 0, 0, 0, 4017, 1, 0, 0, 0, 0, 4019, 1, 0, 0, 0, 0, 4021, + 1, 0, 0, 0, 0, 4023, 1, 0, 0, 0, 0, 4025, 1, 0, 0, 0, 0, 4027, 1, 0, 0, + 0, 0, 4029, 1, 0, 0, 0, 0, 4031, 1, 0, 0, 0, 0, 4033, 1, 0, 0, 0, 0, 4035, + 1, 0, 0, 0, 0, 4037, 1, 0, 0, 0, 0, 4039, 1, 0, 0, 0, 0, 4041, 1, 0, 0, + 0, 0, 4043, 1, 0, 0, 0, 0, 4045, 1, 0, 0, 0, 0, 4047, 1, 0, 0, 0, 0, 4049, + 1, 0, 0, 0, 0, 4051, 1, 0, 0, 0, 0, 4053, 1, 0, 0, 0, 0, 4055, 1, 0, 0, + 0, 0, 4057, 1, 0, 0, 0, 0, 4059, 1, 0, 0, 0, 0, 4061, 1, 0, 0, 0, 0, 4063, + 1, 0, 0, 0, 0, 4065, 1, 0, 0, 0, 0, 4067, 1, 0, 0, 0, 0, 4069, 1, 0, 0, + 0, 0, 4071, 1, 0, 0, 0, 0, 4073, 1, 0, 0, 0, 0, 4075, 1, 0, 0, 0, 0, 4077, + 1, 0, 0, 0, 0, 4079, 1, 0, 0, 0, 0, 4081, 1, 0, 0, 0, 0, 4083, 1, 0, 0, + 0, 0, 4085, 1, 0, 0, 0, 0, 4087, 1, 0, 0, 0, 0, 4089, 1, 0, 0, 0, 0, 4091, + 1, 0, 0, 0, 0, 4093, 1, 0, 0, 0, 0, 4095, 1, 0, 0, 0, 0, 4097, 1, 0, 0, + 0, 0, 4099, 1, 0, 0, 0, 0, 4101, 1, 0, 0, 0, 0, 4103, 1, 0, 0, 0, 0, 4105, + 1, 0, 0, 0, 0, 4107, 1, 0, 0, 0, 0, 4109, 1, 0, 0, 0, 0, 4111, 1, 0, 0, + 0, 0, 4113, 1, 0, 0, 0, 0, 4115, 1, 0, 0, 0, 0, 4117, 1, 0, 0, 0, 0, 4119, + 1, 0, 0, 0, 0, 4121, 1, 0, 0, 0, 0, 4123, 1, 0, 0, 0, 0, 4125, 1, 0, 0, + 0, 0, 4127, 1, 0, 0, 0, 0, 4129, 1, 0, 0, 0, 0, 4131, 1, 0, 0, 0, 0, 4133, + 1, 0, 0, 0, 0, 4135, 1, 0, 0, 0, 0, 4137, 1, 0, 0, 0, 0, 4139, 1, 0, 0, + 0, 0, 4141, 1, 0, 0, 0, 0, 4143, 1, 0, 0, 0, 0, 4145, 1, 0, 0, 0, 0, 4147, + 1, 0, 0, 0, 0, 4149, 1, 0, 0, 0, 0, 4151, 1, 0, 0, 0, 0, 4153, 1, 0, 0, + 0, 0, 4155, 1, 0, 0, 0, 0, 4157, 1, 0, 0, 0, 0, 4159, 1, 0, 0, 0, 0, 4161, + 1, 0, 0, 0, 0, 4163, 1, 0, 0, 0, 0, 4165, 1, 0, 0, 0, 0, 4167, 1, 0, 0, + 0, 0, 4169, 1, 0, 0, 0, 0, 4171, 1, 0, 0, 0, 0, 4173, 1, 0, 0, 0, 0, 4175, + 1, 0, 0, 0, 0, 4177, 1, 0, 0, 0, 0, 4179, 1, 0, 0, 0, 0, 4181, 1, 0, 0, + 0, 0, 4183, 1, 0, 0, 0, 0, 4185, 1, 0, 0, 0, 0, 4187, 1, 0, 0, 0, 0, 4189, + 1, 0, 0, 0, 0, 4191, 1, 0, 0, 0, 0, 4193, 1, 0, 0, 0, 0, 4195, 1, 0, 0, + 0, 0, 4197, 1, 0, 0, 0, 0, 4199, 1, 0, 0, 0, 0, 4201, 1, 0, 0, 0, 0, 4203, + 1, 0, 0, 0, 0, 4205, 1, 0, 0, 0, 0, 4207, 1, 0, 0, 0, 0, 4209, 1, 0, 0, + 0, 0, 4211, 1, 0, 0, 0, 0, 4213, 1, 0, 0, 0, 0, 4215, 1, 0, 0, 0, 0, 4217, + 1, 0, 0, 0, 0, 4219, 1, 0, 0, 0, 0, 4221, 1, 0, 0, 0, 0, 4223, 1, 0, 0, + 0, 0, 4225, 1, 0, 0, 0, 0, 4227, 1, 0, 0, 0, 0, 4229, 1, 0, 0, 0, 0, 4231, + 1, 0, 0, 0, 0, 4233, 1, 0, 0, 0, 0, 4235, 1, 0, 0, 0, 0, 4237, 1, 0, 0, + 0, 0, 4239, 1, 0, 0, 0, 0, 4241, 1, 0, 0, 0, 0, 4243, 1, 0, 0, 0, 0, 4245, + 1, 0, 0, 0, 0, 4247, 1, 0, 0, 0, 0, 4249, 1, 0, 0, 0, 0, 4251, 1, 0, 0, + 0, 0, 4253, 1, 0, 0, 0, 0, 4255, 1, 0, 0, 0, 0, 4257, 1, 0, 0, 0, 0, 4259, + 1, 0, 0, 0, 0, 4261, 1, 0, 0, 0, 0, 4263, 1, 0, 0, 0, 0, 4265, 1, 0, 0, + 0, 0, 4267, 1, 0, 0, 0, 0, 4269, 1, 0, 0, 0, 0, 4271, 1, 0, 0, 0, 0, 4273, + 1, 0, 0, 0, 0, 4275, 1, 0, 0, 0, 0, 4277, 1, 0, 0, 0, 0, 4279, 1, 0, 0, + 0, 0, 4281, 1, 0, 0, 0, 0, 4283, 1, 0, 0, 0, 0, 4285, 1, 0, 0, 0, 0, 4287, + 1, 0, 0, 0, 0, 4289, 1, 0, 0, 0, 0, 4291, 1, 0, 0, 0, 0, 4293, 1, 0, 0, + 0, 0, 4295, 1, 0, 0, 0, 0, 4297, 1, 0, 0, 0, 0, 4299, 1, 0, 0, 0, 0, 4301, + 1, 0, 0, 0, 0, 4303, 1, 0, 0, 0, 0, 4305, 1, 0, 0, 0, 0, 4307, 1, 0, 0, + 0, 0, 4309, 1, 0, 0, 0, 0, 4311, 1, 0, 0, 0, 0, 4313, 1, 0, 0, 0, 0, 4315, + 1, 0, 0, 0, 0, 4317, 1, 0, 0, 0, 0, 4319, 1, 0, 0, 0, 0, 4321, 1, 0, 0, + 0, 0, 4323, 1, 0, 0, 0, 0, 4325, 1, 0, 0, 0, 0, 4327, 1, 0, 0, 0, 0, 4329, + 1, 0, 0, 0, 0, 4331, 1, 0, 0, 0, 0, 4333, 1, 0, 0, 0, 0, 4335, 1, 0, 0, + 0, 0, 4337, 1, 0, 0, 0, 0, 4339, 1, 0, 0, 0, 0, 4341, 1, 0, 0, 0, 0, 4343, + 1, 0, 0, 0, 0, 4345, 1, 0, 0, 0, 0, 4347, 1, 0, 0, 0, 0, 4349, 1, 0, 0, + 0, 0, 4351, 1, 0, 0, 0, 0, 4353, 1, 0, 0, 0, 0, 4355, 1, 0, 0, 0, 0, 4357, + 1, 0, 0, 0, 0, 4359, 1, 0, 0, 0, 0, 4361, 1, 0, 0, 0, 0, 4363, 1, 0, 0, + 0, 0, 4365, 1, 0, 0, 0, 0, 4367, 1, 0, 0, 0, 0, 4369, 1, 0, 0, 0, 0, 4371, + 1, 0, 0, 0, 0, 4373, 1, 0, 0, 0, 0, 4375, 1, 0, 0, 0, 0, 4377, 1, 0, 0, + 0, 0, 4379, 1, 0, 0, 0, 0, 4381, 1, 0, 0, 0, 0, 4383, 1, 0, 0, 0, 0, 4385, + 1, 0, 0, 0, 0, 4387, 1, 0, 0, 0, 0, 4389, 1, 0, 0, 0, 0, 4391, 1, 0, 0, + 0, 0, 4393, 1, 0, 0, 0, 0, 4395, 1, 0, 0, 0, 0, 4397, 1, 0, 0, 0, 0, 4399, + 1, 0, 0, 0, 0, 4401, 1, 0, 0, 0, 0, 4403, 1, 0, 0, 0, 0, 4405, 1, 0, 0, + 0, 0, 4407, 1, 0, 0, 0, 0, 4409, 1, 0, 0, 0, 0, 4411, 1, 0, 0, 0, 0, 4413, + 1, 0, 0, 0, 0, 4415, 1, 0, 0, 0, 0, 4417, 1, 0, 0, 0, 0, 4419, 1, 0, 0, + 0, 0, 4421, 1, 0, 0, 0, 0, 4423, 1, 0, 0, 0, 0, 4425, 1, 0, 0, 0, 0, 4427, + 1, 0, 0, 0, 0, 4429, 1, 0, 0, 0, 0, 4431, 1, 0, 0, 0, 0, 4433, 1, 0, 0, + 0, 0, 4435, 1, 0, 0, 0, 0, 4437, 1, 0, 0, 0, 0, 4439, 1, 0, 0, 0, 0, 4441, + 1, 0, 0, 0, 0, 4443, 1, 0, 0, 0, 0, 4445, 1, 0, 0, 0, 0, 4447, 1, 0, 0, + 0, 0, 4449, 1, 0, 0, 0, 0, 4451, 1, 0, 0, 0, 0, 4453, 1, 0, 0, 0, 0, 4455, + 1, 0, 0, 0, 0, 4457, 1, 0, 0, 0, 0, 4459, 1, 0, 0, 0, 0, 4461, 1, 0, 0, + 0, 0, 4463, 1, 0, 0, 0, 0, 4465, 1, 0, 0, 0, 0, 4467, 1, 0, 0, 0, 0, 4469, + 1, 0, 0, 0, 0, 4471, 1, 0, 0, 0, 0, 4473, 1, 0, 0, 0, 0, 4475, 1, 0, 0, + 0, 0, 4477, 1, 0, 0, 0, 0, 4479, 1, 0, 0, 0, 0, 4481, 1, 0, 0, 0, 0, 4483, + 1, 0, 0, 0, 0, 4485, 1, 0, 0, 0, 0, 4487, 1, 0, 0, 0, 0, 4489, 1, 0, 0, + 0, 0, 4491, 1, 0, 0, 0, 0, 4493, 1, 0, 0, 0, 0, 4495, 1, 0, 0, 0, 0, 4497, + 1, 0, 0, 0, 0, 4499, 1, 0, 0, 0, 0, 4501, 1, 0, 0, 0, 0, 4503, 1, 0, 0, + 0, 0, 4505, 1, 0, 0, 0, 0, 4507, 1, 0, 0, 0, 0, 4509, 1, 0, 0, 0, 0, 4511, + 1, 0, 0, 0, 0, 4513, 1, 0, 0, 0, 0, 4515, 1, 0, 0, 0, 0, 4517, 1, 0, 0, + 0, 0, 4519, 1, 0, 0, 0, 0, 4521, 1, 0, 0, 0, 0, 4523, 1, 0, 0, 0, 0, 4525, + 1, 0, 0, 0, 0, 4527, 1, 0, 0, 0, 0, 4529, 1, 0, 0, 0, 0, 4531, 1, 0, 0, + 0, 0, 4533, 1, 0, 0, 0, 0, 4535, 1, 0, 0, 0, 0, 4537, 1, 0, 0, 0, 0, 4539, + 1, 0, 0, 0, 0, 4541, 1, 0, 0, 0, 0, 4543, 1, 0, 0, 0, 0, 4545, 1, 0, 0, + 0, 0, 4547, 1, 0, 0, 0, 0, 4549, 1, 0, 0, 0, 0, 4551, 1, 0, 0, 0, 0, 4553, + 1, 0, 0, 0, 0, 4555, 1, 0, 0, 0, 0, 4557, 1, 0, 0, 0, 0, 4559, 1, 0, 0, + 0, 0, 4561, 1, 0, 0, 0, 0, 4563, 1, 0, 0, 0, 0, 4565, 1, 0, 0, 0, 0, 4567, + 1, 0, 0, 0, 0, 4569, 1, 0, 0, 0, 0, 4571, 1, 0, 0, 0, 0, 4573, 1, 0, 0, + 0, 0, 4575, 1, 0, 0, 0, 0, 4577, 1, 0, 0, 0, 0, 4579, 1, 0, 0, 0, 0, 4581, + 1, 0, 0, 0, 0, 4583, 1, 0, 0, 0, 0, 4585, 1, 0, 0, 0, 0, 4587, 1, 0, 0, + 0, 0, 4589, 1, 0, 0, 0, 0, 4591, 1, 0, 0, 0, 0, 4593, 1, 0, 0, 0, 0, 4595, + 1, 0, 0, 0, 0, 4597, 1, 0, 0, 0, 0, 4599, 1, 0, 0, 0, 0, 4601, 1, 0, 0, + 0, 0, 4603, 1, 0, 0, 0, 0, 4605, 1, 0, 0, 0, 0, 4607, 1, 0, 0, 0, 0, 4609, + 1, 0, 0, 0, 0, 4611, 1, 0, 0, 0, 0, 4613, 1, 0, 0, 0, 0, 4615, 1, 0, 0, + 0, 0, 4617, 1, 0, 0, 0, 0, 4619, 1, 0, 0, 0, 0, 4621, 1, 0, 0, 0, 0, 4623, + 1, 0, 0, 0, 0, 4625, 1, 0, 0, 0, 0, 4627, 1, 0, 0, 0, 0, 4629, 1, 0, 0, + 0, 0, 4631, 1, 0, 0, 0, 0, 4633, 1, 0, 0, 0, 0, 4635, 1, 0, 0, 0, 0, 4637, + 1, 0, 0, 0, 0, 4639, 1, 0, 0, 0, 0, 4641, 1, 0, 0, 0, 0, 4643, 1, 0, 0, + 0, 0, 4645, 1, 0, 0, 0, 0, 4647, 1, 0, 0, 0, 0, 4649, 1, 0, 0, 0, 0, 4651, + 1, 0, 0, 0, 0, 4653, 1, 0, 0, 0, 0, 4655, 1, 0, 0, 0, 0, 4657, 1, 0, 0, + 0, 0, 4659, 1, 0, 0, 0, 0, 4661, 1, 0, 0, 0, 0, 4663, 1, 0, 0, 0, 0, 4665, + 1, 0, 0, 0, 0, 4667, 1, 0, 0, 0, 0, 4669, 1, 0, 0, 0, 0, 4671, 1, 0, 0, + 0, 0, 4673, 1, 0, 0, 0, 0, 4675, 1, 0, 0, 0, 0, 4677, 1, 0, 0, 0, 0, 4679, + 1, 0, 0, 0, 0, 4681, 1, 0, 0, 0, 0, 4683, 1, 0, 0, 0, 0, 4685, 1, 0, 0, + 0, 0, 4687, 1, 0, 0, 0, 0, 4689, 1, 0, 0, 0, 0, 4691, 1, 0, 0, 0, 0, 4693, + 1, 0, 0, 0, 0, 4695, 1, 0, 0, 0, 0, 4697, 1, 0, 0, 0, 0, 4699, 1, 0, 0, + 0, 0, 4701, 1, 0, 0, 0, 0, 4703, 1, 0, 0, 0, 0, 4705, 1, 0, 0, 0, 0, 4707, + 1, 0, 0, 0, 0, 4709, 1, 0, 0, 0, 0, 4711, 1, 0, 0, 0, 0, 4713, 1, 0, 0, + 0, 0, 4715, 1, 0, 0, 0, 0, 4717, 1, 0, 0, 0, 0, 4719, 1, 0, 0, 0, 0, 4721, + 1, 0, 0, 0, 0, 4723, 1, 0, 0, 0, 0, 4725, 1, 0, 0, 0, 0, 4727, 1, 0, 0, + 0, 0, 4729, 1, 0, 0, 0, 0, 4731, 1, 0, 0, 0, 0, 4733, 1, 0, 0, 0, 0, 4735, + 1, 0, 0, 0, 0, 4737, 1, 0, 0, 0, 0, 4739, 1, 0, 0, 0, 0, 4741, 1, 0, 0, + 0, 0, 4743, 1, 0, 0, 0, 0, 4745, 1, 0, 0, 0, 0, 4803, 1, 0, 0, 0, 0, 4805, + 1, 0, 0, 0, 0, 4807, 1, 0, 0, 0, 0, 4809, 1, 0, 0, 0, 0, 4811, 1, 0, 0, + 0, 0, 4813, 1, 0, 0, 0, 0, 4815, 1, 0, 0, 0, 0, 4817, 1, 0, 0, 0, 0, 4819, + 1, 0, 0, 0, 0, 4821, 1, 0, 0, 0, 0, 4823, 1, 0, 0, 0, 0, 4825, 1, 0, 0, + 0, 0, 4827, 1, 0, 0, 0, 0, 4829, 1, 0, 0, 0, 0, 4831, 1, 0, 0, 0, 0, 4833, + 1, 0, 0, 0, 0, 4835, 1, 0, 0, 0, 0, 4837, 1, 0, 0, 0, 0, 4839, 1, 0, 0, + 0, 0, 4841, 1, 0, 0, 0, 0, 4843, 1, 0, 0, 0, 0, 4845, 1, 0, 0, 0, 0, 4847, + 1, 0, 0, 0, 0, 4849, 1, 0, 0, 0, 0, 4851, 1, 0, 0, 0, 0, 4853, 1, 0, 0, + 0, 0, 4855, 1, 0, 0, 0, 0, 4857, 1, 0, 0, 0, 0, 4859, 1, 0, 0, 0, 0, 4861, + 1, 0, 0, 0, 0, 4863, 1, 0, 0, 0, 0, 4865, 1, 0, 0, 0, 0, 4867, 1, 0, 0, + 0, 0, 4869, 1, 0, 0, 0, 0, 4871, 1, 0, 0, 0, 0, 4873, 1, 0, 0, 0, 1, 4889, + 1, 0, 0, 0, 3, 4895, 1, 0, 0, 0, 5, 4899, 1, 0, 0, 0, 7, 4906, 1, 0, 0, + 0, 9, 4913, 1, 0, 0, 0, 11, 4922, 1, 0, 0, 0, 13, 4930, 1, 0, 0, 0, 15, + 4934, 1, 0, 0, 0, 17, 4939, 1, 0, 0, 0, 19, 4946, 1, 0, 0, 0, 21, 4953, + 1, 0, 0, 0, 23, 4961, 1, 0, 0, 0, 25, 4970, 1, 0, 0, 0, 27, 4977, 1, 0, + 0, 0, 29, 4994, 1, 0, 0, 0, 31, 5006, 1, 0, 0, 0, 33, 5022, 1, 0, 0, 0, + 35, 5033, 1, 0, 0, 0, 37, 5042, 1, 0, 0, 0, 39, 5056, 1, 0, 0, 0, 41, 5060, + 1, 0, 0, 0, 43, 5071, 1, 0, 0, 0, 45, 5081, 1, 0, 0, 0, 47, 5092, 1, 0, + 0, 0, 49, 5101, 1, 0, 0, 0, 51, 5107, 1, 0, 0, 0, 53, 5118, 1, 0, 0, 0, + 55, 5132, 1, 0, 0, 0, 57, 5141, 1, 0, 0, 0, 59, 5148, 1, 0, 0, 0, 61, 5156, + 1, 0, 0, 0, 63, 5171, 1, 0, 0, 0, 65, 5177, 1, 0, 0, 0, 67, 5183, 1, 0, + 0, 0, 69, 5193, 1, 0, 0, 0, 71, 5195, 1, 0, 0, 0, 73, 5201, 1, 0, 0, 0, + 75, 5205, 1, 0, 0, 0, 77, 5214, 1, 0, 0, 0, 79, 5220, 1, 0, 0, 0, 81, 5229, + 1, 0, 0, 0, 83, 5235, 1, 0, 0, 0, 85, 5245, 1, 0, 0, 0, 87, 5252, 1, 0, + 0, 0, 89, 5261, 1, 0, 0, 0, 91, 5269, 1, 0, 0, 0, 93, 5278, 1, 0, 0, 0, + 95, 5288, 1, 0, 0, 0, 97, 5292, 1, 0, 0, 0, 99, 5302, 1, 0, 0, 0, 101, + 5310, 1, 0, 0, 0, 103, 5322, 1, 0, 0, 0, 105, 5331, 1, 0, 0, 0, 107, 5335, + 1, 0, 0, 0, 109, 5345, 1, 0, 0, 0, 111, 5352, 1, 0, 0, 0, 113, 5367, 1, + 0, 0, 0, 115, 5381, 1, 0, 0, 0, 117, 5393, 1, 0, 0, 0, 119, 5399, 1, 0, + 0, 0, 121, 5421, 1, 0, 0, 0, 123, 5430, 1, 0, 0, 0, 125, 5438, 1, 0, 0, + 0, 127, 5447, 1, 0, 0, 0, 129, 5458, 1, 0, 0, 0, 131, 5464, 1, 0, 0, 0, + 133, 5467, 1, 0, 0, 0, 135, 5471, 1, 0, 0, 0, 137, 5477, 1, 0, 0, 0, 139, + 5486, 1, 0, 0, 0, 141, 5491, 1, 0, 0, 0, 143, 5496, 1, 0, 0, 0, 145, 5505, + 1, 0, 0, 0, 147, 5512, 1, 0, 0, 0, 149, 5522, 1, 0, 0, 0, 151, 5528, 1, + 0, 0, 0, 153, 5541, 1, 0, 0, 0, 155, 5547, 1, 0, 0, 0, 157, 5552, 1, 0, + 0, 0, 159, 5555, 1, 0, 0, 0, 161, 5565, 1, 0, 0, 0, 163, 5576, 1, 0, 0, + 0, 165, 5582, 1, 0, 0, 0, 167, 5596, 1, 0, 0, 0, 169, 5611, 1, 0, 0, 0, + 171, 5618, 1, 0, 0, 0, 173, 5632, 1, 0, 0, 0, 175, 5645, 1, 0, 0, 0, 177, + 5650, 1, 0, 0, 0, 179, 5661, 1, 0, 0, 0, 181, 5672, 1, 0, 0, 0, 183, 5682, + 1, 0, 0, 0, 185, 5705, 1, 0, 0, 0, 187, 5721, 1, 0, 0, 0, 189, 5734, 1, + 0, 0, 0, 191, 5739, 1, 0, 0, 0, 193, 5750, 1, 0, 0, 0, 195, 5762, 1, 0, + 0, 0, 197, 5769, 1, 0, 0, 0, 199, 5777, 1, 0, 0, 0, 201, 5783, 1, 0, 0, + 0, 203, 5793, 1, 0, 0, 0, 205, 5799, 1, 0, 0, 0, 207, 5809, 1, 0, 0, 0, + 209, 5837, 1, 0, 0, 0, 211, 5844, 1, 0, 0, 0, 213, 5851, 1, 0, 0, 0, 215, + 5857, 1, 0, 0, 0, 217, 5867, 1, 0, 0, 0, 219, 5886, 1, 0, 0, 0, 221, 5893, + 1, 0, 0, 0, 223, 5902, 1, 0, 0, 0, 225, 5910, 1, 0, 0, 0, 227, 5916, 1, + 0, 0, 0, 229, 5926, 1, 0, 0, 0, 231, 5934, 1, 0, 0, 0, 233, 5941, 1, 0, + 0, 0, 235, 5955, 1, 0, 0, 0, 237, 5978, 1, 0, 0, 0, 239, 5996, 1, 0, 0, + 0, 241, 6009, 1, 0, 0, 0, 243, 6031, 1, 0, 0, 0, 245, 6048, 1, 0, 0, 0, + 247, 6063, 1, 0, 0, 0, 249, 6074, 1, 0, 0, 0, 251, 6082, 1, 0, 0, 0, 253, + 6093, 1, 0, 0, 0, 255, 6100, 1, 0, 0, 0, 257, 6111, 1, 0, 0, 0, 259, 6118, + 1, 0, 0, 0, 261, 6126, 1, 0, 0, 0, 263, 6138, 1, 0, 0, 0, 265, 6143, 1, + 0, 0, 0, 267, 6148, 1, 0, 0, 0, 269, 6154, 1, 0, 0, 0, 271, 6166, 1, 0, + 0, 0, 273, 6173, 1, 0, 0, 0, 275, 6183, 1, 0, 0, 0, 277, 6188, 1, 0, 0, + 0, 279, 6196, 1, 0, 0, 0, 281, 6201, 1, 0, 0, 0, 283, 6207, 1, 0, 0, 0, + 285, 6214, 1, 0, 0, 0, 287, 6222, 1, 0, 0, 0, 289, 6232, 1, 0, 0, 0, 291, + 6237, 1, 0, 0, 0, 293, 6244, 1, 0, 0, 0, 295, 6257, 1, 0, 0, 0, 297, 6269, + 1, 0, 0, 0, 299, 6275, 1, 0, 0, 0, 301, 6280, 1, 0, 0, 0, 303, 6283, 1, + 0, 0, 0, 305, 6306, 1, 0, 0, 0, 307, 6318, 1, 0, 0, 0, 309, 6323, 1, 0, + 0, 0, 311, 6329, 1, 0, 0, 0, 313, 6338, 1, 0, 0, 0, 315, 6354, 1, 0, 0, + 0, 317, 6371, 1, 0, 0, 0, 319, 6379, 1, 0, 0, 0, 321, 6390, 1, 0, 0, 0, + 323, 6399, 1, 0, 0, 0, 325, 6404, 1, 0, 0, 0, 327, 6411, 1, 0, 0, 0, 329, + 6421, 1, 0, 0, 0, 331, 6430, 1, 0, 0, 0, 333, 6438, 1, 0, 0, 0, 335, 6450, + 1, 0, 0, 0, 337, 6458, 1, 0, 0, 0, 339, 6463, 1, 0, 0, 0, 341, 6468, 1, + 0, 0, 0, 343, 6483, 1, 0, 0, 0, 345, 6492, 1, 0, 0, 0, 347, 6504, 1, 0, + 0, 0, 349, 6509, 1, 0, 0, 0, 351, 6526, 1, 0, 0, 0, 353, 6538, 1, 0, 0, + 0, 355, 6544, 1, 0, 0, 0, 357, 6552, 1, 0, 0, 0, 359, 6559, 1, 0, 0, 0, + 361, 6585, 1, 0, 0, 0, 363, 6595, 1, 0, 0, 0, 365, 6600, 1, 0, 0, 0, 367, + 6608, 1, 0, 0, 0, 369, 6620, 1, 0, 0, 0, 371, 6638, 1, 0, 0, 0, 373, 6644, + 1, 0, 0, 0, 375, 6655, 1, 0, 0, 0, 377, 6661, 1, 0, 0, 0, 379, 6668, 1, + 0, 0, 0, 381, 6672, 1, 0, 0, 0, 383, 6678, 1, 0, 0, 0, 385, 6684, 1, 0, + 0, 0, 387, 6699, 1, 0, 0, 0, 389, 6710, 1, 0, 0, 0, 391, 6717, 1, 0, 0, + 0, 393, 6723, 1, 0, 0, 0, 395, 6731, 1, 0, 0, 0, 397, 6737, 1, 0, 0, 0, + 399, 6739, 1, 0, 0, 0, 401, 6746, 1, 0, 0, 0, 403, 6751, 1, 0, 0, 0, 405, + 6757, 1, 0, 0, 0, 407, 6783, 1, 0, 0, 0, 409, 6789, 1, 0, 0, 0, 411, 6806, + 1, 0, 0, 0, 413, 6814, 1, 0, 0, 0, 415, 6830, 1, 0, 0, 0, 417, 6847, 1, + 0, 0, 0, 419, 6858, 1, 0, 0, 0, 421, 6869, 1, 0, 0, 0, 423, 6887, 1, 0, + 0, 0, 425, 6907, 1, 0, 0, 0, 427, 6919, 1, 0, 0, 0, 429, 6928, 1, 0, 0, + 0, 431, 6940, 1, 0, 0, 0, 433, 6947, 1, 0, 0, 0, 435, 6959, 1, 0, 0, 0, + 437, 6964, 1, 0, 0, 0, 439, 6972, 1, 0, 0, 0, 441, 6981, 1, 0, 0, 0, 443, + 7003, 1, 0, 0, 0, 445, 7010, 1, 0, 0, 0, 447, 7018, 1, 0, 0, 0, 449, 7031, + 1, 0, 0, 0, 451, 7044, 1, 0, 0, 0, 453, 7052, 1, 0, 0, 0, 455, 7059, 1, + 0, 0, 0, 457, 7069, 1, 0, 0, 0, 459, 7076, 1, 0, 0, 0, 461, 7088, 1, 0, + 0, 0, 463, 7096, 1, 0, 0, 0, 465, 7110, 1, 0, 0, 0, 467, 7118, 1, 0, 0, + 0, 469, 7127, 1, 0, 0, 0, 471, 7138, 1, 0, 0, 0, 473, 7148, 1, 0, 0, 0, + 475, 7159, 1, 0, 0, 0, 477, 7167, 1, 0, 0, 0, 479, 7177, 1, 0, 0, 0, 481, + 7193, 1, 0, 0, 0, 483, 7202, 1, 0, 0, 0, 485, 7211, 1, 0, 0, 0, 487, 7219, + 1, 0, 0, 0, 489, 7226, 1, 0, 0, 0, 491, 7241, 1, 0, 0, 0, 493, 7253, 1, + 0, 0, 0, 495, 7263, 1, 0, 0, 0, 497, 7271, 1, 0, 0, 0, 499, 7282, 1, 0, + 0, 0, 501, 7297, 1, 0, 0, 0, 503, 7304, 1, 0, 0, 0, 505, 7319, 1, 0, 0, + 0, 507, 7342, 1, 0, 0, 0, 509, 7364, 1, 0, 0, 0, 511, 7386, 1, 0, 0, 0, + 513, 7407, 1, 0, 0, 0, 515, 7428, 1, 0, 0, 0, 517, 7447, 1, 0, 0, 0, 519, + 7465, 1, 0, 0, 0, 521, 7481, 1, 0, 0, 0, 523, 7489, 1, 0, 0, 0, 525, 7502, + 1, 0, 0, 0, 527, 7511, 1, 0, 0, 0, 529, 7522, 1, 0, 0, 0, 531, 7531, 1, + 0, 0, 0, 533, 7537, 1, 0, 0, 0, 535, 7548, 1, 0, 0, 0, 537, 7560, 1, 0, + 0, 0, 539, 7572, 1, 0, 0, 0, 541, 7582, 1, 0, 0, 0, 543, 7593, 1, 0, 0, + 0, 545, 7612, 1, 0, 0, 0, 547, 7627, 1, 0, 0, 0, 549, 7641, 1, 0, 0, 0, + 551, 7649, 1, 0, 0, 0, 553, 7658, 1, 0, 0, 0, 555, 7666, 1, 0, 0, 0, 557, + 7675, 1, 0, 0, 0, 559, 7687, 1, 0, 0, 0, 561, 7701, 1, 0, 0, 0, 563, 7709, + 1, 0, 0, 0, 565, 7720, 1, 0, 0, 0, 567, 7727, 1, 0, 0, 0, 569, 7732, 1, + 0, 0, 0, 571, 7739, 1, 0, 0, 0, 573, 7746, 1, 0, 0, 0, 575, 7757, 1, 0, + 0, 0, 577, 7773, 1, 0, 0, 0, 579, 7785, 1, 0, 0, 0, 581, 7789, 1, 0, 0, + 0, 583, 7794, 1, 0, 0, 0, 585, 7799, 1, 0, 0, 0, 587, 7822, 1, 0, 0, 0, + 589, 7828, 1, 0, 0, 0, 591, 7838, 1, 0, 0, 0, 593, 7849, 1, 0, 0, 0, 595, + 7861, 1, 0, 0, 0, 597, 7874, 1, 0, 0, 0, 599, 7890, 1, 0, 0, 0, 601, 7896, + 1, 0, 0, 0, 603, 7903, 1, 0, 0, 0, 605, 7920, 1, 0, 0, 0, 607, 7943, 1, + 0, 0, 0, 609, 7952, 1, 0, 0, 0, 611, 7963, 1, 0, 0, 0, 613, 7972, 1, 0, + 0, 0, 615, 7978, 1, 0, 0, 0, 617, 7991, 1, 0, 0, 0, 619, 8001, 1, 0, 0, + 0, 621, 8009, 1, 0, 0, 0, 623, 8014, 1, 0, 0, 0, 625, 8022, 1, 0, 0, 0, + 627, 8030, 1, 0, 0, 0, 629, 8041, 1, 0, 0, 0, 631, 8049, 1, 0, 0, 0, 633, + 8062, 1, 0, 0, 0, 635, 8077, 1, 0, 0, 0, 637, 8090, 1, 0, 0, 0, 639, 8108, + 1, 0, 0, 0, 641, 8121, 1, 0, 0, 0, 643, 8130, 1, 0, 0, 0, 645, 8137, 1, + 0, 0, 0, 647, 8158, 1, 0, 0, 0, 649, 8182, 1, 0, 0, 0, 651, 8194, 1, 0, + 0, 0, 653, 8197, 1, 0, 0, 0, 655, 8203, 1, 0, 0, 0, 657, 8212, 1, 0, 0, + 0, 659, 8221, 1, 0, 0, 0, 661, 8226, 1, 0, 0, 0, 663, 8235, 1, 0, 0, 0, + 665, 8245, 1, 0, 0, 0, 667, 8258, 1, 0, 0, 0, 669, 8268, 1, 0, 0, 0, 671, + 8293, 1, 0, 0, 0, 673, 8314, 1, 0, 0, 0, 675, 8323, 1, 0, 0, 0, 677, 8351, + 1, 0, 0, 0, 679, 8356, 1, 0, 0, 0, 681, 8366, 1, 0, 0, 0, 683, 8370, 1, + 0, 0, 0, 685, 8375, 1, 0, 0, 0, 687, 8379, 1, 0, 0, 0, 689, 8394, 1, 0, + 0, 0, 691, 8405, 1, 0, 0, 0, 693, 8420, 1, 0, 0, 0, 695, 8431, 1, 0, 0, + 0, 697, 8446, 1, 0, 0, 0, 699, 8457, 1, 0, 0, 0, 701, 8461, 1, 0, 0, 0, + 703, 8472, 1, 0, 0, 0, 705, 8478, 1, 0, 0, 0, 707, 8487, 1, 0, 0, 0, 709, + 8491, 1, 0, 0, 0, 711, 8499, 1, 0, 0, 0, 713, 8507, 1, 0, 0, 0, 715, 8517, + 1, 0, 0, 0, 717, 8529, 1, 0, 0, 0, 719, 8534, 1, 0, 0, 0, 721, 8544, 1, + 0, 0, 0, 723, 8552, 1, 0, 0, 0, 725, 8564, 1, 0, 0, 0, 727, 8572, 1, 0, + 0, 0, 729, 8581, 1, 0, 0, 0, 731, 8599, 1, 0, 0, 0, 733, 8618, 1, 0, 0, + 0, 735, 8629, 1, 0, 0, 0, 737, 8638, 1, 0, 0, 0, 739, 8646, 1, 0, 0, 0, + 741, 8653, 1, 0, 0, 0, 743, 8661, 1, 0, 0, 0, 745, 8668, 1, 0, 0, 0, 747, + 8674, 1, 0, 0, 0, 749, 8683, 1, 0, 0, 0, 751, 8694, 1, 0, 0, 0, 753, 8701, + 1, 0, 0, 0, 755, 8711, 1, 0, 0, 0, 757, 8718, 1, 0, 0, 0, 759, 8730, 1, + 0, 0, 0, 761, 8740, 1, 0, 0, 0, 763, 8746, 1, 0, 0, 0, 765, 8754, 1, 0, + 0, 0, 767, 8760, 1, 0, 0, 0, 769, 8777, 1, 0, 0, 0, 771, 8782, 1, 0, 0, + 0, 773, 8794, 1, 0, 0, 0, 775, 8802, 1, 0, 0, 0, 777, 8811, 1, 0, 0, 0, + 779, 8822, 1, 0, 0, 0, 781, 8836, 1, 0, 0, 0, 783, 8847, 1, 0, 0, 0, 785, + 8857, 1, 0, 0, 0, 787, 8868, 1, 0, 0, 0, 789, 8880, 1, 0, 0, 0, 791, 8890, + 1, 0, 0, 0, 793, 8902, 1, 0, 0, 0, 795, 8914, 1, 0, 0, 0, 797, 8922, 1, + 0, 0, 0, 799, 8943, 1, 0, 0, 0, 801, 8958, 1, 0, 0, 0, 803, 8971, 1, 0, + 0, 0, 805, 8980, 1, 0, 0, 0, 807, 8993, 1, 0, 0, 0, 809, 9001, 1, 0, 0, + 0, 811, 9012, 1, 0, 0, 0, 813, 9017, 1, 0, 0, 0, 815, 9027, 1, 0, 0, 0, + 817, 9033, 1, 0, 0, 0, 819, 9042, 1, 0, 0, 0, 821, 9051, 1, 0, 0, 0, 823, + 9065, 1, 0, 0, 0, 825, 9077, 1, 0, 0, 0, 827, 9088, 1, 0, 0, 0, 829, 9092, + 1, 0, 0, 0, 831, 9103, 1, 0, 0, 0, 833, 9115, 1, 0, 0, 0, 835, 9124, 1, + 0, 0, 0, 837, 9144, 1, 0, 0, 0, 839, 9165, 1, 0, 0, 0, 841, 9183, 1, 0, + 0, 0, 843, 9190, 1, 0, 0, 0, 845, 9200, 1, 0, 0, 0, 847, 9213, 1, 0, 0, + 0, 849, 9225, 1, 0, 0, 0, 851, 9230, 1, 0, 0, 0, 853, 9241, 1, 0, 0, 0, + 855, 9266, 1, 0, 0, 0, 857, 9290, 1, 0, 0, 0, 859, 9295, 1, 0, 0, 0, 861, + 9305, 1, 0, 0, 0, 863, 9308, 1, 0, 0, 0, 865, 9316, 1, 0, 0, 0, 867, 9333, + 1, 0, 0, 0, 869, 9358, 1, 0, 0, 0, 871, 9360, 1, 0, 0, 0, 873, 9365, 1, + 0, 0, 0, 875, 9377, 1, 0, 0, 0, 877, 9385, 1, 0, 0, 0, 879, 9396, 1, 0, + 0, 0, 881, 9405, 1, 0, 0, 0, 883, 9413, 1, 0, 0, 0, 885, 9426, 1, 0, 0, + 0, 887, 9441, 1, 0, 0, 0, 889, 9455, 1, 0, 0, 0, 891, 9476, 1, 0, 0, 0, + 893, 9481, 1, 0, 0, 0, 895, 9487, 1, 0, 0, 0, 897, 9490, 1, 0, 0, 0, 899, + 9501, 1, 0, 0, 0, 901, 9512, 1, 0, 0, 0, 903, 9518, 1, 0, 0, 0, 905, 9529, + 1, 0, 0, 0, 907, 9536, 1, 0, 0, 0, 909, 9556, 1, 0, 0, 0, 911, 9570, 1, + 0, 0, 0, 913, 9579, 1, 0, 0, 0, 915, 9587, 1, 0, 0, 0, 917, 9598, 1, 0, + 0, 0, 919, 9602, 1, 0, 0, 0, 921, 9619, 1, 0, 0, 0, 923, 9628, 1, 0, 0, + 0, 925, 9636, 1, 0, 0, 0, 927, 9644, 1, 0, 0, 0, 929, 9655, 1, 0, 0, 0, + 931, 9670, 1, 0, 0, 0, 933, 9676, 1, 0, 0, 0, 935, 9685, 1, 0, 0, 0, 937, + 9689, 1, 0, 0, 0, 939, 9704, 1, 0, 0, 0, 941, 9710, 1, 0, 0, 0, 943, 9732, + 1, 0, 0, 0, 945, 9739, 1, 0, 0, 0, 947, 9746, 1, 0, 0, 0, 949, 9755, 1, + 0, 0, 0, 951, 9760, 1, 0, 0, 0, 953, 9769, 1, 0, 0, 0, 955, 9778, 1, 0, + 0, 0, 957, 9789, 1, 0, 0, 0, 959, 9796, 1, 0, 0, 0, 961, 9802, 1, 0, 0, + 0, 963, 9809, 1, 0, 0, 0, 965, 9819, 1, 0, 0, 0, 967, 9834, 1, 0, 0, 0, + 969, 9845, 1, 0, 0, 0, 971, 9854, 1, 0, 0, 0, 973, 9862, 1, 0, 0, 0, 975, + 9872, 1, 0, 0, 0, 977, 9882, 1, 0, 0, 0, 979, 9890, 1, 0, 0, 0, 981, 9897, + 1, 0, 0, 0, 983, 9906, 1, 0, 0, 0, 985, 9913, 1, 0, 0, 0, 987, 9924, 1, + 0, 0, 0, 989, 9929, 1, 0, 0, 0, 991, 9950, 1, 0, 0, 0, 993, 9963, 1, 0, + 0, 0, 995, 9967, 1, 0, 0, 0, 997, 9974, 1, 0, 0, 0, 999, 9982, 1, 0, 0, + 0, 1001, 9992, 1, 0, 0, 0, 1003, 9999, 1, 0, 0, 0, 1005, 10015, 1, 0, 0, + 0, 1007, 10023, 1, 0, 0, 0, 1009, 10031, 1, 0, 0, 0, 1011, 10038, 1, 0, + 0, 0, 1013, 10046, 1, 0, 0, 0, 1015, 10055, 1, 0, 0, 0, 1017, 10066, 1, + 0, 0, 0, 1019, 10081, 1, 0, 0, 0, 1021, 10089, 1, 0, 0, 0, 1023, 10102, + 1, 0, 0, 0, 1025, 10108, 1, 0, 0, 0, 1027, 10117, 1, 0, 0, 0, 1029, 10122, + 1, 0, 0, 0, 1031, 10129, 1, 0, 0, 0, 1033, 10144, 1, 0, 0, 0, 1035, 10151, + 1, 0, 0, 0, 1037, 10173, 1, 0, 0, 0, 1039, 10183, 1, 0, 0, 0, 1041, 10192, + 1, 0, 0, 0, 1043, 10200, 1, 0, 0, 0, 1045, 10206, 1, 0, 0, 0, 1047, 10213, + 1, 0, 0, 0, 1049, 10217, 1, 0, 0, 0, 1051, 10222, 1, 0, 0, 0, 1053, 10232, + 1, 0, 0, 0, 1055, 10240, 1, 0, 0, 0, 1057, 10248, 1, 0, 0, 0, 1059, 10264, + 1, 0, 0, 0, 1061, 10275, 1, 0, 0, 0, 1063, 10287, 1, 0, 0, 0, 1065, 10301, + 1, 0, 0, 0, 1067, 10307, 1, 0, 0, 0, 1069, 10312, 1, 0, 0, 0, 1071, 10330, + 1, 0, 0, 0, 1073, 10340, 1, 0, 0, 0, 1075, 10350, 1, 0, 0, 0, 1077, 10374, + 1, 0, 0, 0, 1079, 10381, 1, 0, 0, 0, 1081, 10387, 1, 0, 0, 0, 1083, 10392, + 1, 0, 0, 0, 1085, 10399, 1, 0, 0, 0, 1087, 10405, 1, 0, 0, 0, 1089, 10412, + 1, 0, 0, 0, 1091, 10423, 1, 0, 0, 0, 1093, 10435, 1, 0, 0, 0, 1095, 10451, + 1, 0, 0, 0, 1097, 10459, 1, 0, 0, 0, 1099, 10469, 1, 0, 0, 0, 1101, 10481, + 1, 0, 0, 0, 1103, 10487, 1, 0, 0, 0, 1105, 10492, 1, 0, 0, 0, 1107, 10497, + 1, 0, 0, 0, 1109, 10503, 1, 0, 0, 0, 1111, 10509, 1, 0, 0, 0, 1113, 10516, + 1, 0, 0, 0, 1115, 10526, 1, 0, 0, 0, 1117, 10534, 1, 0, 0, 0, 1119, 10541, + 1, 0, 0, 0, 1121, 10547, 1, 0, 0, 0, 1123, 10571, 1, 0, 0, 0, 1125, 10579, + 1, 0, 0, 0, 1127, 10587, 1, 0, 0, 0, 1129, 10591, 1, 0, 0, 0, 1131, 10598, + 1, 0, 0, 0, 1133, 10606, 1, 0, 0, 0, 1135, 10622, 1, 0, 0, 0, 1137, 10631, + 1, 0, 0, 0, 1139, 10641, 1, 0, 0, 0, 1141, 10651, 1, 0, 0, 0, 1143, 10657, + 1, 0, 0, 0, 1145, 10662, 1, 0, 0, 0, 1147, 10670, 1, 0, 0, 0, 1149, 10675, + 1, 0, 0, 0, 1151, 10700, 1, 0, 0, 0, 1153, 10709, 1, 0, 0, 0, 1155, 10719, + 1, 0, 0, 0, 1157, 10723, 1, 0, 0, 0, 1159, 10725, 1, 0, 0, 0, 1161, 10753, + 1, 0, 0, 0, 1163, 10776, 1, 0, 0, 0, 1165, 10792, 1, 0, 0, 0, 1167, 10805, + 1, 0, 0, 0, 1169, 10815, 1, 0, 0, 0, 1171, 10819, 1, 0, 0, 0, 1173, 10826, + 1, 0, 0, 0, 1175, 10835, 1, 0, 0, 0, 1177, 10847, 1, 0, 0, 0, 1179, 10868, + 1, 0, 0, 0, 1181, 10873, 1, 0, 0, 0, 1183, 10879, 1, 0, 0, 0, 1185, 10888, + 1, 0, 0, 0, 1187, 10894, 1, 0, 0, 0, 1189, 10903, 1, 0, 0, 0, 1191, 10912, + 1, 0, 0, 0, 1193, 10924, 1, 0, 0, 0, 1195, 10931, 1, 0, 0, 0, 1197, 10942, + 1, 0, 0, 0, 1199, 10952, 1, 0, 0, 0, 1201, 10958, 1, 0, 0, 0, 1203, 10969, + 1, 0, 0, 0, 1205, 10977, 1, 0, 0, 0, 1207, 10982, 1, 0, 0, 0, 1209, 10991, + 1, 0, 0, 0, 1211, 10999, 1, 0, 0, 0, 1213, 11006, 1, 0, 0, 0, 1215, 11013, + 1, 0, 0, 0, 1217, 11018, 1, 0, 0, 0, 1219, 11023, 1, 0, 0, 0, 1221, 11032, + 1, 0, 0, 0, 1223, 11041, 1, 0, 0, 0, 1225, 11048, 1, 0, 0, 0, 1227, 11053, + 1, 0, 0, 0, 1229, 11064, 1, 0, 0, 0, 1231, 11077, 1, 0, 0, 0, 1233, 11089, + 1, 0, 0, 0, 1235, 11099, 1, 0, 0, 0, 1237, 11104, 1, 0, 0, 0, 1239, 11118, + 1, 0, 0, 0, 1241, 11130, 1, 0, 0, 0, 1243, 11134, 1, 0, 0, 0, 1245, 11139, + 1, 0, 0, 0, 1247, 11145, 1, 0, 0, 0, 1249, 11150, 1, 0, 0, 0, 1251, 11163, + 1, 0, 0, 0, 1253, 11170, 1, 0, 0, 0, 1255, 11172, 1, 0, 0, 0, 1257, 11183, + 1, 0, 0, 0, 1259, 11194, 1, 0, 0, 0, 1261, 11203, 1, 0, 0, 0, 1263, 11216, + 1, 0, 0, 0, 1265, 11219, 1, 0, 0, 0, 1267, 11229, 1, 0, 0, 0, 1269, 11232, + 1, 0, 0, 0, 1271, 11239, 1, 0, 0, 0, 1273, 11267, 1, 0, 0, 0, 1275, 11294, + 1, 0, 0, 0, 1277, 11314, 1, 0, 0, 0, 1279, 11318, 1, 0, 0, 0, 1281, 11328, + 1, 0, 0, 0, 1283, 11335, 1, 0, 0, 0, 1285, 11342, 1, 0, 0, 0, 1287, 11351, + 1, 0, 0, 0, 1289, 11373, 1, 0, 0, 0, 1291, 11381, 1, 0, 0, 0, 1293, 11397, + 1, 0, 0, 0, 1295, 11407, 1, 0, 0, 0, 1297, 11419, 1, 0, 0, 0, 1299, 11429, + 1, 0, 0, 0, 1301, 11434, 1, 0, 0, 0, 1303, 11441, 1, 0, 0, 0, 1305, 11451, + 1, 0, 0, 0, 1307, 11465, 1, 0, 0, 0, 1309, 11476, 1, 0, 0, 0, 1311, 11484, + 1, 0, 0, 0, 1313, 11492, 1, 0, 0, 0, 1315, 11502, 1, 0, 0, 0, 1317, 11515, + 1, 0, 0, 0, 1319, 11521, 1, 0, 0, 0, 1321, 11530, 1, 0, 0, 0, 1323, 11541, + 1, 0, 0, 0, 1325, 11552, 1, 0, 0, 0, 1327, 11562, 1, 0, 0, 0, 1329, 11575, + 1, 0, 0, 0, 1331, 11589, 1, 0, 0, 0, 1333, 11598, 1, 0, 0, 0, 1335, 11609, + 1, 0, 0, 0, 1337, 11625, 1, 0, 0, 0, 1339, 11638, 1, 0, 0, 0, 1341, 11652, + 1, 0, 0, 0, 1343, 11661, 1, 0, 0, 0, 1345, 11673, 1, 0, 0, 0, 1347, 11683, + 1, 0, 0, 0, 1349, 11694, 1, 0, 0, 0, 1351, 11704, 1, 0, 0, 0, 1353, 11712, + 1, 0, 0, 0, 1355, 11721, 1, 0, 0, 0, 1357, 11735, 1, 0, 0, 0, 1359, 11743, + 1, 0, 0, 0, 1361, 11746, 1, 0, 0, 0, 1363, 11754, 1, 0, 0, 0, 1365, 11762, + 1, 0, 0, 0, 1367, 11774, 1, 0, 0, 0, 1369, 11784, 1, 0, 0, 0, 1371, 11793, + 1, 0, 0, 0, 1373, 11800, 1, 0, 0, 0, 1375, 11818, 1, 0, 0, 0, 1377, 11827, + 1, 0, 0, 0, 1379, 11846, 1, 0, 0, 0, 1381, 11863, 1, 0, 0, 0, 1383, 11869, + 1, 0, 0, 0, 1385, 11875, 1, 0, 0, 0, 1387, 11883, 1, 0, 0, 0, 1389, 11903, + 1, 0, 0, 0, 1391, 11924, 1, 0, 0, 0, 1393, 11939, 1, 0, 0, 0, 1395, 11946, + 1, 0, 0, 0, 1397, 11961, 1, 0, 0, 0, 1399, 11977, 1, 0, 0, 0, 1401, 11986, + 1, 0, 0, 0, 1403, 11996, 1, 0, 0, 0, 1405, 12009, 1, 0, 0, 0, 1407, 12019, + 1, 0, 0, 0, 1409, 12027, 1, 0, 0, 0, 1411, 12034, 1, 0, 0, 0, 1413, 12041, + 1, 0, 0, 0, 1415, 12048, 1, 0, 0, 0, 1417, 12055, 1, 0, 0, 0, 1419, 12061, + 1, 0, 0, 0, 1421, 12069, 1, 0, 0, 0, 1423, 12081, 1, 0, 0, 0, 1425, 12094, + 1, 0, 0, 0, 1427, 12111, 1, 0, 0, 0, 1429, 12124, 1, 0, 0, 0, 1431, 12136, + 1, 0, 0, 0, 1433, 12146, 1, 0, 0, 0, 1435, 12155, 1, 0, 0, 0, 1437, 12159, + 1, 0, 0, 0, 1439, 12164, 1, 0, 0, 0, 1441, 12175, 1, 0, 0, 0, 1443, 12185, + 1, 0, 0, 0, 1445, 12195, 1, 0, 0, 0, 1447, 12198, 1, 0, 0, 0, 1449, 12206, + 1, 0, 0, 0, 1451, 12216, 1, 0, 0, 0, 1453, 12232, 1, 0, 0, 0, 1455, 12240, + 1, 0, 0, 0, 1457, 12257, 1, 0, 0, 0, 1459, 12262, 1, 0, 0, 0, 1461, 12266, + 1, 0, 0, 0, 1463, 12271, 1, 0, 0, 0, 1465, 12285, 1, 0, 0, 0, 1467, 12296, + 1, 0, 0, 0, 1469, 12307, 1, 0, 0, 0, 1471, 12320, 1, 0, 0, 0, 1473, 12332, + 1, 0, 0, 0, 1475, 12340, 1, 0, 0, 0, 1477, 12345, 1, 0, 0, 0, 1479, 12360, + 1, 0, 0, 0, 1481, 12372, 1, 0, 0, 0, 1483, 12382, 1, 0, 0, 0, 1485, 12393, + 1, 0, 0, 0, 1487, 12408, 1, 0, 0, 0, 1489, 12419, 1, 0, 0, 0, 1491, 12438, + 1, 0, 0, 0, 1493, 12456, 1, 0, 0, 0, 1495, 12471, 1, 0, 0, 0, 1497, 12482, + 1, 0, 0, 0, 1499, 12484, 1, 0, 0, 0, 1501, 12500, 1, 0, 0, 0, 1503, 12505, + 1, 0, 0, 0, 1505, 12514, 1, 0, 0, 0, 1507, 12518, 1, 0, 0, 0, 1509, 12529, + 1, 0, 0, 0, 1511, 12537, 1, 0, 0, 0, 1513, 12542, 1, 0, 0, 0, 1515, 12551, + 1, 0, 0, 0, 1517, 12556, 1, 0, 0, 0, 1519, 12562, 1, 0, 0, 0, 1521, 12571, + 1, 0, 0, 0, 1523, 12580, 1, 0, 0, 0, 1525, 12585, 1, 0, 0, 0, 1527, 12596, + 1, 0, 0, 0, 1529, 12604, 1, 0, 0, 0, 1531, 12608, 1, 0, 0, 0, 1533, 12614, + 1, 0, 0, 0, 1535, 12640, 1, 0, 0, 0, 1537, 12658, 1, 0, 0, 0, 1539, 12681, + 1, 0, 0, 0, 1541, 12686, 1, 0, 0, 0, 1543, 12695, 1, 0, 0, 0, 1545, 12708, + 1, 0, 0, 0, 1547, 12716, 1, 0, 0, 0, 1549, 12721, 1, 0, 0, 0, 1551, 12729, + 1, 0, 0, 0, 1553, 12737, 1, 0, 0, 0, 1555, 12745, 1, 0, 0, 0, 1557, 12753, + 1, 0, 0, 0, 1559, 12760, 1, 0, 0, 0, 1561, 12765, 1, 0, 0, 0, 1563, 12771, + 1, 0, 0, 0, 1565, 12782, 1, 0, 0, 0, 1567, 12789, 1, 0, 0, 0, 1569, 12797, + 1, 0, 0, 0, 1571, 12807, 1, 0, 0, 0, 1573, 12812, 1, 0, 0, 0, 1575, 12821, + 1, 0, 0, 0, 1577, 12827, 1, 0, 0, 0, 1579, 12833, 1, 0, 0, 0, 1581, 12839, + 1, 0, 0, 0, 1583, 12851, 1, 0, 0, 0, 1585, 12856, 1, 0, 0, 0, 1587, 12862, + 1, 0, 0, 0, 1589, 12869, 1, 0, 0, 0, 1591, 12874, 1, 0, 0, 0, 1593, 12879, + 1, 0, 0, 0, 1595, 12882, 1, 0, 0, 0, 1597, 12888, 1, 0, 0, 0, 1599, 12893, + 1, 0, 0, 0, 1601, 12897, 1, 0, 0, 0, 1603, 12904, 1, 0, 0, 0, 1605, 12909, + 1, 0, 0, 0, 1607, 12923, 1, 0, 0, 0, 1609, 12929, 1, 0, 0, 0, 1611, 12939, + 1, 0, 0, 0, 1613, 12954, 1, 0, 0, 0, 1615, 12963, 1, 0, 0, 0, 1617, 12971, + 1, 0, 0, 0, 1619, 12980, 1, 0, 0, 0, 1621, 12987, 1, 0, 0, 0, 1623, 12995, + 1, 0, 0, 0, 1625, 13000, 1, 0, 0, 0, 1627, 13008, 1, 0, 0, 0, 1629, 13017, + 1, 0, 0, 0, 1631, 13025, 1, 0, 0, 0, 1633, 13033, 1, 0, 0, 0, 1635, 13056, + 1, 0, 0, 0, 1637, 13082, 1, 0, 0, 0, 1639, 13086, 1, 0, 0, 0, 1641, 13096, + 1, 0, 0, 0, 1643, 13103, 1, 0, 0, 0, 1645, 13109, 1, 0, 0, 0, 1647, 13134, + 1, 0, 0, 0, 1649, 13139, 1, 0, 0, 0, 1651, 13144, 1, 0, 0, 0, 1653, 13149, + 1, 0, 0, 0, 1655, 13155, 1, 0, 0, 0, 1657, 13159, 1, 0, 0, 0, 1659, 13164, + 1, 0, 0, 0, 1661, 13170, 1, 0, 0, 0, 1663, 13172, 1, 0, 0, 0, 1665, 13177, + 1, 0, 0, 0, 1667, 13186, 1, 0, 0, 0, 1669, 13194, 1, 0, 0, 0, 1671, 13201, + 1, 0, 0, 0, 1673, 13212, 1, 0, 0, 0, 1675, 13220, 1, 0, 0, 0, 1677, 13230, + 1, 0, 0, 0, 1679, 13237, 1, 0, 0, 0, 1681, 13241, 1, 0, 0, 0, 1683, 13249, + 1, 0, 0, 0, 1685, 13256, 1, 0, 0, 0, 1687, 13264, 1, 0, 0, 0, 1689, 13272, + 1, 0, 0, 0, 1691, 13278, 1, 0, 0, 0, 1693, 13291, 1, 0, 0, 0, 1695, 13307, + 1, 0, 0, 0, 1697, 13320, 1, 0, 0, 0, 1699, 13332, 1, 0, 0, 0, 1701, 13344, + 1, 0, 0, 0, 1703, 13357, 1, 0, 0, 0, 1705, 13368, 1, 0, 0, 0, 1707, 13377, + 1, 0, 0, 0, 1709, 13390, 1, 0, 0, 0, 1711, 13402, 1, 0, 0, 0, 1713, 13416, + 1, 0, 0, 0, 1715, 13430, 1, 0, 0, 0, 1717, 13451, 1, 0, 0, 0, 1719, 13459, + 1, 0, 0, 0, 1721, 13468, 1, 0, 0, 0, 1723, 13477, 1, 0, 0, 0, 1725, 13485, + 1, 0, 0, 0, 1727, 13494, 1, 0, 0, 0, 1729, 13501, 1, 0, 0, 0, 1731, 13508, + 1, 0, 0, 0, 1733, 13523, 1, 0, 0, 0, 1735, 13542, 1, 0, 0, 0, 1737, 13554, + 1, 0, 0, 0, 1739, 13573, 1, 0, 0, 0, 1741, 13585, 1, 0, 0, 0, 1743, 13592, + 1, 0, 0, 0, 1745, 13606, 1, 0, 0, 0, 1747, 13615, 1, 0, 0, 0, 1749, 13630, + 1, 0, 0, 0, 1751, 13636, 1, 0, 0, 0, 1753, 13645, 1, 0, 0, 0, 1755, 13654, + 1, 0, 0, 0, 1757, 13661, 1, 0, 0, 0, 1759, 13669, 1, 0, 0, 0, 1761, 13679, + 1, 0, 0, 0, 1763, 13690, 1, 0, 0, 0, 1765, 13699, 1, 0, 0, 0, 1767, 13707, + 1, 0, 0, 0, 1769, 13714, 1, 0, 0, 0, 1771, 13720, 1, 0, 0, 0, 1773, 13731, + 1, 0, 0, 0, 1775, 13738, 1, 0, 0, 0, 1777, 13746, 1, 0, 0, 0, 1779, 13755, + 1, 0, 0, 0, 1781, 13766, 1, 0, 0, 0, 1783, 13776, 1, 0, 0, 0, 1785, 13783, + 1, 0, 0, 0, 1787, 13791, 1, 0, 0, 0, 1789, 13800, 1, 0, 0, 0, 1791, 13809, + 1, 0, 0, 0, 1793, 13832, 1, 0, 0, 0, 1795, 13860, 1, 0, 0, 0, 1797, 13883, + 1, 0, 0, 0, 1799, 13902, 1, 0, 0, 0, 1801, 13908, 1, 0, 0, 0, 1803, 13917, + 1, 0, 0, 0, 1805, 13935, 1, 0, 0, 0, 1807, 13945, 1, 0, 0, 0, 1809, 13960, + 1, 0, 0, 0, 1811, 13969, 1, 0, 0, 0, 1813, 13974, 1, 0, 0, 0, 1815, 13987, + 1, 0, 0, 0, 1817, 14006, 1, 0, 0, 0, 1819, 14013, 1, 0, 0, 0, 1821, 14017, + 1, 0, 0, 0, 1823, 14024, 1, 0, 0, 0, 1825, 14035, 1, 0, 0, 0, 1827, 14043, + 1, 0, 0, 0, 1829, 14049, 1, 0, 0, 0, 1831, 14064, 1, 0, 0, 0, 1833, 14071, + 1, 0, 0, 0, 1835, 14077, 1, 0, 0, 0, 1837, 14087, 1, 0, 0, 0, 1839, 14098, + 1, 0, 0, 0, 1841, 14107, 1, 0, 0, 0, 1843, 14112, 1, 0, 0, 0, 1845, 14129, + 1, 0, 0, 0, 1847, 14138, 1, 0, 0, 0, 1849, 14147, 1, 0, 0, 0, 1851, 14153, + 1, 0, 0, 0, 1853, 14158, 1, 0, 0, 0, 1855, 14168, 1, 0, 0, 0, 1857, 14172, + 1, 0, 0, 0, 1859, 14178, 1, 0, 0, 0, 1861, 14187, 1, 0, 0, 0, 1863, 14210, + 1, 0, 0, 0, 1865, 14217, 1, 0, 0, 0, 1867, 14225, 1, 0, 0, 0, 1869, 14234, + 1, 0, 0, 0, 1871, 14238, 1, 0, 0, 0, 1873, 14247, 1, 0, 0, 0, 1875, 14253, + 1, 0, 0, 0, 1877, 14258, 1, 0, 0, 0, 1879, 14264, 1, 0, 0, 0, 1881, 14271, + 1, 0, 0, 0, 1883, 14275, 1, 0, 0, 0, 1885, 14282, 1, 0, 0, 0, 1887, 14307, + 1, 0, 0, 0, 1889, 14329, 1, 0, 0, 0, 1891, 14345, 1, 0, 0, 0, 1893, 14367, + 1, 0, 0, 0, 1895, 14390, 1, 0, 0, 0, 1897, 14398, 1, 0, 0, 0, 1899, 14404, + 1, 0, 0, 0, 1901, 14408, 1, 0, 0, 0, 1903, 14417, 1, 0, 0, 0, 1905, 14426, + 1, 0, 0, 0, 1907, 14431, 1, 0, 0, 0, 1909, 14437, 1, 0, 0, 0, 1911, 14450, + 1, 0, 0, 0, 1913, 14467, 1, 0, 0, 0, 1915, 14482, 1, 0, 0, 0, 1917, 14495, + 1, 0, 0, 0, 1919, 14508, 1, 0, 0, 0, 1921, 14525, 1, 0, 0, 0, 1923, 14546, + 1, 0, 0, 0, 1925, 14561, 1, 0, 0, 0, 1927, 14578, 1, 0, 0, 0, 1929, 14587, + 1, 0, 0, 0, 1931, 14600, 1, 0, 0, 0, 1933, 14616, 1, 0, 0, 0, 1935, 14634, + 1, 0, 0, 0, 1937, 14646, 1, 0, 0, 0, 1939, 14663, 1, 0, 0, 0, 1941, 14669, + 1, 0, 0, 0, 1943, 14678, 1, 0, 0, 0, 1945, 14691, 1, 0, 0, 0, 1947, 14712, + 1, 0, 0, 0, 1949, 14722, 1, 0, 0, 0, 1951, 14742, 1, 0, 0, 0, 1953, 14765, + 1, 0, 0, 0, 1955, 14774, 1, 0, 0, 0, 1957, 14782, 1, 0, 0, 0, 1959, 14800, + 1, 0, 0, 0, 1961, 14814, 1, 0, 0, 0, 1963, 14824, 1, 0, 0, 0, 1965, 14834, + 1, 0, 0, 0, 1967, 14851, 1, 0, 0, 0, 1969, 14866, 1, 0, 0, 0, 1971, 14875, + 1, 0, 0, 0, 1973, 14888, 1, 0, 0, 0, 1975, 14896, 1, 0, 0, 0, 1977, 14915, + 1, 0, 0, 0, 1979, 14944, 1, 0, 0, 0, 1981, 14975, 1, 0, 0, 0, 1983, 14989, + 1, 0, 0, 0, 1985, 14999, 1, 0, 0, 0, 1987, 15007, 1, 0, 0, 0, 1989, 15020, + 1, 0, 0, 0, 1991, 15041, 1, 0, 0, 0, 1993, 15061, 1, 0, 0, 0, 1995, 15075, + 1, 0, 0, 0, 1997, 15090, 1, 0, 0, 0, 1999, 15105, 1, 0, 0, 0, 2001, 15116, + 1, 0, 0, 0, 2003, 15142, 1, 0, 0, 0, 2005, 15167, 1, 0, 0, 0, 2007, 15192, + 1, 0, 0, 0, 2009, 15216, 1, 0, 0, 0, 2011, 15240, 1, 0, 0, 0, 2013, 15247, + 1, 0, 0, 0, 2015, 15273, 1, 0, 0, 0, 2017, 15288, 1, 0, 0, 0, 2019, 15302, + 1, 0, 0, 0, 2021, 15310, 1, 0, 0, 0, 2023, 15335, 1, 0, 0, 0, 2025, 15350, + 1, 0, 0, 0, 2027, 15358, 1, 0, 0, 0, 2029, 15381, 1, 0, 0, 0, 2031, 15408, + 1, 0, 0, 0, 2033, 15424, 1, 0, 0, 0, 2035, 15442, 1, 0, 0, 0, 2037, 15459, + 1, 0, 0, 0, 2039, 15483, 1, 0, 0, 0, 2041, 15500, 1, 0, 0, 0, 2043, 15524, + 1, 0, 0, 0, 2045, 15534, 1, 0, 0, 0, 2047, 15550, 1, 0, 0, 0, 2049, 15558, + 1, 0, 0, 0, 2051, 15576, 1, 0, 0, 0, 2053, 15589, 1, 0, 0, 0, 2055, 15597, + 1, 0, 0, 0, 2057, 15625, 1, 0, 0, 0, 2059, 15656, 1, 0, 0, 0, 2061, 15672, + 1, 0, 0, 0, 2063, 15684, 1, 0, 0, 0, 2065, 15697, 1, 0, 0, 0, 2067, 15706, + 1, 0, 0, 0, 2069, 15718, 1, 0, 0, 0, 2071, 15730, 1, 0, 0, 0, 2073, 15750, + 1, 0, 0, 0, 2075, 15757, 1, 0, 0, 0, 2077, 15765, 1, 0, 0, 0, 2079, 15773, + 1, 0, 0, 0, 2081, 15783, 1, 0, 0, 0, 2083, 15793, 1, 0, 0, 0, 2085, 15804, + 1, 0, 0, 0, 2087, 15813, 1, 0, 0, 0, 2089, 15824, 1, 0, 0, 0, 2091, 15835, + 1, 0, 0, 0, 2093, 15853, 1, 0, 0, 0, 2095, 15867, 1, 0, 0, 0, 2097, 15880, + 1, 0, 0, 0, 2099, 15891, 1, 0, 0, 0, 2101, 15910, 1, 0, 0, 0, 2103, 15936, + 1, 0, 0, 0, 2105, 15948, 1, 0, 0, 0, 2107, 15963, 1, 0, 0, 0, 2109, 15968, + 1, 0, 0, 0, 2111, 15984, 1, 0, 0, 0, 2113, 16000, 1, 0, 0, 0, 2115, 16003, + 1, 0, 0, 0, 2117, 16013, 1, 0, 0, 0, 2119, 16028, 1, 0, 0, 0, 2121, 16036, + 1, 0, 0, 0, 2123, 16053, 1, 0, 0, 0, 2125, 16075, 1, 0, 0, 0, 2127, 16098, + 1, 0, 0, 0, 2129, 16109, 1, 0, 0, 0, 2131, 16127, 1, 0, 0, 0, 2133, 16144, + 1, 0, 0, 0, 2135, 16156, 1, 0, 0, 0, 2137, 16167, 1, 0, 0, 0, 2139, 16185, + 1, 0, 0, 0, 2141, 16201, 1, 0, 0, 0, 2143, 16228, 1, 0, 0, 0, 2145, 16240, + 1, 0, 0, 0, 2147, 16258, 1, 0, 0, 0, 2149, 16276, 1, 0, 0, 0, 2151, 16299, + 1, 0, 0, 0, 2153, 16309, 1, 0, 0, 0, 2155, 16318, 1, 0, 0, 0, 2157, 16334, + 1, 0, 0, 0, 2159, 16345, 1, 0, 0, 0, 2161, 16360, 1, 0, 0, 0, 2163, 16373, + 1, 0, 0, 0, 2165, 16386, 1, 0, 0, 0, 2167, 16399, 1, 0, 0, 0, 2169, 16421, + 1, 0, 0, 0, 2171, 16439, 1, 0, 0, 0, 2173, 16451, 1, 0, 0, 0, 2175, 16475, + 1, 0, 0, 0, 2177, 16490, 1, 0, 0, 0, 2179, 16501, 1, 0, 0, 0, 2181, 16508, + 1, 0, 0, 0, 2183, 16517, 1, 0, 0, 0, 2185, 16526, 1, 0, 0, 0, 2187, 16538, + 1, 0, 0, 0, 2189, 16554, 1, 0, 0, 0, 2191, 16564, 1, 0, 0, 0, 2193, 16575, + 1, 0, 0, 0, 2195, 16585, 1, 0, 0, 0, 2197, 16592, 1, 0, 0, 0, 2199, 16613, + 1, 0, 0, 0, 2201, 16631, 1, 0, 0, 0, 2203, 16645, 1, 0, 0, 0, 2205, 16655, + 1, 0, 0, 0, 2207, 16667, 1, 0, 0, 0, 2209, 16684, 1, 0, 0, 0, 2211, 16699, + 1, 0, 0, 0, 2213, 16706, 1, 0, 0, 0, 2215, 16725, 1, 0, 0, 0, 2217, 16737, + 1, 0, 0, 0, 2219, 16760, 1, 0, 0, 0, 2221, 16781, 1, 0, 0, 0, 2223, 16796, + 1, 0, 0, 0, 2225, 16805, 1, 0, 0, 0, 2227, 16825, 1, 0, 0, 0, 2229, 16840, + 1, 0, 0, 0, 2231, 16860, 1, 0, 0, 0, 2233, 16869, 1, 0, 0, 0, 2235, 16891, + 1, 0, 0, 0, 2237, 16905, 1, 0, 0, 0, 2239, 16913, 1, 0, 0, 0, 2241, 16926, + 1, 0, 0, 0, 2243, 16930, 1, 0, 0, 0, 2245, 16956, 1, 0, 0, 0, 2247, 16966, + 1, 0, 0, 0, 2249, 16978, 1, 0, 0, 0, 2251, 17002, 1, 0, 0, 0, 2253, 17031, + 1, 0, 0, 0, 2255, 17043, 1, 0, 0, 0, 2257, 17068, 1, 0, 0, 0, 2259, 17081, + 1, 0, 0, 0, 2261, 17091, 1, 0, 0, 0, 2263, 17117, 1, 0, 0, 0, 2265, 17128, + 1, 0, 0, 0, 2267, 17153, 1, 0, 0, 0, 2269, 17178, 1, 0, 0, 0, 2271, 17198, + 1, 0, 0, 0, 2273, 17205, 1, 0, 0, 0, 2275, 17228, 1, 0, 0, 0, 2277, 17247, + 1, 0, 0, 0, 2279, 17277, 1, 0, 0, 0, 2281, 17297, 1, 0, 0, 0, 2283, 17318, + 1, 0, 0, 0, 2285, 17329, 1, 0, 0, 0, 2287, 17339, 1, 0, 0, 0, 2289, 17346, + 1, 0, 0, 0, 2291, 17351, 1, 0, 0, 0, 2293, 17357, 1, 0, 0, 0, 2295, 17364, + 1, 0, 0, 0, 2297, 17372, 1, 0, 0, 0, 2299, 17387, 1, 0, 0, 0, 2301, 17403, + 1, 0, 0, 0, 2303, 17419, 1, 0, 0, 0, 2305, 17429, 1, 0, 0, 0, 2307, 17434, + 1, 0, 0, 0, 2309, 17445, 1, 0, 0, 0, 2311, 17452, 1, 0, 0, 0, 2313, 17459, + 1, 0, 0, 0, 2315, 17465, 1, 0, 0, 0, 2317, 17477, 1, 0, 0, 0, 2319, 17488, + 1, 0, 0, 0, 2321, 17496, 1, 0, 0, 0, 2323, 17500, 1, 0, 0, 0, 2325, 17507, + 1, 0, 0, 0, 2327, 17510, 1, 0, 0, 0, 2329, 17519, 1, 0, 0, 0, 2331, 17523, + 1, 0, 0, 0, 2333, 17528, 1, 0, 0, 0, 2335, 17532, 1, 0, 0, 0, 2337, 17546, + 1, 0, 0, 0, 2339, 17550, 1, 0, 0, 0, 2341, 17555, 1, 0, 0, 0, 2343, 17560, + 1, 0, 0, 0, 2345, 17564, 1, 0, 0, 0, 2347, 17571, 1, 0, 0, 0, 2349, 17576, + 1, 0, 0, 0, 2351, 17579, 1, 0, 0, 0, 2353, 17586, 1, 0, 0, 0, 2355, 17603, + 1, 0, 0, 0, 2357, 17621, 1, 0, 0, 0, 2359, 17628, 1, 0, 0, 0, 2361, 17633, + 1, 0, 0, 0, 2363, 17644, 1, 0, 0, 0, 2365, 17653, 1, 0, 0, 0, 2367, 17666, + 1, 0, 0, 0, 2369, 17674, 1, 0, 0, 0, 2371, 17683, 1, 0, 0, 0, 2373, 17709, + 1, 0, 0, 0, 2375, 17724, 1, 0, 0, 0, 2377, 17731, 1, 0, 0, 0, 2379, 17741, + 1, 0, 0, 0, 2381, 17752, 1, 0, 0, 0, 2383, 17766, 1, 0, 0, 0, 2385, 17786, + 1, 0, 0, 0, 2387, 17801, 1, 0, 0, 0, 2389, 17809, 1, 0, 0, 0, 2391, 17818, + 1, 0, 0, 0, 2393, 17835, 1, 0, 0, 0, 2395, 17851, 1, 0, 0, 0, 2397, 17865, + 1, 0, 0, 0, 2399, 17880, 1, 0, 0, 0, 2401, 17899, 1, 0, 0, 0, 2403, 17908, + 1, 0, 0, 0, 2405, 17928, 1, 0, 0, 0, 2407, 17946, 1, 0, 0, 0, 2409, 17972, + 1, 0, 0, 0, 2411, 17993, 1, 0, 0, 0, 2413, 18008, 1, 0, 0, 0, 2415, 18022, + 1, 0, 0, 0, 2417, 18033, 1, 0, 0, 0, 2419, 18048, 1, 0, 0, 0, 2421, 18063, + 1, 0, 0, 0, 2423, 18078, 1, 0, 0, 0, 2425, 18093, 1, 0, 0, 0, 2427, 18101, + 1, 0, 0, 0, 2429, 18120, 1, 0, 0, 0, 2431, 18126, 1, 0, 0, 0, 2433, 18137, + 1, 0, 0, 0, 2435, 18147, 1, 0, 0, 0, 2437, 18160, 1, 0, 0, 0, 2439, 18163, + 1, 0, 0, 0, 2441, 18177, 1, 0, 0, 0, 2443, 18185, 1, 0, 0, 0, 2445, 18191, + 1, 0, 0, 0, 2447, 18210, 1, 0, 0, 0, 2449, 18230, 1, 0, 0, 0, 2451, 18236, + 1, 0, 0, 0, 2453, 18249, 1, 0, 0, 0, 2455, 18257, 1, 0, 0, 0, 2457, 18269, + 1, 0, 0, 0, 2459, 18273, 1, 0, 0, 0, 2461, 18289, 1, 0, 0, 0, 2463, 18298, + 1, 0, 0, 0, 2465, 18307, 1, 0, 0, 0, 2467, 18312, 1, 0, 0, 0, 2469, 18323, + 1, 0, 0, 0, 2471, 18329, 1, 0, 0, 0, 2473, 18339, 1, 0, 0, 0, 2475, 18343, + 1, 0, 0, 0, 2477, 18345, 1, 0, 0, 0, 2479, 18353, 1, 0, 0, 0, 2481, 18362, + 1, 0, 0, 0, 2483, 18378, 1, 0, 0, 0, 2485, 18393, 1, 0, 0, 0, 2487, 18402, + 1, 0, 0, 0, 2489, 18413, 1, 0, 0, 0, 2491, 18419, 1, 0, 0, 0, 2493, 18426, + 1, 0, 0, 0, 2495, 18444, 1, 0, 0, 0, 2497, 18463, 1, 0, 0, 0, 2499, 18470, + 1, 0, 0, 0, 2501, 18483, 1, 0, 0, 0, 2503, 18493, 1, 0, 0, 0, 2505, 18501, + 1, 0, 0, 0, 2507, 18525, 1, 0, 0, 0, 2509, 18540, 1, 0, 0, 0, 2511, 18555, + 1, 0, 0, 0, 2513, 18565, 1, 0, 0, 0, 2515, 18581, 1, 0, 0, 0, 2517, 18592, + 1, 0, 0, 0, 2519, 18606, 1, 0, 0, 0, 2521, 18614, 1, 0, 0, 0, 2523, 18634, + 1, 0, 0, 0, 2525, 18653, 1, 0, 0, 0, 2527, 18672, 1, 0, 0, 0, 2529, 18681, + 1, 0, 0, 0, 2531, 18700, 1, 0, 0, 0, 2533, 18720, 1, 0, 0, 0, 2535, 18743, + 1, 0, 0, 0, 2537, 18768, 1, 0, 0, 0, 2539, 18773, 1, 0, 0, 0, 2541, 18779, + 1, 0, 0, 0, 2543, 18784, 1, 0, 0, 0, 2545, 18796, 1, 0, 0, 0, 2547, 18802, + 1, 0, 0, 0, 2549, 18810, 1, 0, 0, 0, 2551, 18823, 1, 0, 0, 0, 2553, 18834, + 1, 0, 0, 0, 2555, 18842, 1, 0, 0, 0, 2557, 18854, 1, 0, 0, 0, 2559, 18867, + 1, 0, 0, 0, 2561, 18875, 1, 0, 0, 0, 2563, 18886, 1, 0, 0, 0, 2565, 18894, + 1, 0, 0, 0, 2567, 18907, 1, 0, 0, 0, 2569, 18921, 1, 0, 0, 0, 2571, 18937, + 1, 0, 0, 0, 2573, 18945, 1, 0, 0, 0, 2575, 18959, 1, 0, 0, 0, 2577, 18975, + 1, 0, 0, 0, 2579, 18990, 1, 0, 0, 0, 2581, 19002, 1, 0, 0, 0, 2583, 19014, + 1, 0, 0, 0, 2585, 19021, 1, 0, 0, 0, 2587, 19031, 1, 0, 0, 0, 2589, 19042, + 1, 0, 0, 0, 2591, 19050, 1, 0, 0, 0, 2593, 19054, 1, 0, 0, 0, 2595, 19060, + 1, 0, 0, 0, 2597, 19069, 1, 0, 0, 0, 2599, 19075, 1, 0, 0, 0, 2601, 19085, + 1, 0, 0, 0, 2603, 19090, 1, 0, 0, 0, 2605, 19097, 1, 0, 0, 0, 2607, 19103, + 1, 0, 0, 0, 2609, 19111, 1, 0, 0, 0, 2611, 19126, 1, 0, 0, 0, 2613, 19141, + 1, 0, 0, 0, 2615, 19146, 1, 0, 0, 0, 2617, 19163, 1, 0, 0, 0, 2619, 19175, + 1, 0, 0, 0, 2621, 19189, 1, 0, 0, 0, 2623, 19205, 1, 0, 0, 0, 2625, 19217, + 1, 0, 0, 0, 2627, 19238, 1, 0, 0, 0, 2629, 19253, 1, 0, 0, 0, 2631, 19263, + 1, 0, 0, 0, 2633, 19268, 1, 0, 0, 0, 2635, 19274, 1, 0, 0, 0, 2637, 19281, + 1, 0, 0, 0, 2639, 19290, 1, 0, 0, 0, 2641, 19298, 1, 0, 0, 0, 2643, 19307, + 1, 0, 0, 0, 2645, 19315, 1, 0, 0, 0, 2647, 19323, 1, 0, 0, 0, 2649, 19333, + 1, 0, 0, 0, 2651, 19342, 1, 0, 0, 0, 2653, 19359, 1, 0, 0, 0, 2655, 19388, + 1, 0, 0, 0, 2657, 19402, 1, 0, 0, 0, 2659, 19408, 1, 0, 0, 0, 2661, 19428, + 1, 0, 0, 0, 2663, 19442, 1, 0, 0, 0, 2665, 19463, 1, 0, 0, 0, 2667, 19473, + 1, 0, 0, 0, 2669, 19480, 1, 0, 0, 0, 2671, 19489, 1, 0, 0, 0, 2673, 19502, + 1, 0, 0, 0, 2675, 19510, 1, 0, 0, 0, 2677, 19517, 1, 0, 0, 0, 2679, 19526, + 1, 0, 0, 0, 2681, 19535, 1, 0, 0, 0, 2683, 19545, 1, 0, 0, 0, 2685, 19555, + 1, 0, 0, 0, 2687, 19575, 1, 0, 0, 0, 2689, 19594, 1, 0, 0, 0, 2691, 19602, + 1, 0, 0, 0, 2693, 19610, 1, 0, 0, 0, 2695, 19621, 1, 0, 0, 0, 2697, 19629, + 1, 0, 0, 0, 2699, 19638, 1, 0, 0, 0, 2701, 19651, 1, 0, 0, 0, 2703, 19660, + 1, 0, 0, 0, 2705, 19667, 1, 0, 0, 0, 2707, 19676, 1, 0, 0, 0, 2709, 19681, + 1, 0, 0, 0, 2711, 19689, 1, 0, 0, 0, 2713, 19705, 1, 0, 0, 0, 2715, 19714, + 1, 0, 0, 0, 2717, 19720, 1, 0, 0, 0, 2719, 19728, 1, 0, 0, 0, 2721, 19740, + 1, 0, 0, 0, 2723, 19751, 1, 0, 0, 0, 2725, 19761, 1, 0, 0, 0, 2727, 19772, + 1, 0, 0, 0, 2729, 19783, 1, 0, 0, 0, 2731, 19793, 1, 0, 0, 0, 2733, 19801, + 1, 0, 0, 0, 2735, 19809, 1, 0, 0, 0, 2737, 19817, 1, 0, 0, 0, 2739, 19825, + 1, 0, 0, 0, 2741, 19835, 1, 0, 0, 0, 2743, 19844, 1, 0, 0, 0, 2745, 19854, + 1, 0, 0, 0, 2747, 19865, 1, 0, 0, 0, 2749, 19874, 1, 0, 0, 0, 2751, 19880, + 1, 0, 0, 0, 2753, 19888, 1, 0, 0, 0, 2755, 19895, 1, 0, 0, 0, 2757, 19905, + 1, 0, 0, 0, 2759, 19911, 1, 0, 0, 0, 2761, 19921, 1, 0, 0, 0, 2763, 19931, + 1, 0, 0, 0, 2765, 19950, 1, 0, 0, 0, 2767, 19961, 1, 0, 0, 0, 2769, 19976, + 1, 0, 0, 0, 2771, 19984, 1, 0, 0, 0, 2773, 19993, 1, 0, 0, 0, 2775, 20005, + 1, 0, 0, 0, 2777, 20011, 1, 0, 0, 0, 2779, 20022, 1, 0, 0, 0, 2781, 20028, + 1, 0, 0, 0, 2783, 20039, 1, 0, 0, 0, 2785, 20047, 1, 0, 0, 0, 2787, 20054, + 1, 0, 0, 0, 2789, 20060, 1, 0, 0, 0, 2791, 20071, 1, 0, 0, 0, 2793, 20077, + 1, 0, 0, 0, 2795, 20090, 1, 0, 0, 0, 2797, 20097, 1, 0, 0, 0, 2799, 20103, + 1, 0, 0, 0, 2801, 20109, 1, 0, 0, 0, 2803, 20117, 1, 0, 0, 0, 2805, 20121, + 1, 0, 0, 0, 2807, 20130, 1, 0, 0, 0, 2809, 20140, 1, 0, 0, 0, 2811, 20144, + 1, 0, 0, 0, 2813, 20156, 1, 0, 0, 0, 2815, 20161, 1, 0, 0, 0, 2817, 20166, + 1, 0, 0, 0, 2819, 20172, 1, 0, 0, 0, 2821, 20178, 1, 0, 0, 0, 2823, 20183, + 1, 0, 0, 0, 2825, 20193, 1, 0, 0, 0, 2827, 20201, 1, 0, 0, 0, 2829, 20208, + 1, 0, 0, 0, 2831, 20226, 1, 0, 0, 0, 2833, 20238, 1, 0, 0, 0, 2835, 20246, + 1, 0, 0, 0, 2837, 20255, 1, 0, 0, 0, 2839, 20266, 1, 0, 0, 0, 2841, 20274, + 1, 0, 0, 0, 2843, 20284, 1, 0, 0, 0, 2845, 20293, 1, 0, 0, 0, 2847, 20298, + 1, 0, 0, 0, 2849, 20306, 1, 0, 0, 0, 2851, 20317, 1, 0, 0, 0, 2853, 20336, + 1, 0, 0, 0, 2855, 20347, 1, 0, 0, 0, 2857, 20357, 1, 0, 0, 0, 2859, 20368, + 1, 0, 0, 0, 2861, 20380, 1, 0, 0, 0, 2863, 20384, 1, 0, 0, 0, 2865, 20392, + 1, 0, 0, 0, 2867, 20401, 1, 0, 0, 0, 2869, 20414, 1, 0, 0, 0, 2871, 20427, + 1, 0, 0, 0, 2873, 20439, 1, 0, 0, 0, 2875, 20454, 1, 0, 0, 0, 2877, 20468, + 1, 0, 0, 0, 2879, 20477, 1, 0, 0, 0, 2881, 20487, 1, 0, 0, 0, 2883, 20497, + 1, 0, 0, 0, 2885, 20508, 1, 0, 0, 0, 2887, 20523, 1, 0, 0, 0, 2889, 20531, + 1, 0, 0, 0, 2891, 20542, 1, 0, 0, 0, 2893, 20551, 1, 0, 0, 0, 2895, 20560, + 1, 0, 0, 0, 2897, 20569, 1, 0, 0, 0, 2899, 20577, 1, 0, 0, 0, 2901, 20584, + 1, 0, 0, 0, 2903, 20590, 1, 0, 0, 0, 2905, 20601, 1, 0, 0, 0, 2907, 20611, + 1, 0, 0, 0, 2909, 20620, 1, 0, 0, 0, 2911, 20625, 1, 0, 0, 0, 2913, 20635, + 1, 0, 0, 0, 2915, 20642, 1, 0, 0, 0, 2917, 20656, 1, 0, 0, 0, 2919, 20663, + 1, 0, 0, 0, 2921, 20670, 1, 0, 0, 0, 2923, 20677, 1, 0, 0, 0, 2925, 20684, + 1, 0, 0, 0, 2927, 20692, 1, 0, 0, 0, 2929, 20704, 1, 0, 0, 0, 2931, 20713, + 1, 0, 0, 0, 2933, 20723, 1, 0, 0, 0, 2935, 20729, 1, 0, 0, 0, 2937, 20736, + 1, 0, 0, 0, 2939, 20744, 1, 0, 0, 0, 2941, 20753, 1, 0, 0, 0, 2943, 20762, + 1, 0, 0, 0, 2945, 20770, 1, 0, 0, 0, 2947, 20778, 1, 0, 0, 0, 2949, 20799, + 1, 0, 0, 0, 2951, 20807, 1, 0, 0, 0, 2953, 20829, 1, 0, 0, 0, 2955, 20840, + 1, 0, 0, 0, 2957, 20860, 1, 0, 0, 0, 2959, 20869, 1, 0, 0, 0, 2961, 20882, + 1, 0, 0, 0, 2963, 20889, 1, 0, 0, 0, 2965, 20899, 1, 0, 0, 0, 2967, 20906, + 1, 0, 0, 0, 2969, 20916, 1, 0, 0, 0, 2971, 20936, 1, 0, 0, 0, 2973, 20946, + 1, 0, 0, 0, 2975, 20953, 1, 0, 0, 0, 2977, 20959, 1, 0, 0, 0, 2979, 20967, + 1, 0, 0, 0, 2981, 20974, 1, 0, 0, 0, 2983, 20991, 1, 0, 0, 0, 2985, 20999, + 1, 0, 0, 0, 2987, 21005, 1, 0, 0, 0, 2989, 21010, 1, 0, 0, 0, 2991, 21018, + 1, 0, 0, 0, 2993, 21024, 1, 0, 0, 0, 2995, 21033, 1, 0, 0, 0, 2997, 21041, + 1, 0, 0, 0, 2999, 21048, 1, 0, 0, 0, 3001, 21064, 1, 0, 0, 0, 3003, 21084, + 1, 0, 0, 0, 3005, 21090, 1, 0, 0, 0, 3007, 21102, 1, 0, 0, 0, 3009, 21115, + 1, 0, 0, 0, 3011, 21126, 1, 0, 0, 0, 3013, 21133, 1, 0, 0, 0, 3015, 21137, + 1, 0, 0, 0, 3017, 21142, 1, 0, 0, 0, 3019, 21147, 1, 0, 0, 0, 3021, 21153, + 1, 0, 0, 0, 3023, 21158, 1, 0, 0, 0, 3025, 21164, 1, 0, 0, 0, 3027, 21172, + 1, 0, 0, 0, 3029, 21177, 1, 0, 0, 0, 3031, 21184, 1, 0, 0, 0, 3033, 21202, + 1, 0, 0, 0, 3035, 21212, 1, 0, 0, 0, 3037, 21217, 1, 0, 0, 0, 3039, 21221, + 1, 0, 0, 0, 3041, 21232, 1, 0, 0, 0, 3043, 21238, 1, 0, 0, 0, 3045, 21253, + 1, 0, 0, 0, 3047, 21258, 1, 0, 0, 0, 3049, 21268, 1, 0, 0, 0, 3051, 21280, + 1, 0, 0, 0, 3053, 21287, 1, 0, 0, 0, 3055, 21301, 1, 0, 0, 0, 3057, 21305, + 1, 0, 0, 0, 3059, 21311, 1, 0, 0, 0, 3061, 21317, 1, 0, 0, 0, 3063, 21324, + 1, 0, 0, 0, 3065, 21335, 1, 0, 0, 0, 3067, 21348, 1, 0, 0, 0, 3069, 21361, + 1, 0, 0, 0, 3071, 21369, 1, 0, 0, 0, 3073, 21376, 1, 0, 0, 0, 3075, 21383, + 1, 0, 0, 0, 3077, 21391, 1, 0, 0, 0, 3079, 21398, 1, 0, 0, 0, 3081, 21413, + 1, 0, 0, 0, 3083, 21424, 1, 0, 0, 0, 3085, 21433, 1, 0, 0, 0, 3087, 21438, + 1, 0, 0, 0, 3089, 21448, 1, 0, 0, 0, 3091, 21457, 1, 0, 0, 0, 3093, 21465, + 1, 0, 0, 0, 3095, 21477, 1, 0, 0, 0, 3097, 21484, 1, 0, 0, 0, 3099, 21489, + 1, 0, 0, 0, 3101, 21505, 1, 0, 0, 0, 3103, 21514, 1, 0, 0, 0, 3105, 21528, + 1, 0, 0, 0, 3107, 21538, 1, 0, 0, 0, 3109, 21547, 1, 0, 0, 0, 3111, 21558, + 1, 0, 0, 0, 3113, 21571, 1, 0, 0, 0, 3115, 21589, 1, 0, 0, 0, 3117, 21596, + 1, 0, 0, 0, 3119, 21608, 1, 0, 0, 0, 3121, 21629, 1, 0, 0, 0, 3123, 21637, + 1, 0, 0, 0, 3125, 21646, 1, 0, 0, 0, 3127, 21669, 1, 0, 0, 0, 3129, 21677, + 1, 0, 0, 0, 3131, 21695, 1, 0, 0, 0, 3133, 21711, 1, 0, 0, 0, 3135, 21725, + 1, 0, 0, 0, 3137, 21729, 1, 0, 0, 0, 3139, 21734, 1, 0, 0, 0, 3141, 21743, + 1, 0, 0, 0, 3143, 21755, 1, 0, 0, 0, 3145, 21762, 1, 0, 0, 0, 3147, 21773, + 1, 0, 0, 0, 3149, 21785, 1, 0, 0, 0, 3151, 21792, 1, 0, 0, 0, 3153, 21798, + 1, 0, 0, 0, 3155, 21806, 1, 0, 0, 0, 3157, 21816, 1, 0, 0, 0, 3159, 21821, + 1, 0, 0, 0, 3161, 21828, 1, 0, 0, 0, 3163, 21837, 1, 0, 0, 0, 3165, 21846, + 1, 0, 0, 0, 3167, 21850, 1, 0, 0, 0, 3169, 21855, 1, 0, 0, 0, 3171, 21872, + 1, 0, 0, 0, 3173, 21888, 1, 0, 0, 0, 3175, 21893, 1, 0, 0, 0, 3177, 21902, + 1, 0, 0, 0, 3179, 21917, 1, 0, 0, 0, 3181, 21924, 1, 0, 0, 0, 3183, 21931, + 1, 0, 0, 0, 3185, 21942, 1, 0, 0, 0, 3187, 21947, 1, 0, 0, 0, 3189, 21951, + 1, 0, 0, 0, 3191, 21956, 1, 0, 0, 0, 3193, 21975, 1, 0, 0, 0, 3195, 21980, + 1, 0, 0, 0, 3197, 22002, 1, 0, 0, 0, 3199, 22024, 1, 0, 0, 0, 3201, 22034, + 1, 0, 0, 0, 3203, 22043, 1, 0, 0, 0, 3205, 22052, 1, 0, 0, 0, 3207, 22057, + 1, 0, 0, 0, 3209, 22062, 1, 0, 0, 0, 3211, 22070, 1, 0, 0, 0, 3213, 22092, + 1, 0, 0, 0, 3215, 22117, 1, 0, 0, 0, 3217, 22124, 1, 0, 0, 0, 3219, 22130, + 1, 0, 0, 0, 3221, 22144, 1, 0, 0, 0, 3223, 22151, 1, 0, 0, 0, 3225, 22157, + 1, 0, 0, 0, 3227, 22169, 1, 0, 0, 0, 3229, 22177, 1, 0, 0, 0, 3231, 22186, + 1, 0, 0, 0, 3233, 22193, 1, 0, 0, 0, 3235, 22197, 1, 0, 0, 0, 3237, 22207, + 1, 0, 0, 0, 3239, 22217, 1, 0, 0, 0, 3241, 22241, 1, 0, 0, 0, 3243, 22246, + 1, 0, 0, 0, 3245, 22252, 1, 0, 0, 0, 3247, 22263, 1, 0, 0, 0, 3249, 22272, + 1, 0, 0, 0, 3251, 22286, 1, 0, 0, 0, 3253, 22309, 1, 0, 0, 0, 3255, 22318, + 1, 0, 0, 0, 3257, 22326, 1, 0, 0, 0, 3259, 22331, 1, 0, 0, 0, 3261, 22351, + 1, 0, 0, 0, 3263, 22357, 1, 0, 0, 0, 3265, 22365, 1, 0, 0, 0, 3267, 22378, + 1, 0, 0, 0, 3269, 22396, 1, 0, 0, 0, 3271, 22407, 1, 0, 0, 0, 3273, 22417, + 1, 0, 0, 0, 3275, 22423, 1, 0, 0, 0, 3277, 22430, 1, 0, 0, 0, 3279, 22441, + 1, 0, 0, 0, 3281, 22461, 1, 0, 0, 0, 3283, 22476, 1, 0, 0, 0, 3285, 22489, + 1, 0, 0, 0, 3287, 22503, 1, 0, 0, 0, 3289, 22514, 1, 0, 0, 0, 3291, 22528, + 1, 0, 0, 0, 3293, 22548, 1, 0, 0, 0, 3295, 22567, 1, 0, 0, 0, 3297, 22587, + 1, 0, 0, 0, 3299, 22604, 1, 0, 0, 0, 3301, 22624, 1, 0, 0, 0, 3303, 22639, + 1, 0, 0, 0, 3305, 22650, 1, 0, 0, 0, 3307, 22662, 1, 0, 0, 0, 3309, 22667, + 1, 0, 0, 0, 3311, 22675, 1, 0, 0, 0, 3313, 22681, 1, 0, 0, 0, 3315, 22689, + 1, 0, 0, 0, 3317, 22696, 1, 0, 0, 0, 3319, 22703, 1, 0, 0, 0, 3321, 22710, + 1, 0, 0, 0, 3323, 22725, 1, 0, 0, 0, 3325, 22738, 1, 0, 0, 0, 3327, 22744, + 1, 0, 0, 0, 3329, 22754, 1, 0, 0, 0, 3331, 22766, 1, 0, 0, 0, 3333, 22783, + 1, 0, 0, 0, 3335, 22797, 1, 0, 0, 0, 3337, 22810, 1, 0, 0, 0, 3339, 22821, + 1, 0, 0, 0, 3341, 22838, 1, 0, 0, 0, 3343, 22848, 1, 0, 0, 0, 3345, 22855, + 1, 0, 0, 0, 3347, 22869, 1, 0, 0, 0, 3349, 22877, 1, 0, 0, 0, 3351, 22885, + 1, 0, 0, 0, 3353, 22893, 1, 0, 0, 0, 3355, 22901, 1, 0, 0, 0, 3357, 22909, + 1, 0, 0, 0, 3359, 22920, 1, 0, 0, 0, 3361, 22928, 1, 0, 0, 0, 3363, 22936, + 1, 0, 0, 0, 3365, 22949, 1, 0, 0, 0, 3367, 22957, 1, 0, 0, 0, 3369, 22974, + 1, 0, 0, 0, 3371, 22985, 1, 0, 0, 0, 3373, 22992, 1, 0, 0, 0, 3375, 23004, + 1, 0, 0, 0, 3377, 23009, 1, 0, 0, 0, 3379, 23017, 1, 0, 0, 0, 3381, 23021, + 1, 0, 0, 0, 3383, 23028, 1, 0, 0, 0, 3385, 23038, 1, 0, 0, 0, 3387, 23045, + 1, 0, 0, 0, 3389, 23055, 1, 0, 0, 0, 3391, 23068, 1, 0, 0, 0, 3393, 23088, + 1, 0, 0, 0, 3395, 23108, 1, 0, 0, 0, 3397, 23120, 1, 0, 0, 0, 3399, 23128, + 1, 0, 0, 0, 3401, 23135, 1, 0, 0, 0, 3403, 23148, 1, 0, 0, 0, 3405, 23154, + 1, 0, 0, 0, 3407, 23168, 1, 0, 0, 0, 3409, 23186, 1, 0, 0, 0, 3411, 23204, + 1, 0, 0, 0, 3413, 23220, 1, 0, 0, 0, 3415, 23237, 1, 0, 0, 0, 3417, 23254, + 1, 0, 0, 0, 3419, 23274, 1, 0, 0, 0, 3421, 23295, 1, 0, 0, 0, 3423, 23316, + 1, 0, 0, 0, 3425, 23336, 1, 0, 0, 0, 3427, 23349, 1, 0, 0, 0, 3429, 23365, + 1, 0, 0, 0, 3431, 23380, 1, 0, 0, 0, 3433, 23396, 1, 0, 0, 0, 3435, 23410, + 1, 0, 0, 0, 3437, 23424, 1, 0, 0, 0, 3439, 23439, 1, 0, 0, 0, 3441, 23458, + 1, 0, 0, 0, 3443, 23477, 1, 0, 0, 0, 3445, 23492, 1, 0, 0, 0, 3447, 23506, + 1, 0, 0, 0, 3449, 23515, 1, 0, 0, 0, 3451, 23523, 1, 0, 0, 0, 3453, 23529, + 1, 0, 0, 0, 3455, 23548, 1, 0, 0, 0, 3457, 23560, 1, 0, 0, 0, 3459, 23574, + 1, 0, 0, 0, 3461, 23584, 1, 0, 0, 0, 3463, 23591, 1, 0, 0, 0, 3465, 23606, + 1, 0, 0, 0, 3467, 23621, 1, 0, 0, 0, 3469, 23637, 1, 0, 0, 0, 3471, 23648, + 1, 0, 0, 0, 3473, 23663, 1, 0, 0, 0, 3475, 23677, 1, 0, 0, 0, 3477, 23689, + 1, 0, 0, 0, 3479, 23714, 1, 0, 0, 0, 3481, 23734, 1, 0, 0, 0, 3483, 23745, + 1, 0, 0, 0, 3485, 23757, 1, 0, 0, 0, 3487, 23768, 1, 0, 0, 0, 3489, 23780, + 1, 0, 0, 0, 3491, 23801, 1, 0, 0, 0, 3493, 23813, 1, 0, 0, 0, 3495, 23828, + 1, 0, 0, 0, 3497, 23844, 1, 0, 0, 0, 3499, 23858, 1, 0, 0, 0, 3501, 23876, + 1, 0, 0, 0, 3503, 23887, 1, 0, 0, 0, 3505, 23904, 1, 0, 0, 0, 3507, 23922, + 1, 0, 0, 0, 3509, 23936, 1, 0, 0, 0, 3511, 23951, 1, 0, 0, 0, 3513, 23967, + 1, 0, 0, 0, 3515, 23978, 1, 0, 0, 0, 3517, 23990, 1, 0, 0, 0, 3519, 24006, + 1, 0, 0, 0, 3521, 24031, 1, 0, 0, 0, 3523, 24039, 1, 0, 0, 0, 3525, 24054, + 1, 0, 0, 0, 3527, 24070, 1, 0, 0, 0, 3529, 24082, 1, 0, 0, 0, 3531, 24094, + 1, 0, 0, 0, 3533, 24105, 1, 0, 0, 0, 3535, 24116, 1, 0, 0, 0, 3537, 24141, + 1, 0, 0, 0, 3539, 24171, 1, 0, 0, 0, 3541, 24196, 1, 0, 0, 0, 3543, 24224, + 1, 0, 0, 0, 3545, 24246, 1, 0, 0, 0, 3547, 24258, 1, 0, 0, 0, 3549, 24277, + 1, 0, 0, 0, 3551, 24296, 1, 0, 0, 0, 3553, 24313, 1, 0, 0, 0, 3555, 24333, + 1, 0, 0, 0, 3557, 24351, 1, 0, 0, 0, 3559, 24363, 1, 0, 0, 0, 3561, 24374, + 1, 0, 0, 0, 3563, 24389, 1, 0, 0, 0, 3565, 24408, 1, 0, 0, 0, 3567, 24419, + 1, 0, 0, 0, 3569, 24436, 1, 0, 0, 0, 3571, 24453, 1, 0, 0, 0, 3573, 24464, + 1, 0, 0, 0, 3575, 24475, 1, 0, 0, 0, 3577, 24491, 1, 0, 0, 0, 3579, 24506, + 1, 0, 0, 0, 3581, 24522, 1, 0, 0, 0, 3583, 24538, 1, 0, 0, 0, 3585, 24553, + 1, 0, 0, 0, 3587, 24566, 1, 0, 0, 0, 3589, 24582, 1, 0, 0, 0, 3591, 24596, + 1, 0, 0, 0, 3593, 24607, 1, 0, 0, 0, 3595, 24622, 1, 0, 0, 0, 3597, 24635, + 1, 0, 0, 0, 3599, 24646, 1, 0, 0, 0, 3601, 24662, 1, 0, 0, 0, 3603, 24674, + 1, 0, 0, 0, 3605, 24685, 1, 0, 0, 0, 3607, 24697, 1, 0, 0, 0, 3609, 24715, + 1, 0, 0, 0, 3611, 24726, 1, 0, 0, 0, 3613, 24742, 1, 0, 0, 0, 3615, 24757, + 1, 0, 0, 0, 3617, 24768, 1, 0, 0, 0, 3619, 24780, 1, 0, 0, 0, 3621, 24793, + 1, 0, 0, 0, 3623, 24811, 1, 0, 0, 0, 3625, 24828, 1, 0, 0, 0, 3627, 24842, + 1, 0, 0, 0, 3629, 24856, 1, 0, 0, 0, 3631, 24869, 1, 0, 0, 0, 3633, 24883, + 1, 0, 0, 0, 3635, 24898, 1, 0, 0, 0, 3637, 24910, 1, 0, 0, 0, 3639, 24921, + 1, 0, 0, 0, 3641, 24944, 1, 0, 0, 0, 3643, 24959, 1, 0, 0, 0, 3645, 24974, + 1, 0, 0, 0, 3647, 24988, 1, 0, 0, 0, 3649, 25005, 1, 0, 0, 0, 3651, 25020, + 1, 0, 0, 0, 3653, 25039, 1, 0, 0, 0, 3655, 25061, 1, 0, 0, 0, 3657, 25081, + 1, 0, 0, 0, 3659, 25098, 1, 0, 0, 0, 3661, 25117, 1, 0, 0, 0, 3663, 25137, + 1, 0, 0, 0, 3665, 25157, 1, 0, 0, 0, 3667, 25178, 1, 0, 0, 0, 3669, 25195, + 1, 0, 0, 0, 3671, 25210, 1, 0, 0, 0, 3673, 25226, 1, 0, 0, 0, 3675, 25240, + 1, 0, 0, 0, 3677, 25254, 1, 0, 0, 0, 3679, 25268, 1, 0, 0, 0, 3681, 25283, + 1, 0, 0, 0, 3683, 25298, 1, 0, 0, 0, 3685, 25305, 1, 0, 0, 0, 3687, 25318, + 1, 0, 0, 0, 3689, 25329, 1, 0, 0, 0, 3691, 25342, 1, 0, 0, 0, 3693, 25357, + 1, 0, 0, 0, 3695, 25373, 1, 0, 0, 0, 3697, 25385, 1, 0, 0, 0, 3699, 25400, + 1, 0, 0, 0, 3701, 25411, 1, 0, 0, 0, 3703, 25431, 1, 0, 0, 0, 3705, 25451, + 1, 0, 0, 0, 3707, 25464, 1, 0, 0, 0, 3709, 25487, 1, 0, 0, 0, 3711, 25508, + 1, 0, 0, 0, 3713, 25533, 1, 0, 0, 0, 3715, 25555, 1, 0, 0, 0, 3717, 25579, + 1, 0, 0, 0, 3719, 25602, 1, 0, 0, 0, 3721, 25623, 1, 0, 0, 0, 3723, 25645, + 1, 0, 0, 0, 3725, 25666, 1, 0, 0, 0, 3727, 25680, 1, 0, 0, 0, 3729, 25694, + 1, 0, 0, 0, 3731, 25711, 1, 0, 0, 0, 3733, 25727, 1, 0, 0, 0, 3735, 25742, + 1, 0, 0, 0, 3737, 25760, 1, 0, 0, 0, 3739, 25774, 1, 0, 0, 0, 3741, 25793, + 1, 0, 0, 0, 3743, 25809, 1, 0, 0, 0, 3745, 25823, 1, 0, 0, 0, 3747, 25837, + 1, 0, 0, 0, 3749, 25850, 1, 0, 0, 0, 3751, 25863, 1, 0, 0, 0, 3753, 25882, + 1, 0, 0, 0, 3755, 25892, 1, 0, 0, 0, 3757, 25905, 1, 0, 0, 0, 3759, 25918, + 1, 0, 0, 0, 3761, 25931, 1, 0, 0, 0, 3763, 25946, 1, 0, 0, 0, 3765, 25957, + 1, 0, 0, 0, 3767, 25967, 1, 0, 0, 0, 3769, 25983, 1, 0, 0, 0, 3771, 25998, + 1, 0, 0, 0, 3773, 26012, 1, 0, 0, 0, 3775, 26026, 1, 0, 0, 0, 3777, 26040, + 1, 0, 0, 0, 3779, 26052, 1, 0, 0, 0, 3781, 26065, 1, 0, 0, 0, 3783, 26078, + 1, 0, 0, 0, 3785, 26090, 1, 0, 0, 0, 3787, 26104, 1, 0, 0, 0, 3789, 26118, + 1, 0, 0, 0, 3791, 26129, 1, 0, 0, 0, 3793, 26143, 1, 0, 0, 0, 3795, 26161, + 1, 0, 0, 0, 3797, 26173, 1, 0, 0, 0, 3799, 26186, 1, 0, 0, 0, 3801, 26202, + 1, 0, 0, 0, 3803, 26218, 1, 0, 0, 0, 3805, 26230, 1, 0, 0, 0, 3807, 26247, + 1, 0, 0, 0, 3809, 26260, 1, 0, 0, 0, 3811, 26273, 1, 0, 0, 0, 3813, 26286, + 1, 0, 0, 0, 3815, 26300, 1, 0, 0, 0, 3817, 26311, 1, 0, 0, 0, 3819, 26328, + 1, 0, 0, 0, 3821, 26344, 1, 0, 0, 0, 3823, 26357, 1, 0, 0, 0, 3825, 26372, + 1, 0, 0, 0, 3827, 26388, 1, 0, 0, 0, 3829, 26404, 1, 0, 0, 0, 3831, 26416, + 1, 0, 0, 0, 3833, 26430, 1, 0, 0, 0, 3835, 26446, 1, 0, 0, 0, 3837, 26462, + 1, 0, 0, 0, 3839, 26479, 1, 0, 0, 0, 3841, 26493, 1, 0, 0, 0, 3843, 26507, + 1, 0, 0, 0, 3845, 26521, 1, 0, 0, 0, 3847, 26537, 1, 0, 0, 0, 3849, 26551, + 1, 0, 0, 0, 3851, 26565, 1, 0, 0, 0, 3853, 26579, 1, 0, 0, 0, 3855, 26593, + 1, 0, 0, 0, 3857, 26607, 1, 0, 0, 0, 3859, 26621, 1, 0, 0, 0, 3861, 26636, + 1, 0, 0, 0, 3863, 26650, 1, 0, 0, 0, 3865, 26665, 1, 0, 0, 0, 3867, 26680, + 1, 0, 0, 0, 3869, 26694, 1, 0, 0, 0, 3871, 26708, 1, 0, 0, 0, 3873, 26722, + 1, 0, 0, 0, 3875, 26736, 1, 0, 0, 0, 3877, 26750, 1, 0, 0, 0, 3879, 26764, + 1, 0, 0, 0, 3881, 26778, 1, 0, 0, 0, 3883, 26791, 1, 0, 0, 0, 3885, 26805, + 1, 0, 0, 0, 3887, 26819, 1, 0, 0, 0, 3889, 26837, 1, 0, 0, 0, 3891, 26851, + 1, 0, 0, 0, 3893, 26867, 1, 0, 0, 0, 3895, 26882, 1, 0, 0, 0, 3897, 26894, + 1, 0, 0, 0, 3899, 26911, 1, 0, 0, 0, 3901, 26925, 1, 0, 0, 0, 3903, 26941, + 1, 0, 0, 0, 3905, 26955, 1, 0, 0, 0, 3907, 26967, 1, 0, 0, 0, 3909, 26980, + 1, 0, 0, 0, 3911, 26993, 1, 0, 0, 0, 3913, 27011, 1, 0, 0, 0, 3915, 27028, + 1, 0, 0, 0, 3917, 27043, 1, 0, 0, 0, 3919, 27059, 1, 0, 0, 0, 3921, 27073, + 1, 0, 0, 0, 3923, 27089, 1, 0, 0, 0, 3925, 27105, 1, 0, 0, 0, 3927, 27120, + 1, 0, 0, 0, 3929, 27134, 1, 0, 0, 0, 3931, 27152, 1, 0, 0, 0, 3933, 27164, + 1, 0, 0, 0, 3935, 27180, 1, 0, 0, 0, 3937, 27196, 1, 0, 0, 0, 3939, 27213, + 1, 0, 0, 0, 3941, 27215, 1, 0, 0, 0, 3943, 27234, 1, 0, 0, 0, 3945, 27248, + 1, 0, 0, 0, 3947, 27259, 1, 0, 0, 0, 3949, 27266, 1, 0, 0, 0, 3951, 27278, + 1, 0, 0, 0, 3953, 27284, 1, 0, 0, 0, 3955, 27290, 1, 0, 0, 0, 3957, 27294, + 1, 0, 0, 0, 3959, 27299, 1, 0, 0, 0, 3961, 27303, 1, 0, 0, 0, 3963, 27323, + 1, 0, 0, 0, 3965, 27332, 1, 0, 0, 0, 3967, 27341, 1, 0, 0, 0, 3969, 27351, + 1, 0, 0, 0, 3971, 27362, 1, 0, 0, 0, 3973, 27367, 1, 0, 0, 0, 3975, 27372, + 1, 0, 0, 0, 3977, 27377, 1, 0, 0, 0, 3979, 27382, 1, 0, 0, 0, 3981, 27386, + 1, 0, 0, 0, 3983, 27393, 1, 0, 0, 0, 3985, 27401, 1, 0, 0, 0, 3987, 27406, + 1, 0, 0, 0, 3989, 27411, 1, 0, 0, 0, 3991, 27419, 1, 0, 0, 0, 3993, 27447, + 1, 0, 0, 0, 3995, 27457, 1, 0, 0, 0, 3997, 27484, 1, 0, 0, 0, 3999, 27508, + 1, 0, 0, 0, 4001, 27514, 1, 0, 0, 0, 4003, 27519, 1, 0, 0, 0, 4005, 27528, + 1, 0, 0, 0, 4007, 27542, 1, 0, 0, 0, 4009, 27556, 1, 0, 0, 0, 4011, 27572, + 1, 0, 0, 0, 4013, 27588, 1, 0, 0, 0, 4015, 27604, 1, 0, 0, 0, 4017, 27614, + 1, 0, 0, 0, 4019, 27621, 1, 0, 0, 0, 4021, 27628, 1, 0, 0, 0, 4023, 27636, + 1, 0, 0, 0, 4025, 27645, 1, 0, 0, 0, 4027, 27662, 1, 0, 0, 0, 4029, 27678, + 1, 0, 0, 0, 4031, 27686, 1, 0, 0, 0, 4033, 27694, 1, 0, 0, 0, 4035, 27708, + 1, 0, 0, 0, 4037, 27715, 1, 0, 0, 0, 4039, 27729, 1, 0, 0, 0, 4041, 27738, + 1, 0, 0, 0, 4043, 27747, 1, 0, 0, 0, 4045, 27757, 1, 0, 0, 0, 4047, 27766, + 1, 0, 0, 0, 4049, 27781, 1, 0, 0, 0, 4051, 27794, 1, 0, 0, 0, 4053, 27810, + 1, 0, 0, 0, 4055, 27818, 1, 0, 0, 0, 4057, 27829, 1, 0, 0, 0, 4059, 27832, + 1, 0, 0, 0, 4061, 27846, 1, 0, 0, 0, 4063, 27852, 1, 0, 0, 0, 4065, 27860, + 1, 0, 0, 0, 4067, 27869, 1, 0, 0, 0, 4069, 27878, 1, 0, 0, 0, 4071, 27890, + 1, 0, 0, 0, 4073, 27900, 1, 0, 0, 0, 4075, 27923, 1, 0, 0, 0, 4077, 27936, + 1, 0, 0, 0, 4079, 27947, 1, 0, 0, 0, 4081, 27957, 1, 0, 0, 0, 4083, 27969, + 1, 0, 0, 0, 4085, 27975, 1, 0, 0, 0, 4087, 27984, 1, 0, 0, 0, 4089, 27992, + 1, 0, 0, 0, 4091, 27997, 1, 0, 0, 0, 4093, 28006, 1, 0, 0, 0, 4095, 28012, + 1, 0, 0, 0, 4097, 28020, 1, 0, 0, 0, 4099, 28026, 1, 0, 0, 0, 4101, 28033, + 1, 0, 0, 0, 4103, 28036, 1, 0, 0, 0, 4105, 28042, 1, 0, 0, 0, 4107, 28047, + 1, 0, 0, 0, 4109, 28057, 1, 0, 0, 0, 4111, 28061, 1, 0, 0, 0, 4113, 28065, + 1, 0, 0, 0, 4115, 28070, 1, 0, 0, 0, 4117, 28074, 1, 0, 0, 0, 4119, 28085, + 1, 0, 0, 0, 4121, 28095, 1, 0, 0, 0, 4123, 28103, 1, 0, 0, 0, 4125, 28117, + 1, 0, 0, 0, 4127, 28123, 1, 0, 0, 0, 4129, 28128, 1, 0, 0, 0, 4131, 28135, + 1, 0, 0, 0, 4133, 28143, 1, 0, 0, 0, 4135, 28149, 1, 0, 0, 0, 4137, 28156, + 1, 0, 0, 0, 4139, 28163, 1, 0, 0, 0, 4141, 28173, 1, 0, 0, 0, 4143, 28180, + 1, 0, 0, 0, 4145, 28187, 1, 0, 0, 0, 4147, 28197, 1, 0, 0, 0, 4149, 28225, + 1, 0, 0, 0, 4151, 28255, 1, 0, 0, 0, 4153, 28273, 1, 0, 0, 0, 4155, 28280, + 1, 0, 0, 0, 4157, 28289, 1, 0, 0, 0, 4159, 28297, 1, 0, 0, 0, 4161, 28304, + 1, 0, 0, 0, 4163, 28316, 1, 0, 0, 0, 4165, 28326, 1, 0, 0, 0, 4167, 28340, + 1, 0, 0, 0, 4169, 28353, 1, 0, 0, 0, 4171, 28365, 1, 0, 0, 0, 4173, 28371, + 1, 0, 0, 0, 4175, 28380, 1, 0, 0, 0, 4177, 28387, 1, 0, 0, 0, 4179, 28397, + 1, 0, 0, 0, 4181, 28405, 1, 0, 0, 0, 4183, 28412, 1, 0, 0, 0, 4185, 28422, + 1, 0, 0, 0, 4187, 28434, 1, 0, 0, 0, 4189, 28448, 1, 0, 0, 0, 4191, 28456, + 1, 0, 0, 0, 4193, 28462, 1, 0, 0, 0, 4195, 28469, 1, 0, 0, 0, 4197, 28476, + 1, 0, 0, 0, 4199, 28483, 1, 0, 0, 0, 4201, 28489, 1, 0, 0, 0, 4203, 28498, + 1, 0, 0, 0, 4205, 28509, 1, 0, 0, 0, 4207, 28518, 1, 0, 0, 0, 4209, 28539, + 1, 0, 0, 0, 4211, 28565, 1, 0, 0, 0, 4213, 28574, 1, 0, 0, 0, 4215, 28596, + 1, 0, 0, 0, 4217, 28618, 1, 0, 0, 0, 4219, 28638, 1, 0, 0, 0, 4221, 28648, + 1, 0, 0, 0, 4223, 28655, 1, 0, 0, 0, 4225, 28673, 1, 0, 0, 0, 4227, 28694, + 1, 0, 0, 0, 4229, 28704, 1, 0, 0, 0, 4231, 28717, 1, 0, 0, 0, 4233, 28725, + 1, 0, 0, 0, 4235, 28735, 1, 0, 0, 0, 4237, 28751, 1, 0, 0, 0, 4239, 28757, + 1, 0, 0, 0, 4241, 28774, 1, 0, 0, 0, 4243, 28779, 1, 0, 0, 0, 4245, 28788, + 1, 0, 0, 0, 4247, 28808, 1, 0, 0, 0, 4249, 28826, 1, 0, 0, 0, 4251, 28830, + 1, 0, 0, 0, 4253, 28853, 1, 0, 0, 0, 4255, 28872, 1, 0, 0, 0, 4257, 28888, + 1, 0, 0, 0, 4259, 28894, 1, 0, 0, 0, 4261, 28902, 1, 0, 0, 0, 4263, 28910, + 1, 0, 0, 0, 4265, 28916, 1, 0, 0, 0, 4267, 28921, 1, 0, 0, 0, 4269, 28924, + 1, 0, 0, 0, 4271, 28927, 1, 0, 0, 0, 4273, 28936, 1, 0, 0, 0, 4275, 28956, + 1, 0, 0, 0, 4277, 28967, 1, 0, 0, 0, 4279, 28982, 1, 0, 0, 0, 4281, 28989, + 1, 0, 0, 0, 4283, 28995, 1, 0, 0, 0, 4285, 29004, 1, 0, 0, 0, 4287, 29012, + 1, 0, 0, 0, 4289, 29021, 1, 0, 0, 0, 4291, 29029, 1, 0, 0, 0, 4293, 29037, + 1, 0, 0, 0, 4295, 29044, 1, 0, 0, 0, 4297, 29053, 1, 0, 0, 0, 4299, 29061, + 1, 0, 0, 0, 4301, 29079, 1, 0, 0, 0, 4303, 29091, 1, 0, 0, 0, 4305, 29113, + 1, 0, 0, 0, 4307, 29135, 1, 0, 0, 0, 4309, 29152, 1, 0, 0, 0, 4311, 29161, + 1, 0, 0, 0, 4313, 29168, 1, 0, 0, 0, 4315, 29179, 1, 0, 0, 0, 4317, 29195, + 1, 0, 0, 0, 4319, 29212, 1, 0, 0, 0, 4321, 29231, 1, 0, 0, 0, 4323, 29249, + 1, 0, 0, 0, 4325, 29268, 1, 0, 0, 0, 4327, 29277, 1, 0, 0, 0, 4329, 29290, + 1, 0, 0, 0, 4331, 29298, 1, 0, 0, 0, 4333, 29303, 1, 0, 0, 0, 4335, 29313, + 1, 0, 0, 0, 4337, 29321, 1, 0, 0, 0, 4339, 29332, 1, 0, 0, 0, 4341, 29340, + 1, 0, 0, 0, 4343, 29347, 1, 0, 0, 0, 4345, 29353, 1, 0, 0, 0, 4347, 29358, + 1, 0, 0, 0, 4349, 29365, 1, 0, 0, 0, 4351, 29373, 1, 0, 0, 0, 4353, 29379, + 1, 0, 0, 0, 4355, 29384, 1, 0, 0, 0, 4357, 29395, 1, 0, 0, 0, 4359, 29404, + 1, 0, 0, 0, 4361, 29409, 1, 0, 0, 0, 4363, 29415, 1, 0, 0, 0, 4365, 29421, + 1, 0, 0, 0, 4367, 29432, 1, 0, 0, 0, 4369, 29445, 1, 0, 0, 0, 4371, 29452, + 1, 0, 0, 0, 4373, 29460, 1, 0, 0, 0, 4375, 29471, 1, 0, 0, 0, 4377, 29476, + 1, 0, 0, 0, 4379, 29481, 1, 0, 0, 0, 4381, 29489, 1, 0, 0, 0, 4383, 29497, + 1, 0, 0, 0, 4385, 29503, 1, 0, 0, 0, 4387, 29523, 1, 0, 0, 0, 4389, 29527, + 1, 0, 0, 0, 4391, 29539, 1, 0, 0, 0, 4393, 29543, 1, 0, 0, 0, 4395, 29554, + 1, 0, 0, 0, 4397, 29561, 1, 0, 0, 0, 4399, 29575, 1, 0, 0, 0, 4401, 29583, + 1, 0, 0, 0, 4403, 29592, 1, 0, 0, 0, 4405, 29605, 1, 0, 0, 0, 4407, 29616, + 1, 0, 0, 0, 4409, 29626, 1, 0, 0, 0, 4411, 29634, 1, 0, 0, 0, 4413, 29651, + 1, 0, 0, 0, 4415, 29662, 1, 0, 0, 0, 4417, 29673, 1, 0, 0, 0, 4419, 29683, + 1, 0, 0, 0, 4421, 29693, 1, 0, 0, 0, 4423, 29702, 1, 0, 0, 0, 4425, 29729, + 1, 0, 0, 0, 4427, 29746, 1, 0, 0, 0, 4429, 29767, 1, 0, 0, 0, 4431, 29777, + 1, 0, 0, 0, 4433, 29788, 1, 0, 0, 0, 4435, 29802, 1, 0, 0, 0, 4437, 29811, + 1, 0, 0, 0, 4439, 29820, 1, 0, 0, 0, 4441, 29826, 1, 0, 0, 0, 4443, 29838, + 1, 0, 0, 0, 4445, 29847, 1, 0, 0, 0, 4447, 29855, 1, 0, 0, 0, 4449, 29865, + 1, 0, 0, 0, 4451, 29878, 1, 0, 0, 0, 4453, 29887, 1, 0, 0, 0, 4455, 29904, + 1, 0, 0, 0, 4457, 29917, 1, 0, 0, 0, 4459, 29925, 1, 0, 0, 0, 4461, 29929, + 1, 0, 0, 0, 4463, 29940, 1, 0, 0, 0, 4465, 29955, 1, 0, 0, 0, 4467, 29958, + 1, 0, 0, 0, 4469, 29964, 1, 0, 0, 0, 4471, 29969, 1, 0, 0, 0, 4473, 29973, + 1, 0, 0, 0, 4475, 29998, 1, 0, 0, 0, 4477, 30006, 1, 0, 0, 0, 4479, 30011, + 1, 0, 0, 0, 4481, 30022, 1, 0, 0, 0, 4483, 30040, 1, 0, 0, 0, 4485, 30056, + 1, 0, 0, 0, 4487, 30075, 1, 0, 0, 0, 4489, 30098, 1, 0, 0, 0, 4491, 30113, + 1, 0, 0, 0, 4493, 30124, 1, 0, 0, 0, 4495, 30132, 1, 0, 0, 0, 4497, 30142, + 1, 0, 0, 0, 4499, 30153, 1, 0, 0, 0, 4501, 30164, 1, 0, 0, 0, 4503, 30173, + 1, 0, 0, 0, 4505, 30181, 1, 0, 0, 0, 4507, 30186, 1, 0, 0, 0, 4509, 30196, + 1, 0, 0, 0, 4511, 30212, 1, 0, 0, 0, 4513, 30224, 1, 0, 0, 0, 4515, 30236, + 1, 0, 0, 0, 4517, 30250, 1, 0, 0, 0, 4519, 30261, 1, 0, 0, 0, 4521, 30269, + 1, 0, 0, 0, 4523, 30274, 1, 0, 0, 0, 4525, 30282, 1, 0, 0, 0, 4527, 30287, + 1, 0, 0, 0, 4529, 30293, 1, 0, 0, 0, 4531, 30303, 1, 0, 0, 0, 4533, 30313, + 1, 0, 0, 0, 4535, 30324, 1, 0, 0, 0, 4537, 30332, 1, 0, 0, 0, 4539, 30345, + 1, 0, 0, 0, 4541, 30361, 1, 0, 0, 0, 4543, 30377, 1, 0, 0, 0, 4545, 30382, + 1, 0, 0, 0, 4547, 30386, 1, 0, 0, 0, 4549, 30391, 1, 0, 0, 0, 4551, 30398, + 1, 0, 0, 0, 4553, 30405, 1, 0, 0, 0, 4555, 30409, 1, 0, 0, 0, 4557, 30418, + 1, 0, 0, 0, 4559, 30435, 1, 0, 0, 0, 4561, 30440, 1, 0, 0, 0, 4563, 30444, + 1, 0, 0, 0, 4565, 30451, 1, 0, 0, 0, 4567, 30463, 1, 0, 0, 0, 4569, 30467, + 1, 0, 0, 0, 4571, 30473, 1, 0, 0, 0, 4573, 30477, 1, 0, 0, 0, 4575, 30493, + 1, 0, 0, 0, 4577, 30499, 1, 0, 0, 0, 4579, 30505, 1, 0, 0, 0, 4581, 30516, + 1, 0, 0, 0, 4583, 30523, 1, 0, 0, 0, 4585, 30531, 1, 0, 0, 0, 4587, 30536, + 1, 0, 0, 0, 4589, 30540, 1, 0, 0, 0, 4591, 30547, 1, 0, 0, 0, 4593, 30552, + 1, 0, 0, 0, 4595, 30561, 1, 0, 0, 0, 4597, 30567, 1, 0, 0, 0, 4599, 30576, + 1, 0, 0, 0, 4601, 30584, 1, 0, 0, 0, 4603, 30594, 1, 0, 0, 0, 4605, 30598, + 1, 0, 0, 0, 4607, 30607, 1, 0, 0, 0, 4609, 30618, 1, 0, 0, 0, 4611, 30629, + 1, 0, 0, 0, 4613, 30636, 1, 0, 0, 0, 4615, 30643, 1, 0, 0, 0, 4617, 30651, + 1, 0, 0, 0, 4619, 30663, 1, 0, 0, 0, 4621, 30668, 1, 0, 0, 0, 4623, 30679, + 1, 0, 0, 0, 4625, 30687, 1, 0, 0, 0, 4627, 30695, 1, 0, 0, 0, 4629, 30708, + 1, 0, 0, 0, 4631, 30716, 1, 0, 0, 0, 4633, 30722, 1, 0, 0, 0, 4635, 30732, + 1, 0, 0, 0, 4637, 30739, 1, 0, 0, 0, 4639, 30752, 1, 0, 0, 0, 4641, 30762, + 1, 0, 0, 0, 4643, 30769, 1, 0, 0, 0, 4645, 30773, 1, 0, 0, 0, 4647, 30780, + 1, 0, 0, 0, 4649, 30794, 1, 0, 0, 0, 4651, 30802, 1, 0, 0, 0, 4653, 30808, + 1, 0, 0, 0, 4655, 30812, 1, 0, 0, 0, 4657, 30818, 1, 0, 0, 0, 4659, 30829, + 1, 0, 0, 0, 4661, 30838, 1, 0, 0, 0, 4663, 30867, 1, 0, 0, 0, 4665, 30878, + 1, 0, 0, 0, 4667, 30890, 1, 0, 0, 0, 4669, 30896, 1, 0, 0, 0, 4671, 30907, + 1, 0, 0, 0, 4673, 30916, 1, 0, 0, 0, 4675, 30927, 1, 0, 0, 0, 4677, 30939, + 1, 0, 0, 0, 4679, 30952, 1, 0, 0, 0, 4681, 30969, 1, 0, 0, 0, 4683, 30979, + 1, 0, 0, 0, 4685, 30987, 1, 0, 0, 0, 4687, 31001, 1, 0, 0, 0, 4689, 31013, + 1, 0, 0, 0, 4691, 31023, 1, 0, 0, 0, 4693, 31030, 1, 0, 0, 0, 4695, 31053, + 1, 0, 0, 0, 4697, 31057, 1, 0, 0, 0, 4699, 31066, 1, 0, 0, 0, 4701, 31075, + 1, 0, 0, 0, 4703, 31081, 1, 0, 0, 0, 4705, 31087, 1, 0, 0, 0, 4707, 31096, + 1, 0, 0, 0, 4709, 31105, 1, 0, 0, 0, 4711, 31113, 1, 0, 0, 0, 4713, 31122, + 1, 0, 0, 0, 4715, 31131, 1, 0, 0, 0, 4717, 31137, 1, 0, 0, 0, 4719, 31149, + 1, 0, 0, 0, 4721, 31163, 1, 0, 0, 0, 4723, 31171, 1, 0, 0, 0, 4725, 31178, + 1, 0, 0, 0, 4727, 31187, 1, 0, 0, 0, 4729, 31195, 1, 0, 0, 0, 4731, 31208, + 1, 0, 0, 0, 4733, 31221, 1, 0, 0, 0, 4735, 31234, 1, 0, 0, 0, 4737, 31237, + 1, 0, 0, 0, 4739, 31240, 1, 0, 0, 0, 4741, 31244, 1, 0, 0, 0, 4743, 31262, + 1, 0, 0, 0, 4745, 31274, 1, 0, 0, 0, 4747, 31310, 1, 0, 0, 0, 4749, 31319, + 1, 0, 0, 0, 4751, 31328, 1, 0, 0, 0, 4753, 31337, 1, 0, 0, 0, 4755, 31346, + 1, 0, 0, 0, 4757, 31355, 1, 0, 0, 0, 4759, 31364, 1, 0, 0, 0, 4761, 31373, + 1, 0, 0, 0, 4763, 31382, 1, 0, 0, 0, 4765, 31391, 1, 0, 0, 0, 4767, 31400, + 1, 0, 0, 0, 4769, 31409, 1, 0, 0, 0, 4771, 31418, 1, 0, 0, 0, 4773, 31427, + 1, 0, 0, 0, 4775, 31436, 1, 0, 0, 0, 4777, 31445, 1, 0, 0, 0, 4779, 31454, + 1, 0, 0, 0, 4781, 31463, 1, 0, 0, 0, 4783, 31472, 1, 0, 0, 0, 4785, 31481, + 1, 0, 0, 0, 4787, 31490, 1, 0, 0, 0, 4789, 31499, 1, 0, 0, 0, 4791, 31508, + 1, 0, 0, 0, 4793, 31517, 1, 0, 0, 0, 4795, 31526, 1, 0, 0, 0, 4797, 31535, + 1, 0, 0, 0, 4799, 31544, 1, 0, 0, 0, 4801, 31553, 1, 0, 0, 0, 4803, 31562, + 1, 0, 0, 0, 4805, 31572, 1, 0, 0, 0, 4807, 31574, 1, 0, 0, 0, 4809, 31576, + 1, 0, 0, 0, 4811, 31578, 1, 0, 0, 0, 4813, 31580, 1, 0, 0, 0, 4815, 31583, + 1, 0, 0, 0, 4817, 31585, 1, 0, 0, 0, 4819, 31587, 1, 0, 0, 0, 4821, 31589, + 1, 0, 0, 0, 4823, 31591, 1, 0, 0, 0, 4825, 31593, 1, 0, 0, 0, 4827, 31595, + 1, 0, 0, 0, 4829, 31598, 1, 0, 0, 0, 4831, 31600, 1, 0, 0, 0, 4833, 31616, + 1, 0, 0, 0, 4835, 31626, 1, 0, 0, 0, 4837, 31628, 1, 0, 0, 0, 4839, 31630, + 1, 0, 0, 0, 4841, 31632, 1, 0, 0, 0, 4843, 31634, 1, 0, 0, 0, 4845, 31636, + 1, 0, 0, 0, 4847, 31638, 1, 0, 0, 0, 4849, 31640, 1, 0, 0, 0, 4851, 31642, + 1, 0, 0, 0, 4853, 31644, 1, 0, 0, 0, 4855, 31646, 1, 0, 0, 0, 4857, 31648, + 1, 0, 0, 0, 4859, 31650, 1, 0, 0, 0, 4861, 31652, 1, 0, 0, 0, 4863, 31665, + 1, 0, 0, 0, 4865, 31679, 1, 0, 0, 0, 4867, 31702, 1, 0, 0, 0, 4869, 31723, + 1, 0, 0, 0, 4871, 31738, 1, 0, 0, 0, 4873, 31748, 1, 0, 0, 0, 4875, 31754, + 1, 0, 0, 0, 4877, 31756, 1, 0, 0, 0, 4879, 31758, 1, 0, 0, 0, 4881, 31763, + 1, 0, 0, 0, 4883, 31775, 1, 0, 0, 0, 4885, 31779, 1, 0, 0, 0, 4887, 31781, + 1, 0, 0, 0, 4889, 4890, 7, 0, 0, 0, 4890, 4891, 7, 1, 0, 0, 4891, 4892, + 7, 2, 0, 0, 4892, 4893, 7, 3, 0, 0, 4893, 4894, 7, 4, 0, 0, 4894, 2, 1, + 0, 0, 0, 4895, 4896, 7, 0, 0, 0, 4896, 4897, 7, 1, 0, 0, 4897, 4898, 7, + 5, 0, 0, 4898, 4, 1, 0, 0, 0, 4899, 4900, 7, 0, 0, 0, 4900, 4901, 7, 1, + 0, 0, 4901, 4902, 7, 5, 0, 0, 4902, 4903, 7, 6, 0, 0, 4903, 4904, 7, 7, + 0, 0, 4904, 4905, 7, 4, 0, 0, 4905, 6, 1, 0, 0, 0, 4906, 4907, 7, 0, 0, + 0, 4907, 4908, 7, 8, 0, 0, 4908, 4909, 7, 8, 0, 0, 4909, 4910, 7, 6, 0, + 0, 4910, 4911, 7, 5, 0, 0, 4911, 4912, 7, 5, 0, 0, 4912, 8, 1, 0, 0, 0, + 4913, 4914, 7, 0, 0, 0, 4914, 4915, 7, 8, 0, 0, 4915, 4916, 7, 8, 0, 0, + 4916, 4917, 7, 6, 0, 0, 4917, 4918, 7, 5, 0, 0, 4918, 4919, 7, 5, 0, 0, + 4919, 4920, 7, 6, 0, 0, 4920, 4921, 7, 9, 0, 0, 4921, 10, 1, 0, 0, 0, 4922, + 4923, 7, 0, 0, 0, 4923, 4924, 7, 8, 0, 0, 4924, 4925, 7, 8, 0, 0, 4925, + 4926, 7, 2, 0, 0, 4926, 4927, 7, 10, 0, 0, 4927, 4928, 7, 7, 0, 0, 4928, + 4929, 7, 4, 0, 0, 4929, 12, 1, 0, 0, 0, 4930, 4931, 7, 0, 0, 0, 4931, 4932, + 7, 8, 0, 0, 4932, 4933, 7, 11, 0, 0, 4933, 14, 1, 0, 0, 0, 4934, 4935, + 7, 0, 0, 0, 4935, 4936, 7, 8, 0, 0, 4936, 4937, 7, 2, 0, 0, 4937, 4938, + 7, 5, 0, 0, 4938, 16, 1, 0, 0, 0, 4939, 4940, 7, 0, 0, 0, 4940, 4941, 7, + 8, 0, 0, 4941, 4942, 7, 3, 0, 0, 4942, 4943, 7, 2, 0, 0, 4943, 4944, 7, + 5, 0, 0, 4944, 4945, 7, 5, 0, 0, 4945, 18, 1, 0, 0, 0, 4946, 4947, 7, 0, + 0, 0, 4947, 4948, 7, 8, 0, 0, 4948, 4949, 7, 4, 0, 0, 4949, 4950, 7, 12, + 0, 0, 4950, 4951, 7, 2, 0, 0, 4951, 4952, 7, 7, 0, 0, 4952, 20, 1, 0, 0, + 0, 4953, 4954, 7, 0, 0, 0, 4954, 4955, 7, 8, 0, 0, 4955, 4956, 7, 4, 0, + 0, 4956, 4957, 7, 12, 0, 0, 4957, 4958, 7, 2, 0, 0, 4958, 4959, 7, 7, 0, + 0, 4959, 4960, 7, 5, 0, 0, 4960, 22, 1, 0, 0, 0, 4961, 4962, 7, 0, 0, 0, + 4962, 4963, 7, 8, 0, 0, 4963, 4964, 7, 4, 0, 0, 4964, 4965, 7, 12, 0, 0, + 4965, 4966, 7, 13, 0, 0, 4966, 4967, 7, 0, 0, 0, 4967, 4968, 7, 4, 0, 0, + 4968, 4969, 7, 6, 0, 0, 4969, 24, 1, 0, 0, 0, 4970, 4971, 7, 0, 0, 0, 4971, + 4972, 7, 8, 0, 0, 4972, 4973, 7, 4, 0, 0, 4973, 4974, 7, 12, 0, 0, 4974, + 4975, 7, 13, 0, 0, 4975, 4976, 7, 6, 0, 0, 4976, 26, 1, 0, 0, 0, 4977, + 4978, 7, 0, 0, 0, 4978, 4979, 7, 8, 0, 0, 4979, 4980, 7, 4, 0, 0, 4980, + 4981, 7, 12, 0, 0, 4981, 4982, 7, 13, 0, 0, 4982, 4983, 7, 6, 0, 0, 4983, + 4984, 5, 95, 0, 0, 4984, 4985, 7, 8, 0, 0, 4985, 4986, 7, 2, 0, 0, 4986, + 4987, 7, 14, 0, 0, 4987, 4988, 7, 15, 0, 0, 4988, 4989, 7, 2, 0, 0, 4989, + 4990, 7, 7, 0, 0, 4990, 4991, 7, 6, 0, 0, 4991, 4992, 7, 7, 0, 0, 4992, + 4993, 7, 4, 0, 0, 4993, 28, 1, 0, 0, 0, 4994, 4995, 7, 0, 0, 0, 4995, 4996, + 7, 8, 0, 0, 4996, 4997, 7, 4, 0, 0, 4997, 4998, 7, 12, 0, 0, 4998, 4999, + 7, 13, 0, 0, 4999, 5000, 7, 6, 0, 0, 5000, 5001, 5, 95, 0, 0, 5001, 5002, + 7, 9, 0, 0, 5002, 5003, 7, 0, 0, 0, 5003, 5004, 7, 4, 0, 0, 5004, 5005, + 7, 0, 0, 0, 5005, 30, 1, 0, 0, 0, 5006, 5007, 7, 0, 0, 0, 5007, 5008, 7, + 8, 0, 0, 5008, 5009, 7, 4, 0, 0, 5009, 5010, 7, 12, 0, 0, 5010, 5011, 7, + 13, 0, 0, 5011, 5012, 7, 6, 0, 0, 5012, 5013, 5, 95, 0, 0, 5013, 5014, + 7, 16, 0, 0, 5014, 5015, 7, 10, 0, 0, 5015, 5016, 7, 7, 0, 0, 5016, 5017, + 7, 8, 0, 0, 5017, 5018, 7, 4, 0, 0, 5018, 5019, 7, 12, 0, 0, 5019, 5020, + 7, 2, 0, 0, 5020, 5021, 7, 7, 0, 0, 5021, 32, 1, 0, 0, 0, 5022, 5023, 7, + 0, 0, 0, 5023, 5024, 7, 8, 0, 0, 5024, 5025, 7, 4, 0, 0, 5025, 5026, 7, + 12, 0, 0, 5026, 5027, 7, 13, 0, 0, 5027, 5028, 7, 6, 0, 0, 5028, 5029, + 5, 95, 0, 0, 5029, 5030, 7, 4, 0, 0, 5030, 5031, 7, 0, 0, 0, 5031, 5032, + 7, 17, 0, 0, 5032, 34, 1, 0, 0, 0, 5033, 5034, 7, 0, 0, 0, 5034, 5035, + 7, 8, 0, 0, 5035, 5036, 7, 4, 0, 0, 5036, 5037, 7, 12, 0, 0, 5037, 5038, + 7, 13, 0, 0, 5038, 5039, 7, 12, 0, 0, 5039, 5040, 7, 4, 0, 0, 5040, 5041, + 7, 18, 0, 0, 5041, 36, 1, 0, 0, 0, 5042, 5043, 7, 0, 0, 0, 5043, 5044, + 7, 9, 0, 0, 5044, 5045, 7, 0, 0, 0, 5045, 5046, 7, 15, 0, 0, 5046, 5047, + 7, 4, 0, 0, 5047, 5048, 7, 12, 0, 0, 5048, 5049, 7, 13, 0, 0, 5049, 5050, + 7, 6, 0, 0, 5050, 5051, 5, 95, 0, 0, 5051, 5052, 7, 15, 0, 0, 5052, 5053, + 7, 11, 0, 0, 5053, 5054, 7, 0, 0, 0, 5054, 5055, 7, 7, 0, 0, 5055, 38, + 1, 0, 0, 0, 5056, 5057, 7, 0, 0, 0, 5057, 5058, 7, 9, 0, 0, 5058, 5059, + 7, 9, 0, 0, 5059, 40, 1, 0, 0, 0, 5060, 5061, 7, 0, 0, 0, 5061, 5062, 7, + 9, 0, 0, 5062, 5063, 7, 9, 0, 0, 5063, 5064, 5, 95, 0, 0, 5064, 5065, 7, + 8, 0, 0, 5065, 5066, 7, 2, 0, 0, 5066, 5067, 7, 11, 0, 0, 5067, 5068, 7, + 10, 0, 0, 5068, 5069, 7, 14, 0, 0, 5069, 5070, 7, 7, 0, 0, 5070, 42, 1, + 0, 0, 0, 5071, 5072, 7, 0, 0, 0, 5072, 5073, 7, 9, 0, 0, 5073, 5074, 7, + 9, 0, 0, 5074, 5075, 5, 95, 0, 0, 5075, 5076, 7, 17, 0, 0, 5076, 5077, + 7, 3, 0, 0, 5077, 5078, 7, 2, 0, 0, 5078, 5079, 7, 10, 0, 0, 5079, 5080, + 7, 15, 0, 0, 5080, 44, 1, 0, 0, 0, 5081, 5082, 7, 0, 0, 0, 5082, 5083, + 7, 9, 0, 0, 5083, 5084, 7, 9, 0, 0, 5084, 5085, 5, 95, 0, 0, 5085, 5086, + 7, 14, 0, 0, 5086, 5087, 7, 2, 0, 0, 5087, 5088, 7, 7, 0, 0, 5088, 5089, + 7, 4, 0, 0, 5089, 5090, 7, 19, 0, 0, 5090, 5091, 7, 5, 0, 0, 5091, 46, + 1, 0, 0, 0, 5092, 5093, 7, 0, 0, 0, 5093, 5094, 7, 9, 0, 0, 5094, 5095, + 7, 20, 0, 0, 5095, 5096, 5, 95, 0, 0, 5096, 5097, 7, 9, 0, 0, 5097, 5098, + 7, 0, 0, 0, 5098, 5099, 7, 4, 0, 0, 5099, 5100, 7, 6, 0, 0, 5100, 48, 1, + 0, 0, 0, 5101, 5102, 7, 0, 0, 0, 5102, 5103, 7, 9, 0, 0, 5103, 5104, 7, + 14, 0, 0, 5104, 5105, 7, 12, 0, 0, 5105, 5106, 7, 7, 0, 0, 5106, 50, 1, + 0, 0, 0, 5107, 5108, 7, 0, 0, 0, 5108, 5109, 7, 9, 0, 0, 5109, 5110, 7, + 14, 0, 0, 5110, 5111, 7, 12, 0, 0, 5111, 5112, 7, 7, 0, 0, 5112, 5113, + 7, 12, 0, 0, 5113, 5114, 7, 5, 0, 0, 5114, 5115, 7, 4, 0, 0, 5115, 5116, + 7, 6, 0, 0, 5116, 5117, 7, 3, 0, 0, 5117, 52, 1, 0, 0, 0, 5118, 5119, 7, + 0, 0, 0, 5119, 5120, 7, 9, 0, 0, 5120, 5121, 7, 14, 0, 0, 5121, 5122, 7, + 12, 0, 0, 5122, 5123, 7, 7, 0, 0, 5123, 5124, 7, 12, 0, 0, 5124, 5125, + 7, 5, 0, 0, 5125, 5126, 7, 4, 0, 0, 5126, 5127, 7, 3, 0, 0, 5127, 5128, + 7, 0, 0, 0, 5128, 5129, 7, 4, 0, 0, 5129, 5130, 7, 2, 0, 0, 5130, 5131, + 7, 3, 0, 0, 5131, 54, 1, 0, 0, 0, 5132, 5133, 7, 0, 0, 0, 5133, 5134, 7, + 9, 0, 0, 5134, 5135, 7, 13, 0, 0, 5135, 5136, 7, 0, 0, 0, 5136, 5137, 7, + 7, 0, 0, 5137, 5138, 7, 8, 0, 0, 5138, 5139, 7, 6, 0, 0, 5139, 5140, 7, + 9, 0, 0, 5140, 56, 1, 0, 0, 0, 5141, 5142, 7, 0, 0, 0, 5142, 5143, 7, 9, + 0, 0, 5143, 5144, 7, 13, 0, 0, 5144, 5145, 7, 12, 0, 0, 5145, 5146, 7, + 5, 0, 0, 5146, 5147, 7, 6, 0, 0, 5147, 58, 1, 0, 0, 0, 5148, 5149, 7, 0, + 0, 0, 5149, 5150, 7, 9, 0, 0, 5150, 5151, 7, 13, 0, 0, 5151, 5152, 7, 12, + 0, 0, 5152, 5153, 7, 5, 0, 0, 5153, 5154, 7, 2, 0, 0, 5154, 5155, 7, 3, + 0, 0, 5155, 60, 1, 0, 0, 0, 5156, 5157, 7, 0, 0, 0, 5157, 5158, 7, 16, + 0, 0, 5158, 5159, 7, 9, 0, 0, 5159, 5160, 5, 95, 0, 0, 5160, 5161, 7, 9, + 0, 0, 5161, 5162, 7, 12, 0, 0, 5162, 5163, 7, 5, 0, 0, 5163, 5164, 7, 21, + 0, 0, 5164, 5165, 7, 5, 0, 0, 5165, 5166, 7, 4, 0, 0, 5166, 5167, 7, 3, + 0, 0, 5167, 5168, 7, 12, 0, 0, 5168, 5169, 7, 7, 0, 0, 5169, 5170, 7, 17, + 0, 0, 5170, 62, 1, 0, 0, 0, 5171, 5172, 7, 0, 0, 0, 5172, 5173, 7, 16, + 0, 0, 5173, 5174, 7, 4, 0, 0, 5174, 5175, 7, 6, 0, 0, 5175, 5176, 7, 3, + 0, 0, 5176, 64, 1, 0, 0, 0, 5177, 5178, 7, 0, 0, 0, 5178, 5179, 7, 17, + 0, 0, 5179, 5180, 7, 6, 0, 0, 5180, 5181, 7, 7, 0, 0, 5181, 5182, 7, 4, + 0, 0, 5182, 66, 1, 0, 0, 0, 5183, 5184, 7, 0, 0, 0, 5184, 5185, 7, 17, + 0, 0, 5185, 5186, 7, 17, 0, 0, 5186, 5187, 7, 3, 0, 0, 5187, 5188, 7, 6, + 0, 0, 5188, 5189, 7, 17, 0, 0, 5189, 5190, 7, 0, 0, 0, 5190, 5191, 7, 4, + 0, 0, 5191, 5192, 7, 6, 0, 0, 5192, 68, 1, 0, 0, 0, 5193, 5194, 7, 0, 0, + 0, 5194, 70, 1, 0, 0, 0, 5195, 5196, 7, 0, 0, 0, 5196, 5197, 7, 11, 0, + 0, 5197, 5198, 7, 12, 0, 0, 5198, 5199, 7, 0, 0, 0, 5199, 5200, 7, 5, 0, + 0, 5200, 72, 1, 0, 0, 0, 5201, 5202, 7, 0, 0, 0, 5202, 5203, 7, 11, 0, + 0, 5203, 5204, 7, 11, 0, 0, 5204, 74, 1, 0, 0, 0, 5205, 5206, 7, 0, 0, + 0, 5206, 5207, 7, 11, 0, 0, 5207, 5208, 7, 11, 0, 0, 5208, 5209, 7, 2, + 0, 0, 5209, 5210, 7, 8, 0, 0, 5210, 5211, 7, 0, 0, 0, 5211, 5212, 7, 4, + 0, 0, 5212, 5213, 7, 6, 0, 0, 5213, 76, 1, 0, 0, 0, 5214, 5215, 7, 0, 0, + 0, 5215, 5216, 7, 11, 0, 0, 5216, 5217, 7, 11, 0, 0, 5217, 5218, 7, 2, + 0, 0, 5218, 5219, 7, 22, 0, 0, 5219, 78, 1, 0, 0, 0, 5220, 5221, 7, 0, + 0, 0, 5221, 5222, 7, 11, 0, 0, 5222, 5223, 7, 11, 0, 0, 5223, 5224, 5, + 95, 0, 0, 5224, 5225, 7, 3, 0, 0, 5225, 5226, 7, 2, 0, 0, 5226, 5227, 7, + 22, 0, 0, 5227, 5228, 7, 5, 0, 0, 5228, 80, 1, 0, 0, 0, 5229, 5230, 7, + 0, 0, 0, 5230, 5231, 7, 11, 0, 0, 5231, 5232, 7, 4, 0, 0, 5232, 5233, 7, + 6, 0, 0, 5233, 5234, 7, 3, 0, 0, 5234, 82, 1, 0, 0, 0, 5235, 5236, 7, 0, + 0, 0, 5236, 5237, 7, 11, 0, 0, 5237, 5238, 7, 4, 0, 0, 5238, 5239, 7, 6, + 0, 0, 5239, 5240, 7, 3, 0, 0, 5240, 5241, 7, 7, 0, 0, 5241, 5242, 7, 0, + 0, 0, 5242, 5243, 7, 4, 0, 0, 5243, 5244, 7, 6, 0, 0, 5244, 84, 1, 0, 0, + 0, 5245, 5246, 7, 0, 0, 0, 5246, 5247, 7, 11, 0, 0, 5247, 5248, 7, 22, + 0, 0, 5248, 5249, 7, 0, 0, 0, 5249, 5250, 7, 18, 0, 0, 5250, 5251, 7, 5, + 0, 0, 5251, 86, 1, 0, 0, 0, 5252, 5253, 7, 0, 0, 0, 5253, 5254, 7, 7, 0, + 0, 5254, 5255, 7, 0, 0, 0, 5255, 5256, 7, 11, 0, 0, 5256, 5257, 7, 18, + 0, 0, 5257, 5258, 7, 4, 0, 0, 5258, 5259, 7, 12, 0, 0, 5259, 5260, 7, 8, + 0, 0, 5260, 88, 1, 0, 0, 0, 5261, 5262, 7, 0, 0, 0, 5262, 5263, 7, 7, 0, + 0, 5263, 5264, 7, 0, 0, 0, 5264, 5265, 7, 11, 0, 0, 5265, 5266, 7, 18, + 0, 0, 5266, 5267, 7, 23, 0, 0, 5267, 5268, 7, 6, 0, 0, 5268, 90, 1, 0, + 0, 0, 5269, 5270, 7, 0, 0, 0, 5270, 5271, 7, 7, 0, 0, 5271, 5272, 7, 8, + 0, 0, 5272, 5273, 7, 6, 0, 0, 5273, 5274, 7, 5, 0, 0, 5274, 5275, 7, 4, + 0, 0, 5275, 5276, 7, 2, 0, 0, 5276, 5277, 7, 3, 0, 0, 5277, 92, 1, 0, 0, + 0, 5278, 5279, 7, 0, 0, 0, 5279, 5280, 7, 7, 0, 0, 5280, 5281, 7, 8, 0, + 0, 5281, 5282, 7, 12, 0, 0, 5282, 5283, 7, 11, 0, 0, 5283, 5284, 7, 11, + 0, 0, 5284, 5285, 7, 0, 0, 0, 5285, 5286, 7, 3, 0, 0, 5286, 5287, 7, 18, + 0, 0, 5287, 94, 1, 0, 0, 0, 5288, 5289, 7, 0, 0, 0, 5289, 5290, 7, 7, 0, + 0, 5290, 5291, 7, 9, 0, 0, 5291, 96, 1, 0, 0, 0, 5292, 5293, 7, 0, 0, 0, + 5293, 5294, 7, 7, 0, 0, 5294, 5295, 7, 9, 0, 0, 5295, 5296, 5, 95, 0, 0, + 5296, 5297, 7, 6, 0, 0, 5297, 5298, 7, 24, 0, 0, 5298, 5299, 7, 10, 0, + 0, 5299, 5300, 7, 0, 0, 0, 5300, 5301, 7, 11, 0, 0, 5301, 98, 1, 0, 0, + 0, 5302, 5303, 7, 0, 0, 0, 5303, 5304, 7, 7, 0, 0, 5304, 5305, 7, 2, 0, + 0, 5305, 5306, 7, 14, 0, 0, 5306, 5307, 7, 0, 0, 0, 5307, 5308, 7, 11, + 0, 0, 5308, 5309, 7, 18, 0, 0, 5309, 100, 1, 0, 0, 0, 5310, 5311, 7, 0, + 0, 0, 5311, 5312, 7, 7, 0, 0, 5312, 5313, 7, 5, 0, 0, 5313, 5314, 7, 12, + 0, 0, 5314, 5315, 5, 95, 0, 0, 5315, 5316, 7, 3, 0, 0, 5316, 5317, 7, 6, + 0, 0, 5317, 5318, 7, 0, 0, 0, 5318, 5319, 7, 3, 0, 0, 5319, 5320, 7, 8, + 0, 0, 5320, 5321, 7, 19, 0, 0, 5321, 102, 1, 0, 0, 0, 5322, 5323, 7, 0, + 0, 0, 5323, 5324, 7, 7, 0, 0, 5324, 5325, 7, 4, 0, 0, 5325, 5326, 7, 12, + 0, 0, 5326, 5327, 7, 20, 0, 0, 5327, 5328, 7, 2, 0, 0, 5328, 5329, 7, 12, + 0, 0, 5329, 5330, 7, 7, 0, 0, 5330, 104, 1, 0, 0, 0, 5331, 5332, 7, 0, + 0, 0, 5332, 5333, 7, 7, 0, 0, 5333, 5334, 7, 18, 0, 0, 5334, 106, 1, 0, + 0, 0, 5335, 5336, 7, 0, 0, 0, 5336, 5337, 7, 7, 0, 0, 5337, 5338, 7, 18, + 0, 0, 5338, 5339, 7, 5, 0, 0, 5339, 5340, 7, 8, 0, 0, 5340, 5341, 7, 19, + 0, 0, 5341, 5342, 7, 6, 0, 0, 5342, 5343, 7, 14, 0, 0, 5343, 5344, 7, 0, + 0, 0, 5344, 108, 1, 0, 0, 0, 5345, 5346, 7, 0, 0, 0, 5346, 5347, 7, 15, + 0, 0, 5347, 5348, 7, 15, 0, 0, 5348, 5349, 7, 6, 0, 0, 5349, 5350, 7, 7, + 0, 0, 5350, 5351, 7, 9, 0, 0, 5351, 110, 1, 0, 0, 0, 5352, 5353, 7, 0, + 0, 0, 5353, 5354, 7, 15, 0, 0, 5354, 5355, 7, 15, 0, 0, 5355, 5356, 7, + 6, 0, 0, 5356, 5357, 7, 7, 0, 0, 5357, 5358, 7, 9, 0, 0, 5358, 5359, 7, + 8, 0, 0, 5359, 5360, 7, 19, 0, 0, 5360, 5361, 7, 12, 0, 0, 5361, 5362, + 7, 11, 0, 0, 5362, 5363, 7, 9, 0, 0, 5363, 5364, 7, 25, 0, 0, 5364, 5365, + 7, 14, 0, 0, 5365, 5366, 7, 11, 0, 0, 5366, 112, 1, 0, 0, 0, 5367, 5368, + 7, 0, 0, 0, 5368, 5369, 7, 15, 0, 0, 5369, 5370, 7, 15, 0, 0, 5370, 5371, + 7, 6, 0, 0, 5371, 5372, 7, 7, 0, 0, 5372, 5373, 7, 9, 0, 0, 5373, 5374, + 5, 95, 0, 0, 5374, 5375, 7, 13, 0, 0, 5375, 5376, 7, 0, 0, 0, 5376, 5377, + 7, 11, 0, 0, 5377, 5378, 7, 10, 0, 0, 5378, 5379, 7, 6, 0, 0, 5379, 5380, + 7, 5, 0, 0, 5380, 114, 1, 0, 0, 0, 5381, 5382, 7, 0, 0, 0, 5382, 5383, + 7, 15, 0, 0, 5383, 5384, 7, 15, 0, 0, 5384, 5385, 7, 11, 0, 0, 5385, 5386, + 7, 12, 0, 0, 5386, 5387, 7, 8, 0, 0, 5387, 5388, 7, 0, 0, 0, 5388, 5389, + 7, 4, 0, 0, 5389, 5390, 7, 12, 0, 0, 5390, 5391, 7, 2, 0, 0, 5391, 5392, + 7, 7, 0, 0, 5392, 116, 1, 0, 0, 0, 5393, 5394, 7, 0, 0, 0, 5394, 5395, + 7, 15, 0, 0, 5395, 5396, 7, 15, 0, 0, 5396, 5397, 7, 11, 0, 0, 5397, 5398, + 7, 18, 0, 0, 5398, 118, 1, 0, 0, 0, 5399, 5400, 7, 0, 0, 0, 5400, 5401, + 7, 15, 0, 0, 5401, 5402, 7, 15, 0, 0, 5402, 5403, 7, 3, 0, 0, 5403, 5404, + 7, 2, 0, 0, 5404, 5405, 7, 25, 0, 0, 5405, 5406, 5, 95, 0, 0, 5406, 5407, + 7, 8, 0, 0, 5407, 5408, 7, 2, 0, 0, 5408, 5409, 7, 10, 0, 0, 5409, 5410, + 7, 7, 0, 0, 5410, 5411, 7, 4, 0, 0, 5411, 5412, 5, 95, 0, 0, 5412, 5413, + 7, 9, 0, 0, 5413, 5414, 7, 12, 0, 0, 5414, 5415, 7, 5, 0, 0, 5415, 5416, + 7, 4, 0, 0, 5416, 5417, 7, 12, 0, 0, 5417, 5418, 7, 7, 0, 0, 5418, 5419, + 7, 8, 0, 0, 5419, 5420, 7, 4, 0, 0, 5420, 120, 1, 0, 0, 0, 5421, 5422, + 7, 0, 0, 0, 5422, 5423, 7, 3, 0, 0, 5423, 5424, 7, 8, 0, 0, 5424, 5425, + 7, 19, 0, 0, 5425, 5426, 7, 12, 0, 0, 5426, 5427, 7, 13, 0, 0, 5427, 5428, + 7, 0, 0, 0, 5428, 5429, 7, 11, 0, 0, 5429, 122, 1, 0, 0, 0, 5430, 5431, + 7, 0, 0, 0, 5431, 5432, 7, 3, 0, 0, 5432, 5433, 7, 8, 0, 0, 5433, 5434, + 7, 19, 0, 0, 5434, 5435, 7, 12, 0, 0, 5435, 5436, 7, 13, 0, 0, 5436, 5437, + 7, 6, 0, 0, 5437, 124, 1, 0, 0, 0, 5438, 5439, 7, 0, 0, 0, 5439, 5440, + 7, 3, 0, 0, 5440, 5441, 7, 8, 0, 0, 5441, 5442, 7, 19, 0, 0, 5442, 5443, + 7, 12, 0, 0, 5443, 5444, 7, 13, 0, 0, 5444, 5445, 7, 6, 0, 0, 5445, 5446, + 7, 9, 0, 0, 5446, 126, 1, 0, 0, 0, 5447, 5448, 7, 0, 0, 0, 5448, 5449, + 7, 3, 0, 0, 5449, 5450, 7, 8, 0, 0, 5450, 5451, 7, 19, 0, 0, 5451, 5452, + 7, 12, 0, 0, 5452, 5453, 7, 13, 0, 0, 5453, 5454, 7, 6, 0, 0, 5454, 5455, + 7, 11, 0, 0, 5455, 5456, 7, 2, 0, 0, 5456, 5457, 7, 17, 0, 0, 5457, 128, + 1, 0, 0, 0, 5458, 5459, 7, 0, 0, 0, 5459, 5460, 7, 3, 0, 0, 5460, 5461, + 7, 3, 0, 0, 5461, 5462, 7, 0, 0, 0, 5462, 5463, 7, 18, 0, 0, 5463, 130, + 1, 0, 0, 0, 5464, 5465, 7, 0, 0, 0, 5465, 5466, 7, 5, 0, 0, 5466, 132, + 1, 0, 0, 0, 5467, 5468, 7, 0, 0, 0, 5468, 5469, 7, 5, 0, 0, 5469, 5470, + 7, 8, 0, 0, 5470, 134, 1, 0, 0, 0, 5471, 5472, 7, 0, 0, 0, 5472, 5473, + 7, 5, 0, 0, 5473, 5474, 7, 8, 0, 0, 5474, 5475, 7, 12, 0, 0, 5475, 5476, + 7, 12, 0, 0, 5476, 136, 1, 0, 0, 0, 5477, 5478, 7, 0, 0, 0, 5478, 5479, + 7, 5, 0, 0, 5479, 5480, 7, 8, 0, 0, 5480, 5481, 7, 12, 0, 0, 5481, 5482, + 7, 12, 0, 0, 5482, 5483, 7, 5, 0, 0, 5483, 5484, 7, 4, 0, 0, 5484, 5485, + 7, 3, 0, 0, 5485, 138, 1, 0, 0, 0, 5486, 5487, 7, 0, 0, 0, 5487, 5488, + 7, 5, 0, 0, 5488, 5489, 7, 12, 0, 0, 5489, 5490, 7, 7, 0, 0, 5490, 140, + 1, 0, 0, 0, 5491, 5492, 7, 0, 0, 0, 5492, 5493, 7, 5, 0, 0, 5493, 5494, + 7, 12, 0, 0, 5494, 5495, 7, 5, 0, 0, 5495, 142, 1, 0, 0, 0, 5496, 5497, + 7, 0, 0, 0, 5497, 5498, 7, 5, 0, 0, 5498, 5499, 7, 5, 0, 0, 5499, 5500, + 7, 6, 0, 0, 5500, 5501, 7, 14, 0, 0, 5501, 5502, 7, 1, 0, 0, 5502, 5503, + 7, 11, 0, 0, 5503, 5504, 7, 18, 0, 0, 5504, 144, 1, 0, 0, 0, 5505, 5506, + 7, 0, 0, 0, 5506, 5507, 7, 5, 0, 0, 5507, 5508, 7, 5, 0, 0, 5508, 5509, + 7, 12, 0, 0, 5509, 5510, 7, 17, 0, 0, 5510, 5511, 7, 7, 0, 0, 5511, 146, + 1, 0, 0, 0, 5512, 5513, 7, 0, 0, 0, 5513, 5514, 7, 5, 0, 0, 5514, 5515, + 7, 5, 0, 0, 5515, 5516, 7, 2, 0, 0, 5516, 5517, 7, 8, 0, 0, 5517, 5518, + 7, 12, 0, 0, 5518, 5519, 7, 0, 0, 0, 5519, 5520, 7, 4, 0, 0, 5520, 5521, + 7, 6, 0, 0, 5521, 148, 1, 0, 0, 0, 5522, 5523, 7, 0, 0, 0, 5523, 5524, + 7, 5, 0, 0, 5524, 5525, 7, 18, 0, 0, 5525, 5526, 7, 7, 0, 0, 5526, 5527, + 7, 8, 0, 0, 5527, 150, 1, 0, 0, 0, 5528, 5529, 7, 0, 0, 0, 5529, 5530, + 7, 5, 0, 0, 5530, 5531, 7, 18, 0, 0, 5531, 5532, 7, 7, 0, 0, 5532, 5533, + 7, 8, 0, 0, 5533, 5534, 7, 19, 0, 0, 5534, 5535, 7, 3, 0, 0, 5535, 5536, + 7, 2, 0, 0, 5536, 5537, 7, 7, 0, 0, 5537, 5538, 7, 2, 0, 0, 5538, 5539, + 7, 10, 0, 0, 5539, 5540, 7, 5, 0, 0, 5540, 152, 1, 0, 0, 0, 5541, 5542, + 7, 0, 0, 0, 5542, 5543, 7, 4, 0, 0, 5543, 5544, 7, 0, 0, 0, 5544, 5545, + 7, 7, 0, 0, 5545, 5546, 5, 50, 0, 0, 5546, 154, 1, 0, 0, 0, 5547, 5548, + 7, 0, 0, 0, 5548, 5549, 7, 4, 0, 0, 5549, 5550, 7, 0, 0, 0, 5550, 5551, + 7, 7, 0, 0, 5551, 156, 1, 0, 0, 0, 5552, 5553, 7, 0, 0, 0, 5553, 5554, + 7, 4, 0, 0, 5554, 158, 1, 0, 0, 0, 5555, 5556, 7, 0, 0, 0, 5556, 5557, + 7, 4, 0, 0, 5557, 5558, 7, 4, 0, 0, 5558, 5559, 7, 3, 0, 0, 5559, 5560, + 7, 12, 0, 0, 5560, 5561, 7, 1, 0, 0, 5561, 5562, 7, 10, 0, 0, 5562, 5563, + 7, 4, 0, 0, 5563, 5564, 7, 6, 0, 0, 5564, 160, 1, 0, 0, 0, 5565, 5566, + 7, 0, 0, 0, 5566, 5567, 7, 4, 0, 0, 5567, 5568, 7, 4, 0, 0, 5568, 5569, + 7, 3, 0, 0, 5569, 5570, 7, 12, 0, 0, 5570, 5571, 7, 1, 0, 0, 5571, 5572, + 7, 10, 0, 0, 5572, 5573, 7, 4, 0, 0, 5573, 5574, 7, 6, 0, 0, 5574, 5575, + 7, 5, 0, 0, 5575, 162, 1, 0, 0, 0, 5576, 5577, 7, 0, 0, 0, 5577, 5578, + 7, 10, 0, 0, 5578, 5579, 7, 9, 0, 0, 5579, 5580, 7, 12, 0, 0, 5580, 5581, + 7, 4, 0, 0, 5581, 164, 1, 0, 0, 0, 5582, 5583, 7, 0, 0, 0, 5583, 5584, + 7, 10, 0, 0, 5584, 5585, 7, 4, 0, 0, 5585, 5586, 7, 19, 0, 0, 5586, 5587, + 7, 6, 0, 0, 5587, 5588, 7, 7, 0, 0, 5588, 5589, 7, 4, 0, 0, 5589, 5590, + 7, 12, 0, 0, 5590, 5591, 7, 8, 0, 0, 5591, 5592, 7, 0, 0, 0, 5592, 5593, + 7, 4, 0, 0, 5593, 5594, 7, 6, 0, 0, 5594, 5595, 7, 9, 0, 0, 5595, 166, + 1, 0, 0, 0, 5596, 5597, 7, 0, 0, 0, 5597, 5598, 7, 10, 0, 0, 5598, 5599, + 7, 4, 0, 0, 5599, 5600, 7, 19, 0, 0, 5600, 5601, 7, 6, 0, 0, 5601, 5602, + 7, 7, 0, 0, 5602, 5603, 7, 4, 0, 0, 5603, 5604, 7, 12, 0, 0, 5604, 5605, + 7, 8, 0, 0, 5605, 5606, 7, 0, 0, 0, 5606, 5607, 7, 4, 0, 0, 5607, 5608, + 7, 12, 0, 0, 5608, 5609, 7, 2, 0, 0, 5609, 5610, 7, 7, 0, 0, 5610, 168, + 1, 0, 0, 0, 5611, 5612, 7, 0, 0, 0, 5612, 5613, 7, 10, 0, 0, 5613, 5614, + 7, 4, 0, 0, 5614, 5615, 7, 19, 0, 0, 5615, 5616, 7, 12, 0, 0, 5616, 5617, + 7, 9, 0, 0, 5617, 170, 1, 0, 0, 0, 5618, 5619, 7, 0, 0, 0, 5619, 5620, + 7, 10, 0, 0, 5620, 5621, 7, 4, 0, 0, 5621, 5622, 7, 19, 0, 0, 5622, 5623, + 7, 2, 0, 0, 5623, 5624, 7, 3, 0, 0, 5624, 5625, 7, 12, 0, 0, 5625, 5626, + 7, 23, 0, 0, 5626, 5627, 7, 0, 0, 0, 5627, 5628, 7, 4, 0, 0, 5628, 5629, + 7, 12, 0, 0, 5629, 5630, 7, 2, 0, 0, 5630, 5631, 7, 7, 0, 0, 5631, 172, + 1, 0, 0, 0, 5632, 5633, 7, 0, 0, 0, 5633, 5634, 7, 10, 0, 0, 5634, 5635, + 7, 4, 0, 0, 5635, 5636, 7, 2, 0, 0, 5636, 5637, 7, 0, 0, 0, 5637, 5638, + 7, 11, 0, 0, 5638, 5639, 7, 11, 0, 0, 5639, 5640, 7, 2, 0, 0, 5640, 5641, + 7, 8, 0, 0, 5641, 5642, 7, 0, 0, 0, 5642, 5643, 7, 4, 0, 0, 5643, 5644, + 7, 6, 0, 0, 5644, 174, 1, 0, 0, 0, 5645, 5646, 7, 0, 0, 0, 5646, 5647, + 7, 10, 0, 0, 5647, 5648, 7, 4, 0, 0, 5648, 5649, 7, 2, 0, 0, 5649, 176, + 1, 0, 0, 0, 5650, 5651, 7, 0, 0, 0, 5651, 5652, 7, 10, 0, 0, 5652, 5653, + 7, 4, 0, 0, 5653, 5654, 7, 2, 0, 0, 5654, 5655, 7, 6, 0, 0, 5655, 5656, + 7, 25, 0, 0, 5656, 5657, 7, 4, 0, 0, 5657, 5658, 7, 6, 0, 0, 5658, 5659, + 7, 7, 0, 0, 5659, 5660, 7, 9, 0, 0, 5660, 178, 1, 0, 0, 0, 5661, 5662, + 7, 0, 0, 0, 5662, 5663, 7, 10, 0, 0, 5663, 5664, 7, 4, 0, 0, 5664, 5665, + 7, 2, 0, 0, 5665, 5666, 5, 95, 0, 0, 5666, 5667, 7, 11, 0, 0, 5667, 5668, + 7, 2, 0, 0, 5668, 5669, 7, 17, 0, 0, 5669, 5670, 7, 12, 0, 0, 5670, 5671, + 7, 7, 0, 0, 5671, 180, 1, 0, 0, 0, 5672, 5673, 7, 0, 0, 0, 5673, 5674, + 7, 10, 0, 0, 5674, 5675, 7, 4, 0, 0, 5675, 5676, 7, 2, 0, 0, 5676, 5677, + 7, 14, 0, 0, 5677, 5678, 7, 0, 0, 0, 5678, 5679, 7, 4, 0, 0, 5679, 5680, + 7, 12, 0, 0, 5680, 5681, 7, 8, 0, 0, 5681, 182, 1, 0, 0, 0, 5682, 5683, + 7, 0, 0, 0, 5683, 5684, 7, 10, 0, 0, 5684, 5685, 7, 4, 0, 0, 5685, 5686, + 7, 2, 0, 0, 5686, 5687, 7, 7, 0, 0, 5687, 5688, 7, 2, 0, 0, 5688, 5689, + 7, 14, 0, 0, 5689, 5690, 7, 2, 0, 0, 5690, 5691, 7, 10, 0, 0, 5691, 5692, + 7, 5, 0, 0, 5692, 5693, 5, 95, 0, 0, 5693, 5694, 7, 4, 0, 0, 5694, 5695, + 7, 3, 0, 0, 5695, 5696, 7, 0, 0, 0, 5696, 5697, 7, 7, 0, 0, 5697, 5698, + 7, 5, 0, 0, 5698, 5699, 7, 0, 0, 0, 5699, 5700, 7, 8, 0, 0, 5700, 5701, + 7, 4, 0, 0, 5701, 5702, 7, 12, 0, 0, 5702, 5703, 7, 2, 0, 0, 5703, 5704, + 7, 7, 0, 0, 5704, 184, 1, 0, 0, 0, 5705, 5706, 7, 0, 0, 0, 5706, 5707, + 7, 10, 0, 0, 5707, 5708, 7, 4, 0, 0, 5708, 5709, 7, 2, 0, 0, 5709, 5710, + 5, 95, 0, 0, 5710, 5711, 7, 3, 0, 0, 5711, 5712, 7, 6, 0, 0, 5712, 5713, + 7, 2, 0, 0, 5713, 5714, 7, 15, 0, 0, 5714, 5715, 7, 4, 0, 0, 5715, 5716, + 7, 12, 0, 0, 5716, 5717, 7, 14, 0, 0, 5717, 5718, 7, 12, 0, 0, 5718, 5719, + 7, 23, 0, 0, 5719, 5720, 7, 6, 0, 0, 5720, 186, 1, 0, 0, 0, 5721, 5722, + 7, 0, 0, 0, 5722, 5723, 7, 13, 0, 0, 5723, 5724, 7, 0, 0, 0, 5724, 5725, + 7, 12, 0, 0, 5725, 5726, 7, 11, 0, 0, 5726, 5727, 7, 0, 0, 0, 5727, 5728, + 7, 1, 0, 0, 5728, 5729, 7, 12, 0, 0, 5729, 5730, 7, 11, 0, 0, 5730, 5731, + 7, 12, 0, 0, 5731, 5732, 7, 4, 0, 0, 5732, 5733, 7, 18, 0, 0, 5733, 188, + 1, 0, 0, 0, 5734, 5735, 7, 0, 0, 0, 5735, 5736, 7, 13, 0, 0, 5736, 5737, + 7, 3, 0, 0, 5737, 5738, 7, 2, 0, 0, 5738, 190, 1, 0, 0, 0, 5739, 5740, + 7, 1, 0, 0, 5740, 5741, 7, 0, 0, 0, 5741, 5742, 7, 8, 0, 0, 5742, 5743, + 7, 21, 0, 0, 5743, 5744, 7, 17, 0, 0, 5744, 5745, 7, 3, 0, 0, 5745, 5746, + 7, 2, 0, 0, 5746, 5747, 7, 10, 0, 0, 5747, 5748, 7, 7, 0, 0, 5748, 5749, + 7, 9, 0, 0, 5749, 192, 1, 0, 0, 0, 5750, 5751, 7, 1, 0, 0, 5751, 5752, + 7, 0, 0, 0, 5752, 5753, 7, 8, 0, 0, 5753, 5754, 7, 21, 0, 0, 5754, 5755, + 7, 12, 0, 0, 5755, 5756, 7, 7, 0, 0, 5756, 5757, 7, 17, 0, 0, 5757, 5758, + 7, 16, 0, 0, 5758, 5759, 7, 12, 0, 0, 5759, 5760, 7, 11, 0, 0, 5760, 5761, + 7, 6, 0, 0, 5761, 194, 1, 0, 0, 0, 5762, 5763, 7, 1, 0, 0, 5763, 5764, + 7, 0, 0, 0, 5764, 5765, 7, 8, 0, 0, 5765, 5766, 7, 21, 0, 0, 5766, 5767, + 7, 10, 0, 0, 5767, 5768, 7, 15, 0, 0, 5768, 196, 1, 0, 0, 0, 5769, 5770, + 7, 1, 0, 0, 5770, 5771, 7, 0, 0, 0, 5771, 5772, 7, 8, 0, 0, 5772, 5773, + 7, 21, 0, 0, 5773, 5774, 7, 10, 0, 0, 5774, 5775, 7, 15, 0, 0, 5775, 5776, + 7, 5, 0, 0, 5776, 198, 1, 0, 0, 0, 5777, 5778, 7, 1, 0, 0, 5778, 5779, + 7, 0, 0, 0, 5779, 5780, 7, 5, 0, 0, 5780, 5781, 7, 12, 0, 0, 5781, 5782, + 7, 8, 0, 0, 5782, 200, 1, 0, 0, 0, 5783, 5784, 7, 1, 0, 0, 5784, 5785, + 7, 0, 0, 0, 5785, 5786, 7, 5, 0, 0, 5786, 5787, 7, 12, 0, 0, 5787, 5788, + 7, 8, 0, 0, 5788, 5789, 7, 16, 0, 0, 5789, 5790, 7, 12, 0, 0, 5790, 5791, + 7, 11, 0, 0, 5791, 5792, 7, 6, 0, 0, 5792, 202, 1, 0, 0, 0, 5793, 5794, + 7, 1, 0, 0, 5794, 5795, 7, 0, 0, 0, 5795, 5796, 7, 4, 0, 0, 5796, 5797, + 7, 8, 0, 0, 5797, 5798, 7, 19, 0, 0, 5798, 204, 1, 0, 0, 0, 5799, 5800, + 7, 1, 0, 0, 5800, 5801, 7, 0, 0, 0, 5801, 5802, 7, 4, 0, 0, 5802, 5803, + 7, 8, 0, 0, 5803, 5804, 7, 19, 0, 0, 5804, 5805, 7, 5, 0, 0, 5805, 5806, + 7, 12, 0, 0, 5806, 5807, 7, 23, 0, 0, 5807, 5808, 7, 6, 0, 0, 5808, 206, + 1, 0, 0, 0, 5809, 5810, 7, 1, 0, 0, 5810, 5811, 7, 0, 0, 0, 5811, 5812, + 7, 4, 0, 0, 5812, 5813, 7, 8, 0, 0, 5813, 5814, 7, 19, 0, 0, 5814, 5815, + 5, 95, 0, 0, 5815, 5816, 7, 4, 0, 0, 5816, 5817, 7, 0, 0, 0, 5817, 5818, + 7, 1, 0, 0, 5818, 5819, 7, 11, 0, 0, 5819, 5820, 7, 6, 0, 0, 5820, 5821, + 5, 95, 0, 0, 5821, 5822, 7, 0, 0, 0, 5822, 5823, 7, 8, 0, 0, 5823, 5824, + 7, 8, 0, 0, 5824, 5825, 7, 6, 0, 0, 5825, 5826, 7, 5, 0, 0, 5826, 5827, + 7, 5, 0, 0, 5827, 5828, 5, 95, 0, 0, 5828, 5829, 7, 1, 0, 0, 5829, 5830, + 7, 18, 0, 0, 5830, 5831, 5, 95, 0, 0, 5831, 5832, 7, 3, 0, 0, 5832, 5833, + 7, 2, 0, 0, 5833, 5834, 7, 22, 0, 0, 5834, 5835, 7, 12, 0, 0, 5835, 5836, + 7, 9, 0, 0, 5836, 208, 1, 0, 0, 0, 5837, 5838, 7, 1, 0, 0, 5838, 5839, + 7, 6, 0, 0, 5839, 5840, 7, 8, 0, 0, 5840, 5841, 7, 2, 0, 0, 5841, 5842, + 7, 14, 0, 0, 5842, 5843, 7, 6, 0, 0, 5843, 210, 1, 0, 0, 0, 5844, 5845, + 7, 1, 0, 0, 5845, 5846, 7, 6, 0, 0, 5846, 5847, 7, 16, 0, 0, 5847, 5848, + 7, 2, 0, 0, 5848, 5849, 7, 3, 0, 0, 5849, 5850, 7, 6, 0, 0, 5850, 212, + 1, 0, 0, 0, 5851, 5852, 7, 1, 0, 0, 5852, 5853, 7, 6, 0, 0, 5853, 5854, + 7, 17, 0, 0, 5854, 5855, 7, 12, 0, 0, 5855, 5856, 7, 7, 0, 0, 5856, 214, + 1, 0, 0, 0, 5857, 5858, 7, 1, 0, 0, 5858, 5859, 7, 6, 0, 0, 5859, 5860, + 7, 17, 0, 0, 5860, 5861, 7, 12, 0, 0, 5861, 5862, 7, 7, 0, 0, 5862, 5863, + 7, 7, 0, 0, 5863, 5864, 7, 12, 0, 0, 5864, 5865, 7, 7, 0, 0, 5865, 5866, + 7, 17, 0, 0, 5866, 216, 1, 0, 0, 0, 5867, 5868, 7, 1, 0, 0, 5868, 5869, + 7, 6, 0, 0, 5869, 5870, 7, 17, 0, 0, 5870, 5871, 7, 12, 0, 0, 5871, 5872, + 7, 7, 0, 0, 5872, 5873, 5, 95, 0, 0, 5873, 5874, 7, 2, 0, 0, 5874, 5875, + 7, 10, 0, 0, 5875, 5876, 7, 4, 0, 0, 5876, 5877, 7, 11, 0, 0, 5877, 5878, + 7, 12, 0, 0, 5878, 5879, 7, 7, 0, 0, 5879, 5880, 7, 6, 0, 0, 5880, 5881, + 5, 95, 0, 0, 5881, 5882, 7, 9, 0, 0, 5882, 5883, 7, 0, 0, 0, 5883, 5884, + 7, 4, 0, 0, 5884, 5885, 7, 0, 0, 0, 5885, 218, 1, 0, 0, 0, 5886, 5887, + 7, 1, 0, 0, 5887, 5888, 7, 6, 0, 0, 5888, 5889, 7, 19, 0, 0, 5889, 5890, + 7, 0, 0, 0, 5890, 5891, 7, 11, 0, 0, 5891, 5892, 7, 16, 0, 0, 5892, 220, + 1, 0, 0, 0, 5893, 5894, 7, 1, 0, 0, 5894, 5895, 7, 6, 0, 0, 5895, 5896, + 7, 24, 0, 0, 5896, 5897, 7, 10, 0, 0, 5897, 5898, 7, 6, 0, 0, 5898, 5899, + 7, 0, 0, 0, 5899, 5900, 7, 4, 0, 0, 5900, 5901, 7, 19, 0, 0, 5901, 222, + 1, 0, 0, 0, 5902, 5903, 7, 1, 0, 0, 5903, 5904, 7, 6, 0, 0, 5904, 5905, + 7, 4, 0, 0, 5905, 5906, 7, 22, 0, 0, 5906, 5907, 7, 6, 0, 0, 5907, 5908, + 7, 6, 0, 0, 5908, 5909, 7, 7, 0, 0, 5909, 224, 1, 0, 0, 0, 5910, 5911, + 7, 1, 0, 0, 5911, 5912, 7, 16, 0, 0, 5912, 5913, 7, 12, 0, 0, 5913, 5914, + 7, 11, 0, 0, 5914, 5915, 7, 6, 0, 0, 5915, 226, 1, 0, 0, 0, 5916, 5917, + 7, 1, 0, 0, 5917, 5918, 7, 16, 0, 0, 5918, 5919, 7, 12, 0, 0, 5919, 5920, + 7, 11, 0, 0, 5920, 5921, 7, 6, 0, 0, 5921, 5922, 7, 7, 0, 0, 5922, 5923, + 7, 0, 0, 0, 5923, 5924, 7, 14, 0, 0, 5924, 5925, 7, 6, 0, 0, 5925, 228, + 1, 0, 0, 0, 5926, 5927, 7, 1, 0, 0, 5927, 5928, 7, 12, 0, 0, 5928, 5929, + 7, 17, 0, 0, 5929, 5930, 7, 16, 0, 0, 5930, 5931, 7, 12, 0, 0, 5931, 5932, + 7, 11, 0, 0, 5932, 5933, 7, 6, 0, 0, 5933, 230, 1, 0, 0, 0, 5934, 5935, + 7, 1, 0, 0, 5935, 5936, 7, 12, 0, 0, 5936, 5937, 7, 7, 0, 0, 5937, 5938, + 7, 0, 0, 0, 5938, 5939, 7, 3, 0, 0, 5939, 5940, 7, 18, 0, 0, 5940, 232, + 1, 0, 0, 0, 5941, 5942, 7, 1, 0, 0, 5942, 5943, 7, 12, 0, 0, 5943, 5944, + 7, 7, 0, 0, 5944, 5945, 7, 0, 0, 0, 5945, 5946, 7, 3, 0, 0, 5946, 5947, + 7, 18, 0, 0, 5947, 5948, 5, 95, 0, 0, 5948, 5949, 7, 9, 0, 0, 5949, 5950, + 7, 2, 0, 0, 5950, 5951, 7, 10, 0, 0, 5951, 5952, 7, 1, 0, 0, 5952, 5953, + 7, 11, 0, 0, 5953, 5954, 7, 6, 0, 0, 5954, 234, 1, 0, 0, 0, 5955, 5956, + 7, 1, 0, 0, 5956, 5957, 7, 12, 0, 0, 5957, 5958, 7, 7, 0, 0, 5958, 5959, + 7, 0, 0, 0, 5959, 5960, 7, 3, 0, 0, 5960, 5961, 7, 18, 0, 0, 5961, 5962, + 5, 95, 0, 0, 5962, 5963, 7, 9, 0, 0, 5963, 5964, 7, 2, 0, 0, 5964, 5965, + 7, 10, 0, 0, 5965, 5966, 7, 1, 0, 0, 5966, 5967, 7, 11, 0, 0, 5967, 5968, + 7, 6, 0, 0, 5968, 5969, 5, 95, 0, 0, 5969, 5970, 7, 12, 0, 0, 5970, 5971, + 7, 7, 0, 0, 5971, 5972, 7, 16, 0, 0, 5972, 5973, 7, 12, 0, 0, 5973, 5974, + 7, 7, 0, 0, 5974, 5975, 7, 12, 0, 0, 5975, 5976, 7, 4, 0, 0, 5976, 5977, + 7, 18, 0, 0, 5977, 236, 1, 0, 0, 0, 5978, 5979, 7, 1, 0, 0, 5979, 5980, + 7, 12, 0, 0, 5980, 5981, 7, 7, 0, 0, 5981, 5982, 7, 0, 0, 0, 5982, 5983, + 7, 3, 0, 0, 5983, 5984, 7, 18, 0, 0, 5984, 5985, 5, 95, 0, 0, 5985, 5986, + 7, 9, 0, 0, 5986, 5987, 7, 2, 0, 0, 5987, 5988, 7, 10, 0, 0, 5988, 5989, + 7, 1, 0, 0, 5989, 5990, 7, 11, 0, 0, 5990, 5991, 7, 6, 0, 0, 5991, 5992, + 5, 95, 0, 0, 5992, 5993, 7, 7, 0, 0, 5993, 5994, 7, 0, 0, 0, 5994, 5995, + 7, 7, 0, 0, 5995, 238, 1, 0, 0, 0, 5996, 5997, 7, 1, 0, 0, 5997, 5998, + 7, 12, 0, 0, 5998, 5999, 7, 7, 0, 0, 5999, 6000, 7, 0, 0, 0, 6000, 6001, + 7, 3, 0, 0, 6001, 6002, 7, 18, 0, 0, 6002, 6003, 5, 95, 0, 0, 6003, 6004, + 7, 16, 0, 0, 6004, 6005, 7, 11, 0, 0, 6005, 6006, 7, 2, 0, 0, 6006, 6007, + 7, 0, 0, 0, 6007, 6008, 7, 4, 0, 0, 6008, 240, 1, 0, 0, 0, 6009, 6010, + 7, 1, 0, 0, 6010, 6011, 7, 12, 0, 0, 6011, 6012, 7, 7, 0, 0, 6012, 6013, + 7, 0, 0, 0, 6013, 6014, 7, 3, 0, 0, 6014, 6015, 7, 18, 0, 0, 6015, 6016, + 5, 95, 0, 0, 6016, 6017, 7, 16, 0, 0, 6017, 6018, 7, 11, 0, 0, 6018, 6019, + 7, 2, 0, 0, 6019, 6020, 7, 0, 0, 0, 6020, 6021, 7, 4, 0, 0, 6021, 6022, + 5, 95, 0, 0, 6022, 6023, 7, 12, 0, 0, 6023, 6024, 7, 7, 0, 0, 6024, 6025, + 7, 16, 0, 0, 6025, 6026, 7, 12, 0, 0, 6026, 6027, 7, 7, 0, 0, 6027, 6028, + 7, 12, 0, 0, 6028, 6029, 7, 4, 0, 0, 6029, 6030, 7, 18, 0, 0, 6030, 242, + 1, 0, 0, 0, 6031, 6032, 7, 1, 0, 0, 6032, 6033, 7, 12, 0, 0, 6033, 6034, + 7, 7, 0, 0, 6034, 6035, 7, 0, 0, 0, 6035, 6036, 7, 3, 0, 0, 6036, 6037, + 7, 18, 0, 0, 6037, 6038, 5, 95, 0, 0, 6038, 6039, 7, 16, 0, 0, 6039, 6040, + 7, 11, 0, 0, 6040, 6041, 7, 2, 0, 0, 6041, 6042, 7, 0, 0, 0, 6042, 6043, + 7, 4, 0, 0, 6043, 6044, 5, 95, 0, 0, 6044, 6045, 7, 7, 0, 0, 6045, 6046, + 7, 0, 0, 0, 6046, 6047, 7, 7, 0, 0, 6047, 244, 1, 0, 0, 0, 6048, 6049, + 7, 1, 0, 0, 6049, 6050, 7, 12, 0, 0, 6050, 6051, 7, 7, 0, 0, 6051, 6052, + 7, 0, 0, 0, 6052, 6053, 7, 3, 0, 0, 6053, 6054, 7, 18, 0, 0, 6054, 6055, + 5, 95, 0, 0, 6055, 6056, 7, 12, 0, 0, 6056, 6057, 7, 7, 0, 0, 6057, 6058, + 7, 4, 0, 0, 6058, 6059, 7, 6, 0, 0, 6059, 6060, 7, 17, 0, 0, 6060, 6061, + 7, 6, 0, 0, 6061, 6062, 7, 3, 0, 0, 6062, 246, 1, 0, 0, 0, 6063, 6064, + 7, 1, 0, 0, 6064, 6065, 7, 12, 0, 0, 6065, 6066, 7, 7, 0, 0, 6066, 6067, + 7, 9, 0, 0, 6067, 6068, 5, 95, 0, 0, 6068, 6069, 7, 0, 0, 0, 6069, 6070, + 7, 22, 0, 0, 6070, 6071, 7, 0, 0, 0, 6071, 6072, 7, 3, 0, 0, 6072, 6073, + 7, 6, 0, 0, 6073, 248, 1, 0, 0, 0, 6074, 6075, 7, 1, 0, 0, 6075, 6076, + 7, 12, 0, 0, 6076, 6077, 7, 7, 0, 0, 6077, 6078, 7, 9, 0, 0, 6078, 6079, + 7, 12, 0, 0, 6079, 6080, 7, 7, 0, 0, 6080, 6081, 7, 17, 0, 0, 6081, 250, + 1, 0, 0, 0, 6082, 6083, 7, 1, 0, 0, 6083, 6084, 7, 12, 0, 0, 6084, 6085, + 7, 7, 0, 0, 6085, 6086, 5, 95, 0, 0, 6086, 6087, 7, 4, 0, 0, 6087, 6088, + 7, 2, 0, 0, 6088, 6089, 5, 95, 0, 0, 6089, 6090, 7, 7, 0, 0, 6090, 6091, + 7, 10, 0, 0, 6091, 6092, 7, 14, 0, 0, 6092, 252, 1, 0, 0, 0, 6093, 6094, + 7, 1, 0, 0, 6094, 6095, 7, 12, 0, 0, 6095, 6096, 7, 4, 0, 0, 6096, 6097, + 7, 0, 0, 0, 6097, 6098, 7, 7, 0, 0, 6098, 6099, 7, 9, 0, 0, 6099, 254, + 1, 0, 0, 0, 6100, 6101, 7, 1, 0, 0, 6101, 6102, 7, 12, 0, 0, 6102, 6103, + 7, 4, 0, 0, 6103, 6104, 7, 14, 0, 0, 6104, 6105, 7, 0, 0, 0, 6105, 6106, + 7, 15, 0, 0, 6106, 6107, 5, 95, 0, 0, 6107, 6108, 7, 0, 0, 0, 6108, 6109, + 7, 7, 0, 0, 6109, 6110, 7, 9, 0, 0, 6110, 256, 1, 0, 0, 0, 6111, 6112, + 7, 1, 0, 0, 6112, 6113, 7, 12, 0, 0, 6113, 6114, 7, 4, 0, 0, 6114, 6115, + 7, 14, 0, 0, 6115, 6116, 7, 0, 0, 0, 6116, 6117, 7, 15, 0, 0, 6117, 258, + 1, 0, 0, 0, 6118, 6119, 7, 1, 0, 0, 6119, 6120, 7, 12, 0, 0, 6120, 6121, + 7, 4, 0, 0, 6121, 6122, 7, 14, 0, 0, 6122, 6123, 7, 0, 0, 0, 6123, 6124, + 7, 15, 0, 0, 6124, 6125, 7, 5, 0, 0, 6125, 260, 1, 0, 0, 0, 6126, 6127, + 7, 1, 0, 0, 6127, 6128, 7, 12, 0, 0, 6128, 6129, 7, 4, 0, 0, 6129, 6130, + 7, 14, 0, 0, 6130, 6131, 7, 0, 0, 0, 6131, 6132, 7, 15, 0, 0, 6132, 6133, + 5, 95, 0, 0, 6133, 6134, 7, 4, 0, 0, 6134, 6135, 7, 3, 0, 0, 6135, 6136, + 7, 6, 0, 0, 6136, 6137, 7, 6, 0, 0, 6137, 262, 1, 0, 0, 0, 6138, 6139, + 7, 1, 0, 0, 6139, 6140, 7, 12, 0, 0, 6140, 6141, 7, 4, 0, 0, 6141, 6142, + 7, 5, 0, 0, 6142, 264, 1, 0, 0, 0, 6143, 6144, 7, 1, 0, 0, 6144, 6145, + 7, 11, 0, 0, 6145, 6146, 7, 2, 0, 0, 6146, 6147, 7, 1, 0, 0, 6147, 266, + 1, 0, 0, 0, 6148, 6149, 7, 1, 0, 0, 6149, 6150, 7, 11, 0, 0, 6150, 6151, + 7, 2, 0, 0, 6151, 6152, 7, 8, 0, 0, 6152, 6153, 7, 21, 0, 0, 6153, 268, + 1, 0, 0, 0, 6154, 6155, 7, 1, 0, 0, 6155, 6156, 7, 11, 0, 0, 6156, 6157, + 7, 2, 0, 0, 6157, 6158, 7, 8, 0, 0, 6158, 6159, 7, 21, 0, 0, 6159, 6160, + 5, 95, 0, 0, 6160, 6161, 7, 3, 0, 0, 6161, 6162, 7, 0, 0, 0, 6162, 6163, + 7, 7, 0, 0, 6163, 6164, 7, 17, 0, 0, 6164, 6165, 7, 6, 0, 0, 6165, 270, + 1, 0, 0, 0, 6166, 6167, 7, 1, 0, 0, 6167, 6168, 7, 11, 0, 0, 6168, 6169, + 7, 2, 0, 0, 6169, 6170, 7, 8, 0, 0, 6170, 6171, 7, 21, 0, 0, 6171, 6172, + 7, 5, 0, 0, 6172, 272, 1, 0, 0, 0, 6173, 6174, 7, 1, 0, 0, 6174, 6175, + 7, 11, 0, 0, 6175, 6176, 7, 2, 0, 0, 6176, 6177, 7, 8, 0, 0, 6177, 6178, + 7, 21, 0, 0, 6178, 6179, 7, 5, 0, 0, 6179, 6180, 7, 12, 0, 0, 6180, 6181, + 7, 23, 0, 0, 6181, 6182, 7, 6, 0, 0, 6182, 274, 1, 0, 0, 0, 6183, 6184, + 7, 1, 0, 0, 6184, 6185, 7, 2, 0, 0, 6185, 6186, 7, 9, 0, 0, 6186, 6187, + 7, 18, 0, 0, 6187, 276, 1, 0, 0, 0, 6188, 6189, 7, 1, 0, 0, 6189, 6190, + 7, 2, 0, 0, 6190, 6191, 7, 2, 0, 0, 6191, 6192, 7, 11, 0, 0, 6192, 6193, + 7, 6, 0, 0, 6193, 6194, 7, 0, 0, 0, 6194, 6195, 7, 7, 0, 0, 6195, 278, + 1, 0, 0, 0, 6196, 6197, 7, 1, 0, 0, 6197, 6198, 7, 2, 0, 0, 6198, 6199, + 7, 4, 0, 0, 6199, 6200, 7, 19, 0, 0, 6200, 280, 1, 0, 0, 0, 6201, 6202, + 7, 1, 0, 0, 6202, 6203, 7, 2, 0, 0, 6203, 6204, 7, 10, 0, 0, 6204, 6205, + 7, 7, 0, 0, 6205, 6206, 7, 9, 0, 0, 6206, 282, 1, 0, 0, 0, 6207, 6208, + 7, 1, 0, 0, 6208, 6209, 7, 3, 0, 0, 6209, 6210, 7, 0, 0, 0, 6210, 6211, + 7, 7, 0, 0, 6211, 6212, 7, 8, 0, 0, 6212, 6213, 7, 19, 0, 0, 6213, 284, + 1, 0, 0, 0, 6214, 6215, 7, 1, 0, 0, 6215, 6216, 7, 3, 0, 0, 6216, 6217, + 7, 6, 0, 0, 6217, 6218, 7, 0, 0, 0, 6218, 6219, 7, 9, 0, 0, 6219, 6220, + 7, 4, 0, 0, 6220, 6221, 7, 19, 0, 0, 6221, 286, 1, 0, 0, 0, 6222, 6223, + 7, 1, 0, 0, 6223, 6224, 7, 3, 0, 0, 6224, 6225, 7, 2, 0, 0, 6225, 6226, + 7, 0, 0, 0, 6226, 6227, 7, 9, 0, 0, 6227, 6228, 7, 8, 0, 0, 6228, 6229, + 7, 0, 0, 0, 6229, 6230, 7, 5, 0, 0, 6230, 6231, 7, 4, 0, 0, 6231, 288, + 1, 0, 0, 0, 6232, 6233, 7, 1, 0, 0, 6233, 6234, 7, 5, 0, 0, 6234, 6235, + 7, 2, 0, 0, 6235, 6236, 7, 7, 0, 0, 6236, 290, 1, 0, 0, 0, 6237, 6238, + 7, 1, 0, 0, 6238, 6239, 7, 10, 0, 0, 6239, 6240, 7, 16, 0, 0, 6240, 6241, + 7, 16, 0, 0, 6241, 6242, 7, 6, 0, 0, 6242, 6243, 7, 3, 0, 0, 6243, 292, + 1, 0, 0, 0, 6244, 6245, 7, 1, 0, 0, 6245, 6246, 7, 10, 0, 0, 6246, 6247, + 7, 16, 0, 0, 6247, 6248, 7, 16, 0, 0, 6248, 6249, 7, 6, 0, 0, 6249, 6250, + 7, 3, 0, 0, 6250, 6251, 5, 95, 0, 0, 6251, 6252, 7, 8, 0, 0, 6252, 6253, + 7, 0, 0, 0, 6253, 6254, 7, 8, 0, 0, 6254, 6255, 7, 19, 0, 0, 6255, 6256, + 7, 6, 0, 0, 6256, 294, 1, 0, 0, 0, 6257, 6258, 7, 1, 0, 0, 6258, 6259, + 7, 10, 0, 0, 6259, 6260, 7, 16, 0, 0, 6260, 6261, 7, 16, 0, 0, 6261, 6262, + 7, 6, 0, 0, 6262, 6263, 7, 3, 0, 0, 6263, 6264, 5, 95, 0, 0, 6264, 6265, + 7, 15, 0, 0, 6265, 6266, 7, 2, 0, 0, 6266, 6267, 7, 2, 0, 0, 6267, 6268, + 7, 11, 0, 0, 6268, 296, 1, 0, 0, 0, 6269, 6270, 7, 1, 0, 0, 6270, 6271, + 7, 10, 0, 0, 6271, 6272, 7, 12, 0, 0, 6272, 6273, 7, 11, 0, 0, 6273, 6274, + 7, 9, 0, 0, 6274, 298, 1, 0, 0, 0, 6275, 6276, 7, 1, 0, 0, 6276, 6277, + 7, 10, 0, 0, 6277, 6278, 7, 11, 0, 0, 6278, 6279, 7, 21, 0, 0, 6279, 300, + 1, 0, 0, 0, 6280, 6281, 7, 1, 0, 0, 6281, 6282, 7, 18, 0, 0, 6282, 302, + 1, 0, 0, 0, 6283, 6284, 7, 1, 0, 0, 6284, 6285, 7, 18, 0, 0, 6285, 6286, + 7, 15, 0, 0, 6286, 6287, 7, 0, 0, 0, 6287, 6288, 7, 5, 0, 0, 6288, 6289, + 7, 5, 0, 0, 6289, 6290, 5, 95, 0, 0, 6290, 6291, 7, 3, 0, 0, 6291, 6292, + 7, 6, 0, 0, 6292, 6293, 7, 8, 0, 0, 6293, 6294, 7, 10, 0, 0, 6294, 6295, + 7, 3, 0, 0, 6295, 6296, 7, 5, 0, 0, 6296, 6297, 7, 12, 0, 0, 6297, 6298, + 7, 13, 0, 0, 6298, 6299, 7, 6, 0, 0, 6299, 6300, 5, 95, 0, 0, 6300, 6301, + 7, 8, 0, 0, 6301, 6302, 7, 19, 0, 0, 6302, 6303, 7, 6, 0, 0, 6303, 6304, + 7, 8, 0, 0, 6304, 6305, 7, 21, 0, 0, 6305, 304, 1, 0, 0, 0, 6306, 6307, + 7, 1, 0, 0, 6307, 6308, 7, 18, 0, 0, 6308, 6309, 7, 15, 0, 0, 6309, 6310, + 7, 0, 0, 0, 6310, 6311, 7, 5, 0, 0, 6311, 6312, 7, 5, 0, 0, 6312, 6313, + 5, 95, 0, 0, 6313, 6314, 7, 10, 0, 0, 6314, 6315, 7, 20, 0, 0, 6315, 6316, + 7, 13, 0, 0, 6316, 6317, 7, 8, 0, 0, 6317, 306, 1, 0, 0, 0, 6318, 6319, + 7, 1, 0, 0, 6319, 6320, 7, 18, 0, 0, 6320, 6321, 7, 4, 0, 0, 6321, 6322, + 7, 6, 0, 0, 6322, 308, 1, 0, 0, 0, 6323, 6324, 7, 8, 0, 0, 6324, 6325, + 7, 0, 0, 0, 6325, 6326, 7, 8, 0, 0, 6326, 6327, 7, 19, 0, 0, 6327, 6328, + 7, 6, 0, 0, 6328, 310, 1, 0, 0, 0, 6329, 6330, 7, 8, 0, 0, 6330, 6331, + 7, 0, 0, 0, 6331, 6332, 7, 8, 0, 0, 6332, 6333, 7, 19, 0, 0, 6333, 6334, + 7, 6, 0, 0, 6334, 6335, 5, 95, 0, 0, 6335, 6336, 7, 8, 0, 0, 6336, 6337, + 7, 1, 0, 0, 6337, 312, 1, 0, 0, 0, 6338, 6339, 7, 8, 0, 0, 6339, 6340, + 7, 0, 0, 0, 6340, 6341, 7, 8, 0, 0, 6341, 6342, 7, 19, 0, 0, 6342, 6343, + 7, 6, 0, 0, 6343, 6344, 5, 95, 0, 0, 6344, 6345, 7, 12, 0, 0, 6345, 6346, + 7, 7, 0, 0, 6346, 6347, 7, 5, 0, 0, 6347, 6348, 7, 4, 0, 0, 6348, 6349, + 7, 0, 0, 0, 6349, 6350, 7, 7, 0, 0, 6350, 6351, 7, 8, 0, 0, 6351, 6352, + 7, 6, 0, 0, 6352, 6353, 7, 5, 0, 0, 6353, 314, 1, 0, 0, 0, 6354, 6355, + 7, 8, 0, 0, 6355, 6356, 7, 0, 0, 0, 6356, 6357, 7, 8, 0, 0, 6357, 6358, + 7, 19, 0, 0, 6358, 6359, 7, 6, 0, 0, 6359, 6360, 5, 95, 0, 0, 6360, 6361, + 7, 4, 0, 0, 6361, 6362, 7, 6, 0, 0, 6362, 6363, 7, 14, 0, 0, 6363, 6364, + 7, 15, 0, 0, 6364, 6365, 5, 95, 0, 0, 6365, 6366, 7, 4, 0, 0, 6366, 6367, + 7, 0, 0, 0, 6367, 6368, 7, 1, 0, 0, 6368, 6369, 7, 11, 0, 0, 6369, 6370, + 7, 6, 0, 0, 6370, 316, 1, 0, 0, 0, 6371, 6372, 7, 8, 0, 0, 6372, 6373, + 7, 0, 0, 0, 6373, 6374, 7, 8, 0, 0, 6374, 6375, 7, 19, 0, 0, 6375, 6376, + 7, 12, 0, 0, 6376, 6377, 7, 7, 0, 0, 6377, 6378, 7, 17, 0, 0, 6378, 318, + 1, 0, 0, 0, 6379, 6380, 7, 8, 0, 0, 6380, 6381, 7, 0, 0, 0, 6381, 6382, + 7, 11, 0, 0, 6382, 6383, 7, 8, 0, 0, 6383, 6384, 7, 10, 0, 0, 6384, 6385, + 7, 11, 0, 0, 6385, 6386, 7, 0, 0, 0, 6386, 6387, 7, 4, 0, 0, 6387, 6388, + 7, 6, 0, 0, 6388, 6389, 7, 9, 0, 0, 6389, 320, 1, 0, 0, 0, 6390, 6391, + 7, 8, 0, 0, 6391, 6392, 7, 0, 0, 0, 6392, 6393, 7, 11, 0, 0, 6393, 6394, + 7, 11, 0, 0, 6394, 6395, 7, 1, 0, 0, 6395, 6396, 7, 0, 0, 0, 6396, 6397, + 7, 8, 0, 0, 6397, 6398, 7, 21, 0, 0, 6398, 322, 1, 0, 0, 0, 6399, 6400, + 7, 8, 0, 0, 6400, 6401, 7, 0, 0, 0, 6401, 6402, 7, 11, 0, 0, 6402, 6403, + 7, 11, 0, 0, 6403, 324, 1, 0, 0, 0, 6404, 6405, 7, 8, 0, 0, 6405, 6406, + 7, 0, 0, 0, 6406, 6407, 7, 7, 0, 0, 6407, 6408, 7, 8, 0, 0, 6408, 6409, + 7, 6, 0, 0, 6409, 6410, 7, 11, 0, 0, 6410, 326, 1, 0, 0, 0, 6411, 6412, + 7, 8, 0, 0, 6412, 6413, 7, 0, 0, 0, 6413, 6414, 7, 7, 0, 0, 6414, 6415, + 7, 2, 0, 0, 6415, 6416, 7, 7, 0, 0, 6416, 6417, 7, 12, 0, 0, 6417, 6418, + 7, 8, 0, 0, 6418, 6419, 7, 0, 0, 0, 6419, 6420, 7, 11, 0, 0, 6420, 328, + 1, 0, 0, 0, 6421, 6422, 7, 8, 0, 0, 6422, 6423, 7, 0, 0, 0, 6423, 6424, + 7, 15, 0, 0, 6424, 6425, 7, 0, 0, 0, 6425, 6426, 7, 8, 0, 0, 6426, 6427, + 7, 12, 0, 0, 6427, 6428, 7, 4, 0, 0, 6428, 6429, 7, 18, 0, 0, 6429, 330, + 1, 0, 0, 0, 6430, 6431, 7, 8, 0, 0, 6431, 6432, 7, 0, 0, 0, 6432, 6433, + 7, 15, 0, 0, 6433, 6434, 7, 4, 0, 0, 6434, 6435, 7, 12, 0, 0, 6435, 6436, + 7, 2, 0, 0, 6436, 6437, 7, 7, 0, 0, 6437, 332, 1, 0, 0, 0, 6438, 6439, + 7, 8, 0, 0, 6439, 6440, 7, 0, 0, 0, 6440, 6441, 7, 3, 0, 0, 6441, 6442, + 7, 9, 0, 0, 6442, 6443, 7, 12, 0, 0, 6443, 6444, 7, 7, 0, 0, 6444, 6445, + 7, 0, 0, 0, 6445, 6446, 7, 11, 0, 0, 6446, 6447, 7, 12, 0, 0, 6447, 6448, + 7, 4, 0, 0, 6448, 6449, 7, 18, 0, 0, 6449, 334, 1, 0, 0, 0, 6450, 6451, + 7, 8, 0, 0, 6451, 6452, 7, 0, 0, 0, 6452, 6453, 7, 5, 0, 0, 6453, 6454, + 7, 8, 0, 0, 6454, 6455, 7, 0, 0, 0, 6455, 6456, 7, 9, 0, 0, 6456, 6457, + 7, 6, 0, 0, 6457, 336, 1, 0, 0, 0, 6458, 6459, 7, 8, 0, 0, 6459, 6460, + 7, 0, 0, 0, 6460, 6461, 7, 5, 0, 0, 6461, 6462, 7, 6, 0, 0, 6462, 338, + 1, 0, 0, 0, 6463, 6464, 7, 8, 0, 0, 6464, 6465, 7, 0, 0, 0, 6465, 6466, + 7, 5, 0, 0, 6466, 6467, 7, 4, 0, 0, 6467, 340, 1, 0, 0, 0, 6468, 6469, + 7, 8, 0, 0, 6469, 6470, 7, 0, 0, 0, 6470, 6471, 7, 5, 0, 0, 6471, 6472, + 7, 6, 0, 0, 6472, 6473, 5, 45, 0, 0, 6473, 6474, 7, 5, 0, 0, 6474, 6475, + 7, 6, 0, 0, 6475, 6476, 7, 7, 0, 0, 6476, 6477, 7, 5, 0, 0, 6477, 6478, + 7, 12, 0, 0, 6478, 6479, 7, 4, 0, 0, 6479, 6480, 7, 12, 0, 0, 6480, 6481, + 7, 13, 0, 0, 6481, 6482, 7, 6, 0, 0, 6482, 342, 1, 0, 0, 0, 6483, 6484, + 7, 8, 0, 0, 6484, 6485, 7, 0, 0, 0, 6485, 6486, 7, 4, 0, 0, 6486, 6487, + 7, 6, 0, 0, 6487, 6488, 7, 17, 0, 0, 6488, 6489, 7, 2, 0, 0, 6489, 6490, + 7, 3, 0, 0, 6490, 6491, 7, 18, 0, 0, 6491, 344, 1, 0, 0, 0, 6492, 6493, + 7, 8, 0, 0, 6493, 6494, 7, 9, 0, 0, 6494, 6495, 7, 1, 0, 0, 6495, 6496, + 5, 36, 0, 0, 6496, 6497, 7, 9, 0, 0, 6497, 6498, 7, 6, 0, 0, 6498, 6499, + 7, 16, 0, 0, 6499, 6500, 7, 0, 0, 0, 6500, 6501, 7, 10, 0, 0, 6501, 6502, + 7, 11, 0, 0, 6502, 6503, 7, 4, 0, 0, 6503, 346, 1, 0, 0, 0, 6504, 6505, + 7, 8, 0, 0, 6505, 6506, 7, 6, 0, 0, 6506, 6507, 7, 12, 0, 0, 6507, 6508, + 7, 11, 0, 0, 6508, 348, 1, 0, 0, 0, 6509, 6510, 7, 8, 0, 0, 6510, 6511, + 7, 6, 0, 0, 6511, 6512, 7, 11, 0, 0, 6512, 6513, 7, 11, 0, 0, 6513, 6514, + 5, 95, 0, 0, 6514, 6515, 7, 16, 0, 0, 6515, 6516, 7, 11, 0, 0, 6516, 6517, + 7, 0, 0, 0, 6517, 6518, 7, 5, 0, 0, 6518, 6519, 7, 19, 0, 0, 6519, 6520, + 5, 95, 0, 0, 6520, 6521, 7, 8, 0, 0, 6521, 6522, 7, 0, 0, 0, 6522, 6523, + 7, 8, 0, 0, 6523, 6524, 7, 19, 0, 0, 6524, 6525, 7, 6, 0, 0, 6525, 350, + 1, 0, 0, 0, 6526, 6527, 7, 8, 0, 0, 6527, 6528, 7, 6, 0, 0, 6528, 6529, + 7, 3, 0, 0, 6529, 6530, 7, 4, 0, 0, 6530, 6531, 7, 12, 0, 0, 6531, 6532, + 7, 16, 0, 0, 6532, 6533, 7, 12, 0, 0, 6533, 6534, 7, 8, 0, 0, 6534, 6535, + 7, 0, 0, 0, 6535, 6536, 7, 4, 0, 0, 6536, 6537, 7, 6, 0, 0, 6537, 352, + 1, 0, 0, 0, 6538, 6539, 7, 8, 0, 0, 6539, 6540, 7, 16, 0, 0, 6540, 6541, + 7, 12, 0, 0, 6541, 6542, 7, 11, 0, 0, 6542, 6543, 7, 6, 0, 0, 6543, 354, + 1, 0, 0, 0, 6544, 6545, 7, 8, 0, 0, 6545, 6546, 7, 19, 0, 0, 6546, 6547, + 7, 0, 0, 0, 6547, 6548, 7, 12, 0, 0, 6548, 6549, 7, 7, 0, 0, 6549, 6550, + 7, 6, 0, 0, 6550, 6551, 7, 9, 0, 0, 6551, 356, 1, 0, 0, 0, 6552, 6553, + 7, 8, 0, 0, 6553, 6554, 7, 19, 0, 0, 6554, 6555, 7, 0, 0, 0, 6555, 6556, + 7, 7, 0, 0, 6556, 6557, 7, 17, 0, 0, 6557, 6558, 7, 6, 0, 0, 6558, 358, + 1, 0, 0, 0, 6559, 6560, 7, 8, 0, 0, 6560, 6561, 7, 19, 0, 0, 6561, 6562, + 7, 0, 0, 0, 6562, 6563, 7, 7, 0, 0, 6563, 6564, 7, 17, 0, 0, 6564, 6565, + 7, 6, 0, 0, 6565, 6566, 5, 95, 0, 0, 6566, 6567, 7, 9, 0, 0, 6567, 6568, + 7, 10, 0, 0, 6568, 6569, 7, 15, 0, 0, 6569, 6570, 7, 21, 0, 0, 6570, 6571, + 7, 6, 0, 0, 6571, 6572, 7, 18, 0, 0, 6572, 6573, 5, 95, 0, 0, 6573, 6574, + 7, 6, 0, 0, 6574, 6575, 7, 3, 0, 0, 6575, 6576, 7, 3, 0, 0, 6576, 6577, + 7, 2, 0, 0, 6577, 6578, 7, 3, 0, 0, 6578, 6579, 5, 95, 0, 0, 6579, 6580, + 7, 12, 0, 0, 6580, 6581, 7, 7, 0, 0, 6581, 6582, 7, 9, 0, 0, 6582, 6583, + 7, 6, 0, 0, 6583, 6584, 7, 25, 0, 0, 6584, 360, 1, 0, 0, 0, 6585, 6586, + 7, 8, 0, 0, 6586, 6587, 7, 19, 0, 0, 6587, 6588, 7, 0, 0, 0, 6588, 6589, + 7, 3, 0, 0, 6589, 6590, 7, 0, 0, 0, 6590, 6591, 7, 8, 0, 0, 6591, 6592, + 7, 4, 0, 0, 6592, 6593, 7, 6, 0, 0, 6593, 6594, 7, 3, 0, 0, 6594, 362, + 1, 0, 0, 0, 6595, 6596, 7, 8, 0, 0, 6596, 6597, 7, 19, 0, 0, 6597, 6598, + 7, 0, 0, 0, 6598, 6599, 7, 3, 0, 0, 6599, 364, 1, 0, 0, 0, 6600, 6601, + 7, 8, 0, 0, 6601, 6602, 7, 19, 0, 0, 6602, 6603, 7, 0, 0, 0, 6603, 6604, + 7, 3, 0, 0, 6604, 6605, 5, 95, 0, 0, 6605, 6606, 7, 8, 0, 0, 6606, 6607, + 7, 5, 0, 0, 6607, 366, 1, 0, 0, 0, 6608, 6609, 7, 8, 0, 0, 6609, 6610, + 7, 19, 0, 0, 6610, 6611, 7, 0, 0, 0, 6611, 6612, 7, 3, 0, 0, 6612, 6613, + 7, 4, 0, 0, 6613, 6614, 7, 2, 0, 0, 6614, 6615, 7, 3, 0, 0, 6615, 6616, + 7, 2, 0, 0, 6616, 6617, 7, 22, 0, 0, 6617, 6618, 7, 12, 0, 0, 6618, 6619, + 7, 9, 0, 0, 6619, 368, 1, 0, 0, 0, 6620, 6621, 7, 8, 0, 0, 6621, 6622, + 7, 19, 0, 0, 6622, 6623, 7, 6, 0, 0, 6623, 6624, 7, 8, 0, 0, 6624, 6625, + 7, 21, 0, 0, 6625, 6626, 5, 95, 0, 0, 6626, 6627, 7, 0, 0, 0, 6627, 6628, + 7, 8, 0, 0, 6628, 6629, 7, 11, 0, 0, 6629, 6630, 5, 95, 0, 0, 6630, 6631, + 7, 3, 0, 0, 6631, 6632, 7, 6, 0, 0, 6632, 6633, 7, 22, 0, 0, 6633, 6634, + 7, 3, 0, 0, 6634, 6635, 7, 12, 0, 0, 6635, 6636, 7, 4, 0, 0, 6636, 6637, + 7, 6, 0, 0, 6637, 370, 1, 0, 0, 0, 6638, 6639, 7, 8, 0, 0, 6639, 6640, + 7, 19, 0, 0, 6640, 6641, 7, 6, 0, 0, 6641, 6642, 7, 8, 0, 0, 6642, 6643, + 7, 21, 0, 0, 6643, 372, 1, 0, 0, 0, 6644, 6645, 7, 8, 0, 0, 6645, 6646, + 7, 19, 0, 0, 6646, 6647, 7, 6, 0, 0, 6647, 6648, 7, 8, 0, 0, 6648, 6649, + 7, 21, 0, 0, 6649, 6650, 7, 15, 0, 0, 6650, 6651, 7, 2, 0, 0, 6651, 6652, + 7, 12, 0, 0, 6652, 6653, 7, 7, 0, 0, 6653, 6654, 7, 4, 0, 0, 6654, 374, + 1, 0, 0, 0, 6655, 6656, 7, 8, 0, 0, 6656, 6657, 7, 19, 0, 0, 6657, 6658, + 7, 12, 0, 0, 6658, 6659, 7, 11, 0, 0, 6659, 6660, 7, 9, 0, 0, 6660, 376, + 1, 0, 0, 0, 6661, 6662, 7, 8, 0, 0, 6662, 6663, 7, 19, 0, 0, 6663, 6664, + 7, 2, 0, 0, 6664, 6665, 7, 2, 0, 0, 6665, 6666, 7, 5, 0, 0, 6666, 6667, + 7, 6, 0, 0, 6667, 378, 1, 0, 0, 0, 6668, 6669, 7, 8, 0, 0, 6669, 6670, + 7, 19, 0, 0, 6670, 6671, 7, 3, 0, 0, 6671, 380, 1, 0, 0, 0, 6672, 6673, + 7, 8, 0, 0, 6673, 6674, 7, 19, 0, 0, 6674, 6675, 7, 10, 0, 0, 6675, 6676, + 7, 7, 0, 0, 6676, 6677, 7, 21, 0, 0, 6677, 382, 1, 0, 0, 0, 6678, 6679, + 7, 8, 0, 0, 6679, 6680, 7, 11, 0, 0, 6680, 6681, 7, 0, 0, 0, 6681, 6682, + 7, 5, 0, 0, 6682, 6683, 7, 5, 0, 0, 6683, 384, 1, 0, 0, 0, 6684, 6685, + 7, 8, 0, 0, 6685, 6686, 7, 11, 0, 0, 6686, 6687, 7, 0, 0, 0, 6687, 6688, + 7, 5, 0, 0, 6688, 6689, 7, 5, 0, 0, 6689, 6690, 7, 12, 0, 0, 6690, 6691, + 7, 16, 0, 0, 6691, 6692, 7, 12, 0, 0, 6692, 6693, 7, 8, 0, 0, 6693, 6694, + 7, 0, 0, 0, 6694, 6695, 7, 4, 0, 0, 6695, 6696, 7, 12, 0, 0, 6696, 6697, + 7, 2, 0, 0, 6697, 6698, 7, 7, 0, 0, 6698, 386, 1, 0, 0, 0, 6699, 6700, + 7, 8, 0, 0, 6700, 6701, 7, 11, 0, 0, 6701, 6702, 7, 0, 0, 0, 6702, 6703, + 7, 5, 0, 0, 6703, 6704, 7, 5, 0, 0, 6704, 6705, 7, 12, 0, 0, 6705, 6706, + 7, 16, 0, 0, 6706, 6707, 7, 12, 0, 0, 6707, 6708, 7, 6, 0, 0, 6708, 6709, + 7, 3, 0, 0, 6709, 388, 1, 0, 0, 0, 6710, 6711, 7, 8, 0, 0, 6711, 6712, + 7, 11, 0, 0, 6712, 6713, 7, 0, 0, 0, 6713, 6714, 7, 10, 0, 0, 6714, 6715, + 7, 5, 0, 0, 6715, 6716, 7, 6, 0, 0, 6716, 390, 1, 0, 0, 0, 6717, 6718, + 7, 8, 0, 0, 6718, 6719, 7, 11, 0, 0, 6719, 6720, 7, 6, 0, 0, 6720, 6721, + 7, 0, 0, 0, 6721, 6722, 7, 7, 0, 0, 6722, 392, 1, 0, 0, 0, 6723, 6724, + 7, 8, 0, 0, 6724, 6725, 7, 11, 0, 0, 6725, 6726, 7, 6, 0, 0, 6726, 6727, + 7, 0, 0, 0, 6727, 6728, 7, 7, 0, 0, 6728, 6729, 7, 10, 0, 0, 6729, 6730, + 7, 15, 0, 0, 6730, 394, 1, 0, 0, 0, 6731, 6732, 7, 8, 0, 0, 6732, 6733, + 7, 11, 0, 0, 6733, 6734, 7, 6, 0, 0, 6734, 6735, 7, 0, 0, 0, 6735, 6736, + 7, 3, 0, 0, 6736, 396, 1, 0, 0, 0, 6737, 6738, 7, 8, 0, 0, 6738, 398, 1, + 0, 0, 0, 6739, 6740, 7, 8, 0, 0, 6740, 6741, 7, 11, 0, 0, 6741, 6742, 7, + 12, 0, 0, 6742, 6743, 7, 6, 0, 0, 6743, 6744, 7, 7, 0, 0, 6744, 6745, 7, + 4, 0, 0, 6745, 400, 1, 0, 0, 0, 6746, 6747, 7, 8, 0, 0, 6747, 6748, 7, + 11, 0, 0, 6748, 6749, 7, 2, 0, 0, 6749, 6750, 7, 1, 0, 0, 6750, 402, 1, + 0, 0, 0, 6751, 6752, 7, 8, 0, 0, 6752, 6753, 7, 11, 0, 0, 6753, 6754, 7, + 2, 0, 0, 6754, 6755, 7, 7, 0, 0, 6755, 6756, 7, 6, 0, 0, 6756, 404, 1, + 0, 0, 0, 6757, 6758, 7, 8, 0, 0, 6758, 6759, 7, 11, 0, 0, 6759, 6760, 7, + 2, 0, 0, 6760, 6761, 7, 5, 0, 0, 6761, 6762, 7, 6, 0, 0, 6762, 6763, 5, + 95, 0, 0, 6763, 6764, 7, 8, 0, 0, 6764, 6765, 7, 0, 0, 0, 6765, 6766, 7, + 8, 0, 0, 6766, 6767, 7, 19, 0, 0, 6767, 6768, 7, 6, 0, 0, 6768, 6769, 7, + 9, 0, 0, 6769, 6770, 5, 95, 0, 0, 6770, 6771, 7, 2, 0, 0, 6771, 6772, 7, + 15, 0, 0, 6772, 6773, 7, 6, 0, 0, 6773, 6774, 7, 7, 0, 0, 6774, 6775, 5, + 95, 0, 0, 6775, 6776, 7, 8, 0, 0, 6776, 6777, 7, 10, 0, 0, 6777, 6778, + 7, 3, 0, 0, 6778, 6779, 7, 5, 0, 0, 6779, 6780, 7, 2, 0, 0, 6780, 6781, + 7, 3, 0, 0, 6781, 6782, 7, 5, 0, 0, 6782, 406, 1, 0, 0, 0, 6783, 6784, + 7, 8, 0, 0, 6784, 6785, 7, 11, 0, 0, 6785, 6786, 7, 2, 0, 0, 6786, 6787, + 7, 5, 0, 0, 6787, 6788, 7, 6, 0, 0, 6788, 408, 1, 0, 0, 0, 6789, 6790, + 7, 8, 0, 0, 6790, 6791, 7, 11, 0, 0, 6791, 6792, 7, 10, 0, 0, 6792, 6793, + 7, 5, 0, 0, 6793, 6794, 7, 4, 0, 0, 6794, 6795, 7, 6, 0, 0, 6795, 6796, + 7, 3, 0, 0, 6796, 6797, 5, 95, 0, 0, 6797, 6798, 7, 1, 0, 0, 6798, 6799, + 7, 18, 0, 0, 6799, 6800, 5, 95, 0, 0, 6800, 6801, 7, 3, 0, 0, 6801, 6802, + 7, 2, 0, 0, 6802, 6803, 7, 22, 0, 0, 6803, 6804, 7, 12, 0, 0, 6804, 6805, + 7, 9, 0, 0, 6805, 410, 1, 0, 0, 0, 6806, 6807, 7, 8, 0, 0, 6807, 6808, + 7, 11, 0, 0, 6808, 6809, 7, 10, 0, 0, 6809, 6810, 7, 5, 0, 0, 6810, 6811, + 7, 4, 0, 0, 6811, 6812, 7, 6, 0, 0, 6812, 6813, 7, 3, 0, 0, 6813, 412, + 1, 0, 0, 0, 6814, 6815, 7, 8, 0, 0, 6815, 6816, 7, 11, 0, 0, 6816, 6817, + 7, 10, 0, 0, 6817, 6818, 7, 5, 0, 0, 6818, 6819, 7, 4, 0, 0, 6819, 6820, + 7, 6, 0, 0, 6820, 6821, 7, 3, 0, 0, 6821, 6822, 5, 95, 0, 0, 6822, 6823, + 7, 9, 0, 0, 6823, 6824, 7, 6, 0, 0, 6824, 6825, 7, 4, 0, 0, 6825, 6826, + 7, 0, 0, 0, 6826, 6827, 7, 12, 0, 0, 6827, 6828, 7, 11, 0, 0, 6828, 6829, + 7, 5, 0, 0, 6829, 414, 1, 0, 0, 0, 6830, 6831, 7, 8, 0, 0, 6831, 6832, + 7, 11, 0, 0, 6832, 6833, 7, 10, 0, 0, 6833, 6834, 7, 5, 0, 0, 6834, 6835, + 7, 4, 0, 0, 6835, 6836, 7, 6, 0, 0, 6836, 6837, 7, 3, 0, 0, 6837, 6838, + 5, 95, 0, 0, 6838, 6839, 7, 9, 0, 0, 6839, 6840, 7, 12, 0, 0, 6840, 6841, + 7, 5, 0, 0, 6841, 6842, 7, 4, 0, 0, 6842, 6843, 7, 0, 0, 0, 6843, 6844, + 7, 7, 0, 0, 6844, 6845, 7, 8, 0, 0, 6845, 6846, 7, 6, 0, 0, 6846, 416, + 1, 0, 0, 0, 6847, 6848, 7, 8, 0, 0, 6848, 6849, 7, 11, 0, 0, 6849, 6850, + 7, 10, 0, 0, 6850, 6851, 7, 5, 0, 0, 6851, 6852, 7, 4, 0, 0, 6852, 6853, + 7, 6, 0, 0, 6853, 6854, 7, 3, 0, 0, 6854, 6855, 5, 95, 0, 0, 6855, 6856, + 7, 12, 0, 0, 6856, 6857, 7, 9, 0, 0, 6857, 418, 1, 0, 0, 0, 6858, 6859, + 7, 8, 0, 0, 6859, 6860, 7, 11, 0, 0, 6860, 6861, 7, 10, 0, 0, 6861, 6862, + 7, 5, 0, 0, 6862, 6863, 7, 4, 0, 0, 6863, 6864, 7, 6, 0, 0, 6864, 6865, + 7, 3, 0, 0, 6865, 6866, 7, 12, 0, 0, 6866, 6867, 7, 7, 0, 0, 6867, 6868, + 7, 17, 0, 0, 6868, 420, 1, 0, 0, 0, 6869, 6870, 7, 8, 0, 0, 6870, 6871, + 7, 11, 0, 0, 6871, 6872, 7, 10, 0, 0, 6872, 6873, 7, 5, 0, 0, 6873, 6874, + 7, 4, 0, 0, 6874, 6875, 7, 6, 0, 0, 6875, 6876, 7, 3, 0, 0, 6876, 6877, + 7, 12, 0, 0, 6877, 6878, 7, 7, 0, 0, 6878, 6879, 7, 17, 0, 0, 6879, 6880, + 5, 95, 0, 0, 6880, 6881, 7, 16, 0, 0, 6881, 6882, 7, 0, 0, 0, 6882, 6883, + 7, 8, 0, 0, 6883, 6884, 7, 4, 0, 0, 6884, 6885, 7, 2, 0, 0, 6885, 6886, + 7, 3, 0, 0, 6886, 422, 1, 0, 0, 0, 6887, 6888, 7, 8, 0, 0, 6888, 6889, + 7, 11, 0, 0, 6889, 6890, 7, 10, 0, 0, 6890, 6891, 7, 5, 0, 0, 6891, 6892, + 7, 4, 0, 0, 6892, 6893, 7, 6, 0, 0, 6893, 6894, 7, 3, 0, 0, 6894, 6895, + 5, 95, 0, 0, 6895, 6896, 7, 15, 0, 0, 6896, 6897, 7, 3, 0, 0, 6897, 6898, + 7, 2, 0, 0, 6898, 6899, 7, 1, 0, 0, 6899, 6900, 7, 0, 0, 0, 6900, 6901, + 7, 1, 0, 0, 6901, 6902, 7, 12, 0, 0, 6902, 6903, 7, 11, 0, 0, 6903, 6904, + 7, 12, 0, 0, 6904, 6905, 7, 4, 0, 0, 6905, 6906, 7, 18, 0, 0, 6906, 424, + 1, 0, 0, 0, 6907, 6908, 7, 8, 0, 0, 6908, 6909, 7, 11, 0, 0, 6909, 6910, + 7, 10, 0, 0, 6910, 6911, 7, 5, 0, 0, 6911, 6912, 7, 4, 0, 0, 6912, 6913, + 7, 6, 0, 0, 6913, 6914, 7, 3, 0, 0, 6914, 6915, 5, 95, 0, 0, 6915, 6916, + 7, 5, 0, 0, 6916, 6917, 7, 6, 0, 0, 6917, 6918, 7, 4, 0, 0, 6918, 426, + 1, 0, 0, 0, 6919, 6920, 7, 8, 0, 0, 6920, 6921, 7, 2, 0, 0, 6921, 6922, + 7, 0, 0, 0, 6922, 6923, 7, 11, 0, 0, 6923, 6924, 7, 6, 0, 0, 6924, 6925, + 7, 5, 0, 0, 6925, 6926, 7, 8, 0, 0, 6926, 6927, 7, 6, 0, 0, 6927, 428, + 1, 0, 0, 0, 6928, 6929, 7, 8, 0, 0, 6929, 6930, 7, 2, 0, 0, 6930, 6931, + 7, 0, 0, 0, 6931, 6932, 7, 11, 0, 0, 6932, 6933, 7, 6, 0, 0, 6933, 6934, + 7, 5, 0, 0, 6934, 6935, 7, 8, 0, 0, 6935, 6936, 7, 6, 0, 0, 6936, 6937, + 5, 95, 0, 0, 6937, 6938, 7, 5, 0, 0, 6938, 6939, 7, 24, 0, 0, 6939, 430, + 1, 0, 0, 0, 6940, 6941, 7, 8, 0, 0, 6941, 6942, 7, 2, 0, 0, 6942, 6943, + 7, 0, 0, 0, 6943, 6944, 7, 3, 0, 0, 6944, 6945, 7, 5, 0, 0, 6945, 6946, + 7, 6, 0, 0, 6946, 432, 1, 0, 0, 0, 6947, 6948, 7, 8, 0, 0, 6948, 6949, + 7, 2, 0, 0, 6949, 6950, 5, 95, 0, 0, 6950, 6951, 7, 0, 0, 0, 6951, 6952, + 7, 10, 0, 0, 6952, 6953, 7, 4, 0, 0, 6953, 6954, 7, 19, 0, 0, 6954, 6955, + 5, 95, 0, 0, 6955, 6956, 7, 12, 0, 0, 6956, 6957, 7, 7, 0, 0, 6957, 6958, + 7, 9, 0, 0, 6958, 434, 1, 0, 0, 0, 6959, 6960, 7, 8, 0, 0, 6960, 6961, + 7, 2, 0, 0, 6961, 6962, 7, 11, 0, 0, 6962, 6963, 7, 9, 0, 0, 6963, 436, + 1, 0, 0, 0, 6964, 6965, 7, 8, 0, 0, 6965, 6966, 7, 2, 0, 0, 6966, 6967, + 7, 11, 0, 0, 6967, 6968, 7, 11, 0, 0, 6968, 6969, 7, 6, 0, 0, 6969, 6970, + 7, 8, 0, 0, 6970, 6971, 7, 4, 0, 0, 6971, 438, 1, 0, 0, 0, 6972, 6973, + 7, 8, 0, 0, 6973, 6974, 7, 2, 0, 0, 6974, 6975, 7, 11, 0, 0, 6975, 6976, + 7, 10, 0, 0, 6976, 6977, 7, 14, 0, 0, 6977, 6978, 7, 7, 0, 0, 6978, 6979, + 7, 0, 0, 0, 6979, 6980, 7, 3, 0, 0, 6980, 440, 1, 0, 0, 0, 6981, 6982, + 7, 8, 0, 0, 6982, 6983, 7, 2, 0, 0, 6983, 6984, 7, 11, 0, 0, 6984, 6985, + 7, 10, 0, 0, 6985, 6986, 7, 14, 0, 0, 6986, 6987, 7, 7, 0, 0, 6987, 6988, + 5, 95, 0, 0, 6988, 6989, 7, 0, 0, 0, 6989, 6990, 7, 10, 0, 0, 6990, 6991, + 7, 4, 0, 0, 6991, 6992, 7, 19, 0, 0, 6992, 6993, 5, 95, 0, 0, 6993, 6994, + 7, 12, 0, 0, 6994, 6995, 7, 7, 0, 0, 6995, 6996, 7, 9, 0, 0, 6996, 6997, + 7, 12, 0, 0, 6997, 6998, 7, 8, 0, 0, 6998, 6999, 7, 0, 0, 0, 6999, 7000, + 7, 4, 0, 0, 7000, 7001, 7, 2, 0, 0, 7001, 7002, 7, 3, 0, 0, 7002, 442, + 1, 0, 0, 0, 7003, 7004, 7, 8, 0, 0, 7004, 7005, 7, 2, 0, 0, 7005, 7006, + 7, 11, 0, 0, 7006, 7007, 7, 10, 0, 0, 7007, 7008, 7, 14, 0, 0, 7008, 7009, + 7, 7, 0, 0, 7009, 444, 1, 0, 0, 0, 7010, 7011, 7, 8, 0, 0, 7011, 7012, + 7, 2, 0, 0, 7012, 7013, 7, 11, 0, 0, 7013, 7014, 7, 10, 0, 0, 7014, 7015, + 7, 14, 0, 0, 7015, 7016, 7, 7, 0, 0, 7016, 7017, 7, 5, 0, 0, 7017, 446, + 1, 0, 0, 0, 7018, 7019, 7, 8, 0, 0, 7019, 7020, 7, 2, 0, 0, 7020, 7021, + 7, 11, 0, 0, 7021, 7022, 7, 10, 0, 0, 7022, 7023, 7, 14, 0, 0, 7023, 7024, + 7, 7, 0, 0, 7024, 7025, 5, 95, 0, 0, 7025, 7026, 7, 5, 0, 0, 7026, 7027, + 7, 4, 0, 0, 7027, 7028, 7, 0, 0, 0, 7028, 7029, 7, 4, 0, 0, 7029, 7030, + 7, 5, 0, 0, 7030, 448, 1, 0, 0, 0, 7031, 7032, 7, 8, 0, 0, 7032, 7033, + 7, 2, 0, 0, 7033, 7034, 7, 11, 0, 0, 7034, 7035, 7, 10, 0, 0, 7035, 7036, + 7, 14, 0, 0, 7036, 7037, 7, 7, 0, 0, 7037, 7038, 5, 95, 0, 0, 7038, 7039, + 7, 13, 0, 0, 7039, 7040, 7, 0, 0, 0, 7040, 7041, 7, 11, 0, 0, 7041, 7042, + 7, 10, 0, 0, 7042, 7043, 7, 6, 0, 0, 7043, 450, 1, 0, 0, 0, 7044, 7045, + 7, 8, 0, 0, 7045, 7046, 7, 2, 0, 0, 7046, 7047, 7, 14, 0, 0, 7047, 7048, + 7, 14, 0, 0, 7048, 7049, 7, 6, 0, 0, 7049, 7050, 7, 7, 0, 0, 7050, 7051, + 7, 4, 0, 0, 7051, 452, 1, 0, 0, 0, 7052, 7053, 7, 8, 0, 0, 7053, 7054, + 7, 2, 0, 0, 7054, 7055, 7, 14, 0, 0, 7055, 7056, 7, 14, 0, 0, 7056, 7057, + 7, 12, 0, 0, 7057, 7058, 7, 4, 0, 0, 7058, 454, 1, 0, 0, 0, 7059, 7060, + 7, 8, 0, 0, 7060, 7061, 7, 2, 0, 0, 7061, 7062, 7, 14, 0, 0, 7062, 7063, + 7, 14, 0, 0, 7063, 7064, 7, 12, 0, 0, 7064, 7065, 7, 4, 0, 0, 7065, 7066, + 7, 4, 0, 0, 7066, 7067, 7, 6, 0, 0, 7067, 7068, 7, 9, 0, 0, 7068, 456, + 1, 0, 0, 0, 7069, 7070, 7, 8, 0, 0, 7070, 7071, 7, 2, 0, 0, 7071, 7072, + 7, 14, 0, 0, 7072, 7073, 7, 14, 0, 0, 7073, 7074, 7, 2, 0, 0, 7074, 7075, + 7, 7, 0, 0, 7075, 458, 1, 0, 0, 0, 7076, 7077, 7, 8, 0, 0, 7077, 7078, + 7, 2, 0, 0, 7078, 7079, 7, 14, 0, 0, 7079, 7080, 7, 14, 0, 0, 7080, 7081, + 7, 2, 0, 0, 7081, 7082, 7, 7, 0, 0, 7082, 7083, 5, 95, 0, 0, 7083, 7084, + 7, 9, 0, 0, 7084, 7085, 7, 0, 0, 0, 7085, 7086, 7, 4, 0, 0, 7086, 7087, + 7, 0, 0, 0, 7087, 460, 1, 0, 0, 0, 7088, 7089, 7, 8, 0, 0, 7089, 7090, + 7, 2, 0, 0, 7090, 7091, 7, 14, 0, 0, 7091, 7092, 7, 15, 0, 0, 7092, 7093, + 7, 0, 0, 0, 7093, 7094, 7, 8, 0, 0, 7094, 7095, 7, 4, 0, 0, 7095, 462, + 1, 0, 0, 0, 7096, 7097, 7, 8, 0, 0, 7097, 7098, 7, 2, 0, 0, 7098, 7099, + 7, 14, 0, 0, 7099, 7100, 7, 15, 0, 0, 7100, 7101, 7, 0, 0, 0, 7101, 7102, + 7, 4, 0, 0, 7102, 7103, 7, 12, 0, 0, 7103, 7104, 7, 1, 0, 0, 7104, 7105, + 7, 12, 0, 0, 7105, 7106, 7, 11, 0, 0, 7106, 7107, 7, 12, 0, 0, 7107, 7108, + 7, 4, 0, 0, 7108, 7109, 7, 18, 0, 0, 7109, 464, 1, 0, 0, 0, 7110, 7111, + 7, 8, 0, 0, 7111, 7112, 7, 2, 0, 0, 7112, 7113, 7, 14, 0, 0, 7113, 7114, + 7, 15, 0, 0, 7114, 7115, 7, 12, 0, 0, 7115, 7116, 7, 11, 0, 0, 7116, 7117, + 7, 6, 0, 0, 7117, 466, 1, 0, 0, 0, 7118, 7119, 7, 8, 0, 0, 7119, 7120, + 7, 2, 0, 0, 7120, 7121, 7, 14, 0, 0, 7121, 7122, 7, 15, 0, 0, 7122, 7123, + 7, 11, 0, 0, 7123, 7124, 7, 6, 0, 0, 7124, 7125, 7, 4, 0, 0, 7125, 7126, + 7, 6, 0, 0, 7126, 468, 1, 0, 0, 0, 7127, 7128, 7, 8, 0, 0, 7128, 7129, + 7, 2, 0, 0, 7129, 7130, 7, 14, 0, 0, 7130, 7131, 7, 15, 0, 0, 7131, 7132, + 7, 11, 0, 0, 7132, 7133, 7, 12, 0, 0, 7133, 7134, 7, 0, 0, 0, 7134, 7135, + 7, 7, 0, 0, 7135, 7136, 7, 8, 0, 0, 7136, 7137, 7, 6, 0, 0, 7137, 470, + 1, 0, 0, 0, 7138, 7139, 7, 8, 0, 0, 7139, 7140, 7, 2, 0, 0, 7140, 7141, + 7, 14, 0, 0, 7141, 7142, 7, 15, 0, 0, 7142, 7143, 7, 2, 0, 0, 7143, 7144, + 7, 7, 0, 0, 7144, 7145, 7, 6, 0, 0, 7145, 7146, 7, 7, 0, 0, 7146, 7147, + 7, 4, 0, 0, 7147, 472, 1, 0, 0, 0, 7148, 7149, 7, 8, 0, 0, 7149, 7150, + 7, 2, 0, 0, 7150, 7151, 7, 14, 0, 0, 7151, 7152, 7, 15, 0, 0, 7152, 7153, + 7, 2, 0, 0, 7153, 7154, 7, 7, 0, 0, 7154, 7155, 7, 6, 0, 0, 7155, 7156, + 7, 7, 0, 0, 7156, 7157, 7, 4, 0, 0, 7157, 7158, 7, 5, 0, 0, 7158, 474, + 1, 0, 0, 0, 7159, 7160, 7, 8, 0, 0, 7160, 7161, 7, 2, 0, 0, 7161, 7162, + 7, 14, 0, 0, 7162, 7163, 7, 15, 0, 0, 7163, 7164, 7, 2, 0, 0, 7164, 7165, + 7, 5, 0, 0, 7165, 7166, 7, 6, 0, 0, 7166, 476, 1, 0, 0, 0, 7167, 7168, + 7, 8, 0, 0, 7168, 7169, 7, 2, 0, 0, 7169, 7170, 7, 14, 0, 0, 7170, 7171, + 7, 15, 0, 0, 7171, 7172, 7, 2, 0, 0, 7172, 7173, 7, 5, 0, 0, 7173, 7174, + 7, 12, 0, 0, 7174, 7175, 7, 4, 0, 0, 7175, 7176, 7, 6, 0, 0, 7176, 478, + 1, 0, 0, 0, 7177, 7178, 7, 8, 0, 0, 7178, 7179, 7, 2, 0, 0, 7179, 7180, + 7, 14, 0, 0, 7180, 7181, 7, 15, 0, 0, 7181, 7182, 7, 2, 0, 0, 7182, 7183, + 7, 5, 0, 0, 7183, 7184, 7, 12, 0, 0, 7184, 7185, 7, 4, 0, 0, 7185, 7186, + 7, 6, 0, 0, 7186, 7187, 5, 95, 0, 0, 7187, 7188, 7, 11, 0, 0, 7188, 7189, + 7, 12, 0, 0, 7189, 7190, 7, 14, 0, 0, 7190, 7191, 7, 12, 0, 0, 7191, 7192, + 7, 4, 0, 0, 7192, 480, 1, 0, 0, 0, 7193, 7194, 7, 8, 0, 0, 7194, 7195, + 7, 2, 0, 0, 7195, 7196, 7, 14, 0, 0, 7196, 7197, 7, 15, 0, 0, 7197, 7198, + 7, 2, 0, 0, 7198, 7199, 7, 10, 0, 0, 7199, 7200, 7, 7, 0, 0, 7200, 7201, + 7, 9, 0, 0, 7201, 482, 1, 0, 0, 0, 7202, 7203, 7, 8, 0, 0, 7203, 7204, + 7, 2, 0, 0, 7204, 7205, 7, 14, 0, 0, 7205, 7206, 7, 15, 0, 0, 7206, 7207, + 7, 3, 0, 0, 7207, 7208, 7, 6, 0, 0, 7208, 7209, 7, 5, 0, 0, 7209, 7210, + 7, 5, 0, 0, 7210, 484, 1, 0, 0, 0, 7211, 7212, 7, 8, 0, 0, 7212, 7213, + 7, 2, 0, 0, 7213, 7214, 7, 14, 0, 0, 7214, 7215, 7, 15, 0, 0, 7215, 7216, + 7, 10, 0, 0, 7216, 7217, 7, 4, 0, 0, 7217, 7218, 7, 6, 0, 0, 7218, 486, + 1, 0, 0, 0, 7219, 7220, 7, 8, 0, 0, 7220, 7221, 7, 2, 0, 0, 7221, 7222, + 7, 7, 0, 0, 7222, 7223, 7, 8, 0, 0, 7223, 7224, 7, 0, 0, 0, 7224, 7225, + 7, 4, 0, 0, 7225, 488, 1, 0, 0, 0, 7226, 7227, 7, 8, 0, 0, 7227, 7228, + 7, 2, 0, 0, 7228, 7229, 7, 7, 0, 0, 7229, 7230, 5, 95, 0, 0, 7230, 7231, + 7, 9, 0, 0, 7231, 7232, 7, 1, 0, 0, 7232, 7233, 7, 12, 0, 0, 7233, 7234, + 7, 9, 0, 0, 7234, 7235, 5, 95, 0, 0, 7235, 7236, 7, 4, 0, 0, 7236, 7237, + 7, 2, 0, 0, 7237, 7238, 5, 95, 0, 0, 7238, 7239, 7, 12, 0, 0, 7239, 7240, + 7, 9, 0, 0, 7240, 490, 1, 0, 0, 0, 7241, 7242, 7, 8, 0, 0, 7242, 7243, + 7, 2, 0, 0, 7243, 7244, 7, 7, 0, 0, 7244, 7245, 7, 9, 0, 0, 7245, 7246, + 7, 12, 0, 0, 7246, 7247, 7, 4, 0, 0, 7247, 7248, 7, 12, 0, 0, 7248, 7249, + 7, 2, 0, 0, 7249, 7250, 7, 7, 0, 0, 7250, 7251, 7, 0, 0, 0, 7251, 7252, + 7, 11, 0, 0, 7252, 492, 1, 0, 0, 0, 7253, 7254, 7, 8, 0, 0, 7254, 7255, + 7, 2, 0, 0, 7255, 7256, 7, 7, 0, 0, 7256, 7257, 7, 9, 0, 0, 7257, 7258, + 7, 12, 0, 0, 7258, 7259, 7, 4, 0, 0, 7259, 7260, 7, 12, 0, 0, 7260, 7261, + 7, 2, 0, 0, 7261, 7262, 7, 7, 0, 0, 7262, 494, 1, 0, 0, 0, 7263, 7264, + 7, 8, 0, 0, 7264, 7265, 7, 2, 0, 0, 7265, 7266, 7, 7, 0, 0, 7266, 7267, + 7, 16, 0, 0, 7267, 7268, 7, 12, 0, 0, 7268, 7269, 7, 3, 0, 0, 7269, 7270, + 7, 14, 0, 0, 7270, 496, 1, 0, 0, 0, 7271, 7272, 7, 8, 0, 0, 7272, 7273, + 7, 2, 0, 0, 7273, 7274, 7, 7, 0, 0, 7274, 7275, 7, 16, 0, 0, 7275, 7276, + 7, 2, 0, 0, 7276, 7277, 7, 3, 0, 0, 7277, 7278, 7, 14, 0, 0, 7278, 7279, + 7, 12, 0, 0, 7279, 7280, 7, 7, 0, 0, 7280, 7281, 7, 17, 0, 0, 7281, 498, + 1, 0, 0, 0, 7282, 7283, 7, 8, 0, 0, 7283, 7284, 7, 2, 0, 0, 7284, 7285, + 7, 7, 0, 0, 7285, 7286, 5, 95, 0, 0, 7286, 7287, 7, 17, 0, 0, 7287, 7288, + 7, 10, 0, 0, 7288, 7289, 7, 12, 0, 0, 7289, 7290, 7, 9, 0, 0, 7290, 7291, + 5, 95, 0, 0, 7291, 7292, 7, 4, 0, 0, 7292, 7293, 7, 2, 0, 0, 7293, 7294, + 5, 95, 0, 0, 7294, 7295, 7, 12, 0, 0, 7295, 7296, 7, 9, 0, 0, 7296, 500, + 1, 0, 0, 0, 7297, 7298, 7, 8, 0, 0, 7298, 7299, 7, 2, 0, 0, 7299, 7300, + 7, 7, 0, 0, 7300, 7301, 5, 95, 0, 0, 7301, 7302, 7, 12, 0, 0, 7302, 7303, + 7, 9, 0, 0, 7303, 502, 1, 0, 0, 0, 7304, 7305, 7, 8, 0, 0, 7305, 7306, + 7, 2, 0, 0, 7306, 7307, 7, 7, 0, 0, 7307, 7308, 5, 95, 0, 0, 7308, 7309, + 7, 7, 0, 0, 7309, 7310, 7, 0, 0, 0, 7310, 7311, 7, 14, 0, 0, 7311, 7312, + 7, 6, 0, 0, 7312, 7313, 5, 95, 0, 0, 7313, 7314, 7, 4, 0, 0, 7314, 7315, + 7, 2, 0, 0, 7315, 7316, 5, 95, 0, 0, 7316, 7317, 7, 12, 0, 0, 7317, 7318, + 7, 9, 0, 0, 7318, 504, 1, 0, 0, 0, 7319, 7320, 7, 8, 0, 0, 7320, 7321, + 7, 2, 0, 0, 7321, 7322, 7, 7, 0, 0, 7322, 7323, 7, 7, 0, 0, 7323, 7324, + 7, 6, 0, 0, 7324, 7325, 7, 8, 0, 0, 7325, 7326, 7, 4, 0, 0, 7326, 7327, + 5, 95, 0, 0, 7327, 7328, 7, 1, 0, 0, 7328, 7329, 7, 18, 0, 0, 7329, 7330, + 5, 95, 0, 0, 7330, 7331, 7, 8, 0, 0, 7331, 7332, 7, 1, 0, 0, 7332, 7333, + 5, 95, 0, 0, 7333, 7334, 7, 22, 0, 0, 7334, 7335, 7, 19, 0, 0, 7335, 7336, + 7, 3, 0, 0, 7336, 7337, 5, 95, 0, 0, 7337, 7338, 7, 2, 0, 0, 7338, 7339, + 7, 7, 0, 0, 7339, 7340, 7, 11, 0, 0, 7340, 7341, 7, 18, 0, 0, 7341, 506, + 1, 0, 0, 0, 7342, 7343, 7, 8, 0, 0, 7343, 7344, 7, 2, 0, 0, 7344, 7345, + 7, 7, 0, 0, 7345, 7346, 7, 7, 0, 0, 7346, 7347, 7, 6, 0, 0, 7347, 7348, + 7, 8, 0, 0, 7348, 7349, 7, 4, 0, 0, 7349, 7350, 5, 95, 0, 0, 7350, 7351, + 7, 1, 0, 0, 7351, 7352, 7, 18, 0, 0, 7352, 7353, 5, 95, 0, 0, 7353, 7354, + 7, 8, 0, 0, 7354, 7355, 7, 2, 0, 0, 7355, 7356, 7, 14, 0, 0, 7356, 7357, + 7, 1, 0, 0, 7357, 7358, 7, 12, 0, 0, 7358, 7359, 7, 7, 0, 0, 7359, 7360, + 7, 6, 0, 0, 7360, 7361, 5, 95, 0, 0, 7361, 7362, 7, 5, 0, 0, 7362, 7363, + 7, 22, 0, 0, 7363, 508, 1, 0, 0, 0, 7364, 7365, 7, 8, 0, 0, 7365, 7366, + 7, 2, 0, 0, 7366, 7367, 7, 7, 0, 0, 7367, 7368, 7, 7, 0, 0, 7368, 7369, + 7, 6, 0, 0, 7369, 7370, 7, 8, 0, 0, 7370, 7371, 7, 4, 0, 0, 7371, 7372, + 5, 95, 0, 0, 7372, 7373, 7, 1, 0, 0, 7373, 7374, 7, 18, 0, 0, 7374, 7375, + 5, 95, 0, 0, 7375, 7376, 7, 8, 0, 0, 7376, 7377, 7, 2, 0, 0, 7377, 7378, + 7, 5, 0, 0, 7378, 7379, 7, 4, 0, 0, 7379, 7380, 5, 95, 0, 0, 7380, 7381, + 7, 1, 0, 0, 7381, 7382, 7, 0, 0, 0, 7382, 7383, 7, 5, 0, 0, 7383, 7384, + 7, 6, 0, 0, 7384, 7385, 7, 9, 0, 0, 7385, 510, 1, 0, 0, 0, 7386, 7387, + 7, 8, 0, 0, 7387, 7388, 7, 2, 0, 0, 7388, 7389, 7, 7, 0, 0, 7389, 7390, + 7, 7, 0, 0, 7390, 7391, 7, 6, 0, 0, 7391, 7392, 7, 8, 0, 0, 7392, 7393, + 7, 4, 0, 0, 7393, 7394, 5, 95, 0, 0, 7394, 7395, 7, 1, 0, 0, 7395, 7396, + 7, 18, 0, 0, 7396, 7397, 5, 95, 0, 0, 7397, 7398, 7, 6, 0, 0, 7398, 7399, + 7, 11, 0, 0, 7399, 7400, 7, 12, 0, 0, 7400, 7401, 7, 14, 0, 0, 7401, 7402, + 5, 95, 0, 0, 7402, 7403, 7, 9, 0, 0, 7403, 7404, 7, 10, 0, 0, 7404, 7405, + 7, 15, 0, 0, 7405, 7406, 7, 5, 0, 0, 7406, 512, 1, 0, 0, 0, 7407, 7408, + 7, 8, 0, 0, 7408, 7409, 7, 2, 0, 0, 7409, 7410, 7, 7, 0, 0, 7410, 7411, + 7, 7, 0, 0, 7411, 7412, 7, 6, 0, 0, 7412, 7413, 7, 8, 0, 0, 7413, 7414, + 7, 4, 0, 0, 7414, 7415, 5, 95, 0, 0, 7415, 7416, 7, 1, 0, 0, 7416, 7417, + 7, 18, 0, 0, 7417, 7418, 5, 95, 0, 0, 7418, 7419, 7, 16, 0, 0, 7419, 7420, + 7, 12, 0, 0, 7420, 7421, 7, 11, 0, 0, 7421, 7422, 7, 4, 0, 0, 7422, 7423, + 7, 6, 0, 0, 7423, 7424, 7, 3, 0, 0, 7424, 7425, 7, 12, 0, 0, 7425, 7426, + 7, 7, 0, 0, 7426, 7427, 7, 17, 0, 0, 7427, 514, 1, 0, 0, 0, 7428, 7429, + 7, 8, 0, 0, 7429, 7430, 7, 2, 0, 0, 7430, 7431, 7, 7, 0, 0, 7431, 7432, + 7, 7, 0, 0, 7432, 7433, 7, 6, 0, 0, 7433, 7434, 7, 8, 0, 0, 7434, 7435, + 7, 4, 0, 0, 7435, 7436, 5, 95, 0, 0, 7436, 7437, 7, 1, 0, 0, 7437, 7438, + 7, 18, 0, 0, 7438, 7439, 5, 95, 0, 0, 7439, 7440, 7, 12, 0, 0, 7440, 7441, + 7, 5, 0, 0, 7441, 7442, 7, 8, 0, 0, 7442, 7443, 7, 18, 0, 0, 7443, 7444, + 7, 8, 0, 0, 7444, 7445, 7, 11, 0, 0, 7445, 7446, 7, 6, 0, 0, 7446, 516, + 1, 0, 0, 0, 7447, 7448, 7, 8, 0, 0, 7448, 7449, 7, 2, 0, 0, 7449, 7450, + 7, 7, 0, 0, 7450, 7451, 7, 7, 0, 0, 7451, 7452, 7, 6, 0, 0, 7452, 7453, + 7, 8, 0, 0, 7453, 7454, 7, 4, 0, 0, 7454, 7455, 5, 95, 0, 0, 7455, 7456, + 7, 1, 0, 0, 7456, 7457, 7, 18, 0, 0, 7457, 7458, 5, 95, 0, 0, 7458, 7459, + 7, 12, 0, 0, 7459, 7460, 7, 5, 0, 0, 7460, 7461, 7, 11, 0, 0, 7461, 7462, + 7, 6, 0, 0, 7462, 7463, 7, 0, 0, 0, 7463, 7464, 7, 16, 0, 0, 7464, 518, + 1, 0, 0, 0, 7465, 7466, 7, 8, 0, 0, 7466, 7467, 7, 2, 0, 0, 7467, 7468, + 7, 7, 0, 0, 7468, 7469, 7, 7, 0, 0, 7469, 7470, 7, 6, 0, 0, 7470, 7471, + 7, 8, 0, 0, 7471, 7472, 7, 4, 0, 0, 7472, 7473, 5, 95, 0, 0, 7473, 7474, + 7, 1, 0, 0, 7474, 7475, 7, 18, 0, 0, 7475, 7476, 5, 95, 0, 0, 7476, 7477, + 7, 3, 0, 0, 7477, 7478, 7, 2, 0, 0, 7478, 7479, 7, 2, 0, 0, 7479, 7480, + 7, 4, 0, 0, 7480, 520, 1, 0, 0, 0, 7481, 7482, 7, 8, 0, 0, 7482, 7483, + 7, 2, 0, 0, 7483, 7484, 7, 7, 0, 0, 7484, 7485, 7, 7, 0, 0, 7485, 7486, + 7, 6, 0, 0, 7486, 7487, 7, 8, 0, 0, 7487, 7488, 7, 4, 0, 0, 7488, 522, + 1, 0, 0, 0, 7489, 7490, 7, 8, 0, 0, 7490, 7491, 7, 2, 0, 0, 7491, 7492, + 7, 7, 0, 0, 7492, 7493, 7, 7, 0, 0, 7493, 7494, 7, 6, 0, 0, 7494, 7495, + 7, 8, 0, 0, 7495, 7496, 7, 4, 0, 0, 7496, 7497, 5, 95, 0, 0, 7497, 7498, + 7, 4, 0, 0, 7498, 7499, 7, 12, 0, 0, 7499, 7500, 7, 14, 0, 0, 7500, 7501, + 7, 6, 0, 0, 7501, 524, 1, 0, 0, 0, 7502, 7503, 7, 8, 0, 0, 7503, 7504, + 7, 2, 0, 0, 7504, 7505, 7, 7, 0, 0, 7505, 7506, 7, 5, 0, 0, 7506, 7507, + 7, 12, 0, 0, 7507, 7508, 7, 9, 0, 0, 7508, 7509, 7, 6, 0, 0, 7509, 7510, + 7, 3, 0, 0, 7510, 526, 1, 0, 0, 0, 7511, 7512, 7, 8, 0, 0, 7512, 7513, + 7, 2, 0, 0, 7513, 7514, 7, 7, 0, 0, 7514, 7515, 7, 5, 0, 0, 7515, 7516, + 7, 12, 0, 0, 7516, 7517, 7, 5, 0, 0, 7517, 7518, 7, 4, 0, 0, 7518, 7519, + 7, 6, 0, 0, 7519, 7520, 7, 7, 0, 0, 7520, 7521, 7, 4, 0, 0, 7521, 528, + 1, 0, 0, 0, 7522, 7523, 7, 8, 0, 0, 7523, 7524, 7, 2, 0, 0, 7524, 7525, + 7, 7, 0, 0, 7525, 7526, 7, 5, 0, 0, 7526, 7527, 7, 4, 0, 0, 7527, 7528, + 7, 0, 0, 0, 7528, 7529, 7, 7, 0, 0, 7529, 7530, 7, 4, 0, 0, 7530, 530, + 1, 0, 0, 0, 7531, 7532, 7, 8, 0, 0, 7532, 7533, 7, 2, 0, 0, 7533, 7534, + 7, 7, 0, 0, 7534, 7535, 7, 5, 0, 0, 7535, 7536, 7, 4, 0, 0, 7536, 532, + 1, 0, 0, 0, 7537, 7538, 7, 8, 0, 0, 7538, 7539, 7, 2, 0, 0, 7539, 7540, + 7, 7, 0, 0, 7540, 7541, 7, 5, 0, 0, 7541, 7542, 7, 4, 0, 0, 7542, 7543, + 7, 3, 0, 0, 7543, 7544, 7, 0, 0, 0, 7544, 7545, 7, 12, 0, 0, 7545, 7546, + 7, 7, 0, 0, 7546, 7547, 7, 4, 0, 0, 7547, 534, 1, 0, 0, 0, 7548, 7549, + 7, 8, 0, 0, 7549, 7550, 7, 2, 0, 0, 7550, 7551, 7, 7, 0, 0, 7551, 7552, + 7, 5, 0, 0, 7552, 7553, 7, 4, 0, 0, 7553, 7554, 7, 3, 0, 0, 7554, 7555, + 7, 0, 0, 0, 7555, 7556, 7, 12, 0, 0, 7556, 7557, 7, 7, 0, 0, 7557, 7558, + 7, 4, 0, 0, 7558, 7559, 7, 5, 0, 0, 7559, 536, 1, 0, 0, 0, 7560, 7561, + 7, 8, 0, 0, 7561, 7562, 7, 2, 0, 0, 7562, 7563, 7, 7, 0, 0, 7563, 7564, + 7, 5, 0, 0, 7564, 7565, 7, 4, 0, 0, 7565, 7566, 7, 3, 0, 0, 7566, 7567, + 7, 10, 0, 0, 7567, 7568, 7, 8, 0, 0, 7568, 7569, 7, 4, 0, 0, 7569, 7570, + 7, 2, 0, 0, 7570, 7571, 7, 3, 0, 0, 7571, 538, 1, 0, 0, 0, 7572, 7573, + 7, 8, 0, 0, 7573, 7574, 7, 2, 0, 0, 7574, 7575, 7, 7, 0, 0, 7575, 7576, + 7, 4, 0, 0, 7576, 7577, 7, 0, 0, 0, 7577, 7578, 7, 12, 0, 0, 7578, 7579, + 7, 7, 0, 0, 7579, 7580, 7, 6, 0, 0, 7580, 7581, 7, 3, 0, 0, 7581, 540, + 1, 0, 0, 0, 7582, 7583, 7, 8, 0, 0, 7583, 7584, 7, 2, 0, 0, 7584, 7585, + 7, 7, 0, 0, 7585, 7586, 7, 4, 0, 0, 7586, 7587, 7, 0, 0, 0, 7587, 7588, + 7, 12, 0, 0, 7588, 7589, 7, 7, 0, 0, 7589, 7590, 7, 6, 0, 0, 7590, 7591, + 7, 3, 0, 0, 7591, 7592, 7, 5, 0, 0, 7592, 542, 1, 0, 0, 0, 7593, 7594, + 7, 8, 0, 0, 7594, 7595, 7, 2, 0, 0, 7595, 7596, 7, 7, 0, 0, 7596, 7597, + 7, 4, 0, 0, 7597, 7598, 7, 0, 0, 0, 7598, 7599, 7, 12, 0, 0, 7599, 7600, + 7, 7, 0, 0, 7600, 7601, 7, 6, 0, 0, 7601, 7602, 7, 3, 0, 0, 7602, 7603, + 7, 5, 0, 0, 7603, 7604, 5, 95, 0, 0, 7604, 7605, 7, 9, 0, 0, 7605, 7606, + 7, 6, 0, 0, 7606, 7607, 7, 16, 0, 0, 7607, 7608, 7, 0, 0, 0, 7608, 7609, + 7, 10, 0, 0, 7609, 7610, 7, 11, 0, 0, 7610, 7611, 7, 4, 0, 0, 7611, 544, + 1, 0, 0, 0, 7612, 7613, 7, 8, 0, 0, 7613, 7614, 7, 2, 0, 0, 7614, 7615, + 7, 7, 0, 0, 7615, 7616, 7, 4, 0, 0, 7616, 7617, 7, 0, 0, 0, 7617, 7618, + 7, 12, 0, 0, 7618, 7619, 7, 7, 0, 0, 7619, 7620, 7, 6, 0, 0, 7620, 7621, + 7, 3, 0, 0, 7621, 7622, 5, 95, 0, 0, 7622, 7623, 7, 9, 0, 0, 7623, 7624, + 7, 0, 0, 0, 7624, 7625, 7, 4, 0, 0, 7625, 7626, 7, 0, 0, 0, 7626, 546, + 1, 0, 0, 0, 7627, 7628, 7, 8, 0, 0, 7628, 7629, 7, 2, 0, 0, 7629, 7630, + 7, 7, 0, 0, 7630, 7631, 7, 4, 0, 0, 7631, 7632, 7, 0, 0, 0, 7632, 7633, + 7, 12, 0, 0, 7633, 7634, 7, 7, 0, 0, 7634, 7635, 7, 6, 0, 0, 7635, 7636, + 7, 3, 0, 0, 7636, 7637, 5, 95, 0, 0, 7637, 7638, 7, 14, 0, 0, 7638, 7639, + 7, 0, 0, 0, 7639, 7640, 7, 15, 0, 0, 7640, 548, 1, 0, 0, 0, 7641, 7642, + 7, 8, 0, 0, 7642, 7643, 7, 2, 0, 0, 7643, 7644, 7, 7, 0, 0, 7644, 7645, + 7, 4, 0, 0, 7645, 7646, 7, 6, 0, 0, 7646, 7647, 7, 7, 0, 0, 7647, 7648, + 7, 4, 0, 0, 7648, 550, 1, 0, 0, 0, 7649, 7650, 7, 8, 0, 0, 7650, 7651, + 7, 2, 0, 0, 7651, 7652, 7, 7, 0, 0, 7652, 7653, 7, 4, 0, 0, 7653, 7654, + 7, 6, 0, 0, 7654, 7655, 7, 7, 0, 0, 7655, 7656, 7, 4, 0, 0, 7656, 7657, + 7, 5, 0, 0, 7657, 552, 1, 0, 0, 0, 7658, 7659, 7, 8, 0, 0, 7659, 7660, + 7, 2, 0, 0, 7660, 7661, 7, 7, 0, 0, 7661, 7662, 7, 4, 0, 0, 7662, 7663, + 7, 6, 0, 0, 7663, 7664, 7, 25, 0, 0, 7664, 7665, 7, 4, 0, 0, 7665, 554, + 1, 0, 0, 0, 7666, 7667, 7, 8, 0, 0, 7667, 7668, 7, 2, 0, 0, 7668, 7669, + 7, 7, 0, 0, 7669, 7670, 7, 4, 0, 0, 7670, 7671, 7, 12, 0, 0, 7671, 7672, + 7, 7, 0, 0, 7672, 7673, 7, 10, 0, 0, 7673, 7674, 7, 6, 0, 0, 7674, 556, + 1, 0, 0, 0, 7675, 7676, 7, 8, 0, 0, 7676, 7677, 7, 2, 0, 0, 7677, 7678, + 7, 7, 0, 0, 7678, 7679, 7, 4, 0, 0, 7679, 7680, 7, 3, 0, 0, 7680, 7681, + 7, 2, 0, 0, 7681, 7682, 7, 11, 0, 0, 7682, 7683, 7, 16, 0, 0, 7683, 7684, + 7, 12, 0, 0, 7684, 7685, 7, 11, 0, 0, 7685, 7686, 7, 6, 0, 0, 7686, 558, + 1, 0, 0, 0, 7687, 7688, 7, 8, 0, 0, 7688, 7689, 7, 2, 0, 0, 7689, 7690, + 7, 7, 0, 0, 7690, 7691, 5, 95, 0, 0, 7691, 7692, 7, 10, 0, 0, 7692, 7693, + 7, 12, 0, 0, 7693, 7694, 7, 9, 0, 0, 7694, 7695, 5, 95, 0, 0, 7695, 7696, + 7, 4, 0, 0, 7696, 7697, 7, 2, 0, 0, 7697, 7698, 5, 95, 0, 0, 7698, 7699, + 7, 12, 0, 0, 7699, 7700, 7, 9, 0, 0, 7700, 560, 1, 0, 0, 0, 7701, 7702, + 7, 8, 0, 0, 7702, 7703, 7, 2, 0, 0, 7703, 7704, 7, 7, 0, 0, 7704, 7705, + 7, 13, 0, 0, 7705, 7706, 7, 6, 0, 0, 7706, 7707, 7, 3, 0, 0, 7707, 7708, + 7, 4, 0, 0, 7708, 562, 1, 0, 0, 0, 7709, 7710, 7, 8, 0, 0, 7710, 7711, + 7, 2, 0, 0, 7711, 7712, 7, 7, 0, 0, 7712, 7713, 7, 13, 0, 0, 7713, 7714, + 7, 6, 0, 0, 7714, 7715, 7, 3, 0, 0, 7715, 7716, 7, 5, 0, 0, 7716, 7717, + 7, 12, 0, 0, 7717, 7718, 7, 2, 0, 0, 7718, 7719, 7, 7, 0, 0, 7719, 564, + 1, 0, 0, 0, 7720, 7721, 7, 8, 0, 0, 7721, 7722, 7, 2, 0, 0, 7722, 7723, + 7, 2, 0, 0, 7723, 7724, 7, 21, 0, 0, 7724, 7725, 7, 12, 0, 0, 7725, 7726, + 7, 6, 0, 0, 7726, 566, 1, 0, 0, 0, 7727, 7728, 7, 8, 0, 0, 7728, 7729, + 7, 2, 0, 0, 7729, 7730, 7, 15, 0, 0, 7730, 7731, 7, 18, 0, 0, 7731, 568, + 1, 0, 0, 0, 7732, 7733, 7, 8, 0, 0, 7733, 7734, 7, 2, 0, 0, 7734, 7735, + 7, 3, 0, 0, 7735, 7736, 7, 3, 0, 0, 7736, 7737, 5, 95, 0, 0, 7737, 7738, + 7, 21, 0, 0, 7738, 570, 1, 0, 0, 0, 7739, 7740, 7, 8, 0, 0, 7740, 7741, + 7, 2, 0, 0, 7741, 7742, 7, 3, 0, 0, 7742, 7743, 7, 3, 0, 0, 7743, 7744, + 5, 95, 0, 0, 7744, 7745, 7, 5, 0, 0, 7745, 572, 1, 0, 0, 0, 7746, 7747, + 7, 8, 0, 0, 7747, 7748, 7, 2, 0, 0, 7748, 7749, 7, 3, 0, 0, 7749, 7750, + 7, 3, 0, 0, 7750, 7751, 7, 10, 0, 0, 7751, 7752, 7, 15, 0, 0, 7752, 7753, + 7, 4, 0, 0, 7753, 7754, 7, 12, 0, 0, 7754, 7755, 7, 2, 0, 0, 7755, 7756, + 7, 7, 0, 0, 7756, 574, 1, 0, 0, 0, 7757, 7758, 7, 8, 0, 0, 7758, 7759, + 7, 2, 0, 0, 7759, 7760, 7, 3, 0, 0, 7760, 7761, 7, 3, 0, 0, 7761, 7762, + 7, 10, 0, 0, 7762, 7763, 7, 15, 0, 0, 7763, 7764, 7, 4, 0, 0, 7764, 7765, + 5, 95, 0, 0, 7765, 7766, 7, 25, 0, 0, 7766, 7767, 7, 12, 0, 0, 7767, 7768, + 7, 9, 0, 0, 7768, 7769, 5, 95, 0, 0, 7769, 7770, 7, 0, 0, 0, 7770, 7771, + 7, 11, 0, 0, 7771, 7772, 7, 11, 0, 0, 7772, 576, 1, 0, 0, 0, 7773, 7774, + 7, 8, 0, 0, 7774, 7775, 7, 2, 0, 0, 7775, 7776, 7, 3, 0, 0, 7776, 7777, + 7, 3, 0, 0, 7777, 7778, 7, 10, 0, 0, 7778, 7779, 7, 15, 0, 0, 7779, 7780, + 7, 4, 0, 0, 7780, 7781, 5, 95, 0, 0, 7781, 7782, 7, 25, 0, 0, 7782, 7783, + 7, 12, 0, 0, 7783, 7784, 7, 9, 0, 0, 7784, 578, 1, 0, 0, 0, 7785, 7786, + 7, 8, 0, 0, 7786, 7787, 7, 2, 0, 0, 7787, 7788, 7, 5, 0, 0, 7788, 580, + 1, 0, 0, 0, 7789, 7790, 7, 8, 0, 0, 7790, 7791, 7, 2, 0, 0, 7791, 7792, + 7, 5, 0, 0, 7792, 7793, 7, 19, 0, 0, 7793, 582, 1, 0, 0, 0, 7794, 7795, + 7, 8, 0, 0, 7795, 7796, 7, 2, 0, 0, 7796, 7797, 7, 5, 0, 0, 7797, 7798, + 7, 4, 0, 0, 7798, 584, 1, 0, 0, 0, 7799, 7800, 7, 8, 0, 0, 7800, 7801, + 7, 2, 0, 0, 7801, 7802, 7, 5, 0, 0, 7802, 7803, 7, 4, 0, 0, 7803, 7804, + 5, 95, 0, 0, 7804, 7805, 7, 25, 0, 0, 7805, 7806, 7, 14, 0, 0, 7806, 7807, + 7, 11, 0, 0, 7807, 7808, 5, 95, 0, 0, 7808, 7809, 7, 24, 0, 0, 7809, 7810, + 7, 10, 0, 0, 7810, 7811, 7, 6, 0, 0, 7811, 7812, 7, 3, 0, 0, 7812, 7813, + 7, 18, 0, 0, 7813, 7814, 5, 95, 0, 0, 7814, 7815, 7, 3, 0, 0, 7815, 7816, + 7, 6, 0, 0, 7816, 7817, 7, 22, 0, 0, 7817, 7818, 7, 3, 0, 0, 7818, 7819, + 7, 12, 0, 0, 7819, 7820, 7, 4, 0, 0, 7820, 7821, 7, 6, 0, 0, 7821, 586, + 1, 0, 0, 0, 7822, 7823, 7, 8, 0, 0, 7823, 7824, 7, 2, 0, 0, 7824, 7825, + 7, 10, 0, 0, 7825, 7826, 7, 7, 0, 0, 7826, 7827, 7, 4, 0, 0, 7827, 588, + 1, 0, 0, 0, 7828, 7829, 7, 8, 0, 0, 7829, 7830, 7, 2, 0, 0, 7830, 7831, + 7, 13, 0, 0, 7831, 7832, 7, 0, 0, 0, 7832, 7833, 7, 3, 0, 0, 7833, 7834, + 5, 95, 0, 0, 7834, 7835, 7, 15, 0, 0, 7835, 7836, 7, 2, 0, 0, 7836, 7837, + 7, 15, 0, 0, 7837, 590, 1, 0, 0, 0, 7838, 7839, 7, 8, 0, 0, 7839, 7840, + 7, 2, 0, 0, 7840, 7841, 7, 13, 0, 0, 7841, 7842, 7, 0, 0, 0, 7842, 7843, + 7, 3, 0, 0, 7843, 7844, 5, 95, 0, 0, 7844, 7845, 7, 5, 0, 0, 7845, 7846, + 7, 0, 0, 0, 7846, 7847, 7, 14, 0, 0, 7847, 7848, 7, 15, 0, 0, 7848, 592, + 1, 0, 0, 0, 7849, 7850, 7, 8, 0, 0, 7850, 7851, 7, 15, 0, 0, 7851, 7852, + 7, 10, 0, 0, 7852, 7853, 5, 95, 0, 0, 7853, 7854, 7, 8, 0, 0, 7854, 7855, + 7, 2, 0, 0, 7855, 7856, 7, 5, 0, 0, 7856, 7857, 7, 4, 0, 0, 7857, 7858, + 7, 12, 0, 0, 7858, 7859, 7, 7, 0, 0, 7859, 7860, 7, 17, 0, 0, 7860, 594, + 1, 0, 0, 0, 7861, 7862, 7, 8, 0, 0, 7862, 7863, 7, 15, 0, 0, 7863, 7864, + 7, 10, 0, 0, 7864, 7865, 5, 95, 0, 0, 7865, 7866, 7, 15, 0, 0, 7866, 7867, + 7, 6, 0, 0, 7867, 7868, 7, 3, 0, 0, 7868, 7869, 5, 95, 0, 0, 7869, 7870, + 7, 8, 0, 0, 7870, 7871, 7, 0, 0, 0, 7871, 7872, 7, 11, 0, 0, 7872, 7873, + 7, 11, 0, 0, 7873, 596, 1, 0, 0, 0, 7874, 7875, 7, 8, 0, 0, 7875, 7876, + 7, 15, 0, 0, 7876, 7877, 7, 10, 0, 0, 7877, 7878, 5, 95, 0, 0, 7878, 7879, + 7, 15, 0, 0, 7879, 7880, 7, 6, 0, 0, 7880, 7881, 7, 3, 0, 0, 7881, 7882, + 5, 95, 0, 0, 7882, 7883, 7, 5, 0, 0, 7883, 7884, 7, 6, 0, 0, 7884, 7885, + 7, 5, 0, 0, 7885, 7886, 7, 5, 0, 0, 7886, 7887, 7, 12, 0, 0, 7887, 7888, + 7, 2, 0, 0, 7888, 7889, 7, 7, 0, 0, 7889, 598, 1, 0, 0, 0, 7890, 7891, + 7, 8, 0, 0, 7891, 7892, 7, 3, 0, 0, 7892, 7893, 7, 0, 0, 0, 7893, 7894, + 7, 5, 0, 0, 7894, 7895, 7, 19, 0, 0, 7895, 600, 1, 0, 0, 0, 7896, 7897, + 7, 8, 0, 0, 7897, 7898, 7, 3, 0, 0, 7898, 7899, 7, 6, 0, 0, 7899, 7900, + 7, 0, 0, 0, 7900, 7901, 7, 4, 0, 0, 7901, 7902, 7, 6, 0, 0, 7902, 602, + 1, 0, 0, 0, 7903, 7904, 7, 8, 0, 0, 7904, 7905, 7, 3, 0, 0, 7905, 7906, + 7, 6, 0, 0, 7906, 7907, 7, 0, 0, 0, 7907, 7908, 7, 4, 0, 0, 7908, 7909, + 7, 6, 0, 0, 7909, 7910, 5, 95, 0, 0, 7910, 7911, 7, 16, 0, 0, 7911, 7912, + 7, 12, 0, 0, 7912, 7913, 7, 11, 0, 0, 7913, 7914, 7, 6, 0, 0, 7914, 7915, + 5, 95, 0, 0, 7915, 7916, 7, 9, 0, 0, 7916, 7917, 7, 6, 0, 0, 7917, 7918, + 7, 5, 0, 0, 7918, 7919, 7, 4, 0, 0, 7919, 604, 1, 0, 0, 0, 7920, 7921, + 7, 8, 0, 0, 7921, 7922, 7, 3, 0, 0, 7922, 7923, 7, 6, 0, 0, 7923, 7924, + 7, 0, 0, 0, 7924, 7925, 7, 4, 0, 0, 7925, 7926, 7, 6, 0, 0, 7926, 7927, + 5, 95, 0, 0, 7927, 7928, 7, 5, 0, 0, 7928, 7929, 7, 4, 0, 0, 7929, 7930, + 7, 2, 0, 0, 7930, 7931, 7, 3, 0, 0, 7931, 7932, 7, 6, 0, 0, 7932, 7933, + 7, 9, 0, 0, 7933, 7934, 5, 95, 0, 0, 7934, 7935, 7, 2, 0, 0, 7935, 7936, + 7, 10, 0, 0, 7936, 7937, 7, 4, 0, 0, 7937, 7938, 7, 11, 0, 0, 7938, 7939, + 7, 12, 0, 0, 7939, 7940, 7, 7, 0, 0, 7940, 7941, 7, 6, 0, 0, 7941, 7942, + 7, 5, 0, 0, 7942, 606, 1, 0, 0, 0, 7943, 7944, 7, 8, 0, 0, 7944, 7945, + 7, 3, 0, 0, 7945, 7946, 7, 6, 0, 0, 7946, 7947, 7, 0, 0, 0, 7947, 7948, + 7, 4, 0, 0, 7948, 7949, 7, 12, 0, 0, 7949, 7950, 7, 2, 0, 0, 7950, 7951, + 7, 7, 0, 0, 7951, 608, 1, 0, 0, 0, 7952, 7953, 7, 8, 0, 0, 7953, 7954, + 7, 3, 0, 0, 7954, 7955, 7, 6, 0, 0, 7955, 7956, 7, 9, 0, 0, 7956, 7957, + 7, 6, 0, 0, 7957, 7958, 7, 7, 0, 0, 7958, 7959, 7, 4, 0, 0, 7959, 7960, + 7, 12, 0, 0, 7960, 7961, 7, 0, 0, 0, 7961, 7962, 7, 11, 0, 0, 7962, 610, + 1, 0, 0, 0, 7963, 7964, 7, 8, 0, 0, 7964, 7965, 7, 3, 0, 0, 7965, 7966, + 7, 12, 0, 0, 7966, 7967, 7, 4, 0, 0, 7967, 7968, 7, 12, 0, 0, 7968, 7969, + 7, 8, 0, 0, 7969, 7970, 7, 0, 0, 0, 7970, 7971, 7, 11, 0, 0, 7971, 612, + 1, 0, 0, 0, 7972, 7973, 7, 8, 0, 0, 7973, 7974, 7, 3, 0, 0, 7974, 7975, + 7, 2, 0, 0, 7975, 7976, 7, 5, 0, 0, 7976, 7977, 7, 5, 0, 0, 7977, 614, + 1, 0, 0, 0, 7978, 7979, 7, 8, 0, 0, 7979, 7980, 7, 3, 0, 0, 7980, 7981, + 7, 2, 0, 0, 7981, 7982, 7, 5, 0, 0, 7982, 7983, 7, 5, 0, 0, 7983, 7984, + 7, 6, 0, 0, 7984, 7985, 7, 9, 0, 0, 7985, 7986, 7, 12, 0, 0, 7986, 7987, + 7, 4, 0, 0, 7987, 7988, 7, 12, 0, 0, 7988, 7989, 7, 2, 0, 0, 7989, 7990, + 7, 7, 0, 0, 7990, 616, 1, 0, 0, 0, 7991, 7992, 7, 8, 0, 0, 7992, 7993, + 7, 5, 0, 0, 7993, 7994, 7, 8, 0, 0, 7994, 7995, 7, 2, 0, 0, 7995, 7996, + 7, 7, 0, 0, 7996, 7997, 7, 13, 0, 0, 7997, 7998, 7, 6, 0, 0, 7998, 7999, + 7, 3, 0, 0, 7999, 8000, 7, 4, 0, 0, 8000, 618, 1, 0, 0, 0, 8001, 8002, + 7, 8, 0, 0, 8002, 8003, 7, 10, 0, 0, 8003, 8004, 7, 1, 0, 0, 8004, 8005, + 7, 6, 0, 0, 8005, 8006, 5, 95, 0, 0, 8006, 8007, 7, 0, 0, 0, 8007, 8008, + 7, 20, 0, 0, 8008, 620, 1, 0, 0, 0, 8009, 8010, 7, 8, 0, 0, 8010, 8011, + 7, 10, 0, 0, 8011, 8012, 7, 1, 0, 0, 8012, 8013, 7, 6, 0, 0, 8013, 622, + 1, 0, 0, 0, 8014, 8015, 7, 8, 0, 0, 8015, 8016, 7, 10, 0, 0, 8016, 8017, + 7, 1, 0, 0, 8017, 8018, 7, 6, 0, 0, 8018, 8019, 5, 95, 0, 0, 8019, 8020, + 7, 17, 0, 0, 8020, 8021, 7, 1, 0, 0, 8021, 624, 1, 0, 0, 0, 8022, 8023, + 7, 8, 0, 0, 8023, 8024, 7, 10, 0, 0, 8024, 8025, 7, 1, 0, 0, 8025, 8026, + 7, 6, 0, 0, 8026, 8027, 5, 95, 0, 0, 8027, 8028, 7, 5, 0, 0, 8028, 8029, + 7, 20, 0, 0, 8029, 626, 1, 0, 0, 0, 8030, 8031, 7, 8, 0, 0, 8031, 8032, + 7, 10, 0, 0, 8032, 8033, 7, 14, 0, 0, 8033, 8034, 7, 6, 0, 0, 8034, 8035, + 5, 95, 0, 0, 8035, 8036, 7, 9, 0, 0, 8036, 8037, 7, 12, 0, 0, 8037, 8038, + 7, 5, 0, 0, 8038, 8039, 7, 4, 0, 0, 8039, 8040, 7, 14, 0, 0, 8040, 628, + 1, 0, 0, 0, 8041, 8042, 7, 8, 0, 0, 8042, 8043, 7, 10, 0, 0, 8043, 8044, + 7, 3, 0, 0, 8044, 8045, 7, 3, 0, 0, 8045, 8046, 7, 6, 0, 0, 8046, 8047, + 7, 7, 0, 0, 8047, 8048, 7, 4, 0, 0, 8048, 630, 1, 0, 0, 0, 8049, 8050, + 7, 8, 0, 0, 8050, 8051, 7, 10, 0, 0, 8051, 8052, 7, 3, 0, 0, 8052, 8053, + 7, 3, 0, 0, 8053, 8054, 7, 6, 0, 0, 8054, 8055, 7, 7, 0, 0, 8055, 8056, + 7, 4, 0, 0, 8056, 8057, 5, 95, 0, 0, 8057, 8058, 7, 9, 0, 0, 8058, 8059, + 7, 0, 0, 0, 8059, 8060, 7, 4, 0, 0, 8060, 8061, 7, 6, 0, 0, 8061, 632, + 1, 0, 0, 0, 8062, 8063, 7, 8, 0, 0, 8063, 8064, 7, 10, 0, 0, 8064, 8065, + 7, 3, 0, 0, 8065, 8066, 7, 3, 0, 0, 8066, 8067, 7, 6, 0, 0, 8067, 8068, + 7, 7, 0, 0, 8068, 8069, 7, 4, 0, 0, 8069, 8070, 5, 95, 0, 0, 8070, 8071, + 7, 5, 0, 0, 8071, 8072, 7, 8, 0, 0, 8072, 8073, 7, 19, 0, 0, 8073, 8074, + 7, 6, 0, 0, 8074, 8075, 7, 14, 0, 0, 8075, 8076, 7, 0, 0, 0, 8076, 634, + 1, 0, 0, 0, 8077, 8078, 7, 8, 0, 0, 8078, 8079, 7, 10, 0, 0, 8079, 8080, + 7, 3, 0, 0, 8080, 8081, 7, 3, 0, 0, 8081, 8082, 7, 6, 0, 0, 8082, 8083, + 7, 7, 0, 0, 8083, 8084, 7, 4, 0, 0, 8084, 8085, 5, 95, 0, 0, 8085, 8086, + 7, 4, 0, 0, 8086, 8087, 7, 12, 0, 0, 8087, 8088, 7, 14, 0, 0, 8088, 8089, + 7, 6, 0, 0, 8089, 636, 1, 0, 0, 0, 8090, 8091, 7, 8, 0, 0, 8091, 8092, + 7, 10, 0, 0, 8092, 8093, 7, 3, 0, 0, 8093, 8094, 7, 3, 0, 0, 8094, 8095, + 7, 6, 0, 0, 8095, 8096, 7, 7, 0, 0, 8096, 8097, 7, 4, 0, 0, 8097, 8098, + 5, 95, 0, 0, 8098, 8099, 7, 4, 0, 0, 8099, 8100, 7, 12, 0, 0, 8100, 8101, + 7, 14, 0, 0, 8101, 8102, 7, 6, 0, 0, 8102, 8103, 7, 5, 0, 0, 8103, 8104, + 7, 4, 0, 0, 8104, 8105, 7, 0, 0, 0, 8105, 8106, 7, 14, 0, 0, 8106, 8107, + 7, 15, 0, 0, 8107, 638, 1, 0, 0, 0, 8108, 8109, 7, 8, 0, 0, 8109, 8110, + 7, 10, 0, 0, 8110, 8111, 7, 3, 0, 0, 8111, 8112, 7, 3, 0, 0, 8112, 8113, + 7, 6, 0, 0, 8113, 8114, 7, 7, 0, 0, 8114, 8115, 7, 4, 0, 0, 8115, 8116, + 5, 95, 0, 0, 8116, 8117, 7, 10, 0, 0, 8117, 8118, 7, 5, 0, 0, 8118, 8119, + 7, 6, 0, 0, 8119, 8120, 7, 3, 0, 0, 8120, 640, 1, 0, 0, 0, 8121, 8122, + 7, 8, 0, 0, 8122, 8123, 7, 10, 0, 0, 8123, 8124, 7, 3, 0, 0, 8124, 8125, + 7, 3, 0, 0, 8125, 8126, 7, 6, 0, 0, 8126, 8127, 7, 7, 0, 0, 8127, 8128, + 7, 4, 0, 0, 8128, 8129, 7, 13, 0, 0, 8129, 642, 1, 0, 0, 0, 8130, 8131, + 7, 8, 0, 0, 8131, 8132, 7, 10, 0, 0, 8132, 8133, 7, 3, 0, 0, 8133, 8134, + 7, 5, 0, 0, 8134, 8135, 7, 2, 0, 0, 8135, 8136, 7, 3, 0, 0, 8136, 644, + 1, 0, 0, 0, 8137, 8138, 7, 8, 0, 0, 8138, 8139, 7, 10, 0, 0, 8139, 8140, + 7, 3, 0, 0, 8140, 8141, 7, 5, 0, 0, 8141, 8142, 7, 2, 0, 0, 8142, 8143, + 7, 3, 0, 0, 8143, 8144, 5, 95, 0, 0, 8144, 8145, 7, 5, 0, 0, 8145, 8146, + 7, 19, 0, 0, 8146, 8147, 7, 0, 0, 0, 8147, 8148, 7, 3, 0, 0, 8148, 8149, + 7, 12, 0, 0, 8149, 8150, 7, 7, 0, 0, 8150, 8151, 7, 17, 0, 0, 8151, 8152, + 5, 95, 0, 0, 8152, 8153, 7, 6, 0, 0, 8153, 8154, 7, 25, 0, 0, 8154, 8155, + 7, 0, 0, 0, 8155, 8156, 7, 8, 0, 0, 8156, 8157, 7, 4, 0, 0, 8157, 646, + 1, 0, 0, 0, 8158, 8159, 7, 8, 0, 0, 8159, 8160, 7, 10, 0, 0, 8160, 8161, + 7, 3, 0, 0, 8161, 8162, 7, 5, 0, 0, 8162, 8163, 7, 2, 0, 0, 8163, 8164, + 7, 3, 0, 0, 8164, 8165, 5, 95, 0, 0, 8165, 8166, 7, 5, 0, 0, 8166, 8167, + 7, 15, 0, 0, 8167, 8168, 7, 6, 0, 0, 8168, 8169, 7, 8, 0, 0, 8169, 8170, + 7, 12, 0, 0, 8170, 8171, 7, 16, 0, 0, 8171, 8172, 7, 12, 0, 0, 8172, 8173, + 7, 8, 0, 0, 8173, 8174, 5, 95, 0, 0, 8174, 8175, 7, 5, 0, 0, 8175, 8176, + 7, 6, 0, 0, 8176, 8177, 7, 17, 0, 0, 8177, 8178, 7, 14, 0, 0, 8178, 8179, + 7, 6, 0, 0, 8179, 8180, 7, 7, 0, 0, 8180, 8181, 7, 4, 0, 0, 8181, 648, + 1, 0, 0, 0, 8182, 8183, 7, 8, 0, 0, 8183, 8184, 7, 10, 0, 0, 8184, 8185, + 7, 5, 0, 0, 8185, 8186, 7, 4, 0, 0, 8186, 8187, 7, 2, 0, 0, 8187, 8188, + 7, 14, 0, 0, 8188, 8189, 7, 9, 0, 0, 8189, 8190, 7, 0, 0, 0, 8190, 8191, + 7, 4, 0, 0, 8191, 8192, 7, 10, 0, 0, 8192, 8193, 7, 14, 0, 0, 8193, 650, + 1, 0, 0, 0, 8194, 8195, 7, 8, 0, 0, 8195, 8196, 7, 13, 0, 0, 8196, 652, + 1, 0, 0, 0, 8197, 8198, 7, 8, 0, 0, 8198, 8199, 7, 18, 0, 0, 8199, 8200, + 7, 8, 0, 0, 8200, 8201, 7, 11, 0, 0, 8201, 8202, 7, 6, 0, 0, 8202, 654, + 1, 0, 0, 0, 8203, 8204, 7, 9, 0, 0, 8204, 8205, 7, 0, 0, 0, 8205, 8206, + 7, 7, 0, 0, 8206, 8207, 7, 17, 0, 0, 8207, 8208, 7, 11, 0, 0, 8208, 8209, + 7, 12, 0, 0, 8209, 8210, 7, 7, 0, 0, 8210, 8211, 7, 17, 0, 0, 8211, 656, + 1, 0, 0, 0, 8212, 8213, 7, 9, 0, 0, 8213, 8214, 7, 0, 0, 0, 8214, 8215, + 7, 4, 0, 0, 8215, 8216, 7, 0, 0, 0, 8216, 8217, 7, 1, 0, 0, 8217, 8218, + 7, 0, 0, 0, 8218, 8219, 7, 5, 0, 0, 8219, 8220, 7, 6, 0, 0, 8220, 658, + 1, 0, 0, 0, 8221, 8222, 7, 9, 0, 0, 8222, 8223, 7, 0, 0, 0, 8223, 8224, + 7, 4, 0, 0, 8224, 8225, 7, 0, 0, 0, 8225, 660, 1, 0, 0, 0, 8226, 8227, + 7, 9, 0, 0, 8227, 8228, 7, 0, 0, 0, 8228, 8229, 7, 4, 0, 0, 8229, 8230, + 7, 0, 0, 0, 8230, 8231, 7, 16, 0, 0, 8231, 8232, 7, 12, 0, 0, 8232, 8233, + 7, 11, 0, 0, 8233, 8234, 7, 6, 0, 0, 8234, 662, 1, 0, 0, 0, 8235, 8236, + 7, 9, 0, 0, 8236, 8237, 7, 0, 0, 0, 8237, 8238, 7, 4, 0, 0, 8238, 8239, + 7, 0, 0, 0, 8239, 8240, 7, 16, 0, 0, 8240, 8241, 7, 12, 0, 0, 8241, 8242, + 7, 11, 0, 0, 8242, 8243, 7, 6, 0, 0, 8243, 8244, 7, 5, 0, 0, 8244, 664, + 1, 0, 0, 0, 8245, 8246, 7, 9, 0, 0, 8246, 8247, 7, 0, 0, 0, 8247, 8248, + 7, 4, 0, 0, 8248, 8249, 7, 0, 0, 0, 8249, 8250, 7, 14, 0, 0, 8250, 8251, + 7, 2, 0, 0, 8251, 8252, 7, 13, 0, 0, 8252, 8253, 7, 6, 0, 0, 8253, 8254, + 7, 14, 0, 0, 8254, 8255, 7, 6, 0, 0, 8255, 8256, 7, 7, 0, 0, 8256, 8257, + 7, 4, 0, 0, 8257, 666, 1, 0, 0, 0, 8258, 8259, 7, 9, 0, 0, 8259, 8260, + 7, 0, 0, 0, 8260, 8261, 7, 4, 0, 0, 8261, 8262, 7, 0, 0, 0, 8262, 8263, + 7, 2, 0, 0, 8263, 8264, 7, 1, 0, 0, 8264, 8265, 7, 20, 0, 0, 8265, 8266, + 7, 7, 0, 0, 8266, 8267, 7, 2, 0, 0, 8267, 668, 1, 0, 0, 0, 8268, 8269, + 7, 9, 0, 0, 8269, 8270, 7, 0, 0, 0, 8270, 8271, 7, 4, 0, 0, 8271, 8272, + 7, 0, 0, 0, 8272, 8273, 7, 2, 0, 0, 8273, 8274, 7, 1, 0, 0, 8274, 8275, + 7, 20, 0, 0, 8275, 8276, 5, 95, 0, 0, 8276, 8277, 7, 4, 0, 0, 8277, 8278, + 7, 2, 0, 0, 8278, 8279, 5, 95, 0, 0, 8279, 8280, 7, 14, 0, 0, 8280, 8281, + 7, 0, 0, 0, 8281, 8282, 7, 4, 0, 0, 8282, 8283, 5, 95, 0, 0, 8283, 8284, + 7, 15, 0, 0, 8284, 8285, 7, 0, 0, 0, 8285, 8286, 7, 3, 0, 0, 8286, 8287, + 7, 4, 0, 0, 8287, 8288, 7, 12, 0, 0, 8288, 8289, 7, 4, 0, 0, 8289, 8290, + 7, 12, 0, 0, 8290, 8291, 7, 2, 0, 0, 8291, 8292, 7, 7, 0, 0, 8292, 670, + 1, 0, 0, 0, 8293, 8294, 7, 9, 0, 0, 8294, 8295, 7, 0, 0, 0, 8295, 8296, + 7, 4, 0, 0, 8296, 8297, 7, 0, 0, 0, 8297, 8298, 7, 2, 0, 0, 8298, 8299, + 7, 1, 0, 0, 8299, 8300, 7, 20, 0, 0, 8300, 8301, 5, 95, 0, 0, 8301, 8302, + 7, 4, 0, 0, 8302, 8303, 7, 2, 0, 0, 8303, 8304, 5, 95, 0, 0, 8304, 8305, + 7, 15, 0, 0, 8305, 8306, 7, 0, 0, 0, 8306, 8307, 7, 3, 0, 0, 8307, 8308, + 7, 4, 0, 0, 8308, 8309, 7, 12, 0, 0, 8309, 8310, 7, 4, 0, 0, 8310, 8311, + 7, 12, 0, 0, 8311, 8312, 7, 2, 0, 0, 8312, 8313, 7, 7, 0, 0, 8313, 672, + 1, 0, 0, 0, 8314, 8315, 7, 9, 0, 0, 8315, 8316, 7, 0, 0, 0, 8316, 8317, + 7, 4, 0, 0, 8317, 8318, 7, 0, 0, 0, 8318, 8319, 7, 15, 0, 0, 8319, 8320, + 7, 10, 0, 0, 8320, 8321, 7, 14, 0, 0, 8321, 8322, 7, 15, 0, 0, 8322, 674, + 1, 0, 0, 0, 8323, 8324, 7, 9, 0, 0, 8324, 8325, 7, 0, 0, 0, 8325, 8326, + 7, 4, 0, 0, 8326, 8327, 7, 0, 0, 0, 8327, 8328, 5, 95, 0, 0, 8328, 8329, + 7, 5, 0, 0, 8329, 8330, 7, 6, 0, 0, 8330, 8331, 7, 8, 0, 0, 8331, 8332, + 7, 10, 0, 0, 8332, 8333, 7, 3, 0, 0, 8333, 8334, 7, 12, 0, 0, 8334, 8335, + 7, 4, 0, 0, 8335, 8336, 7, 18, 0, 0, 8336, 8337, 5, 95, 0, 0, 8337, 8338, + 7, 3, 0, 0, 8338, 8339, 7, 6, 0, 0, 8339, 8340, 7, 22, 0, 0, 8340, 8341, + 7, 3, 0, 0, 8341, 8342, 7, 12, 0, 0, 8342, 8343, 7, 4, 0, 0, 8343, 8344, + 7, 6, 0, 0, 8344, 8345, 5, 95, 0, 0, 8345, 8346, 7, 11, 0, 0, 8346, 8347, + 7, 12, 0, 0, 8347, 8348, 7, 14, 0, 0, 8348, 8349, 7, 12, 0, 0, 8349, 8350, + 7, 4, 0, 0, 8350, 676, 1, 0, 0, 0, 8351, 8352, 7, 9, 0, 0, 8352, 8353, + 7, 0, 0, 0, 8353, 8354, 7, 4, 0, 0, 8354, 8355, 7, 6, 0, 0, 8355, 678, + 1, 0, 0, 0, 8356, 8357, 7, 9, 0, 0, 8357, 8358, 7, 0, 0, 0, 8358, 8359, + 7, 4, 0, 0, 8359, 8360, 7, 6, 0, 0, 8360, 8361, 5, 95, 0, 0, 8361, 8362, + 7, 14, 0, 0, 8362, 8363, 7, 2, 0, 0, 8363, 8364, 7, 9, 0, 0, 8364, 8365, + 7, 6, 0, 0, 8365, 680, 1, 0, 0, 0, 8366, 8367, 7, 9, 0, 0, 8367, 8368, + 7, 0, 0, 0, 8368, 8369, 7, 18, 0, 0, 8369, 682, 1, 0, 0, 0, 8370, 8371, + 7, 9, 0, 0, 8371, 8372, 7, 0, 0, 0, 8372, 8373, 7, 18, 0, 0, 8373, 8374, + 7, 5, 0, 0, 8374, 684, 1, 0, 0, 0, 8375, 8376, 7, 9, 0, 0, 8376, 8377, + 7, 1, 0, 0, 8377, 8378, 7, 0, 0, 0, 8378, 686, 1, 0, 0, 0, 8379, 8380, + 7, 9, 0, 0, 8380, 8381, 7, 1, 0, 0, 8381, 8382, 7, 0, 0, 0, 8382, 8383, + 5, 95, 0, 0, 8383, 8384, 7, 3, 0, 0, 8384, 8385, 7, 6, 0, 0, 8385, 8386, + 7, 8, 0, 0, 8386, 8387, 7, 18, 0, 0, 8387, 8388, 7, 8, 0, 0, 8388, 8389, + 7, 11, 0, 0, 8389, 8390, 7, 6, 0, 0, 8390, 8391, 7, 1, 0, 0, 8391, 8392, + 7, 12, 0, 0, 8392, 8393, 7, 7, 0, 0, 8393, 688, 1, 0, 0, 0, 8394, 8395, + 7, 9, 0, 0, 8395, 8396, 7, 1, 0, 0, 8396, 8397, 7, 14, 0, 0, 8397, 8398, + 7, 5, 0, 0, 8398, 8399, 5, 95, 0, 0, 8399, 8400, 7, 5, 0, 0, 8400, 8401, + 7, 4, 0, 0, 8401, 8402, 7, 0, 0, 0, 8402, 8403, 7, 4, 0, 0, 8403, 8404, + 7, 5, 0, 0, 8404, 690, 1, 0, 0, 0, 8405, 8406, 7, 9, 0, 0, 8406, 8407, + 7, 1, 0, 0, 8407, 8408, 5, 95, 0, 0, 8408, 8409, 7, 3, 0, 0, 8409, 8410, + 7, 2, 0, 0, 8410, 8411, 7, 11, 0, 0, 8411, 8412, 7, 6, 0, 0, 8412, 8413, + 5, 95, 0, 0, 8413, 8414, 7, 8, 0, 0, 8414, 8415, 7, 19, 0, 0, 8415, 8416, + 7, 0, 0, 0, 8416, 8417, 7, 7, 0, 0, 8417, 8418, 7, 17, 0, 0, 8418, 8419, + 7, 6, 0, 0, 8419, 692, 1, 0, 0, 0, 8420, 8421, 7, 9, 0, 0, 8421, 8422, + 7, 1, 0, 0, 8422, 8423, 7, 4, 0, 0, 8423, 8424, 7, 12, 0, 0, 8424, 8425, + 7, 14, 0, 0, 8425, 8426, 7, 6, 0, 0, 8426, 8427, 7, 23, 0, 0, 8427, 8428, + 7, 2, 0, 0, 8428, 8429, 7, 7, 0, 0, 8429, 8430, 7, 6, 0, 0, 8430, 694, + 1, 0, 0, 0, 8431, 8432, 7, 9, 0, 0, 8432, 8433, 7, 1, 0, 0, 8433, 8434, + 5, 95, 0, 0, 8434, 8435, 7, 10, 0, 0, 8435, 8436, 7, 7, 0, 0, 8436, 8437, + 7, 12, 0, 0, 8437, 8438, 7, 24, 0, 0, 8438, 8439, 7, 10, 0, 0, 8439, 8440, + 7, 6, 0, 0, 8440, 8441, 5, 95, 0, 0, 8441, 8442, 7, 7, 0, 0, 8442, 8443, + 7, 0, 0, 0, 8443, 8444, 7, 14, 0, 0, 8444, 8445, 7, 6, 0, 0, 8445, 696, + 1, 0, 0, 0, 8446, 8447, 7, 9, 0, 0, 8447, 8448, 7, 1, 0, 0, 8448, 8449, + 5, 95, 0, 0, 8449, 8450, 7, 13, 0, 0, 8450, 8451, 7, 6, 0, 0, 8451, 8452, + 7, 3, 0, 0, 8452, 8453, 7, 5, 0, 0, 8453, 8454, 7, 12, 0, 0, 8454, 8455, + 7, 2, 0, 0, 8455, 8456, 7, 7, 0, 0, 8456, 698, 1, 0, 0, 0, 8457, 8458, + 7, 9, 0, 0, 8458, 8459, 7, 9, 0, 0, 8459, 8460, 7, 11, 0, 0, 8460, 700, + 1, 0, 0, 0, 8461, 8462, 7, 9, 0, 0, 8462, 8463, 7, 6, 0, 0, 8463, 8464, + 7, 0, 0, 0, 8464, 8465, 7, 11, 0, 0, 8465, 8466, 7, 11, 0, 0, 8466, 8467, + 7, 2, 0, 0, 8467, 8468, 7, 8, 0, 0, 8468, 8469, 7, 0, 0, 0, 8469, 8470, + 7, 4, 0, 0, 8470, 8471, 7, 6, 0, 0, 8471, 702, 1, 0, 0, 0, 8472, 8473, + 7, 9, 0, 0, 8473, 8474, 7, 6, 0, 0, 8474, 8475, 7, 1, 0, 0, 8475, 8476, + 7, 10, 0, 0, 8476, 8477, 7, 17, 0, 0, 8477, 704, 1, 0, 0, 0, 8478, 8479, + 7, 9, 0, 0, 8479, 8480, 7, 6, 0, 0, 8480, 8481, 7, 1, 0, 0, 8481, 8482, + 7, 10, 0, 0, 8482, 8483, 7, 17, 0, 0, 8483, 8484, 7, 17, 0, 0, 8484, 8485, + 7, 6, 0, 0, 8485, 8486, 7, 3, 0, 0, 8486, 706, 1, 0, 0, 0, 8487, 8488, + 7, 9, 0, 0, 8488, 8489, 7, 6, 0, 0, 8489, 8490, 7, 8, 0, 0, 8490, 708, + 1, 0, 0, 0, 8491, 8492, 7, 9, 0, 0, 8492, 8493, 7, 6, 0, 0, 8493, 8494, + 7, 8, 0, 0, 8494, 8495, 7, 12, 0, 0, 8495, 8496, 7, 14, 0, 0, 8496, 8497, + 7, 0, 0, 0, 8497, 8498, 7, 11, 0, 0, 8498, 710, 1, 0, 0, 0, 8499, 8500, + 7, 9, 0, 0, 8500, 8501, 7, 6, 0, 0, 8501, 8502, 7, 8, 0, 0, 8502, 8503, + 7, 11, 0, 0, 8503, 8504, 7, 0, 0, 0, 8504, 8505, 7, 3, 0, 0, 8505, 8506, + 7, 6, 0, 0, 8506, 712, 1, 0, 0, 0, 8507, 8508, 7, 9, 0, 0, 8508, 8509, + 7, 6, 0, 0, 8509, 8510, 7, 8, 0, 0, 8510, 8511, 7, 2, 0, 0, 8511, 8512, + 7, 14, 0, 0, 8512, 8513, 7, 15, 0, 0, 8513, 8514, 7, 2, 0, 0, 8514, 8515, + 7, 5, 0, 0, 8515, 8516, 7, 6, 0, 0, 8516, 714, 1, 0, 0, 0, 8517, 8518, + 7, 9, 0, 0, 8518, 8519, 7, 6, 0, 0, 8519, 8520, 7, 8, 0, 0, 8520, 8521, + 7, 2, 0, 0, 8521, 8522, 7, 3, 0, 0, 8522, 8523, 7, 3, 0, 0, 8523, 8524, + 7, 6, 0, 0, 8524, 8525, 7, 11, 0, 0, 8525, 8526, 7, 0, 0, 0, 8526, 8527, + 7, 4, 0, 0, 8527, 8528, 7, 6, 0, 0, 8528, 716, 1, 0, 0, 0, 8529, 8530, + 7, 9, 0, 0, 8530, 8531, 7, 6, 0, 0, 8531, 8532, 7, 8, 0, 0, 8532, 8533, + 7, 3, 0, 0, 8533, 718, 1, 0, 0, 0, 8534, 8535, 7, 9, 0, 0, 8535, 8536, + 7, 6, 0, 0, 8536, 8537, 7, 8, 0, 0, 8537, 8538, 7, 3, 0, 0, 8538, 8539, + 7, 6, 0, 0, 8539, 8540, 7, 14, 0, 0, 8540, 8541, 7, 6, 0, 0, 8541, 8542, + 7, 7, 0, 0, 8542, 8543, 7, 4, 0, 0, 8543, 720, 1, 0, 0, 0, 8544, 8545, + 7, 9, 0, 0, 8545, 8546, 7, 6, 0, 0, 8546, 8547, 7, 8, 0, 0, 8547, 8548, + 7, 3, 0, 0, 8548, 8549, 7, 18, 0, 0, 8549, 8550, 7, 15, 0, 0, 8550, 8551, + 7, 4, 0, 0, 8551, 722, 1, 0, 0, 0, 8552, 8553, 7, 9, 0, 0, 8553, 8554, + 7, 6, 0, 0, 8554, 8555, 7, 9, 0, 0, 8555, 8556, 7, 10, 0, 0, 8556, 8557, + 7, 15, 0, 0, 8557, 8558, 7, 11, 0, 0, 8558, 8559, 7, 12, 0, 0, 8559, 8560, + 7, 8, 0, 0, 8560, 8561, 7, 0, 0, 0, 8561, 8562, 7, 4, 0, 0, 8562, 8563, + 7, 6, 0, 0, 8563, 724, 1, 0, 0, 0, 8564, 8565, 7, 9, 0, 0, 8565, 8566, + 7, 6, 0, 0, 8566, 8567, 7, 16, 0, 0, 8567, 8568, 7, 0, 0, 0, 8568, 8569, + 7, 10, 0, 0, 8569, 8570, 7, 11, 0, 0, 8570, 8571, 7, 4, 0, 0, 8571, 726, + 1, 0, 0, 0, 8572, 8573, 7, 9, 0, 0, 8573, 8574, 7, 6, 0, 0, 8574, 8575, + 7, 16, 0, 0, 8575, 8576, 7, 0, 0, 0, 8576, 8577, 7, 10, 0, 0, 8577, 8578, + 7, 11, 0, 0, 8578, 8579, 7, 4, 0, 0, 8579, 8580, 7, 5, 0, 0, 8580, 728, + 1, 0, 0, 0, 8581, 8582, 7, 9, 0, 0, 8582, 8583, 7, 6, 0, 0, 8583, 8584, + 7, 16, 0, 0, 8584, 8585, 7, 0, 0, 0, 8585, 8586, 7, 10, 0, 0, 8586, 8587, + 7, 11, 0, 0, 8587, 8588, 7, 4, 0, 0, 8588, 8589, 5, 95, 0, 0, 8589, 8590, + 7, 8, 0, 0, 8590, 8591, 7, 2, 0, 0, 8591, 8592, 7, 11, 0, 0, 8592, 8593, + 7, 11, 0, 0, 8593, 8594, 7, 0, 0, 0, 8594, 8595, 7, 4, 0, 0, 8595, 8596, + 7, 12, 0, 0, 8596, 8597, 7, 2, 0, 0, 8597, 8598, 7, 7, 0, 0, 8598, 730, + 1, 0, 0, 0, 8599, 8600, 7, 9, 0, 0, 8600, 8601, 7, 6, 0, 0, 8601, 8602, + 7, 16, 0, 0, 8602, 8603, 7, 0, 0, 0, 8603, 8604, 7, 10, 0, 0, 8604, 8605, + 7, 11, 0, 0, 8605, 8606, 7, 4, 0, 0, 8606, 8607, 5, 95, 0, 0, 8607, 8608, + 7, 8, 0, 0, 8608, 8609, 7, 3, 0, 0, 8609, 8610, 7, 6, 0, 0, 8610, 8611, + 7, 9, 0, 0, 8611, 8612, 7, 6, 0, 0, 8612, 8613, 7, 7, 0, 0, 8613, 8614, + 7, 4, 0, 0, 8614, 8615, 7, 12, 0, 0, 8615, 8616, 7, 0, 0, 0, 8616, 8617, + 7, 11, 0, 0, 8617, 732, 1, 0, 0, 0, 8618, 8619, 7, 9, 0, 0, 8619, 8620, + 7, 6, 0, 0, 8620, 8621, 7, 16, 0, 0, 8621, 8622, 7, 6, 0, 0, 8622, 8623, + 7, 3, 0, 0, 8623, 8624, 7, 3, 0, 0, 8624, 8625, 7, 0, 0, 0, 8625, 8626, + 7, 1, 0, 0, 8626, 8627, 7, 11, 0, 0, 8627, 8628, 7, 6, 0, 0, 8628, 734, + 1, 0, 0, 0, 8629, 8630, 7, 9, 0, 0, 8630, 8631, 7, 6, 0, 0, 8631, 8632, + 7, 16, 0, 0, 8632, 8633, 7, 6, 0, 0, 8633, 8634, 7, 3, 0, 0, 8634, 8635, + 7, 3, 0, 0, 8635, 8636, 7, 6, 0, 0, 8636, 8637, 7, 9, 0, 0, 8637, 736, + 1, 0, 0, 0, 8638, 8639, 7, 9, 0, 0, 8639, 8640, 7, 6, 0, 0, 8640, 8641, + 7, 16, 0, 0, 8641, 8642, 7, 12, 0, 0, 8642, 8643, 7, 7, 0, 0, 8643, 8644, + 7, 6, 0, 0, 8644, 8645, 7, 9, 0, 0, 8645, 738, 1, 0, 0, 0, 8646, 8647, + 7, 9, 0, 0, 8647, 8648, 7, 6, 0, 0, 8648, 8649, 7, 16, 0, 0, 8649, 8650, + 7, 12, 0, 0, 8650, 8651, 7, 7, 0, 0, 8651, 8652, 7, 6, 0, 0, 8652, 740, + 1, 0, 0, 0, 8653, 8654, 7, 9, 0, 0, 8654, 8655, 7, 6, 0, 0, 8655, 8656, + 7, 16, 0, 0, 8656, 8657, 7, 12, 0, 0, 8657, 8658, 7, 7, 0, 0, 8658, 8659, + 7, 6, 0, 0, 8659, 8660, 7, 3, 0, 0, 8660, 742, 1, 0, 0, 0, 8661, 8662, + 7, 9, 0, 0, 8662, 8663, 7, 6, 0, 0, 8663, 8664, 7, 17, 0, 0, 8664, 8665, + 7, 3, 0, 0, 8665, 8666, 7, 6, 0, 0, 8666, 8667, 7, 6, 0, 0, 8667, 744, + 1, 0, 0, 0, 8668, 8669, 7, 9, 0, 0, 8669, 8670, 7, 6, 0, 0, 8670, 8671, + 7, 11, 0, 0, 8671, 8672, 7, 0, 0, 0, 8672, 8673, 7, 18, 0, 0, 8673, 746, + 1, 0, 0, 0, 8674, 8675, 7, 9, 0, 0, 8675, 8676, 7, 6, 0, 0, 8676, 8677, + 7, 11, 0, 0, 8677, 8678, 7, 6, 0, 0, 8678, 8679, 7, 17, 0, 0, 8679, 8680, + 7, 0, 0, 0, 8680, 8681, 7, 4, 0, 0, 8681, 8682, 7, 6, 0, 0, 8682, 748, + 1, 0, 0, 0, 8683, 8684, 7, 9, 0, 0, 8684, 8685, 7, 6, 0, 0, 8685, 8686, + 7, 11, 0, 0, 8686, 8687, 7, 6, 0, 0, 8687, 8688, 7, 4, 0, 0, 8688, 8689, + 7, 6, 0, 0, 8689, 8690, 5, 95, 0, 0, 8690, 8691, 7, 0, 0, 0, 8691, 8692, + 7, 11, 0, 0, 8692, 8693, 7, 11, 0, 0, 8693, 750, 1, 0, 0, 0, 8694, 8695, + 7, 9, 0, 0, 8695, 8696, 7, 6, 0, 0, 8696, 8697, 7, 11, 0, 0, 8697, 8698, + 7, 6, 0, 0, 8698, 8699, 7, 4, 0, 0, 8699, 8700, 7, 6, 0, 0, 8700, 752, + 1, 0, 0, 0, 8701, 8702, 7, 9, 0, 0, 8702, 8703, 7, 6, 0, 0, 8703, 8704, + 7, 11, 0, 0, 8704, 8705, 7, 6, 0, 0, 8705, 8706, 7, 4, 0, 0, 8706, 8707, + 7, 6, 0, 0, 8707, 8708, 7, 25, 0, 0, 8708, 8709, 7, 14, 0, 0, 8709, 8710, + 7, 11, 0, 0, 8710, 754, 1, 0, 0, 0, 8711, 8712, 7, 9, 0, 0, 8712, 8713, + 7, 6, 0, 0, 8713, 8714, 7, 14, 0, 0, 8714, 8715, 7, 0, 0, 0, 8715, 8716, + 7, 7, 0, 0, 8716, 8717, 7, 9, 0, 0, 8717, 756, 1, 0, 0, 0, 8718, 8719, + 7, 9, 0, 0, 8719, 8720, 7, 6, 0, 0, 8720, 8721, 7, 7, 0, 0, 8721, 8722, + 7, 5, 0, 0, 8722, 8723, 7, 6, 0, 0, 8723, 8724, 5, 95, 0, 0, 8724, 8725, + 7, 3, 0, 0, 8725, 8726, 7, 0, 0, 0, 8726, 8727, 7, 7, 0, 0, 8727, 8728, + 7, 21, 0, 0, 8728, 8729, 7, 14, 0, 0, 8729, 758, 1, 0, 0, 0, 8730, 8731, + 7, 9, 0, 0, 8731, 8732, 7, 6, 0, 0, 8732, 8733, 7, 15, 0, 0, 8733, 8734, + 7, 6, 0, 0, 8734, 8735, 7, 7, 0, 0, 8735, 8736, 7, 9, 0, 0, 8736, 8737, + 7, 6, 0, 0, 8737, 8738, 7, 7, 0, 0, 8738, 8739, 7, 4, 0, 0, 8739, 760, + 1, 0, 0, 0, 8740, 8741, 7, 9, 0, 0, 8741, 8742, 7, 6, 0, 0, 8742, 8743, + 7, 15, 0, 0, 8743, 8744, 7, 4, 0, 0, 8744, 8745, 7, 19, 0, 0, 8745, 762, + 1, 0, 0, 0, 8746, 8747, 7, 9, 0, 0, 8747, 8748, 7, 6, 0, 0, 8748, 8749, + 7, 24, 0, 0, 8749, 8750, 7, 10, 0, 0, 8750, 8751, 7, 6, 0, 0, 8751, 8752, + 7, 10, 0, 0, 8752, 8753, 7, 6, 0, 0, 8753, 764, 1, 0, 0, 0, 8754, 8755, + 7, 9, 0, 0, 8755, 8756, 7, 6, 0, 0, 8756, 8757, 7, 3, 0, 0, 8757, 8758, + 7, 6, 0, 0, 8758, 8759, 7, 16, 0, 0, 8759, 766, 1, 0, 0, 0, 8760, 8761, + 7, 9, 0, 0, 8761, 8762, 7, 6, 0, 0, 8762, 8763, 7, 3, 0, 0, 8763, 8764, + 7, 6, 0, 0, 8764, 8765, 7, 16, 0, 0, 8765, 8766, 5, 95, 0, 0, 8766, 8767, + 7, 7, 0, 0, 8767, 8768, 7, 2, 0, 0, 8768, 8769, 5, 95, 0, 0, 8769, 8770, + 7, 3, 0, 0, 8770, 8771, 7, 6, 0, 0, 8771, 8772, 7, 22, 0, 0, 8772, 8773, + 7, 3, 0, 0, 8773, 8774, 7, 12, 0, 0, 8774, 8775, 7, 4, 0, 0, 8775, 8776, + 7, 6, 0, 0, 8776, 768, 1, 0, 0, 0, 8777, 8778, 7, 9, 0, 0, 8778, 8779, + 7, 6, 0, 0, 8779, 8780, 7, 5, 0, 0, 8780, 8781, 7, 8, 0, 0, 8781, 770, + 1, 0, 0, 0, 8782, 8783, 7, 9, 0, 0, 8783, 8784, 7, 6, 0, 0, 8784, 8785, + 7, 5, 0, 0, 8785, 8786, 7, 8, 0, 0, 8786, 8787, 7, 3, 0, 0, 8787, 8788, + 7, 12, 0, 0, 8788, 8789, 7, 15, 0, 0, 8789, 8790, 7, 4, 0, 0, 8790, 8791, + 7, 12, 0, 0, 8791, 8792, 7, 2, 0, 0, 8792, 8793, 7, 7, 0, 0, 8793, 772, + 1, 0, 0, 0, 8794, 8795, 7, 9, 0, 0, 8795, 8796, 7, 6, 0, 0, 8796, 8797, + 7, 5, 0, 0, 8797, 8798, 7, 4, 0, 0, 8798, 8799, 7, 3, 0, 0, 8799, 8800, + 7, 2, 0, 0, 8800, 8801, 7, 18, 0, 0, 8801, 774, 1, 0, 0, 0, 8802, 8803, + 7, 9, 0, 0, 8803, 8804, 7, 6, 0, 0, 8804, 8805, 7, 4, 0, 0, 8805, 8806, + 7, 0, 0, 0, 8806, 8807, 7, 8, 0, 0, 8807, 8808, 7, 19, 0, 0, 8808, 8809, + 7, 6, 0, 0, 8809, 8810, 7, 9, 0, 0, 8810, 776, 1, 0, 0, 0, 8811, 8812, + 7, 9, 0, 0, 8812, 8813, 7, 6, 0, 0, 8813, 8814, 7, 4, 0, 0, 8814, 8815, + 7, 6, 0, 0, 8815, 8816, 7, 3, 0, 0, 8816, 8817, 7, 14, 0, 0, 8817, 8818, + 7, 12, 0, 0, 8818, 8819, 7, 7, 0, 0, 8819, 8820, 7, 6, 0, 0, 8820, 8821, + 7, 5, 0, 0, 8821, 778, 1, 0, 0, 0, 8822, 8823, 7, 9, 0, 0, 8823, 8824, + 7, 6, 0, 0, 8824, 8825, 7, 4, 0, 0, 8825, 8826, 7, 6, 0, 0, 8826, 8827, + 7, 3, 0, 0, 8827, 8828, 7, 14, 0, 0, 8828, 8829, 7, 12, 0, 0, 8829, 8830, + 7, 7, 0, 0, 8830, 8831, 7, 12, 0, 0, 8831, 8832, 7, 5, 0, 0, 8832, 8833, + 7, 4, 0, 0, 8833, 8834, 7, 12, 0, 0, 8834, 8835, 7, 8, 0, 0, 8835, 780, + 1, 0, 0, 0, 8836, 8837, 7, 9, 0, 0, 8837, 8838, 7, 12, 0, 0, 8838, 8839, + 7, 8, 0, 0, 8839, 8840, 7, 4, 0, 0, 8840, 8841, 7, 12, 0, 0, 8841, 8842, + 7, 2, 0, 0, 8842, 8843, 7, 7, 0, 0, 8843, 8844, 7, 0, 0, 0, 8844, 8845, + 7, 3, 0, 0, 8845, 8846, 7, 18, 0, 0, 8846, 782, 1, 0, 0, 0, 8847, 8848, + 7, 9, 0, 0, 8848, 8849, 7, 12, 0, 0, 8849, 8850, 7, 14, 0, 0, 8850, 8851, + 7, 6, 0, 0, 8851, 8852, 7, 7, 0, 0, 8852, 8853, 7, 5, 0, 0, 8853, 8854, + 7, 12, 0, 0, 8854, 8855, 7, 2, 0, 0, 8855, 8856, 7, 7, 0, 0, 8856, 784, + 1, 0, 0, 0, 8857, 8858, 7, 9, 0, 0, 8858, 8859, 7, 12, 0, 0, 8859, 8860, + 7, 14, 0, 0, 8860, 8861, 7, 6, 0, 0, 8861, 8862, 7, 7, 0, 0, 8862, 8863, + 7, 5, 0, 0, 8863, 8864, 7, 12, 0, 0, 8864, 8865, 7, 2, 0, 0, 8865, 8866, + 7, 7, 0, 0, 8866, 8867, 7, 5, 0, 0, 8867, 786, 1, 0, 0, 0, 8868, 8869, + 7, 9, 0, 0, 8869, 8870, 7, 12, 0, 0, 8870, 8871, 7, 3, 0, 0, 8871, 8872, + 7, 6, 0, 0, 8872, 8873, 7, 8, 0, 0, 8873, 8874, 7, 4, 0, 0, 8874, 8875, + 5, 95, 0, 0, 8875, 8876, 7, 11, 0, 0, 8876, 8877, 7, 2, 0, 0, 8877, 8878, + 7, 0, 0, 0, 8878, 8879, 7, 9, 0, 0, 8879, 788, 1, 0, 0, 0, 8880, 8881, + 7, 9, 0, 0, 8881, 8882, 7, 12, 0, 0, 8882, 8883, 7, 3, 0, 0, 8883, 8884, + 7, 6, 0, 0, 8884, 8885, 7, 8, 0, 0, 8885, 8886, 7, 4, 0, 0, 8886, 8887, + 7, 2, 0, 0, 8887, 8888, 7, 3, 0, 0, 8888, 8889, 7, 18, 0, 0, 8889, 790, + 1, 0, 0, 0, 8890, 8891, 7, 9, 0, 0, 8891, 8892, 7, 12, 0, 0, 8892, 8893, + 7, 3, 0, 0, 8893, 8894, 7, 6, 0, 0, 8894, 8895, 7, 8, 0, 0, 8895, 8896, + 7, 4, 0, 0, 8896, 8897, 5, 95, 0, 0, 8897, 8898, 7, 15, 0, 0, 8898, 8899, + 7, 0, 0, 0, 8899, 8900, 7, 4, 0, 0, 8900, 8901, 7, 19, 0, 0, 8901, 792, + 1, 0, 0, 0, 8902, 8903, 7, 9, 0, 0, 8903, 8904, 7, 12, 0, 0, 8904, 8905, + 7, 5, 0, 0, 8905, 8906, 7, 0, 0, 0, 8906, 8907, 7, 1, 0, 0, 8907, 8908, + 7, 11, 0, 0, 8908, 8909, 7, 6, 0, 0, 8909, 8910, 5, 95, 0, 0, 8910, 8911, + 7, 0, 0, 0, 8911, 8912, 7, 11, 0, 0, 8912, 8913, 7, 11, 0, 0, 8913, 794, + 1, 0, 0, 0, 8914, 8915, 7, 9, 0, 0, 8915, 8916, 7, 12, 0, 0, 8916, 8917, + 7, 5, 0, 0, 8917, 8918, 7, 0, 0, 0, 8918, 8919, 7, 1, 0, 0, 8919, 8920, + 7, 11, 0, 0, 8920, 8921, 7, 6, 0, 0, 8921, 796, 1, 0, 0, 0, 8922, 8923, + 7, 9, 0, 0, 8923, 8924, 7, 12, 0, 0, 8924, 8925, 7, 5, 0, 0, 8925, 8926, + 7, 0, 0, 0, 8926, 8927, 7, 1, 0, 0, 8927, 8928, 7, 11, 0, 0, 8928, 8929, + 7, 6, 0, 0, 8929, 8930, 5, 95, 0, 0, 8930, 8931, 7, 15, 0, 0, 8931, 8932, + 7, 0, 0, 0, 8932, 8933, 7, 3, 0, 0, 8933, 8934, 7, 0, 0, 0, 8934, 8935, + 7, 11, 0, 0, 8935, 8936, 7, 11, 0, 0, 8936, 8937, 7, 6, 0, 0, 8937, 8938, + 7, 11, 0, 0, 8938, 8939, 5, 95, 0, 0, 8939, 8940, 7, 9, 0, 0, 8940, 8941, + 7, 14, 0, 0, 8941, 8942, 7, 11, 0, 0, 8942, 798, 1, 0, 0, 0, 8943, 8944, + 7, 9, 0, 0, 8944, 8945, 7, 12, 0, 0, 8945, 8946, 7, 5, 0, 0, 8946, 8947, + 7, 0, 0, 0, 8947, 8948, 7, 1, 0, 0, 8948, 8949, 7, 11, 0, 0, 8949, 8950, + 7, 6, 0, 0, 8950, 8951, 5, 95, 0, 0, 8951, 8952, 7, 15, 0, 0, 8952, 8953, + 7, 3, 0, 0, 8953, 8954, 7, 6, 0, 0, 8954, 8955, 7, 5, 0, 0, 8955, 8956, + 7, 6, 0, 0, 8956, 8957, 7, 4, 0, 0, 8957, 800, 1, 0, 0, 0, 8958, 8959, + 7, 9, 0, 0, 8959, 8960, 7, 12, 0, 0, 8960, 8961, 7, 5, 0, 0, 8961, 8962, + 7, 0, 0, 0, 8962, 8963, 7, 1, 0, 0, 8963, 8964, 7, 11, 0, 0, 8964, 8965, + 7, 6, 0, 0, 8965, 8966, 5, 95, 0, 0, 8966, 8967, 7, 3, 0, 0, 8967, 8968, + 7, 15, 0, 0, 8968, 8969, 7, 21, 0, 0, 8969, 8970, 7, 6, 0, 0, 8970, 802, + 1, 0, 0, 0, 8971, 8972, 7, 9, 0, 0, 8972, 8973, 7, 12, 0, 0, 8973, 8974, + 7, 5, 0, 0, 8974, 8975, 7, 0, 0, 0, 8975, 8976, 7, 11, 0, 0, 8976, 8977, + 7, 11, 0, 0, 8977, 8978, 7, 2, 0, 0, 8978, 8979, 7, 22, 0, 0, 8979, 804, + 1, 0, 0, 0, 8980, 8981, 7, 9, 0, 0, 8981, 8982, 7, 12, 0, 0, 8982, 8983, + 7, 5, 0, 0, 8983, 8984, 7, 0, 0, 0, 8984, 8985, 7, 5, 0, 0, 8985, 8986, + 7, 5, 0, 0, 8986, 8987, 7, 2, 0, 0, 8987, 8988, 7, 8, 0, 0, 8988, 8989, + 7, 12, 0, 0, 8989, 8990, 7, 0, 0, 0, 8990, 8991, 7, 4, 0, 0, 8991, 8992, + 7, 6, 0, 0, 8992, 806, 1, 0, 0, 0, 8993, 8994, 7, 9, 0, 0, 8994, 8995, + 7, 12, 0, 0, 8995, 8996, 7, 5, 0, 0, 8996, 8997, 7, 8, 0, 0, 8997, 8998, + 7, 0, 0, 0, 8998, 8999, 7, 3, 0, 0, 8999, 9000, 7, 9, 0, 0, 9000, 808, + 1, 0, 0, 0, 9001, 9002, 7, 9, 0, 0, 9002, 9003, 7, 12, 0, 0, 9003, 9004, + 7, 5, 0, 0, 9004, 9005, 7, 8, 0, 0, 9005, 9006, 7, 2, 0, 0, 9006, 9007, + 7, 7, 0, 0, 9007, 9008, 7, 7, 0, 0, 9008, 9009, 7, 6, 0, 0, 9009, 9010, + 7, 8, 0, 0, 9010, 9011, 7, 4, 0, 0, 9011, 810, 1, 0, 0, 0, 9012, 9013, + 7, 9, 0, 0, 9013, 9014, 7, 12, 0, 0, 9014, 9015, 7, 5, 0, 0, 9015, 9016, + 7, 21, 0, 0, 9016, 812, 1, 0, 0, 0, 9017, 9018, 7, 9, 0, 0, 9018, 9019, + 7, 12, 0, 0, 9019, 9020, 7, 5, 0, 0, 9020, 9021, 7, 21, 0, 0, 9021, 9022, + 7, 17, 0, 0, 9022, 9023, 7, 3, 0, 0, 9023, 9024, 7, 2, 0, 0, 9024, 9025, + 7, 10, 0, 0, 9025, 9026, 7, 15, 0, 0, 9026, 814, 1, 0, 0, 0, 9027, 9028, + 7, 9, 0, 0, 9028, 9029, 7, 12, 0, 0, 9029, 9030, 7, 5, 0, 0, 9030, 9031, + 7, 21, 0, 0, 9031, 9032, 7, 5, 0, 0, 9032, 816, 1, 0, 0, 0, 9033, 9034, + 7, 9, 0, 0, 9034, 9035, 7, 12, 0, 0, 9035, 9036, 7, 5, 0, 0, 9036, 9037, + 7, 14, 0, 0, 9037, 9038, 7, 2, 0, 0, 9038, 9039, 7, 10, 0, 0, 9039, 9040, + 7, 7, 0, 0, 9040, 9041, 7, 4, 0, 0, 9041, 818, 1, 0, 0, 0, 9042, 9043, + 7, 9, 0, 0, 9043, 9044, 7, 12, 0, 0, 9044, 9045, 7, 5, 0, 0, 9045, 9046, + 7, 4, 0, 0, 9046, 9047, 7, 12, 0, 0, 9047, 9048, 7, 7, 0, 0, 9048, 9049, + 7, 8, 0, 0, 9049, 9050, 7, 4, 0, 0, 9050, 820, 1, 0, 0, 0, 9051, 9052, + 7, 9, 0, 0, 9052, 9053, 7, 12, 0, 0, 9053, 9054, 7, 5, 0, 0, 9054, 9055, + 7, 4, 0, 0, 9055, 9056, 7, 12, 0, 0, 9056, 9057, 7, 7, 0, 0, 9057, 9058, + 7, 17, 0, 0, 9058, 9059, 7, 10, 0, 0, 9059, 9060, 7, 12, 0, 0, 9060, 9061, + 7, 5, 0, 0, 9061, 9062, 7, 19, 0, 0, 9062, 9063, 7, 6, 0, 0, 9063, 9064, + 7, 9, 0, 0, 9064, 822, 1, 0, 0, 0, 9065, 9066, 7, 9, 0, 0, 9066, 9067, + 7, 12, 0, 0, 9067, 9068, 7, 5, 0, 0, 9068, 9069, 7, 4, 0, 0, 9069, 9070, + 7, 3, 0, 0, 9070, 9071, 7, 12, 0, 0, 9071, 9072, 7, 1, 0, 0, 9072, 9073, + 7, 10, 0, 0, 9073, 9074, 7, 4, 0, 0, 9074, 9075, 7, 6, 0, 0, 9075, 9076, + 7, 9, 0, 0, 9076, 824, 1, 0, 0, 0, 9077, 9078, 7, 9, 0, 0, 9078, 9079, + 7, 12, 0, 0, 9079, 9080, 7, 5, 0, 0, 9080, 9081, 7, 4, 0, 0, 9081, 9082, + 7, 3, 0, 0, 9082, 9083, 7, 12, 0, 0, 9083, 9084, 7, 1, 0, 0, 9084, 9085, + 7, 10, 0, 0, 9085, 9086, 7, 4, 0, 0, 9086, 9087, 7, 6, 0, 0, 9087, 826, + 1, 0, 0, 0, 9088, 9089, 7, 9, 0, 0, 9089, 9090, 7, 14, 0, 0, 9090, 9091, + 7, 11, 0, 0, 9091, 828, 1, 0, 0, 0, 9092, 9093, 7, 9, 0, 0, 9093, 9094, + 7, 14, 0, 0, 9094, 9095, 7, 11, 0, 0, 9095, 9096, 5, 95, 0, 0, 9096, 9097, + 7, 10, 0, 0, 9097, 9098, 7, 15, 0, 0, 9098, 9099, 7, 9, 0, 0, 9099, 9100, + 7, 0, 0, 0, 9100, 9101, 7, 4, 0, 0, 9101, 9102, 7, 6, 0, 0, 9102, 830, + 1, 0, 0, 0, 9103, 9104, 7, 9, 0, 0, 9104, 9105, 7, 2, 0, 0, 9105, 9106, + 7, 8, 0, 0, 9106, 9107, 7, 16, 0, 0, 9107, 9108, 7, 12, 0, 0, 9108, 9109, + 7, 9, 0, 0, 9109, 9110, 7, 6, 0, 0, 9110, 9111, 7, 11, 0, 0, 9111, 9112, + 7, 12, 0, 0, 9112, 9113, 7, 4, 0, 0, 9113, 9114, 7, 18, 0, 0, 9114, 832, + 1, 0, 0, 0, 9115, 9116, 7, 9, 0, 0, 9116, 9117, 7, 2, 0, 0, 9117, 9118, + 7, 8, 0, 0, 9118, 9119, 7, 10, 0, 0, 9119, 9120, 7, 14, 0, 0, 9120, 9121, + 7, 6, 0, 0, 9121, 9122, 7, 7, 0, 0, 9122, 9123, 7, 4, 0, 0, 9123, 834, + 1, 0, 0, 0, 9124, 9125, 7, 9, 0, 0, 9125, 9126, 7, 2, 0, 0, 9126, 9127, + 7, 14, 0, 0, 9127, 9128, 7, 0, 0, 0, 9128, 9129, 7, 12, 0, 0, 9129, 9130, + 7, 7, 0, 0, 9130, 9131, 5, 95, 0, 0, 9131, 9132, 7, 12, 0, 0, 9132, 9133, + 7, 7, 0, 0, 9133, 9134, 7, 9, 0, 0, 9134, 9135, 7, 6, 0, 0, 9135, 9136, + 7, 25, 0, 0, 9136, 9137, 5, 95, 0, 0, 9137, 9138, 7, 16, 0, 0, 9138, 9139, + 7, 12, 0, 0, 9139, 9140, 7, 11, 0, 0, 9140, 9141, 7, 4, 0, 0, 9141, 9142, + 7, 6, 0, 0, 9142, 9143, 7, 3, 0, 0, 9143, 836, 1, 0, 0, 0, 9144, 9145, + 7, 9, 0, 0, 9145, 9146, 7, 2, 0, 0, 9146, 9147, 7, 14, 0, 0, 9147, 9148, + 7, 0, 0, 0, 9148, 9149, 7, 12, 0, 0, 9149, 9150, 7, 7, 0, 0, 9150, 9151, + 5, 95, 0, 0, 9151, 9152, 7, 12, 0, 0, 9152, 9153, 7, 7, 0, 0, 9153, 9154, + 7, 9, 0, 0, 9154, 9155, 7, 6, 0, 0, 9155, 9156, 7, 25, 0, 0, 9156, 9157, + 5, 95, 0, 0, 9157, 9158, 7, 7, 0, 0, 9158, 9159, 7, 2, 0, 0, 9159, 9160, + 5, 95, 0, 0, 9160, 9161, 7, 5, 0, 0, 9161, 9162, 7, 2, 0, 0, 9162, 9163, + 7, 3, 0, 0, 9163, 9164, 7, 4, 0, 0, 9164, 838, 1, 0, 0, 0, 9165, 9166, + 7, 9, 0, 0, 9166, 9167, 7, 2, 0, 0, 9167, 9168, 7, 14, 0, 0, 9168, 9169, + 7, 0, 0, 0, 9169, 9170, 7, 12, 0, 0, 9170, 9171, 7, 7, 0, 0, 9171, 9172, + 5, 95, 0, 0, 9172, 9173, 7, 12, 0, 0, 9173, 9174, 7, 7, 0, 0, 9174, 9175, + 7, 9, 0, 0, 9175, 9176, 7, 6, 0, 0, 9176, 9177, 7, 25, 0, 0, 9177, 9178, + 5, 95, 0, 0, 9178, 9179, 7, 5, 0, 0, 9179, 9180, 7, 2, 0, 0, 9180, 9181, + 7, 3, 0, 0, 9181, 9182, 7, 4, 0, 0, 9182, 840, 1, 0, 0, 0, 9183, 9184, + 7, 9, 0, 0, 9184, 9185, 7, 2, 0, 0, 9185, 9186, 7, 10, 0, 0, 9186, 9187, + 7, 1, 0, 0, 9187, 9188, 7, 11, 0, 0, 9188, 9189, 7, 6, 0, 0, 9189, 842, + 1, 0, 0, 0, 9190, 9191, 7, 9, 0, 0, 9191, 9192, 7, 2, 0, 0, 9192, 9193, + 7, 22, 0, 0, 9193, 9194, 7, 7, 0, 0, 9194, 9195, 7, 17, 0, 0, 9195, 9196, + 7, 3, 0, 0, 9196, 9197, 7, 0, 0, 0, 9197, 9198, 7, 9, 0, 0, 9198, 9199, + 7, 6, 0, 0, 9199, 844, 1, 0, 0, 0, 9200, 9201, 7, 9, 0, 0, 9201, 9202, + 7, 3, 0, 0, 9202, 9203, 7, 12, 0, 0, 9203, 9204, 7, 13, 0, 0, 9204, 9205, + 7, 12, 0, 0, 9205, 9206, 7, 7, 0, 0, 9206, 9207, 7, 17, 0, 0, 9207, 9208, + 5, 95, 0, 0, 9208, 9209, 7, 5, 0, 0, 9209, 9210, 7, 12, 0, 0, 9210, 9211, + 7, 4, 0, 0, 9211, 9212, 7, 6, 0, 0, 9212, 846, 1, 0, 0, 0, 9213, 9214, + 7, 9, 0, 0, 9214, 9215, 7, 3, 0, 0, 9215, 9216, 7, 2, 0, 0, 9216, 9217, + 7, 15, 0, 0, 9217, 9218, 5, 95, 0, 0, 9218, 9219, 7, 8, 0, 0, 9219, 9220, + 7, 2, 0, 0, 9220, 9221, 7, 11, 0, 0, 9221, 9222, 7, 10, 0, 0, 9222, 9223, + 7, 14, 0, 0, 9223, 9224, 7, 7, 0, 0, 9224, 848, 1, 0, 0, 0, 9225, 9226, + 7, 9, 0, 0, 9226, 9227, 7, 3, 0, 0, 9227, 9228, 7, 2, 0, 0, 9228, 9229, + 7, 15, 0, 0, 9229, 850, 1, 0, 0, 0, 9230, 9231, 7, 9, 0, 0, 9231, 9232, + 7, 3, 0, 0, 9232, 9233, 7, 2, 0, 0, 9233, 9234, 7, 15, 0, 0, 9234, 9235, + 5, 95, 0, 0, 9235, 9236, 7, 17, 0, 0, 9236, 9237, 7, 3, 0, 0, 9237, 9238, + 7, 2, 0, 0, 9238, 9239, 7, 10, 0, 0, 9239, 9240, 7, 15, 0, 0, 9240, 852, + 1, 0, 0, 0, 9241, 9242, 7, 9, 0, 0, 9242, 9243, 7, 5, 0, 0, 9243, 9244, + 7, 12, 0, 0, 9244, 9245, 7, 7, 0, 0, 9245, 9246, 7, 4, 0, 0, 9246, 9247, + 7, 6, 0, 0, 9247, 9248, 7, 3, 0, 0, 9248, 9249, 7, 13, 0, 0, 9249, 9250, + 7, 0, 0, 0, 9250, 9251, 7, 11, 0, 0, 9251, 9252, 5, 95, 0, 0, 9252, 9253, + 7, 10, 0, 0, 9253, 9254, 7, 7, 0, 0, 9254, 9255, 7, 8, 0, 0, 9255, 9256, + 7, 2, 0, 0, 9256, 9257, 7, 7, 0, 0, 9257, 9258, 7, 5, 0, 0, 9258, 9259, + 7, 4, 0, 0, 9259, 9260, 7, 3, 0, 0, 9260, 9261, 7, 0, 0, 0, 9261, 9262, + 7, 12, 0, 0, 9262, 9263, 7, 7, 0, 0, 9263, 9264, 7, 6, 0, 0, 9264, 9265, + 7, 9, 0, 0, 9265, 854, 1, 0, 0, 0, 9266, 9267, 7, 9, 0, 0, 9267, 9268, + 7, 5, 0, 0, 9268, 9269, 7, 4, 0, 0, 9269, 9270, 5, 95, 0, 0, 9270, 9271, + 7, 10, 0, 0, 9271, 9272, 7, 15, 0, 0, 9272, 9273, 7, 17, 0, 0, 9273, 9274, + 7, 3, 0, 0, 9274, 9275, 7, 0, 0, 0, 9275, 9276, 7, 9, 0, 0, 9276, 9277, + 7, 6, 0, 0, 9277, 9278, 5, 95, 0, 0, 9278, 9279, 7, 12, 0, 0, 9279, 9280, + 7, 7, 0, 0, 9280, 9281, 7, 5, 0, 0, 9281, 9282, 7, 6, 0, 0, 9282, 9283, + 7, 3, 0, 0, 9283, 9284, 7, 4, 0, 0, 9284, 9285, 5, 95, 0, 0, 9285, 9286, + 7, 8, 0, 0, 9286, 9287, 7, 2, 0, 0, 9287, 9288, 7, 7, 0, 0, 9288, 9289, + 7, 13, 0, 0, 9289, 856, 1, 0, 0, 0, 9290, 9291, 7, 9, 0, 0, 9291, 9292, + 7, 10, 0, 0, 9292, 9293, 7, 14, 0, 0, 9293, 9294, 7, 15, 0, 0, 9294, 858, + 1, 0, 0, 0, 9295, 9296, 7, 9, 0, 0, 9296, 9297, 7, 10, 0, 0, 9297, 9298, + 7, 15, 0, 0, 9298, 9299, 7, 11, 0, 0, 9299, 9300, 7, 12, 0, 0, 9300, 9301, + 7, 8, 0, 0, 9301, 9302, 7, 0, 0, 0, 9302, 9303, 7, 4, 0, 0, 9303, 9304, + 7, 6, 0, 0, 9304, 860, 1, 0, 0, 0, 9305, 9306, 7, 9, 0, 0, 9306, 9307, + 7, 13, 0, 0, 9307, 862, 1, 0, 0, 0, 9308, 9309, 7, 9, 0, 0, 9309, 9310, + 7, 18, 0, 0, 9310, 9311, 7, 7, 0, 0, 9311, 9312, 7, 0, 0, 0, 9312, 9313, + 7, 14, 0, 0, 9313, 9314, 7, 12, 0, 0, 9314, 9315, 7, 8, 0, 0, 9315, 864, + 1, 0, 0, 0, 9316, 9317, 7, 9, 0, 0, 9317, 9318, 7, 18, 0, 0, 9318, 9319, + 7, 7, 0, 0, 9319, 9320, 7, 0, 0, 0, 9320, 9321, 7, 14, 0, 0, 9321, 9322, + 7, 12, 0, 0, 9322, 9323, 7, 8, 0, 0, 9323, 9324, 5, 95, 0, 0, 9324, 9325, + 7, 5, 0, 0, 9325, 9326, 7, 0, 0, 0, 9326, 9327, 7, 14, 0, 0, 9327, 9328, + 7, 15, 0, 0, 9328, 9329, 7, 11, 0, 0, 9329, 9330, 7, 12, 0, 0, 9330, 9331, + 7, 7, 0, 0, 9331, 9332, 7, 17, 0, 0, 9332, 866, 1, 0, 0, 0, 9333, 9334, + 7, 9, 0, 0, 9334, 9335, 7, 18, 0, 0, 9335, 9336, 7, 7, 0, 0, 9336, 9337, + 7, 0, 0, 0, 9337, 9338, 7, 14, 0, 0, 9338, 9339, 7, 12, 0, 0, 9339, 9340, + 7, 8, 0, 0, 9340, 9341, 5, 95, 0, 0, 9341, 9342, 7, 5, 0, 0, 9342, 9343, + 7, 0, 0, 0, 9343, 9344, 7, 14, 0, 0, 9344, 9345, 7, 15, 0, 0, 9345, 9346, + 7, 11, 0, 0, 9346, 9347, 7, 12, 0, 0, 9347, 9348, 7, 7, 0, 0, 9348, 9349, + 7, 17, 0, 0, 9349, 9350, 5, 95, 0, 0, 9350, 9351, 7, 6, 0, 0, 9351, 9352, + 7, 5, 0, 0, 9352, 9353, 7, 4, 0, 0, 9353, 9354, 5, 95, 0, 0, 9354, 9355, + 7, 8, 0, 0, 9355, 9356, 7, 9, 0, 0, 9356, 9357, 7, 7, 0, 0, 9357, 868, + 1, 0, 0, 0, 9358, 9359, 7, 6, 0, 0, 9359, 870, 1, 0, 0, 0, 9360, 9361, + 7, 6, 0, 0, 9361, 9362, 7, 0, 0, 0, 9362, 9363, 7, 8, 0, 0, 9363, 9364, + 7, 19, 0, 0, 9364, 872, 1, 0, 0, 0, 9365, 9366, 7, 6, 0, 0, 9366, 9367, + 7, 9, 0, 0, 9367, 9368, 7, 12, 0, 0, 9368, 9369, 7, 4, 0, 0, 9369, 9370, + 7, 12, 0, 0, 9370, 9371, 7, 2, 0, 0, 9371, 9372, 7, 7, 0, 0, 9372, 9373, + 7, 0, 0, 0, 9373, 9374, 7, 1, 0, 0, 9374, 9375, 7, 11, 0, 0, 9375, 9376, + 7, 6, 0, 0, 9376, 874, 1, 0, 0, 0, 9377, 9378, 7, 6, 0, 0, 9378, 9379, + 7, 9, 0, 0, 9379, 9380, 7, 12, 0, 0, 9380, 9381, 7, 4, 0, 0, 9381, 9382, + 7, 12, 0, 0, 9382, 9383, 7, 2, 0, 0, 9383, 9384, 7, 7, 0, 0, 9384, 876, + 1, 0, 0, 0, 9385, 9386, 7, 6, 0, 0, 9386, 9387, 7, 9, 0, 0, 9387, 9388, + 7, 12, 0, 0, 9388, 9389, 7, 4, 0, 0, 9389, 9390, 7, 12, 0, 0, 9390, 9391, + 7, 2, 0, 0, 9391, 9392, 7, 7, 0, 0, 9392, 9393, 7, 12, 0, 0, 9393, 9394, + 7, 7, 0, 0, 9394, 9395, 7, 17, 0, 0, 9395, 878, 1, 0, 0, 0, 9396, 9397, + 7, 6, 0, 0, 9397, 9398, 7, 9, 0, 0, 9398, 9399, 7, 12, 0, 0, 9399, 9400, + 7, 4, 0, 0, 9400, 9401, 7, 12, 0, 0, 9401, 9402, 7, 2, 0, 0, 9402, 9403, + 7, 7, 0, 0, 9403, 9404, 7, 5, 0, 0, 9404, 880, 1, 0, 0, 0, 9405, 9406, + 7, 6, 0, 0, 9406, 9407, 7, 11, 0, 0, 9407, 9408, 7, 6, 0, 0, 9408, 9409, + 7, 14, 0, 0, 9409, 9410, 7, 6, 0, 0, 9410, 9411, 7, 7, 0, 0, 9411, 9412, + 7, 4, 0, 0, 9412, 882, 1, 0, 0, 0, 9413, 9414, 7, 6, 0, 0, 9414, 9415, + 7, 11, 0, 0, 9415, 9416, 7, 12, 0, 0, 9416, 9417, 7, 14, 0, 0, 9417, 9418, + 5, 95, 0, 0, 9418, 9419, 7, 17, 0, 0, 9419, 9420, 7, 3, 0, 0, 9420, 9421, + 7, 2, 0, 0, 9421, 9422, 7, 10, 0, 0, 9422, 9423, 7, 15, 0, 0, 9423, 9424, + 7, 1, 0, 0, 9424, 9425, 7, 18, 0, 0, 9425, 884, 1, 0, 0, 0, 9426, 9427, + 7, 6, 0, 0, 9427, 9428, 7, 11, 0, 0, 9428, 9429, 7, 12, 0, 0, 9429, 9430, + 7, 14, 0, 0, 9430, 9431, 7, 12, 0, 0, 9431, 9432, 7, 7, 0, 0, 9432, 9433, + 7, 0, 0, 0, 9433, 9434, 7, 4, 0, 0, 9434, 9435, 7, 6, 0, 0, 9435, 9436, + 5, 95, 0, 0, 9436, 9437, 7, 20, 0, 0, 9437, 9438, 7, 2, 0, 0, 9438, 9439, + 7, 12, 0, 0, 9439, 9440, 7, 7, 0, 0, 9440, 886, 1, 0, 0, 0, 9441, 9442, + 7, 6, 0, 0, 9442, 9443, 7, 11, 0, 0, 9443, 9444, 7, 12, 0, 0, 9444, 9445, + 7, 14, 0, 0, 9445, 9446, 7, 12, 0, 0, 9446, 9447, 7, 7, 0, 0, 9447, 9448, + 7, 0, 0, 0, 9448, 9449, 7, 4, 0, 0, 9449, 9450, 7, 6, 0, 0, 9450, 9451, + 5, 95, 0, 0, 9451, 9452, 7, 2, 0, 0, 9452, 9453, 7, 1, 0, 0, 9453, 9454, + 7, 18, 0, 0, 9454, 888, 1, 0, 0, 0, 9455, 9456, 7, 6, 0, 0, 9456, 9457, + 7, 11, 0, 0, 9457, 9458, 7, 12, 0, 0, 9458, 9459, 7, 14, 0, 0, 9459, 9460, + 7, 12, 0, 0, 9460, 9461, 7, 7, 0, 0, 9461, 9462, 7, 0, 0, 0, 9462, 9463, + 7, 4, 0, 0, 9463, 9464, 7, 6, 0, 0, 9464, 9465, 5, 95, 0, 0, 9465, 9466, + 7, 2, 0, 0, 9466, 9467, 7, 10, 0, 0, 9467, 9468, 7, 4, 0, 0, 9468, 9469, + 7, 6, 0, 0, 9469, 9470, 7, 3, 0, 0, 9470, 9471, 5, 95, 0, 0, 9471, 9472, + 7, 20, 0, 0, 9472, 9473, 7, 2, 0, 0, 9473, 9474, 7, 12, 0, 0, 9474, 9475, + 7, 7, 0, 0, 9475, 890, 1, 0, 0, 0, 9476, 9477, 7, 6, 0, 0, 9477, 9478, + 7, 11, 0, 0, 9478, 9479, 7, 5, 0, 0, 9479, 9480, 7, 6, 0, 0, 9480, 892, + 1, 0, 0, 0, 9481, 9482, 7, 6, 0, 0, 9482, 9483, 7, 11, 0, 0, 9483, 9484, + 7, 5, 0, 0, 9484, 9485, 7, 12, 0, 0, 9485, 9486, 7, 16, 0, 0, 9486, 894, + 1, 0, 0, 0, 9487, 9488, 7, 6, 0, 0, 9488, 9489, 7, 14, 0, 0, 9489, 896, + 1, 0, 0, 0, 9490, 9491, 7, 6, 0, 0, 9491, 9492, 7, 14, 0, 0, 9492, 9493, + 7, 15, 0, 0, 9493, 9494, 7, 4, 0, 0, 9494, 9495, 7, 18, 0, 0, 9495, 9496, + 5, 95, 0, 0, 9496, 9497, 7, 1, 0, 0, 9497, 9498, 7, 11, 0, 0, 9498, 9499, + 7, 2, 0, 0, 9499, 9500, 7, 1, 0, 0, 9500, 898, 1, 0, 0, 0, 9501, 9502, + 7, 6, 0, 0, 9502, 9503, 7, 14, 0, 0, 9503, 9504, 7, 15, 0, 0, 9504, 9505, + 7, 4, 0, 0, 9505, 9506, 7, 18, 0, 0, 9506, 9507, 5, 95, 0, 0, 9507, 9508, + 7, 8, 0, 0, 9508, 9509, 7, 11, 0, 0, 9509, 9510, 7, 2, 0, 0, 9510, 9511, + 7, 1, 0, 0, 9511, 900, 1, 0, 0, 0, 9512, 9513, 7, 6, 0, 0, 9513, 9514, + 7, 14, 0, 0, 9514, 9515, 7, 15, 0, 0, 9515, 9516, 7, 4, 0, 0, 9516, 9517, + 7, 18, 0, 0, 9517, 902, 1, 0, 0, 0, 9518, 9519, 7, 6, 0, 0, 9519, 9520, + 7, 7, 0, 0, 9520, 9521, 7, 0, 0, 0, 9521, 9522, 7, 1, 0, 0, 9522, 9523, + 7, 11, 0, 0, 9523, 9524, 7, 6, 0, 0, 9524, 9525, 5, 95, 0, 0, 9525, 9526, + 7, 0, 0, 0, 9526, 9527, 7, 11, 0, 0, 9527, 9528, 7, 11, 0, 0, 9528, 904, + 1, 0, 0, 0, 9529, 9530, 7, 6, 0, 0, 9530, 9531, 7, 7, 0, 0, 9531, 9532, + 7, 0, 0, 0, 9532, 9533, 7, 1, 0, 0, 9533, 9534, 7, 11, 0, 0, 9534, 9535, + 7, 6, 0, 0, 9535, 906, 1, 0, 0, 0, 9536, 9537, 7, 6, 0, 0, 9537, 9538, + 7, 7, 0, 0, 9538, 9539, 7, 0, 0, 0, 9539, 9540, 7, 1, 0, 0, 9540, 9541, + 7, 11, 0, 0, 9541, 9542, 7, 6, 0, 0, 9542, 9543, 5, 95, 0, 0, 9543, 9544, + 7, 15, 0, 0, 9544, 9545, 7, 0, 0, 0, 9545, 9546, 7, 3, 0, 0, 9546, 9547, + 7, 0, 0, 0, 9547, 9548, 7, 11, 0, 0, 9548, 9549, 7, 11, 0, 0, 9549, 9550, + 7, 6, 0, 0, 9550, 9551, 7, 11, 0, 0, 9551, 9552, 5, 95, 0, 0, 9552, 9553, + 7, 9, 0, 0, 9553, 9554, 7, 14, 0, 0, 9554, 9555, 7, 11, 0, 0, 9555, 908, + 1, 0, 0, 0, 9556, 9557, 7, 6, 0, 0, 9557, 9558, 7, 7, 0, 0, 9558, 9559, + 7, 0, 0, 0, 9559, 9560, 7, 1, 0, 0, 9560, 9561, 7, 11, 0, 0, 9561, 9562, + 7, 6, 0, 0, 9562, 9563, 5, 95, 0, 0, 9563, 9564, 7, 15, 0, 0, 9564, 9565, + 7, 3, 0, 0, 9565, 9566, 7, 6, 0, 0, 9566, 9567, 7, 5, 0, 0, 9567, 9568, + 7, 6, 0, 0, 9568, 9569, 7, 4, 0, 0, 9569, 910, 1, 0, 0, 0, 9570, 9571, + 7, 6, 0, 0, 9571, 9572, 7, 7, 0, 0, 9572, 9573, 7, 8, 0, 0, 9573, 9574, + 7, 2, 0, 0, 9574, 9575, 7, 9, 0, 0, 9575, 9576, 7, 12, 0, 0, 9576, 9577, + 7, 7, 0, 0, 9577, 9578, 7, 17, 0, 0, 9578, 912, 1, 0, 0, 0, 9579, 9580, + 7, 6, 0, 0, 9580, 9581, 7, 7, 0, 0, 9581, 9582, 7, 8, 0, 0, 9582, 9583, + 7, 3, 0, 0, 9583, 9584, 7, 18, 0, 0, 9584, 9585, 7, 15, 0, 0, 9585, 9586, + 7, 4, 0, 0, 9586, 914, 1, 0, 0, 0, 9587, 9588, 7, 6, 0, 0, 9588, 9589, + 7, 7, 0, 0, 9589, 9590, 7, 8, 0, 0, 9590, 9591, 7, 3, 0, 0, 9591, 9592, + 7, 18, 0, 0, 9592, 9593, 7, 15, 0, 0, 9593, 9594, 7, 4, 0, 0, 9594, 9595, + 7, 12, 0, 0, 9595, 9596, 7, 2, 0, 0, 9596, 9597, 7, 7, 0, 0, 9597, 916, + 1, 0, 0, 0, 9598, 9599, 7, 6, 0, 0, 9599, 9600, 7, 7, 0, 0, 9600, 9601, + 7, 9, 0, 0, 9601, 918, 1, 0, 0, 0, 9602, 9603, 7, 6, 0, 0, 9603, 9604, + 7, 7, 0, 0, 9604, 9605, 7, 9, 0, 0, 9605, 9606, 5, 95, 0, 0, 9606, 9607, + 7, 2, 0, 0, 9607, 9608, 7, 10, 0, 0, 9608, 9609, 7, 4, 0, 0, 9609, 9610, + 7, 11, 0, 0, 9610, 9611, 7, 12, 0, 0, 9611, 9612, 7, 7, 0, 0, 9612, 9613, + 7, 6, 0, 0, 9613, 9614, 5, 95, 0, 0, 9614, 9615, 7, 9, 0, 0, 9615, 9616, + 7, 0, 0, 0, 9616, 9617, 7, 4, 0, 0, 9617, 9618, 7, 0, 0, 0, 9618, 920, + 1, 0, 0, 0, 9619, 9620, 7, 6, 0, 0, 9620, 9621, 7, 7, 0, 0, 9621, 9622, + 7, 16, 0, 0, 9622, 9623, 7, 2, 0, 0, 9623, 9624, 7, 3, 0, 0, 9624, 9625, + 7, 8, 0, 0, 9625, 9626, 7, 6, 0, 0, 9626, 9627, 7, 9, 0, 0, 9627, 922, + 1, 0, 0, 0, 9628, 9629, 7, 6, 0, 0, 9629, 9630, 7, 7, 0, 0, 9630, 9631, + 7, 16, 0, 0, 9631, 9632, 7, 2, 0, 0, 9632, 9633, 7, 3, 0, 0, 9633, 9634, + 7, 8, 0, 0, 9634, 9635, 7, 6, 0, 0, 9635, 924, 1, 0, 0, 0, 9636, 9637, + 7, 6, 0, 0, 9637, 9638, 7, 7, 0, 0, 9638, 9639, 7, 24, 0, 0, 9639, 9640, + 7, 10, 0, 0, 9640, 9641, 7, 6, 0, 0, 9641, 9642, 7, 10, 0, 0, 9642, 9643, + 7, 6, 0, 0, 9643, 926, 1, 0, 0, 0, 9644, 9645, 7, 6, 0, 0, 9645, 9646, + 7, 7, 0, 0, 9646, 9647, 7, 4, 0, 0, 9647, 9648, 7, 6, 0, 0, 9648, 9649, + 7, 3, 0, 0, 9649, 9650, 7, 15, 0, 0, 9650, 9651, 7, 3, 0, 0, 9651, 9652, + 7, 12, 0, 0, 9652, 9653, 7, 5, 0, 0, 9653, 9654, 7, 6, 0, 0, 9654, 928, + 1, 0, 0, 0, 9655, 9656, 7, 6, 0, 0, 9656, 9657, 7, 7, 0, 0, 9657, 9658, + 7, 4, 0, 0, 9658, 9659, 7, 12, 0, 0, 9659, 9660, 7, 4, 0, 0, 9660, 9661, + 7, 18, 0, 0, 9661, 9662, 7, 6, 0, 0, 9662, 9663, 7, 5, 0, 0, 9663, 9664, + 7, 8, 0, 0, 9664, 9665, 7, 0, 0, 0, 9665, 9666, 7, 15, 0, 0, 9666, 9667, + 7, 12, 0, 0, 9667, 9668, 7, 7, 0, 0, 9668, 9669, 7, 17, 0, 0, 9669, 930, + 1, 0, 0, 0, 9670, 9671, 7, 6, 0, 0, 9671, 9672, 7, 7, 0, 0, 9672, 9673, + 7, 4, 0, 0, 9673, 9674, 7, 3, 0, 0, 9674, 9675, 7, 18, 0, 0, 9675, 932, + 1, 0, 0, 0, 9676, 9677, 7, 6, 0, 0, 9677, 9678, 7, 24, 0, 0, 9678, 9679, + 7, 10, 0, 0, 9679, 9680, 7, 12, 0, 0, 9680, 9681, 7, 15, 0, 0, 9681, 9682, + 7, 0, 0, 0, 9682, 9683, 7, 3, 0, 0, 9683, 9684, 7, 4, 0, 0, 9684, 934, + 1, 0, 0, 0, 9685, 9686, 7, 6, 0, 0, 9686, 9687, 7, 3, 0, 0, 9687, 9688, + 7, 3, 0, 0, 9688, 936, 1, 0, 0, 0, 9689, 9690, 7, 6, 0, 0, 9690, 9691, + 7, 3, 0, 0, 9691, 9692, 7, 3, 0, 0, 9692, 9693, 7, 2, 0, 0, 9693, 9694, + 7, 3, 0, 0, 9694, 9695, 5, 95, 0, 0, 9695, 9696, 7, 0, 0, 0, 9696, 9697, + 7, 3, 0, 0, 9697, 9698, 7, 17, 0, 0, 9698, 9699, 7, 10, 0, 0, 9699, 9700, + 7, 14, 0, 0, 9700, 9701, 7, 6, 0, 0, 9701, 9702, 7, 7, 0, 0, 9702, 9703, + 7, 4, 0, 0, 9703, 938, 1, 0, 0, 0, 9704, 9705, 7, 6, 0, 0, 9705, 9706, + 7, 3, 0, 0, 9706, 9707, 7, 3, 0, 0, 9707, 9708, 7, 2, 0, 0, 9708, 9709, + 7, 3, 0, 0, 9709, 940, 1, 0, 0, 0, 9710, 9711, 7, 6, 0, 0, 9711, 9712, + 7, 3, 0, 0, 9712, 9713, 7, 3, 0, 0, 9713, 9714, 7, 2, 0, 0, 9714, 9715, + 7, 3, 0, 0, 9715, 9716, 5, 95, 0, 0, 9716, 9717, 7, 2, 0, 0, 9717, 9718, + 7, 7, 0, 0, 9718, 9719, 5, 95, 0, 0, 9719, 9720, 7, 2, 0, 0, 9720, 9721, + 7, 13, 0, 0, 9721, 9722, 7, 6, 0, 0, 9722, 9723, 7, 3, 0, 0, 9723, 9724, + 7, 11, 0, 0, 9724, 9725, 7, 0, 0, 0, 9725, 9726, 7, 15, 0, 0, 9726, 9727, + 5, 95, 0, 0, 9727, 9728, 7, 4, 0, 0, 9728, 9729, 7, 12, 0, 0, 9729, 9730, + 7, 14, 0, 0, 9730, 9731, 7, 6, 0, 0, 9731, 942, 1, 0, 0, 0, 9732, 9733, + 7, 6, 0, 0, 9733, 9734, 7, 3, 0, 0, 9734, 9735, 7, 3, 0, 0, 9735, 9736, + 7, 2, 0, 0, 9736, 9737, 7, 3, 0, 0, 9737, 9738, 7, 5, 0, 0, 9738, 944, + 1, 0, 0, 0, 9739, 9740, 7, 6, 0, 0, 9740, 9741, 7, 5, 0, 0, 9741, 9742, + 7, 8, 0, 0, 9742, 9743, 7, 0, 0, 0, 9743, 9744, 7, 15, 0, 0, 9744, 9745, + 7, 6, 0, 0, 9745, 946, 1, 0, 0, 0, 9746, 9747, 7, 6, 0, 0, 9747, 9748, + 7, 5, 0, 0, 9748, 9749, 7, 4, 0, 0, 9749, 9750, 7, 12, 0, 0, 9750, 9751, + 7, 14, 0, 0, 9751, 9752, 7, 0, 0, 0, 9752, 9753, 7, 4, 0, 0, 9753, 9754, + 7, 6, 0, 0, 9754, 948, 1, 0, 0, 0, 9755, 9756, 7, 6, 0, 0, 9756, 9757, + 7, 13, 0, 0, 9757, 9758, 7, 0, 0, 0, 9758, 9759, 7, 11, 0, 0, 9759, 950, + 1, 0, 0, 0, 9760, 9761, 7, 6, 0, 0, 9761, 9762, 7, 13, 0, 0, 9762, 9763, + 7, 0, 0, 0, 9763, 9764, 7, 11, 0, 0, 9764, 9765, 7, 7, 0, 0, 9765, 9766, + 7, 0, 0, 0, 9766, 9767, 7, 14, 0, 0, 9767, 9768, 7, 6, 0, 0, 9768, 952, + 1, 0, 0, 0, 9769, 9770, 7, 6, 0, 0, 9770, 9771, 7, 13, 0, 0, 9771, 9772, + 7, 0, 0, 0, 9772, 9773, 7, 11, 0, 0, 9773, 9774, 7, 10, 0, 0, 9774, 9775, + 7, 0, 0, 0, 9775, 9776, 7, 4, 0, 0, 9776, 9777, 7, 6, 0, 0, 9777, 954, + 1, 0, 0, 0, 9778, 9779, 7, 6, 0, 0, 9779, 9780, 7, 13, 0, 0, 9780, 9781, + 7, 0, 0, 0, 9781, 9782, 7, 11, 0, 0, 9782, 9783, 7, 10, 0, 0, 9783, 9784, + 7, 0, 0, 0, 9784, 9785, 7, 4, 0, 0, 9785, 9786, 7, 12, 0, 0, 9786, 9787, + 7, 2, 0, 0, 9787, 9788, 7, 7, 0, 0, 9788, 956, 1, 0, 0, 0, 9789, 9790, + 7, 6, 0, 0, 9790, 9791, 7, 13, 0, 0, 9791, 9792, 7, 6, 0, 0, 9792, 9793, + 7, 7, 0, 0, 9793, 9794, 7, 4, 0, 0, 9794, 9795, 7, 5, 0, 0, 9795, 958, + 1, 0, 0, 0, 9796, 9797, 7, 6, 0, 0, 9797, 9798, 7, 13, 0, 0, 9798, 9799, + 7, 6, 0, 0, 9799, 9800, 7, 3, 0, 0, 9800, 9801, 7, 18, 0, 0, 9801, 960, + 1, 0, 0, 0, 9802, 9803, 7, 6, 0, 0, 9803, 9804, 7, 25, 0, 0, 9804, 9805, + 7, 8, 0, 0, 9805, 9806, 7, 6, 0, 0, 9806, 9807, 7, 15, 0, 0, 9807, 9808, + 7, 4, 0, 0, 9808, 962, 1, 0, 0, 0, 9809, 9810, 7, 6, 0, 0, 9810, 9811, + 7, 25, 0, 0, 9811, 9812, 7, 8, 0, 0, 9812, 9813, 7, 6, 0, 0, 9813, 9814, + 7, 15, 0, 0, 9814, 9815, 7, 4, 0, 0, 9815, 9816, 7, 12, 0, 0, 9816, 9817, + 7, 2, 0, 0, 9817, 9818, 7, 7, 0, 0, 9818, 964, 1, 0, 0, 0, 9819, 9820, + 7, 6, 0, 0, 9820, 9821, 7, 25, 0, 0, 9821, 9822, 7, 8, 0, 0, 9822, 9823, + 7, 6, 0, 0, 9823, 9824, 7, 15, 0, 0, 9824, 9825, 7, 4, 0, 0, 9825, 9826, + 7, 12, 0, 0, 9826, 9827, 7, 2, 0, 0, 9827, 9828, 7, 7, 0, 0, 9828, 9829, + 5, 95, 0, 0, 9829, 9830, 7, 12, 0, 0, 9830, 9831, 7, 7, 0, 0, 9831, 9832, + 7, 12, 0, 0, 9832, 9833, 7, 4, 0, 0, 9833, 966, 1, 0, 0, 0, 9834, 9835, + 7, 6, 0, 0, 9835, 9836, 7, 25, 0, 0, 9836, 9837, 7, 8, 0, 0, 9837, 9838, + 7, 6, 0, 0, 9838, 9839, 7, 15, 0, 0, 9839, 9840, 7, 4, 0, 0, 9840, 9841, + 7, 12, 0, 0, 9841, 9842, 7, 2, 0, 0, 9842, 9843, 7, 7, 0, 0, 9843, 9844, + 7, 5, 0, 0, 9844, 968, 1, 0, 0, 0, 9845, 9846, 7, 6, 0, 0, 9846, 9847, + 7, 25, 0, 0, 9847, 9848, 7, 8, 0, 0, 9848, 9849, 7, 19, 0, 0, 9849, 9850, + 7, 0, 0, 0, 9850, 9851, 7, 7, 0, 0, 9851, 9852, 7, 17, 0, 0, 9852, 9853, + 7, 6, 0, 0, 9853, 970, 1, 0, 0, 0, 9854, 9855, 7, 6, 0, 0, 9855, 9856, + 7, 25, 0, 0, 9856, 9857, 7, 8, 0, 0, 9857, 9858, 7, 11, 0, 0, 9858, 9859, + 7, 10, 0, 0, 9859, 9860, 7, 9, 0, 0, 9860, 9861, 7, 6, 0, 0, 9861, 972, + 1, 0, 0, 0, 9862, 9863, 7, 6, 0, 0, 9863, 9864, 7, 25, 0, 0, 9864, 9865, + 7, 8, 0, 0, 9865, 9866, 7, 11, 0, 0, 9866, 9867, 7, 10, 0, 0, 9867, 9868, + 7, 9, 0, 0, 9868, 9869, 7, 12, 0, 0, 9869, 9870, 7, 7, 0, 0, 9870, 9871, + 7, 17, 0, 0, 9871, 974, 1, 0, 0, 0, 9872, 9873, 7, 6, 0, 0, 9873, 9874, + 7, 25, 0, 0, 9874, 9875, 7, 8, 0, 0, 9875, 9876, 7, 11, 0, 0, 9876, 9877, + 7, 10, 0, 0, 9877, 9878, 7, 5, 0, 0, 9878, 9879, 7, 12, 0, 0, 9879, 9880, + 7, 13, 0, 0, 9880, 9881, 7, 6, 0, 0, 9881, 976, 1, 0, 0, 0, 9882, 9883, + 7, 6, 0, 0, 9883, 9884, 7, 25, 0, 0, 9884, 9885, 7, 6, 0, 0, 9885, 9886, + 7, 8, 0, 0, 9886, 9887, 7, 10, 0, 0, 9887, 9888, 7, 4, 0, 0, 9888, 9889, + 7, 6, 0, 0, 9889, 978, 1, 0, 0, 0, 9890, 9891, 7, 6, 0, 0, 9891, 9892, + 7, 25, 0, 0, 9892, 9893, 7, 6, 0, 0, 9893, 9894, 7, 14, 0, 0, 9894, 9895, + 7, 15, 0, 0, 9895, 9896, 7, 4, 0, 0, 9896, 980, 1, 0, 0, 0, 9897, 9898, + 7, 6, 0, 0, 9898, 9899, 7, 25, 0, 0, 9899, 9900, 7, 12, 0, 0, 9900, 9901, + 7, 5, 0, 0, 9901, 9902, 7, 4, 0, 0, 9902, 9903, 7, 12, 0, 0, 9903, 9904, + 7, 7, 0, 0, 9904, 9905, 7, 17, 0, 0, 9905, 982, 1, 0, 0, 0, 9906, 9907, + 7, 6, 0, 0, 9907, 9908, 7, 25, 0, 0, 9908, 9909, 7, 12, 0, 0, 9909, 9910, + 7, 5, 0, 0, 9910, 9911, 7, 4, 0, 0, 9911, 9912, 7, 5, 0, 0, 9912, 984, + 1, 0, 0, 0, 9913, 9914, 7, 6, 0, 0, 9914, 9915, 7, 25, 0, 0, 9915, 9916, + 7, 12, 0, 0, 9916, 9917, 7, 5, 0, 0, 9917, 9918, 7, 4, 0, 0, 9918, 9919, + 7, 5, 0, 0, 9919, 9920, 7, 7, 0, 0, 9920, 9921, 7, 2, 0, 0, 9921, 9922, + 7, 9, 0, 0, 9922, 9923, 7, 6, 0, 0, 9923, 986, 1, 0, 0, 0, 9924, 9925, + 7, 6, 0, 0, 9925, 9926, 7, 25, 0, 0, 9926, 9927, 7, 12, 0, 0, 9927, 9928, + 7, 4, 0, 0, 9928, 988, 1, 0, 0, 0, 9929, 9930, 7, 6, 0, 0, 9930, 9931, + 7, 25, 0, 0, 9931, 9932, 7, 15, 0, 0, 9932, 9933, 7, 0, 0, 0, 9933, 9934, + 7, 7, 0, 0, 9934, 9935, 7, 9, 0, 0, 9935, 9936, 5, 95, 0, 0, 9936, 9937, + 7, 17, 0, 0, 9937, 9938, 7, 5, 0, 0, 9938, 9939, 7, 6, 0, 0, 9939, 9940, + 7, 4, 0, 0, 9940, 9941, 5, 95, 0, 0, 9941, 9942, 7, 4, 0, 0, 9942, 9943, + 7, 2, 0, 0, 9943, 9944, 5, 95, 0, 0, 9944, 9945, 7, 10, 0, 0, 9945, 9946, + 7, 7, 0, 0, 9946, 9947, 7, 12, 0, 0, 9947, 9948, 7, 2, 0, 0, 9948, 9949, + 7, 7, 0, 0, 9949, 990, 1, 0, 0, 0, 9950, 9951, 7, 6, 0, 0, 9951, 9952, + 7, 25, 0, 0, 9952, 9953, 7, 15, 0, 0, 9953, 9954, 7, 0, 0, 0, 9954, 9955, + 7, 7, 0, 0, 9955, 9956, 7, 9, 0, 0, 9956, 9957, 5, 95, 0, 0, 9957, 9958, + 7, 4, 0, 0, 9958, 9959, 7, 0, 0, 0, 9959, 9960, 7, 1, 0, 0, 9960, 9961, + 7, 11, 0, 0, 9961, 9962, 7, 6, 0, 0, 9962, 992, 1, 0, 0, 0, 9963, 9964, + 7, 6, 0, 0, 9964, 9965, 7, 25, 0, 0, 9965, 9966, 7, 15, 0, 0, 9966, 994, + 1, 0, 0, 0, 9967, 9968, 7, 6, 0, 0, 9968, 9969, 7, 25, 0, 0, 9969, 9970, + 7, 15, 0, 0, 9970, 9971, 7, 12, 0, 0, 9971, 9972, 7, 3, 0, 0, 9972, 9973, + 7, 6, 0, 0, 9973, 996, 1, 0, 0, 0, 9974, 9975, 7, 6, 0, 0, 9975, 9976, + 7, 25, 0, 0, 9976, 9977, 7, 15, 0, 0, 9977, 9978, 7, 11, 0, 0, 9978, 9979, + 7, 0, 0, 0, 9979, 9980, 7, 12, 0, 0, 9980, 9981, 7, 7, 0, 0, 9981, 998, + 1, 0, 0, 0, 9982, 9983, 7, 6, 0, 0, 9983, 9984, 7, 25, 0, 0, 9984, 9985, + 7, 15, 0, 0, 9985, 9986, 7, 11, 0, 0, 9986, 9987, 7, 2, 0, 0, 9987, 9988, + 7, 5, 0, 0, 9988, 9989, 7, 12, 0, 0, 9989, 9990, 7, 2, 0, 0, 9990, 9991, + 7, 7, 0, 0, 9991, 1000, 1, 0, 0, 0, 9992, 9993, 7, 6, 0, 0, 9993, 9994, + 7, 25, 0, 0, 9994, 9995, 7, 15, 0, 0, 9995, 9996, 7, 2, 0, 0, 9996, 9997, + 7, 3, 0, 0, 9997, 9998, 7, 4, 0, 0, 9998, 1002, 1, 0, 0, 0, 9999, 10000, + 7, 6, 0, 0, 10000, 10001, 7, 25, 0, 0, 10001, 10002, 7, 15, 0, 0, 10002, + 10003, 7, 3, 0, 0, 10003, 10004, 5, 95, 0, 0, 10004, 10005, 7, 8, 0, 0, + 10005, 10006, 7, 2, 0, 0, 10006, 10007, 7, 3, 0, 0, 10007, 10008, 7, 3, + 0, 0, 10008, 10009, 5, 95, 0, 0, 10009, 10010, 7, 8, 0, 0, 10010, 10011, + 7, 19, 0, 0, 10011, 10012, 7, 6, 0, 0, 10012, 10013, 7, 8, 0, 0, 10013, + 10014, 7, 21, 0, 0, 10014, 1004, 1, 0, 0, 0, 10015, 10016, 7, 6, 0, 0, + 10016, 10017, 7, 25, 0, 0, 10017, 10018, 7, 15, 0, 0, 10018, 10019, 7, + 3, 0, 0, 10019, 10020, 7, 6, 0, 0, 10020, 10021, 7, 5, 0, 0, 10021, 10022, + 7, 5, 0, 0, 10022, 1006, 1, 0, 0, 0, 10023, 10024, 7, 6, 0, 0, 10024, 10025, + 7, 25, 0, 0, 10025, 10026, 7, 4, 0, 0, 10026, 10027, 7, 6, 0, 0, 10027, + 10028, 7, 7, 0, 0, 10028, 10029, 7, 9, 0, 0, 10029, 10030, 7, 5, 0, 0, + 10030, 1008, 1, 0, 0, 0, 10031, 10032, 7, 6, 0, 0, 10032, 10033, 7, 25, + 0, 0, 10033, 10034, 7, 4, 0, 0, 10034, 10035, 7, 6, 0, 0, 10035, 10036, + 7, 7, 0, 0, 10036, 10037, 7, 4, 0, 0, 10037, 1010, 1, 0, 0, 0, 10038, 10039, + 7, 6, 0, 0, 10039, 10040, 7, 25, 0, 0, 10040, 10041, 7, 4, 0, 0, 10041, + 10042, 7, 6, 0, 0, 10042, 10043, 7, 7, 0, 0, 10043, 10044, 7, 4, 0, 0, + 10044, 10045, 7, 5, 0, 0, 10045, 1012, 1, 0, 0, 0, 10046, 10047, 7, 6, + 0, 0, 10047, 10048, 7, 25, 0, 0, 10048, 10049, 7, 4, 0, 0, 10049, 10050, + 7, 6, 0, 0, 10050, 10051, 7, 3, 0, 0, 10051, 10052, 7, 7, 0, 0, 10052, + 10053, 7, 0, 0, 0, 10053, 10054, 7, 11, 0, 0, 10054, 1014, 1, 0, 0, 0, + 10055, 10056, 7, 6, 0, 0, 10056, 10057, 7, 25, 0, 0, 10057, 10058, 7, 4, + 0, 0, 10058, 10059, 7, 6, 0, 0, 10059, 10060, 7, 3, 0, 0, 10060, 10061, + 7, 7, 0, 0, 10061, 10062, 7, 0, 0, 0, 10062, 10063, 7, 11, 0, 0, 10063, + 10064, 7, 11, 0, 0, 10064, 10065, 7, 18, 0, 0, 10065, 1016, 1, 0, 0, 0, + 10066, 10067, 7, 6, 0, 0, 10067, 10068, 7, 25, 0, 0, 10068, 10069, 7, 4, + 0, 0, 10069, 10070, 7, 3, 0, 0, 10070, 10071, 7, 0, 0, 0, 10071, 10072, + 7, 8, 0, 0, 10072, 10073, 7, 4, 0, 0, 10073, 10074, 7, 8, 0, 0, 10074, + 10075, 7, 11, 0, 0, 10075, 10076, 7, 2, 0, 0, 10076, 10077, 7, 1, 0, 0, + 10077, 10078, 7, 25, 0, 0, 10078, 10079, 7, 14, 0, 0, 10079, 10080, 7, + 11, 0, 0, 10080, 1018, 1, 0, 0, 0, 10081, 10082, 7, 6, 0, 0, 10082, 10083, + 7, 25, 0, 0, 10083, 10084, 7, 4, 0, 0, 10084, 10085, 7, 3, 0, 0, 10085, + 10086, 7, 0, 0, 0, 10086, 10087, 7, 8, 0, 0, 10087, 10088, 7, 4, 0, 0, + 10088, 1020, 1, 0, 0, 0, 10089, 10090, 7, 6, 0, 0, 10090, 10091, 7, 25, + 0, 0, 10091, 10092, 7, 4, 0, 0, 10092, 10093, 7, 3, 0, 0, 10093, 10094, + 7, 0, 0, 0, 10094, 10095, 7, 8, 0, 0, 10095, 10096, 7, 4, 0, 0, 10096, + 10097, 7, 13, 0, 0, 10097, 10098, 7, 0, 0, 0, 10098, 10099, 7, 11, 0, 0, + 10099, 10100, 7, 10, 0, 0, 10100, 10101, 7, 6, 0, 0, 10101, 1022, 1, 0, + 0, 0, 10102, 10103, 7, 6, 0, 0, 10103, 10104, 7, 25, 0, 0, 10104, 10105, + 7, 4, 0, 0, 10105, 10106, 7, 3, 0, 0, 10106, 10107, 7, 0, 0, 0, 10107, + 1024, 1, 0, 0, 0, 10108, 10109, 7, 16, 0, 0, 10109, 10110, 7, 0, 0, 0, + 10110, 10111, 7, 8, 0, 0, 10111, 10112, 7, 12, 0, 0, 10112, 10113, 7, 11, + 0, 0, 10113, 10114, 7, 12, 0, 0, 10114, 10115, 7, 4, 0, 0, 10115, 10116, + 7, 18, 0, 0, 10116, 1026, 1, 0, 0, 0, 10117, 10118, 7, 16, 0, 0, 10118, + 10119, 7, 0, 0, 0, 10119, 10120, 7, 8, 0, 0, 10120, 10121, 7, 4, 0, 0, + 10121, 1028, 1, 0, 0, 0, 10122, 10123, 7, 16, 0, 0, 10123, 10124, 7, 0, + 0, 0, 10124, 10125, 7, 8, 0, 0, 10125, 10126, 7, 4, 0, 0, 10126, 10127, + 7, 2, 0, 0, 10127, 10128, 7, 3, 0, 0, 10128, 1030, 1, 0, 0, 0, 10129, 10130, + 7, 16, 0, 0, 10130, 10131, 7, 0, 0, 0, 10131, 10132, 7, 8, 0, 0, 10132, + 10133, 7, 4, 0, 0, 10133, 10134, 7, 2, 0, 0, 10134, 10135, 7, 3, 0, 0, + 10135, 10136, 7, 12, 0, 0, 10136, 10137, 7, 23, 0, 0, 10137, 10138, 7, + 6, 0, 0, 10138, 10139, 5, 95, 0, 0, 10139, 10140, 7, 20, 0, 0, 10140, 10141, + 7, 2, 0, 0, 10141, 10142, 7, 12, 0, 0, 10142, 10143, 7, 7, 0, 0, 10143, + 1032, 1, 0, 0, 0, 10144, 10145, 7, 16, 0, 0, 10145, 10146, 7, 0, 0, 0, + 10146, 10147, 7, 12, 0, 0, 10147, 10148, 7, 11, 0, 0, 10148, 10149, 7, + 6, 0, 0, 10149, 10150, 7, 9, 0, 0, 10150, 1034, 1, 0, 0, 0, 10151, 10152, + 7, 16, 0, 0, 10152, 10153, 7, 0, 0, 0, 10153, 10154, 7, 12, 0, 0, 10154, + 10155, 7, 11, 0, 0, 10155, 10156, 7, 6, 0, 0, 10156, 10157, 7, 9, 0, 0, + 10157, 10158, 5, 95, 0, 0, 10158, 10159, 7, 11, 0, 0, 10159, 10160, 7, + 2, 0, 0, 10160, 10161, 7, 17, 0, 0, 10161, 10162, 7, 12, 0, 0, 10162, 10163, + 7, 7, 0, 0, 10163, 10164, 5, 95, 0, 0, 10164, 10165, 7, 0, 0, 0, 10165, + 10166, 7, 4, 0, 0, 10166, 10167, 7, 4, 0, 0, 10167, 10168, 7, 6, 0, 0, + 10168, 10169, 7, 14, 0, 0, 10169, 10170, 7, 15, 0, 0, 10170, 10171, 7, + 4, 0, 0, 10171, 10172, 7, 5, 0, 0, 10172, 1036, 1, 0, 0, 0, 10173, 10174, + 7, 16, 0, 0, 10174, 10175, 7, 0, 0, 0, 10175, 10176, 7, 12, 0, 0, 10176, + 10177, 7, 11, 0, 0, 10177, 10178, 7, 17, 0, 0, 10178, 10179, 7, 3, 0, 0, + 10179, 10180, 7, 2, 0, 0, 10180, 10181, 7, 10, 0, 0, 10181, 10182, 7, 15, + 0, 0, 10182, 1038, 1, 0, 0, 0, 10183, 10184, 7, 16, 0, 0, 10184, 10185, + 7, 0, 0, 0, 10185, 10186, 7, 12, 0, 0, 10186, 10187, 7, 11, 0, 0, 10187, + 10188, 7, 2, 0, 0, 10188, 10189, 7, 13, 0, 0, 10189, 10190, 7, 6, 0, 0, + 10190, 10191, 7, 3, 0, 0, 10191, 1040, 1, 0, 0, 0, 10192, 10193, 7, 16, + 0, 0, 10193, 10194, 7, 0, 0, 0, 10194, 10195, 7, 12, 0, 0, 10195, 10196, + 7, 11, 0, 0, 10196, 10197, 7, 10, 0, 0, 10197, 10198, 7, 3, 0, 0, 10198, + 10199, 7, 6, 0, 0, 10199, 1042, 1, 0, 0, 0, 10200, 10201, 7, 16, 0, 0, + 10201, 10202, 7, 0, 0, 0, 10202, 10203, 7, 11, 0, 0, 10203, 10204, 7, 5, + 0, 0, 10204, 10205, 7, 6, 0, 0, 10205, 1044, 1, 0, 0, 0, 10206, 10207, + 7, 16, 0, 0, 10207, 10208, 7, 0, 0, 0, 10208, 10209, 7, 14, 0, 0, 10209, + 10210, 7, 12, 0, 0, 10210, 10211, 7, 11, 0, 0, 10211, 10212, 7, 18, 0, + 0, 10212, 1046, 1, 0, 0, 0, 10213, 10214, 7, 16, 0, 0, 10214, 10215, 7, + 0, 0, 0, 10215, 10216, 7, 3, 0, 0, 10216, 1048, 1, 0, 0, 0, 10217, 10218, + 7, 16, 0, 0, 10218, 10219, 7, 0, 0, 0, 10219, 10220, 7, 5, 0, 0, 10220, + 10221, 7, 4, 0, 0, 10221, 1050, 1, 0, 0, 0, 10222, 10223, 7, 16, 0, 0, + 10223, 10224, 7, 0, 0, 0, 10224, 10225, 7, 5, 0, 0, 10225, 10226, 7, 4, + 0, 0, 10226, 10227, 7, 5, 0, 0, 10227, 10228, 7, 4, 0, 0, 10228, 10229, + 7, 0, 0, 0, 10229, 10230, 7, 3, 0, 0, 10230, 10231, 7, 4, 0, 0, 10231, + 1052, 1, 0, 0, 0, 10232, 10233, 7, 16, 0, 0, 10233, 10234, 7, 1, 0, 0, + 10234, 10235, 7, 4, 0, 0, 10235, 10236, 7, 5, 0, 0, 10236, 10237, 7, 8, + 0, 0, 10237, 10238, 7, 0, 0, 0, 10238, 10239, 7, 7, 0, 0, 10239, 1054, + 1, 0, 0, 0, 10240, 10241, 7, 16, 0, 0, 10241, 10242, 7, 6, 0, 0, 10242, + 10243, 7, 0, 0, 0, 10243, 10244, 7, 4, 0, 0, 10244, 10245, 7, 10, 0, 0, + 10245, 10246, 7, 3, 0, 0, 10246, 10247, 7, 6, 0, 0, 10247, 1056, 1, 0, + 0, 0, 10248, 10249, 7, 16, 0, 0, 10249, 10250, 7, 6, 0, 0, 10250, 10251, + 7, 0, 0, 0, 10251, 10252, 7, 4, 0, 0, 10252, 10253, 7, 10, 0, 0, 10253, + 10254, 7, 3, 0, 0, 10254, 10255, 7, 6, 0, 0, 10255, 10256, 5, 95, 0, 0, + 10256, 10257, 7, 9, 0, 0, 10257, 10258, 7, 6, 0, 0, 10258, 10259, 7, 4, + 0, 0, 10259, 10260, 7, 0, 0, 0, 10260, 10261, 7, 12, 0, 0, 10261, 10262, + 7, 11, 0, 0, 10262, 10263, 7, 5, 0, 0, 10263, 1058, 1, 0, 0, 0, 10264, + 10265, 7, 16, 0, 0, 10265, 10266, 7, 6, 0, 0, 10266, 10267, 7, 0, 0, 0, + 10267, 10268, 7, 4, 0, 0, 10268, 10269, 7, 10, 0, 0, 10269, 10270, 7, 3, + 0, 0, 10270, 10271, 7, 6, 0, 0, 10271, 10272, 5, 95, 0, 0, 10272, 10273, + 7, 12, 0, 0, 10273, 10274, 7, 9, 0, 0, 10274, 1060, 1, 0, 0, 0, 10275, + 10276, 7, 16, 0, 0, 10276, 10277, 7, 6, 0, 0, 10277, 10278, 7, 0, 0, 0, + 10278, 10279, 7, 4, 0, 0, 10279, 10280, 7, 10, 0, 0, 10280, 10281, 7, 3, + 0, 0, 10281, 10282, 7, 6, 0, 0, 10282, 10283, 5, 95, 0, 0, 10283, 10284, + 7, 5, 0, 0, 10284, 10285, 7, 6, 0, 0, 10285, 10286, 7, 4, 0, 0, 10286, + 1062, 1, 0, 0, 0, 10287, 10288, 7, 16, 0, 0, 10288, 10289, 7, 6, 0, 0, + 10289, 10290, 7, 0, 0, 0, 10290, 10291, 7, 4, 0, 0, 10291, 10292, 7, 10, + 0, 0, 10292, 10293, 7, 3, 0, 0, 10293, 10294, 7, 6, 0, 0, 10294, 10295, + 5, 95, 0, 0, 10295, 10296, 7, 13, 0, 0, 10296, 10297, 7, 0, 0, 0, 10297, + 10298, 7, 11, 0, 0, 10298, 10299, 7, 10, 0, 0, 10299, 10300, 7, 6, 0, 0, + 10300, 1064, 1, 0, 0, 0, 10301, 10302, 7, 16, 0, 0, 10302, 10303, 7, 6, + 0, 0, 10303, 10304, 7, 4, 0, 0, 10304, 10305, 7, 8, 0, 0, 10305, 10306, + 7, 19, 0, 0, 10306, 1066, 1, 0, 0, 0, 10307, 10308, 7, 16, 0, 0, 10308, + 10309, 7, 12, 0, 0, 10309, 10310, 7, 11, 0, 0, 10310, 10311, 7, 6, 0, 0, + 10311, 1068, 1, 0, 0, 0, 10312, 10313, 7, 16, 0, 0, 10313, 10314, 7, 12, + 0, 0, 10314, 10315, 7, 11, 0, 0, 10315, 10316, 7, 6, 0, 0, 10316, 10317, + 5, 95, 0, 0, 10317, 10318, 7, 7, 0, 0, 10318, 10319, 7, 0, 0, 0, 10319, + 10320, 7, 14, 0, 0, 10320, 10321, 7, 6, 0, 0, 10321, 10322, 5, 95, 0, 0, + 10322, 10323, 7, 8, 0, 0, 10323, 10324, 7, 2, 0, 0, 10324, 10325, 7, 7, + 0, 0, 10325, 10326, 7, 13, 0, 0, 10326, 10327, 7, 6, 0, 0, 10327, 10328, + 7, 3, 0, 0, 10328, 10329, 7, 4, 0, 0, 10329, 1070, 1, 0, 0, 0, 10330, 10331, + 7, 16, 0, 0, 10331, 10332, 7, 12, 0, 0, 10332, 10333, 7, 11, 0, 0, 10333, + 10334, 7, 6, 0, 0, 10334, 10335, 7, 17, 0, 0, 10335, 10336, 7, 3, 0, 0, + 10336, 10337, 7, 2, 0, 0, 10337, 10338, 7, 10, 0, 0, 10338, 10339, 7, 15, + 0, 0, 10339, 1072, 1, 0, 0, 0, 10340, 10341, 7, 16, 0, 0, 10341, 10342, + 7, 12, 0, 0, 10342, 10343, 7, 11, 0, 0, 10343, 10344, 7, 6, 0, 0, 10344, + 10345, 7, 5, 0, 0, 10345, 10346, 7, 4, 0, 0, 10346, 10347, 7, 2, 0, 0, + 10347, 10348, 7, 3, 0, 0, 10348, 10349, 7, 6, 0, 0, 10349, 1074, 1, 0, + 0, 0, 10350, 10351, 7, 16, 0, 0, 10351, 10352, 7, 12, 0, 0, 10352, 10353, + 7, 11, 0, 0, 10353, 10354, 7, 6, 0, 0, 10354, 10355, 7, 5, 0, 0, 10355, + 10356, 7, 18, 0, 0, 10356, 10357, 7, 5, 0, 0, 10357, 10358, 7, 4, 0, 0, + 10358, 10359, 7, 6, 0, 0, 10359, 10360, 7, 14, 0, 0, 10360, 10361, 5, 95, + 0, 0, 10361, 10362, 7, 11, 0, 0, 10362, 10363, 7, 12, 0, 0, 10363, 10364, + 7, 21, 0, 0, 10364, 10365, 7, 6, 0, 0, 10365, 10366, 5, 95, 0, 0, 10366, + 10367, 7, 11, 0, 0, 10367, 10368, 7, 2, 0, 0, 10368, 10369, 7, 17, 0, 0, + 10369, 10370, 7, 17, 0, 0, 10370, 10371, 7, 12, 0, 0, 10371, 10372, 7, + 7, 0, 0, 10372, 10373, 7, 17, 0, 0, 10373, 1076, 1, 0, 0, 0, 10374, 10375, + 7, 16, 0, 0, 10375, 10376, 7, 12, 0, 0, 10376, 10377, 7, 11, 0, 0, 10377, + 10378, 7, 4, 0, 0, 10378, 10379, 7, 6, 0, 0, 10379, 10380, 7, 3, 0, 0, + 10380, 1078, 1, 0, 0, 0, 10381, 10382, 7, 16, 0, 0, 10382, 10383, 7, 12, + 0, 0, 10383, 10384, 7, 7, 0, 0, 10384, 10385, 7, 0, 0, 0, 10385, 10386, + 7, 11, 0, 0, 10386, 1080, 1, 0, 0, 0, 10387, 10388, 7, 16, 0, 0, 10388, + 10389, 7, 12, 0, 0, 10389, 10390, 7, 7, 0, 0, 10390, 10391, 7, 6, 0, 0, + 10391, 1082, 1, 0, 0, 0, 10392, 10393, 7, 16, 0, 0, 10393, 10394, 7, 12, + 0, 0, 10394, 10395, 7, 7, 0, 0, 10395, 10396, 7, 12, 0, 0, 10396, 10397, + 7, 5, 0, 0, 10397, 10398, 7, 19, 0, 0, 10398, 1084, 1, 0, 0, 0, 10399, + 10400, 7, 16, 0, 0, 10400, 10401, 7, 12, 0, 0, 10401, 10402, 7, 3, 0, 0, + 10402, 10403, 7, 5, 0, 0, 10403, 10404, 7, 4, 0, 0, 10404, 1086, 1, 0, + 0, 0, 10405, 10406, 7, 16, 0, 0, 10406, 10407, 7, 12, 0, 0, 10407, 10408, + 7, 3, 0, 0, 10408, 10409, 7, 5, 0, 0, 10409, 10410, 7, 4, 0, 0, 10410, + 10411, 7, 14, 0, 0, 10411, 1088, 1, 0, 0, 0, 10412, 10413, 7, 16, 0, 0, + 10413, 10414, 7, 12, 0, 0, 10414, 10415, 7, 3, 0, 0, 10415, 10416, 7, 5, + 0, 0, 10416, 10417, 7, 4, 0, 0, 10417, 10418, 5, 95, 0, 0, 10418, 10419, + 7, 3, 0, 0, 10419, 10420, 7, 2, 0, 0, 10420, 10421, 7, 22, 0, 0, 10421, + 10422, 7, 5, 0, 0, 10422, 1090, 1, 0, 0, 0, 10423, 10424, 7, 16, 0, 0, + 10424, 10425, 7, 12, 0, 0, 10425, 10426, 7, 3, 0, 0, 10426, 10427, 7, 5, + 0, 0, 10427, 10428, 7, 4, 0, 0, 10428, 10429, 5, 95, 0, 0, 10429, 10430, + 7, 13, 0, 0, 10430, 10431, 7, 0, 0, 0, 10431, 10432, 7, 11, 0, 0, 10432, + 10433, 7, 10, 0, 0, 10433, 10434, 7, 6, 0, 0, 10434, 1092, 1, 0, 0, 0, + 10435, 10436, 7, 16, 0, 0, 10436, 10437, 7, 12, 0, 0, 10437, 10438, 7, + 25, 0, 0, 10438, 10439, 7, 6, 0, 0, 10439, 10440, 7, 9, 0, 0, 10440, 10441, + 5, 95, 0, 0, 10441, 10442, 7, 13, 0, 0, 10442, 10443, 7, 12, 0, 0, 10443, + 10444, 7, 6, 0, 0, 10444, 10445, 7, 22, 0, 0, 10445, 10446, 5, 95, 0, 0, + 10446, 10447, 7, 9, 0, 0, 10447, 10448, 7, 0, 0, 0, 10448, 10449, 7, 4, + 0, 0, 10449, 10450, 7, 0, 0, 0, 10450, 1094, 1, 0, 0, 0, 10451, 10452, + 7, 16, 0, 0, 10452, 10453, 7, 11, 0, 0, 10453, 10454, 7, 0, 0, 0, 10454, + 10455, 7, 17, 0, 0, 10455, 10456, 7, 17, 0, 0, 10456, 10457, 7, 6, 0, 0, + 10457, 10458, 7, 3, 0, 0, 10458, 1096, 1, 0, 0, 0, 10459, 10460, 7, 16, + 0, 0, 10460, 10461, 7, 11, 0, 0, 10461, 10462, 7, 0, 0, 0, 10462, 10463, + 7, 5, 0, 0, 10463, 10464, 7, 19, 0, 0, 10464, 10465, 7, 1, 0, 0, 10465, + 10466, 7, 0, 0, 0, 10466, 10467, 7, 8, 0, 0, 10467, 10468, 7, 21, 0, 0, + 10468, 1098, 1, 0, 0, 0, 10469, 10470, 7, 16, 0, 0, 10470, 10471, 7, 11, + 0, 0, 10471, 10472, 7, 0, 0, 0, 10472, 10473, 7, 5, 0, 0, 10473, 10474, + 7, 19, 0, 0, 10474, 10475, 5, 95, 0, 0, 10475, 10476, 7, 8, 0, 0, 10476, + 10477, 7, 0, 0, 0, 10477, 10478, 7, 8, 0, 0, 10478, 10479, 7, 19, 0, 0, + 10479, 10480, 7, 6, 0, 0, 10480, 1100, 1, 0, 0, 0, 10481, 10482, 7, 16, + 0, 0, 10482, 10483, 7, 11, 0, 0, 10483, 10484, 7, 2, 0, 0, 10484, 10485, + 7, 0, 0, 0, 10485, 10486, 7, 4, 0, 0, 10486, 1102, 1, 0, 0, 0, 10487, 10488, + 7, 16, 0, 0, 10488, 10489, 7, 11, 0, 0, 10489, 10490, 7, 2, 0, 0, 10490, + 10491, 7, 1, 0, 0, 10491, 1104, 1, 0, 0, 0, 10492, 10493, 7, 16, 0, 0, + 10493, 10494, 7, 11, 0, 0, 10494, 10495, 7, 6, 0, 0, 10495, 10496, 7, 25, + 0, 0, 10496, 1106, 1, 0, 0, 0, 10497, 10498, 7, 16, 0, 0, 10498, 10499, + 7, 11, 0, 0, 10499, 10500, 7, 2, 0, 0, 10500, 10501, 7, 2, 0, 0, 10501, + 10502, 7, 3, 0, 0, 10502, 1108, 1, 0, 0, 0, 10503, 10504, 7, 16, 0, 0, + 10504, 10505, 7, 11, 0, 0, 10505, 10506, 7, 10, 0, 0, 10506, 10507, 7, + 5, 0, 0, 10507, 10508, 7, 19, 0, 0, 10508, 1110, 1, 0, 0, 0, 10509, 10510, + 7, 16, 0, 0, 10510, 10511, 7, 2, 0, 0, 10511, 10512, 7, 11, 0, 0, 10512, + 10513, 7, 9, 0, 0, 10513, 10514, 7, 6, 0, 0, 10514, 10515, 7, 3, 0, 0, + 10515, 1112, 1, 0, 0, 0, 10516, 10517, 7, 16, 0, 0, 10517, 10518, 7, 2, + 0, 0, 10518, 10519, 7, 11, 0, 0, 10519, 10520, 7, 11, 0, 0, 10520, 10521, + 7, 2, 0, 0, 10521, 10522, 7, 22, 0, 0, 10522, 10523, 7, 12, 0, 0, 10523, + 10524, 7, 7, 0, 0, 10524, 10525, 7, 17, 0, 0, 10525, 1114, 1, 0, 0, 0, + 10526, 10527, 7, 16, 0, 0, 10527, 10528, 7, 2, 0, 0, 10528, 10529, 7, 11, + 0, 0, 10529, 10530, 7, 11, 0, 0, 10530, 10531, 7, 2, 0, 0, 10531, 10532, + 7, 22, 0, 0, 10532, 10533, 7, 5, 0, 0, 10533, 1116, 1, 0, 0, 0, 10534, + 10535, 7, 16, 0, 0, 10535, 10536, 7, 2, 0, 0, 10536, 10537, 7, 3, 0, 0, + 10537, 10538, 7, 0, 0, 0, 10538, 10539, 7, 11, 0, 0, 10539, 10540, 7, 11, + 0, 0, 10540, 1118, 1, 0, 0, 0, 10541, 10542, 7, 16, 0, 0, 10542, 10543, + 7, 2, 0, 0, 10543, 10544, 7, 3, 0, 0, 10544, 10545, 7, 8, 0, 0, 10545, + 10546, 7, 6, 0, 0, 10546, 1120, 1, 0, 0, 0, 10547, 10548, 7, 16, 0, 0, + 10548, 10549, 7, 2, 0, 0, 10549, 10550, 7, 3, 0, 0, 10550, 10551, 7, 8, + 0, 0, 10551, 10552, 7, 6, 0, 0, 10552, 10553, 5, 95, 0, 0, 10553, 10554, + 7, 25, 0, 0, 10554, 10555, 7, 14, 0, 0, 10555, 10556, 7, 11, 0, 0, 10556, + 10557, 5, 95, 0, 0, 10557, 10558, 7, 24, 0, 0, 10558, 10559, 7, 10, 0, + 0, 10559, 10560, 7, 6, 0, 0, 10560, 10561, 7, 3, 0, 0, 10561, 10562, 7, + 18, 0, 0, 10562, 10563, 5, 95, 0, 0, 10563, 10564, 7, 3, 0, 0, 10564, 10565, + 7, 6, 0, 0, 10565, 10566, 7, 22, 0, 0, 10566, 10567, 7, 3, 0, 0, 10567, + 10568, 7, 12, 0, 0, 10568, 10569, 7, 4, 0, 0, 10569, 10570, 7, 6, 0, 0, + 10570, 1122, 1, 0, 0, 0, 10571, 10572, 7, 16, 0, 0, 10572, 10573, 7, 2, + 0, 0, 10573, 10574, 7, 3, 0, 0, 10574, 10575, 7, 6, 0, 0, 10575, 10576, + 7, 12, 0, 0, 10576, 10577, 7, 17, 0, 0, 10577, 10578, 7, 7, 0, 0, 10578, + 1124, 1, 0, 0, 0, 10579, 10580, 7, 16, 0, 0, 10580, 10581, 7, 2, 0, 0, + 10581, 10582, 7, 3, 0, 0, 10582, 10583, 7, 6, 0, 0, 10583, 10584, 7, 13, + 0, 0, 10584, 10585, 7, 6, 0, 0, 10585, 10586, 7, 3, 0, 0, 10586, 1126, + 1, 0, 0, 0, 10587, 10588, 7, 16, 0, 0, 10588, 10589, 7, 2, 0, 0, 10589, + 10590, 7, 3, 0, 0, 10590, 1128, 1, 0, 0, 0, 10591, 10592, 7, 16, 0, 0, + 10592, 10593, 7, 2, 0, 0, 10593, 10594, 7, 3, 0, 0, 10594, 10595, 7, 14, + 0, 0, 10595, 10596, 7, 0, 0, 0, 10596, 10597, 7, 4, 0, 0, 10597, 1130, + 1, 0, 0, 0, 10598, 10599, 7, 16, 0, 0, 10599, 10600, 7, 2, 0, 0, 10600, + 10601, 7, 3, 0, 0, 10601, 10602, 7, 22, 0, 0, 10602, 10603, 7, 0, 0, 0, + 10603, 10604, 7, 3, 0, 0, 10604, 10605, 7, 9, 0, 0, 10605, 1132, 1, 0, + 0, 0, 10606, 10607, 7, 16, 0, 0, 10607, 10608, 7, 3, 0, 0, 10608, 10609, + 7, 0, 0, 0, 10609, 10610, 7, 17, 0, 0, 10610, 10611, 7, 14, 0, 0, 10611, + 10612, 7, 6, 0, 0, 10612, 10613, 7, 7, 0, 0, 10613, 10614, 7, 4, 0, 0, + 10614, 10615, 5, 95, 0, 0, 10615, 10616, 7, 7, 0, 0, 10616, 10617, 7, 10, + 0, 0, 10617, 10618, 7, 14, 0, 0, 10618, 10619, 7, 1, 0, 0, 10619, 10620, + 7, 6, 0, 0, 10620, 10621, 7, 3, 0, 0, 10621, 1134, 1, 0, 0, 0, 10622, 10623, + 7, 16, 0, 0, 10623, 10624, 7, 3, 0, 0, 10624, 10625, 7, 6, 0, 0, 10625, + 10626, 7, 6, 0, 0, 10626, 10627, 7, 11, 0, 0, 10627, 10628, 7, 12, 0, 0, + 10628, 10629, 7, 5, 0, 0, 10629, 10630, 7, 4, 0, 0, 10630, 1136, 1, 0, + 0, 0, 10631, 10632, 7, 16, 0, 0, 10632, 10633, 7, 3, 0, 0, 10633, 10634, + 7, 6, 0, 0, 10634, 10635, 7, 6, 0, 0, 10635, 10636, 7, 11, 0, 0, 10636, + 10637, 7, 12, 0, 0, 10637, 10638, 7, 5, 0, 0, 10638, 10639, 7, 4, 0, 0, + 10639, 10640, 7, 5, 0, 0, 10640, 1138, 1, 0, 0, 0, 10641, 10642, 7, 16, + 0, 0, 10642, 10643, 7, 3, 0, 0, 10643, 10644, 7, 6, 0, 0, 10644, 10645, + 7, 6, 0, 0, 10645, 10646, 7, 15, 0, 0, 10646, 10647, 7, 2, 0, 0, 10647, + 10648, 7, 2, 0, 0, 10648, 10649, 7, 11, 0, 0, 10649, 10650, 7, 5, 0, 0, + 10650, 1140, 1, 0, 0, 0, 10651, 10652, 7, 16, 0, 0, 10652, 10653, 7, 3, + 0, 0, 10653, 10654, 7, 6, 0, 0, 10654, 10655, 7, 5, 0, 0, 10655, 10656, + 7, 19, 0, 0, 10656, 1142, 1, 0, 0, 0, 10657, 10658, 7, 16, 0, 0, 10658, + 10659, 7, 3, 0, 0, 10659, 10660, 7, 2, 0, 0, 10660, 10661, 7, 14, 0, 0, + 10661, 1144, 1, 0, 0, 0, 10662, 10663, 7, 16, 0, 0, 10663, 10664, 7, 3, + 0, 0, 10664, 10665, 7, 2, 0, 0, 10665, 10666, 7, 14, 0, 0, 10666, 10667, + 5, 95, 0, 0, 10667, 10668, 7, 4, 0, 0, 10668, 10669, 7, 23, 0, 0, 10669, + 1146, 1, 0, 0, 0, 10670, 10671, 7, 16, 0, 0, 10671, 10672, 7, 10, 0, 0, + 10672, 10673, 7, 11, 0, 0, 10673, 10674, 7, 11, 0, 0, 10674, 1148, 1, 0, + 0, 0, 10675, 10676, 7, 16, 0, 0, 10676, 10677, 7, 10, 0, 0, 10677, 10678, + 7, 11, 0, 0, 10678, 10679, 7, 11, 0, 0, 10679, 10680, 5, 95, 0, 0, 10680, + 10681, 7, 2, 0, 0, 10681, 10682, 7, 10, 0, 0, 10682, 10683, 7, 4, 0, 0, + 10683, 10684, 7, 6, 0, 0, 10684, 10685, 7, 3, 0, 0, 10685, 10686, 5, 95, + 0, 0, 10686, 10687, 7, 20, 0, 0, 10687, 10688, 7, 2, 0, 0, 10688, 10689, + 7, 12, 0, 0, 10689, 10690, 7, 7, 0, 0, 10690, 10691, 5, 95, 0, 0, 10691, + 10692, 7, 4, 0, 0, 10692, 10693, 7, 2, 0, 0, 10693, 10694, 5, 95, 0, 0, + 10694, 10695, 7, 2, 0, 0, 10695, 10696, 7, 10, 0, 0, 10696, 10697, 7, 4, + 0, 0, 10697, 10698, 7, 6, 0, 0, 10698, 10699, 7, 3, 0, 0, 10699, 1150, + 1, 0, 0, 0, 10700, 10701, 7, 16, 0, 0, 10701, 10702, 7, 10, 0, 0, 10702, + 10703, 7, 7, 0, 0, 10703, 10704, 7, 8, 0, 0, 10704, 10705, 7, 4, 0, 0, + 10705, 10706, 7, 12, 0, 0, 10706, 10707, 7, 2, 0, 0, 10707, 10708, 7, 7, + 0, 0, 10708, 1152, 1, 0, 0, 0, 10709, 10710, 7, 16, 0, 0, 10710, 10711, + 7, 10, 0, 0, 10711, 10712, 7, 7, 0, 0, 10712, 10713, 7, 8, 0, 0, 10713, + 10714, 7, 4, 0, 0, 10714, 10715, 7, 12, 0, 0, 10715, 10716, 7, 2, 0, 0, + 10716, 10717, 7, 7, 0, 0, 10717, 10718, 7, 5, 0, 0, 10718, 1154, 1, 0, + 0, 0, 10719, 10720, 7, 16, 0, 0, 10720, 10721, 7, 4, 0, 0, 10721, 10722, + 7, 15, 0, 0, 10722, 1156, 1, 0, 0, 0, 10723, 10724, 7, 17, 0, 0, 10724, + 1158, 1, 0, 0, 0, 10725, 10726, 7, 17, 0, 0, 10726, 10727, 7, 0, 0, 0, + 10727, 10728, 7, 4, 0, 0, 10728, 10729, 7, 19, 0, 0, 10729, 10730, 7, 6, + 0, 0, 10730, 10731, 7, 3, 0, 0, 10731, 10732, 5, 95, 0, 0, 10732, 10733, + 7, 2, 0, 0, 10733, 10734, 7, 15, 0, 0, 10734, 10735, 7, 4, 0, 0, 10735, + 10736, 7, 12, 0, 0, 10736, 10737, 7, 14, 0, 0, 10737, 10738, 7, 12, 0, + 0, 10738, 10739, 7, 23, 0, 0, 10739, 10740, 7, 6, 0, 0, 10740, 10741, 7, + 3, 0, 0, 10741, 10742, 5, 95, 0, 0, 10742, 10743, 7, 5, 0, 0, 10743, 10744, + 7, 4, 0, 0, 10744, 10745, 7, 0, 0, 0, 10745, 10746, 7, 4, 0, 0, 10746, + 10747, 7, 12, 0, 0, 10747, 10748, 7, 5, 0, 0, 10748, 10749, 7, 4, 0, 0, + 10749, 10750, 7, 12, 0, 0, 10750, 10751, 7, 8, 0, 0, 10751, 10752, 7, 5, + 0, 0, 10752, 1160, 1, 0, 0, 0, 10753, 10754, 7, 17, 0, 0, 10754, 10755, + 7, 0, 0, 0, 10755, 10756, 7, 4, 0, 0, 10756, 10757, 7, 19, 0, 0, 10757, + 10758, 7, 6, 0, 0, 10758, 10759, 7, 3, 0, 0, 10759, 10760, 5, 95, 0, 0, + 10760, 10761, 7, 15, 0, 0, 10761, 10762, 7, 11, 0, 0, 10762, 10763, 7, + 0, 0, 0, 10763, 10764, 7, 7, 0, 0, 10764, 10765, 5, 95, 0, 0, 10765, 10766, + 7, 5, 0, 0, 10766, 10767, 7, 4, 0, 0, 10767, 10768, 7, 0, 0, 0, 10768, + 10769, 7, 4, 0, 0, 10769, 10770, 7, 12, 0, 0, 10770, 10771, 7, 5, 0, 0, + 10771, 10772, 7, 4, 0, 0, 10772, 10773, 7, 12, 0, 0, 10773, 10774, 7, 8, + 0, 0, 10774, 10775, 7, 5, 0, 0, 10775, 1162, 1, 0, 0, 0, 10776, 10777, + 7, 17, 0, 0, 10777, 10778, 7, 1, 0, 0, 10778, 10779, 7, 18, 0, 0, 10779, + 10780, 5, 95, 0, 0, 10780, 10781, 7, 8, 0, 0, 10781, 10782, 7, 2, 0, 0, + 10782, 10783, 7, 7, 0, 0, 10783, 10784, 7, 8, 0, 0, 10784, 10785, 5, 95, + 0, 0, 10785, 10786, 7, 3, 0, 0, 10786, 10787, 7, 2, 0, 0, 10787, 10788, + 7, 11, 0, 0, 10788, 10789, 7, 11, 0, 0, 10789, 10790, 7, 10, 0, 0, 10790, + 10791, 7, 15, 0, 0, 10791, 1164, 1, 0, 0, 0, 10792, 10793, 7, 17, 0, 0, + 10793, 10794, 7, 1, 0, 0, 10794, 10795, 7, 18, 0, 0, 10795, 10796, 5, 95, + 0, 0, 10796, 10797, 7, 15, 0, 0, 10797, 10798, 7, 10, 0, 0, 10798, 10799, + 7, 5, 0, 0, 10799, 10800, 7, 19, 0, 0, 10800, 10801, 7, 9, 0, 0, 10801, + 10802, 7, 2, 0, 0, 10802, 10803, 7, 22, 0, 0, 10803, 10804, 7, 7, 0, 0, + 10804, 1166, 1, 0, 0, 0, 10805, 10806, 7, 17, 0, 0, 10806, 10807, 7, 6, + 0, 0, 10807, 10808, 7, 7, 0, 0, 10808, 10809, 7, 6, 0, 0, 10809, 10810, + 7, 3, 0, 0, 10810, 10811, 7, 0, 0, 0, 10811, 10812, 7, 4, 0, 0, 10812, + 10813, 7, 6, 0, 0, 10813, 10814, 7, 9, 0, 0, 10814, 1168, 1, 0, 0, 0, 10815, + 10816, 7, 17, 0, 0, 10816, 10817, 7, 6, 0, 0, 10817, 10818, 7, 4, 0, 0, + 10818, 1170, 1, 0, 0, 0, 10819, 10820, 7, 17, 0, 0, 10820, 10821, 7, 11, + 0, 0, 10821, 10822, 7, 2, 0, 0, 10822, 10823, 7, 1, 0, 0, 10823, 10824, + 7, 0, 0, 0, 10824, 10825, 7, 11, 0, 0, 10825, 1172, 1, 0, 0, 0, 10826, + 10827, 7, 17, 0, 0, 10827, 10828, 7, 11, 0, 0, 10828, 10829, 7, 2, 0, 0, + 10829, 10830, 7, 1, 0, 0, 10830, 10831, 7, 0, 0, 0, 10831, 10832, 7, 11, + 0, 0, 10832, 10833, 7, 11, 0, 0, 10833, 10834, 7, 18, 0, 0, 10834, 1174, + 1, 0, 0, 0, 10835, 10836, 7, 17, 0, 0, 10836, 10837, 7, 11, 0, 0, 10837, + 10838, 7, 2, 0, 0, 10838, 10839, 7, 1, 0, 0, 10839, 10840, 7, 0, 0, 0, + 10840, 10841, 7, 11, 0, 0, 10841, 10842, 5, 95, 0, 0, 10842, 10843, 7, + 7, 0, 0, 10843, 10844, 7, 0, 0, 0, 10844, 10845, 7, 14, 0, 0, 10845, 10846, + 7, 6, 0, 0, 10846, 1176, 1, 0, 0, 0, 10847, 10848, 7, 17, 0, 0, 10848, + 10849, 7, 11, 0, 0, 10849, 10850, 7, 2, 0, 0, 10850, 10851, 7, 1, 0, 0, + 10851, 10852, 7, 0, 0, 0, 10852, 10853, 7, 11, 0, 0, 10853, 10854, 5, 95, + 0, 0, 10854, 10855, 7, 4, 0, 0, 10855, 10856, 7, 2, 0, 0, 10856, 10857, + 7, 15, 0, 0, 10857, 10858, 7, 12, 0, 0, 10858, 10859, 7, 8, 0, 0, 10859, + 10860, 5, 95, 0, 0, 10860, 10861, 7, 6, 0, 0, 10861, 10862, 7, 7, 0, 0, + 10862, 10863, 7, 0, 0, 0, 10863, 10864, 7, 1, 0, 0, 10864, 10865, 7, 11, + 0, 0, 10865, 10866, 7, 6, 0, 0, 10866, 10867, 7, 9, 0, 0, 10867, 1178, + 1, 0, 0, 0, 10868, 10869, 7, 17, 0, 0, 10869, 10870, 7, 2, 0, 0, 10870, + 10871, 7, 4, 0, 0, 10871, 10872, 7, 2, 0, 0, 10872, 1180, 1, 0, 0, 0, 10873, + 10874, 7, 17, 0, 0, 10874, 10875, 7, 3, 0, 0, 10875, 10876, 7, 0, 0, 0, + 10876, 10877, 7, 7, 0, 0, 10877, 10878, 7, 4, 0, 0, 10878, 1182, 1, 0, + 0, 0, 10879, 10880, 7, 17, 0, 0, 10880, 10881, 7, 3, 0, 0, 10881, 10882, + 7, 2, 0, 0, 10882, 10883, 7, 10, 0, 0, 10883, 10884, 7, 15, 0, 0, 10884, + 10885, 5, 95, 0, 0, 10885, 10886, 7, 1, 0, 0, 10886, 10887, 7, 18, 0, 0, + 10887, 1184, 1, 0, 0, 0, 10888, 10889, 7, 17, 0, 0, 10889, 10890, 7, 3, + 0, 0, 10890, 10891, 7, 2, 0, 0, 10891, 10892, 7, 10, 0, 0, 10892, 10893, + 7, 15, 0, 0, 10893, 1186, 1, 0, 0, 0, 10894, 10895, 7, 17, 0, 0, 10895, + 10896, 7, 3, 0, 0, 10896, 10897, 7, 2, 0, 0, 10897, 10898, 7, 10, 0, 0, + 10898, 10899, 7, 15, 0, 0, 10899, 10900, 5, 95, 0, 0, 10900, 10901, 7, + 12, 0, 0, 10901, 10902, 7, 9, 0, 0, 10902, 1188, 1, 0, 0, 0, 10903, 10904, + 7, 17, 0, 0, 10904, 10905, 7, 3, 0, 0, 10905, 10906, 7, 2, 0, 0, 10906, + 10907, 7, 10, 0, 0, 10907, 10908, 7, 15, 0, 0, 10908, 10909, 7, 12, 0, + 0, 10909, 10910, 7, 7, 0, 0, 10910, 10911, 7, 17, 0, 0, 10911, 1190, 1, + 0, 0, 0, 10912, 10913, 7, 17, 0, 0, 10913, 10914, 7, 3, 0, 0, 10914, 10915, + 7, 2, 0, 0, 10915, 10916, 7, 10, 0, 0, 10916, 10917, 7, 15, 0, 0, 10917, + 10918, 7, 12, 0, 0, 10918, 10919, 7, 7, 0, 0, 10919, 10920, 7, 17, 0, 0, + 10920, 10921, 5, 95, 0, 0, 10921, 10922, 7, 12, 0, 0, 10922, 10923, 7, + 9, 0, 0, 10923, 1192, 1, 0, 0, 0, 10924, 10925, 7, 17, 0, 0, 10925, 10926, + 7, 3, 0, 0, 10926, 10927, 7, 2, 0, 0, 10927, 10928, 7, 10, 0, 0, 10928, + 10929, 7, 15, 0, 0, 10929, 10930, 7, 5, 0, 0, 10930, 1194, 1, 0, 0, 0, + 10931, 10932, 7, 17, 0, 0, 10932, 10933, 7, 10, 0, 0, 10933, 10934, 7, + 0, 0, 0, 10934, 10935, 7, 3, 0, 0, 10935, 10936, 7, 0, 0, 0, 10936, 10937, + 7, 7, 0, 0, 10937, 10938, 7, 4, 0, 0, 10938, 10939, 7, 6, 0, 0, 10939, + 10940, 7, 6, 0, 0, 10940, 10941, 7, 9, 0, 0, 10941, 1196, 1, 0, 0, 0, 10942, + 10943, 7, 17, 0, 0, 10943, 10944, 7, 10, 0, 0, 10944, 10945, 7, 0, 0, 0, + 10945, 10946, 7, 3, 0, 0, 10946, 10947, 7, 0, 0, 0, 10947, 10948, 7, 7, + 0, 0, 10948, 10949, 7, 4, 0, 0, 10949, 10950, 7, 6, 0, 0, 10950, 10951, + 7, 6, 0, 0, 10951, 1198, 1, 0, 0, 0, 10952, 10953, 7, 17, 0, 0, 10953, + 10954, 7, 10, 0, 0, 10954, 10955, 7, 0, 0, 0, 10955, 10956, 7, 3, 0, 0, + 10956, 10957, 7, 9, 0, 0, 10957, 1200, 1, 0, 0, 0, 10958, 10959, 7, 19, + 0, 0, 10959, 10960, 7, 0, 0, 0, 10960, 10961, 7, 11, 0, 0, 10961, 10962, + 7, 16, 0, 0, 10962, 10963, 5, 95, 0, 0, 10963, 10964, 7, 18, 0, 0, 10964, + 10965, 7, 6, 0, 0, 10965, 10966, 7, 0, 0, 0, 10966, 10967, 7, 3, 0, 0, + 10967, 10968, 7, 5, 0, 0, 10968, 1202, 1, 0, 0, 0, 10969, 10970, 7, 19, + 0, 0, 10970, 10971, 7, 0, 0, 0, 10971, 10972, 7, 5, 0, 0, 10972, 10973, + 7, 19, 0, 0, 10973, 10974, 5, 95, 0, 0, 10974, 10975, 7, 0, 0, 0, 10975, + 10976, 7, 20, 0, 0, 10976, 1204, 1, 0, 0, 0, 10977, 10978, 7, 19, 0, 0, + 10978, 10979, 7, 0, 0, 0, 10979, 10980, 7, 5, 0, 0, 10980, 10981, 7, 19, + 0, 0, 10981, 1206, 1, 0, 0, 0, 10982, 10983, 7, 19, 0, 0, 10983, 10984, + 7, 0, 0, 0, 10984, 10985, 7, 5, 0, 0, 10985, 10986, 7, 19, 0, 0, 10986, + 10987, 7, 21, 0, 0, 10987, 10988, 7, 6, 0, 0, 10988, 10989, 7, 18, 0, 0, + 10989, 10990, 7, 5, 0, 0, 10990, 1208, 1, 0, 0, 0, 10991, 10992, 7, 19, + 0, 0, 10992, 10993, 7, 0, 0, 0, 10993, 10994, 7, 5, 0, 0, 10994, 10995, + 7, 19, 0, 0, 10995, 10996, 5, 95, 0, 0, 10996, 10997, 7, 5, 0, 0, 10997, + 10998, 7, 20, 0, 0, 10998, 1210, 1, 0, 0, 0, 10999, 11000, 7, 19, 0, 0, + 11000, 11001, 7, 0, 0, 0, 11001, 11002, 7, 13, 0, 0, 11002, 11003, 7, 12, + 0, 0, 11003, 11004, 7, 7, 0, 0, 11004, 11005, 7, 17, 0, 0, 11005, 1212, + 1, 0, 0, 0, 11006, 11007, 7, 19, 0, 0, 11007, 11008, 7, 6, 0, 0, 11008, + 11009, 7, 0, 0, 0, 11009, 11010, 7, 9, 0, 0, 11010, 11011, 7, 6, 0, 0, + 11011, 11012, 7, 3, 0, 0, 11012, 1214, 1, 0, 0, 0, 11013, 11014, 7, 19, + 0, 0, 11014, 11015, 7, 6, 0, 0, 11015, 11016, 7, 0, 0, 0, 11016, 11017, + 7, 15, 0, 0, 11017, 1216, 1, 0, 0, 0, 11018, 11019, 7, 19, 0, 0, 11019, + 11020, 7, 6, 0, 0, 11020, 11021, 7, 11, 0, 0, 11021, 11022, 7, 15, 0, 0, + 11022, 1218, 1, 0, 0, 0, 11023, 11024, 7, 19, 0, 0, 11024, 11025, 7, 6, + 0, 0, 11025, 11026, 7, 25, 0, 0, 11026, 11027, 7, 4, 0, 0, 11027, 11028, + 7, 2, 0, 0, 11028, 11029, 7, 3, 0, 0, 11029, 11030, 7, 0, 0, 0, 11030, + 11031, 7, 22, 0, 0, 11031, 1220, 1, 0, 0, 0, 11032, 11033, 7, 19, 0, 0, + 11033, 11034, 7, 6, 0, 0, 11034, 11035, 7, 25, 0, 0, 11035, 11036, 7, 4, + 0, 0, 11036, 11037, 7, 2, 0, 0, 11037, 11038, 7, 3, 0, 0, 11038, 11039, + 7, 6, 0, 0, 11039, 11040, 7, 16, 0, 0, 11040, 1222, 1, 0, 0, 0, 11041, + 11042, 7, 19, 0, 0, 11042, 11043, 7, 12, 0, 0, 11043, 11044, 7, 9, 0, 0, + 11044, 11045, 7, 9, 0, 0, 11045, 11046, 7, 6, 0, 0, 11046, 11047, 7, 7, + 0, 0, 11047, 1224, 1, 0, 0, 0, 11048, 11049, 7, 19, 0, 0, 11049, 11050, + 7, 12, 0, 0, 11050, 11051, 7, 9, 0, 0, 11051, 11052, 7, 6, 0, 0, 11052, + 1226, 1, 0, 0, 0, 11053, 11054, 7, 19, 0, 0, 11054, 11055, 7, 12, 0, 0, + 11055, 11056, 7, 6, 0, 0, 11056, 11057, 7, 3, 0, 0, 11057, 11058, 5, 95, + 0, 0, 11058, 11059, 7, 2, 0, 0, 11059, 11060, 7, 3, 0, 0, 11060, 11061, + 7, 9, 0, 0, 11061, 11062, 7, 6, 0, 0, 11062, 11063, 7, 3, 0, 0, 11063, + 1228, 1, 0, 0, 0, 11064, 11065, 7, 19, 0, 0, 11065, 11066, 7, 12, 0, 0, + 11066, 11067, 7, 6, 0, 0, 11067, 11068, 7, 3, 0, 0, 11068, 11069, 7, 0, + 0, 0, 11069, 11070, 7, 3, 0, 0, 11070, 11071, 7, 8, 0, 0, 11071, 11072, + 7, 19, 0, 0, 11072, 11073, 7, 12, 0, 0, 11073, 11074, 7, 8, 0, 0, 11074, + 11075, 7, 0, 0, 0, 11075, 11076, 7, 11, 0, 0, 11076, 1230, 1, 0, 0, 0, + 11077, 11078, 7, 19, 0, 0, 11078, 11079, 7, 12, 0, 0, 11079, 11080, 7, + 6, 0, 0, 11080, 11081, 7, 3, 0, 0, 11081, 11082, 7, 0, 0, 0, 11082, 11083, + 7, 3, 0, 0, 11083, 11084, 7, 8, 0, 0, 11084, 11085, 7, 19, 0, 0, 11085, + 11086, 7, 12, 0, 0, 11086, 11087, 7, 6, 0, 0, 11087, 11088, 7, 5, 0, 0, + 11088, 1232, 1, 0, 0, 0, 11089, 11090, 7, 19, 0, 0, 11090, 11091, 7, 12, + 0, 0, 11091, 11092, 7, 6, 0, 0, 11092, 11093, 7, 3, 0, 0, 11093, 11094, + 7, 0, 0, 0, 11094, 11095, 7, 3, 0, 0, 11095, 11096, 7, 8, 0, 0, 11096, + 11097, 7, 19, 0, 0, 11097, 11098, 7, 18, 0, 0, 11098, 1234, 1, 0, 0, 0, + 11099, 11100, 7, 19, 0, 0, 11100, 11101, 7, 12, 0, 0, 11101, 11102, 7, + 17, 0, 0, 11102, 11103, 7, 19, 0, 0, 11103, 1236, 1, 0, 0, 0, 11104, 11105, + 7, 19, 0, 0, 11105, 11106, 7, 12, 0, 0, 11106, 11107, 7, 7, 0, 0, 11107, + 11108, 7, 4, 0, 0, 11108, 11109, 7, 5, 0, 0, 11109, 11110, 7, 6, 0, 0, + 11110, 11111, 7, 4, 0, 0, 11111, 11112, 5, 95, 0, 0, 11112, 11113, 7, 1, + 0, 0, 11113, 11114, 7, 6, 0, 0, 11114, 11115, 7, 17, 0, 0, 11115, 11116, + 7, 12, 0, 0, 11116, 11117, 7, 7, 0, 0, 11117, 1238, 1, 0, 0, 0, 11118, + 11119, 7, 19, 0, 0, 11119, 11120, 7, 12, 0, 0, 11120, 11121, 7, 7, 0, 0, + 11121, 11122, 7, 4, 0, 0, 11122, 11123, 7, 5, 0, 0, 11123, 11124, 7, 6, + 0, 0, 11124, 11125, 7, 4, 0, 0, 11125, 11126, 5, 95, 0, 0, 11126, 11127, + 7, 6, 0, 0, 11127, 11128, 7, 7, 0, 0, 11128, 11129, 7, 9, 0, 0, 11129, + 1240, 1, 0, 0, 0, 11130, 11131, 7, 19, 0, 0, 11131, 11132, 7, 2, 0, 0, + 11132, 11133, 7, 4, 0, 0, 11133, 1242, 1, 0, 0, 0, 11134, 11135, 7, 19, + 0, 0, 11135, 11136, 7, 2, 0, 0, 11136, 11137, 7, 10, 0, 0, 11137, 11138, + 7, 3, 0, 0, 11138, 1244, 1, 0, 0, 0, 11139, 11140, 7, 19, 0, 0, 11140, + 11141, 7, 2, 0, 0, 11141, 11142, 7, 10, 0, 0, 11142, 11143, 7, 3, 0, 0, + 11143, 11144, 7, 5, 0, 0, 11144, 1246, 1, 0, 0, 0, 11145, 11146, 7, 19, + 0, 0, 11146, 11147, 7, 4, 0, 0, 11147, 11148, 7, 4, 0, 0, 11148, 11149, + 7, 15, 0, 0, 11149, 1248, 1, 0, 0, 0, 11150, 11151, 7, 19, 0, 0, 11151, + 11152, 7, 22, 0, 0, 11152, 11153, 7, 14, 0, 0, 11153, 11154, 5, 95, 0, + 0, 11154, 11155, 7, 1, 0, 0, 11155, 11156, 7, 3, 0, 0, 11156, 11157, 7, + 2, 0, 0, 11157, 11158, 7, 21, 0, 0, 11158, 11159, 7, 6, 0, 0, 11159, 11160, + 7, 3, 0, 0, 11160, 11161, 7, 6, 0, 0, 11161, 11162, 7, 9, 0, 0, 11162, + 1250, 1, 0, 0, 0, 11163, 11164, 7, 19, 0, 0, 11164, 11165, 7, 18, 0, 0, + 11165, 11166, 7, 1, 0, 0, 11166, 11167, 7, 3, 0, 0, 11167, 11168, 7, 12, + 0, 0, 11168, 11169, 7, 9, 0, 0, 11169, 1252, 1, 0, 0, 0, 11170, 11171, + 7, 19, 0, 0, 11171, 1254, 1, 0, 0, 0, 11172, 11173, 7, 12, 0, 0, 11173, + 11174, 7, 9, 0, 0, 11174, 11175, 7, 6, 0, 0, 11175, 11176, 7, 7, 0, 0, + 11176, 11177, 7, 4, 0, 0, 11177, 11178, 7, 12, 0, 0, 11178, 11179, 7, 16, + 0, 0, 11179, 11180, 7, 12, 0, 0, 11180, 11181, 7, 6, 0, 0, 11181, 11182, + 7, 9, 0, 0, 11182, 1256, 1, 0, 0, 0, 11183, 11184, 7, 12, 0, 0, 11184, + 11185, 7, 9, 0, 0, 11185, 11186, 7, 6, 0, 0, 11186, 11187, 7, 7, 0, 0, + 11187, 11188, 7, 4, 0, 0, 11188, 11189, 7, 12, 0, 0, 11189, 11190, 7, 16, + 0, 0, 11190, 11191, 7, 12, 0, 0, 11191, 11192, 7, 6, 0, 0, 11192, 11193, + 7, 3, 0, 0, 11193, 1258, 1, 0, 0, 0, 11194, 11195, 7, 12, 0, 0, 11195, + 11196, 7, 9, 0, 0, 11196, 11197, 7, 6, 0, 0, 11197, 11198, 7, 7, 0, 0, + 11198, 11199, 7, 4, 0, 0, 11199, 11200, 7, 12, 0, 0, 11200, 11201, 7, 4, + 0, 0, 11201, 11202, 7, 18, 0, 0, 11202, 1260, 1, 0, 0, 0, 11203, 11204, + 7, 12, 0, 0, 11204, 11205, 7, 9, 0, 0, 11205, 11206, 7, 17, 0, 0, 11206, + 11207, 7, 6, 0, 0, 11207, 11208, 7, 7, 0, 0, 11208, 11209, 7, 6, 0, 0, + 11209, 11210, 7, 3, 0, 0, 11210, 11211, 7, 0, 0, 0, 11211, 11212, 7, 4, + 0, 0, 11212, 11213, 7, 2, 0, 0, 11213, 11214, 7, 3, 0, 0, 11214, 11215, + 7, 5, 0, 0, 11215, 1262, 1, 0, 0, 0, 11216, 11217, 7, 12, 0, 0, 11217, + 11218, 7, 9, 0, 0, 11218, 1264, 1, 0, 0, 0, 11219, 11220, 7, 12, 0, 0, + 11220, 11221, 7, 9, 0, 0, 11221, 11222, 7, 11, 0, 0, 11222, 11223, 7, 6, + 0, 0, 11223, 11224, 5, 95, 0, 0, 11224, 11225, 7, 4, 0, 0, 11225, 11226, + 7, 12, 0, 0, 11226, 11227, 7, 14, 0, 0, 11227, 11228, 7, 6, 0, 0, 11228, + 1266, 1, 0, 0, 0, 11229, 11230, 7, 12, 0, 0, 11230, 11231, 7, 16, 0, 0, + 11231, 1268, 1, 0, 0, 0, 11232, 11233, 7, 12, 0, 0, 11233, 11234, 7, 17, + 0, 0, 11234, 11235, 7, 7, 0, 0, 11235, 11236, 7, 2, 0, 0, 11236, 11237, + 7, 3, 0, 0, 11237, 11238, 7, 6, 0, 0, 11238, 1270, 1, 0, 0, 0, 11239, 11240, + 7, 12, 0, 0, 11240, 11241, 7, 17, 0, 0, 11241, 11242, 7, 7, 0, 0, 11242, + 11243, 7, 2, 0, 0, 11243, 11244, 7, 3, 0, 0, 11244, 11245, 7, 6, 0, 0, + 11245, 11246, 5, 95, 0, 0, 11246, 11247, 7, 2, 0, 0, 11247, 11248, 7, 15, + 0, 0, 11248, 11249, 7, 4, 0, 0, 11249, 11250, 7, 12, 0, 0, 11250, 11251, + 7, 14, 0, 0, 11251, 11252, 5, 95, 0, 0, 11252, 11253, 7, 6, 0, 0, 11253, + 11254, 7, 14, 0, 0, 11254, 11255, 7, 1, 0, 0, 11255, 11256, 7, 6, 0, 0, + 11256, 11257, 7, 9, 0, 0, 11257, 11258, 7, 9, 0, 0, 11258, 11259, 7, 6, + 0, 0, 11259, 11260, 7, 9, 0, 0, 11260, 11261, 5, 95, 0, 0, 11261, 11262, + 7, 19, 0, 0, 11262, 11263, 7, 12, 0, 0, 11263, 11264, 7, 7, 0, 0, 11264, + 11265, 7, 4, 0, 0, 11265, 11266, 7, 5, 0, 0, 11266, 1272, 1, 0, 0, 0, 11267, + 11268, 7, 12, 0, 0, 11268, 11269, 7, 17, 0, 0, 11269, 11270, 7, 7, 0, 0, + 11270, 11271, 7, 2, 0, 0, 11271, 11272, 7, 3, 0, 0, 11272, 11273, 7, 6, + 0, 0, 11273, 11274, 5, 95, 0, 0, 11274, 11275, 7, 3, 0, 0, 11275, 11276, + 7, 2, 0, 0, 11276, 11277, 7, 22, 0, 0, 11277, 11278, 5, 95, 0, 0, 11278, + 11279, 7, 2, 0, 0, 11279, 11280, 7, 7, 0, 0, 11280, 11281, 5, 95, 0, 0, + 11281, 11282, 7, 9, 0, 0, 11282, 11283, 7, 10, 0, 0, 11283, 11284, 7, 15, + 0, 0, 11284, 11285, 7, 21, 0, 0, 11285, 11286, 7, 6, 0, 0, 11286, 11287, + 7, 18, 0, 0, 11287, 11288, 5, 95, 0, 0, 11288, 11289, 7, 12, 0, 0, 11289, + 11290, 7, 7, 0, 0, 11290, 11291, 7, 9, 0, 0, 11291, 11292, 7, 6, 0, 0, + 11292, 11293, 7, 25, 0, 0, 11293, 1274, 1, 0, 0, 0, 11294, 11295, 7, 12, + 0, 0, 11295, 11296, 7, 17, 0, 0, 11296, 11297, 7, 7, 0, 0, 11297, 11298, + 7, 2, 0, 0, 11298, 11299, 7, 3, 0, 0, 11299, 11300, 7, 6, 0, 0, 11300, + 11301, 5, 95, 0, 0, 11301, 11302, 7, 22, 0, 0, 11302, 11303, 7, 19, 0, + 0, 11303, 11304, 7, 6, 0, 0, 11304, 11305, 7, 3, 0, 0, 11305, 11306, 7, + 6, 0, 0, 11306, 11307, 5, 95, 0, 0, 11307, 11308, 7, 8, 0, 0, 11308, 11309, + 7, 11, 0, 0, 11309, 11310, 7, 0, 0, 0, 11310, 11311, 7, 10, 0, 0, 11311, + 11312, 7, 5, 0, 0, 11312, 11313, 7, 6, 0, 0, 11313, 1276, 1, 0, 0, 0, 11314, + 11315, 7, 12, 0, 0, 11315, 11316, 7, 11, 0, 0, 11316, 11317, 7, 14, 0, + 0, 11317, 1278, 1, 0, 0, 0, 11318, 11319, 7, 12, 0, 0, 11319, 11320, 7, + 14, 0, 0, 11320, 11321, 7, 14, 0, 0, 11321, 11322, 7, 6, 0, 0, 11322, 11323, + 7, 9, 0, 0, 11323, 11324, 7, 12, 0, 0, 11324, 11325, 7, 0, 0, 0, 11325, + 11326, 7, 4, 0, 0, 11326, 11327, 7, 6, 0, 0, 11327, 1280, 1, 0, 0, 0, 11328, + 11329, 7, 12, 0, 0, 11329, 11330, 7, 14, 0, 0, 11330, 11331, 7, 15, 0, + 0, 11331, 11332, 7, 0, 0, 0, 11332, 11333, 7, 8, 0, 0, 11333, 11334, 7, + 4, 0, 0, 11334, 1282, 1, 0, 0, 0, 11335, 11336, 7, 12, 0, 0, 11336, 11337, + 7, 14, 0, 0, 11337, 11338, 7, 15, 0, 0, 11338, 11339, 7, 2, 0, 0, 11339, + 11340, 7, 3, 0, 0, 11340, 11341, 7, 4, 0, 0, 11341, 1284, 1, 0, 0, 0, 11342, + 11343, 7, 12, 0, 0, 11343, 11344, 7, 7, 0, 0, 11344, 11345, 7, 0, 0, 0, + 11345, 11346, 7, 8, 0, 0, 11346, 11347, 7, 4, 0, 0, 11347, 11348, 7, 12, + 0, 0, 11348, 11349, 7, 13, 0, 0, 11349, 11350, 7, 6, 0, 0, 11350, 1286, + 1, 0, 0, 0, 11351, 11352, 7, 12, 0, 0, 11352, 11353, 7, 7, 0, 0, 11353, + 11354, 7, 0, 0, 0, 11354, 11355, 7, 8, 0, 0, 11355, 11356, 7, 4, 0, 0, + 11356, 11357, 7, 12, 0, 0, 11357, 11358, 7, 13, 0, 0, 11358, 11359, 7, + 6, 0, 0, 11359, 11360, 5, 95, 0, 0, 11360, 11361, 7, 0, 0, 0, 11361, 11362, + 7, 8, 0, 0, 11362, 11363, 7, 8, 0, 0, 11363, 11364, 7, 2, 0, 0, 11364, + 11365, 7, 10, 0, 0, 11365, 11366, 7, 7, 0, 0, 11366, 11367, 7, 4, 0, 0, + 11367, 11368, 5, 95, 0, 0, 11368, 11369, 7, 4, 0, 0, 11369, 11370, 7, 12, + 0, 0, 11370, 11371, 7, 14, 0, 0, 11371, 11372, 7, 6, 0, 0, 11372, 1288, + 1, 0, 0, 0, 11373, 11374, 7, 12, 0, 0, 11374, 11375, 7, 7, 0, 0, 11375, + 11376, 7, 8, 0, 0, 11376, 11377, 7, 11, 0, 0, 11377, 11378, 7, 10, 0, 0, + 11378, 11379, 7, 9, 0, 0, 11379, 11380, 7, 6, 0, 0, 11380, 1290, 1, 0, + 0, 0, 11381, 11382, 7, 12, 0, 0, 11382, 11383, 7, 7, 0, 0, 11383, 11384, + 7, 8, 0, 0, 11384, 11385, 7, 11, 0, 0, 11385, 11386, 7, 10, 0, 0, 11386, + 11387, 7, 9, 0, 0, 11387, 11388, 7, 6, 0, 0, 11388, 11389, 5, 95, 0, 0, + 11389, 11390, 7, 13, 0, 0, 11390, 11391, 7, 6, 0, 0, 11391, 11392, 7, 3, + 0, 0, 11392, 11393, 7, 5, 0, 0, 11393, 11394, 7, 12, 0, 0, 11394, 11395, + 7, 2, 0, 0, 11395, 11396, 7, 7, 0, 0, 11396, 1292, 1, 0, 0, 0, 11397, 11398, + 7, 12, 0, 0, 11398, 11399, 7, 7, 0, 0, 11399, 11400, 7, 8, 0, 0, 11400, + 11401, 7, 11, 0, 0, 11401, 11402, 7, 10, 0, 0, 11402, 11403, 7, 9, 0, 0, + 11403, 11404, 7, 12, 0, 0, 11404, 11405, 7, 7, 0, 0, 11405, 11406, 7, 17, + 0, 0, 11406, 1294, 1, 0, 0, 0, 11407, 11408, 7, 12, 0, 0, 11408, 11409, + 7, 7, 0, 0, 11409, 11410, 7, 8, 0, 0, 11410, 11411, 7, 3, 0, 0, 11411, + 11412, 7, 6, 0, 0, 11412, 11413, 7, 14, 0, 0, 11413, 11414, 7, 6, 0, 0, + 11414, 11415, 7, 7, 0, 0, 11415, 11416, 7, 4, 0, 0, 11416, 11417, 7, 0, + 0, 0, 11417, 11418, 7, 11, 0, 0, 11418, 1296, 1, 0, 0, 0, 11419, 11420, + 7, 12, 0, 0, 11420, 11421, 7, 7, 0, 0, 11421, 11422, 7, 8, 0, 0, 11422, + 11423, 7, 3, 0, 0, 11423, 11424, 7, 6, 0, 0, 11424, 11425, 7, 14, 0, 0, + 11425, 11426, 7, 6, 0, 0, 11426, 11427, 7, 7, 0, 0, 11427, 11428, 7, 4, + 0, 0, 11428, 1298, 1, 0, 0, 0, 11429, 11430, 7, 12, 0, 0, 11430, 11431, + 7, 7, 0, 0, 11431, 11432, 7, 8, 0, 0, 11432, 11433, 7, 3, 0, 0, 11433, + 1300, 1, 0, 0, 0, 11434, 11435, 7, 12, 0, 0, 11435, 11436, 7, 7, 0, 0, + 11436, 11437, 7, 9, 0, 0, 11437, 11438, 7, 6, 0, 0, 11438, 11439, 7, 7, + 0, 0, 11439, 11440, 7, 4, 0, 0, 11440, 1302, 1, 0, 0, 0, 11441, 11442, + 7, 12, 0, 0, 11442, 11443, 7, 7, 0, 0, 11443, 11444, 7, 9, 0, 0, 11444, + 11445, 7, 6, 0, 0, 11445, 11446, 7, 25, 0, 0, 11446, 11447, 5, 95, 0, 0, + 11447, 11448, 7, 0, 0, 0, 11448, 11449, 7, 5, 0, 0, 11449, 11450, 7, 8, + 0, 0, 11450, 1304, 1, 0, 0, 0, 11451, 11452, 7, 12, 0, 0, 11452, 11453, + 7, 7, 0, 0, 11453, 11454, 7, 9, 0, 0, 11454, 11455, 7, 6, 0, 0, 11455, + 11456, 7, 25, 0, 0, 11456, 11457, 5, 95, 0, 0, 11457, 11458, 7, 8, 0, 0, + 11458, 11459, 7, 2, 0, 0, 11459, 11460, 7, 14, 0, 0, 11460, 11461, 7, 1, + 0, 0, 11461, 11462, 7, 12, 0, 0, 11462, 11463, 7, 7, 0, 0, 11463, 11464, + 7, 6, 0, 0, 11464, 1306, 1, 0, 0, 0, 11465, 11466, 7, 12, 0, 0, 11466, + 11467, 7, 7, 0, 0, 11467, 11468, 7, 9, 0, 0, 11468, 11469, 7, 6, 0, 0, + 11469, 11470, 7, 25, 0, 0, 11470, 11471, 5, 95, 0, 0, 11471, 11472, 7, + 9, 0, 0, 11472, 11473, 7, 6, 0, 0, 11473, 11474, 7, 5, 0, 0, 11474, 11475, + 7, 8, 0, 0, 11475, 1308, 1, 0, 0, 0, 11476, 11477, 7, 12, 0, 0, 11477, + 11478, 7, 7, 0, 0, 11478, 11479, 7, 9, 0, 0, 11479, 11480, 7, 6, 0, 0, + 11480, 11481, 7, 25, 0, 0, 11481, 11482, 7, 6, 0, 0, 11482, 11483, 7, 9, + 0, 0, 11483, 1310, 1, 0, 0, 0, 11484, 11485, 7, 12, 0, 0, 11485, 11486, + 7, 7, 0, 0, 11486, 11487, 7, 9, 0, 0, 11487, 11488, 7, 6, 0, 0, 11488, + 11489, 7, 25, 0, 0, 11489, 11490, 7, 6, 0, 0, 11490, 11491, 7, 5, 0, 0, + 11491, 1312, 1, 0, 0, 0, 11492, 11493, 7, 12, 0, 0, 11493, 11494, 7, 7, + 0, 0, 11494, 11495, 7, 9, 0, 0, 11495, 11496, 7, 6, 0, 0, 11496, 11497, + 7, 25, 0, 0, 11497, 11498, 5, 95, 0, 0, 11498, 11499, 7, 16, 0, 0, 11499, + 11500, 7, 16, 0, 0, 11500, 11501, 7, 5, 0, 0, 11501, 1314, 1, 0, 0, 0, + 11502, 11503, 7, 12, 0, 0, 11503, 11504, 7, 7, 0, 0, 11504, 11505, 7, 9, + 0, 0, 11505, 11506, 7, 6, 0, 0, 11506, 11507, 7, 25, 0, 0, 11507, 11508, + 5, 95, 0, 0, 11508, 11509, 7, 16, 0, 0, 11509, 11510, 7, 12, 0, 0, 11510, + 11511, 7, 11, 0, 0, 11511, 11512, 7, 4, 0, 0, 11512, 11513, 7, 6, 0, 0, + 11513, 11514, 7, 3, 0, 0, 11514, 1316, 1, 0, 0, 0, 11515, 11516, 7, 12, + 0, 0, 11516, 11517, 7, 7, 0, 0, 11517, 11518, 7, 9, 0, 0, 11518, 11519, + 7, 6, 0, 0, 11519, 11520, 7, 25, 0, 0, 11520, 1318, 1, 0, 0, 0, 11521, + 11522, 7, 12, 0, 0, 11522, 11523, 7, 7, 0, 0, 11523, 11524, 7, 9, 0, 0, + 11524, 11525, 7, 6, 0, 0, 11525, 11526, 7, 25, 0, 0, 11526, 11527, 7, 12, + 0, 0, 11527, 11528, 7, 7, 0, 0, 11528, 11529, 7, 17, 0, 0, 11529, 1320, + 1, 0, 0, 0, 11530, 11531, 7, 12, 0, 0, 11531, 11532, 7, 7, 0, 0, 11532, + 11533, 7, 9, 0, 0, 11533, 11534, 7, 6, 0, 0, 11534, 11535, 7, 25, 0, 0, + 11535, 11536, 5, 95, 0, 0, 11536, 11537, 7, 20, 0, 0, 11537, 11538, 7, + 2, 0, 0, 11538, 11539, 7, 12, 0, 0, 11539, 11540, 7, 7, 0, 0, 11540, 1322, + 1, 0, 0, 0, 11541, 11542, 7, 12, 0, 0, 11542, 11543, 7, 7, 0, 0, 11543, + 11544, 7, 9, 0, 0, 11544, 11545, 7, 6, 0, 0, 11545, 11546, 7, 25, 0, 0, + 11546, 11547, 5, 95, 0, 0, 11547, 11548, 7, 3, 0, 0, 11548, 11549, 7, 2, + 0, 0, 11549, 11550, 7, 22, 0, 0, 11550, 11551, 7, 5, 0, 0, 11551, 1324, + 1, 0, 0, 0, 11552, 11553, 7, 12, 0, 0, 11553, 11554, 7, 7, 0, 0, 11554, + 11555, 7, 9, 0, 0, 11555, 11556, 7, 6, 0, 0, 11556, 11557, 7, 25, 0, 0, + 11557, 11558, 5, 95, 0, 0, 11558, 11559, 7, 3, 0, 0, 11559, 11560, 7, 3, + 0, 0, 11560, 11561, 7, 5, 0, 0, 11561, 1326, 1, 0, 0, 0, 11562, 11563, + 7, 12, 0, 0, 11563, 11564, 7, 7, 0, 0, 11564, 11565, 7, 9, 0, 0, 11565, + 11566, 7, 6, 0, 0, 11566, 11567, 7, 25, 0, 0, 11567, 11568, 5, 95, 0, 0, + 11568, 11569, 7, 3, 0, 0, 11569, 11570, 7, 5, 0, 0, 11570, 11571, 5, 95, + 0, 0, 11571, 11572, 7, 0, 0, 0, 11572, 11573, 7, 5, 0, 0, 11573, 11574, + 7, 8, 0, 0, 11574, 1328, 1, 0, 0, 0, 11575, 11576, 7, 12, 0, 0, 11576, + 11577, 7, 7, 0, 0, 11577, 11578, 7, 9, 0, 0, 11578, 11579, 7, 6, 0, 0, + 11579, 11580, 7, 25, 0, 0, 11580, 11581, 5, 95, 0, 0, 11581, 11582, 7, + 3, 0, 0, 11582, 11583, 7, 5, 0, 0, 11583, 11584, 5, 95, 0, 0, 11584, 11585, + 7, 9, 0, 0, 11585, 11586, 7, 6, 0, 0, 11586, 11587, 7, 5, 0, 0, 11587, + 11588, 7, 8, 0, 0, 11588, 1330, 1, 0, 0, 0, 11589, 11590, 7, 12, 0, 0, + 11590, 11591, 7, 7, 0, 0, 11591, 11592, 7, 9, 0, 0, 11592, 11593, 7, 6, + 0, 0, 11593, 11594, 7, 25, 0, 0, 11594, 11595, 5, 95, 0, 0, 11595, 11596, + 7, 3, 0, 0, 11596, 11597, 7, 5, 0, 0, 11597, 1332, 1, 0, 0, 0, 11598, 11599, + 7, 12, 0, 0, 11599, 11600, 7, 7, 0, 0, 11600, 11601, 7, 9, 0, 0, 11601, + 11602, 7, 6, 0, 0, 11602, 11603, 7, 25, 0, 0, 11603, 11604, 5, 95, 0, 0, + 11604, 11605, 7, 5, 0, 0, 11605, 11606, 7, 8, 0, 0, 11606, 11607, 7, 0, + 0, 0, 11607, 11608, 7, 7, 0, 0, 11608, 1334, 1, 0, 0, 0, 11609, 11610, + 7, 12, 0, 0, 11610, 11611, 7, 7, 0, 0, 11611, 11612, 7, 9, 0, 0, 11612, + 11613, 7, 6, 0, 0, 11613, 11614, 7, 25, 0, 0, 11614, 11615, 5, 95, 0, 0, + 11615, 11616, 7, 5, 0, 0, 11616, 11617, 7, 21, 0, 0, 11617, 11618, 7, 12, + 0, 0, 11618, 11619, 7, 15, 0, 0, 11619, 11620, 5, 95, 0, 0, 11620, 11621, + 7, 5, 0, 0, 11621, 11622, 7, 8, 0, 0, 11622, 11623, 7, 0, 0, 0, 11623, + 11624, 7, 7, 0, 0, 11624, 1336, 1, 0, 0, 0, 11625, 11626, 7, 12, 0, 0, + 11626, 11627, 7, 7, 0, 0, 11627, 11628, 7, 9, 0, 0, 11628, 11629, 7, 6, + 0, 0, 11629, 11630, 7, 25, 0, 0, 11630, 11631, 5, 95, 0, 0, 11631, 11632, + 7, 5, 0, 0, 11632, 11633, 7, 5, 0, 0, 11633, 11634, 5, 95, 0, 0, 11634, + 11635, 7, 0, 0, 0, 11635, 11636, 7, 5, 0, 0, 11636, 11637, 7, 8, 0, 0, + 11637, 1338, 1, 0, 0, 0, 11638, 11639, 7, 12, 0, 0, 11639, 11640, 7, 7, + 0, 0, 11640, 11641, 7, 9, 0, 0, 11641, 11642, 7, 6, 0, 0, 11642, 11643, + 7, 25, 0, 0, 11643, 11644, 5, 95, 0, 0, 11644, 11645, 7, 5, 0, 0, 11645, + 11646, 7, 5, 0, 0, 11646, 11647, 5, 95, 0, 0, 11647, 11648, 7, 9, 0, 0, + 11648, 11649, 7, 6, 0, 0, 11649, 11650, 7, 5, 0, 0, 11650, 11651, 7, 8, + 0, 0, 11651, 1340, 1, 0, 0, 0, 11652, 11653, 7, 12, 0, 0, 11653, 11654, + 7, 7, 0, 0, 11654, 11655, 7, 9, 0, 0, 11655, 11656, 7, 6, 0, 0, 11656, + 11657, 7, 25, 0, 0, 11657, 11658, 5, 95, 0, 0, 11658, 11659, 7, 5, 0, 0, + 11659, 11660, 7, 5, 0, 0, 11660, 1342, 1, 0, 0, 0, 11661, 11662, 7, 12, + 0, 0, 11662, 11663, 7, 7, 0, 0, 11663, 11664, 7, 9, 0, 0, 11664, 11665, + 7, 6, 0, 0, 11665, 11666, 7, 25, 0, 0, 11666, 11667, 5, 95, 0, 0, 11667, + 11668, 7, 5, 0, 0, 11668, 11669, 7, 4, 0, 0, 11669, 11670, 7, 0, 0, 0, + 11670, 11671, 7, 4, 0, 0, 11671, 11672, 7, 5, 0, 0, 11672, 1344, 1, 0, + 0, 0, 11673, 11674, 7, 12, 0, 0, 11674, 11675, 7, 7, 0, 0, 11675, 11676, + 7, 9, 0, 0, 11676, 11677, 7, 6, 0, 0, 11677, 11678, 7, 25, 0, 0, 11678, + 11679, 7, 4, 0, 0, 11679, 11680, 7, 18, 0, 0, 11680, 11681, 7, 15, 0, 0, + 11681, 11682, 7, 6, 0, 0, 11682, 1346, 1, 0, 0, 0, 11683, 11684, 7, 12, + 0, 0, 11684, 11685, 7, 7, 0, 0, 11685, 11686, 7, 9, 0, 0, 11686, 11687, + 7, 6, 0, 0, 11687, 11688, 7, 25, 0, 0, 11688, 11689, 7, 4, 0, 0, 11689, + 11690, 7, 18, 0, 0, 11690, 11691, 7, 15, 0, 0, 11691, 11692, 7, 6, 0, 0, + 11692, 11693, 7, 5, 0, 0, 11693, 1348, 1, 0, 0, 0, 11694, 11695, 7, 12, + 0, 0, 11695, 11696, 7, 7, 0, 0, 11696, 11697, 7, 9, 0, 0, 11697, 11698, + 7, 12, 0, 0, 11698, 11699, 7, 8, 0, 0, 11699, 11700, 7, 0, 0, 0, 11700, + 11701, 7, 4, 0, 0, 11701, 11702, 7, 2, 0, 0, 11702, 11703, 7, 3, 0, 0, + 11703, 1350, 1, 0, 0, 0, 11704, 11705, 7, 12, 0, 0, 11705, 11706, 7, 7, + 0, 0, 11706, 11707, 7, 9, 0, 0, 11707, 11708, 7, 12, 0, 0, 11708, 11709, + 7, 8, 0, 0, 11709, 11710, 7, 6, 0, 0, 11710, 11711, 7, 5, 0, 0, 11711, + 1352, 1, 0, 0, 0, 11712, 11713, 7, 12, 0, 0, 11713, 11714, 7, 7, 0, 0, + 11714, 11715, 7, 16, 0, 0, 11715, 11716, 7, 12, 0, 0, 11716, 11717, 7, + 7, 0, 0, 11717, 11718, 7, 12, 0, 0, 11718, 11719, 7, 4, 0, 0, 11719, 11720, + 7, 6, 0, 0, 11720, 1354, 1, 0, 0, 0, 11721, 11722, 7, 12, 0, 0, 11722, + 11723, 7, 7, 0, 0, 11723, 11724, 7, 16, 0, 0, 11724, 11725, 7, 2, 0, 0, + 11725, 11726, 7, 3, 0, 0, 11726, 11727, 7, 14, 0, 0, 11727, 11728, 7, 0, + 0, 0, 11728, 11729, 7, 4, 0, 0, 11729, 11730, 7, 12, 0, 0, 11730, 11731, + 7, 2, 0, 0, 11731, 11732, 7, 7, 0, 0, 11732, 11733, 7, 0, 0, 0, 11733, + 11734, 7, 11, 0, 0, 11734, 1356, 1, 0, 0, 0, 11735, 11736, 7, 12, 0, 0, + 11736, 11737, 7, 7, 0, 0, 11737, 11738, 7, 19, 0, 0, 11738, 11739, 7, 6, + 0, 0, 11739, 11740, 7, 3, 0, 0, 11740, 11741, 7, 12, 0, 0, 11741, 11742, + 7, 4, 0, 0, 11742, 1358, 1, 0, 0, 0, 11743, 11744, 7, 12, 0, 0, 11744, + 11745, 7, 7, 0, 0, 11745, 1360, 1, 0, 0, 0, 11746, 11747, 7, 12, 0, 0, + 11747, 11748, 7, 7, 0, 0, 11748, 11749, 7, 12, 0, 0, 11749, 11750, 7, 4, + 0, 0, 11750, 11751, 7, 8, 0, 0, 11751, 11752, 7, 0, 0, 0, 11752, 11753, + 7, 15, 0, 0, 11753, 1362, 1, 0, 0, 0, 11754, 11755, 7, 12, 0, 0, 11755, + 11756, 7, 7, 0, 0, 11756, 11757, 7, 12, 0, 0, 11757, 11758, 7, 4, 0, 0, + 11758, 11759, 7, 12, 0, 0, 11759, 11760, 7, 0, 0, 0, 11760, 11761, 7, 11, + 0, 0, 11761, 1364, 1, 0, 0, 0, 11762, 11763, 7, 12, 0, 0, 11763, 11764, + 7, 7, 0, 0, 11764, 11765, 7, 12, 0, 0, 11765, 11766, 7, 4, 0, 0, 11766, + 11767, 7, 12, 0, 0, 11767, 11768, 7, 0, 0, 0, 11768, 11769, 7, 11, 0, 0, + 11769, 11770, 7, 12, 0, 0, 11770, 11771, 7, 23, 0, 0, 11771, 11772, 7, + 6, 0, 0, 11772, 11773, 7, 9, 0, 0, 11773, 1366, 1, 0, 0, 0, 11774, 11775, + 7, 12, 0, 0, 11775, 11776, 7, 7, 0, 0, 11776, 11777, 7, 12, 0, 0, 11777, + 11778, 7, 4, 0, 0, 11778, 11779, 7, 12, 0, 0, 11779, 11780, 7, 0, 0, 0, + 11780, 11781, 7, 11, 0, 0, 11781, 11782, 7, 11, 0, 0, 11782, 11783, 7, + 18, 0, 0, 11783, 1368, 1, 0, 0, 0, 11784, 11785, 7, 12, 0, 0, 11785, 11786, + 7, 7, 0, 0, 11786, 11787, 7, 12, 0, 0, 11787, 11788, 7, 4, 0, 0, 11788, + 11789, 7, 3, 0, 0, 11789, 11790, 7, 0, 0, 0, 11790, 11791, 7, 7, 0, 0, + 11791, 11792, 7, 5, 0, 0, 11792, 1370, 1, 0, 0, 0, 11793, 11794, 7, 12, + 0, 0, 11794, 11795, 7, 7, 0, 0, 11795, 11796, 7, 11, 0, 0, 11796, 11797, + 7, 12, 0, 0, 11797, 11798, 7, 7, 0, 0, 11798, 11799, 7, 6, 0, 0, 11799, + 1372, 1, 0, 0, 0, 11800, 11801, 7, 12, 0, 0, 11801, 11802, 7, 7, 0, 0, + 11802, 11803, 7, 11, 0, 0, 11803, 11804, 7, 12, 0, 0, 11804, 11805, 7, + 7, 0, 0, 11805, 11806, 7, 6, 0, 0, 11806, 11807, 5, 95, 0, 0, 11807, 11808, + 7, 25, 0, 0, 11808, 11809, 7, 14, 0, 0, 11809, 11810, 7, 11, 0, 0, 11810, + 11811, 7, 4, 0, 0, 11811, 11812, 7, 18, 0, 0, 11812, 11813, 7, 15, 0, 0, + 11813, 11814, 7, 6, 0, 0, 11814, 11815, 5, 95, 0, 0, 11815, 11816, 7, 7, + 0, 0, 11816, 11817, 7, 4, 0, 0, 11817, 1374, 1, 0, 0, 0, 11818, 11819, + 7, 12, 0, 0, 11819, 11820, 7, 7, 0, 0, 11820, 11821, 7, 14, 0, 0, 11821, + 11822, 7, 6, 0, 0, 11822, 11823, 7, 14, 0, 0, 11823, 11824, 7, 2, 0, 0, + 11824, 11825, 7, 3, 0, 0, 11825, 11826, 7, 18, 0, 0, 11826, 1376, 1, 0, + 0, 0, 11827, 11828, 7, 12, 0, 0, 11828, 11829, 7, 7, 0, 0, 11829, 11830, + 5, 95, 0, 0, 11830, 11831, 7, 14, 0, 0, 11831, 11832, 7, 6, 0, 0, 11832, + 11833, 7, 14, 0, 0, 11833, 11834, 7, 2, 0, 0, 11834, 11835, 7, 3, 0, 0, + 11835, 11836, 7, 18, 0, 0, 11836, 11837, 5, 95, 0, 0, 11837, 11838, 7, + 14, 0, 0, 11838, 11839, 7, 6, 0, 0, 11839, 11840, 7, 4, 0, 0, 11840, 11841, + 7, 0, 0, 0, 11841, 11842, 7, 9, 0, 0, 11842, 11843, 7, 0, 0, 0, 11843, + 11844, 7, 4, 0, 0, 11844, 11845, 7, 0, 0, 0, 11845, 1378, 1, 0, 0, 0, 11846, + 11847, 7, 12, 0, 0, 11847, 11848, 7, 7, 0, 0, 11848, 11849, 7, 14, 0, 0, + 11849, 11850, 7, 6, 0, 0, 11850, 11851, 7, 14, 0, 0, 11851, 11852, 7, 2, + 0, 0, 11852, 11853, 7, 3, 0, 0, 11853, 11854, 7, 18, 0, 0, 11854, 11855, + 5, 95, 0, 0, 11855, 11856, 7, 15, 0, 0, 11856, 11857, 7, 3, 0, 0, 11857, + 11858, 7, 10, 0, 0, 11858, 11859, 7, 7, 0, 0, 11859, 11860, 7, 12, 0, 0, + 11860, 11861, 7, 7, 0, 0, 11861, 11862, 7, 17, 0, 0, 11862, 1380, 1, 0, + 0, 0, 11863, 11864, 7, 12, 0, 0, 11864, 11865, 7, 7, 0, 0, 11865, 11866, + 7, 7, 0, 0, 11866, 11867, 7, 6, 0, 0, 11867, 11868, 7, 3, 0, 0, 11868, + 1382, 1, 0, 0, 0, 11869, 11870, 7, 12, 0, 0, 11870, 11871, 7, 7, 0, 0, + 11871, 11872, 7, 2, 0, 0, 11872, 11873, 7, 10, 0, 0, 11873, 11874, 7, 4, + 0, 0, 11874, 1384, 1, 0, 0, 0, 11875, 11876, 7, 12, 0, 0, 11876, 11877, + 7, 7, 0, 0, 11877, 11878, 7, 15, 0, 0, 11878, 11879, 7, 11, 0, 0, 11879, + 11880, 7, 0, 0, 0, 11880, 11881, 7, 8, 0, 0, 11881, 11882, 7, 6, 0, 0, + 11882, 1386, 1, 0, 0, 0, 11883, 11884, 7, 12, 0, 0, 11884, 11885, 7, 7, + 0, 0, 11885, 11886, 7, 5, 0, 0, 11886, 11887, 7, 6, 0, 0, 11887, 11888, + 7, 3, 0, 0, 11888, 11889, 7, 4, 0, 0, 11889, 11890, 7, 8, 0, 0, 11890, + 11891, 7, 19, 0, 0, 11891, 11892, 7, 12, 0, 0, 11892, 11893, 7, 11, 0, + 0, 11893, 11894, 7, 9, 0, 0, 11894, 11895, 7, 25, 0, 0, 11895, 11896, 7, + 14, 0, 0, 11896, 11897, 7, 11, 0, 0, 11897, 11898, 7, 0, 0, 0, 11898, 11899, + 7, 16, 0, 0, 11899, 11900, 7, 4, 0, 0, 11900, 11901, 7, 6, 0, 0, 11901, + 11902, 7, 3, 0, 0, 11902, 1388, 1, 0, 0, 0, 11903, 11904, 7, 12, 0, 0, + 11904, 11905, 7, 7, 0, 0, 11905, 11906, 7, 5, 0, 0, 11906, 11907, 7, 6, + 0, 0, 11907, 11908, 7, 3, 0, 0, 11908, 11909, 7, 4, 0, 0, 11909, 11910, + 7, 8, 0, 0, 11910, 11911, 7, 19, 0, 0, 11911, 11912, 7, 12, 0, 0, 11912, + 11913, 7, 11, 0, 0, 11913, 11914, 7, 9, 0, 0, 11914, 11915, 7, 25, 0, 0, + 11915, 11916, 7, 14, 0, 0, 11916, 11917, 7, 11, 0, 0, 11917, 11918, 7, + 1, 0, 0, 11918, 11919, 7, 6, 0, 0, 11919, 11920, 7, 16, 0, 0, 11920, 11921, + 7, 2, 0, 0, 11921, 11922, 7, 3, 0, 0, 11922, 11923, 7, 6, 0, 0, 11923, + 1390, 1, 0, 0, 0, 11924, 11925, 7, 12, 0, 0, 11925, 11926, 7, 7, 0, 0, + 11926, 11927, 7, 5, 0, 0, 11927, 11928, 7, 6, 0, 0, 11928, 11929, 7, 3, + 0, 0, 11929, 11930, 7, 4, 0, 0, 11930, 11931, 7, 8, 0, 0, 11931, 11932, + 7, 19, 0, 0, 11932, 11933, 7, 12, 0, 0, 11933, 11934, 7, 11, 0, 0, 11934, + 11935, 7, 9, 0, 0, 11935, 11936, 7, 25, 0, 0, 11936, 11937, 7, 14, 0, 0, + 11937, 11938, 7, 11, 0, 0, 11938, 1392, 1, 0, 0, 0, 11939, 11940, 7, 12, + 0, 0, 11940, 11941, 7, 7, 0, 0, 11941, 11942, 7, 5, 0, 0, 11942, 11943, + 7, 6, 0, 0, 11943, 11944, 7, 3, 0, 0, 11944, 11945, 7, 4, 0, 0, 11945, + 1394, 1, 0, 0, 0, 11946, 11947, 7, 12, 0, 0, 11947, 11948, 7, 7, 0, 0, + 11948, 11949, 7, 5, 0, 0, 11949, 11950, 7, 6, 0, 0, 11950, 11951, 7, 3, + 0, 0, 11951, 11952, 7, 4, 0, 0, 11952, 11953, 7, 25, 0, 0, 11953, 11954, + 7, 14, 0, 0, 11954, 11955, 7, 11, 0, 0, 11955, 11956, 7, 0, 0, 0, 11956, + 11957, 7, 16, 0, 0, 11957, 11958, 7, 4, 0, 0, 11958, 11959, 7, 6, 0, 0, + 11959, 11960, 7, 3, 0, 0, 11960, 1396, 1, 0, 0, 0, 11961, 11962, 7, 12, + 0, 0, 11962, 11963, 7, 7, 0, 0, 11963, 11964, 7, 5, 0, 0, 11964, 11965, + 7, 6, 0, 0, 11965, 11966, 7, 3, 0, 0, 11966, 11967, 7, 4, 0, 0, 11967, + 11968, 7, 25, 0, 0, 11968, 11969, 7, 14, 0, 0, 11969, 11970, 7, 11, 0, + 0, 11970, 11971, 7, 1, 0, 0, 11971, 11972, 7, 6, 0, 0, 11972, 11973, 7, + 16, 0, 0, 11973, 11974, 7, 2, 0, 0, 11974, 11975, 7, 3, 0, 0, 11975, 11976, + 7, 6, 0, 0, 11976, 1398, 1, 0, 0, 0, 11977, 11978, 7, 12, 0, 0, 11978, + 11979, 7, 7, 0, 0, 11979, 11980, 7, 5, 0, 0, 11980, 11981, 7, 4, 0, 0, + 11981, 11982, 7, 0, 0, 0, 11982, 11983, 7, 7, 0, 0, 11983, 11984, 7, 8, + 0, 0, 11984, 11985, 7, 6, 0, 0, 11985, 1400, 1, 0, 0, 0, 11986, 11987, + 7, 12, 0, 0, 11987, 11988, 7, 7, 0, 0, 11988, 11989, 7, 5, 0, 0, 11989, + 11990, 7, 4, 0, 0, 11990, 11991, 7, 0, 0, 0, 11991, 11992, 7, 7, 0, 0, + 11992, 11993, 7, 8, 0, 0, 11993, 11994, 7, 6, 0, 0, 11994, 11995, 7, 5, + 0, 0, 11995, 1402, 1, 0, 0, 0, 11996, 11997, 7, 12, 0, 0, 11997, 11998, + 7, 7, 0, 0, 11998, 11999, 7, 5, 0, 0, 11999, 12000, 7, 4, 0, 0, 12000, + 12001, 7, 0, 0, 0, 12001, 12002, 7, 7, 0, 0, 12002, 12003, 7, 4, 0, 0, + 12003, 12004, 7, 12, 0, 0, 12004, 12005, 7, 0, 0, 0, 12005, 12006, 7, 1, + 0, 0, 12006, 12007, 7, 11, 0, 0, 12007, 12008, 7, 6, 0, 0, 12008, 1404, + 1, 0, 0, 0, 12009, 12010, 7, 12, 0, 0, 12010, 12011, 7, 7, 0, 0, 12011, + 12012, 7, 5, 0, 0, 12012, 12013, 7, 4, 0, 0, 12013, 12014, 7, 0, 0, 0, + 12014, 12015, 7, 7, 0, 0, 12015, 12016, 7, 4, 0, 0, 12016, 12017, 7, 11, + 0, 0, 12017, 12018, 7, 18, 0, 0, 12018, 1406, 1, 0, 0, 0, 12019, 12020, + 7, 12, 0, 0, 12020, 12021, 7, 7, 0, 0, 12021, 12022, 7, 5, 0, 0, 12022, + 12023, 7, 4, 0, 0, 12023, 12024, 7, 6, 0, 0, 12024, 12025, 7, 0, 0, 0, + 12025, 12026, 7, 9, 0, 0, 12026, 1408, 1, 0, 0, 0, 12027, 12028, 7, 12, + 0, 0, 12028, 12029, 7, 7, 0, 0, 12029, 12030, 7, 5, 0, 0, 12030, 12031, + 7, 4, 0, 0, 12031, 12032, 7, 3, 0, 0, 12032, 12033, 5, 50, 0, 0, 12033, + 1410, 1, 0, 0, 0, 12034, 12035, 7, 12, 0, 0, 12035, 12036, 7, 7, 0, 0, + 12036, 12037, 7, 5, 0, 0, 12037, 12038, 7, 4, 0, 0, 12038, 12039, 7, 3, + 0, 0, 12039, 12040, 5, 52, 0, 0, 12040, 1412, 1, 0, 0, 0, 12041, 12042, + 7, 12, 0, 0, 12042, 12043, 7, 7, 0, 0, 12043, 12044, 7, 5, 0, 0, 12044, + 12045, 7, 4, 0, 0, 12045, 12046, 7, 3, 0, 0, 12046, 12047, 7, 1, 0, 0, + 12047, 1414, 1, 0, 0, 0, 12048, 12049, 7, 12, 0, 0, 12049, 12050, 7, 7, + 0, 0, 12050, 12051, 7, 5, 0, 0, 12051, 12052, 7, 4, 0, 0, 12052, 12053, + 7, 3, 0, 0, 12053, 12054, 7, 8, 0, 0, 12054, 1416, 1, 0, 0, 0, 12055, 12056, + 7, 12, 0, 0, 12056, 12057, 7, 7, 0, 0, 12057, 12058, 7, 5, 0, 0, 12058, + 12059, 7, 4, 0, 0, 12059, 12060, 7, 3, 0, 0, 12060, 1418, 1, 0, 0, 0, 12061, + 12062, 7, 12, 0, 0, 12062, 12063, 7, 7, 0, 0, 12063, 12064, 7, 4, 0, 0, + 12064, 12065, 7, 6, 0, 0, 12065, 12066, 7, 17, 0, 0, 12066, 12067, 7, 6, + 0, 0, 12067, 12068, 7, 3, 0, 0, 12068, 1420, 1, 0, 0, 0, 12069, 12070, + 7, 12, 0, 0, 12070, 12071, 7, 7, 0, 0, 12071, 12072, 7, 4, 0, 0, 12072, + 12073, 7, 6, 0, 0, 12073, 12074, 7, 3, 0, 0, 12074, 12075, 7, 11, 0, 0, + 12075, 12076, 7, 6, 0, 0, 12076, 12077, 7, 0, 0, 0, 12077, 12078, 7, 13, + 0, 0, 12078, 12079, 7, 6, 0, 0, 12079, 12080, 7, 9, 0, 0, 12080, 1422, + 1, 0, 0, 0, 12081, 12082, 7, 12, 0, 0, 12082, 12083, 7, 7, 0, 0, 12083, + 12084, 7, 4, 0, 0, 12084, 12085, 7, 6, 0, 0, 12085, 12086, 7, 3, 0, 0, + 12086, 12087, 7, 14, 0, 0, 12087, 12088, 7, 6, 0, 0, 12088, 12089, 7, 9, + 0, 0, 12089, 12090, 7, 12, 0, 0, 12090, 12091, 7, 0, 0, 0, 12091, 12092, + 7, 4, 0, 0, 12092, 12093, 7, 6, 0, 0, 12093, 1424, 1, 0, 0, 0, 12094, 12095, + 7, 12, 0, 0, 12095, 12096, 7, 7, 0, 0, 12096, 12097, 7, 4, 0, 0, 12097, + 12098, 7, 6, 0, 0, 12098, 12099, 7, 3, 0, 0, 12099, 12100, 7, 7, 0, 0, + 12100, 12101, 7, 0, 0, 0, 12101, 12102, 7, 11, 0, 0, 12102, 12103, 5, 95, + 0, 0, 12103, 12104, 7, 8, 0, 0, 12104, 12105, 7, 2, 0, 0, 12105, 12106, + 7, 7, 0, 0, 12106, 12107, 7, 13, 0, 0, 12107, 12108, 7, 6, 0, 0, 12108, + 12109, 7, 3, 0, 0, 12109, 12110, 7, 4, 0, 0, 12110, 1426, 1, 0, 0, 0, 12111, + 12112, 7, 12, 0, 0, 12112, 12113, 7, 7, 0, 0, 12113, 12114, 7, 4, 0, 0, + 12114, 12115, 7, 6, 0, 0, 12115, 12116, 7, 3, 0, 0, 12116, 12117, 7, 7, + 0, 0, 12117, 12118, 7, 0, 0, 0, 12118, 12119, 7, 11, 0, 0, 12119, 12120, + 5, 95, 0, 0, 12120, 12121, 7, 10, 0, 0, 12121, 12122, 7, 5, 0, 0, 12122, + 12123, 7, 6, 0, 0, 12123, 1428, 1, 0, 0, 0, 12124, 12125, 7, 12, 0, 0, + 12125, 12126, 7, 7, 0, 0, 12126, 12127, 7, 4, 0, 0, 12127, 12128, 7, 6, + 0, 0, 12128, 12129, 7, 3, 0, 0, 12129, 12130, 7, 15, 0, 0, 12130, 12131, + 7, 3, 0, 0, 12131, 12132, 7, 6, 0, 0, 12132, 12133, 7, 4, 0, 0, 12133, + 12134, 7, 6, 0, 0, 12134, 12135, 7, 9, 0, 0, 12135, 1430, 1, 0, 0, 0, 12136, + 12137, 7, 12, 0, 0, 12137, 12138, 7, 7, 0, 0, 12138, 12139, 7, 4, 0, 0, + 12139, 12140, 7, 6, 0, 0, 12140, 12141, 7, 3, 0, 0, 12141, 12142, 7, 5, + 0, 0, 12142, 12143, 7, 6, 0, 0, 12143, 12144, 7, 8, 0, 0, 12144, 12145, + 7, 4, 0, 0, 12145, 1432, 1, 0, 0, 0, 12146, 12147, 7, 12, 0, 0, 12147, + 12148, 7, 7, 0, 0, 12148, 12149, 7, 4, 0, 0, 12149, 12150, 7, 6, 0, 0, + 12150, 12151, 7, 3, 0, 0, 12151, 12152, 7, 13, 0, 0, 12152, 12153, 7, 0, + 0, 0, 12153, 12154, 7, 11, 0, 0, 12154, 1434, 1, 0, 0, 0, 12155, 12156, + 7, 12, 0, 0, 12156, 12157, 7, 7, 0, 0, 12157, 12158, 7, 4, 0, 0, 12158, + 1436, 1, 0, 0, 0, 12159, 12160, 7, 12, 0, 0, 12160, 12161, 7, 7, 0, 0, + 12161, 12162, 7, 4, 0, 0, 12162, 12163, 7, 2, 0, 0, 12163, 1438, 1, 0, + 0, 0, 12164, 12165, 7, 12, 0, 0, 12165, 12166, 7, 7, 0, 0, 12166, 12167, + 7, 13, 0, 0, 12167, 12168, 7, 0, 0, 0, 12168, 12169, 7, 11, 0, 0, 12169, + 12170, 7, 12, 0, 0, 12170, 12171, 7, 9, 0, 0, 12171, 12172, 7, 0, 0, 0, + 12172, 12173, 7, 4, 0, 0, 12173, 12174, 7, 6, 0, 0, 12174, 1440, 1, 0, + 0, 0, 12175, 12176, 7, 12, 0, 0, 12176, 12177, 7, 7, 0, 0, 12177, 12178, + 7, 13, 0, 0, 12178, 12179, 7, 12, 0, 0, 12179, 12180, 7, 5, 0, 0, 12180, + 12181, 7, 12, 0, 0, 12181, 12182, 7, 1, 0, 0, 12182, 12183, 7, 11, 0, 0, + 12183, 12184, 7, 6, 0, 0, 12184, 1442, 1, 0, 0, 0, 12185, 12186, 7, 12, + 0, 0, 12186, 12187, 7, 7, 0, 0, 12187, 12188, 5, 95, 0, 0, 12188, 12189, + 7, 25, 0, 0, 12189, 12190, 7, 24, 0, 0, 12190, 12191, 7, 10, 0, 0, 12191, + 12192, 7, 6, 0, 0, 12192, 12193, 7, 3, 0, 0, 12193, 12194, 7, 18, 0, 0, + 12194, 1444, 1, 0, 0, 0, 12195, 12196, 7, 12, 0, 0, 12196, 12197, 7, 5, + 0, 0, 12197, 1446, 1, 0, 0, 0, 12198, 12199, 7, 12, 0, 0, 12199, 12200, + 7, 5, 0, 0, 12200, 12201, 5, 95, 0, 0, 12201, 12202, 7, 11, 0, 0, 12202, + 12203, 7, 6, 0, 0, 12203, 12204, 7, 0, 0, 0, 12204, 12205, 7, 16, 0, 0, + 12205, 1448, 1, 0, 0, 0, 12206, 12207, 7, 12, 0, 0, 12207, 12208, 7, 5, + 0, 0, 12208, 12209, 7, 2, 0, 0, 12209, 12210, 7, 11, 0, 0, 12210, 12211, + 7, 0, 0, 0, 12211, 12212, 7, 4, 0, 0, 12212, 12213, 7, 12, 0, 0, 12213, + 12214, 7, 2, 0, 0, 12214, 12215, 7, 7, 0, 0, 12215, 1450, 1, 0, 0, 0, 12216, + 12217, 7, 12, 0, 0, 12217, 12218, 7, 5, 0, 0, 12218, 12219, 7, 2, 0, 0, + 12219, 12220, 7, 11, 0, 0, 12220, 12221, 7, 0, 0, 0, 12221, 12222, 7, 4, + 0, 0, 12222, 12223, 7, 12, 0, 0, 12223, 12224, 7, 2, 0, 0, 12224, 12225, + 7, 7, 0, 0, 12225, 12226, 5, 95, 0, 0, 12226, 12227, 7, 11, 0, 0, 12227, + 12228, 7, 6, 0, 0, 12228, 12229, 7, 13, 0, 0, 12229, 12230, 7, 6, 0, 0, + 12230, 12231, 7, 11, 0, 0, 12231, 1452, 1, 0, 0, 0, 12232, 12233, 7, 12, + 0, 0, 12233, 12234, 7, 4, 0, 0, 12234, 12235, 7, 6, 0, 0, 12235, 12236, + 7, 3, 0, 0, 12236, 12237, 7, 0, 0, 0, 12237, 12238, 7, 4, 0, 0, 12238, + 12239, 7, 6, 0, 0, 12239, 1454, 1, 0, 0, 0, 12240, 12241, 7, 12, 0, 0, + 12241, 12242, 7, 4, 0, 0, 12242, 12243, 7, 6, 0, 0, 12243, 12244, 7, 3, + 0, 0, 12244, 12245, 7, 0, 0, 0, 12245, 12246, 7, 4, 0, 0, 12246, 12247, + 7, 12, 0, 0, 12247, 12248, 7, 2, 0, 0, 12248, 12249, 7, 7, 0, 0, 12249, + 12250, 5, 95, 0, 0, 12250, 12251, 7, 7, 0, 0, 12251, 12252, 7, 10, 0, 0, + 12252, 12253, 7, 14, 0, 0, 12253, 12254, 7, 1, 0, 0, 12254, 12255, 7, 6, + 0, 0, 12255, 12256, 7, 3, 0, 0, 12256, 1456, 1, 0, 0, 0, 12257, 12258, + 7, 20, 0, 0, 12258, 12259, 7, 0, 0, 0, 12259, 12260, 7, 13, 0, 0, 12260, + 12261, 7, 0, 0, 0, 12261, 1458, 1, 0, 0, 0, 12262, 12263, 7, 20, 0, 0, + 12263, 12264, 7, 2, 0, 0, 12264, 12265, 7, 1, 0, 0, 12265, 1460, 1, 0, + 0, 0, 12266, 12267, 7, 20, 0, 0, 12267, 12268, 7, 2, 0, 0, 12268, 12269, + 7, 12, 0, 0, 12269, 12270, 7, 7, 0, 0, 12270, 1462, 1, 0, 0, 0, 12271, + 12272, 7, 20, 0, 0, 12272, 12273, 7, 5, 0, 0, 12273, 12274, 7, 2, 0, 0, + 12274, 12275, 7, 7, 0, 0, 12275, 12276, 5, 95, 0, 0, 12276, 12277, 7, 0, + 0, 0, 12277, 12278, 7, 3, 0, 0, 12278, 12279, 7, 3, 0, 0, 12279, 12280, + 7, 0, 0, 0, 12280, 12281, 7, 18, 0, 0, 12281, 12282, 7, 0, 0, 0, 12282, + 12283, 7, 17, 0, 0, 12283, 12284, 7, 17, 0, 0, 12284, 1464, 1, 0, 0, 0, + 12285, 12286, 7, 20, 0, 0, 12286, 12287, 7, 5, 0, 0, 12287, 12288, 7, 2, + 0, 0, 12288, 12289, 7, 7, 0, 0, 12289, 12290, 5, 95, 0, 0, 12290, 12291, + 7, 0, 0, 0, 12291, 12292, 7, 3, 0, 0, 12292, 12293, 7, 3, 0, 0, 12293, + 12294, 7, 0, 0, 0, 12294, 12295, 7, 18, 0, 0, 12295, 1466, 1, 0, 0, 0, + 12296, 12297, 7, 20, 0, 0, 12297, 12298, 7, 5, 0, 0, 12298, 12299, 7, 2, + 0, 0, 12299, 12300, 7, 7, 0, 0, 12300, 12301, 5, 95, 0, 0, 12301, 12302, + 7, 6, 0, 0, 12302, 12303, 7, 24, 0, 0, 12303, 12304, 7, 10, 0, 0, 12304, + 12305, 7, 0, 0, 0, 12305, 12306, 7, 11, 0, 0, 12306, 1468, 1, 0, 0, 0, + 12307, 12308, 7, 20, 0, 0, 12308, 12309, 7, 5, 0, 0, 12309, 12310, 7, 2, + 0, 0, 12310, 12311, 7, 7, 0, 0, 12311, 12312, 5, 95, 0, 0, 12312, 12313, + 7, 6, 0, 0, 12313, 12314, 7, 25, 0, 0, 12314, 12315, 7, 12, 0, 0, 12315, + 12316, 7, 5, 0, 0, 12316, 12317, 7, 4, 0, 0, 12317, 12318, 7, 5, 0, 0, + 12318, 12319, 5, 50, 0, 0, 12319, 1470, 1, 0, 0, 0, 12320, 12321, 7, 20, + 0, 0, 12321, 12322, 7, 5, 0, 0, 12322, 12323, 7, 2, 0, 0, 12323, 12324, + 7, 7, 0, 0, 12324, 12325, 5, 95, 0, 0, 12325, 12326, 7, 6, 0, 0, 12326, + 12327, 7, 25, 0, 0, 12327, 12328, 7, 12, 0, 0, 12328, 12329, 7, 5, 0, 0, + 12329, 12330, 7, 4, 0, 0, 12330, 12331, 7, 5, 0, 0, 12331, 1472, 1, 0, + 0, 0, 12332, 12333, 7, 20, 0, 0, 12333, 12334, 7, 5, 0, 0, 12334, 12335, + 7, 2, 0, 0, 12335, 12336, 7, 7, 0, 0, 12336, 12337, 7, 17, 0, 0, 12337, + 12338, 7, 6, 0, 0, 12338, 12339, 7, 4, 0, 0, 12339, 1474, 1, 0, 0, 0, 12340, + 12341, 7, 20, 0, 0, 12341, 12342, 7, 5, 0, 0, 12342, 12343, 7, 2, 0, 0, + 12343, 12344, 7, 7, 0, 0, 12344, 1476, 1, 0, 0, 0, 12345, 12346, 7, 20, + 0, 0, 12346, 12347, 7, 5, 0, 0, 12347, 12348, 7, 2, 0, 0, 12348, 12349, + 7, 7, 0, 0, 12349, 12350, 5, 95, 0, 0, 12350, 12351, 7, 2, 0, 0, 12351, + 12352, 7, 1, 0, 0, 12352, 12353, 7, 20, 0, 0, 12353, 12354, 7, 6, 0, 0, + 12354, 12355, 7, 8, 0, 0, 12355, 12356, 7, 4, 0, 0, 12356, 12357, 7, 0, + 0, 0, 12357, 12358, 7, 17, 0, 0, 12358, 12359, 7, 17, 0, 0, 12359, 1478, + 1, 0, 0, 0, 12360, 12361, 7, 20, 0, 0, 12361, 12362, 7, 5, 0, 0, 12362, + 12363, 7, 2, 0, 0, 12363, 12364, 7, 7, 0, 0, 12364, 12365, 5, 95, 0, 0, + 12365, 12366, 7, 2, 0, 0, 12366, 12367, 7, 1, 0, 0, 12367, 12368, 7, 20, + 0, 0, 12368, 12369, 7, 6, 0, 0, 12369, 12370, 7, 8, 0, 0, 12370, 12371, + 7, 4, 0, 0, 12371, 1480, 1, 0, 0, 0, 12372, 12373, 7, 20, 0, 0, 12373, + 12374, 7, 5, 0, 0, 12374, 12375, 7, 2, 0, 0, 12375, 12376, 7, 7, 0, 0, + 12376, 12377, 7, 15, 0, 0, 12377, 12378, 7, 0, 0, 0, 12378, 12379, 7, 3, + 0, 0, 12379, 12380, 7, 5, 0, 0, 12380, 12381, 7, 6, 0, 0, 12381, 1482, + 1, 0, 0, 0, 12382, 12383, 7, 20, 0, 0, 12383, 12384, 7, 5, 0, 0, 12384, + 12385, 7, 2, 0, 0, 12385, 12386, 7, 7, 0, 0, 12386, 12387, 5, 95, 0, 0, + 12387, 12388, 7, 24, 0, 0, 12388, 12389, 7, 10, 0, 0, 12389, 12390, 7, + 6, 0, 0, 12390, 12391, 7, 3, 0, 0, 12391, 12392, 7, 18, 0, 0, 12392, 1484, + 1, 0, 0, 0, 12393, 12394, 7, 20, 0, 0, 12394, 12395, 7, 5, 0, 0, 12395, + 12396, 7, 2, 0, 0, 12396, 12397, 7, 7, 0, 0, 12397, 12398, 5, 95, 0, 0, + 12398, 12399, 7, 5, 0, 0, 12399, 12400, 7, 6, 0, 0, 12400, 12401, 7, 3, + 0, 0, 12401, 12402, 7, 12, 0, 0, 12402, 12403, 7, 0, 0, 0, 12403, 12404, + 7, 11, 0, 0, 12404, 12405, 7, 12, 0, 0, 12405, 12406, 7, 23, 0, 0, 12406, + 12407, 7, 6, 0, 0, 12407, 1486, 1, 0, 0, 0, 12408, 12409, 7, 20, 0, 0, + 12409, 12410, 7, 5, 0, 0, 12410, 12411, 7, 2, 0, 0, 12411, 12412, 7, 7, + 0, 0, 12412, 12413, 5, 95, 0, 0, 12413, 12414, 7, 4, 0, 0, 12414, 12415, + 7, 0, 0, 0, 12415, 12416, 7, 1, 0, 0, 12416, 12417, 7, 11, 0, 0, 12417, + 12418, 7, 6, 0, 0, 12418, 1488, 1, 0, 0, 0, 12419, 12420, 7, 20, 0, 0, + 12420, 12421, 7, 5, 0, 0, 12421, 12422, 7, 2, 0, 0, 12422, 12423, 7, 7, + 0, 0, 12423, 12424, 5, 95, 0, 0, 12424, 12425, 7, 4, 0, 0, 12425, 12426, + 7, 6, 0, 0, 12426, 12427, 7, 25, 0, 0, 12427, 12428, 7, 4, 0, 0, 12428, + 12429, 7, 8, 0, 0, 12429, 12430, 7, 2, 0, 0, 12430, 12431, 7, 7, 0, 0, + 12431, 12432, 7, 4, 0, 0, 12432, 12433, 7, 0, 0, 0, 12433, 12434, 7, 12, + 0, 0, 12434, 12435, 7, 7, 0, 0, 12435, 12436, 7, 5, 0, 0, 12436, 12437, + 5, 50, 0, 0, 12437, 1490, 1, 0, 0, 0, 12438, 12439, 7, 20, 0, 0, 12439, + 12440, 7, 5, 0, 0, 12440, 12441, 7, 2, 0, 0, 12441, 12442, 7, 7, 0, 0, + 12442, 12443, 5, 95, 0, 0, 12443, 12444, 7, 4, 0, 0, 12444, 12445, 7, 6, + 0, 0, 12445, 12446, 7, 25, 0, 0, 12446, 12447, 7, 4, 0, 0, 12447, 12448, + 7, 8, 0, 0, 12448, 12449, 7, 2, 0, 0, 12449, 12450, 7, 7, 0, 0, 12450, + 12451, 7, 4, 0, 0, 12451, 12452, 7, 0, 0, 0, 12452, 12453, 7, 12, 0, 0, + 12453, 12454, 7, 7, 0, 0, 12454, 12455, 7, 5, 0, 0, 12455, 1492, 1, 0, + 0, 0, 12456, 12457, 7, 20, 0, 0, 12457, 12458, 7, 5, 0, 0, 12458, 12459, + 7, 2, 0, 0, 12459, 12460, 7, 7, 0, 0, 12460, 12461, 5, 95, 0, 0, 12461, + 12462, 7, 4, 0, 0, 12462, 12463, 7, 3, 0, 0, 12463, 12464, 7, 0, 0, 0, + 12464, 12465, 7, 7, 0, 0, 12465, 12466, 7, 5, 0, 0, 12466, 12467, 7, 16, + 0, 0, 12467, 12468, 7, 2, 0, 0, 12468, 12469, 7, 3, 0, 0, 12469, 12470, + 7, 14, 0, 0, 12470, 1494, 1, 0, 0, 0, 12471, 12472, 7, 20, 0, 0, 12472, + 12473, 7, 5, 0, 0, 12473, 12474, 7, 2, 0, 0, 12474, 12475, 7, 7, 0, 0, + 12475, 12476, 5, 95, 0, 0, 12476, 12477, 7, 13, 0, 0, 12477, 12478, 7, + 0, 0, 0, 12478, 12479, 7, 11, 0, 0, 12479, 12480, 7, 10, 0, 0, 12480, 12481, + 7, 6, 0, 0, 12481, 1496, 1, 0, 0, 0, 12482, 12483, 7, 21, 0, 0, 12483, + 1498, 1, 0, 0, 0, 12484, 12485, 7, 21, 0, 0, 12485, 12486, 7, 6, 0, 0, + 12486, 12487, 7, 6, 0, 0, 12487, 12488, 7, 15, 0, 0, 12488, 12489, 5, 95, + 0, 0, 12489, 12490, 7, 9, 0, 0, 12490, 12491, 7, 10, 0, 0, 12491, 12492, + 7, 15, 0, 0, 12492, 12493, 7, 11, 0, 0, 12493, 12494, 7, 12, 0, 0, 12494, + 12495, 7, 8, 0, 0, 12495, 12496, 7, 0, 0, 0, 12496, 12497, 7, 4, 0, 0, + 12497, 12498, 7, 6, 0, 0, 12498, 12499, 7, 5, 0, 0, 12499, 1500, 1, 0, + 0, 0, 12500, 12501, 7, 21, 0, 0, 12501, 12502, 7, 6, 0, 0, 12502, 12503, + 7, 6, 0, 0, 12503, 12504, 7, 15, 0, 0, 12504, 1502, 1, 0, 0, 0, 12505, + 12506, 7, 21, 0, 0, 12506, 12507, 7, 6, 0, 0, 12507, 12508, 7, 3, 0, 0, + 12508, 12509, 7, 1, 0, 0, 12509, 12510, 7, 6, 0, 0, 12510, 12511, 7, 3, + 0, 0, 12511, 12512, 7, 2, 0, 0, 12512, 12513, 7, 5, 0, 0, 12513, 1504, + 1, 0, 0, 0, 12514, 12515, 7, 21, 0, 0, 12515, 12516, 7, 6, 0, 0, 12516, + 12517, 7, 18, 0, 0, 12517, 1506, 1, 0, 0, 0, 12518, 12519, 7, 21, 0, 0, + 12519, 12520, 7, 6, 0, 0, 12520, 12521, 7, 18, 0, 0, 12521, 12522, 5, 95, + 0, 0, 12522, 12523, 7, 11, 0, 0, 12523, 12524, 7, 6, 0, 0, 12524, 12525, + 7, 7, 0, 0, 12525, 12526, 7, 17, 0, 0, 12526, 12527, 7, 4, 0, 0, 12527, + 12528, 7, 19, 0, 0, 12528, 1508, 1, 0, 0, 0, 12529, 12530, 7, 21, 0, 0, + 12530, 12531, 7, 6, 0, 0, 12531, 12532, 7, 18, 0, 0, 12532, 12533, 7, 5, + 0, 0, 12533, 12534, 7, 12, 0, 0, 12534, 12535, 7, 23, 0, 0, 12535, 12536, + 7, 6, 0, 0, 12536, 1510, 1, 0, 0, 0, 12537, 12538, 7, 21, 0, 0, 12538, + 12539, 7, 6, 0, 0, 12539, 12540, 7, 18, 0, 0, 12540, 12541, 7, 5, 0, 0, + 12541, 1512, 1, 0, 0, 0, 12542, 12543, 7, 21, 0, 0, 12543, 12544, 7, 6, + 0, 0, 12544, 12545, 7, 18, 0, 0, 12545, 12546, 7, 5, 0, 0, 12546, 12547, + 7, 4, 0, 0, 12547, 12548, 7, 2, 0, 0, 12548, 12549, 7, 3, 0, 0, 12549, + 12550, 7, 6, 0, 0, 12550, 1514, 1, 0, 0, 0, 12551, 12552, 7, 21, 0, 0, + 12552, 12553, 7, 12, 0, 0, 12553, 12554, 7, 11, 0, 0, 12554, 12555, 7, + 11, 0, 0, 12555, 1516, 1, 0, 0, 0, 12556, 12557, 7, 11, 0, 0, 12557, 12558, + 7, 0, 0, 0, 12558, 12559, 7, 1, 0, 0, 12559, 12560, 7, 6, 0, 0, 12560, + 12561, 7, 11, 0, 0, 12561, 1518, 1, 0, 0, 0, 12562, 12563, 7, 11, 0, 0, + 12563, 12564, 7, 0, 0, 0, 12564, 12565, 7, 7, 0, 0, 12565, 12566, 7, 17, + 0, 0, 12566, 12567, 7, 10, 0, 0, 12567, 12568, 7, 0, 0, 0, 12568, 12569, + 7, 17, 0, 0, 12569, 12570, 7, 6, 0, 0, 12570, 1520, 1, 0, 0, 0, 12571, + 12572, 7, 11, 0, 0, 12572, 12573, 7, 0, 0, 0, 12573, 12574, 7, 5, 0, 0, + 12574, 12575, 7, 4, 0, 0, 12575, 12576, 5, 95, 0, 0, 12576, 12577, 7, 9, + 0, 0, 12577, 12578, 7, 0, 0, 0, 12578, 12579, 7, 18, 0, 0, 12579, 1522, + 1, 0, 0, 0, 12580, 12581, 7, 11, 0, 0, 12581, 12582, 7, 0, 0, 0, 12582, + 12583, 7, 5, 0, 0, 12583, 12584, 7, 4, 0, 0, 12584, 1524, 1, 0, 0, 0, 12585, + 12586, 7, 11, 0, 0, 12586, 12587, 7, 0, 0, 0, 12587, 12588, 7, 5, 0, 0, + 12588, 12589, 7, 4, 0, 0, 12589, 12590, 5, 95, 0, 0, 12590, 12591, 7, 13, + 0, 0, 12591, 12592, 7, 0, 0, 0, 12592, 12593, 7, 11, 0, 0, 12593, 12594, + 7, 10, 0, 0, 12594, 12595, 7, 6, 0, 0, 12595, 1526, 1, 0, 0, 0, 12596, + 12597, 7, 11, 0, 0, 12597, 12598, 7, 0, 0, 0, 12598, 12599, 7, 4, 0, 0, + 12599, 12600, 7, 6, 0, 0, 12600, 12601, 7, 3, 0, 0, 12601, 12602, 7, 0, + 0, 0, 12602, 12603, 7, 11, 0, 0, 12603, 1528, 1, 0, 0, 0, 12604, 12605, + 7, 11, 0, 0, 12605, 12606, 7, 0, 0, 0, 12606, 12607, 7, 25, 0, 0, 12607, + 1530, 1, 0, 0, 0, 12608, 12609, 7, 11, 0, 0, 12609, 12610, 7, 0, 0, 0, + 12610, 12611, 7, 18, 0, 0, 12611, 12612, 7, 6, 0, 0, 12612, 12613, 7, 3, + 0, 0, 12613, 1532, 1, 0, 0, 0, 12614, 12615, 7, 11, 0, 0, 12615, 12616, + 7, 9, 0, 0, 12616, 12617, 7, 0, 0, 0, 12617, 12618, 7, 15, 0, 0, 12618, + 12619, 5, 95, 0, 0, 12619, 12620, 7, 3, 0, 0, 12620, 12621, 7, 6, 0, 0, + 12621, 12622, 7, 17, 0, 0, 12622, 12623, 7, 12, 0, 0, 12623, 12624, 7, + 5, 0, 0, 12624, 12625, 7, 4, 0, 0, 12625, 12626, 7, 3, 0, 0, 12626, 12627, + 7, 0, 0, 0, 12627, 12628, 7, 4, 0, 0, 12628, 12629, 7, 12, 0, 0, 12629, + 12630, 7, 2, 0, 0, 12630, 12631, 7, 7, 0, 0, 12631, 12632, 5, 95, 0, 0, + 12632, 12633, 7, 6, 0, 0, 12633, 12634, 7, 7, 0, 0, 12634, 12635, 7, 0, + 0, 0, 12635, 12636, 7, 1, 0, 0, 12636, 12637, 7, 11, 0, 0, 12637, 12638, + 7, 6, 0, 0, 12638, 12639, 7, 9, 0, 0, 12639, 1534, 1, 0, 0, 0, 12640, 12641, + 7, 11, 0, 0, 12641, 12642, 7, 9, 0, 0, 12642, 12643, 7, 0, 0, 0, 12643, + 12644, 7, 15, 0, 0, 12644, 12645, 5, 95, 0, 0, 12645, 12646, 7, 3, 0, 0, + 12646, 12647, 7, 6, 0, 0, 12647, 12648, 7, 17, 0, 0, 12648, 12649, 7, 12, + 0, 0, 12649, 12650, 7, 5, 0, 0, 12650, 12651, 7, 4, 0, 0, 12651, 12652, + 7, 3, 0, 0, 12652, 12653, 7, 0, 0, 0, 12653, 12654, 7, 4, 0, 0, 12654, + 12655, 7, 12, 0, 0, 12655, 12656, 7, 2, 0, 0, 12656, 12657, 7, 7, 0, 0, + 12657, 1536, 1, 0, 0, 0, 12658, 12659, 7, 11, 0, 0, 12659, 12660, 7, 9, + 0, 0, 12660, 12661, 7, 0, 0, 0, 12661, 12662, 7, 15, 0, 0, 12662, 12663, + 5, 95, 0, 0, 12663, 12664, 7, 3, 0, 0, 12664, 12665, 7, 6, 0, 0, 12665, + 12666, 7, 17, 0, 0, 12666, 12667, 5, 95, 0, 0, 12667, 12668, 7, 5, 0, 0, + 12668, 12669, 7, 18, 0, 0, 12669, 12670, 7, 7, 0, 0, 12670, 12671, 7, 8, + 0, 0, 12671, 12672, 5, 95, 0, 0, 12672, 12673, 7, 12, 0, 0, 12673, 12674, + 7, 7, 0, 0, 12674, 12675, 7, 4, 0, 0, 12675, 12676, 7, 6, 0, 0, 12676, + 12677, 7, 3, 0, 0, 12677, 12678, 7, 13, 0, 0, 12678, 12679, 7, 0, 0, 0, + 12679, 12680, 7, 11, 0, 0, 12680, 1538, 1, 0, 0, 0, 12681, 12682, 7, 11, + 0, 0, 12682, 12683, 7, 6, 0, 0, 12683, 12684, 7, 0, 0, 0, 12684, 12685, + 7, 16, 0, 0, 12685, 1540, 1, 0, 0, 0, 12686, 12687, 7, 11, 0, 0, 12687, + 12688, 7, 6, 0, 0, 12688, 12689, 7, 0, 0, 0, 12689, 12690, 7, 9, 0, 0, + 12690, 12691, 5, 95, 0, 0, 12691, 12692, 7, 8, 0, 0, 12692, 12693, 7, 9, + 0, 0, 12693, 12694, 7, 1, 0, 0, 12694, 1542, 1, 0, 0, 0, 12695, 12696, + 7, 11, 0, 0, 12696, 12697, 7, 6, 0, 0, 12697, 12698, 7, 0, 0, 0, 12698, + 12699, 7, 9, 0, 0, 12699, 12700, 5, 95, 0, 0, 12700, 12701, 7, 8, 0, 0, + 12701, 12702, 7, 9, 0, 0, 12702, 12703, 7, 1, 0, 0, 12703, 12704, 5, 95, + 0, 0, 12704, 12705, 7, 10, 0, 0, 12705, 12706, 7, 3, 0, 0, 12706, 12707, + 7, 12, 0, 0, 12707, 1544, 1, 0, 0, 0, 12708, 12709, 7, 11, 0, 0, 12709, + 12710, 7, 6, 0, 0, 12710, 12711, 7, 0, 0, 0, 12711, 12712, 7, 9, 0, 0, + 12712, 12713, 7, 12, 0, 0, 12713, 12714, 7, 7, 0, 0, 12714, 12715, 7, 17, + 0, 0, 12715, 1546, 1, 0, 0, 0, 12716, 12717, 7, 11, 0, 0, 12717, 12718, + 7, 6, 0, 0, 12718, 12719, 7, 16, 0, 0, 12719, 12720, 7, 4, 0, 0, 12720, + 1548, 1, 0, 0, 0, 12721, 12722, 7, 11, 0, 0, 12722, 12723, 7, 6, 0, 0, + 12723, 12724, 7, 7, 0, 0, 12724, 12725, 7, 17, 0, 0, 12725, 12726, 7, 4, + 0, 0, 12726, 12727, 7, 19, 0, 0, 12727, 12728, 5, 50, 0, 0, 12728, 1550, + 1, 0, 0, 0, 12729, 12730, 7, 11, 0, 0, 12730, 12731, 7, 6, 0, 0, 12731, + 12732, 7, 7, 0, 0, 12732, 12733, 7, 17, 0, 0, 12733, 12734, 7, 4, 0, 0, + 12734, 12735, 7, 19, 0, 0, 12735, 12736, 5, 52, 0, 0, 12736, 1552, 1, 0, + 0, 0, 12737, 12738, 7, 11, 0, 0, 12738, 12739, 7, 6, 0, 0, 12739, 12740, + 7, 7, 0, 0, 12740, 12741, 7, 17, 0, 0, 12741, 12742, 7, 4, 0, 0, 12742, + 12743, 7, 19, 0, 0, 12743, 12744, 7, 1, 0, 0, 12744, 1554, 1, 0, 0, 0, + 12745, 12746, 7, 11, 0, 0, 12746, 12747, 7, 6, 0, 0, 12747, 12748, 7, 7, + 0, 0, 12748, 12749, 7, 17, 0, 0, 12749, 12750, 7, 4, 0, 0, 12750, 12751, + 7, 19, 0, 0, 12751, 12752, 7, 8, 0, 0, 12752, 1556, 1, 0, 0, 0, 12753, + 12754, 7, 11, 0, 0, 12754, 12755, 7, 6, 0, 0, 12755, 12756, 7, 7, 0, 0, + 12756, 12757, 7, 17, 0, 0, 12757, 12758, 7, 4, 0, 0, 12758, 12759, 7, 19, + 0, 0, 12759, 1558, 1, 0, 0, 0, 12760, 12761, 7, 11, 0, 0, 12761, 12762, + 7, 6, 0, 0, 12762, 12763, 7, 5, 0, 0, 12763, 12764, 7, 5, 0, 0, 12764, + 1560, 1, 0, 0, 0, 12765, 12766, 7, 11, 0, 0, 12766, 12767, 7, 6, 0, 0, + 12767, 12768, 7, 13, 0, 0, 12768, 12769, 7, 6, 0, 0, 12769, 12770, 7, 11, + 0, 0, 12770, 1562, 1, 0, 0, 0, 12771, 12772, 7, 11, 0, 0, 12772, 12773, + 7, 6, 0, 0, 12773, 12774, 7, 13, 0, 0, 12774, 12775, 7, 6, 0, 0, 12775, + 12776, 7, 11, 0, 0, 12776, 12777, 5, 95, 0, 0, 12777, 12778, 7, 7, 0, 0, + 12778, 12779, 7, 0, 0, 0, 12779, 12780, 7, 14, 0, 0, 12780, 12781, 7, 6, + 0, 0, 12781, 1564, 1, 0, 0, 0, 12782, 12783, 7, 11, 0, 0, 12783, 12784, + 7, 6, 0, 0, 12784, 12785, 7, 13, 0, 0, 12785, 12786, 7, 6, 0, 0, 12786, + 12787, 7, 11, 0, 0, 12787, 12788, 7, 5, 0, 0, 12788, 1566, 1, 0, 0, 0, + 12789, 12790, 7, 11, 0, 0, 12790, 12791, 7, 12, 0, 0, 12791, 12792, 7, + 1, 0, 0, 12792, 12793, 7, 3, 0, 0, 12793, 12794, 7, 0, 0, 0, 12794, 12795, + 7, 3, 0, 0, 12795, 12796, 7, 18, 0, 0, 12796, 1568, 1, 0, 0, 0, 12797, + 12798, 7, 11, 0, 0, 12798, 12799, 7, 12, 0, 0, 12799, 12800, 7, 16, 0, + 0, 12800, 12801, 7, 6, 0, 0, 12801, 12802, 7, 8, 0, 0, 12802, 12803, 7, + 18, 0, 0, 12803, 12804, 7, 8, 0, 0, 12804, 12805, 7, 11, 0, 0, 12805, 12806, + 7, 6, 0, 0, 12806, 1570, 1, 0, 0, 0, 12807, 12808, 7, 11, 0, 0, 12808, + 12809, 7, 12, 0, 0, 12809, 12810, 7, 16, 0, 0, 12810, 12811, 7, 6, 0, 0, + 12811, 1572, 1, 0, 0, 0, 12812, 12813, 7, 11, 0, 0, 12813, 12814, 7, 12, + 0, 0, 12814, 12815, 7, 16, 0, 0, 12815, 12816, 7, 6, 0, 0, 12816, 12817, + 7, 4, 0, 0, 12817, 12818, 7, 12, 0, 0, 12818, 12819, 7, 14, 0, 0, 12819, + 12820, 7, 6, 0, 0, 12820, 1574, 1, 0, 0, 0, 12821, 12822, 7, 11, 0, 0, + 12822, 12823, 7, 12, 0, 0, 12823, 12824, 7, 21, 0, 0, 12824, 12825, 7, + 6, 0, 0, 12825, 12826, 5, 50, 0, 0, 12826, 1576, 1, 0, 0, 0, 12827, 12828, + 7, 11, 0, 0, 12828, 12829, 7, 12, 0, 0, 12829, 12830, 7, 21, 0, 0, 12830, + 12831, 7, 6, 0, 0, 12831, 12832, 5, 52, 0, 0, 12832, 1578, 1, 0, 0, 0, + 12833, 12834, 7, 11, 0, 0, 12834, 12835, 7, 12, 0, 0, 12835, 12836, 7, + 21, 0, 0, 12836, 12837, 7, 6, 0, 0, 12837, 12838, 7, 8, 0, 0, 12838, 1580, + 1, 0, 0, 0, 12839, 12840, 7, 11, 0, 0, 12840, 12841, 7, 12, 0, 0, 12841, + 12842, 7, 21, 0, 0, 12842, 12843, 7, 6, 0, 0, 12843, 12844, 5, 95, 0, 0, + 12844, 12845, 7, 6, 0, 0, 12845, 12846, 7, 25, 0, 0, 12846, 12847, 7, 15, + 0, 0, 12847, 12848, 7, 0, 0, 0, 12848, 12849, 7, 7, 0, 0, 12849, 12850, + 7, 9, 0, 0, 12850, 1582, 1, 0, 0, 0, 12851, 12852, 7, 11, 0, 0, 12852, + 12853, 7, 12, 0, 0, 12853, 12854, 7, 21, 0, 0, 12854, 12855, 7, 6, 0, 0, + 12855, 1584, 1, 0, 0, 0, 12856, 12857, 7, 11, 0, 0, 12857, 12858, 7, 12, + 0, 0, 12858, 12859, 7, 14, 0, 0, 12859, 12860, 7, 12, 0, 0, 12860, 12861, + 7, 4, 0, 0, 12861, 1586, 1, 0, 0, 0, 12862, 12863, 7, 11, 0, 0, 12863, + 12864, 7, 12, 0, 0, 12864, 12865, 7, 7, 0, 0, 12865, 12866, 7, 6, 0, 0, + 12866, 12867, 7, 0, 0, 0, 12867, 12868, 7, 3, 0, 0, 12868, 1588, 1, 0, + 0, 0, 12869, 12870, 7, 11, 0, 0, 12870, 12871, 7, 12, 0, 0, 12871, 12872, + 7, 7, 0, 0, 12872, 12873, 7, 21, 0, 0, 12873, 1590, 1, 0, 0, 0, 12874, + 12875, 7, 11, 0, 0, 12875, 12876, 7, 12, 0, 0, 12876, 12877, 7, 5, 0, 0, + 12877, 12878, 7, 4, 0, 0, 12878, 1592, 1, 0, 0, 0, 12879, 12880, 7, 11, + 0, 0, 12880, 12881, 7, 7, 0, 0, 12881, 1594, 1, 0, 0, 0, 12882, 12883, + 7, 11, 0, 0, 12883, 12884, 7, 7, 0, 0, 12884, 12885, 7, 7, 0, 0, 12885, + 12886, 7, 13, 0, 0, 12886, 12887, 7, 11, 0, 0, 12887, 1596, 1, 0, 0, 0, + 12888, 12889, 7, 11, 0, 0, 12889, 12890, 7, 2, 0, 0, 12890, 12891, 7, 0, + 0, 0, 12891, 12892, 7, 9, 0, 0, 12892, 1598, 1, 0, 0, 0, 12893, 12894, + 7, 11, 0, 0, 12894, 12895, 7, 2, 0, 0, 12895, 12896, 7, 1, 0, 0, 12896, + 1600, 1, 0, 0, 0, 12897, 12898, 7, 11, 0, 0, 12898, 12899, 7, 2, 0, 0, + 12899, 12900, 7, 1, 0, 0, 12900, 12901, 7, 7, 0, 0, 12901, 12902, 7, 13, + 0, 0, 12902, 12903, 7, 11, 0, 0, 12903, 1602, 1, 0, 0, 0, 12904, 12905, + 7, 11, 0, 0, 12905, 12906, 7, 2, 0, 0, 12906, 12907, 7, 1, 0, 0, 12907, + 12908, 7, 5, 0, 0, 12908, 1604, 1, 0, 0, 0, 12909, 12910, 7, 11, 0, 0, + 12910, 12911, 7, 2, 0, 0, 12911, 12912, 7, 8, 0, 0, 12912, 12913, 7, 0, + 0, 0, 12913, 12914, 7, 11, 0, 0, 12914, 12915, 5, 95, 0, 0, 12915, 12916, + 7, 12, 0, 0, 12916, 12917, 7, 7, 0, 0, 12917, 12918, 7, 9, 0, 0, 12918, + 12919, 7, 6, 0, 0, 12919, 12920, 7, 25, 0, 0, 12920, 12921, 7, 6, 0, 0, + 12921, 12922, 7, 5, 0, 0, 12922, 1606, 1, 0, 0, 0, 12923, 12924, 7, 11, + 0, 0, 12924, 12925, 7, 2, 0, 0, 12925, 12926, 7, 8, 0, 0, 12926, 12927, + 7, 0, 0, 0, 12927, 12928, 7, 11, 0, 0, 12928, 1608, 1, 0, 0, 0, 12929, + 12930, 7, 11, 0, 0, 12930, 12931, 7, 2, 0, 0, 12931, 12932, 7, 8, 0, 0, + 12932, 12933, 7, 0, 0, 0, 12933, 12934, 7, 11, 0, 0, 12934, 12935, 7, 4, + 0, 0, 12935, 12936, 7, 12, 0, 0, 12936, 12937, 7, 14, 0, 0, 12937, 12938, + 7, 6, 0, 0, 12938, 1610, 1, 0, 0, 0, 12939, 12940, 7, 11, 0, 0, 12940, + 12941, 7, 2, 0, 0, 12941, 12942, 7, 8, 0, 0, 12942, 12943, 7, 0, 0, 0, + 12943, 12944, 7, 11, 0, 0, 12944, 12945, 7, 4, 0, 0, 12945, 12946, 7, 12, + 0, 0, 12946, 12947, 7, 14, 0, 0, 12947, 12948, 7, 6, 0, 0, 12948, 12949, + 7, 5, 0, 0, 12949, 12950, 7, 4, 0, 0, 12950, 12951, 7, 0, 0, 0, 12951, + 12952, 7, 14, 0, 0, 12952, 12953, 7, 15, 0, 0, 12953, 1612, 1, 0, 0, 0, + 12954, 12955, 7, 11, 0, 0, 12955, 12956, 7, 2, 0, 0, 12956, 12957, 7, 8, + 0, 0, 12957, 12958, 7, 0, 0, 0, 12958, 12959, 7, 4, 0, 0, 12959, 12960, + 7, 12, 0, 0, 12960, 12961, 7, 2, 0, 0, 12961, 12962, 7, 7, 0, 0, 12962, + 1614, 1, 0, 0, 0, 12963, 12964, 7, 11, 0, 0, 12964, 12965, 7, 2, 0, 0, + 12965, 12966, 7, 8, 0, 0, 12966, 12967, 7, 0, 0, 0, 12967, 12968, 7, 4, + 0, 0, 12968, 12969, 7, 2, 0, 0, 12969, 12970, 7, 3, 0, 0, 12970, 1616, + 1, 0, 0, 0, 12971, 12972, 7, 11, 0, 0, 12972, 12973, 7, 2, 0, 0, 12973, + 12974, 7, 8, 0, 0, 12974, 12975, 7, 21, 0, 0, 12975, 12976, 7, 9, 0, 0, + 12976, 12977, 7, 2, 0, 0, 12977, 12978, 7, 22, 0, 0, 12978, 12979, 7, 7, + 0, 0, 12979, 1618, 1, 0, 0, 0, 12980, 12981, 7, 11, 0, 0, 12981, 12982, + 7, 2, 0, 0, 12982, 12983, 7, 8, 0, 0, 12983, 12984, 7, 21, 0, 0, 12984, + 12985, 7, 6, 0, 0, 12985, 12986, 7, 9, 0, 0, 12986, 1620, 1, 0, 0, 0, 12987, + 12988, 7, 11, 0, 0, 12988, 12989, 7, 2, 0, 0, 12989, 12990, 7, 8, 0, 0, + 12990, 12991, 7, 21, 0, 0, 12991, 12992, 7, 12, 0, 0, 12992, 12993, 7, + 7, 0, 0, 12993, 12994, 7, 17, 0, 0, 12994, 1622, 1, 0, 0, 0, 12995, 12996, + 7, 11, 0, 0, 12996, 12997, 7, 2, 0, 0, 12997, 12998, 7, 8, 0, 0, 12998, + 12999, 7, 21, 0, 0, 12999, 1624, 1, 0, 0, 0, 13000, 13001, 7, 11, 0, 0, + 13001, 13002, 7, 2, 0, 0, 13002, 13003, 7, 17, 0, 0, 13003, 13004, 7, 16, + 0, 0, 13004, 13005, 7, 12, 0, 0, 13005, 13006, 7, 11, 0, 0, 13006, 13007, + 7, 6, 0, 0, 13007, 1626, 1, 0, 0, 0, 13008, 13009, 7, 11, 0, 0, 13009, + 13010, 7, 2, 0, 0, 13010, 13011, 7, 17, 0, 0, 13011, 13012, 7, 16, 0, 0, + 13012, 13013, 7, 12, 0, 0, 13013, 13014, 7, 11, 0, 0, 13014, 13015, 7, + 6, 0, 0, 13015, 13016, 7, 5, 0, 0, 13016, 1628, 1, 0, 0, 0, 13017, 13018, + 7, 11, 0, 0, 13018, 13019, 7, 2, 0, 0, 13019, 13020, 7, 17, 0, 0, 13020, + 13021, 7, 17, 0, 0, 13021, 13022, 7, 12, 0, 0, 13022, 13023, 7, 7, 0, 0, + 13023, 13024, 7, 17, 0, 0, 13024, 1630, 1, 0, 0, 0, 13025, 13026, 7, 11, + 0, 0, 13026, 13027, 7, 2, 0, 0, 13027, 13028, 7, 17, 0, 0, 13028, 13029, + 7, 12, 0, 0, 13029, 13030, 7, 8, 0, 0, 13030, 13031, 7, 0, 0, 0, 13031, + 13032, 7, 11, 0, 0, 13032, 1632, 1, 0, 0, 0, 13033, 13034, 7, 11, 0, 0, + 13034, 13035, 7, 2, 0, 0, 13035, 13036, 7, 17, 0, 0, 13036, 13037, 7, 12, + 0, 0, 13037, 13038, 7, 8, 0, 0, 13038, 13039, 7, 0, 0, 0, 13039, 13040, + 7, 11, 0, 0, 13040, 13041, 5, 95, 0, 0, 13041, 13042, 7, 3, 0, 0, 13042, + 13043, 7, 6, 0, 0, 13043, 13044, 7, 0, 0, 0, 13044, 13045, 7, 9, 0, 0, + 13045, 13046, 7, 5, 0, 0, 13046, 13047, 5, 95, 0, 0, 13047, 13048, 7, 15, + 0, 0, 13048, 13049, 7, 6, 0, 0, 13049, 13050, 7, 3, 0, 0, 13050, 13051, + 5, 95, 0, 0, 13051, 13052, 7, 8, 0, 0, 13052, 13053, 7, 0, 0, 0, 13053, + 13054, 7, 11, 0, 0, 13054, 13055, 7, 11, 0, 0, 13055, 1634, 1, 0, 0, 0, + 13056, 13057, 7, 11, 0, 0, 13057, 13058, 7, 2, 0, 0, 13058, 13059, 7, 17, + 0, 0, 13059, 13060, 7, 12, 0, 0, 13060, 13061, 7, 8, 0, 0, 13061, 13062, + 7, 0, 0, 0, 13062, 13063, 7, 11, 0, 0, 13063, 13064, 5, 95, 0, 0, 13064, + 13065, 7, 3, 0, 0, 13065, 13066, 7, 6, 0, 0, 13066, 13067, 7, 0, 0, 0, + 13067, 13068, 7, 9, 0, 0, 13068, 13069, 7, 5, 0, 0, 13069, 13070, 5, 95, + 0, 0, 13070, 13071, 7, 15, 0, 0, 13071, 13072, 7, 6, 0, 0, 13072, 13073, + 7, 3, 0, 0, 13073, 13074, 5, 95, 0, 0, 13074, 13075, 7, 5, 0, 0, 13075, + 13076, 7, 6, 0, 0, 13076, 13077, 7, 5, 0, 0, 13077, 13078, 7, 5, 0, 0, + 13078, 13079, 7, 12, 0, 0, 13079, 13080, 7, 2, 0, 0, 13080, 13081, 7, 7, + 0, 0, 13081, 1636, 1, 0, 0, 0, 13082, 13083, 7, 11, 0, 0, 13083, 13084, + 7, 2, 0, 0, 13084, 13085, 7, 17, 0, 0, 13085, 1638, 1, 0, 0, 0, 13086, + 13087, 7, 11, 0, 0, 13087, 13088, 7, 2, 0, 0, 13088, 13089, 7, 17, 0, 0, + 13089, 13090, 7, 14, 0, 0, 13090, 13091, 7, 12, 0, 0, 13091, 13092, 7, + 7, 0, 0, 13092, 13093, 7, 12, 0, 0, 13093, 13094, 7, 7, 0, 0, 13094, 13095, + 7, 17, 0, 0, 13095, 1640, 1, 0, 0, 0, 13096, 13097, 7, 11, 0, 0, 13097, + 13098, 7, 2, 0, 0, 13098, 13099, 7, 17, 0, 0, 13099, 13100, 7, 2, 0, 0, + 13100, 13101, 7, 16, 0, 0, 13101, 13102, 7, 16, 0, 0, 13102, 1642, 1, 0, + 0, 0, 13103, 13104, 7, 11, 0, 0, 13104, 13105, 7, 2, 0, 0, 13105, 13106, + 7, 17, 0, 0, 13106, 13107, 7, 2, 0, 0, 13107, 13108, 7, 7, 0, 0, 13108, + 1644, 1, 0, 0, 0, 13109, 13110, 7, 11, 0, 0, 13110, 13111, 7, 2, 0, 0, + 13111, 13112, 7, 17, 0, 0, 13112, 13113, 5, 95, 0, 0, 13113, 13114, 7, + 3, 0, 0, 13114, 13115, 7, 6, 0, 0, 13115, 13116, 7, 0, 0, 0, 13116, 13117, + 7, 9, 0, 0, 13117, 13118, 5, 95, 0, 0, 13118, 13119, 7, 2, 0, 0, 13119, + 13120, 7, 7, 0, 0, 13120, 13121, 7, 11, 0, 0, 13121, 13122, 7, 18, 0, 0, + 13122, 13123, 5, 95, 0, 0, 13123, 13124, 7, 13, 0, 0, 13124, 13125, 7, + 12, 0, 0, 13125, 13126, 7, 2, 0, 0, 13126, 13127, 7, 11, 0, 0, 13127, 13128, + 7, 0, 0, 0, 13128, 13129, 7, 4, 0, 0, 13129, 13130, 7, 12, 0, 0, 13130, + 13131, 7, 2, 0, 0, 13131, 13132, 7, 7, 0, 0, 13132, 13133, 7, 5, 0, 0, + 13133, 1646, 1, 0, 0, 0, 13134, 13135, 7, 11, 0, 0, 13135, 13136, 7, 2, + 0, 0, 13136, 13137, 7, 7, 0, 0, 13137, 13138, 7, 17, 0, 0, 13138, 1648, + 1, 0, 0, 0, 13139, 13140, 7, 11, 0, 0, 13140, 13141, 7, 2, 0, 0, 13141, + 13142, 7, 2, 0, 0, 13142, 13143, 7, 15, 0, 0, 13143, 1650, 1, 0, 0, 0, + 13144, 13145, 7, 11, 0, 0, 13145, 13146, 7, 2, 0, 0, 13146, 13147, 7, 5, + 0, 0, 13147, 13148, 7, 4, 0, 0, 13148, 1652, 1, 0, 0, 0, 13149, 13150, + 7, 11, 0, 0, 13150, 13151, 7, 2, 0, 0, 13151, 13152, 7, 22, 0, 0, 13152, + 13153, 7, 6, 0, 0, 13153, 13154, 7, 3, 0, 0, 13154, 1654, 1, 0, 0, 0, 13155, + 13156, 7, 11, 0, 0, 13156, 13157, 7, 2, 0, 0, 13157, 13158, 7, 22, 0, 0, + 13158, 1656, 1, 0, 0, 0, 13159, 13160, 7, 11, 0, 0, 13160, 13161, 7, 15, + 0, 0, 13161, 13162, 7, 0, 0, 0, 13162, 13163, 7, 9, 0, 0, 13163, 1658, + 1, 0, 0, 0, 13164, 13165, 7, 11, 0, 0, 13165, 13166, 7, 4, 0, 0, 13166, + 13167, 7, 3, 0, 0, 13167, 13168, 7, 12, 0, 0, 13168, 13169, 7, 14, 0, 0, + 13169, 1660, 1, 0, 0, 0, 13170, 13171, 7, 14, 0, 0, 13171, 1662, 1, 0, + 0, 0, 13172, 13173, 7, 14, 0, 0, 13173, 13174, 7, 0, 0, 0, 13174, 13175, + 7, 12, 0, 0, 13175, 13176, 7, 7, 0, 0, 13176, 1664, 1, 0, 0, 0, 13177, + 13178, 7, 14, 0, 0, 13178, 13179, 7, 0, 0, 0, 13179, 13180, 7, 21, 0, 0, + 13180, 13181, 7, 6, 0, 0, 13181, 13182, 5, 95, 0, 0, 13182, 13183, 7, 3, + 0, 0, 13183, 13184, 7, 6, 0, 0, 13184, 13185, 7, 16, 0, 0, 13185, 1666, + 1, 0, 0, 0, 13186, 13187, 7, 14, 0, 0, 13187, 13188, 7, 0, 0, 0, 13188, + 13189, 7, 7, 0, 0, 13189, 13190, 7, 0, 0, 0, 13190, 13191, 7, 17, 0, 0, + 13191, 13192, 7, 6, 0, 0, 13192, 13193, 7, 9, 0, 0, 13193, 1668, 1, 0, + 0, 0, 13194, 13195, 7, 14, 0, 0, 13195, 13196, 7, 0, 0, 0, 13196, 13197, + 7, 7, 0, 0, 13197, 13198, 7, 0, 0, 0, 13198, 13199, 7, 17, 0, 0, 13199, + 13200, 7, 6, 0, 0, 13200, 1670, 1, 0, 0, 0, 13201, 13202, 7, 14, 0, 0, + 13202, 13203, 7, 0, 0, 0, 13203, 13204, 7, 7, 0, 0, 13204, 13205, 7, 0, + 0, 0, 13205, 13206, 7, 17, 0, 0, 13206, 13207, 7, 6, 0, 0, 13207, 13208, + 7, 14, 0, 0, 13208, 13209, 7, 6, 0, 0, 13209, 13210, 7, 7, 0, 0, 13210, + 13211, 7, 4, 0, 0, 13211, 1672, 1, 0, 0, 0, 13212, 13213, 7, 14, 0, 0, + 13213, 13214, 7, 0, 0, 0, 13214, 13215, 7, 7, 0, 0, 13215, 13216, 7, 0, + 0, 0, 13216, 13217, 7, 17, 0, 0, 13217, 13218, 7, 6, 0, 0, 13218, 13219, + 7, 3, 0, 0, 13219, 1674, 1, 0, 0, 0, 13220, 13221, 7, 14, 0, 0, 13221, + 13222, 7, 0, 0, 0, 13222, 13223, 7, 7, 0, 0, 13223, 13224, 7, 9, 0, 0, + 13224, 13225, 7, 0, 0, 0, 13225, 13226, 7, 4, 0, 0, 13226, 13227, 7, 2, + 0, 0, 13227, 13228, 7, 3, 0, 0, 13228, 13229, 7, 18, 0, 0, 13229, 1676, + 1, 0, 0, 0, 13230, 13231, 7, 14, 0, 0, 13231, 13232, 7, 0, 0, 0, 13232, + 13233, 7, 7, 0, 0, 13233, 13234, 7, 10, 0, 0, 13234, 13235, 7, 0, 0, 0, + 13235, 13236, 7, 11, 0, 0, 13236, 1678, 1, 0, 0, 0, 13237, 13238, 7, 14, + 0, 0, 13238, 13239, 7, 0, 0, 0, 13239, 13240, 7, 15, 0, 0, 13240, 1680, + 1, 0, 0, 0, 13241, 13242, 7, 14, 0, 0, 13242, 13243, 7, 0, 0, 0, 13243, + 13244, 7, 15, 0, 0, 13244, 13245, 7, 15, 0, 0, 13245, 13246, 7, 12, 0, + 0, 13246, 13247, 7, 7, 0, 0, 13247, 13248, 7, 17, 0, 0, 13248, 1682, 1, + 0, 0, 0, 13249, 13250, 7, 14, 0, 0, 13250, 13251, 7, 0, 0, 0, 13251, 13252, + 7, 5, 0, 0, 13252, 13253, 7, 4, 0, 0, 13253, 13254, 7, 6, 0, 0, 13254, + 13255, 7, 3, 0, 0, 13255, 1684, 1, 0, 0, 0, 13256, 13257, 7, 14, 0, 0, + 13257, 13258, 7, 0, 0, 0, 13258, 13259, 7, 4, 0, 0, 13259, 13260, 7, 8, + 0, 0, 13260, 13261, 7, 19, 0, 0, 13261, 13262, 7, 6, 0, 0, 13262, 13263, + 7, 9, 0, 0, 13263, 1686, 1, 0, 0, 0, 13264, 13265, 7, 14, 0, 0, 13265, + 13266, 7, 0, 0, 0, 13266, 13267, 7, 4, 0, 0, 13267, 13268, 7, 8, 0, 0, + 13268, 13269, 7, 19, 0, 0, 13269, 13270, 7, 6, 0, 0, 13270, 13271, 7, 5, + 0, 0, 13271, 1688, 1, 0, 0, 0, 13272, 13273, 7, 14, 0, 0, 13273, 13274, + 7, 0, 0, 0, 13274, 13275, 7, 4, 0, 0, 13275, 13276, 7, 8, 0, 0, 13276, + 13277, 7, 19, 0, 0, 13277, 1690, 1, 0, 0, 0, 13278, 13279, 7, 14, 0, 0, + 13279, 13280, 7, 0, 0, 0, 13280, 13281, 7, 4, 0, 0, 13281, 13282, 7, 8, + 0, 0, 13282, 13283, 7, 19, 0, 0, 13283, 13284, 5, 95, 0, 0, 13284, 13285, + 7, 7, 0, 0, 13285, 13286, 7, 10, 0, 0, 13286, 13287, 7, 14, 0, 0, 13287, + 13288, 7, 1, 0, 0, 13288, 13289, 7, 6, 0, 0, 13289, 13290, 7, 3, 0, 0, + 13290, 1692, 1, 0, 0, 0, 13291, 13292, 7, 14, 0, 0, 13292, 13293, 7, 0, + 0, 0, 13293, 13294, 7, 4, 0, 0, 13294, 13295, 7, 8, 0, 0, 13295, 13296, + 7, 19, 0, 0, 13296, 13297, 5, 95, 0, 0, 13297, 13298, 7, 3, 0, 0, 13298, + 13299, 7, 6, 0, 0, 13299, 13300, 7, 8, 0, 0, 13300, 13301, 7, 2, 0, 0, + 13301, 13302, 7, 17, 0, 0, 13302, 13303, 7, 7, 0, 0, 13303, 13304, 7, 12, + 0, 0, 13304, 13305, 7, 23, 0, 0, 13305, 13306, 7, 6, 0, 0, 13306, 1694, + 1, 0, 0, 0, 13307, 13308, 7, 14, 0, 0, 13308, 13309, 7, 0, 0, 0, 13309, + 13310, 7, 4, 0, 0, 13310, 13311, 7, 6, 0, 0, 13311, 13312, 7, 3, 0, 0, + 13312, 13313, 7, 12, 0, 0, 13313, 13314, 7, 0, 0, 0, 13314, 13315, 7, 11, + 0, 0, 13315, 13316, 7, 12, 0, 0, 13316, 13317, 7, 23, 0, 0, 13317, 13318, + 7, 6, 0, 0, 13318, 13319, 7, 9, 0, 0, 13319, 1696, 1, 0, 0, 0, 13320, 13321, + 7, 14, 0, 0, 13321, 13322, 7, 0, 0, 0, 13322, 13323, 7, 4, 0, 0, 13323, + 13324, 7, 6, 0, 0, 13324, 13325, 7, 3, 0, 0, 13325, 13326, 7, 12, 0, 0, + 13326, 13327, 7, 0, 0, 0, 13327, 13328, 7, 11, 0, 0, 13328, 13329, 7, 12, + 0, 0, 13329, 13330, 7, 23, 0, 0, 13330, 13331, 7, 6, 0, 0, 13331, 1698, + 1, 0, 0, 0, 13332, 13333, 7, 14, 0, 0, 13333, 13334, 7, 0, 0, 0, 13334, + 13335, 7, 25, 0, 0, 13335, 13336, 7, 0, 0, 0, 13336, 13337, 7, 3, 0, 0, + 13337, 13338, 7, 8, 0, 0, 13338, 13339, 7, 19, 0, 0, 13339, 13340, 7, 11, + 0, 0, 13340, 13341, 7, 2, 0, 0, 13341, 13342, 7, 17, 0, 0, 13342, 13343, + 7, 5, 0, 0, 13343, 1700, 1, 0, 0, 0, 13344, 13345, 7, 14, 0, 0, 13345, + 13346, 7, 0, 0, 0, 13346, 13347, 7, 25, 0, 0, 13347, 13348, 7, 9, 0, 0, + 13348, 13349, 7, 0, 0, 0, 13349, 13350, 7, 4, 0, 0, 13350, 13351, 7, 0, + 0, 0, 13351, 13352, 7, 16, 0, 0, 13352, 13353, 7, 12, 0, 0, 13353, 13354, + 7, 11, 0, 0, 13354, 13355, 7, 6, 0, 0, 13355, 13356, 7, 5, 0, 0, 13356, + 1702, 1, 0, 0, 0, 13357, 13358, 7, 14, 0, 0, 13358, 13359, 7, 0, 0, 0, + 13359, 13360, 7, 25, 0, 0, 13360, 13361, 7, 6, 0, 0, 13361, 13362, 7, 25, + 0, 0, 13362, 13363, 7, 4, 0, 0, 13363, 13364, 7, 6, 0, 0, 13364, 13365, + 7, 7, 0, 0, 13365, 13366, 7, 4, 0, 0, 13366, 13367, 7, 5, 0, 0, 13367, + 1704, 1, 0, 0, 0, 13368, 13369, 7, 14, 0, 0, 13369, 13370, 7, 0, 0, 0, + 13370, 13371, 7, 25, 0, 0, 13371, 13372, 7, 12, 0, 0, 13372, 13373, 7, + 14, 0, 0, 13373, 13374, 7, 12, 0, 0, 13374, 13375, 7, 23, 0, 0, 13375, + 13376, 7, 6, 0, 0, 13376, 1706, 1, 0, 0, 0, 13377, 13378, 7, 14, 0, 0, + 13378, 13379, 7, 0, 0, 0, 13379, 13380, 7, 25, 0, 0, 13380, 13381, 7, 12, + 0, 0, 13381, 13382, 7, 7, 0, 0, 13382, 13383, 7, 5, 0, 0, 13383, 13384, + 7, 4, 0, 0, 13384, 13385, 7, 0, 0, 0, 13385, 13386, 7, 7, 0, 0, 13386, + 13387, 7, 8, 0, 0, 13387, 13388, 7, 6, 0, 0, 13388, 13389, 7, 5, 0, 0, + 13389, 1708, 1, 0, 0, 0, 13390, 13391, 7, 14, 0, 0, 13391, 13392, 7, 0, + 0, 0, 13392, 13393, 7, 25, 0, 0, 13393, 13394, 7, 11, 0, 0, 13394, 13395, + 7, 2, 0, 0, 13395, 13396, 7, 17, 0, 0, 13396, 13397, 7, 16, 0, 0, 13397, + 13398, 7, 12, 0, 0, 13398, 13399, 7, 11, 0, 0, 13399, 13400, 7, 6, 0, 0, + 13400, 13401, 7, 5, 0, 0, 13401, 1710, 1, 0, 0, 0, 13402, 13403, 7, 14, + 0, 0, 13403, 13404, 7, 0, 0, 0, 13404, 13405, 7, 25, 0, 0, 13405, 13406, + 7, 11, 0, 0, 13406, 13407, 7, 2, 0, 0, 13407, 13408, 7, 17, 0, 0, 13408, + 13409, 7, 19, 0, 0, 13409, 13410, 7, 12, 0, 0, 13410, 13411, 7, 5, 0, 0, + 13411, 13412, 7, 4, 0, 0, 13412, 13413, 7, 2, 0, 0, 13413, 13414, 7, 3, + 0, 0, 13414, 13415, 7, 18, 0, 0, 13415, 1712, 1, 0, 0, 0, 13416, 13417, + 7, 14, 0, 0, 13417, 13418, 7, 0, 0, 0, 13418, 13419, 7, 25, 0, 0, 13419, + 13420, 7, 11, 0, 0, 13420, 13421, 7, 2, 0, 0, 13421, 13422, 7, 17, 0, 0, + 13422, 13423, 7, 14, 0, 0, 13423, 13424, 7, 6, 0, 0, 13424, 13425, 7, 14, + 0, 0, 13425, 13426, 7, 1, 0, 0, 13426, 13427, 7, 6, 0, 0, 13427, 13428, + 7, 3, 0, 0, 13428, 13429, 7, 5, 0, 0, 13429, 1714, 1, 0, 0, 0, 13430, 13431, + 7, 14, 0, 0, 13431, 13432, 7, 0, 0, 0, 13432, 13433, 7, 25, 0, 0, 13433, + 13434, 5, 95, 0, 0, 13434, 13435, 7, 5, 0, 0, 13435, 13436, 7, 19, 0, 0, + 13436, 13437, 7, 0, 0, 0, 13437, 13438, 7, 3, 0, 0, 13438, 13439, 7, 6, + 0, 0, 13439, 13440, 7, 9, 0, 0, 13440, 13441, 5, 95, 0, 0, 13441, 13442, + 7, 4, 0, 0, 13442, 13443, 7, 6, 0, 0, 13443, 13444, 7, 14, 0, 0, 13444, + 13445, 7, 15, 0, 0, 13445, 13446, 5, 95, 0, 0, 13446, 13447, 7, 5, 0, 0, + 13447, 13448, 7, 12, 0, 0, 13448, 13449, 7, 23, 0, 0, 13449, 13450, 7, + 6, 0, 0, 13450, 1716, 1, 0, 0, 0, 13451, 13452, 7, 14, 0, 0, 13452, 13453, + 7, 0, 0, 0, 13453, 13454, 7, 25, 0, 0, 13454, 13455, 7, 5, 0, 0, 13455, + 13456, 7, 12, 0, 0, 13456, 13457, 7, 23, 0, 0, 13457, 13458, 7, 6, 0, 0, + 13458, 1718, 1, 0, 0, 0, 13459, 13460, 7, 14, 0, 0, 13460, 13461, 7, 0, + 0, 0, 13461, 13462, 7, 25, 0, 0, 13462, 13463, 7, 4, 0, 0, 13463, 13464, + 7, 3, 0, 0, 13464, 13465, 7, 0, 0, 0, 13465, 13466, 7, 7, 0, 0, 13466, + 13467, 7, 5, 0, 0, 13467, 1720, 1, 0, 0, 0, 13468, 13469, 7, 14, 0, 0, + 13469, 13470, 7, 0, 0, 0, 13470, 13471, 7, 25, 0, 0, 13471, 13472, 7, 13, + 0, 0, 13472, 13473, 7, 0, 0, 0, 13473, 13474, 7, 11, 0, 0, 13474, 13475, + 7, 10, 0, 0, 13475, 13476, 7, 6, 0, 0, 13476, 1722, 1, 0, 0, 0, 13477, + 13478, 7, 14, 0, 0, 13478, 13479, 7, 6, 0, 0, 13479, 13480, 7, 0, 0, 0, + 13480, 13481, 7, 5, 0, 0, 13481, 13482, 7, 10, 0, 0, 13482, 13483, 7, 3, + 0, 0, 13483, 13484, 7, 6, 0, 0, 13484, 1724, 1, 0, 0, 0, 13485, 13486, + 7, 14, 0, 0, 13486, 13487, 7, 6, 0, 0, 13487, 13488, 7, 0, 0, 0, 13488, + 13489, 7, 5, 0, 0, 13489, 13490, 7, 10, 0, 0, 13490, 13491, 7, 3, 0, 0, + 13491, 13492, 7, 6, 0, 0, 13492, 13493, 7, 5, 0, 0, 13493, 1726, 1, 0, + 0, 0, 13494, 13495, 7, 14, 0, 0, 13495, 13496, 7, 6, 0, 0, 13496, 13497, + 7, 9, 0, 0, 13497, 13498, 7, 12, 0, 0, 13498, 13499, 7, 10, 0, 0, 13499, + 13500, 7, 14, 0, 0, 13500, 1728, 1, 0, 0, 0, 13501, 13502, 7, 14, 0, 0, + 13502, 13503, 7, 6, 0, 0, 13503, 13504, 7, 14, 0, 0, 13504, 13505, 7, 1, + 0, 0, 13505, 13506, 7, 6, 0, 0, 13506, 13507, 7, 3, 0, 0, 13507, 1730, + 1, 0, 0, 0, 13508, 13509, 7, 14, 0, 0, 13509, 13510, 7, 6, 0, 0, 13510, + 13511, 7, 14, 0, 0, 13511, 13512, 7, 1, 0, 0, 13512, 13513, 7, 6, 0, 0, + 13513, 13514, 7, 3, 0, 0, 13514, 13515, 5, 95, 0, 0, 13515, 13516, 7, 8, + 0, 0, 13516, 13517, 7, 0, 0, 0, 13517, 13518, 7, 15, 0, 0, 13518, 13519, + 7, 4, 0, 0, 13519, 13520, 7, 12, 0, 0, 13520, 13521, 7, 2, 0, 0, 13521, + 13522, 7, 7, 0, 0, 13522, 1732, 1, 0, 0, 0, 13523, 13524, 7, 14, 0, 0, + 13524, 13525, 7, 6, 0, 0, 13525, 13526, 7, 14, 0, 0, 13526, 13527, 7, 1, + 0, 0, 13527, 13528, 7, 6, 0, 0, 13528, 13529, 7, 3, 0, 0, 13529, 13530, + 5, 95, 0, 0, 13530, 13531, 7, 9, 0, 0, 13531, 13532, 7, 6, 0, 0, 13532, + 13533, 7, 5, 0, 0, 13533, 13534, 7, 8, 0, 0, 13534, 13535, 7, 3, 0, 0, + 13535, 13536, 7, 12, 0, 0, 13536, 13537, 7, 15, 0, 0, 13537, 13538, 7, + 4, 0, 0, 13538, 13539, 7, 12, 0, 0, 13539, 13540, 7, 2, 0, 0, 13540, 13541, + 7, 7, 0, 0, 13541, 1734, 1, 0, 0, 0, 13542, 13543, 7, 14, 0, 0, 13543, + 13544, 7, 6, 0, 0, 13544, 13545, 7, 14, 0, 0, 13545, 13546, 7, 1, 0, 0, + 13546, 13547, 7, 6, 0, 0, 13547, 13548, 7, 3, 0, 0, 13548, 13549, 5, 95, + 0, 0, 13549, 13550, 7, 7, 0, 0, 13550, 13551, 7, 0, 0, 0, 13551, 13552, + 7, 14, 0, 0, 13552, 13553, 7, 6, 0, 0, 13553, 1736, 1, 0, 0, 0, 13554, + 13555, 7, 14, 0, 0, 13555, 13556, 7, 6, 0, 0, 13556, 13557, 7, 14, 0, 0, + 13557, 13558, 7, 1, 0, 0, 13558, 13559, 7, 6, 0, 0, 13559, 13560, 7, 3, + 0, 0, 13560, 13561, 5, 95, 0, 0, 13561, 13562, 7, 10, 0, 0, 13562, 13563, + 7, 7, 0, 0, 13563, 13564, 7, 12, 0, 0, 13564, 13565, 7, 24, 0, 0, 13565, + 13566, 7, 10, 0, 0, 13566, 13567, 7, 6, 0, 0, 13567, 13568, 5, 95, 0, 0, + 13568, 13569, 7, 7, 0, 0, 13569, 13570, 7, 0, 0, 0, 13570, 13571, 7, 14, + 0, 0, 13571, 13572, 7, 6, 0, 0, 13572, 1738, 1, 0, 0, 0, 13573, 13574, + 7, 14, 0, 0, 13574, 13575, 7, 6, 0, 0, 13575, 13576, 7, 14, 0, 0, 13576, + 13577, 7, 8, 0, 0, 13577, 13578, 7, 2, 0, 0, 13578, 13579, 7, 14, 0, 0, + 13579, 13580, 7, 15, 0, 0, 13580, 13581, 7, 3, 0, 0, 13581, 13582, 7, 6, + 0, 0, 13582, 13583, 7, 5, 0, 0, 13583, 13584, 7, 5, 0, 0, 13584, 1740, + 1, 0, 0, 0, 13585, 13586, 7, 14, 0, 0, 13586, 13587, 7, 6, 0, 0, 13587, + 13588, 7, 14, 0, 0, 13588, 13589, 7, 2, 0, 0, 13589, 13590, 7, 3, 0, 0, + 13590, 13591, 7, 18, 0, 0, 13591, 1742, 1, 0, 0, 0, 13592, 13593, 7, 14, + 0, 0, 13593, 13594, 7, 6, 0, 0, 13594, 13595, 7, 3, 0, 0, 13595, 13596, + 7, 17, 0, 0, 13596, 13597, 7, 6, 0, 0, 13597, 13598, 5, 36, 0, 0, 13598, + 13599, 7, 0, 0, 0, 13599, 13600, 7, 8, 0, 0, 13600, 13601, 7, 4, 0, 0, + 13601, 13602, 7, 12, 0, 0, 13602, 13603, 7, 2, 0, 0, 13603, 13604, 7, 7, + 0, 0, 13604, 13605, 7, 5, 0, 0, 13605, 1744, 1, 0, 0, 0, 13606, 13607, + 7, 14, 0, 0, 13607, 13608, 7, 6, 0, 0, 13608, 13609, 7, 3, 0, 0, 13609, + 13610, 7, 17, 0, 0, 13610, 13611, 7, 6, 0, 0, 13611, 13612, 5, 95, 0, 0, + 13612, 13613, 7, 0, 0, 0, 13613, 13614, 7, 20, 0, 0, 13614, 1746, 1, 0, + 0, 0, 13615, 13616, 7, 14, 0, 0, 13616, 13617, 7, 6, 0, 0, 13617, 13618, + 7, 3, 0, 0, 13618, 13619, 7, 17, 0, 0, 13619, 13620, 7, 6, 0, 0, 13620, + 13621, 5, 95, 0, 0, 13621, 13622, 7, 8, 0, 0, 13622, 13623, 7, 2, 0, 0, + 13623, 13624, 7, 7, 0, 0, 13624, 13625, 7, 5, 0, 0, 13625, 13626, 7, 4, + 0, 0, 13626, 13627, 5, 95, 0, 0, 13627, 13628, 7, 2, 0, 0, 13628, 13629, + 7, 7, 0, 0, 13629, 1748, 1, 0, 0, 0, 13630, 13631, 7, 14, 0, 0, 13631, + 13632, 7, 6, 0, 0, 13632, 13633, 7, 3, 0, 0, 13633, 13634, 7, 17, 0, 0, + 13634, 13635, 7, 6, 0, 0, 13635, 1750, 1, 0, 0, 0, 13636, 13637, 7, 14, + 0, 0, 13637, 13638, 7, 6, 0, 0, 13638, 13639, 7, 3, 0, 0, 13639, 13640, + 7, 17, 0, 0, 13640, 13641, 7, 6, 0, 0, 13641, 13642, 5, 95, 0, 0, 13642, + 13643, 7, 5, 0, 0, 13643, 13644, 7, 20, 0, 0, 13644, 1752, 1, 0, 0, 0, + 13645, 13646, 7, 14, 0, 0, 13646, 13647, 7, 6, 0, 0, 13647, 13648, 7, 4, + 0, 0, 13648, 13649, 7, 0, 0, 0, 13649, 13650, 7, 9, 0, 0, 13650, 13651, + 7, 0, 0, 0, 13651, 13652, 7, 4, 0, 0, 13652, 13653, 7, 0, 0, 0, 13653, + 1754, 1, 0, 0, 0, 13654, 13655, 7, 14, 0, 0, 13655, 13656, 7, 6, 0, 0, + 13656, 13657, 7, 4, 0, 0, 13657, 13658, 7, 19, 0, 0, 13658, 13659, 7, 2, + 0, 0, 13659, 13660, 7, 9, 0, 0, 13660, 1756, 1, 0, 0, 0, 13661, 13662, + 7, 14, 0, 0, 13662, 13663, 7, 12, 0, 0, 13663, 13664, 7, 17, 0, 0, 13664, + 13665, 7, 3, 0, 0, 13665, 13666, 7, 0, 0, 0, 13666, 13667, 7, 4, 0, 0, + 13667, 13668, 7, 6, 0, 0, 13668, 1758, 1, 0, 0, 0, 13669, 13670, 7, 14, + 0, 0, 13670, 13671, 7, 12, 0, 0, 13671, 13672, 7, 17, 0, 0, 13672, 13673, + 7, 3, 0, 0, 13673, 13674, 7, 0, 0, 0, 13674, 13675, 7, 4, 0, 0, 13675, + 13676, 7, 12, 0, 0, 13676, 13677, 7, 2, 0, 0, 13677, 13678, 7, 7, 0, 0, + 13678, 1760, 1, 0, 0, 0, 13679, 13680, 7, 14, 0, 0, 13680, 13681, 7, 12, + 0, 0, 13681, 13682, 7, 7, 0, 0, 13682, 13683, 7, 6, 0, 0, 13683, 13684, + 7, 25, 0, 0, 13684, 13685, 7, 4, 0, 0, 13685, 13686, 7, 6, 0, 0, 13686, + 13687, 7, 7, 0, 0, 13687, 13688, 7, 4, 0, 0, 13688, 13689, 7, 5, 0, 0, + 13689, 1762, 1, 0, 0, 0, 13690, 13691, 7, 14, 0, 0, 13691, 13692, 7, 12, + 0, 0, 13692, 13693, 7, 7, 0, 0, 13693, 13694, 7, 12, 0, 0, 13694, 13695, + 7, 14, 0, 0, 13695, 13696, 7, 12, 0, 0, 13696, 13697, 7, 23, 0, 0, 13697, + 13698, 7, 6, 0, 0, 13698, 1764, 1, 0, 0, 0, 13699, 13700, 7, 14, 0, 0, + 13700, 13701, 7, 12, 0, 0, 13701, 13702, 7, 7, 0, 0, 13702, 13703, 7, 12, + 0, 0, 13703, 13704, 7, 14, 0, 0, 13704, 13705, 7, 10, 0, 0, 13705, 13706, + 7, 14, 0, 0, 13706, 1766, 1, 0, 0, 0, 13707, 13708, 7, 14, 0, 0, 13708, + 13709, 7, 12, 0, 0, 13709, 13710, 7, 7, 0, 0, 13710, 13711, 7, 12, 0, 0, + 13711, 13712, 7, 7, 0, 0, 13712, 13713, 7, 17, 0, 0, 13713, 1768, 1, 0, + 0, 0, 13714, 13715, 7, 14, 0, 0, 13715, 13716, 7, 12, 0, 0, 13716, 13717, + 7, 7, 0, 0, 13717, 13718, 7, 10, 0, 0, 13718, 13719, 7, 5, 0, 0, 13719, + 1770, 1, 0, 0, 0, 13720, 13721, 7, 14, 0, 0, 13721, 13722, 7, 12, 0, 0, + 13722, 13723, 7, 7, 0, 0, 13723, 13724, 7, 10, 0, 0, 13724, 13725, 7, 5, + 0, 0, 13725, 13726, 5, 95, 0, 0, 13726, 13727, 7, 7, 0, 0, 13727, 13728, + 7, 10, 0, 0, 13728, 13729, 7, 11, 0, 0, 13729, 13730, 7, 11, 0, 0, 13730, + 1772, 1, 0, 0, 0, 13731, 13732, 7, 14, 0, 0, 13732, 13733, 7, 12, 0, 0, + 13733, 13734, 7, 7, 0, 0, 13734, 13735, 7, 10, 0, 0, 13735, 13736, 7, 4, + 0, 0, 13736, 13737, 7, 6, 0, 0, 13737, 1774, 1, 0, 0, 0, 13738, 13739, + 7, 14, 0, 0, 13739, 13740, 7, 12, 0, 0, 13740, 13741, 7, 7, 0, 0, 13741, + 13742, 7, 10, 0, 0, 13742, 13743, 7, 4, 0, 0, 13743, 13744, 7, 6, 0, 0, + 13744, 13745, 7, 5, 0, 0, 13745, 1776, 1, 0, 0, 0, 13746, 13747, 7, 14, + 0, 0, 13747, 13748, 7, 12, 0, 0, 13748, 13749, 7, 7, 0, 0, 13749, 13750, + 7, 13, 0, 0, 13750, 13751, 7, 0, 0, 0, 13751, 13752, 7, 11, 0, 0, 13752, + 13753, 7, 10, 0, 0, 13753, 13754, 7, 6, 0, 0, 13754, 1778, 1, 0, 0, 0, + 13755, 13756, 7, 14, 0, 0, 13756, 13757, 7, 12, 0, 0, 13757, 13758, 7, + 3, 0, 0, 13758, 13759, 7, 3, 0, 0, 13759, 13760, 7, 2, 0, 0, 13760, 13761, + 7, 3, 0, 0, 13761, 13762, 7, 8, 0, 0, 13762, 13763, 7, 2, 0, 0, 13763, + 13764, 7, 11, 0, 0, 13764, 13765, 7, 9, 0, 0, 13765, 1780, 1, 0, 0, 0, + 13766, 13767, 7, 14, 0, 0, 13767, 13768, 7, 12, 0, 0, 13768, 13769, 7, + 3, 0, 0, 13769, 13770, 7, 3, 0, 0, 13770, 13771, 7, 2, 0, 0, 13771, 13772, + 7, 3, 0, 0, 13772, 13773, 7, 19, 0, 0, 13773, 13774, 7, 2, 0, 0, 13774, + 13775, 7, 4, 0, 0, 13775, 1782, 1, 0, 0, 0, 13776, 13777, 7, 14, 0, 0, + 13777, 13778, 7, 12, 0, 0, 13778, 13779, 7, 3, 0, 0, 13779, 13780, 7, 3, + 0, 0, 13780, 13781, 7, 2, 0, 0, 13781, 13782, 7, 3, 0, 0, 13782, 1784, + 1, 0, 0, 0, 13783, 13784, 7, 14, 0, 0, 13784, 13785, 7, 12, 0, 0, 13785, + 13786, 7, 5, 0, 0, 13786, 13787, 7, 5, 0, 0, 13787, 13788, 7, 12, 0, 0, + 13788, 13789, 7, 7, 0, 0, 13789, 13790, 7, 17, 0, 0, 13790, 1786, 1, 0, + 0, 0, 13791, 13792, 7, 14, 0, 0, 13792, 13793, 7, 12, 0, 0, 13793, 13794, + 7, 5, 0, 0, 13794, 13795, 7, 14, 0, 0, 13795, 13796, 7, 0, 0, 0, 13796, + 13797, 7, 4, 0, 0, 13797, 13798, 7, 8, 0, 0, 13798, 13799, 7, 19, 0, 0, + 13799, 1788, 1, 0, 0, 0, 13800, 13801, 7, 14, 0, 0, 13801, 13802, 7, 11, + 0, 0, 13802, 13803, 7, 5, 0, 0, 13803, 13804, 7, 11, 0, 0, 13804, 13805, + 7, 0, 0, 0, 13805, 13806, 7, 1, 0, 0, 13806, 13807, 7, 6, 0, 0, 13807, + 13808, 7, 11, 0, 0, 13808, 1790, 1, 0, 0, 0, 13809, 13810, 7, 14, 0, 0, + 13810, 13811, 7, 2, 0, 0, 13811, 13812, 7, 9, 0, 0, 13812, 13813, 7, 6, + 0, 0, 13813, 13814, 7, 11, 0, 0, 13814, 13815, 5, 95, 0, 0, 13815, 13816, + 7, 8, 0, 0, 13816, 13817, 7, 2, 0, 0, 13817, 13818, 7, 14, 0, 0, 13818, + 13819, 7, 15, 0, 0, 13819, 13820, 7, 12, 0, 0, 13820, 13821, 7, 11, 0, + 0, 13821, 13822, 7, 6, 0, 0, 13822, 13823, 5, 95, 0, 0, 13823, 13824, 7, + 5, 0, 0, 13824, 13825, 7, 10, 0, 0, 13825, 13826, 7, 1, 0, 0, 13826, 13827, + 7, 24, 0, 0, 13827, 13828, 7, 10, 0, 0, 13828, 13829, 7, 6, 0, 0, 13829, + 13830, 7, 3, 0, 0, 13830, 13831, 7, 18, 0, 0, 13831, 1792, 1, 0, 0, 0, + 13832, 13833, 7, 14, 0, 0, 13833, 13834, 7, 2, 0, 0, 13834, 13835, 7, 9, + 0, 0, 13835, 13836, 7, 6, 0, 0, 13836, 13837, 7, 11, 0, 0, 13837, 13838, + 5, 95, 0, 0, 13838, 13839, 7, 9, 0, 0, 13839, 13840, 7, 2, 0, 0, 13840, + 13841, 7, 7, 0, 0, 13841, 13842, 7, 4, 0, 0, 13842, 13843, 7, 13, 0, 0, + 13843, 13844, 7, 6, 0, 0, 13844, 13845, 7, 3, 0, 0, 13845, 13846, 7, 12, + 0, 0, 13846, 13847, 7, 16, 0, 0, 13847, 13848, 7, 18, 0, 0, 13848, 13849, + 5, 95, 0, 0, 13849, 13850, 7, 10, 0, 0, 13850, 13851, 7, 7, 0, 0, 13851, + 13852, 7, 12, 0, 0, 13852, 13853, 7, 24, 0, 0, 13853, 13854, 7, 10, 0, + 0, 13854, 13855, 7, 6, 0, 0, 13855, 13856, 7, 7, 0, 0, 13856, 13857, 7, + 6, 0, 0, 13857, 13858, 7, 5, 0, 0, 13858, 13859, 7, 5, 0, 0, 13859, 1794, + 1, 0, 0, 0, 13860, 13861, 7, 14, 0, 0, 13861, 13862, 7, 2, 0, 0, 13862, + 13863, 7, 9, 0, 0, 13863, 13864, 7, 6, 0, 0, 13864, 13865, 7, 11, 0, 0, + 13865, 13866, 5, 95, 0, 0, 13866, 13867, 7, 9, 0, 0, 13867, 13868, 7, 18, + 0, 0, 13868, 13869, 7, 7, 0, 0, 13869, 13870, 7, 0, 0, 0, 13870, 13871, + 7, 14, 0, 0, 13871, 13872, 7, 12, 0, 0, 13872, 13873, 7, 8, 0, 0, 13873, + 13874, 5, 95, 0, 0, 13874, 13875, 7, 5, 0, 0, 13875, 13876, 7, 10, 0, 0, + 13876, 13877, 7, 1, 0, 0, 13877, 13878, 7, 24, 0, 0, 13878, 13879, 7, 10, + 0, 0, 13879, 13880, 7, 6, 0, 0, 13880, 13881, 7, 3, 0, 0, 13881, 13882, + 7, 18, 0, 0, 13882, 1796, 1, 0, 0, 0, 13883, 13884, 7, 14, 0, 0, 13884, + 13885, 7, 2, 0, 0, 13885, 13886, 7, 9, 0, 0, 13886, 13887, 7, 6, 0, 0, + 13887, 13888, 7, 11, 0, 0, 13888, 13889, 5, 95, 0, 0, 13889, 13890, 7, + 14, 0, 0, 13890, 13891, 7, 12, 0, 0, 13891, 13892, 7, 7, 0, 0, 13892, 13893, + 5, 95, 0, 0, 13893, 13894, 7, 0, 0, 0, 13894, 13895, 7, 7, 0, 0, 13895, + 13896, 7, 0, 0, 0, 13896, 13897, 7, 11, 0, 0, 13897, 13898, 7, 18, 0, 0, + 13898, 13899, 7, 5, 0, 0, 13899, 13900, 7, 12, 0, 0, 13900, 13901, 7, 5, + 0, 0, 13901, 1798, 1, 0, 0, 0, 13902, 13903, 7, 14, 0, 0, 13903, 13904, + 7, 2, 0, 0, 13904, 13905, 7, 9, 0, 0, 13905, 13906, 7, 6, 0, 0, 13906, + 13907, 7, 11, 0, 0, 13907, 1800, 1, 0, 0, 0, 13908, 13909, 7, 14, 0, 0, + 13909, 13910, 7, 2, 0, 0, 13910, 13911, 7, 9, 0, 0, 13911, 13912, 7, 6, + 0, 0, 13912, 13913, 7, 11, 0, 0, 13913, 13914, 5, 95, 0, 0, 13914, 13915, + 7, 7, 0, 0, 13915, 13916, 7, 1, 0, 0, 13916, 1802, 1, 0, 0, 0, 13917, 13918, + 7, 14, 0, 0, 13918, 13919, 7, 2, 0, 0, 13919, 13920, 7, 9, 0, 0, 13920, + 13921, 7, 6, 0, 0, 13921, 13922, 7, 11, 0, 0, 13922, 13923, 5, 95, 0, 0, + 13923, 13924, 7, 7, 0, 0, 13924, 13925, 7, 2, 0, 0, 13925, 13926, 5, 95, + 0, 0, 13926, 13927, 7, 0, 0, 0, 13927, 13928, 7, 7, 0, 0, 13928, 13929, + 7, 0, 0, 0, 13929, 13930, 7, 11, 0, 0, 13930, 13931, 7, 18, 0, 0, 13931, + 13932, 7, 5, 0, 0, 13932, 13933, 7, 12, 0, 0, 13933, 13934, 7, 5, 0, 0, + 13934, 1804, 1, 0, 0, 0, 13935, 13936, 7, 14, 0, 0, 13936, 13937, 7, 2, + 0, 0, 13937, 13938, 7, 9, 0, 0, 13938, 13939, 7, 6, 0, 0, 13939, 13940, + 7, 11, 0, 0, 13940, 13941, 5, 95, 0, 0, 13941, 13942, 7, 15, 0, 0, 13942, + 13943, 7, 1, 0, 0, 13943, 13944, 7, 18, 0, 0, 13944, 1806, 1, 0, 0, 0, + 13945, 13946, 7, 14, 0, 0, 13946, 13947, 7, 2, 0, 0, 13947, 13948, 7, 9, + 0, 0, 13948, 13949, 7, 6, 0, 0, 13949, 13950, 7, 11, 0, 0, 13950, 13951, + 5, 95, 0, 0, 13951, 13952, 7, 15, 0, 0, 13952, 13953, 7, 10, 0, 0, 13953, + 13954, 7, 5, 0, 0, 13954, 13955, 7, 19, 0, 0, 13955, 13956, 5, 95, 0, 0, + 13956, 13957, 7, 3, 0, 0, 13957, 13958, 7, 6, 0, 0, 13958, 13959, 7, 16, + 0, 0, 13959, 1808, 1, 0, 0, 0, 13960, 13961, 7, 14, 0, 0, 13961, 13962, + 7, 2, 0, 0, 13962, 13963, 7, 9, 0, 0, 13963, 13964, 7, 6, 0, 0, 13964, + 13965, 7, 11, 0, 0, 13965, 13966, 5, 95, 0, 0, 13966, 13967, 7, 5, 0, 0, + 13967, 13968, 7, 13, 0, 0, 13968, 1810, 1, 0, 0, 0, 13969, 13970, 7, 14, + 0, 0, 13970, 13971, 7, 2, 0, 0, 13971, 13972, 7, 9, 0, 0, 13972, 13973, + 7, 6, 0, 0, 13973, 1812, 1, 0, 0, 0, 13974, 13975, 7, 14, 0, 0, 13975, + 13976, 7, 2, 0, 0, 13976, 13977, 7, 9, 0, 0, 13977, 13978, 7, 12, 0, 0, + 13978, 13979, 7, 16, 0, 0, 13979, 13980, 7, 12, 0, 0, 13980, 13981, 7, + 8, 0, 0, 13981, 13982, 7, 0, 0, 0, 13982, 13983, 7, 4, 0, 0, 13983, 13984, + 7, 12, 0, 0, 13984, 13985, 7, 2, 0, 0, 13985, 13986, 7, 7, 0, 0, 13986, + 1814, 1, 0, 0, 0, 13987, 13988, 7, 14, 0, 0, 13988, 13989, 7, 2, 0, 0, + 13989, 13990, 7, 9, 0, 0, 13990, 13991, 7, 12, 0, 0, 13991, 13992, 7, 16, + 0, 0, 13992, 13993, 7, 18, 0, 0, 13993, 13994, 5, 95, 0, 0, 13994, 13995, + 7, 8, 0, 0, 13995, 13996, 7, 2, 0, 0, 13996, 13997, 7, 11, 0, 0, 13997, + 13998, 7, 10, 0, 0, 13998, 13999, 7, 14, 0, 0, 13999, 14000, 7, 7, 0, 0, + 14000, 14001, 5, 95, 0, 0, 14001, 14002, 7, 4, 0, 0, 14002, 14003, 7, 18, + 0, 0, 14003, 14004, 7, 15, 0, 0, 14004, 14005, 7, 6, 0, 0, 14005, 1816, + 1, 0, 0, 0, 14006, 14007, 7, 14, 0, 0, 14007, 14008, 7, 2, 0, 0, 14008, + 14009, 7, 9, 0, 0, 14009, 14010, 7, 12, 0, 0, 14010, 14011, 7, 16, 0, 0, + 14011, 14012, 7, 18, 0, 0, 14012, 1818, 1, 0, 0, 0, 14013, 14014, 7, 14, + 0, 0, 14014, 14015, 7, 2, 0, 0, 14015, 14016, 7, 9, 0, 0, 14016, 1820, + 1, 0, 0, 0, 14017, 14018, 7, 14, 0, 0, 14018, 14019, 7, 2, 0, 0, 14019, + 14020, 7, 9, 0, 0, 14020, 14021, 7, 10, 0, 0, 14021, 14022, 7, 11, 0, 0, + 14022, 14023, 7, 6, 0, 0, 14023, 1822, 1, 0, 0, 0, 14024, 14025, 7, 14, + 0, 0, 14025, 14026, 7, 2, 0, 0, 14026, 14027, 7, 7, 0, 0, 14027, 14028, + 7, 12, 0, 0, 14028, 14029, 7, 4, 0, 0, 14029, 14030, 7, 2, 0, 0, 14030, + 14031, 7, 3, 0, 0, 14031, 14032, 7, 12, 0, 0, 14032, 14033, 7, 7, 0, 0, + 14033, 14034, 7, 17, 0, 0, 14034, 1824, 1, 0, 0, 0, 14035, 14036, 7, 14, + 0, 0, 14036, 14037, 7, 2, 0, 0, 14037, 14038, 7, 7, 0, 0, 14038, 14039, + 7, 12, 0, 0, 14039, 14040, 7, 4, 0, 0, 14040, 14041, 7, 2, 0, 0, 14041, + 14042, 7, 3, 0, 0, 14042, 1826, 1, 0, 0, 0, 14043, 14044, 7, 14, 0, 0, + 14044, 14045, 7, 2, 0, 0, 14045, 14046, 7, 7, 0, 0, 14046, 14047, 7, 4, + 0, 0, 14047, 14048, 7, 19, 0, 0, 14048, 1828, 1, 0, 0, 0, 14049, 14050, + 7, 14, 0, 0, 14050, 14051, 7, 2, 0, 0, 14051, 14052, 7, 7, 0, 0, 14052, + 14053, 7, 4, 0, 0, 14053, 14054, 7, 19, 0, 0, 14054, 14055, 7, 5, 0, 0, + 14055, 14056, 5, 95, 0, 0, 14056, 14057, 7, 1, 0, 0, 14057, 14058, 7, 6, + 0, 0, 14058, 14059, 7, 4, 0, 0, 14059, 14060, 7, 22, 0, 0, 14060, 14061, + 7, 6, 0, 0, 14061, 14062, 7, 6, 0, 0, 14062, 14063, 7, 7, 0, 0, 14063, + 1830, 1, 0, 0, 0, 14064, 14065, 7, 14, 0, 0, 14065, 14066, 7, 2, 0, 0, + 14066, 14067, 7, 7, 0, 0, 14067, 14068, 7, 4, 0, 0, 14068, 14069, 7, 19, + 0, 0, 14069, 14070, 7, 5, 0, 0, 14070, 1832, 1, 0, 0, 0, 14071, 14072, + 7, 14, 0, 0, 14072, 14073, 7, 2, 0, 0, 14073, 14074, 7, 10, 0, 0, 14074, + 14075, 7, 7, 0, 0, 14075, 14076, 7, 4, 0, 0, 14076, 1834, 1, 0, 0, 0, 14077, + 14078, 7, 14, 0, 0, 14078, 14079, 7, 2, 0, 0, 14079, 14080, 7, 10, 0, 0, + 14080, 14081, 7, 7, 0, 0, 14081, 14082, 7, 4, 0, 0, 14082, 14083, 7, 15, + 0, 0, 14083, 14084, 7, 0, 0, 0, 14084, 14085, 7, 4, 0, 0, 14085, 14086, + 7, 19, 0, 0, 14086, 1836, 1, 0, 0, 0, 14087, 14088, 7, 14, 0, 0, 14088, + 14089, 7, 2, 0, 0, 14089, 14090, 7, 10, 0, 0, 14090, 14091, 7, 7, 0, 0, + 14091, 14092, 7, 4, 0, 0, 14092, 14093, 7, 15, 0, 0, 14093, 14094, 7, 2, + 0, 0, 14094, 14095, 7, 12, 0, 0, 14095, 14096, 7, 7, 0, 0, 14096, 14097, + 7, 4, 0, 0, 14097, 1838, 1, 0, 0, 0, 14098, 14099, 7, 14, 0, 0, 14099, + 14100, 7, 2, 0, 0, 14100, 14101, 7, 13, 0, 0, 14101, 14102, 7, 6, 0, 0, + 14102, 14103, 7, 14, 0, 0, 14103, 14104, 7, 6, 0, 0, 14104, 14105, 7, 7, + 0, 0, 14105, 14106, 7, 4, 0, 0, 14106, 1840, 1, 0, 0, 0, 14107, 14108, + 7, 14, 0, 0, 14108, 14109, 7, 2, 0, 0, 14109, 14110, 7, 13, 0, 0, 14110, + 14111, 7, 6, 0, 0, 14111, 1842, 1, 0, 0, 0, 14112, 14113, 7, 14, 0, 0, + 14113, 14114, 7, 10, 0, 0, 14114, 14115, 7, 11, 0, 0, 14115, 14116, 7, + 4, 0, 0, 14116, 14117, 7, 12, 0, 0, 14117, 14118, 7, 9, 0, 0, 14118, 14119, + 7, 12, 0, 0, 14119, 14120, 7, 14, 0, 0, 14120, 14121, 7, 6, 0, 0, 14121, + 14122, 7, 7, 0, 0, 14122, 14123, 7, 5, 0, 0, 14123, 14124, 7, 12, 0, 0, + 14124, 14125, 7, 2, 0, 0, 14125, 14126, 7, 7, 0, 0, 14126, 14127, 7, 0, + 0, 0, 14127, 14128, 7, 11, 0, 0, 14128, 1844, 1, 0, 0, 0, 14129, 14130, + 7, 14, 0, 0, 14130, 14131, 7, 10, 0, 0, 14131, 14132, 7, 11, 0, 0, 14132, + 14133, 7, 4, 0, 0, 14133, 14134, 7, 12, 0, 0, 14134, 14135, 7, 5, 0, 0, + 14135, 14136, 7, 6, 0, 0, 14136, 14137, 7, 4, 0, 0, 14137, 1846, 1, 0, + 0, 0, 14138, 14139, 7, 14, 0, 0, 14139, 14140, 7, 13, 0, 0, 14140, 14141, + 5, 95, 0, 0, 14141, 14142, 7, 14, 0, 0, 14142, 14143, 7, 6, 0, 0, 14143, + 14144, 7, 3, 0, 0, 14144, 14145, 7, 17, 0, 0, 14145, 14146, 7, 6, 0, 0, + 14146, 1848, 1, 0, 0, 0, 14147, 14148, 7, 7, 0, 0, 14148, 14149, 7, 0, + 0, 0, 14149, 14150, 7, 14, 0, 0, 14150, 14151, 7, 6, 0, 0, 14151, 14152, + 7, 9, 0, 0, 14152, 1850, 1, 0, 0, 0, 14153, 14154, 7, 7, 0, 0, 14154, 14155, + 7, 0, 0, 0, 14155, 14156, 7, 14, 0, 0, 14156, 14157, 7, 6, 0, 0, 14157, + 1852, 1, 0, 0, 0, 14158, 14159, 7, 7, 0, 0, 14159, 14160, 7, 0, 0, 0, 14160, + 14161, 7, 14, 0, 0, 14161, 14162, 7, 6, 0, 0, 14162, 14163, 7, 5, 0, 0, + 14163, 14164, 7, 15, 0, 0, 14164, 14165, 7, 0, 0, 0, 14165, 14166, 7, 8, + 0, 0, 14166, 14167, 7, 6, 0, 0, 14167, 1854, 1, 0, 0, 0, 14168, 14169, + 7, 7, 0, 0, 14169, 14170, 7, 0, 0, 0, 14170, 14171, 7, 7, 0, 0, 14171, + 1856, 1, 0, 0, 0, 14172, 14173, 7, 7, 0, 0, 14173, 14174, 7, 0, 0, 0, 14174, + 14175, 7, 7, 0, 0, 14175, 14176, 7, 13, 0, 0, 14176, 14177, 7, 11, 0, 0, + 14177, 1858, 1, 0, 0, 0, 14178, 14179, 7, 7, 0, 0, 14179, 14180, 7, 0, + 0, 0, 14180, 14181, 7, 4, 0, 0, 14181, 14182, 7, 12, 0, 0, 14182, 14183, + 7, 2, 0, 0, 14183, 14184, 7, 7, 0, 0, 14184, 14185, 7, 0, 0, 0, 14185, + 14186, 7, 11, 0, 0, 14186, 1860, 1, 0, 0, 0, 14187, 14188, 7, 7, 0, 0, + 14188, 14189, 7, 0, 0, 0, 14189, 14190, 7, 4, 0, 0, 14190, 14191, 7, 12, + 0, 0, 14191, 14192, 7, 13, 0, 0, 14192, 14193, 7, 6, 0, 0, 14193, 14194, + 5, 95, 0, 0, 14194, 14195, 7, 16, 0, 0, 14195, 14196, 7, 10, 0, 0, 14196, + 14197, 7, 11, 0, 0, 14197, 14198, 7, 11, 0, 0, 14198, 14199, 5, 95, 0, + 0, 14199, 14200, 7, 2, 0, 0, 14200, 14201, 7, 10, 0, 0, 14201, 14202, 7, + 4, 0, 0, 14202, 14203, 7, 6, 0, 0, 14203, 14204, 7, 3, 0, 0, 14204, 14205, + 5, 95, 0, 0, 14205, 14206, 7, 20, 0, 0, 14206, 14207, 7, 2, 0, 0, 14207, + 14208, 7, 12, 0, 0, 14208, 14209, 7, 7, 0, 0, 14209, 1862, 1, 0, 0, 0, + 14210, 14211, 7, 7, 0, 0, 14211, 14212, 7, 0, 0, 0, 14212, 14213, 7, 4, + 0, 0, 14213, 14214, 7, 12, 0, 0, 14214, 14215, 7, 13, 0, 0, 14215, 14216, + 7, 6, 0, 0, 14216, 1864, 1, 0, 0, 0, 14217, 14218, 7, 7, 0, 0, 14218, 14219, + 7, 0, 0, 0, 14219, 14220, 7, 4, 0, 0, 14220, 14221, 7, 10, 0, 0, 14221, + 14222, 7, 3, 0, 0, 14222, 14223, 7, 0, 0, 0, 14223, 14224, 7, 11, 0, 0, + 14224, 1866, 1, 0, 0, 0, 14225, 14226, 7, 7, 0, 0, 14226, 14227, 7, 0, + 0, 0, 14227, 14228, 7, 4, 0, 0, 14228, 14229, 7, 10, 0, 0, 14229, 14230, + 7, 3, 0, 0, 14230, 14231, 7, 0, 0, 0, 14231, 14232, 7, 11, 0, 0, 14232, + 14233, 7, 7, 0, 0, 14233, 1868, 1, 0, 0, 0, 14234, 14235, 7, 7, 0, 0, 14235, + 14236, 7, 0, 0, 0, 14236, 14237, 7, 13, 0, 0, 14237, 1870, 1, 0, 0, 0, + 14238, 14239, 7, 7, 0, 0, 14239, 14240, 7, 8, 0, 0, 14240, 14241, 7, 19, + 0, 0, 14241, 14242, 7, 0, 0, 0, 14242, 14243, 7, 3, 0, 0, 14243, 14244, + 5, 95, 0, 0, 14244, 14245, 7, 8, 0, 0, 14245, 14246, 7, 5, 0, 0, 14246, + 1872, 1, 0, 0, 0, 14247, 14248, 7, 7, 0, 0, 14248, 14249, 7, 8, 0, 0, 14249, + 14250, 7, 19, 0, 0, 14250, 14251, 7, 0, 0, 0, 14251, 14252, 7, 3, 0, 0, + 14252, 1874, 1, 0, 0, 0, 14253, 14254, 7, 7, 0, 0, 14254, 14255, 7, 8, + 0, 0, 14255, 14256, 7, 19, 0, 0, 14256, 14257, 7, 3, 0, 0, 14257, 1876, + 1, 0, 0, 0, 14258, 14259, 7, 7, 0, 0, 14259, 14260, 7, 8, 0, 0, 14260, + 14261, 7, 11, 0, 0, 14261, 14262, 7, 2, 0, 0, 14262, 14263, 7, 1, 0, 0, + 14263, 1878, 1, 0, 0, 0, 14264, 14265, 7, 7, 0, 0, 14265, 14266, 7, 6, + 0, 0, 14266, 14267, 7, 6, 0, 0, 14267, 14268, 7, 9, 0, 0, 14268, 14269, + 7, 6, 0, 0, 14269, 14270, 7, 9, 0, 0, 14270, 1880, 1, 0, 0, 0, 14271, 14272, + 7, 7, 0, 0, 14272, 14273, 7, 6, 0, 0, 14273, 14274, 7, 17, 0, 0, 14274, + 1882, 1, 0, 0, 0, 14275, 14276, 7, 7, 0, 0, 14276, 14277, 7, 6, 0, 0, 14277, + 14278, 7, 5, 0, 0, 14278, 14279, 7, 4, 0, 0, 14279, 14280, 7, 6, 0, 0, + 14280, 14281, 7, 9, 0, 0, 14281, 1884, 1, 0, 0, 0, 14282, 14283, 7, 7, + 0, 0, 14283, 14284, 7, 6, 0, 0, 14284, 14285, 7, 5, 0, 0, 14285, 14286, + 7, 4, 0, 0, 14286, 14287, 7, 6, 0, 0, 14287, 14288, 7, 9, 0, 0, 14288, + 14289, 5, 95, 0, 0, 14289, 14290, 7, 4, 0, 0, 14290, 14291, 7, 0, 0, 0, + 14291, 14292, 7, 1, 0, 0, 14292, 14293, 7, 11, 0, 0, 14293, 14294, 7, 6, + 0, 0, 14294, 14295, 5, 95, 0, 0, 14295, 14296, 7, 16, 0, 0, 14296, 14297, + 7, 0, 0, 0, 14297, 14298, 7, 5, 0, 0, 14298, 14299, 7, 4, 0, 0, 14299, + 14300, 5, 95, 0, 0, 14300, 14301, 7, 12, 0, 0, 14301, 14302, 7, 7, 0, 0, + 14302, 14303, 7, 5, 0, 0, 14303, 14304, 7, 6, 0, 0, 14304, 14305, 7, 3, + 0, 0, 14305, 14306, 7, 4, 0, 0, 14306, 1886, 1, 0, 0, 0, 14307, 14308, + 7, 7, 0, 0, 14308, 14309, 7, 6, 0, 0, 14309, 14310, 7, 5, 0, 0, 14310, + 14311, 7, 4, 0, 0, 14311, 14312, 7, 6, 0, 0, 14312, 14313, 7, 9, 0, 0, + 14313, 14314, 5, 95, 0, 0, 14314, 14315, 7, 4, 0, 0, 14315, 14316, 7, 0, + 0, 0, 14316, 14317, 7, 1, 0, 0, 14317, 14318, 7, 11, 0, 0, 14318, 14319, + 7, 6, 0, 0, 14319, 14320, 5, 95, 0, 0, 14320, 14321, 7, 17, 0, 0, 14321, + 14322, 7, 6, 0, 0, 14322, 14323, 7, 4, 0, 0, 14323, 14324, 5, 95, 0, 0, + 14324, 14325, 7, 3, 0, 0, 14325, 14326, 7, 6, 0, 0, 14326, 14327, 7, 16, + 0, 0, 14327, 14328, 7, 5, 0, 0, 14328, 1888, 1, 0, 0, 0, 14329, 14330, + 7, 7, 0, 0, 14330, 14331, 7, 6, 0, 0, 14331, 14332, 7, 5, 0, 0, 14332, + 14333, 7, 4, 0, 0, 14333, 14334, 7, 6, 0, 0, 14334, 14335, 7, 9, 0, 0, + 14335, 14336, 5, 95, 0, 0, 14336, 14337, 7, 4, 0, 0, 14337, 14338, 7, 0, + 0, 0, 14338, 14339, 7, 1, 0, 0, 14339, 14340, 7, 11, 0, 0, 14340, 14341, + 7, 6, 0, 0, 14341, 14342, 5, 95, 0, 0, 14342, 14343, 7, 12, 0, 0, 14343, + 14344, 7, 9, 0, 0, 14344, 1890, 1, 0, 0, 0, 14345, 14346, 7, 7, 0, 0, 14346, + 14347, 7, 6, 0, 0, 14347, 14348, 7, 5, 0, 0, 14348, 14349, 7, 4, 0, 0, + 14349, 14350, 7, 6, 0, 0, 14350, 14351, 7, 9, 0, 0, 14351, 14352, 5, 95, + 0, 0, 14352, 14353, 7, 4, 0, 0, 14353, 14354, 7, 0, 0, 0, 14354, 14355, + 7, 1, 0, 0, 14355, 14356, 7, 11, 0, 0, 14356, 14357, 7, 6, 0, 0, 14357, + 14358, 5, 95, 0, 0, 14358, 14359, 7, 5, 0, 0, 14359, 14360, 7, 6, 0, 0, + 14360, 14361, 7, 4, 0, 0, 14361, 14362, 5, 95, 0, 0, 14362, 14363, 7, 3, + 0, 0, 14363, 14364, 7, 6, 0, 0, 14364, 14365, 7, 16, 0, 0, 14365, 14366, + 7, 5, 0, 0, 14366, 1892, 1, 0, 0, 0, 14367, 14368, 7, 7, 0, 0, 14368, 14369, + 7, 6, 0, 0, 14369, 14370, 7, 5, 0, 0, 14370, 14371, 7, 4, 0, 0, 14371, + 14372, 7, 6, 0, 0, 14372, 14373, 7, 9, 0, 0, 14373, 14374, 5, 95, 0, 0, + 14374, 14375, 7, 4, 0, 0, 14375, 14376, 7, 0, 0, 0, 14376, 14377, 7, 1, + 0, 0, 14377, 14378, 7, 11, 0, 0, 14378, 14379, 7, 6, 0, 0, 14379, 14380, + 5, 95, 0, 0, 14380, 14381, 7, 5, 0, 0, 14381, 14382, 7, 6, 0, 0, 14382, + 14383, 7, 4, 0, 0, 14383, 14384, 5, 95, 0, 0, 14384, 14385, 7, 5, 0, 0, + 14385, 14386, 7, 6, 0, 0, 14386, 14387, 7, 4, 0, 0, 14387, 14388, 7, 12, + 0, 0, 14388, 14389, 7, 9, 0, 0, 14389, 1894, 1, 0, 0, 0, 14390, 14391, + 7, 7, 0, 0, 14391, 14392, 7, 6, 0, 0, 14392, 14393, 7, 4, 0, 0, 14393, + 14394, 7, 22, 0, 0, 14394, 14395, 7, 2, 0, 0, 14395, 14396, 7, 3, 0, 0, + 14396, 14397, 7, 21, 0, 0, 14397, 1896, 1, 0, 0, 0, 14398, 14399, 7, 7, + 0, 0, 14399, 14400, 7, 6, 0, 0, 14400, 14401, 7, 13, 0, 0, 14401, 14402, + 7, 6, 0, 0, 14402, 14403, 7, 3, 0, 0, 14403, 1898, 1, 0, 0, 0, 14404, 14405, + 7, 7, 0, 0, 14405, 14406, 7, 6, 0, 0, 14406, 14407, 7, 22, 0, 0, 14407, + 1900, 1, 0, 0, 0, 14408, 14409, 7, 7, 0, 0, 14409, 14410, 7, 6, 0, 0, 14410, + 14411, 7, 22, 0, 0, 14411, 14412, 5, 95, 0, 0, 14412, 14413, 7, 4, 0, 0, + 14413, 14414, 7, 12, 0, 0, 14414, 14415, 7, 14, 0, 0, 14415, 14416, 7, + 6, 0, 0, 14416, 1902, 1, 0, 0, 0, 14417, 14418, 7, 7, 0, 0, 14418, 14419, + 7, 6, 0, 0, 14419, 14420, 7, 25, 0, 0, 14420, 14421, 7, 4, 0, 0, 14421, + 14422, 5, 95, 0, 0, 14422, 14423, 7, 9, 0, 0, 14423, 14424, 7, 0, 0, 0, + 14424, 14425, 7, 18, 0, 0, 14425, 1904, 1, 0, 0, 0, 14426, 14427, 7, 7, + 0, 0, 14427, 14428, 7, 6, 0, 0, 14428, 14429, 7, 25, 0, 0, 14429, 14430, + 7, 4, 0, 0, 14430, 1906, 1, 0, 0, 0, 14431, 14432, 7, 7, 0, 0, 14432, 14433, + 7, 11, 0, 0, 14433, 14434, 5, 95, 0, 0, 14434, 14435, 7, 0, 0, 0, 14435, + 14436, 7, 20, 0, 0, 14436, 1908, 1, 0, 0, 0, 14437, 14438, 7, 7, 0, 0, + 14438, 14439, 7, 11, 0, 0, 14439, 14440, 7, 20, 0, 0, 14440, 14441, 5, + 95, 0, 0, 14441, 14442, 7, 1, 0, 0, 14442, 14443, 7, 0, 0, 0, 14443, 14444, + 7, 4, 0, 0, 14444, 14445, 7, 8, 0, 0, 14445, 14446, 7, 19, 0, 0, 14446, + 14447, 7, 12, 0, 0, 14447, 14448, 7, 7, 0, 0, 14448, 14449, 7, 17, 0, 0, + 14449, 1910, 1, 0, 0, 0, 14450, 14451, 7, 7, 0, 0, 14451, 14452, 7, 11, + 0, 0, 14452, 14453, 7, 20, 0, 0, 14453, 14454, 5, 95, 0, 0, 14454, 14455, + 7, 12, 0, 0, 14455, 14456, 7, 7, 0, 0, 14456, 14457, 7, 9, 0, 0, 14457, + 14458, 7, 6, 0, 0, 14458, 14459, 7, 25, 0, 0, 14459, 14460, 5, 95, 0, 0, + 14460, 14461, 7, 16, 0, 0, 14461, 14462, 7, 12, 0, 0, 14462, 14463, 7, + 11, 0, 0, 14463, 14464, 7, 4, 0, 0, 14464, 14465, 7, 6, 0, 0, 14465, 14466, + 7, 3, 0, 0, 14466, 1912, 1, 0, 0, 0, 14467, 14468, 7, 7, 0, 0, 14468, 14469, + 7, 11, 0, 0, 14469, 14470, 7, 20, 0, 0, 14470, 14471, 5, 95, 0, 0, 14471, + 14472, 7, 12, 0, 0, 14472, 14473, 7, 7, 0, 0, 14473, 14474, 7, 9, 0, 0, + 14474, 14475, 7, 6, 0, 0, 14475, 14476, 7, 25, 0, 0, 14476, 14477, 5, 95, + 0, 0, 14477, 14478, 7, 5, 0, 0, 14478, 14479, 7, 8, 0, 0, 14479, 14480, + 7, 0, 0, 0, 14480, 14481, 7, 7, 0, 0, 14481, 1914, 1, 0, 0, 0, 14482, 14483, + 7, 7, 0, 0, 14483, 14484, 7, 11, 0, 0, 14484, 14485, 7, 20, 0, 0, 14485, + 14486, 5, 95, 0, 0, 14486, 14487, 7, 15, 0, 0, 14487, 14488, 7, 3, 0, 0, + 14488, 14489, 7, 6, 0, 0, 14489, 14490, 7, 16, 0, 0, 14490, 14491, 7, 6, + 0, 0, 14491, 14492, 7, 4, 0, 0, 14492, 14493, 7, 8, 0, 0, 14493, 14494, + 7, 19, 0, 0, 14494, 1916, 1, 0, 0, 0, 14495, 14496, 7, 7, 0, 0, 14496, + 14497, 7, 11, 0, 0, 14497, 14498, 7, 5, 0, 0, 14498, 14499, 5, 95, 0, 0, + 14499, 14500, 7, 8, 0, 0, 14500, 14501, 7, 0, 0, 0, 14501, 14502, 7, 11, + 0, 0, 14502, 14503, 7, 6, 0, 0, 14503, 14504, 7, 7, 0, 0, 14504, 14505, + 7, 9, 0, 0, 14505, 14506, 7, 0, 0, 0, 14506, 14507, 7, 3, 0, 0, 14507, + 1918, 1, 0, 0, 0, 14508, 14509, 7, 7, 0, 0, 14509, 14510, 7, 11, 0, 0, + 14510, 14511, 7, 5, 0, 0, 14511, 14512, 5, 95, 0, 0, 14512, 14513, 7, 8, + 0, 0, 14513, 14514, 7, 19, 0, 0, 14514, 14515, 7, 0, 0, 0, 14515, 14516, + 7, 3, 0, 0, 14516, 14517, 7, 0, 0, 0, 14517, 14518, 7, 8, 0, 0, 14518, + 14519, 7, 4, 0, 0, 14519, 14520, 7, 6, 0, 0, 14520, 14521, 7, 3, 0, 0, + 14521, 14522, 7, 5, 0, 0, 14522, 14523, 7, 6, 0, 0, 14523, 14524, 7, 4, + 0, 0, 14524, 1920, 1, 0, 0, 0, 14525, 14526, 7, 7, 0, 0, 14526, 14527, + 7, 11, 0, 0, 14527, 14528, 7, 5, 0, 0, 14528, 14529, 5, 95, 0, 0, 14529, + 14530, 7, 8, 0, 0, 14530, 14531, 7, 19, 0, 0, 14531, 14532, 7, 0, 0, 0, + 14532, 14533, 7, 3, 0, 0, 14533, 14534, 7, 5, 0, 0, 14534, 14535, 7, 6, + 0, 0, 14535, 14536, 7, 4, 0, 0, 14536, 14537, 5, 95, 0, 0, 14537, 14538, + 7, 9, 0, 0, 14538, 14539, 7, 6, 0, 0, 14539, 14540, 7, 8, 0, 0, 14540, + 14541, 7, 11, 0, 0, 14541, 14542, 5, 95, 0, 0, 14542, 14543, 7, 11, 0, + 0, 14543, 14544, 7, 6, 0, 0, 14544, 14545, 7, 7, 0, 0, 14545, 1922, 1, + 0, 0, 0, 14546, 14547, 7, 7, 0, 0, 14547, 14548, 7, 11, 0, 0, 14548, 14549, + 7, 5, 0, 0, 14549, 14550, 5, 95, 0, 0, 14550, 14551, 7, 8, 0, 0, 14551, + 14552, 7, 19, 0, 0, 14552, 14553, 7, 0, 0, 0, 14553, 14554, 7, 3, 0, 0, + 14554, 14555, 7, 5, 0, 0, 14555, 14556, 7, 6, 0, 0, 14556, 14557, 7, 4, + 0, 0, 14557, 14558, 5, 95, 0, 0, 14558, 14559, 7, 12, 0, 0, 14559, 14560, + 7, 9, 0, 0, 14560, 1924, 1, 0, 0, 0, 14561, 14562, 7, 7, 0, 0, 14562, 14563, + 7, 11, 0, 0, 14563, 14564, 7, 5, 0, 0, 14564, 14565, 5, 95, 0, 0, 14565, + 14566, 7, 8, 0, 0, 14566, 14567, 7, 19, 0, 0, 14567, 14568, 7, 0, 0, 0, + 14568, 14569, 7, 3, 0, 0, 14569, 14570, 7, 5, 0, 0, 14570, 14571, 7, 6, + 0, 0, 14571, 14572, 7, 4, 0, 0, 14572, 14573, 5, 95, 0, 0, 14573, 14574, + 7, 7, 0, 0, 14574, 14575, 7, 0, 0, 0, 14575, 14576, 7, 14, 0, 0, 14576, + 14577, 7, 6, 0, 0, 14577, 1926, 1, 0, 0, 0, 14578, 14579, 7, 7, 0, 0, 14579, + 14580, 7, 11, 0, 0, 14580, 14581, 7, 5, 0, 0, 14581, 14582, 5, 95, 0, 0, + 14582, 14583, 7, 8, 0, 0, 14583, 14584, 7, 2, 0, 0, 14584, 14585, 7, 14, + 0, 0, 14585, 14586, 7, 15, 0, 0, 14586, 1928, 1, 0, 0, 0, 14587, 14588, + 7, 7, 0, 0, 14588, 14589, 7, 11, 0, 0, 14589, 14590, 7, 5, 0, 0, 14590, + 14591, 5, 95, 0, 0, 14591, 14592, 7, 8, 0, 0, 14592, 14593, 7, 10, 0, 0, + 14593, 14594, 7, 3, 0, 0, 14594, 14595, 7, 3, 0, 0, 14595, 14596, 7, 6, + 0, 0, 14596, 14597, 7, 7, 0, 0, 14597, 14598, 7, 8, 0, 0, 14598, 14599, + 7, 18, 0, 0, 14599, 1930, 1, 0, 0, 0, 14600, 14601, 7, 7, 0, 0, 14601, + 14602, 7, 11, 0, 0, 14602, 14603, 7, 5, 0, 0, 14603, 14604, 5, 95, 0, 0, + 14604, 14605, 7, 9, 0, 0, 14605, 14606, 7, 0, 0, 0, 14606, 14607, 7, 4, + 0, 0, 14607, 14608, 7, 6, 0, 0, 14608, 14609, 5, 95, 0, 0, 14609, 14610, + 7, 16, 0, 0, 14610, 14611, 7, 2, 0, 0, 14611, 14612, 7, 3, 0, 0, 14612, + 14613, 7, 14, 0, 0, 14613, 14614, 7, 0, 0, 0, 14614, 14615, 7, 4, 0, 0, + 14615, 1932, 1, 0, 0, 0, 14616, 14617, 7, 7, 0, 0, 14617, 14618, 7, 11, + 0, 0, 14618, 14619, 7, 5, 0, 0, 14619, 14620, 5, 95, 0, 0, 14620, 14621, + 7, 9, 0, 0, 14621, 14622, 7, 0, 0, 0, 14622, 14623, 7, 4, 0, 0, 14623, + 14624, 7, 6, 0, 0, 14624, 14625, 5, 95, 0, 0, 14625, 14626, 7, 11, 0, 0, + 14626, 14627, 7, 0, 0, 0, 14627, 14628, 7, 7, 0, 0, 14628, 14629, 7, 17, + 0, 0, 14629, 14630, 7, 10, 0, 0, 14630, 14631, 7, 0, 0, 0, 14631, 14632, + 7, 17, 0, 0, 14632, 14633, 7, 6, 0, 0, 14633, 1934, 1, 0, 0, 0, 14634, + 14635, 7, 7, 0, 0, 14635, 14636, 7, 11, 0, 0, 14636, 14637, 7, 5, 0, 0, + 14637, 14638, 5, 95, 0, 0, 14638, 14639, 7, 12, 0, 0, 14639, 14640, 7, + 7, 0, 0, 14640, 14641, 7, 12, 0, 0, 14641, 14642, 7, 4, 0, 0, 14642, 14643, + 7, 8, 0, 0, 14643, 14644, 7, 0, 0, 0, 14644, 14645, 7, 15, 0, 0, 14645, + 1936, 1, 0, 0, 0, 14646, 14647, 7, 7, 0, 0, 14647, 14648, 7, 11, 0, 0, + 14648, 14649, 7, 5, 0, 0, 14649, 14650, 5, 95, 0, 0, 14650, 14651, 7, 12, + 0, 0, 14651, 14652, 7, 5, 0, 0, 14652, 14653, 7, 2, 0, 0, 14653, 14654, + 5, 95, 0, 0, 14654, 14655, 7, 8, 0, 0, 14655, 14656, 7, 10, 0, 0, 14656, + 14657, 7, 3, 0, 0, 14657, 14658, 7, 3, 0, 0, 14658, 14659, 7, 6, 0, 0, + 14659, 14660, 7, 7, 0, 0, 14660, 14661, 7, 8, 0, 0, 14661, 14662, 7, 18, + 0, 0, 14662, 1938, 1, 0, 0, 0, 14663, 14664, 7, 7, 0, 0, 14664, 14665, + 7, 11, 0, 0, 14665, 14666, 5, 95, 0, 0, 14666, 14667, 7, 5, 0, 0, 14667, + 14668, 7, 20, 0, 0, 14668, 1940, 1, 0, 0, 0, 14669, 14670, 7, 7, 0, 0, + 14670, 14671, 7, 11, 0, 0, 14671, 14672, 7, 5, 0, 0, 14672, 14673, 5, 95, + 0, 0, 14673, 14674, 7, 11, 0, 0, 14674, 14675, 7, 0, 0, 0, 14675, 14676, + 7, 7, 0, 0, 14676, 14677, 7, 17, 0, 0, 14677, 1942, 1, 0, 0, 0, 14678, + 14679, 7, 7, 0, 0, 14679, 14680, 7, 11, 0, 0, 14680, 14681, 7, 5, 0, 0, + 14681, 14682, 5, 95, 0, 0, 14682, 14683, 7, 11, 0, 0, 14683, 14684, 7, + 0, 0, 0, 14684, 14685, 7, 7, 0, 0, 14685, 14686, 7, 17, 0, 0, 14686, 14687, + 7, 10, 0, 0, 14687, 14688, 7, 0, 0, 0, 14688, 14689, 7, 17, 0, 0, 14689, + 14690, 7, 6, 0, 0, 14690, 1944, 1, 0, 0, 0, 14691, 14692, 7, 7, 0, 0, 14692, + 14693, 7, 11, 0, 0, 14693, 14694, 7, 5, 0, 0, 14694, 14695, 5, 95, 0, 0, + 14695, 14696, 7, 11, 0, 0, 14696, 14697, 7, 6, 0, 0, 14697, 14698, 7, 7, + 0, 0, 14698, 14699, 7, 17, 0, 0, 14699, 14700, 7, 4, 0, 0, 14700, 14701, + 7, 19, 0, 0, 14701, 14702, 5, 95, 0, 0, 14702, 14703, 7, 5, 0, 0, 14703, + 14704, 7, 6, 0, 0, 14704, 14705, 7, 14, 0, 0, 14705, 14706, 7, 0, 0, 0, + 14706, 14707, 7, 7, 0, 0, 14707, 14708, 7, 4, 0, 0, 14708, 14709, 7, 12, + 0, 0, 14709, 14710, 7, 8, 0, 0, 14710, 14711, 7, 5, 0, 0, 14711, 1946, + 1, 0, 0, 0, 14712, 14713, 7, 7, 0, 0, 14713, 14714, 7, 11, 0, 0, 14714, + 14715, 7, 5, 0, 0, 14715, 14716, 5, 95, 0, 0, 14716, 14717, 7, 11, 0, 0, + 14717, 14718, 7, 2, 0, 0, 14718, 14719, 7, 22, 0, 0, 14719, 14720, 7, 6, + 0, 0, 14720, 14721, 7, 3, 0, 0, 14721, 1948, 1, 0, 0, 0, 14722, 14723, + 7, 7, 0, 0, 14723, 14724, 7, 11, 0, 0, 14724, 14725, 7, 5, 0, 0, 14725, + 14726, 5, 95, 0, 0, 14726, 14727, 7, 7, 0, 0, 14727, 14728, 7, 8, 0, 0, + 14728, 14729, 7, 19, 0, 0, 14729, 14730, 7, 0, 0, 0, 14730, 14731, 7, 3, + 0, 0, 14731, 14732, 5, 95, 0, 0, 14732, 14733, 7, 8, 0, 0, 14733, 14734, + 7, 2, 0, 0, 14734, 14735, 7, 7, 0, 0, 14735, 14736, 7, 13, 0, 0, 14736, + 14737, 5, 95, 0, 0, 14737, 14738, 7, 6, 0, 0, 14738, 14739, 7, 25, 0, 0, + 14739, 14740, 7, 8, 0, 0, 14740, 14741, 7, 15, 0, 0, 14741, 1950, 1, 0, + 0, 0, 14742, 14743, 7, 7, 0, 0, 14743, 14744, 7, 11, 0, 0, 14744, 14745, + 7, 5, 0, 0, 14745, 14746, 5, 95, 0, 0, 14746, 14747, 7, 7, 0, 0, 14747, + 14748, 7, 10, 0, 0, 14748, 14749, 7, 14, 0, 0, 14749, 14750, 7, 6, 0, 0, + 14750, 14751, 7, 3, 0, 0, 14751, 14752, 7, 12, 0, 0, 14752, 14753, 7, 8, + 0, 0, 14753, 14754, 5, 95, 0, 0, 14754, 14755, 7, 8, 0, 0, 14755, 14756, + 7, 19, 0, 0, 14756, 14757, 7, 0, 0, 0, 14757, 14758, 7, 3, 0, 0, 14758, + 14759, 7, 0, 0, 0, 14759, 14760, 7, 8, 0, 0, 14760, 14761, 7, 4, 0, 0, + 14761, 14762, 7, 6, 0, 0, 14762, 14763, 7, 3, 0, 0, 14763, 14764, 7, 5, + 0, 0, 14764, 1952, 1, 0, 0, 0, 14765, 14766, 7, 7, 0, 0, 14766, 14767, + 7, 11, 0, 0, 14767, 14768, 7, 5, 0, 0, 14768, 14769, 5, 95, 0, 0, 14769, + 14770, 7, 5, 0, 0, 14770, 14771, 7, 2, 0, 0, 14771, 14772, 7, 3, 0, 0, + 14772, 14773, 7, 4, 0, 0, 14773, 1954, 1, 0, 0, 0, 14774, 14775, 7, 7, + 0, 0, 14775, 14776, 7, 11, 0, 0, 14776, 14777, 7, 5, 0, 0, 14777, 14778, + 7, 5, 0, 0, 14778, 14779, 7, 2, 0, 0, 14779, 14780, 7, 3, 0, 0, 14780, + 14781, 7, 4, 0, 0, 14781, 1956, 1, 0, 0, 0, 14782, 14783, 7, 7, 0, 0, 14783, + 14784, 7, 11, 0, 0, 14784, 14785, 7, 5, 0, 0, 14785, 14786, 5, 95, 0, 0, + 14786, 14787, 7, 5, 0, 0, 14787, 14788, 7, 15, 0, 0, 14788, 14789, 7, 6, + 0, 0, 14789, 14790, 7, 8, 0, 0, 14790, 14791, 7, 12, 0, 0, 14791, 14792, + 7, 0, 0, 0, 14792, 14793, 7, 11, 0, 0, 14793, 14794, 5, 95, 0, 0, 14794, + 14795, 7, 8, 0, 0, 14795, 14796, 7, 19, 0, 0, 14796, 14797, 7, 0, 0, 0, + 14797, 14798, 7, 3, 0, 0, 14798, 14799, 7, 5, 0, 0, 14799, 1958, 1, 0, + 0, 0, 14800, 14801, 7, 7, 0, 0, 14801, 14802, 7, 11, 0, 0, 14802, 14803, + 7, 5, 0, 0, 14803, 14804, 5, 95, 0, 0, 14804, 14805, 7, 4, 0, 0, 14805, + 14806, 7, 6, 0, 0, 14806, 14807, 7, 3, 0, 0, 14807, 14808, 7, 3, 0, 0, + 14808, 14809, 7, 12, 0, 0, 14809, 14810, 7, 4, 0, 0, 14810, 14811, 7, 2, + 0, 0, 14811, 14812, 7, 3, 0, 0, 14812, 14813, 7, 18, 0, 0, 14813, 1960, + 1, 0, 0, 0, 14814, 14815, 7, 7, 0, 0, 14815, 14816, 7, 11, 0, 0, 14816, + 14817, 7, 5, 0, 0, 14817, 14818, 5, 95, 0, 0, 14818, 14819, 7, 10, 0, 0, + 14819, 14820, 7, 15, 0, 0, 14820, 14821, 7, 15, 0, 0, 14821, 14822, 7, + 6, 0, 0, 14822, 14823, 7, 3, 0, 0, 14823, 1962, 1, 0, 0, 0, 14824, 14825, + 7, 7, 0, 0, 14825, 14826, 7, 2, 0, 0, 14826, 14827, 5, 95, 0, 0, 14827, + 14828, 7, 0, 0, 0, 14828, 14829, 7, 8, 0, 0, 14829, 14830, 7, 8, 0, 0, + 14830, 14831, 7, 6, 0, 0, 14831, 14832, 7, 5, 0, 0, 14832, 14833, 7, 5, + 0, 0, 14833, 1964, 1, 0, 0, 0, 14834, 14835, 7, 7, 0, 0, 14835, 14836, + 7, 2, 0, 0, 14836, 14837, 5, 95, 0, 0, 14837, 14838, 7, 0, 0, 0, 14838, + 14839, 7, 9, 0, 0, 14839, 14840, 7, 0, 0, 0, 14840, 14841, 7, 15, 0, 0, + 14841, 14842, 7, 4, 0, 0, 14842, 14843, 7, 12, 0, 0, 14843, 14844, 7, 13, + 0, 0, 14844, 14845, 7, 6, 0, 0, 14845, 14846, 5, 95, 0, 0, 14846, 14847, + 7, 15, 0, 0, 14847, 14848, 7, 11, 0, 0, 14848, 14849, 7, 0, 0, 0, 14849, + 14850, 7, 7, 0, 0, 14850, 1966, 1, 0, 0, 0, 14851, 14852, 7, 7, 0, 0, 14852, + 14853, 7, 2, 0, 0, 14853, 14854, 5, 95, 0, 0, 14854, 14855, 7, 0, 0, 0, + 14855, 14856, 7, 7, 0, 0, 14856, 14857, 7, 5, 0, 0, 14857, 14858, 7, 12, + 0, 0, 14858, 14859, 5, 95, 0, 0, 14859, 14860, 7, 3, 0, 0, 14860, 14861, + 7, 6, 0, 0, 14861, 14862, 7, 0, 0, 0, 14862, 14863, 7, 3, 0, 0, 14863, + 14864, 7, 8, 0, 0, 14864, 14865, 7, 19, 0, 0, 14865, 1968, 1, 0, 0, 0, + 14866, 14867, 7, 7, 0, 0, 14867, 14868, 7, 2, 0, 0, 14868, 14869, 7, 0, + 0, 0, 14869, 14870, 7, 15, 0, 0, 14870, 14871, 7, 15, 0, 0, 14871, 14872, + 7, 6, 0, 0, 14872, 14873, 7, 7, 0, 0, 14873, 14874, 7, 9, 0, 0, 14874, + 1970, 1, 0, 0, 0, 14875, 14876, 7, 7, 0, 0, 14876, 14877, 7, 2, 0, 0, 14877, + 14878, 7, 0, 0, 0, 14878, 14879, 7, 3, 0, 0, 14879, 14880, 7, 8, 0, 0, + 14880, 14881, 7, 19, 0, 0, 14881, 14882, 7, 12, 0, 0, 14882, 14883, 7, + 13, 0, 0, 14883, 14884, 7, 6, 0, 0, 14884, 14885, 7, 11, 0, 0, 14885, 14886, + 7, 2, 0, 0, 14886, 14887, 7, 17, 0, 0, 14887, 1972, 1, 0, 0, 0, 14888, + 14889, 7, 7, 0, 0, 14889, 14890, 7, 2, 0, 0, 14890, 14891, 7, 0, 0, 0, + 14891, 14892, 7, 10, 0, 0, 14892, 14893, 7, 9, 0, 0, 14893, 14894, 7, 12, + 0, 0, 14894, 14895, 7, 4, 0, 0, 14895, 1974, 1, 0, 0, 0, 14896, 14897, + 7, 7, 0, 0, 14897, 14898, 7, 2, 0, 0, 14898, 14899, 5, 95, 0, 0, 14899, + 14900, 7, 0, 0, 0, 14900, 14901, 7, 10, 0, 0, 14901, 14902, 7, 4, 0, 0, + 14902, 14903, 7, 2, 0, 0, 14903, 14904, 5, 95, 0, 0, 14904, 14905, 7, 3, + 0, 0, 14905, 14906, 7, 6, 0, 0, 14906, 14907, 7, 2, 0, 0, 14907, 14908, + 7, 15, 0, 0, 14908, 14909, 7, 4, 0, 0, 14909, 14910, 7, 12, 0, 0, 14910, + 14911, 7, 14, 0, 0, 14911, 14912, 7, 12, 0, 0, 14912, 14913, 7, 23, 0, + 0, 14913, 14914, 7, 6, 0, 0, 14914, 1976, 1, 0, 0, 0, 14915, 14916, 7, + 7, 0, 0, 14916, 14917, 7, 2, 0, 0, 14917, 14918, 5, 95, 0, 0, 14918, 14919, + 7, 1, 0, 0, 14919, 14920, 7, 0, 0, 0, 14920, 14921, 7, 5, 0, 0, 14921, + 14922, 7, 6, 0, 0, 14922, 14923, 7, 4, 0, 0, 14923, 14924, 7, 0, 0, 0, + 14924, 14925, 7, 1, 0, 0, 14925, 14926, 7, 11, 0, 0, 14926, 14927, 7, 6, + 0, 0, 14927, 14928, 5, 95, 0, 0, 14928, 14929, 7, 14, 0, 0, 14929, 14930, + 7, 10, 0, 0, 14930, 14931, 7, 11, 0, 0, 14931, 14932, 7, 4, 0, 0, 14932, + 14933, 7, 12, 0, 0, 14933, 14934, 7, 14, 0, 0, 14934, 14935, 7, 13, 0, + 0, 14935, 14936, 5, 95, 0, 0, 14936, 14937, 7, 3, 0, 0, 14937, 14938, 7, + 6, 0, 0, 14938, 14939, 7, 22, 0, 0, 14939, 14940, 7, 3, 0, 0, 14940, 14941, + 7, 12, 0, 0, 14941, 14942, 7, 4, 0, 0, 14942, 14943, 7, 6, 0, 0, 14943, + 1978, 1, 0, 0, 0, 14944, 14945, 7, 7, 0, 0, 14945, 14946, 7, 2, 0, 0, 14946, + 14947, 5, 95, 0, 0, 14947, 14948, 7, 1, 0, 0, 14948, 14949, 7, 0, 0, 0, + 14949, 14950, 7, 4, 0, 0, 14950, 14951, 7, 8, 0, 0, 14951, 14952, 7, 19, + 0, 0, 14952, 14953, 5, 95, 0, 0, 14953, 14954, 7, 4, 0, 0, 14954, 14955, + 7, 0, 0, 0, 14955, 14956, 7, 1, 0, 0, 14956, 14957, 7, 11, 0, 0, 14957, + 14958, 7, 6, 0, 0, 14958, 14959, 5, 95, 0, 0, 14959, 14960, 7, 0, 0, 0, + 14960, 14961, 7, 8, 0, 0, 14961, 14962, 7, 8, 0, 0, 14962, 14963, 7, 6, + 0, 0, 14963, 14964, 7, 5, 0, 0, 14964, 14965, 7, 5, 0, 0, 14965, 14966, + 5, 95, 0, 0, 14966, 14967, 7, 1, 0, 0, 14967, 14968, 7, 18, 0, 0, 14968, + 14969, 5, 95, 0, 0, 14969, 14970, 7, 3, 0, 0, 14970, 14971, 7, 2, 0, 0, + 14971, 14972, 7, 22, 0, 0, 14972, 14973, 7, 12, 0, 0, 14973, 14974, 7, + 9, 0, 0, 14974, 1980, 1, 0, 0, 0, 14975, 14976, 7, 7, 0, 0, 14976, 14977, + 7, 2, 0, 0, 14977, 14978, 5, 95, 0, 0, 14978, 14979, 7, 1, 0, 0, 14979, + 14980, 7, 12, 0, 0, 14980, 14981, 7, 7, 0, 0, 14981, 14982, 7, 9, 0, 0, + 14982, 14983, 5, 95, 0, 0, 14983, 14984, 7, 0, 0, 0, 14984, 14985, 7, 22, + 0, 0, 14985, 14986, 7, 0, 0, 0, 14986, 14987, 7, 3, 0, 0, 14987, 14988, + 7, 6, 0, 0, 14988, 1982, 1, 0, 0, 0, 14989, 14990, 7, 7, 0, 0, 14990, 14991, + 7, 2, 0, 0, 14991, 14992, 5, 95, 0, 0, 14992, 14993, 7, 1, 0, 0, 14993, + 14994, 7, 10, 0, 0, 14994, 14995, 7, 16, 0, 0, 14995, 14996, 7, 16, 0, + 0, 14996, 14997, 7, 6, 0, 0, 14997, 14998, 7, 3, 0, 0, 14998, 1984, 1, + 0, 0, 0, 14999, 15000, 7, 7, 0, 0, 15000, 15001, 7, 2, 0, 0, 15001, 15002, + 7, 8, 0, 0, 15002, 15003, 7, 0, 0, 0, 15003, 15004, 7, 8, 0, 0, 15004, + 15005, 7, 19, 0, 0, 15005, 15006, 7, 6, 0, 0, 15006, 1986, 1, 0, 0, 0, + 15007, 15008, 7, 7, 0, 0, 15008, 15009, 7, 2, 0, 0, 15009, 15010, 5, 95, + 0, 0, 15010, 15011, 7, 8, 0, 0, 15011, 15012, 7, 0, 0, 0, 15012, 15013, + 7, 3, 0, 0, 15013, 15014, 7, 4, 0, 0, 15014, 15015, 7, 6, 0, 0, 15015, + 15016, 7, 5, 0, 0, 15016, 15017, 7, 12, 0, 0, 15017, 15018, 7, 0, 0, 0, + 15018, 15019, 7, 7, 0, 0, 15019, 1988, 1, 0, 0, 0, 15020, 15021, 7, 7, + 0, 0, 15021, 15022, 7, 2, 0, 0, 15022, 15023, 5, 95, 0, 0, 15023, 15024, + 7, 8, 0, 0, 15024, 15025, 7, 19, 0, 0, 15025, 15026, 7, 6, 0, 0, 15026, + 15027, 7, 8, 0, 0, 15027, 15028, 7, 21, 0, 0, 15028, 15029, 5, 95, 0, 0, + 15029, 15030, 7, 0, 0, 0, 15030, 15031, 7, 8, 0, 0, 15031, 15032, 7, 11, + 0, 0, 15032, 15033, 5, 95, 0, 0, 15033, 15034, 7, 3, 0, 0, 15034, 15035, + 7, 6, 0, 0, 15035, 15036, 7, 22, 0, 0, 15036, 15037, 7, 3, 0, 0, 15037, + 15038, 7, 12, 0, 0, 15038, 15039, 7, 4, 0, 0, 15039, 15040, 7, 6, 0, 0, + 15040, 1990, 1, 0, 0, 0, 15041, 15042, 7, 7, 0, 0, 15042, 15043, 7, 2, + 0, 0, 15043, 15044, 5, 95, 0, 0, 15044, 15045, 7, 8, 0, 0, 15045, 15046, + 7, 11, 0, 0, 15046, 15047, 7, 10, 0, 0, 15047, 15048, 7, 5, 0, 0, 15048, + 15049, 7, 4, 0, 0, 15049, 15050, 7, 6, 0, 0, 15050, 15051, 7, 3, 0, 0, + 15051, 15052, 5, 95, 0, 0, 15052, 15053, 7, 1, 0, 0, 15053, 15054, 7, 18, + 0, 0, 15054, 15055, 5, 95, 0, 0, 15055, 15056, 7, 3, 0, 0, 15056, 15057, + 7, 2, 0, 0, 15057, 15058, 7, 22, 0, 0, 15058, 15059, 7, 12, 0, 0, 15059, + 15060, 7, 9, 0, 0, 15060, 1992, 1, 0, 0, 0, 15061, 15062, 7, 7, 0, 0, 15062, + 15063, 7, 2, 0, 0, 15063, 15064, 5, 95, 0, 0, 15064, 15065, 7, 8, 0, 0, + 15065, 15066, 7, 11, 0, 0, 15066, 15067, 7, 10, 0, 0, 15067, 15068, 7, + 5, 0, 0, 15068, 15069, 7, 4, 0, 0, 15069, 15070, 7, 6, 0, 0, 15070, 15071, + 7, 3, 0, 0, 15071, 15072, 7, 12, 0, 0, 15072, 15073, 7, 7, 0, 0, 15073, + 15074, 7, 17, 0, 0, 15074, 1994, 1, 0, 0, 0, 15075, 15076, 7, 7, 0, 0, + 15076, 15077, 7, 2, 0, 0, 15077, 15078, 5, 95, 0, 0, 15078, 15079, 7, 8, + 0, 0, 15079, 15080, 7, 2, 0, 0, 15080, 15081, 7, 0, 0, 0, 15081, 15082, + 7, 11, 0, 0, 15082, 15083, 7, 6, 0, 0, 15083, 15084, 7, 5, 0, 0, 15084, + 15085, 7, 8, 0, 0, 15085, 15086, 7, 6, 0, 0, 15086, 15087, 5, 95, 0, 0, + 15087, 15088, 7, 5, 0, 0, 15088, 15089, 7, 24, 0, 0, 15089, 1996, 1, 0, + 0, 0, 15090, 15091, 7, 7, 0, 0, 15091, 15092, 7, 2, 0, 0, 15092, 15093, + 5, 95, 0, 0, 15093, 15094, 7, 8, 0, 0, 15094, 15095, 7, 2, 0, 0, 15095, + 15096, 7, 14, 0, 0, 15096, 15097, 7, 14, 0, 0, 15097, 15098, 7, 2, 0, 0, + 15098, 15099, 7, 7, 0, 0, 15099, 15100, 5, 95, 0, 0, 15100, 15101, 7, 9, + 0, 0, 15101, 15102, 7, 0, 0, 0, 15102, 15103, 7, 4, 0, 0, 15103, 15104, + 7, 0, 0, 0, 15104, 1998, 1, 0, 0, 0, 15105, 15106, 7, 7, 0, 0, 15106, 15107, + 7, 2, 0, 0, 15107, 15108, 7, 8, 0, 0, 15108, 15109, 7, 2, 0, 0, 15109, + 15110, 7, 14, 0, 0, 15110, 15111, 7, 15, 0, 0, 15111, 15112, 7, 3, 0, 0, + 15112, 15113, 7, 6, 0, 0, 15113, 15114, 7, 5, 0, 0, 15114, 15115, 7, 5, + 0, 0, 15115, 2000, 1, 0, 0, 0, 15116, 15117, 7, 7, 0, 0, 15117, 15118, + 7, 2, 0, 0, 15118, 15119, 5, 95, 0, 0, 15119, 15120, 7, 8, 0, 0, 15120, + 15121, 7, 2, 0, 0, 15121, 15122, 7, 7, 0, 0, 15122, 15123, 7, 7, 0, 0, + 15123, 15124, 7, 6, 0, 0, 15124, 15125, 7, 8, 0, 0, 15125, 15126, 7, 4, + 0, 0, 15126, 15127, 5, 95, 0, 0, 15127, 15128, 7, 1, 0, 0, 15128, 15129, + 7, 18, 0, 0, 15129, 15130, 5, 95, 0, 0, 15130, 15131, 7, 8, 0, 0, 15131, + 15132, 7, 1, 0, 0, 15132, 15133, 5, 95, 0, 0, 15133, 15134, 7, 22, 0, 0, + 15134, 15135, 7, 19, 0, 0, 15135, 15136, 7, 3, 0, 0, 15136, 15137, 5, 95, + 0, 0, 15137, 15138, 7, 2, 0, 0, 15138, 15139, 7, 7, 0, 0, 15139, 15140, + 7, 11, 0, 0, 15140, 15141, 7, 18, 0, 0, 15141, 2002, 1, 0, 0, 0, 15142, + 15143, 7, 7, 0, 0, 15143, 15144, 7, 2, 0, 0, 15144, 15145, 5, 95, 0, 0, + 15145, 15146, 7, 8, 0, 0, 15146, 15147, 7, 2, 0, 0, 15147, 15148, 7, 7, + 0, 0, 15148, 15149, 7, 7, 0, 0, 15149, 15150, 7, 6, 0, 0, 15150, 15151, + 7, 8, 0, 0, 15151, 15152, 7, 4, 0, 0, 15152, 15153, 5, 95, 0, 0, 15153, + 15154, 7, 1, 0, 0, 15154, 15155, 7, 18, 0, 0, 15155, 15156, 5, 95, 0, 0, + 15156, 15157, 7, 8, 0, 0, 15157, 15158, 7, 2, 0, 0, 15158, 15159, 7, 14, + 0, 0, 15159, 15160, 7, 1, 0, 0, 15160, 15161, 7, 12, 0, 0, 15161, 15162, + 7, 7, 0, 0, 15162, 15163, 7, 6, 0, 0, 15163, 15164, 5, 95, 0, 0, 15164, + 15165, 7, 5, 0, 0, 15165, 15166, 7, 22, 0, 0, 15166, 2004, 1, 0, 0, 0, + 15167, 15168, 7, 7, 0, 0, 15168, 15169, 7, 2, 0, 0, 15169, 15170, 5, 95, + 0, 0, 15170, 15171, 7, 8, 0, 0, 15171, 15172, 7, 2, 0, 0, 15172, 15173, + 7, 7, 0, 0, 15173, 15174, 7, 7, 0, 0, 15174, 15175, 7, 6, 0, 0, 15175, + 15176, 7, 8, 0, 0, 15176, 15177, 7, 4, 0, 0, 15177, 15178, 5, 95, 0, 0, + 15178, 15179, 7, 1, 0, 0, 15179, 15180, 7, 18, 0, 0, 15180, 15181, 5, 95, + 0, 0, 15181, 15182, 7, 8, 0, 0, 15182, 15183, 7, 2, 0, 0, 15183, 15184, + 7, 5, 0, 0, 15184, 15185, 7, 4, 0, 0, 15185, 15186, 5, 95, 0, 0, 15186, + 15187, 7, 1, 0, 0, 15187, 15188, 7, 0, 0, 0, 15188, 15189, 7, 5, 0, 0, + 15189, 15190, 7, 6, 0, 0, 15190, 15191, 7, 9, 0, 0, 15191, 2006, 1, 0, + 0, 0, 15192, 15193, 7, 7, 0, 0, 15193, 15194, 7, 2, 0, 0, 15194, 15195, + 5, 95, 0, 0, 15195, 15196, 7, 8, 0, 0, 15196, 15197, 7, 2, 0, 0, 15197, + 15198, 7, 7, 0, 0, 15198, 15199, 7, 7, 0, 0, 15199, 15200, 7, 6, 0, 0, + 15200, 15201, 7, 8, 0, 0, 15201, 15202, 7, 4, 0, 0, 15202, 15203, 5, 95, + 0, 0, 15203, 15204, 7, 1, 0, 0, 15204, 15205, 7, 18, 0, 0, 15205, 15206, + 5, 95, 0, 0, 15206, 15207, 7, 6, 0, 0, 15207, 15208, 7, 11, 0, 0, 15208, + 15209, 7, 12, 0, 0, 15209, 15210, 7, 14, 0, 0, 15210, 15211, 5, 95, 0, + 0, 15211, 15212, 7, 9, 0, 0, 15212, 15213, 7, 10, 0, 0, 15213, 15214, 7, + 15, 0, 0, 15214, 15215, 7, 5, 0, 0, 15215, 2008, 1, 0, 0, 0, 15216, 15217, + 7, 7, 0, 0, 15217, 15218, 7, 2, 0, 0, 15218, 15219, 5, 95, 0, 0, 15219, + 15220, 7, 8, 0, 0, 15220, 15221, 7, 2, 0, 0, 15221, 15222, 7, 7, 0, 0, + 15222, 15223, 7, 7, 0, 0, 15223, 15224, 7, 6, 0, 0, 15224, 15225, 7, 8, + 0, 0, 15225, 15226, 7, 4, 0, 0, 15226, 15227, 5, 95, 0, 0, 15227, 15228, + 7, 1, 0, 0, 15228, 15229, 7, 18, 0, 0, 15229, 15230, 5, 95, 0, 0, 15230, + 15231, 7, 16, 0, 0, 15231, 15232, 7, 12, 0, 0, 15232, 15233, 7, 11, 0, + 0, 15233, 15234, 7, 4, 0, 0, 15234, 15235, 7, 6, 0, 0, 15235, 15236, 7, + 3, 0, 0, 15236, 15237, 7, 12, 0, 0, 15237, 15238, 7, 7, 0, 0, 15238, 15239, + 7, 17, 0, 0, 15239, 2010, 1, 0, 0, 0, 15240, 15241, 7, 7, 0, 0, 15241, + 15242, 7, 2, 0, 0, 15242, 15243, 7, 8, 0, 0, 15243, 15244, 7, 2, 0, 0, + 15244, 15245, 7, 15, 0, 0, 15245, 15246, 7, 18, 0, 0, 15246, 2012, 1, 0, + 0, 0, 15247, 15248, 7, 7, 0, 0, 15248, 15249, 7, 2, 0, 0, 15249, 15250, + 5, 95, 0, 0, 15250, 15251, 7, 8, 0, 0, 15251, 15252, 7, 2, 0, 0, 15252, + 15253, 7, 5, 0, 0, 15253, 15254, 7, 4, 0, 0, 15254, 15255, 5, 95, 0, 0, + 15255, 15256, 7, 25, 0, 0, 15256, 15257, 7, 14, 0, 0, 15257, 15258, 7, + 11, 0, 0, 15258, 15259, 5, 95, 0, 0, 15259, 15260, 7, 24, 0, 0, 15260, + 15261, 7, 10, 0, 0, 15261, 15262, 7, 6, 0, 0, 15262, 15263, 7, 3, 0, 0, + 15263, 15264, 7, 18, 0, 0, 15264, 15265, 5, 95, 0, 0, 15265, 15266, 7, + 3, 0, 0, 15266, 15267, 7, 6, 0, 0, 15267, 15268, 7, 22, 0, 0, 15268, 15269, + 7, 3, 0, 0, 15269, 15270, 7, 12, 0, 0, 15270, 15271, 7, 4, 0, 0, 15271, + 15272, 7, 6, 0, 0, 15272, 2014, 1, 0, 0, 0, 15273, 15274, 7, 7, 0, 0, 15274, + 15275, 7, 2, 0, 0, 15275, 15276, 5, 95, 0, 0, 15276, 15277, 7, 8, 0, 0, + 15277, 15278, 7, 15, 0, 0, 15278, 15279, 7, 10, 0, 0, 15279, 15280, 5, + 95, 0, 0, 15280, 15281, 7, 8, 0, 0, 15281, 15282, 7, 2, 0, 0, 15282, 15283, + 7, 5, 0, 0, 15283, 15284, 7, 4, 0, 0, 15284, 15285, 7, 12, 0, 0, 15285, + 15286, 7, 7, 0, 0, 15286, 15287, 7, 17, 0, 0, 15287, 2016, 1, 0, 0, 0, + 15288, 15289, 7, 7, 0, 0, 15289, 15290, 7, 2, 0, 0, 15290, 15291, 7, 8, + 0, 0, 15291, 15292, 7, 15, 0, 0, 15292, 15293, 7, 10, 0, 0, 15293, 15294, + 5, 95, 0, 0, 15294, 15295, 7, 8, 0, 0, 15295, 15296, 7, 2, 0, 0, 15296, + 15297, 7, 5, 0, 0, 15297, 15298, 7, 4, 0, 0, 15298, 15299, 7, 12, 0, 0, + 15299, 15300, 7, 7, 0, 0, 15300, 15301, 7, 17, 0, 0, 15301, 2018, 1, 0, + 0, 0, 15302, 15303, 7, 7, 0, 0, 15303, 15304, 7, 2, 0, 0, 15304, 15305, + 7, 8, 0, 0, 15305, 15306, 7, 18, 0, 0, 15306, 15307, 7, 8, 0, 0, 15307, + 15308, 7, 11, 0, 0, 15308, 15309, 7, 6, 0, 0, 15309, 2020, 1, 0, 0, 0, + 15310, 15311, 7, 7, 0, 0, 15311, 15312, 7, 2, 0, 0, 15312, 15313, 5, 95, + 0, 0, 15313, 15314, 7, 9, 0, 0, 15314, 15315, 7, 0, 0, 0, 15315, 15316, + 7, 4, 0, 0, 15316, 15317, 7, 0, 0, 0, 15317, 15318, 5, 95, 0, 0, 15318, + 15319, 7, 5, 0, 0, 15319, 15320, 7, 6, 0, 0, 15320, 15321, 7, 8, 0, 0, + 15321, 15322, 7, 10, 0, 0, 15322, 15323, 7, 3, 0, 0, 15323, 15324, 7, 12, + 0, 0, 15324, 15325, 7, 4, 0, 0, 15325, 15326, 7, 18, 0, 0, 15326, 15327, + 5, 95, 0, 0, 15327, 15328, 7, 3, 0, 0, 15328, 15329, 7, 6, 0, 0, 15329, + 15330, 7, 22, 0, 0, 15330, 15331, 7, 3, 0, 0, 15331, 15332, 7, 12, 0, 0, + 15332, 15333, 7, 4, 0, 0, 15333, 15334, 7, 6, 0, 0, 15334, 2022, 1, 0, + 0, 0, 15335, 15336, 7, 7, 0, 0, 15336, 15337, 7, 2, 0, 0, 15337, 15338, + 5, 95, 0, 0, 15338, 15339, 7, 9, 0, 0, 15339, 15340, 7, 6, 0, 0, 15340, + 15341, 7, 8, 0, 0, 15341, 15342, 7, 2, 0, 0, 15342, 15343, 7, 3, 0, 0, + 15343, 15344, 7, 3, 0, 0, 15344, 15345, 7, 6, 0, 0, 15345, 15346, 7, 11, + 0, 0, 15346, 15347, 7, 0, 0, 0, 15347, 15348, 7, 4, 0, 0, 15348, 15349, + 7, 6, 0, 0, 15349, 2024, 1, 0, 0, 0, 15350, 15351, 7, 7, 0, 0, 15351, 15352, + 7, 2, 0, 0, 15352, 15353, 7, 9, 0, 0, 15353, 15354, 7, 6, 0, 0, 15354, + 15355, 7, 11, 0, 0, 15355, 15356, 7, 0, 0, 0, 15356, 15357, 7, 18, 0, 0, + 15357, 2026, 1, 0, 0, 0, 15358, 15359, 7, 7, 0, 0, 15359, 15360, 7, 2, + 0, 0, 15360, 15361, 5, 95, 0, 0, 15361, 15362, 7, 9, 0, 0, 15362, 15363, + 7, 2, 0, 0, 15363, 15364, 7, 14, 0, 0, 15364, 15365, 7, 0, 0, 0, 15365, + 15366, 7, 12, 0, 0, 15366, 15367, 7, 7, 0, 0, 15367, 15368, 5, 95, 0, 0, + 15368, 15369, 7, 12, 0, 0, 15369, 15370, 7, 7, 0, 0, 15370, 15371, 7, 9, + 0, 0, 15371, 15372, 7, 6, 0, 0, 15372, 15373, 7, 25, 0, 0, 15373, 15374, + 5, 95, 0, 0, 15374, 15375, 7, 16, 0, 0, 15375, 15376, 7, 12, 0, 0, 15376, + 15377, 7, 11, 0, 0, 15377, 15378, 7, 4, 0, 0, 15378, 15379, 7, 6, 0, 0, + 15379, 15380, 7, 3, 0, 0, 15380, 2028, 1, 0, 0, 0, 15381, 15382, 7, 7, + 0, 0, 15382, 15383, 7, 2, 0, 0, 15383, 15384, 5, 95, 0, 0, 15384, 15385, + 7, 9, 0, 0, 15385, 15386, 7, 5, 0, 0, 15386, 15387, 7, 4, 0, 0, 15387, + 15388, 5, 95, 0, 0, 15388, 15389, 7, 10, 0, 0, 15389, 15390, 7, 15, 0, + 0, 15390, 15391, 7, 17, 0, 0, 15391, 15392, 7, 3, 0, 0, 15392, 15393, 7, + 0, 0, 0, 15393, 15394, 7, 9, 0, 0, 15394, 15395, 7, 6, 0, 0, 15395, 15396, + 5, 95, 0, 0, 15396, 15397, 7, 12, 0, 0, 15397, 15398, 7, 7, 0, 0, 15398, + 15399, 7, 5, 0, 0, 15399, 15400, 7, 6, 0, 0, 15400, 15401, 7, 3, 0, 0, + 15401, 15402, 7, 4, 0, 0, 15402, 15403, 5, 95, 0, 0, 15403, 15404, 7, 8, + 0, 0, 15404, 15405, 7, 2, 0, 0, 15405, 15406, 7, 7, 0, 0, 15406, 15407, + 7, 13, 0, 0, 15407, 2030, 1, 0, 0, 0, 15408, 15409, 7, 7, 0, 0, 15409, + 15410, 7, 2, 0, 0, 15410, 15411, 5, 95, 0, 0, 15411, 15412, 7, 6, 0, 0, + 15412, 15413, 7, 11, 0, 0, 15413, 15414, 7, 12, 0, 0, 15414, 15415, 7, + 14, 0, 0, 15415, 15416, 5, 95, 0, 0, 15416, 15417, 7, 17, 0, 0, 15417, + 15418, 7, 3, 0, 0, 15418, 15419, 7, 2, 0, 0, 15419, 15420, 7, 10, 0, 0, + 15420, 15421, 7, 15, 0, 0, 15421, 15422, 7, 1, 0, 0, 15422, 15423, 7, 18, + 0, 0, 15423, 2032, 1, 0, 0, 0, 15424, 15425, 7, 7, 0, 0, 15425, 15426, + 7, 2, 0, 0, 15426, 15427, 5, 95, 0, 0, 15427, 15428, 7, 6, 0, 0, 15428, + 15429, 7, 11, 0, 0, 15429, 15430, 7, 12, 0, 0, 15430, 15431, 7, 14, 0, + 0, 15431, 15432, 7, 12, 0, 0, 15432, 15433, 7, 7, 0, 0, 15433, 15434, 7, + 0, 0, 0, 15434, 15435, 7, 4, 0, 0, 15435, 15436, 7, 6, 0, 0, 15436, 15437, + 5, 95, 0, 0, 15437, 15438, 7, 20, 0, 0, 15438, 15439, 7, 2, 0, 0, 15439, + 15440, 7, 12, 0, 0, 15440, 15441, 7, 7, 0, 0, 15441, 2034, 1, 0, 0, 0, + 15442, 15443, 7, 7, 0, 0, 15443, 15444, 7, 2, 0, 0, 15444, 15445, 5, 95, + 0, 0, 15445, 15446, 7, 6, 0, 0, 15446, 15447, 7, 11, 0, 0, 15447, 15448, + 7, 12, 0, 0, 15448, 15449, 7, 14, 0, 0, 15449, 15450, 7, 12, 0, 0, 15450, + 15451, 7, 7, 0, 0, 15451, 15452, 7, 0, 0, 0, 15452, 15453, 7, 4, 0, 0, + 15453, 15454, 7, 6, 0, 0, 15454, 15455, 5, 95, 0, 0, 15455, 15456, 7, 2, + 0, 0, 15456, 15457, 7, 1, 0, 0, 15457, 15458, 7, 18, 0, 0, 15458, 2036, + 1, 0, 0, 0, 15459, 15460, 7, 7, 0, 0, 15460, 15461, 7, 2, 0, 0, 15461, + 15462, 5, 95, 0, 0, 15462, 15463, 7, 6, 0, 0, 15463, 15464, 7, 11, 0, 0, + 15464, 15465, 7, 12, 0, 0, 15465, 15466, 7, 14, 0, 0, 15466, 15467, 7, + 12, 0, 0, 15467, 15468, 7, 7, 0, 0, 15468, 15469, 7, 0, 0, 0, 15469, 15470, + 7, 4, 0, 0, 15470, 15471, 7, 6, 0, 0, 15471, 15472, 5, 95, 0, 0, 15472, + 15473, 7, 2, 0, 0, 15473, 15474, 7, 10, 0, 0, 15474, 15475, 7, 4, 0, 0, + 15475, 15476, 7, 6, 0, 0, 15476, 15477, 7, 3, 0, 0, 15477, 15478, 5, 95, + 0, 0, 15478, 15479, 7, 20, 0, 0, 15479, 15480, 7, 2, 0, 0, 15480, 15481, + 7, 12, 0, 0, 15481, 15482, 7, 7, 0, 0, 15482, 2038, 1, 0, 0, 0, 15483, + 15484, 7, 7, 0, 0, 15484, 15485, 7, 2, 0, 0, 15485, 15486, 7, 6, 0, 0, + 15486, 15487, 7, 7, 0, 0, 15487, 15488, 7, 4, 0, 0, 15488, 15489, 7, 12, + 0, 0, 15489, 15490, 7, 4, 0, 0, 15490, 15491, 7, 18, 0, 0, 15491, 15492, + 7, 6, 0, 0, 15492, 15493, 7, 5, 0, 0, 15493, 15494, 7, 8, 0, 0, 15494, + 15495, 7, 0, 0, 0, 15495, 15496, 7, 15, 0, 0, 15496, 15497, 7, 12, 0, 0, + 15497, 15498, 7, 7, 0, 0, 15498, 15499, 7, 17, 0, 0, 15499, 2040, 1, 0, + 0, 0, 15500, 15501, 7, 7, 0, 0, 15501, 15502, 7, 2, 0, 0, 15502, 15503, + 5, 95, 0, 0, 15503, 15504, 7, 6, 0, 0, 15504, 15505, 7, 25, 0, 0, 15505, + 15506, 7, 15, 0, 0, 15506, 15507, 7, 0, 0, 0, 15507, 15508, 7, 7, 0, 0, + 15508, 15509, 7, 9, 0, 0, 15509, 15510, 5, 95, 0, 0, 15510, 15511, 7, 17, + 0, 0, 15511, 15512, 7, 5, 0, 0, 15512, 15513, 7, 6, 0, 0, 15513, 15514, + 7, 4, 0, 0, 15514, 15515, 5, 95, 0, 0, 15515, 15516, 7, 4, 0, 0, 15516, + 15517, 7, 2, 0, 0, 15517, 15518, 5, 95, 0, 0, 15518, 15519, 7, 10, 0, 0, + 15519, 15520, 7, 7, 0, 0, 15520, 15521, 7, 12, 0, 0, 15521, 15522, 7, 2, + 0, 0, 15522, 15523, 7, 7, 0, 0, 15523, 2042, 1, 0, 0, 0, 15524, 15525, + 7, 7, 0, 0, 15525, 15526, 7, 2, 0, 0, 15526, 15527, 5, 95, 0, 0, 15527, + 15528, 7, 6, 0, 0, 15528, 15529, 7, 25, 0, 0, 15529, 15530, 7, 15, 0, 0, + 15530, 15531, 7, 0, 0, 0, 15531, 15532, 7, 7, 0, 0, 15532, 15533, 7, 9, + 0, 0, 15533, 2044, 1, 0, 0, 0, 15534, 15535, 7, 7, 0, 0, 15535, 15536, + 7, 2, 0, 0, 15536, 15537, 5, 95, 0, 0, 15537, 15538, 7, 6, 0, 0, 15538, + 15539, 7, 25, 0, 0, 15539, 15540, 7, 15, 0, 0, 15540, 15541, 7, 0, 0, 0, + 15541, 15542, 7, 7, 0, 0, 15542, 15543, 7, 9, 0, 0, 15543, 15544, 5, 95, + 0, 0, 15544, 15545, 7, 4, 0, 0, 15545, 15546, 7, 0, 0, 0, 15546, 15547, + 7, 1, 0, 0, 15547, 15548, 7, 11, 0, 0, 15548, 15549, 7, 6, 0, 0, 15549, + 2046, 1, 0, 0, 0, 15550, 15551, 7, 7, 0, 0, 15551, 15552, 7, 2, 0, 0, 15552, + 15553, 5, 95, 0, 0, 15553, 15554, 7, 16, 0, 0, 15554, 15555, 7, 0, 0, 0, + 15555, 15556, 7, 8, 0, 0, 15556, 15557, 7, 4, 0, 0, 15557, 2048, 1, 0, + 0, 0, 15558, 15559, 7, 7, 0, 0, 15559, 15560, 7, 2, 0, 0, 15560, 15561, + 5, 95, 0, 0, 15561, 15562, 7, 16, 0, 0, 15562, 15563, 7, 0, 0, 0, 15563, + 15564, 7, 8, 0, 0, 15564, 15565, 7, 4, 0, 0, 15565, 15566, 7, 2, 0, 0, + 15566, 15567, 7, 3, 0, 0, 15567, 15568, 7, 12, 0, 0, 15568, 15569, 7, 23, + 0, 0, 15569, 15570, 7, 6, 0, 0, 15570, 15571, 5, 95, 0, 0, 15571, 15572, + 7, 20, 0, 0, 15572, 15573, 7, 2, 0, 0, 15573, 15574, 7, 12, 0, 0, 15574, + 15575, 7, 7, 0, 0, 15575, 2050, 1, 0, 0, 0, 15576, 15577, 7, 7, 0, 0, 15577, + 15578, 7, 2, 0, 0, 15578, 15579, 5, 95, 0, 0, 15579, 15580, 7, 16, 0, 0, + 15580, 15581, 7, 12, 0, 0, 15581, 15582, 7, 11, 0, 0, 15582, 15583, 7, + 4, 0, 0, 15583, 15584, 7, 6, 0, 0, 15584, 15585, 7, 3, 0, 0, 15585, 15586, + 7, 12, 0, 0, 15586, 15587, 7, 7, 0, 0, 15587, 15588, 7, 17, 0, 0, 15588, + 2052, 1, 0, 0, 0, 15589, 15590, 7, 7, 0, 0, 15590, 15591, 7, 2, 0, 0, 15591, + 15592, 7, 16, 0, 0, 15592, 15593, 7, 2, 0, 0, 15593, 15594, 7, 3, 0, 0, + 15594, 15595, 7, 8, 0, 0, 15595, 15596, 7, 6, 0, 0, 15596, 2054, 1, 0, + 0, 0, 15597, 15598, 7, 7, 0, 0, 15598, 15599, 7, 2, 0, 0, 15599, 15600, + 5, 95, 0, 0, 15600, 15601, 7, 16, 0, 0, 15601, 15602, 7, 10, 0, 0, 15602, + 15603, 7, 11, 0, 0, 15603, 15604, 7, 11, 0, 0, 15604, 15605, 5, 95, 0, + 0, 15605, 15606, 7, 2, 0, 0, 15606, 15607, 7, 10, 0, 0, 15607, 15608, 7, + 4, 0, 0, 15608, 15609, 7, 6, 0, 0, 15609, 15610, 7, 3, 0, 0, 15610, 15611, + 5, 95, 0, 0, 15611, 15612, 7, 20, 0, 0, 15612, 15613, 7, 2, 0, 0, 15613, + 15614, 7, 12, 0, 0, 15614, 15615, 7, 7, 0, 0, 15615, 15616, 5, 95, 0, 0, + 15616, 15617, 7, 4, 0, 0, 15617, 15618, 7, 2, 0, 0, 15618, 15619, 5, 95, + 0, 0, 15619, 15620, 7, 2, 0, 0, 15620, 15621, 7, 10, 0, 0, 15621, 15622, + 7, 4, 0, 0, 15622, 15623, 7, 6, 0, 0, 15623, 15624, 7, 3, 0, 0, 15624, + 2056, 1, 0, 0, 0, 15625, 15626, 7, 7, 0, 0, 15626, 15627, 7, 2, 0, 0, 15627, + 15628, 5, 95, 0, 0, 15628, 15629, 7, 17, 0, 0, 15629, 15630, 7, 0, 0, 0, + 15630, 15631, 7, 4, 0, 0, 15631, 15632, 7, 19, 0, 0, 15632, 15633, 7, 6, + 0, 0, 15633, 15634, 7, 3, 0, 0, 15634, 15635, 5, 95, 0, 0, 15635, 15636, + 7, 2, 0, 0, 15636, 15637, 7, 15, 0, 0, 15637, 15638, 7, 4, 0, 0, 15638, + 15639, 7, 12, 0, 0, 15639, 15640, 7, 14, 0, 0, 15640, 15641, 7, 12, 0, + 0, 15641, 15642, 7, 23, 0, 0, 15642, 15643, 7, 6, 0, 0, 15643, 15644, 7, + 3, 0, 0, 15644, 15645, 5, 95, 0, 0, 15645, 15646, 7, 5, 0, 0, 15646, 15647, + 7, 4, 0, 0, 15647, 15648, 7, 0, 0, 0, 15648, 15649, 7, 4, 0, 0, 15649, + 15650, 7, 12, 0, 0, 15650, 15651, 7, 5, 0, 0, 15651, 15652, 7, 4, 0, 0, + 15652, 15653, 7, 12, 0, 0, 15653, 15654, 7, 8, 0, 0, 15654, 15655, 7, 5, + 0, 0, 15655, 2058, 1, 0, 0, 0, 15656, 15657, 7, 7, 0, 0, 15657, 15658, + 7, 2, 0, 0, 15658, 15659, 5, 95, 0, 0, 15659, 15660, 7, 17, 0, 0, 15660, + 15661, 7, 1, 0, 0, 15661, 15662, 7, 18, 0, 0, 15662, 15663, 5, 95, 0, 0, + 15663, 15664, 7, 15, 0, 0, 15664, 15665, 7, 10, 0, 0, 15665, 15666, 7, + 5, 0, 0, 15666, 15667, 7, 19, 0, 0, 15667, 15668, 7, 9, 0, 0, 15668, 15669, + 7, 2, 0, 0, 15669, 15670, 7, 22, 0, 0, 15670, 15671, 7, 7, 0, 0, 15671, + 2060, 1, 0, 0, 0, 15672, 15673, 7, 7, 0, 0, 15673, 15674, 7, 2, 0, 0, 15674, + 15675, 7, 17, 0, 0, 15675, 15676, 7, 10, 0, 0, 15676, 15677, 7, 0, 0, 0, + 15677, 15678, 7, 3, 0, 0, 15678, 15679, 7, 0, 0, 0, 15679, 15680, 7, 7, + 0, 0, 15680, 15681, 7, 4, 0, 0, 15681, 15682, 7, 6, 0, 0, 15682, 15683, + 7, 6, 0, 0, 15683, 2062, 1, 0, 0, 0, 15684, 15685, 7, 7, 0, 0, 15685, 15686, + 7, 2, 0, 0, 15686, 15687, 5, 95, 0, 0, 15687, 15688, 7, 12, 0, 0, 15688, + 15689, 7, 7, 0, 0, 15689, 15690, 7, 9, 0, 0, 15690, 15691, 7, 6, 0, 0, + 15691, 15692, 7, 25, 0, 0, 15692, 15693, 5, 95, 0, 0, 15693, 15694, 7, + 16, 0, 0, 15694, 15695, 7, 16, 0, 0, 15695, 15696, 7, 5, 0, 0, 15696, 2064, + 1, 0, 0, 0, 15697, 15698, 7, 7, 0, 0, 15698, 15699, 7, 2, 0, 0, 15699, + 15700, 5, 95, 0, 0, 15700, 15701, 7, 12, 0, 0, 15701, 15702, 7, 7, 0, 0, + 15702, 15703, 7, 9, 0, 0, 15703, 15704, 7, 6, 0, 0, 15704, 15705, 7, 25, + 0, 0, 15705, 2066, 1, 0, 0, 0, 15706, 15707, 7, 7, 0, 0, 15707, 15708, + 7, 2, 0, 0, 15708, 15709, 5, 95, 0, 0, 15709, 15710, 7, 12, 0, 0, 15710, + 15711, 7, 7, 0, 0, 15711, 15712, 7, 9, 0, 0, 15712, 15713, 7, 6, 0, 0, + 15713, 15714, 7, 25, 0, 0, 15714, 15715, 5, 95, 0, 0, 15715, 15716, 7, + 5, 0, 0, 15716, 15717, 7, 5, 0, 0, 15717, 2068, 1, 0, 0, 0, 15718, 15719, + 7, 7, 0, 0, 15719, 15720, 7, 2, 0, 0, 15720, 15721, 5, 95, 0, 0, 15721, + 15722, 7, 12, 0, 0, 15722, 15723, 7, 7, 0, 0, 15723, 15724, 7, 14, 0, 0, + 15724, 15725, 7, 6, 0, 0, 15725, 15726, 7, 14, 0, 0, 15726, 15727, 7, 2, + 0, 0, 15727, 15728, 7, 3, 0, 0, 15728, 15729, 7, 18, 0, 0, 15729, 2070, + 1, 0, 0, 0, 15730, 15731, 7, 7, 0, 0, 15731, 15732, 7, 2, 0, 0, 15732, + 15733, 5, 95, 0, 0, 15733, 15734, 7, 12, 0, 0, 15734, 15735, 7, 7, 0, 0, + 15735, 15736, 7, 14, 0, 0, 15736, 15737, 7, 6, 0, 0, 15737, 15738, 7, 14, + 0, 0, 15738, 15739, 7, 2, 0, 0, 15739, 15740, 7, 3, 0, 0, 15740, 15741, + 7, 18, 0, 0, 15741, 15742, 5, 95, 0, 0, 15742, 15743, 7, 15, 0, 0, 15743, + 15744, 7, 3, 0, 0, 15744, 15745, 7, 10, 0, 0, 15745, 15746, 7, 7, 0, 0, + 15746, 15747, 7, 12, 0, 0, 15747, 15748, 7, 7, 0, 0, 15748, 15749, 7, 17, + 0, 0, 15749, 2072, 1, 0, 0, 0, 15750, 15751, 7, 7, 0, 0, 15751, 15752, + 7, 2, 0, 0, 15752, 15753, 7, 21, 0, 0, 15753, 15754, 7, 6, 0, 0, 15754, + 15755, 7, 6, 0, 0, 15755, 15756, 7, 15, 0, 0, 15756, 2074, 1, 0, 0, 0, + 15757, 15758, 7, 7, 0, 0, 15758, 15759, 7, 2, 0, 0, 15759, 15760, 5, 95, + 0, 0, 15760, 15761, 7, 11, 0, 0, 15761, 15762, 7, 2, 0, 0, 15762, 15763, + 7, 0, 0, 0, 15763, 15764, 7, 9, 0, 0, 15764, 2076, 1, 0, 0, 0, 15765, 15766, + 7, 7, 0, 0, 15766, 15767, 7, 2, 0, 0, 15767, 15768, 7, 11, 0, 0, 15768, + 15769, 7, 2, 0, 0, 15769, 15770, 7, 8, 0, 0, 15770, 15771, 7, 0, 0, 0, + 15771, 15772, 7, 11, 0, 0, 15772, 2078, 1, 0, 0, 0, 15773, 15774, 7, 7, + 0, 0, 15774, 15775, 7, 2, 0, 0, 15775, 15776, 7, 11, 0, 0, 15776, 15777, + 7, 2, 0, 0, 15777, 15778, 7, 17, 0, 0, 15778, 15779, 7, 17, 0, 0, 15779, + 15780, 7, 12, 0, 0, 15780, 15781, 7, 7, 0, 0, 15781, 15782, 7, 17, 0, 0, + 15782, 2080, 1, 0, 0, 0, 15783, 15784, 7, 7, 0, 0, 15784, 15785, 7, 2, + 0, 0, 15785, 15786, 7, 14, 0, 0, 15786, 15787, 7, 0, 0, 0, 15787, 15788, + 7, 15, 0, 0, 15788, 15789, 7, 15, 0, 0, 15789, 15790, 7, 12, 0, 0, 15790, + 15791, 7, 7, 0, 0, 15791, 15792, 7, 17, 0, 0, 15792, 2082, 1, 0, 0, 0, + 15793, 15794, 7, 7, 0, 0, 15794, 15795, 7, 2, 0, 0, 15795, 15796, 7, 14, + 0, 0, 15796, 15797, 7, 0, 0, 0, 15797, 15798, 7, 25, 0, 0, 15798, 15799, + 7, 13, 0, 0, 15799, 15800, 7, 0, 0, 0, 15800, 15801, 7, 11, 0, 0, 15801, + 15802, 7, 10, 0, 0, 15802, 15803, 7, 6, 0, 0, 15803, 2084, 1, 0, 0, 0, + 15804, 15805, 7, 7, 0, 0, 15805, 15806, 7, 2, 0, 0, 15806, 15807, 5, 95, + 0, 0, 15807, 15808, 7, 14, 0, 0, 15808, 15809, 7, 6, 0, 0, 15809, 15810, + 7, 3, 0, 0, 15810, 15811, 7, 17, 0, 0, 15811, 15812, 7, 6, 0, 0, 15812, + 2086, 1, 0, 0, 0, 15813, 15814, 7, 7, 0, 0, 15814, 15815, 7, 2, 0, 0, 15815, + 15816, 7, 14, 0, 0, 15816, 15817, 7, 12, 0, 0, 15817, 15818, 7, 7, 0, 0, + 15818, 15819, 7, 12, 0, 0, 15819, 15820, 7, 14, 0, 0, 15820, 15821, 7, + 12, 0, 0, 15821, 15822, 7, 23, 0, 0, 15822, 15823, 7, 6, 0, 0, 15823, 2088, + 1, 0, 0, 0, 15824, 15825, 7, 7, 0, 0, 15825, 15826, 7, 2, 0, 0, 15826, + 15827, 7, 14, 0, 0, 15827, 15828, 7, 12, 0, 0, 15828, 15829, 7, 7, 0, 0, + 15829, 15830, 7, 13, 0, 0, 15830, 15831, 7, 0, 0, 0, 15831, 15832, 7, 11, + 0, 0, 15832, 15833, 7, 10, 0, 0, 15833, 15834, 7, 6, 0, 0, 15834, 2090, + 1, 0, 0, 0, 15835, 15836, 7, 7, 0, 0, 15836, 15837, 7, 2, 0, 0, 15837, + 15838, 5, 95, 0, 0, 15838, 15839, 7, 14, 0, 0, 15839, 15840, 7, 2, 0, 0, + 15840, 15841, 7, 9, 0, 0, 15841, 15842, 7, 6, 0, 0, 15842, 15843, 7, 11, + 0, 0, 15843, 15844, 5, 95, 0, 0, 15844, 15845, 7, 15, 0, 0, 15845, 15846, + 7, 10, 0, 0, 15846, 15847, 7, 5, 0, 0, 15847, 15848, 7, 19, 0, 0, 15848, + 15849, 5, 95, 0, 0, 15849, 15850, 7, 3, 0, 0, 15850, 15851, 7, 6, 0, 0, + 15851, 15852, 7, 16, 0, 0, 15852, 2092, 1, 0, 0, 0, 15853, 15854, 7, 7, + 0, 0, 15854, 15855, 7, 2, 0, 0, 15855, 15856, 5, 95, 0, 0, 15856, 15857, + 7, 14, 0, 0, 15857, 15858, 7, 2, 0, 0, 15858, 15859, 7, 7, 0, 0, 15859, + 15860, 7, 12, 0, 0, 15860, 15861, 7, 4, 0, 0, 15861, 15862, 7, 2, 0, 0, + 15862, 15863, 7, 3, 0, 0, 15863, 15864, 7, 12, 0, 0, 15864, 15865, 7, 7, + 0, 0, 15865, 15866, 7, 17, 0, 0, 15866, 2094, 1, 0, 0, 0, 15867, 15868, + 7, 7, 0, 0, 15868, 15869, 7, 2, 0, 0, 15869, 15870, 7, 14, 0, 0, 15870, + 15871, 7, 2, 0, 0, 15871, 15872, 7, 7, 0, 0, 15872, 15873, 7, 12, 0, 0, + 15873, 15874, 7, 4, 0, 0, 15874, 15875, 7, 2, 0, 0, 15875, 15876, 7, 3, + 0, 0, 15876, 15877, 7, 12, 0, 0, 15877, 15878, 7, 7, 0, 0, 15878, 15879, + 7, 17, 0, 0, 15879, 2096, 1, 0, 0, 0, 15880, 15881, 7, 7, 0, 0, 15881, + 15882, 7, 2, 0, 0, 15882, 15883, 5, 95, 0, 0, 15883, 15884, 7, 14, 0, 0, + 15884, 15885, 7, 2, 0, 0, 15885, 15886, 7, 7, 0, 0, 15886, 15887, 7, 12, + 0, 0, 15887, 15888, 7, 4, 0, 0, 15888, 15889, 7, 2, 0, 0, 15889, 15890, + 7, 3, 0, 0, 15890, 2098, 1, 0, 0, 0, 15891, 15892, 7, 7, 0, 0, 15892, 15893, + 7, 2, 0, 0, 15893, 15894, 5, 95, 0, 0, 15894, 15895, 7, 14, 0, 0, 15895, + 15896, 7, 10, 0, 0, 15896, 15897, 7, 11, 0, 0, 15897, 15898, 7, 4, 0, 0, + 15898, 15899, 7, 12, 0, 0, 15899, 15900, 7, 14, 0, 0, 15900, 15901, 7, + 13, 0, 0, 15901, 15902, 5, 95, 0, 0, 15902, 15903, 7, 3, 0, 0, 15903, 15904, + 7, 6, 0, 0, 15904, 15905, 7, 22, 0, 0, 15905, 15906, 7, 3, 0, 0, 15906, + 15907, 7, 12, 0, 0, 15907, 15908, 7, 4, 0, 0, 15908, 15909, 7, 6, 0, 0, + 15909, 2100, 1, 0, 0, 0, 15910, 15911, 7, 7, 0, 0, 15911, 15912, 7, 2, + 0, 0, 15912, 15913, 5, 95, 0, 0, 15913, 15914, 7, 7, 0, 0, 15914, 15915, + 7, 0, 0, 0, 15915, 15916, 7, 4, 0, 0, 15916, 15917, 7, 12, 0, 0, 15917, + 15918, 7, 13, 0, 0, 15918, 15919, 7, 6, 0, 0, 15919, 15920, 5, 95, 0, 0, + 15920, 15921, 7, 16, 0, 0, 15921, 15922, 7, 10, 0, 0, 15922, 15923, 7, + 11, 0, 0, 15923, 15924, 7, 11, 0, 0, 15924, 15925, 5, 95, 0, 0, 15925, + 15926, 7, 2, 0, 0, 15926, 15927, 7, 10, 0, 0, 15927, 15928, 7, 4, 0, 0, + 15928, 15929, 7, 6, 0, 0, 15929, 15930, 7, 3, 0, 0, 15930, 15931, 5, 95, + 0, 0, 15931, 15932, 7, 20, 0, 0, 15932, 15933, 7, 2, 0, 0, 15933, 15934, + 7, 12, 0, 0, 15934, 15935, 7, 7, 0, 0, 15935, 2102, 1, 0, 0, 0, 15936, + 15937, 7, 7, 0, 0, 15937, 15938, 7, 2, 0, 0, 15938, 15939, 7, 7, 0, 0, + 15939, 15940, 7, 1, 0, 0, 15940, 15941, 7, 11, 0, 0, 15941, 15942, 7, 2, + 0, 0, 15942, 15943, 7, 8, 0, 0, 15943, 15944, 7, 21, 0, 0, 15944, 15945, + 7, 12, 0, 0, 15945, 15946, 7, 7, 0, 0, 15946, 15947, 7, 17, 0, 0, 15947, + 2104, 1, 0, 0, 0, 15948, 15949, 7, 7, 0, 0, 15949, 15950, 7, 2, 0, 0, 15950, + 15951, 7, 7, 0, 0, 15951, 15952, 7, 6, 0, 0, 15952, 15953, 7, 9, 0, 0, + 15953, 15954, 7, 12, 0, 0, 15954, 15955, 7, 4, 0, 0, 15955, 15956, 7, 12, + 0, 0, 15956, 15957, 7, 2, 0, 0, 15957, 15958, 7, 7, 0, 0, 15958, 15959, + 7, 0, 0, 0, 15959, 15960, 7, 1, 0, 0, 15960, 15961, 7, 11, 0, 0, 15961, + 15962, 7, 6, 0, 0, 15962, 2106, 1, 0, 0, 0, 15963, 15964, 7, 7, 0, 0, 15964, + 15965, 7, 2, 0, 0, 15965, 15966, 7, 7, 0, 0, 15966, 15967, 7, 6, 0, 0, + 15967, 2108, 1, 0, 0, 0, 15968, 15969, 7, 7, 0, 0, 15969, 15970, 7, 2, + 0, 0, 15970, 15971, 5, 95, 0, 0, 15971, 15972, 7, 7, 0, 0, 15972, 15973, + 7, 11, 0, 0, 15973, 15974, 7, 20, 0, 0, 15974, 15975, 5, 95, 0, 0, 15975, + 15976, 7, 1, 0, 0, 15976, 15977, 7, 0, 0, 0, 15977, 15978, 7, 4, 0, 0, + 15978, 15979, 7, 8, 0, 0, 15979, 15980, 7, 19, 0, 0, 15980, 15981, 7, 12, + 0, 0, 15981, 15982, 7, 7, 0, 0, 15982, 15983, 7, 17, 0, 0, 15983, 2110, + 1, 0, 0, 0, 15984, 15985, 7, 7, 0, 0, 15985, 15986, 7, 2, 0, 0, 15986, + 15987, 5, 95, 0, 0, 15987, 15988, 7, 7, 0, 0, 15988, 15989, 7, 11, 0, 0, + 15989, 15990, 7, 20, 0, 0, 15990, 15991, 5, 95, 0, 0, 15991, 15992, 7, + 15, 0, 0, 15992, 15993, 7, 3, 0, 0, 15993, 15994, 7, 6, 0, 0, 15994, 15995, + 7, 16, 0, 0, 15995, 15996, 7, 6, 0, 0, 15996, 15997, 7, 4, 0, 0, 15997, + 15998, 7, 8, 0, 0, 15998, 15999, 7, 19, 0, 0, 15999, 2112, 1, 0, 0, 0, + 16000, 16001, 7, 7, 0, 0, 16001, 16002, 7, 2, 0, 0, 16002, 2114, 1, 0, + 0, 0, 16003, 16004, 7, 7, 0, 0, 16004, 16005, 7, 2, 0, 0, 16005, 16006, + 7, 7, 0, 0, 16006, 16007, 7, 5, 0, 0, 16007, 16008, 7, 8, 0, 0, 16008, + 16009, 7, 19, 0, 0, 16009, 16010, 7, 6, 0, 0, 16010, 16011, 7, 14, 0, 0, + 16011, 16012, 7, 0, 0, 0, 16012, 2116, 1, 0, 0, 0, 16013, 16014, 7, 7, + 0, 0, 16014, 16015, 7, 2, 0, 0, 16015, 16016, 5, 95, 0, 0, 16016, 16017, + 7, 2, 0, 0, 16017, 16018, 7, 1, 0, 0, 16018, 16019, 7, 20, 0, 0, 16019, + 16020, 7, 6, 0, 0, 16020, 16021, 7, 8, 0, 0, 16021, 16022, 7, 4, 0, 0, + 16022, 16023, 5, 95, 0, 0, 16023, 16024, 7, 11, 0, 0, 16024, 16025, 7, + 12, 0, 0, 16025, 16026, 7, 7, 0, 0, 16026, 16027, 7, 21, 0, 0, 16027, 2118, + 1, 0, 0, 0, 16028, 16029, 7, 7, 0, 0, 16029, 16030, 7, 2, 0, 0, 16030, + 16031, 7, 2, 0, 0, 16031, 16032, 7, 3, 0, 0, 16032, 16033, 7, 9, 0, 0, + 16033, 16034, 7, 6, 0, 0, 16034, 16035, 7, 3, 0, 0, 16035, 2120, 1, 0, + 0, 0, 16036, 16037, 7, 7, 0, 0, 16037, 16038, 7, 2, 0, 0, 16038, 16039, + 5, 95, 0, 0, 16039, 16040, 7, 2, 0, 0, 16040, 16041, 7, 3, 0, 0, 16041, + 16042, 7, 9, 0, 0, 16042, 16043, 7, 6, 0, 0, 16043, 16044, 7, 3, 0, 0, + 16044, 16045, 5, 95, 0, 0, 16045, 16046, 7, 3, 0, 0, 16046, 16047, 7, 2, + 0, 0, 16047, 16048, 7, 11, 0, 0, 16048, 16049, 7, 11, 0, 0, 16049, 16050, + 7, 10, 0, 0, 16050, 16051, 7, 15, 0, 0, 16051, 16052, 7, 5, 0, 0, 16052, + 2122, 1, 0, 0, 0, 16053, 16054, 7, 7, 0, 0, 16054, 16055, 7, 2, 0, 0, 16055, + 16056, 5, 95, 0, 0, 16056, 16057, 7, 2, 0, 0, 16057, 16058, 7, 10, 0, 0, + 16058, 16059, 7, 4, 0, 0, 16059, 16060, 7, 6, 0, 0, 16060, 16061, 7, 3, + 0, 0, 16061, 16062, 5, 95, 0, 0, 16062, 16063, 7, 20, 0, 0, 16063, 16064, + 7, 2, 0, 0, 16064, 16065, 7, 12, 0, 0, 16065, 16066, 7, 7, 0, 0, 16066, + 16067, 5, 95, 0, 0, 16067, 16068, 7, 4, 0, 0, 16068, 16069, 7, 2, 0, 0, + 16069, 16070, 5, 95, 0, 0, 16070, 16071, 7, 0, 0, 0, 16071, 16072, 7, 7, + 0, 0, 16072, 16073, 7, 4, 0, 0, 16073, 16074, 7, 12, 0, 0, 16074, 2124, + 1, 0, 0, 0, 16075, 16076, 7, 7, 0, 0, 16076, 16077, 7, 2, 0, 0, 16077, + 16078, 5, 95, 0, 0, 16078, 16079, 7, 2, 0, 0, 16079, 16080, 7, 10, 0, 0, + 16080, 16081, 7, 4, 0, 0, 16081, 16082, 7, 6, 0, 0, 16082, 16083, 7, 3, + 0, 0, 16083, 16084, 5, 95, 0, 0, 16084, 16085, 7, 20, 0, 0, 16085, 16086, + 7, 2, 0, 0, 16086, 16087, 7, 12, 0, 0, 16087, 16088, 7, 7, 0, 0, 16088, + 16089, 5, 95, 0, 0, 16089, 16090, 7, 4, 0, 0, 16090, 16091, 7, 2, 0, 0, + 16091, 16092, 5, 95, 0, 0, 16092, 16093, 7, 12, 0, 0, 16093, 16094, 7, + 7, 0, 0, 16094, 16095, 7, 7, 0, 0, 16095, 16096, 7, 6, 0, 0, 16096, 16097, + 7, 3, 0, 0, 16097, 2126, 1, 0, 0, 0, 16098, 16099, 7, 7, 0, 0, 16099, 16100, + 7, 2, 0, 0, 16100, 16101, 7, 2, 0, 0, 16101, 16102, 7, 13, 0, 0, 16102, + 16103, 7, 6, 0, 0, 16103, 16104, 7, 3, 0, 0, 16104, 16105, 7, 3, 0, 0, + 16105, 16106, 7, 12, 0, 0, 16106, 16107, 7, 9, 0, 0, 16107, 16108, 7, 6, + 0, 0, 16108, 2128, 1, 0, 0, 0, 16109, 16110, 7, 7, 0, 0, 16110, 16111, + 7, 2, 0, 0, 16111, 16112, 5, 95, 0, 0, 16112, 16113, 7, 15, 0, 0, 16113, + 16114, 7, 0, 0, 0, 16114, 16115, 7, 3, 0, 0, 16115, 16116, 7, 0, 0, 0, + 16116, 16117, 7, 11, 0, 0, 16117, 16118, 7, 11, 0, 0, 16118, 16119, 7, + 6, 0, 0, 16119, 16120, 7, 11, 0, 0, 16120, 16121, 5, 95, 0, 0, 16121, 16122, + 7, 12, 0, 0, 16122, 16123, 7, 7, 0, 0, 16123, 16124, 7, 9, 0, 0, 16124, + 16125, 7, 6, 0, 0, 16125, 16126, 7, 25, 0, 0, 16126, 2130, 1, 0, 0, 0, + 16127, 16128, 7, 7, 0, 0, 16128, 16129, 7, 2, 0, 0, 16129, 16130, 7, 15, + 0, 0, 16130, 16131, 7, 0, 0, 0, 16131, 16132, 7, 3, 0, 0, 16132, 16133, + 7, 0, 0, 0, 16133, 16134, 7, 11, 0, 0, 16134, 16135, 7, 11, 0, 0, 16135, + 16136, 7, 6, 0, 0, 16136, 16137, 7, 11, 0, 0, 16137, 16138, 5, 95, 0, 0, + 16138, 16139, 7, 12, 0, 0, 16139, 16140, 7, 7, 0, 0, 16140, 16141, 7, 9, + 0, 0, 16141, 16142, 7, 6, 0, 0, 16142, 16143, 7, 25, 0, 0, 16143, 2132, + 1, 0, 0, 0, 16144, 16145, 7, 7, 0, 0, 16145, 16146, 7, 2, 0, 0, 16146, + 16147, 5, 95, 0, 0, 16147, 16148, 7, 15, 0, 0, 16148, 16149, 7, 0, 0, 0, + 16149, 16150, 7, 3, 0, 0, 16150, 16151, 7, 0, 0, 0, 16151, 16152, 7, 11, + 0, 0, 16152, 16153, 7, 11, 0, 0, 16153, 16154, 7, 6, 0, 0, 16154, 16155, + 7, 11, 0, 0, 16155, 2134, 1, 0, 0, 0, 16156, 16157, 7, 7, 0, 0, 16157, + 16158, 7, 2, 0, 0, 16158, 16159, 7, 15, 0, 0, 16159, 16160, 7, 0, 0, 0, + 16160, 16161, 7, 3, 0, 0, 16161, 16162, 7, 0, 0, 0, 16162, 16163, 7, 11, + 0, 0, 16163, 16164, 7, 11, 0, 0, 16164, 16165, 7, 6, 0, 0, 16165, 16166, + 7, 11, 0, 0, 16166, 2136, 1, 0, 0, 0, 16167, 16168, 7, 7, 0, 0, 16168, + 16169, 7, 2, 0, 0, 16169, 16170, 5, 95, 0, 0, 16170, 16171, 7, 15, 0, 0, + 16171, 16172, 7, 0, 0, 0, 16172, 16173, 7, 3, 0, 0, 16173, 16174, 7, 4, + 0, 0, 16174, 16175, 7, 12, 0, 0, 16175, 16176, 7, 0, 0, 0, 16176, 16177, + 7, 11, 0, 0, 16177, 16178, 5, 95, 0, 0, 16178, 16179, 7, 8, 0, 0, 16179, + 16180, 7, 2, 0, 0, 16180, 16181, 7, 14, 0, 0, 16181, 16182, 7, 14, 0, 0, + 16182, 16183, 7, 12, 0, 0, 16183, 16184, 7, 4, 0, 0, 16184, 2138, 1, 0, + 0, 0, 16185, 16186, 7, 7, 0, 0, 16186, 16187, 7, 2, 0, 0, 16187, 16188, + 5, 95, 0, 0, 16188, 16189, 7, 15, 0, 0, 16189, 16190, 7, 0, 0, 0, 16190, + 16191, 7, 3, 0, 0, 16191, 16192, 7, 4, 0, 0, 16192, 16193, 7, 12, 0, 0, + 16193, 16194, 7, 0, 0, 0, 16194, 16195, 7, 11, 0, 0, 16195, 16196, 5, 95, + 0, 0, 16196, 16197, 7, 20, 0, 0, 16197, 16198, 7, 2, 0, 0, 16198, 16199, + 7, 12, 0, 0, 16199, 16200, 7, 7, 0, 0, 16200, 2140, 1, 0, 0, 0, 16201, + 16202, 7, 7, 0, 0, 16202, 16203, 7, 2, 0, 0, 16203, 16204, 5, 95, 0, 0, + 16204, 16205, 7, 15, 0, 0, 16205, 16206, 7, 0, 0, 0, 16206, 16207, 7, 3, + 0, 0, 16207, 16208, 7, 4, 0, 0, 16208, 16209, 7, 12, 0, 0, 16209, 16210, + 7, 0, 0, 0, 16210, 16211, 7, 11, 0, 0, 16211, 16212, 5, 95, 0, 0, 16212, + 16213, 7, 3, 0, 0, 16213, 16214, 7, 2, 0, 0, 16214, 16215, 7, 11, 0, 0, + 16215, 16216, 7, 11, 0, 0, 16216, 16217, 7, 10, 0, 0, 16217, 16218, 7, + 15, 0, 0, 16218, 16219, 5, 95, 0, 0, 16219, 16220, 7, 15, 0, 0, 16220, + 16221, 7, 10, 0, 0, 16221, 16222, 7, 5, 0, 0, 16222, 16223, 7, 19, 0, 0, + 16223, 16224, 7, 9, 0, 0, 16224, 16225, 7, 2, 0, 0, 16225, 16226, 7, 22, + 0, 0, 16226, 16227, 7, 7, 0, 0, 16227, 2142, 1, 0, 0, 0, 16228, 16229, + 7, 7, 0, 0, 16229, 16230, 7, 2, 0, 0, 16230, 16231, 7, 15, 0, 0, 16231, + 16232, 7, 0, 0, 0, 16232, 16233, 7, 3, 0, 0, 16233, 16234, 7, 4, 0, 0, + 16234, 16235, 7, 12, 0, 0, 16235, 16236, 7, 4, 0, 0, 16236, 16237, 7, 12, + 0, 0, 16237, 16238, 7, 2, 0, 0, 16238, 16239, 7, 7, 0, 0, 16239, 2144, + 1, 0, 0, 0, 16240, 16241, 7, 7, 0, 0, 16241, 16242, 7, 2, 0, 0, 16242, + 16243, 5, 95, 0, 0, 16243, 16244, 7, 15, 0, 0, 16244, 16245, 7, 11, 0, + 0, 16245, 16246, 7, 0, 0, 0, 16246, 16247, 7, 8, 0, 0, 16247, 16248, 7, + 6, 0, 0, 16248, 16249, 5, 95, 0, 0, 16249, 16250, 7, 9, 0, 0, 16250, 16251, + 7, 12, 0, 0, 16251, 16252, 7, 5, 0, 0, 16252, 16253, 7, 4, 0, 0, 16253, + 16254, 7, 12, 0, 0, 16254, 16255, 7, 7, 0, 0, 16255, 16256, 7, 8, 0, 0, + 16256, 16257, 7, 4, 0, 0, 16257, 2146, 1, 0, 0, 0, 16258, 16259, 7, 7, + 0, 0, 16259, 16260, 7, 2, 0, 0, 16260, 16261, 5, 95, 0, 0, 16261, 16262, + 7, 15, 0, 0, 16262, 16263, 7, 11, 0, 0, 16263, 16264, 7, 0, 0, 0, 16264, + 16265, 7, 8, 0, 0, 16265, 16266, 7, 6, 0, 0, 16266, 16267, 5, 95, 0, 0, + 16267, 16268, 7, 17, 0, 0, 16268, 16269, 7, 3, 0, 0, 16269, 16270, 7, 2, + 0, 0, 16270, 16271, 7, 10, 0, 0, 16271, 16272, 7, 15, 0, 0, 16272, 16273, + 5, 95, 0, 0, 16273, 16274, 7, 1, 0, 0, 16274, 16275, 7, 18, 0, 0, 16275, + 2148, 1, 0, 0, 0, 16276, 16277, 7, 7, 0, 0, 16277, 16278, 7, 2, 0, 0, 16278, + 16279, 5, 95, 0, 0, 16279, 16280, 7, 15, 0, 0, 16280, 16281, 7, 24, 0, + 0, 16281, 16282, 5, 95, 0, 0, 16282, 16283, 7, 8, 0, 0, 16283, 16284, 7, + 2, 0, 0, 16284, 16285, 7, 7, 0, 0, 16285, 16286, 7, 8, 0, 0, 16286, 16287, + 7, 10, 0, 0, 16287, 16288, 7, 3, 0, 0, 16288, 16289, 7, 3, 0, 0, 16289, + 16290, 7, 6, 0, 0, 16290, 16291, 7, 7, 0, 0, 16291, 16292, 7, 4, 0, 0, + 16292, 16293, 5, 95, 0, 0, 16293, 16294, 7, 10, 0, 0, 16294, 16295, 7, + 7, 0, 0, 16295, 16296, 7, 12, 0, 0, 16296, 16297, 7, 2, 0, 0, 16297, 16298, + 7, 7, 0, 0, 16298, 2150, 1, 0, 0, 0, 16299, 16300, 7, 7, 0, 0, 16300, 16301, + 7, 2, 0, 0, 16301, 16302, 5, 95, 0, 0, 16302, 16303, 7, 15, 0, 0, 16303, + 16304, 7, 24, 0, 0, 16304, 16305, 5, 95, 0, 0, 16305, 16306, 7, 14, 0, + 0, 16306, 16307, 7, 0, 0, 0, 16307, 16308, 7, 15, 0, 0, 16308, 2152, 1, + 0, 0, 0, 16309, 16310, 7, 7, 0, 0, 16310, 16311, 7, 2, 0, 0, 16311, 16312, + 7, 15, 0, 0, 16312, 16313, 7, 3, 0, 0, 16313, 16314, 7, 2, 0, 0, 16314, + 16315, 7, 14, 0, 0, 16315, 16316, 7, 15, 0, 0, 16316, 16317, 7, 4, 0, 0, + 16317, 2154, 1, 0, 0, 0, 16318, 16319, 7, 7, 0, 0, 16319, 16320, 7, 2, + 0, 0, 16320, 16321, 5, 95, 0, 0, 16321, 16322, 7, 15, 0, 0, 16322, 16323, + 7, 24, 0, 0, 16323, 16324, 5, 95, 0, 0, 16324, 16325, 7, 3, 0, 0, 16325, + 16326, 7, 6, 0, 0, 16326, 16327, 7, 15, 0, 0, 16327, 16328, 7, 11, 0, 0, + 16328, 16329, 7, 12, 0, 0, 16329, 16330, 7, 8, 0, 0, 16330, 16331, 7, 0, + 0, 0, 16331, 16332, 7, 4, 0, 0, 16332, 16333, 7, 6, 0, 0, 16333, 2156, + 1, 0, 0, 0, 16334, 16335, 7, 7, 0, 0, 16335, 16336, 7, 2, 0, 0, 16336, + 16337, 5, 95, 0, 0, 16337, 16338, 7, 15, 0, 0, 16338, 16339, 7, 24, 0, + 0, 16339, 16340, 5, 95, 0, 0, 16340, 16341, 7, 5, 0, 0, 16341, 16342, 7, + 21, 0, 0, 16342, 16343, 7, 6, 0, 0, 16343, 16344, 7, 22, 0, 0, 16344, 2158, + 1, 0, 0, 0, 16345, 16346, 7, 7, 0, 0, 16346, 16347, 7, 2, 0, 0, 16347, + 16348, 5, 95, 0, 0, 16348, 16349, 7, 15, 0, 0, 16349, 16350, 7, 3, 0, 0, + 16350, 16351, 7, 10, 0, 0, 16351, 16352, 7, 7, 0, 0, 16352, 16353, 7, 6, + 0, 0, 16353, 16354, 5, 95, 0, 0, 16354, 16355, 7, 17, 0, 0, 16355, 16356, + 7, 5, 0, 0, 16356, 16357, 7, 6, 0, 0, 16357, 16358, 7, 4, 0, 0, 16358, + 16359, 7, 5, 0, 0, 16359, 2160, 1, 0, 0, 0, 16360, 16361, 7, 7, 0, 0, 16361, + 16362, 7, 2, 0, 0, 16362, 16363, 5, 95, 0, 0, 16363, 16364, 7, 15, 0, 0, + 16364, 16365, 7, 10, 0, 0, 16365, 16366, 7, 11, 0, 0, 16366, 16367, 7, + 11, 0, 0, 16367, 16368, 5, 95, 0, 0, 16368, 16369, 7, 15, 0, 0, 16369, + 16370, 7, 3, 0, 0, 16370, 16371, 7, 6, 0, 0, 16371, 16372, 7, 9, 0, 0, + 16372, 2162, 1, 0, 0, 0, 16373, 16374, 7, 7, 0, 0, 16374, 16375, 7, 2, + 0, 0, 16375, 16376, 5, 95, 0, 0, 16376, 16377, 7, 15, 0, 0, 16377, 16378, + 7, 10, 0, 0, 16378, 16379, 7, 5, 0, 0, 16379, 16380, 7, 19, 0, 0, 16380, + 16381, 5, 95, 0, 0, 16381, 16382, 7, 15, 0, 0, 16382, 16383, 7, 3, 0, 0, + 16383, 16384, 7, 6, 0, 0, 16384, 16385, 7, 9, 0, 0, 16385, 2164, 1, 0, + 0, 0, 16386, 16387, 7, 7, 0, 0, 16387, 16388, 7, 2, 0, 0, 16388, 16389, + 5, 95, 0, 0, 16389, 16390, 7, 15, 0, 0, 16390, 16391, 7, 10, 0, 0, 16391, + 16392, 7, 5, 0, 0, 16392, 16393, 7, 19, 0, 0, 16393, 16394, 5, 95, 0, 0, + 16394, 16395, 7, 5, 0, 0, 16395, 16396, 7, 10, 0, 0, 16396, 16397, 7, 1, + 0, 0, 16397, 16398, 7, 24, 0, 0, 16398, 2166, 1, 0, 0, 0, 16399, 16400, + 7, 7, 0, 0, 16400, 16401, 7, 2, 0, 0, 16401, 16402, 5, 95, 0, 0, 16402, + 16403, 7, 15, 0, 0, 16403, 16404, 7, 25, 0, 0, 16404, 16405, 5, 95, 0, + 0, 16405, 16406, 7, 16, 0, 0, 16406, 16407, 7, 0, 0, 0, 16407, 16408, 7, + 10, 0, 0, 16408, 16409, 7, 11, 0, 0, 16409, 16410, 7, 4, 0, 0, 16410, 16411, + 5, 95, 0, 0, 16411, 16412, 7, 4, 0, 0, 16412, 16413, 7, 2, 0, 0, 16413, + 16414, 7, 11, 0, 0, 16414, 16415, 7, 6, 0, 0, 16415, 16416, 7, 3, 0, 0, + 16416, 16417, 7, 0, 0, 0, 16417, 16418, 7, 7, 0, 0, 16418, 16419, 7, 8, + 0, 0, 16419, 16420, 7, 6, 0, 0, 16420, 2168, 1, 0, 0, 0, 16421, 16422, + 7, 7, 0, 0, 16422, 16423, 7, 2, 0, 0, 16423, 16424, 5, 95, 0, 0, 16424, + 16425, 7, 15, 0, 0, 16425, 16426, 7, 25, 0, 0, 16426, 16427, 5, 95, 0, + 0, 16427, 16428, 7, 20, 0, 0, 16428, 16429, 7, 2, 0, 0, 16429, 16430, 7, + 12, 0, 0, 16430, 16431, 7, 7, 0, 0, 16431, 16432, 5, 95, 0, 0, 16432, 16433, + 7, 16, 0, 0, 16433, 16434, 7, 12, 0, 0, 16434, 16435, 7, 11, 0, 0, 16435, + 16436, 7, 4, 0, 0, 16436, 16437, 7, 6, 0, 0, 16437, 16438, 7, 3, 0, 0, + 16438, 2170, 1, 0, 0, 0, 16439, 16440, 7, 7, 0, 0, 16440, 16441, 7, 2, + 0, 0, 16441, 16442, 5, 95, 0, 0, 16442, 16443, 7, 24, 0, 0, 16443, 16444, + 7, 21, 0, 0, 16444, 16445, 7, 7, 0, 0, 16445, 16446, 5, 95, 0, 0, 16446, + 16447, 7, 1, 0, 0, 16447, 16448, 7, 10, 0, 0, 16448, 16449, 7, 16, 0, 0, + 16449, 16450, 7, 16, 0, 0, 16450, 2172, 1, 0, 0, 0, 16451, 16452, 7, 7, + 0, 0, 16452, 16453, 7, 2, 0, 0, 16453, 16454, 5, 95, 0, 0, 16454, 16455, + 7, 24, 0, 0, 16455, 16456, 7, 10, 0, 0, 16456, 16457, 7, 6, 0, 0, 16457, + 16458, 7, 3, 0, 0, 16458, 16459, 7, 18, 0, 0, 16459, 16460, 5, 95, 0, 0, + 16460, 16461, 7, 4, 0, 0, 16461, 16462, 7, 3, 0, 0, 16462, 16463, 7, 0, + 0, 0, 16463, 16464, 7, 7, 0, 0, 16464, 16465, 7, 5, 0, 0, 16465, 16466, + 7, 16, 0, 0, 16466, 16467, 7, 2, 0, 0, 16467, 16468, 7, 3, 0, 0, 16468, + 16469, 7, 14, 0, 0, 16469, 16470, 7, 0, 0, 0, 16470, 16471, 7, 4, 0, 0, + 16471, 16472, 7, 12, 0, 0, 16472, 16473, 7, 2, 0, 0, 16473, 16474, 7, 7, + 0, 0, 16474, 2174, 1, 0, 0, 0, 16475, 16476, 7, 7, 0, 0, 16476, 16477, + 7, 2, 0, 0, 16477, 16478, 5, 95, 0, 0, 16478, 16479, 7, 3, 0, 0, 16479, + 16480, 7, 6, 0, 0, 16480, 16481, 7, 16, 0, 0, 16481, 16482, 5, 95, 0, 0, + 16482, 16483, 7, 8, 0, 0, 16483, 16484, 7, 0, 0, 0, 16484, 16485, 7, 5, + 0, 0, 16485, 16486, 7, 8, 0, 0, 16486, 16487, 7, 0, 0, 0, 16487, 16488, + 7, 9, 0, 0, 16488, 16489, 7, 6, 0, 0, 16489, 2176, 1, 0, 0, 0, 16490, 16491, + 7, 7, 0, 0, 16491, 16492, 7, 2, 0, 0, 16492, 16493, 7, 3, 0, 0, 16493, + 16494, 7, 6, 0, 0, 16494, 16495, 7, 11, 0, 0, 16495, 16496, 7, 2, 0, 0, + 16496, 16497, 7, 8, 0, 0, 16497, 16498, 7, 0, 0, 0, 16498, 16499, 7, 4, + 0, 0, 16499, 16500, 7, 6, 0, 0, 16500, 2178, 1, 0, 0, 0, 16501, 16502, + 7, 7, 0, 0, 16502, 16503, 7, 2, 0, 0, 16503, 16504, 7, 3, 0, 0, 16504, + 16505, 7, 6, 0, 0, 16505, 16506, 7, 11, 0, 0, 16506, 16507, 7, 18, 0, 0, + 16507, 2180, 1, 0, 0, 0, 16508, 16509, 7, 7, 0, 0, 16509, 16510, 7, 2, + 0, 0, 16510, 16511, 7, 3, 0, 0, 16511, 16512, 7, 6, 0, 0, 16512, 16513, + 7, 15, 0, 0, 16513, 16514, 7, 0, 0, 0, 16514, 16515, 7, 12, 0, 0, 16515, + 16516, 7, 3, 0, 0, 16516, 2182, 1, 0, 0, 0, 16517, 16518, 7, 7, 0, 0, 16518, + 16519, 7, 2, 0, 0, 16519, 16520, 7, 3, 0, 0, 16520, 16521, 7, 6, 0, 0, + 16521, 16522, 7, 15, 0, 0, 16522, 16523, 7, 11, 0, 0, 16523, 16524, 7, + 0, 0, 0, 16524, 16525, 7, 18, 0, 0, 16525, 2184, 1, 0, 0, 0, 16526, 16527, + 7, 7, 0, 0, 16527, 16528, 7, 2, 0, 0, 16528, 16529, 7, 3, 0, 0, 16529, + 16530, 7, 6, 0, 0, 16530, 16531, 7, 5, 0, 0, 16531, 16532, 7, 6, 0, 0, + 16532, 16533, 7, 4, 0, 0, 16533, 16534, 7, 11, 0, 0, 16534, 16535, 7, 2, + 0, 0, 16535, 16536, 7, 17, 0, 0, 16536, 16537, 7, 5, 0, 0, 16537, 2186, + 1, 0, 0, 0, 16538, 16539, 7, 7, 0, 0, 16539, 16540, 7, 2, 0, 0, 16540, + 16541, 5, 95, 0, 0, 16541, 16542, 7, 3, 0, 0, 16542, 16543, 7, 6, 0, 0, + 16543, 16544, 7, 5, 0, 0, 16544, 16545, 7, 10, 0, 0, 16545, 16546, 7, 11, + 0, 0, 16546, 16547, 7, 4, 0, 0, 16547, 16548, 5, 95, 0, 0, 16548, 16549, + 7, 8, 0, 0, 16549, 16550, 7, 0, 0, 0, 16550, 16551, 7, 8, 0, 0, 16551, + 16552, 7, 19, 0, 0, 16552, 16553, 7, 6, 0, 0, 16553, 2188, 1, 0, 0, 0, + 16554, 16555, 7, 7, 0, 0, 16555, 16556, 7, 2, 0, 0, 16556, 16557, 7, 3, + 0, 0, 16557, 16558, 7, 6, 0, 0, 16558, 16559, 7, 13, 0, 0, 16559, 16560, + 7, 6, 0, 0, 16560, 16561, 7, 3, 0, 0, 16561, 16562, 7, 5, 0, 0, 16562, + 16563, 7, 6, 0, 0, 16563, 2190, 1, 0, 0, 0, 16564, 16565, 7, 7, 0, 0, 16565, + 16566, 7, 2, 0, 0, 16566, 16567, 5, 95, 0, 0, 16567, 16568, 7, 3, 0, 0, + 16568, 16569, 7, 6, 0, 0, 16569, 16570, 7, 22, 0, 0, 16570, 16571, 7, 3, + 0, 0, 16571, 16572, 7, 12, 0, 0, 16572, 16573, 7, 4, 0, 0, 16573, 16574, + 7, 6, 0, 0, 16574, 2192, 1, 0, 0, 0, 16575, 16576, 7, 7, 0, 0, 16576, 16577, + 7, 2, 0, 0, 16577, 16578, 7, 3, 0, 0, 16578, 16579, 7, 6, 0, 0, 16579, + 16580, 7, 22, 0, 0, 16580, 16581, 7, 3, 0, 0, 16581, 16582, 7, 12, 0, 0, + 16582, 16583, 7, 4, 0, 0, 16583, 16584, 7, 6, 0, 0, 16584, 2194, 1, 0, + 0, 0, 16585, 16586, 7, 7, 0, 0, 16586, 16587, 7, 2, 0, 0, 16587, 16588, + 7, 3, 0, 0, 16588, 16589, 7, 14, 0, 0, 16589, 16590, 7, 0, 0, 0, 16590, + 16591, 7, 11, 0, 0, 16591, 2196, 1, 0, 0, 0, 16592, 16593, 7, 7, 0, 0, + 16593, 16594, 7, 2, 0, 0, 16594, 16595, 5, 95, 0, 0, 16595, 16596, 7, 3, + 0, 0, 16596, 16597, 7, 2, 0, 0, 16597, 16598, 7, 2, 0, 0, 16598, 16599, + 7, 4, 0, 0, 16599, 16600, 5, 95, 0, 0, 16600, 16601, 7, 5, 0, 0, 16601, + 16602, 7, 22, 0, 0, 16602, 16603, 5, 95, 0, 0, 16603, 16604, 7, 16, 0, + 0, 16604, 16605, 7, 2, 0, 0, 16605, 16606, 7, 3, 0, 0, 16606, 16607, 5, + 95, 0, 0, 16607, 16608, 7, 11, 0, 0, 16608, 16609, 7, 2, 0, 0, 16609, 16610, + 7, 8, 0, 0, 16610, 16611, 7, 0, 0, 0, 16611, 16612, 7, 11, 0, 0, 16612, + 2198, 1, 0, 0, 0, 16613, 16614, 7, 7, 0, 0, 16614, 16615, 7, 2, 0, 0, 16615, + 16616, 7, 3, 0, 0, 16616, 16617, 7, 2, 0, 0, 16617, 16618, 7, 22, 0, 0, + 16618, 16619, 7, 9, 0, 0, 16619, 16620, 7, 6, 0, 0, 16620, 16621, 7, 15, + 0, 0, 16621, 16622, 7, 6, 0, 0, 16622, 16623, 7, 7, 0, 0, 16623, 16624, + 7, 9, 0, 0, 16624, 16625, 7, 6, 0, 0, 16625, 16626, 7, 7, 0, 0, 16626, + 16627, 7, 8, 0, 0, 16627, 16628, 7, 12, 0, 0, 16628, 16629, 7, 6, 0, 0, + 16629, 16630, 7, 5, 0, 0, 16630, 2200, 1, 0, 0, 0, 16631, 16632, 7, 7, + 0, 0, 16632, 16633, 7, 2, 0, 0, 16633, 16634, 7, 5, 0, 0, 16634, 16635, + 7, 8, 0, 0, 16635, 16636, 7, 19, 0, 0, 16636, 16637, 7, 6, 0, 0, 16637, + 16638, 7, 14, 0, 0, 16638, 16639, 7, 0, 0, 0, 16639, 16640, 7, 8, 0, 0, + 16640, 16641, 7, 19, 0, 0, 16641, 16642, 7, 6, 0, 0, 16642, 16643, 7, 8, + 0, 0, 16643, 16644, 7, 21, 0, 0, 16644, 2202, 1, 0, 0, 0, 16645, 16646, + 7, 7, 0, 0, 16646, 16647, 7, 2, 0, 0, 16647, 16648, 7, 5, 0, 0, 16648, + 16649, 7, 6, 0, 0, 16649, 16650, 7, 17, 0, 0, 16650, 16651, 7, 14, 0, 0, + 16651, 16652, 7, 6, 0, 0, 16652, 16653, 7, 7, 0, 0, 16653, 16654, 7, 4, + 0, 0, 16654, 2204, 1, 0, 0, 0, 16655, 16656, 7, 7, 0, 0, 16656, 16657, + 7, 2, 0, 0, 16657, 16658, 5, 95, 0, 0, 16658, 16659, 7, 5, 0, 0, 16659, + 16660, 7, 6, 0, 0, 16660, 16661, 7, 14, 0, 0, 16661, 16662, 7, 12, 0, 0, + 16662, 16663, 7, 20, 0, 0, 16663, 16664, 7, 2, 0, 0, 16664, 16665, 7, 12, + 0, 0, 16665, 16666, 7, 7, 0, 0, 16666, 2206, 1, 0, 0, 0, 16667, 16668, + 7, 7, 0, 0, 16668, 16669, 7, 2, 0, 0, 16669, 16670, 5, 95, 0, 0, 16670, + 16671, 7, 5, 0, 0, 16671, 16672, 7, 6, 0, 0, 16672, 16673, 7, 14, 0, 0, + 16673, 16674, 7, 12, 0, 0, 16674, 16675, 5, 95, 0, 0, 16675, 16676, 7, + 4, 0, 0, 16676, 16677, 7, 2, 0, 0, 16677, 16678, 5, 95, 0, 0, 16678, 16679, + 7, 12, 0, 0, 16679, 16680, 7, 7, 0, 0, 16680, 16681, 7, 7, 0, 0, 16681, + 16682, 7, 6, 0, 0, 16682, 16683, 7, 3, 0, 0, 16683, 2208, 1, 0, 0, 0, 16684, + 16685, 7, 7, 0, 0, 16685, 16686, 7, 2, 0, 0, 16686, 16687, 5, 95, 0, 0, + 16687, 16688, 7, 5, 0, 0, 16688, 16689, 7, 6, 0, 0, 16689, 16690, 7, 4, + 0, 0, 16690, 16691, 5, 95, 0, 0, 16691, 16692, 7, 4, 0, 0, 16692, 16693, + 7, 2, 0, 0, 16693, 16694, 5, 95, 0, 0, 16694, 16695, 7, 20, 0, 0, 16695, + 16696, 7, 2, 0, 0, 16696, 16697, 7, 12, 0, 0, 16697, 16698, 7, 7, 0, 0, + 16698, 2210, 1, 0, 0, 0, 16699, 16700, 7, 7, 0, 0, 16700, 16701, 7, 2, + 0, 0, 16701, 16702, 7, 5, 0, 0, 16702, 16703, 7, 2, 0, 0, 16703, 16704, + 7, 3, 0, 0, 16704, 16705, 7, 4, 0, 0, 16705, 2212, 1, 0, 0, 0, 16706, 16707, + 7, 7, 0, 0, 16707, 16708, 7, 2, 0, 0, 16708, 16709, 5, 95, 0, 0, 16709, + 16710, 7, 5, 0, 0, 16710, 16711, 7, 24, 0, 0, 16711, 16712, 7, 11, 0, 0, + 16712, 16713, 5, 95, 0, 0, 16713, 16714, 7, 4, 0, 0, 16714, 16715, 7, 3, + 0, 0, 16715, 16716, 7, 0, 0, 0, 16716, 16717, 7, 7, 0, 0, 16717, 16718, + 7, 5, 0, 0, 16718, 16719, 7, 11, 0, 0, 16719, 16720, 7, 0, 0, 0, 16720, + 16721, 7, 4, 0, 0, 16721, 16722, 7, 12, 0, 0, 16722, 16723, 7, 2, 0, 0, + 16723, 16724, 7, 7, 0, 0, 16724, 2214, 1, 0, 0, 0, 16725, 16726, 7, 7, + 0, 0, 16726, 16727, 7, 2, 0, 0, 16727, 16728, 5, 95, 0, 0, 16728, 16729, + 7, 5, 0, 0, 16729, 16730, 7, 24, 0, 0, 16730, 16731, 7, 11, 0, 0, 16731, + 16732, 5, 95, 0, 0, 16732, 16733, 7, 4, 0, 0, 16733, 16734, 7, 10, 0, 0, + 16734, 16735, 7, 7, 0, 0, 16735, 16736, 7, 6, 0, 0, 16736, 2216, 1, 0, + 0, 0, 16737, 16738, 7, 7, 0, 0, 16738, 16739, 7, 2, 0, 0, 16739, 16740, + 5, 95, 0, 0, 16740, 16741, 7, 5, 0, 0, 16741, 16742, 7, 4, 0, 0, 16742, + 16743, 7, 0, 0, 0, 16743, 16744, 7, 3, 0, 0, 16744, 16745, 5, 95, 0, 0, + 16745, 16746, 7, 4, 0, 0, 16746, 16747, 7, 3, 0, 0, 16747, 16748, 7, 0, + 0, 0, 16748, 16749, 7, 7, 0, 0, 16749, 16750, 7, 5, 0, 0, 16750, 16751, + 7, 16, 0, 0, 16751, 16752, 7, 2, 0, 0, 16752, 16753, 7, 3, 0, 0, 16753, + 16754, 7, 14, 0, 0, 16754, 16755, 7, 0, 0, 0, 16755, 16756, 7, 4, 0, 0, + 16756, 16757, 7, 12, 0, 0, 16757, 16758, 7, 2, 0, 0, 16758, 16759, 7, 7, + 0, 0, 16759, 2218, 1, 0, 0, 0, 16760, 16761, 7, 7, 0, 0, 16761, 16762, + 7, 2, 0, 0, 16762, 16763, 5, 95, 0, 0, 16763, 16764, 7, 5, 0, 0, 16764, + 16765, 7, 4, 0, 0, 16765, 16766, 7, 0, 0, 0, 16766, 16767, 7, 4, 0, 0, + 16767, 16768, 7, 6, 0, 0, 16768, 16769, 7, 14, 0, 0, 16769, 16770, 7, 6, + 0, 0, 16770, 16771, 7, 7, 0, 0, 16771, 16772, 7, 4, 0, 0, 16772, 16773, + 5, 95, 0, 0, 16773, 16774, 7, 24, 0, 0, 16774, 16775, 7, 10, 0, 0, 16775, + 16776, 7, 6, 0, 0, 16776, 16777, 7, 10, 0, 0, 16777, 16778, 7, 12, 0, 0, + 16778, 16779, 7, 7, 0, 0, 16779, 16780, 7, 17, 0, 0, 16780, 2220, 1, 0, + 0, 0, 16781, 16782, 7, 7, 0, 0, 16782, 16783, 7, 2, 0, 0, 16783, 16784, + 5, 95, 0, 0, 16784, 16785, 7, 5, 0, 0, 16785, 16786, 7, 4, 0, 0, 16786, + 16787, 7, 0, 0, 0, 16787, 16788, 7, 4, 0, 0, 16788, 16789, 7, 5, 0, 0, + 16789, 16790, 5, 95, 0, 0, 16790, 16791, 7, 17, 0, 0, 16791, 16792, 7, + 5, 0, 0, 16792, 16793, 7, 6, 0, 0, 16793, 16794, 7, 4, 0, 0, 16794, 16795, + 7, 5, 0, 0, 16795, 2222, 1, 0, 0, 0, 16796, 16797, 7, 7, 0, 0, 16797, 16798, + 7, 2, 0, 0, 16798, 16799, 7, 5, 0, 0, 16799, 16800, 7, 4, 0, 0, 16800, + 16801, 7, 3, 0, 0, 16801, 16802, 7, 12, 0, 0, 16802, 16803, 7, 8, 0, 0, + 16803, 16804, 7, 4, 0, 0, 16804, 2224, 1, 0, 0, 0, 16805, 16806, 7, 7, + 0, 0, 16806, 16807, 7, 2, 0, 0, 16807, 16808, 5, 95, 0, 0, 16808, 16809, + 7, 5, 0, 0, 16809, 16810, 7, 10, 0, 0, 16810, 16811, 7, 1, 0, 0, 16811, + 16812, 7, 24, 0, 0, 16812, 16813, 7, 10, 0, 0, 16813, 16814, 7, 6, 0, 0, + 16814, 16815, 7, 3, 0, 0, 16815, 16816, 7, 18, 0, 0, 16816, 16817, 5, 95, + 0, 0, 16817, 16818, 7, 15, 0, 0, 16818, 16819, 7, 3, 0, 0, 16819, 16820, + 7, 10, 0, 0, 16820, 16821, 7, 7, 0, 0, 16821, 16822, 7, 12, 0, 0, 16822, + 16823, 7, 7, 0, 0, 16823, 16824, 7, 17, 0, 0, 16824, 2226, 1, 0, 0, 0, + 16825, 16826, 7, 7, 0, 0, 16826, 16827, 7, 2, 0, 0, 16827, 16828, 5, 95, + 0, 0, 16828, 16829, 7, 5, 0, 0, 16829, 16830, 7, 10, 0, 0, 16830, 16831, + 7, 1, 0, 0, 16831, 16832, 7, 5, 0, 0, 16832, 16833, 7, 4, 0, 0, 16833, + 16834, 7, 3, 0, 0, 16834, 16835, 7, 1, 0, 0, 16835, 16836, 5, 95, 0, 0, + 16836, 16837, 7, 15, 0, 0, 16837, 16838, 7, 0, 0, 0, 16838, 16839, 7, 9, + 0, 0, 16839, 2228, 1, 0, 0, 0, 16840, 16841, 7, 7, 0, 0, 16841, 16842, + 7, 2, 0, 0, 16842, 16843, 5, 95, 0, 0, 16843, 16844, 7, 5, 0, 0, 16844, + 16845, 7, 22, 0, 0, 16845, 16846, 7, 0, 0, 0, 16846, 16847, 7, 15, 0, 0, + 16847, 16848, 5, 95, 0, 0, 16848, 16849, 7, 20, 0, 0, 16849, 16850, 7, + 2, 0, 0, 16850, 16851, 7, 12, 0, 0, 16851, 16852, 7, 7, 0, 0, 16852, 16853, + 5, 95, 0, 0, 16853, 16854, 7, 12, 0, 0, 16854, 16855, 7, 7, 0, 0, 16855, + 16856, 7, 15, 0, 0, 16856, 16857, 7, 10, 0, 0, 16857, 16858, 7, 4, 0, 0, + 16858, 16859, 7, 5, 0, 0, 16859, 2230, 1, 0, 0, 0, 16860, 16861, 7, 7, + 0, 0, 16861, 16862, 7, 2, 0, 0, 16862, 16863, 7, 5, 0, 0, 16863, 16864, + 7, 22, 0, 0, 16864, 16865, 7, 12, 0, 0, 16865, 16866, 7, 4, 0, 0, 16866, + 16867, 7, 8, 0, 0, 16867, 16868, 7, 19, 0, 0, 16868, 2232, 1, 0, 0, 0, + 16869, 16870, 7, 7, 0, 0, 16870, 16871, 7, 2, 0, 0, 16871, 16872, 5, 95, + 0, 0, 16872, 16873, 7, 4, 0, 0, 16873, 16874, 7, 0, 0, 0, 16874, 16875, + 7, 1, 0, 0, 16875, 16876, 7, 11, 0, 0, 16876, 16877, 7, 6, 0, 0, 16877, + 16878, 5, 95, 0, 0, 16878, 16879, 7, 11, 0, 0, 16879, 16880, 7, 2, 0, 0, + 16880, 16881, 7, 2, 0, 0, 16881, 16882, 7, 21, 0, 0, 16882, 16883, 7, 10, + 0, 0, 16883, 16884, 7, 15, 0, 0, 16884, 16885, 5, 95, 0, 0, 16885, 16886, + 7, 1, 0, 0, 16886, 16887, 7, 18, 0, 0, 16887, 16888, 5, 95, 0, 0, 16888, + 16889, 7, 7, 0, 0, 16889, 16890, 7, 11, 0, 0, 16890, 2234, 1, 0, 0, 0, + 16891, 16892, 7, 7, 0, 0, 16892, 16893, 7, 2, 0, 0, 16893, 16894, 5, 95, + 0, 0, 16894, 16895, 7, 4, 0, 0, 16895, 16896, 7, 6, 0, 0, 16896, 16897, + 7, 14, 0, 0, 16897, 16898, 7, 15, 0, 0, 16898, 16899, 5, 95, 0, 0, 16899, + 16900, 7, 4, 0, 0, 16900, 16901, 7, 0, 0, 0, 16901, 16902, 7, 1, 0, 0, + 16902, 16903, 7, 11, 0, 0, 16903, 16904, 7, 6, 0, 0, 16904, 2236, 1, 0, + 0, 0, 16905, 16906, 7, 7, 0, 0, 16906, 16907, 7, 2, 0, 0, 16907, 16908, + 7, 4, 0, 0, 16908, 16909, 7, 19, 0, 0, 16909, 16910, 7, 12, 0, 0, 16910, + 16911, 7, 7, 0, 0, 16911, 16912, 7, 17, 0, 0, 16912, 2238, 1, 0, 0, 0, + 16913, 16914, 7, 7, 0, 0, 16914, 16915, 7, 2, 0, 0, 16915, 16916, 7, 4, + 0, 0, 16916, 16917, 7, 12, 0, 0, 16917, 16918, 7, 16, 0, 0, 16918, 16919, + 7, 12, 0, 0, 16919, 16920, 7, 8, 0, 0, 16920, 16921, 7, 0, 0, 0, 16921, + 16922, 7, 4, 0, 0, 16922, 16923, 7, 12, 0, 0, 16923, 16924, 7, 2, 0, 0, + 16924, 16925, 7, 7, 0, 0, 16925, 2240, 1, 0, 0, 0, 16926, 16927, 7, 7, + 0, 0, 16927, 16928, 7, 2, 0, 0, 16928, 16929, 7, 4, 0, 0, 16929, 2242, + 1, 0, 0, 0, 16930, 16931, 7, 7, 0, 0, 16931, 16932, 7, 2, 0, 0, 16932, + 16933, 5, 95, 0, 0, 16933, 16934, 7, 4, 0, 0, 16934, 16935, 7, 3, 0, 0, + 16935, 16936, 7, 0, 0, 0, 16936, 16937, 7, 7, 0, 0, 16937, 16938, 7, 5, + 0, 0, 16938, 16939, 7, 16, 0, 0, 16939, 16940, 7, 2, 0, 0, 16940, 16941, + 7, 3, 0, 0, 16941, 16942, 7, 14, 0, 0, 16942, 16943, 5, 95, 0, 0, 16943, + 16944, 7, 9, 0, 0, 16944, 16945, 7, 12, 0, 0, 16945, 16946, 7, 5, 0, 0, + 16946, 16947, 7, 4, 0, 0, 16947, 16948, 7, 12, 0, 0, 16948, 16949, 7, 7, + 0, 0, 16949, 16950, 7, 8, 0, 0, 16950, 16951, 7, 4, 0, 0, 16951, 16952, + 5, 95, 0, 0, 16952, 16953, 7, 0, 0, 0, 16953, 16954, 7, 17, 0, 0, 16954, + 16955, 7, 17, 0, 0, 16955, 2244, 1, 0, 0, 0, 16956, 16957, 7, 7, 0, 0, + 16957, 16958, 7, 2, 0, 0, 16958, 16959, 5, 95, 0, 0, 16959, 16960, 7, 10, + 0, 0, 16960, 16961, 7, 7, 0, 0, 16961, 16962, 7, 7, 0, 0, 16962, 16963, + 7, 6, 0, 0, 16963, 16964, 7, 5, 0, 0, 16964, 16965, 7, 4, 0, 0, 16965, + 2246, 1, 0, 0, 0, 16966, 16967, 7, 7, 0, 0, 16967, 16968, 7, 2, 0, 0, 16968, + 16969, 5, 95, 0, 0, 16969, 16970, 7, 10, 0, 0, 16970, 16971, 7, 5, 0, 0, + 16971, 16972, 7, 6, 0, 0, 16972, 16973, 5, 95, 0, 0, 16973, 16974, 7, 8, + 0, 0, 16974, 16975, 7, 10, 0, 0, 16975, 16976, 7, 1, 0, 0, 16976, 16977, + 7, 6, 0, 0, 16977, 2248, 1, 0, 0, 0, 16978, 16979, 7, 7, 0, 0, 16979, 16980, + 7, 2, 0, 0, 16980, 16981, 5, 95, 0, 0, 16981, 16982, 7, 10, 0, 0, 16982, + 16983, 7, 5, 0, 0, 16983, 16984, 7, 6, 0, 0, 16984, 16985, 5, 95, 0, 0, + 16985, 16986, 7, 19, 0, 0, 16986, 16987, 7, 0, 0, 0, 16987, 16988, 7, 5, + 0, 0, 16988, 16989, 7, 19, 0, 0, 16989, 16990, 5, 95, 0, 0, 16990, 16991, + 7, 0, 0, 0, 16991, 16992, 7, 17, 0, 0, 16992, 16993, 7, 17, 0, 0, 16993, + 16994, 7, 3, 0, 0, 16994, 16995, 7, 6, 0, 0, 16995, 16996, 7, 17, 0, 0, + 16996, 16997, 7, 0, 0, 0, 16997, 16998, 7, 4, 0, 0, 16998, 16999, 7, 12, + 0, 0, 16999, 17000, 7, 2, 0, 0, 17000, 17001, 7, 7, 0, 0, 17001, 2250, + 1, 0, 0, 0, 17002, 17003, 7, 7, 0, 0, 17003, 17004, 7, 2, 0, 0, 17004, + 17005, 5, 95, 0, 0, 17005, 17006, 7, 10, 0, 0, 17006, 17007, 7, 5, 0, 0, + 17007, 17008, 7, 6, 0, 0, 17008, 17009, 5, 95, 0, 0, 17009, 17010, 7, 19, + 0, 0, 17010, 17011, 7, 0, 0, 0, 17011, 17012, 7, 5, 0, 0, 17012, 17013, + 7, 19, 0, 0, 17013, 17014, 5, 95, 0, 0, 17014, 17015, 7, 17, 0, 0, 17015, + 17016, 7, 1, 0, 0, 17016, 17017, 7, 18, 0, 0, 17017, 17018, 5, 95, 0, 0, + 17018, 17019, 7, 16, 0, 0, 17019, 17020, 7, 2, 0, 0, 17020, 17021, 7, 3, + 0, 0, 17021, 17022, 5, 95, 0, 0, 17022, 17023, 7, 15, 0, 0, 17023, 17024, + 7, 10, 0, 0, 17024, 17025, 7, 5, 0, 0, 17025, 17026, 7, 19, 0, 0, 17026, + 17027, 7, 9, 0, 0, 17027, 17028, 7, 2, 0, 0, 17028, 17029, 7, 22, 0, 0, + 17029, 17030, 7, 7, 0, 0, 17030, 2252, 1, 0, 0, 0, 17031, 17032, 7, 7, + 0, 0, 17032, 17033, 7, 2, 0, 0, 17033, 17034, 5, 95, 0, 0, 17034, 17035, + 7, 10, 0, 0, 17035, 17036, 7, 5, 0, 0, 17036, 17037, 7, 6, 0, 0, 17037, + 17038, 5, 95, 0, 0, 17038, 17039, 7, 19, 0, 0, 17039, 17040, 7, 0, 0, 0, + 17040, 17041, 7, 5, 0, 0, 17041, 17042, 7, 19, 0, 0, 17042, 2254, 1, 0, + 0, 0, 17043, 17044, 7, 7, 0, 0, 17044, 17045, 7, 2, 0, 0, 17045, 17046, + 5, 95, 0, 0, 17046, 17047, 7, 10, 0, 0, 17047, 17048, 7, 5, 0, 0, 17048, + 17049, 7, 6, 0, 0, 17049, 17050, 5, 95, 0, 0, 17050, 17051, 7, 12, 0, 0, + 17051, 17052, 7, 7, 0, 0, 17052, 17053, 7, 13, 0, 0, 17053, 17054, 7, 12, + 0, 0, 17054, 17055, 7, 5, 0, 0, 17055, 17056, 7, 12, 0, 0, 17056, 17057, + 7, 1, 0, 0, 17057, 17058, 7, 11, 0, 0, 17058, 17059, 7, 6, 0, 0, 17059, + 17060, 5, 95, 0, 0, 17060, 17061, 7, 12, 0, 0, 17061, 17062, 7, 7, 0, 0, + 17062, 17063, 7, 9, 0, 0, 17063, 17064, 7, 6, 0, 0, 17064, 17065, 7, 25, + 0, 0, 17065, 17066, 7, 6, 0, 0, 17066, 17067, 7, 5, 0, 0, 17067, 2256, + 1, 0, 0, 0, 17068, 17069, 7, 7, 0, 0, 17069, 17070, 7, 2, 0, 0, 17070, + 17071, 5, 95, 0, 0, 17071, 17072, 7, 10, 0, 0, 17072, 17073, 7, 5, 0, 0, + 17073, 17074, 7, 6, 0, 0, 17074, 17075, 5, 95, 0, 0, 17075, 17076, 7, 14, + 0, 0, 17076, 17077, 7, 6, 0, 0, 17077, 17078, 7, 3, 0, 0, 17078, 17079, + 7, 17, 0, 0, 17079, 17080, 7, 6, 0, 0, 17080, 2258, 1, 0, 0, 0, 17081, + 17082, 7, 7, 0, 0, 17082, 17083, 7, 2, 0, 0, 17083, 17084, 5, 95, 0, 0, + 17084, 17085, 7, 10, 0, 0, 17085, 17086, 7, 5, 0, 0, 17086, 17087, 7, 6, + 0, 0, 17087, 17088, 5, 95, 0, 0, 17088, 17089, 7, 7, 0, 0, 17089, 17090, + 7, 11, 0, 0, 17090, 2260, 1, 0, 0, 0, 17091, 17092, 7, 7, 0, 0, 17092, + 17093, 7, 2, 0, 0, 17093, 17094, 5, 95, 0, 0, 17094, 17095, 7, 10, 0, 0, + 17095, 17096, 7, 5, 0, 0, 17096, 17097, 7, 6, 0, 0, 17097, 17098, 5, 95, + 0, 0, 17098, 17099, 7, 13, 0, 0, 17099, 17100, 7, 6, 0, 0, 17100, 17101, + 7, 8, 0, 0, 17101, 17102, 7, 4, 0, 0, 17102, 17103, 7, 2, 0, 0, 17103, + 17104, 7, 3, 0, 0, 17104, 17105, 5, 95, 0, 0, 17105, 17106, 7, 0, 0, 0, + 17106, 17107, 7, 17, 0, 0, 17107, 17108, 7, 17, 0, 0, 17108, 17109, 7, + 3, 0, 0, 17109, 17110, 7, 6, 0, 0, 17110, 17111, 7, 17, 0, 0, 17111, 17112, + 7, 0, 0, 0, 17112, 17113, 7, 4, 0, 0, 17113, 17114, 7, 12, 0, 0, 17114, + 17115, 7, 2, 0, 0, 17115, 17116, 7, 7, 0, 0, 17116, 2262, 1, 0, 0, 0, 17117, + 17118, 7, 7, 0, 0, 17118, 17119, 7, 2, 0, 0, 17119, 17120, 7, 13, 0, 0, + 17120, 17121, 7, 0, 0, 0, 17121, 17122, 7, 11, 0, 0, 17122, 17123, 7, 12, + 0, 0, 17123, 17124, 7, 9, 0, 0, 17124, 17125, 7, 0, 0, 0, 17125, 17126, + 7, 4, 0, 0, 17126, 17127, 7, 6, 0, 0, 17127, 2264, 1, 0, 0, 0, 17128, 17129, + 7, 7, 0, 0, 17129, 17130, 7, 2, 0, 0, 17130, 17131, 5, 95, 0, 0, 17131, + 17132, 7, 13, 0, 0, 17132, 17133, 7, 6, 0, 0, 17133, 17134, 7, 8, 0, 0, + 17134, 17135, 7, 4, 0, 0, 17135, 17136, 7, 2, 0, 0, 17136, 17137, 7, 3, + 0, 0, 17137, 17138, 5, 95, 0, 0, 17138, 17139, 7, 4, 0, 0, 17139, 17140, + 7, 3, 0, 0, 17140, 17141, 7, 0, 0, 0, 17141, 17142, 7, 7, 0, 0, 17142, + 17143, 7, 5, 0, 0, 17143, 17144, 7, 16, 0, 0, 17144, 17145, 7, 2, 0, 0, + 17145, 17146, 7, 3, 0, 0, 17146, 17147, 7, 14, 0, 0, 17147, 17148, 5, 95, + 0, 0, 17148, 17149, 7, 9, 0, 0, 17149, 17150, 7, 12, 0, 0, 17150, 17151, + 7, 14, 0, 0, 17151, 17152, 7, 5, 0, 0, 17152, 2266, 1, 0, 0, 0, 17153, + 17154, 7, 7, 0, 0, 17154, 17155, 7, 2, 0, 0, 17155, 17156, 5, 95, 0, 0, + 17156, 17157, 7, 13, 0, 0, 17157, 17158, 7, 6, 0, 0, 17158, 17159, 7, 8, + 0, 0, 17159, 17160, 7, 4, 0, 0, 17160, 17161, 7, 2, 0, 0, 17161, 17162, + 7, 3, 0, 0, 17162, 17163, 5, 95, 0, 0, 17163, 17164, 7, 4, 0, 0, 17164, + 17165, 7, 3, 0, 0, 17165, 17166, 7, 0, 0, 0, 17166, 17167, 7, 7, 0, 0, + 17167, 17168, 7, 5, 0, 0, 17168, 17169, 7, 16, 0, 0, 17169, 17170, 7, 2, + 0, 0, 17170, 17171, 7, 3, 0, 0, 17171, 17172, 7, 14, 0, 0, 17172, 17173, + 5, 95, 0, 0, 17173, 17174, 7, 16, 0, 0, 17174, 17175, 7, 0, 0, 0, 17175, + 17176, 7, 8, 0, 0, 17176, 17177, 7, 4, 0, 0, 17177, 2268, 1, 0, 0, 0, 17178, + 17179, 7, 7, 0, 0, 17179, 17180, 7, 2, 0, 0, 17180, 17181, 5, 95, 0, 0, + 17181, 17182, 7, 13, 0, 0, 17182, 17183, 7, 6, 0, 0, 17183, 17184, 7, 8, + 0, 0, 17184, 17185, 7, 4, 0, 0, 17185, 17186, 7, 2, 0, 0, 17186, 17187, + 7, 3, 0, 0, 17187, 17188, 5, 95, 0, 0, 17188, 17189, 7, 4, 0, 0, 17189, + 17190, 7, 3, 0, 0, 17190, 17191, 7, 0, 0, 0, 17191, 17192, 7, 7, 0, 0, + 17192, 17193, 7, 5, 0, 0, 17193, 17194, 7, 16, 0, 0, 17194, 17195, 7, 2, + 0, 0, 17195, 17196, 7, 3, 0, 0, 17196, 17197, 7, 14, 0, 0, 17197, 2270, + 1, 0, 0, 0, 17198, 17199, 7, 7, 0, 0, 17199, 17200, 7, 2, 0, 0, 17200, + 17201, 7, 22, 0, 0, 17201, 17202, 7, 0, 0, 0, 17202, 17203, 7, 12, 0, 0, + 17203, 17204, 7, 4, 0, 0, 17204, 2272, 1, 0, 0, 0, 17205, 17206, 7, 7, + 0, 0, 17206, 17207, 7, 2, 0, 0, 17207, 17208, 5, 95, 0, 0, 17208, 17209, + 7, 25, 0, 0, 17209, 17210, 7, 9, 0, 0, 17210, 17211, 7, 1, 0, 0, 17211, + 17212, 5, 95, 0, 0, 17212, 17213, 7, 16, 0, 0, 17213, 17214, 7, 0, 0, 0, + 17214, 17215, 7, 5, 0, 0, 17215, 17216, 7, 4, 0, 0, 17216, 17217, 7, 15, + 0, 0, 17217, 17218, 7, 0, 0, 0, 17218, 17219, 7, 4, 0, 0, 17219, 17220, + 7, 19, 0, 0, 17220, 17221, 5, 95, 0, 0, 17221, 17222, 7, 12, 0, 0, 17222, + 17223, 7, 7, 0, 0, 17223, 17224, 7, 5, 0, 0, 17224, 17225, 7, 6, 0, 0, + 17225, 17226, 7, 3, 0, 0, 17226, 17227, 7, 4, 0, 0, 17227, 2274, 1, 0, + 0, 0, 17228, 17229, 7, 7, 0, 0, 17229, 17230, 7, 2, 0, 0, 17230, 17231, + 5, 95, 0, 0, 17231, 17232, 7, 25, 0, 0, 17232, 17233, 7, 14, 0, 0, 17233, + 17234, 7, 11, 0, 0, 17234, 17235, 5, 95, 0, 0, 17235, 17236, 7, 9, 0, 0, + 17236, 17237, 7, 14, 0, 0, 17237, 17238, 7, 11, 0, 0, 17238, 17239, 5, + 95, 0, 0, 17239, 17240, 7, 3, 0, 0, 17240, 17241, 7, 6, 0, 0, 17241, 17242, + 7, 22, 0, 0, 17242, 17243, 7, 3, 0, 0, 17243, 17244, 7, 12, 0, 0, 17244, + 17245, 7, 4, 0, 0, 17245, 17246, 7, 6, 0, 0, 17246, 2276, 1, 0, 0, 0, 17247, + 17248, 7, 7, 0, 0, 17248, 17249, 7, 2, 0, 0, 17249, 17250, 5, 95, 0, 0, + 17250, 17251, 7, 25, 0, 0, 17251, 17252, 7, 14, 0, 0, 17252, 17253, 7, + 11, 0, 0, 17253, 17254, 7, 12, 0, 0, 17254, 17255, 7, 7, 0, 0, 17255, 17256, + 7, 9, 0, 0, 17256, 17257, 7, 6, 0, 0, 17257, 17258, 7, 25, 0, 0, 17258, + 17259, 5, 95, 0, 0, 17259, 17260, 7, 3, 0, 0, 17260, 17261, 7, 6, 0, 0, + 17261, 17262, 7, 22, 0, 0, 17262, 17263, 7, 3, 0, 0, 17263, 17264, 7, 12, + 0, 0, 17264, 17265, 7, 4, 0, 0, 17265, 17266, 7, 6, 0, 0, 17266, 17267, + 5, 95, 0, 0, 17267, 17268, 7, 12, 0, 0, 17268, 17269, 7, 7, 0, 0, 17269, + 17270, 5, 95, 0, 0, 17270, 17271, 7, 5, 0, 0, 17271, 17272, 7, 6, 0, 0, + 17272, 17273, 7, 11, 0, 0, 17273, 17274, 7, 6, 0, 0, 17274, 17275, 7, 8, + 0, 0, 17275, 17276, 7, 4, 0, 0, 17276, 2278, 1, 0, 0, 0, 17277, 17278, + 7, 7, 0, 0, 17278, 17279, 7, 2, 0, 0, 17279, 17280, 5, 95, 0, 0, 17280, + 17281, 7, 25, 0, 0, 17281, 17282, 7, 14, 0, 0, 17282, 17283, 7, 11, 0, + 0, 17283, 17284, 7, 12, 0, 0, 17284, 17285, 7, 7, 0, 0, 17285, 17286, 7, + 9, 0, 0, 17286, 17287, 7, 6, 0, 0, 17287, 17288, 7, 25, 0, 0, 17288, 17289, + 5, 95, 0, 0, 17289, 17290, 7, 3, 0, 0, 17290, 17291, 7, 6, 0, 0, 17291, + 17292, 7, 22, 0, 0, 17292, 17293, 7, 3, 0, 0, 17293, 17294, 7, 12, 0, 0, + 17294, 17295, 7, 4, 0, 0, 17295, 17296, 7, 6, 0, 0, 17296, 2280, 1, 0, + 0, 0, 17297, 17298, 7, 7, 0, 0, 17298, 17299, 7, 2, 0, 0, 17299, 17300, + 5, 95, 0, 0, 17300, 17301, 7, 25, 0, 0, 17301, 17302, 7, 14, 0, 0, 17302, + 17303, 7, 11, 0, 0, 17303, 17304, 5, 95, 0, 0, 17304, 17305, 7, 24, 0, + 0, 17305, 17306, 7, 10, 0, 0, 17306, 17307, 7, 6, 0, 0, 17307, 17308, 7, + 3, 0, 0, 17308, 17309, 7, 18, 0, 0, 17309, 17310, 5, 95, 0, 0, 17310, 17311, + 7, 3, 0, 0, 17311, 17312, 7, 6, 0, 0, 17312, 17313, 7, 22, 0, 0, 17313, + 17314, 7, 3, 0, 0, 17314, 17315, 7, 12, 0, 0, 17315, 17316, 7, 4, 0, 0, + 17316, 17317, 7, 6, 0, 0, 17317, 2282, 1, 0, 0, 0, 17318, 17319, 7, 7, + 0, 0, 17319, 17320, 7, 2, 0, 0, 17320, 17321, 5, 95, 0, 0, 17321, 17322, + 7, 23, 0, 0, 17322, 17323, 7, 2, 0, 0, 17323, 17324, 7, 7, 0, 0, 17324, + 17325, 7, 6, 0, 0, 17325, 17326, 7, 14, 0, 0, 17326, 17327, 7, 0, 0, 0, + 17327, 17328, 7, 15, 0, 0, 17328, 2284, 1, 0, 0, 0, 17329, 17330, 7, 7, + 0, 0, 17330, 17331, 7, 4, 0, 0, 17331, 17332, 7, 19, 0, 0, 17332, 17333, + 5, 95, 0, 0, 17333, 17334, 7, 13, 0, 0, 17334, 17335, 7, 0, 0, 0, 17335, + 17336, 7, 11, 0, 0, 17336, 17337, 7, 10, 0, 0, 17337, 17338, 7, 6, 0, 0, + 17338, 2286, 1, 0, 0, 0, 17339, 17340, 7, 7, 0, 0, 17340, 17341, 7, 10, + 0, 0, 17341, 17342, 7, 11, 0, 0, 17342, 17343, 7, 11, 0, 0, 17343, 17344, + 7, 12, 0, 0, 17344, 17345, 7, 16, 0, 0, 17345, 2288, 1, 0, 0, 0, 17346, + 17347, 7, 7, 0, 0, 17347, 17348, 7, 10, 0, 0, 17348, 17349, 7, 11, 0, 0, + 17349, 17350, 7, 11, 0, 0, 17350, 2290, 1, 0, 0, 0, 17351, 17352, 7, 7, + 0, 0, 17352, 17353, 7, 10, 0, 0, 17353, 17354, 7, 11, 0, 0, 17354, 17355, + 7, 11, 0, 0, 17355, 17356, 7, 5, 0, 0, 17356, 2292, 1, 0, 0, 0, 17357, + 17358, 7, 7, 0, 0, 17358, 17359, 7, 10, 0, 0, 17359, 17360, 7, 14, 0, 0, + 17360, 17361, 7, 1, 0, 0, 17361, 17362, 7, 6, 0, 0, 17362, 17363, 7, 3, + 0, 0, 17363, 2294, 1, 0, 0, 0, 17364, 17365, 7, 7, 0, 0, 17365, 17366, + 7, 10, 0, 0, 17366, 17367, 7, 14, 0, 0, 17367, 17368, 7, 6, 0, 0, 17368, + 17369, 7, 3, 0, 0, 17369, 17370, 7, 12, 0, 0, 17370, 17371, 7, 8, 0, 0, + 17371, 2296, 1, 0, 0, 0, 17372, 17373, 7, 7, 0, 0, 17373, 17374, 7, 10, + 0, 0, 17374, 17375, 7, 14, 0, 0, 17375, 17376, 5, 95, 0, 0, 17376, 17377, + 7, 12, 0, 0, 17377, 17378, 7, 7, 0, 0, 17378, 17379, 7, 9, 0, 0, 17379, + 17380, 7, 6, 0, 0, 17380, 17381, 7, 25, 0, 0, 17381, 17382, 5, 95, 0, 0, + 17382, 17383, 7, 21, 0, 0, 17383, 17384, 7, 6, 0, 0, 17384, 17385, 7, 18, + 0, 0, 17385, 17386, 7, 5, 0, 0, 17386, 2298, 1, 0, 0, 0, 17387, 17388, + 7, 7, 0, 0, 17388, 17389, 7, 10, 0, 0, 17389, 17390, 7, 14, 0, 0, 17390, + 17391, 7, 4, 0, 0, 17391, 17392, 7, 2, 0, 0, 17392, 17393, 7, 9, 0, 0, + 17393, 17394, 7, 5, 0, 0, 17394, 17395, 7, 12, 0, 0, 17395, 17396, 7, 7, + 0, 0, 17396, 17397, 7, 4, 0, 0, 17397, 17398, 7, 6, 0, 0, 17398, 17399, + 7, 3, 0, 0, 17399, 17400, 7, 13, 0, 0, 17400, 17401, 7, 0, 0, 0, 17401, + 17402, 7, 11, 0, 0, 17402, 2300, 1, 0, 0, 0, 17403, 17404, 7, 7, 0, 0, + 17404, 17405, 7, 10, 0, 0, 17405, 17406, 7, 14, 0, 0, 17406, 17407, 7, + 4, 0, 0, 17407, 17408, 7, 2, 0, 0, 17408, 17409, 7, 18, 0, 0, 17409, 17410, + 7, 14, 0, 0, 17410, 17411, 7, 12, 0, 0, 17411, 17412, 7, 7, 0, 0, 17412, + 17413, 7, 4, 0, 0, 17413, 17414, 7, 6, 0, 0, 17414, 17415, 7, 3, 0, 0, + 17415, 17416, 7, 13, 0, 0, 17416, 17417, 7, 0, 0, 0, 17417, 17418, 7, 11, + 0, 0, 17418, 2302, 1, 0, 0, 0, 17419, 17420, 7, 7, 0, 0, 17420, 17421, + 7, 13, 0, 0, 17421, 17422, 7, 0, 0, 0, 17422, 17423, 7, 3, 0, 0, 17423, + 17424, 7, 8, 0, 0, 17424, 17425, 7, 19, 0, 0, 17425, 17426, 7, 0, 0, 0, + 17426, 17427, 7, 3, 0, 0, 17427, 17428, 5, 50, 0, 0, 17428, 2304, 1, 0, + 0, 0, 17429, 17430, 7, 7, 0, 0, 17430, 17431, 7, 13, 0, 0, 17431, 17432, + 7, 11, 0, 0, 17432, 17433, 5, 50, 0, 0, 17433, 2306, 1, 0, 0, 0, 17434, + 17435, 7, 2, 0, 0, 17435, 17436, 7, 1, 0, 0, 17436, 17437, 7, 20, 0, 0, + 17437, 17438, 7, 6, 0, 0, 17438, 17439, 7, 8, 0, 0, 17439, 17440, 7, 4, + 0, 0, 17440, 17441, 5, 50, 0, 0, 17441, 17442, 7, 25, 0, 0, 17442, 17443, + 7, 14, 0, 0, 17443, 17444, 7, 11, 0, 0, 17444, 2308, 1, 0, 0, 0, 17445, + 17446, 7, 2, 0, 0, 17446, 17447, 7, 1, 0, 0, 17447, 17448, 7, 20, 0, 0, + 17448, 17449, 7, 6, 0, 0, 17449, 17450, 7, 8, 0, 0, 17450, 17451, 7, 4, + 0, 0, 17451, 2310, 1, 0, 0, 0, 17452, 17453, 7, 2, 0, 0, 17453, 17454, + 7, 1, 0, 0, 17454, 17455, 7, 20, 0, 0, 17455, 17456, 5, 95, 0, 0, 17456, + 17457, 7, 12, 0, 0, 17457, 17458, 7, 9, 0, 0, 17458, 2312, 1, 0, 0, 0, + 17459, 17460, 7, 2, 0, 0, 17460, 17461, 7, 1, 0, 0, 17461, 17462, 7, 20, + 0, 0, 17462, 17463, 7, 7, 0, 0, 17463, 17464, 7, 2, 0, 0, 17464, 2314, + 1, 0, 0, 0, 17465, 17466, 7, 2, 0, 0, 17466, 17467, 7, 1, 0, 0, 17467, + 17468, 7, 20, 0, 0, 17468, 17469, 7, 7, 0, 0, 17469, 17470, 7, 2, 0, 0, + 17470, 17471, 5, 95, 0, 0, 17471, 17472, 7, 3, 0, 0, 17472, 17473, 7, 6, + 0, 0, 17473, 17474, 7, 10, 0, 0, 17474, 17475, 7, 5, 0, 0, 17475, 17476, + 7, 6, 0, 0, 17476, 2316, 1, 0, 0, 0, 17477, 17478, 7, 2, 0, 0, 17478, 17479, + 7, 8, 0, 0, 17479, 17480, 7, 8, 0, 0, 17480, 17481, 7, 10, 0, 0, 17481, + 17482, 7, 3, 0, 0, 17482, 17483, 7, 6, 0, 0, 17483, 17484, 7, 7, 0, 0, + 17484, 17485, 7, 8, 0, 0, 17485, 17486, 7, 6, 0, 0, 17486, 17487, 7, 5, + 0, 0, 17487, 2318, 1, 0, 0, 0, 17488, 17489, 7, 2, 0, 0, 17489, 17490, + 7, 16, 0, 0, 17490, 17491, 7, 16, 0, 0, 17491, 17492, 7, 11, 0, 0, 17492, + 17493, 7, 12, 0, 0, 17493, 17494, 7, 7, 0, 0, 17494, 17495, 7, 6, 0, 0, + 17495, 2320, 1, 0, 0, 0, 17496, 17497, 7, 2, 0, 0, 17497, 17498, 7, 16, + 0, 0, 17498, 17499, 7, 16, 0, 0, 17499, 2322, 1, 0, 0, 0, 17500, 17501, + 7, 2, 0, 0, 17501, 17502, 7, 16, 0, 0, 17502, 17503, 7, 16, 0, 0, 17503, + 17504, 7, 5, 0, 0, 17504, 17505, 7, 6, 0, 0, 17505, 17506, 7, 4, 0, 0, + 17506, 2324, 1, 0, 0, 0, 17507, 17508, 7, 2, 0, 0, 17508, 17509, 7, 16, + 0, 0, 17509, 2326, 1, 0, 0, 0, 17510, 17511, 7, 2, 0, 0, 17511, 17512, + 7, 12, 0, 0, 17512, 17513, 7, 9, 0, 0, 17513, 17514, 7, 12, 0, 0, 17514, + 17515, 7, 7, 0, 0, 17515, 17516, 7, 9, 0, 0, 17516, 17517, 7, 6, 0, 0, + 17517, 17518, 7, 25, 0, 0, 17518, 2328, 1, 0, 0, 0, 17519, 17520, 7, 2, + 0, 0, 17520, 17521, 7, 12, 0, 0, 17521, 17522, 7, 9, 0, 0, 17522, 2330, + 1, 0, 0, 0, 17523, 17524, 7, 2, 0, 0, 17524, 17525, 7, 11, 0, 0, 17525, + 17526, 7, 0, 0, 0, 17526, 17527, 7, 15, 0, 0, 17527, 2332, 1, 0, 0, 0, + 17528, 17529, 7, 2, 0, 0, 17529, 17530, 7, 11, 0, 0, 17530, 17531, 7, 9, + 0, 0, 17531, 2334, 1, 0, 0, 0, 17532, 17533, 7, 2, 0, 0, 17533, 17534, + 7, 11, 0, 0, 17534, 17535, 7, 9, 0, 0, 17535, 17536, 5, 95, 0, 0, 17536, + 17537, 7, 15, 0, 0, 17537, 17538, 7, 10, 0, 0, 17538, 17539, 7, 5, 0, 0, + 17539, 17540, 7, 19, 0, 0, 17540, 17541, 5, 95, 0, 0, 17541, 17542, 7, + 15, 0, 0, 17542, 17543, 7, 3, 0, 0, 17543, 17544, 7, 6, 0, 0, 17544, 17545, + 7, 9, 0, 0, 17545, 2336, 1, 0, 0, 0, 17546, 17547, 7, 2, 0, 0, 17547, 17548, + 7, 11, 0, 0, 17548, 17549, 7, 5, 0, 0, 17549, 2338, 1, 0, 0, 0, 17550, + 17551, 7, 2, 0, 0, 17551, 17552, 7, 11, 0, 0, 17552, 17553, 7, 4, 0, 0, + 17553, 17554, 7, 15, 0, 0, 17554, 2340, 1, 0, 0, 0, 17555, 17556, 7, 2, + 0, 0, 17556, 17557, 7, 14, 0, 0, 17557, 17558, 7, 12, 0, 0, 17558, 17559, + 7, 4, 0, 0, 17559, 2342, 1, 0, 0, 0, 17560, 17561, 7, 2, 0, 0, 17561, 17562, + 7, 7, 0, 0, 17562, 17563, 7, 6, 0, 0, 17563, 2344, 1, 0, 0, 0, 17564, 17565, + 7, 2, 0, 0, 17565, 17566, 7, 7, 0, 0, 17566, 17567, 7, 11, 0, 0, 17567, + 17568, 7, 12, 0, 0, 17568, 17569, 7, 7, 0, 0, 17569, 17570, 7, 6, 0, 0, + 17570, 2346, 1, 0, 0, 0, 17571, 17572, 7, 2, 0, 0, 17572, 17573, 7, 7, + 0, 0, 17573, 17574, 7, 11, 0, 0, 17574, 17575, 7, 18, 0, 0, 17575, 2348, + 1, 0, 0, 0, 17576, 17577, 7, 2, 0, 0, 17577, 17578, 7, 7, 0, 0, 17578, + 2350, 1, 0, 0, 0, 17579, 17580, 7, 2, 0, 0, 17580, 17581, 7, 15, 0, 0, + 17581, 17582, 7, 0, 0, 0, 17582, 17583, 7, 24, 0, 0, 17583, 17584, 7, 10, + 0, 0, 17584, 17585, 7, 6, 0, 0, 17585, 2352, 1, 0, 0, 0, 17586, 17587, + 7, 2, 0, 0, 17587, 17588, 7, 15, 0, 0, 17588, 17589, 7, 0, 0, 0, 17589, + 17590, 7, 24, 0, 0, 17590, 17591, 7, 10, 0, 0, 17591, 17592, 7, 6, 0, 0, + 17592, 17593, 5, 95, 0, 0, 17593, 17594, 7, 4, 0, 0, 17594, 17595, 7, 3, + 0, 0, 17595, 17596, 7, 0, 0, 0, 17596, 17597, 7, 7, 0, 0, 17597, 17598, + 7, 5, 0, 0, 17598, 17599, 7, 16, 0, 0, 17599, 17600, 7, 2, 0, 0, 17600, + 17601, 7, 3, 0, 0, 17601, 17602, 7, 14, 0, 0, 17602, 2354, 1, 0, 0, 0, + 17603, 17604, 7, 2, 0, 0, 17604, 17605, 7, 15, 0, 0, 17605, 17606, 7, 0, + 0, 0, 17606, 17607, 7, 24, 0, 0, 17607, 17608, 7, 10, 0, 0, 17608, 17609, + 7, 6, 0, 0, 17609, 17610, 5, 95, 0, 0, 17610, 17611, 7, 25, 0, 0, 17611, + 17612, 7, 8, 0, 0, 17612, 17613, 7, 0, 0, 0, 17613, 17614, 7, 7, 0, 0, + 17614, 17615, 7, 2, 0, 0, 17615, 17616, 7, 7, 0, 0, 17616, 17617, 7, 12, + 0, 0, 17617, 17618, 7, 8, 0, 0, 17618, 17619, 7, 0, 0, 0, 17619, 17620, + 7, 11, 0, 0, 17620, 2356, 1, 0, 0, 0, 17621, 17622, 7, 2, 0, 0, 17622, + 17623, 7, 15, 0, 0, 17623, 17624, 7, 8, 0, 0, 17624, 17625, 7, 2, 0, 0, + 17625, 17626, 7, 9, 0, 0, 17626, 17627, 7, 6, 0, 0, 17627, 2358, 1, 0, + 0, 0, 17628, 17629, 7, 2, 0, 0, 17629, 17630, 7, 15, 0, 0, 17630, 17631, + 7, 6, 0, 0, 17631, 17632, 7, 7, 0, 0, 17632, 2360, 1, 0, 0, 0, 17633, 17634, + 7, 2, 0, 0, 17634, 17635, 7, 15, 0, 0, 17635, 17636, 7, 6, 0, 0, 17636, + 17637, 7, 3, 0, 0, 17637, 17638, 7, 0, 0, 0, 17638, 17639, 7, 4, 0, 0, + 17639, 17640, 7, 12, 0, 0, 17640, 17641, 7, 2, 0, 0, 17641, 17642, 7, 7, + 0, 0, 17642, 17643, 7, 5, 0, 0, 17643, 2362, 1, 0, 0, 0, 17644, 17645, + 7, 2, 0, 0, 17645, 17646, 7, 15, 0, 0, 17646, 17647, 7, 6, 0, 0, 17647, + 17648, 7, 3, 0, 0, 17648, 17649, 7, 0, 0, 0, 17649, 17650, 7, 4, 0, 0, + 17650, 17651, 7, 2, 0, 0, 17651, 17652, 7, 3, 0, 0, 17652, 2364, 1, 0, + 0, 0, 17653, 17654, 7, 2, 0, 0, 17654, 17655, 7, 15, 0, 0, 17655, 17656, + 7, 4, 0, 0, 17656, 17657, 5, 95, 0, 0, 17657, 17658, 7, 6, 0, 0, 17658, + 17659, 7, 5, 0, 0, 17659, 17660, 7, 4, 0, 0, 17660, 17661, 7, 12, 0, 0, + 17661, 17662, 7, 14, 0, 0, 17662, 17663, 7, 0, 0, 0, 17663, 17664, 7, 4, + 0, 0, 17664, 17665, 7, 6, 0, 0, 17665, 2366, 1, 0, 0, 0, 17666, 17667, + 7, 2, 0, 0, 17667, 17668, 7, 15, 0, 0, 17668, 17669, 7, 4, 0, 0, 17669, + 17670, 7, 12, 0, 0, 17670, 17671, 7, 14, 0, 0, 17671, 17672, 7, 0, 0, 0, + 17672, 17673, 7, 11, 0, 0, 17673, 2368, 1, 0, 0, 0, 17674, 17675, 7, 2, + 0, 0, 17675, 17676, 7, 15, 0, 0, 17676, 17677, 7, 4, 0, 0, 17677, 17678, + 7, 12, 0, 0, 17678, 17679, 7, 14, 0, 0, 17679, 17680, 7, 12, 0, 0, 17680, + 17681, 7, 23, 0, 0, 17681, 17682, 7, 6, 0, 0, 17682, 2370, 1, 0, 0, 0, + 17683, 17684, 7, 2, 0, 0, 17684, 17685, 7, 15, 0, 0, 17685, 17686, 7, 4, + 0, 0, 17686, 17687, 7, 12, 0, 0, 17687, 17688, 7, 14, 0, 0, 17688, 17689, + 7, 12, 0, 0, 17689, 17690, 7, 23, 0, 0, 17690, 17691, 7, 6, 0, 0, 17691, + 17692, 7, 3, 0, 0, 17692, 17693, 5, 95, 0, 0, 17693, 17694, 7, 16, 0, 0, + 17694, 17695, 7, 6, 0, 0, 17695, 17696, 7, 0, 0, 0, 17696, 17697, 7, 4, + 0, 0, 17697, 17698, 7, 10, 0, 0, 17698, 17699, 7, 3, 0, 0, 17699, 17700, + 7, 6, 0, 0, 17700, 17701, 7, 5, 0, 0, 17701, 17702, 5, 95, 0, 0, 17702, + 17703, 7, 6, 0, 0, 17703, 17704, 7, 7, 0, 0, 17704, 17705, 7, 0, 0, 0, + 17705, 17706, 7, 1, 0, 0, 17706, 17707, 7, 11, 0, 0, 17707, 17708, 7, 6, + 0, 0, 17708, 2372, 1, 0, 0, 0, 17709, 17710, 7, 2, 0, 0, 17710, 17711, + 7, 15, 0, 0, 17711, 17712, 7, 4, 0, 0, 17712, 17713, 7, 12, 0, 0, 17713, + 17714, 7, 14, 0, 0, 17714, 17715, 7, 12, 0, 0, 17715, 17716, 7, 23, 0, + 0, 17716, 17717, 7, 6, 0, 0, 17717, 17718, 7, 3, 0, 0, 17718, 17719, 5, + 95, 0, 0, 17719, 17720, 7, 17, 0, 0, 17720, 17721, 7, 2, 0, 0, 17721, 17722, + 7, 0, 0, 0, 17722, 17723, 7, 11, 0, 0, 17723, 2374, 1, 0, 0, 0, 17724, + 17725, 7, 2, 0, 0, 17725, 17726, 7, 15, 0, 0, 17726, 17727, 7, 4, 0, 0, + 17727, 17728, 7, 12, 0, 0, 17728, 17729, 7, 2, 0, 0, 17729, 17730, 7, 7, + 0, 0, 17730, 2376, 1, 0, 0, 0, 17731, 17732, 7, 2, 0, 0, 17732, 17733, + 7, 15, 0, 0, 17733, 17734, 7, 4, 0, 0, 17734, 17735, 5, 95, 0, 0, 17735, + 17736, 7, 15, 0, 0, 17736, 17737, 7, 0, 0, 0, 17737, 17738, 7, 3, 0, 0, + 17738, 17739, 7, 0, 0, 0, 17739, 17740, 7, 14, 0, 0, 17740, 2378, 1, 0, + 0, 0, 17741, 17742, 7, 2, 0, 0, 17742, 17743, 7, 3, 0, 0, 17743, 17744, + 7, 0, 0, 0, 17744, 17745, 5, 95, 0, 0, 17745, 17746, 7, 1, 0, 0, 17746, + 17747, 7, 3, 0, 0, 17747, 17748, 7, 0, 0, 0, 17748, 17749, 7, 7, 0, 0, + 17749, 17750, 7, 8, 0, 0, 17750, 17751, 7, 19, 0, 0, 17751, 2380, 1, 0, + 0, 0, 17752, 17753, 7, 2, 0, 0, 17753, 17754, 7, 3, 0, 0, 17754, 17755, + 7, 0, 0, 0, 17755, 17756, 5, 95, 0, 0, 17756, 17757, 7, 8, 0, 0, 17757, + 17758, 7, 19, 0, 0, 17758, 17759, 7, 6, 0, 0, 17759, 17760, 7, 8, 0, 0, + 17760, 17761, 7, 21, 0, 0, 17761, 17762, 5, 95, 0, 0, 17762, 17763, 7, + 0, 0, 0, 17763, 17764, 7, 8, 0, 0, 17764, 17765, 7, 11, 0, 0, 17765, 2382, + 1, 0, 0, 0, 17766, 17767, 7, 2, 0, 0, 17767, 17768, 7, 3, 0, 0, 17768, + 17769, 7, 0, 0, 0, 17769, 17770, 5, 95, 0, 0, 17770, 17771, 7, 8, 0, 0, + 17771, 17772, 7, 19, 0, 0, 17772, 17773, 7, 6, 0, 0, 17773, 17774, 7, 8, + 0, 0, 17774, 17775, 7, 21, 0, 0, 17775, 17776, 5, 95, 0, 0, 17776, 17777, + 7, 15, 0, 0, 17777, 17778, 7, 3, 0, 0, 17778, 17779, 7, 12, 0, 0, 17779, + 17780, 7, 13, 0, 0, 17780, 17781, 7, 12, 0, 0, 17781, 17782, 7, 11, 0, + 0, 17782, 17783, 7, 6, 0, 0, 17783, 17784, 7, 17, 0, 0, 17784, 17785, 7, + 6, 0, 0, 17785, 2384, 1, 0, 0, 0, 17786, 17787, 7, 2, 0, 0, 17787, 17788, + 7, 3, 0, 0, 17788, 17789, 7, 0, 0, 0, 17789, 17790, 5, 95, 0, 0, 17790, + 17791, 7, 8, 0, 0, 17791, 17792, 7, 11, 0, 0, 17792, 17793, 7, 10, 0, 0, + 17793, 17794, 7, 5, 0, 0, 17794, 17795, 7, 4, 0, 0, 17795, 17796, 7, 6, + 0, 0, 17796, 17797, 7, 3, 0, 0, 17797, 17798, 7, 12, 0, 0, 17798, 17799, + 7, 7, 0, 0, 17799, 17800, 7, 17, 0, 0, 17800, 2386, 1, 0, 0, 0, 17801, + 17802, 7, 2, 0, 0, 17802, 17803, 7, 3, 0, 0, 17803, 17804, 7, 0, 0, 0, + 17804, 17805, 7, 9, 0, 0, 17805, 17806, 7, 0, 0, 0, 17806, 17807, 7, 4, + 0, 0, 17807, 17808, 7, 0, 0, 0, 17808, 2388, 1, 0, 0, 0, 17809, 17810, + 7, 2, 0, 0, 17810, 17811, 7, 3, 0, 0, 17811, 17812, 7, 0, 0, 0, 17812, + 17813, 7, 9, 0, 0, 17813, 17814, 7, 6, 0, 0, 17814, 17815, 7, 1, 0, 0, + 17815, 17816, 7, 10, 0, 0, 17816, 17817, 7, 17, 0, 0, 17817, 2390, 1, 0, + 0, 0, 17818, 17819, 7, 2, 0, 0, 17819, 17820, 7, 3, 0, 0, 17820, 17821, + 7, 0, 0, 0, 17821, 17822, 5, 95, 0, 0, 17822, 17823, 7, 9, 0, 0, 17823, + 17824, 7, 5, 0, 0, 17824, 17825, 7, 4, 0, 0, 17825, 17826, 5, 95, 0, 0, + 17826, 17827, 7, 0, 0, 0, 17827, 17828, 7, 16, 0, 0, 17828, 17829, 7, 16, + 0, 0, 17829, 17830, 7, 6, 0, 0, 17830, 17831, 7, 8, 0, 0, 17831, 17832, + 7, 4, 0, 0, 17832, 17833, 7, 6, 0, 0, 17833, 17834, 7, 9, 0, 0, 17834, + 2392, 1, 0, 0, 0, 17835, 17836, 7, 2, 0, 0, 17836, 17837, 7, 3, 0, 0, 17837, + 17838, 7, 0, 0, 0, 17838, 17839, 5, 95, 0, 0, 17839, 17840, 7, 9, 0, 0, + 17840, 17841, 7, 5, 0, 0, 17841, 17842, 7, 4, 0, 0, 17842, 17843, 5, 95, + 0, 0, 17843, 17844, 7, 8, 0, 0, 17844, 17845, 7, 2, 0, 0, 17845, 17846, + 7, 7, 0, 0, 17846, 17847, 7, 13, 0, 0, 17847, 17848, 7, 6, 0, 0, 17848, + 17849, 7, 3, 0, 0, 17849, 17850, 7, 4, 0, 0, 17850, 2394, 1, 0, 0, 0, 17851, + 17852, 7, 2, 0, 0, 17852, 17853, 7, 3, 0, 0, 17853, 17854, 7, 0, 0, 0, + 17854, 17855, 5, 95, 0, 0, 17855, 17856, 7, 9, 0, 0, 17856, 17857, 7, 5, + 0, 0, 17857, 17858, 7, 4, 0, 0, 17858, 17859, 5, 95, 0, 0, 17859, 17860, + 7, 6, 0, 0, 17860, 17861, 7, 3, 0, 0, 17861, 17862, 7, 3, 0, 0, 17862, + 17863, 7, 2, 0, 0, 17863, 17864, 7, 3, 0, 0, 17864, 2396, 1, 0, 0, 0, 17865, + 17866, 7, 2, 0, 0, 17866, 17867, 7, 3, 0, 0, 17867, 17868, 7, 0, 0, 0, + 17868, 17869, 5, 95, 0, 0, 17869, 17870, 7, 17, 0, 0, 17870, 17871, 7, + 6, 0, 0, 17871, 17872, 7, 4, 0, 0, 17872, 17873, 5, 95, 0, 0, 17873, 17874, + 7, 0, 0, 0, 17874, 17875, 7, 8, 0, 0, 17875, 17876, 7, 11, 0, 0, 17876, + 17877, 7, 12, 0, 0, 17877, 17878, 7, 9, 0, 0, 17878, 17879, 7, 5, 0, 0, + 17879, 2398, 1, 0, 0, 0, 17880, 17881, 7, 2, 0, 0, 17881, 17882, 7, 3, + 0, 0, 17882, 17883, 7, 0, 0, 0, 17883, 17884, 5, 95, 0, 0, 17884, 17885, + 7, 17, 0, 0, 17885, 17886, 7, 6, 0, 0, 17886, 17887, 7, 4, 0, 0, 17887, + 17888, 5, 95, 0, 0, 17888, 17889, 7, 15, 0, 0, 17889, 17890, 7, 3, 0, 0, + 17890, 17891, 7, 12, 0, 0, 17891, 17892, 7, 13, 0, 0, 17892, 17893, 7, + 12, 0, 0, 17893, 17894, 7, 11, 0, 0, 17894, 17895, 7, 6, 0, 0, 17895, 17896, + 7, 17, 0, 0, 17896, 17897, 7, 6, 0, 0, 17897, 17898, 7, 5, 0, 0, 17898, + 2400, 1, 0, 0, 0, 17899, 17900, 7, 2, 0, 0, 17900, 17901, 7, 3, 0, 0, 17901, + 17902, 7, 0, 0, 0, 17902, 17903, 5, 95, 0, 0, 17903, 17904, 7, 19, 0, 0, + 17904, 17905, 7, 0, 0, 0, 17905, 17906, 7, 5, 0, 0, 17906, 17907, 7, 19, + 0, 0, 17907, 2402, 1, 0, 0, 0, 17908, 17909, 7, 2, 0, 0, 17909, 17910, + 7, 3, 0, 0, 17910, 17911, 7, 0, 0, 0, 17911, 17912, 5, 95, 0, 0, 17912, + 17913, 7, 12, 0, 0, 17913, 17914, 7, 7, 0, 0, 17914, 17915, 7, 13, 0, 0, + 17915, 17916, 7, 2, 0, 0, 17916, 17917, 7, 21, 0, 0, 17917, 17918, 7, 12, + 0, 0, 17918, 17919, 7, 7, 0, 0, 17919, 17920, 7, 17, 0, 0, 17920, 17921, + 5, 95, 0, 0, 17921, 17922, 7, 10, 0, 0, 17922, 17923, 7, 5, 0, 0, 17923, + 17924, 7, 6, 0, 0, 17924, 17925, 7, 3, 0, 0, 17925, 17926, 7, 12, 0, 0, + 17926, 17927, 7, 9, 0, 0, 17927, 2404, 1, 0, 0, 0, 17928, 17929, 7, 2, + 0, 0, 17929, 17930, 7, 3, 0, 0, 17930, 17931, 7, 0, 0, 0, 17931, 17932, + 5, 95, 0, 0, 17932, 17933, 7, 12, 0, 0, 17933, 17934, 7, 7, 0, 0, 17934, + 17935, 7, 13, 0, 0, 17935, 17936, 7, 2, 0, 0, 17936, 17937, 7, 21, 0, 0, + 17937, 17938, 7, 12, 0, 0, 17938, 17939, 7, 7, 0, 0, 17939, 17940, 7, 17, + 0, 0, 17940, 17941, 5, 95, 0, 0, 17941, 17942, 7, 10, 0, 0, 17942, 17943, + 7, 5, 0, 0, 17943, 17944, 7, 6, 0, 0, 17944, 17945, 7, 3, 0, 0, 17945, + 2406, 1, 0, 0, 0, 17946, 17947, 7, 2, 0, 0, 17947, 17948, 7, 3, 0, 0, 17948, + 17949, 7, 0, 0, 0, 17949, 17950, 5, 95, 0, 0, 17950, 17951, 7, 12, 0, 0, + 17951, 17952, 7, 7, 0, 0, 17952, 17953, 7, 13, 0, 0, 17953, 17954, 7, 2, + 0, 0, 17954, 17955, 7, 21, 0, 0, 17955, 17956, 7, 12, 0, 0, 17956, 17957, + 7, 7, 0, 0, 17957, 17958, 7, 17, 0, 0, 17958, 17959, 5, 95, 0, 0, 17959, + 17960, 7, 25, 0, 0, 17960, 17961, 7, 5, 0, 0, 17961, 17962, 5, 95, 0, 0, + 17962, 17963, 7, 10, 0, 0, 17963, 17964, 7, 5, 0, 0, 17964, 17965, 7, 6, + 0, 0, 17965, 17966, 7, 3, 0, 0, 17966, 17967, 5, 95, 0, 0, 17967, 17968, + 7, 17, 0, 0, 17968, 17969, 7, 10, 0, 0, 17969, 17970, 7, 12, 0, 0, 17970, + 17971, 7, 9, 0, 0, 17971, 2408, 1, 0, 0, 0, 17972, 17973, 7, 2, 0, 0, 17973, + 17974, 7, 3, 0, 0, 17974, 17975, 7, 0, 0, 0, 17975, 17976, 5, 95, 0, 0, + 17976, 17977, 7, 12, 0, 0, 17977, 17978, 7, 7, 0, 0, 17978, 17979, 7, 13, + 0, 0, 17979, 17980, 7, 2, 0, 0, 17980, 17981, 7, 21, 0, 0, 17981, 17982, + 7, 12, 0, 0, 17982, 17983, 7, 7, 0, 0, 17983, 17984, 7, 17, 0, 0, 17984, + 17985, 5, 95, 0, 0, 17985, 17986, 7, 25, 0, 0, 17986, 17987, 7, 5, 0, 0, + 17987, 17988, 5, 95, 0, 0, 17988, 17989, 7, 10, 0, 0, 17989, 17990, 7, + 5, 0, 0, 17990, 17991, 7, 6, 0, 0, 17991, 17992, 7, 3, 0, 0, 17992, 2410, + 1, 0, 0, 0, 17993, 17994, 7, 2, 0, 0, 17994, 17995, 7, 3, 0, 0, 17995, + 17996, 7, 0, 0, 0, 17996, 17997, 5, 95, 0, 0, 17997, 17998, 7, 3, 0, 0, + 17998, 17999, 7, 0, 0, 0, 17999, 18000, 7, 22, 0, 0, 18000, 18001, 7, 8, + 0, 0, 18001, 18002, 7, 2, 0, 0, 18002, 18003, 7, 14, 0, 0, 18003, 18004, + 7, 15, 0, 0, 18004, 18005, 7, 0, 0, 0, 18005, 18006, 7, 3, 0, 0, 18006, + 18007, 7, 6, 0, 0, 18007, 2412, 1, 0, 0, 0, 18008, 18009, 7, 2, 0, 0, 18009, + 18010, 7, 3, 0, 0, 18010, 18011, 7, 0, 0, 0, 18011, 18012, 5, 95, 0, 0, + 18012, 18013, 7, 3, 0, 0, 18013, 18014, 7, 0, 0, 0, 18014, 18015, 7, 22, + 0, 0, 18015, 18016, 7, 8, 0, 0, 18016, 18017, 7, 2, 0, 0, 18017, 18018, + 7, 7, 0, 0, 18018, 18019, 7, 8, 0, 0, 18019, 18020, 7, 0, 0, 0, 18020, + 18021, 7, 4, 0, 0, 18021, 2414, 1, 0, 0, 0, 18022, 18023, 7, 2, 0, 0, 18023, + 18024, 7, 3, 0, 0, 18024, 18025, 7, 0, 0, 0, 18025, 18026, 5, 95, 0, 0, + 18026, 18027, 7, 3, 0, 0, 18027, 18028, 7, 2, 0, 0, 18028, 18029, 7, 22, + 0, 0, 18029, 18030, 7, 5, 0, 0, 18030, 18031, 7, 8, 0, 0, 18031, 18032, + 7, 7, 0, 0, 18032, 2416, 1, 0, 0, 0, 18033, 18034, 7, 2, 0, 0, 18034, 18035, + 7, 3, 0, 0, 18035, 18036, 7, 0, 0, 0, 18036, 18037, 5, 95, 0, 0, 18037, + 18038, 7, 3, 0, 0, 18038, 18039, 7, 2, 0, 0, 18039, 18040, 7, 22, 0, 0, + 18040, 18041, 7, 5, 0, 0, 18041, 18042, 7, 8, 0, 0, 18042, 18043, 7, 7, + 0, 0, 18043, 18044, 5, 95, 0, 0, 18044, 18045, 7, 3, 0, 0, 18045, 18046, + 7, 0, 0, 0, 18046, 18047, 7, 22, 0, 0, 18047, 2418, 1, 0, 0, 0, 18048, + 18049, 7, 2, 0, 0, 18049, 18050, 7, 3, 0, 0, 18050, 18051, 7, 0, 0, 0, + 18051, 18052, 5, 95, 0, 0, 18052, 18053, 7, 3, 0, 0, 18053, 18054, 7, 2, + 0, 0, 18054, 18055, 7, 22, 0, 0, 18055, 18056, 7, 13, 0, 0, 18056, 18057, + 7, 6, 0, 0, 18057, 18058, 7, 3, 0, 0, 18058, 18059, 7, 5, 0, 0, 18059, + 18060, 7, 12, 0, 0, 18060, 18061, 7, 2, 0, 0, 18061, 18062, 7, 7, 0, 0, + 18062, 2420, 1, 0, 0, 0, 18063, 18064, 7, 2, 0, 0, 18064, 18065, 7, 3, + 0, 0, 18065, 18066, 7, 0, 0, 0, 18066, 18067, 5, 95, 0, 0, 18067, 18068, + 7, 4, 0, 0, 18068, 18069, 7, 0, 0, 0, 18069, 18070, 7, 1, 0, 0, 18070, + 18071, 7, 13, 0, 0, 18071, 18072, 7, 6, 0, 0, 18072, 18073, 7, 3, 0, 0, + 18073, 18074, 7, 5, 0, 0, 18074, 18075, 7, 12, 0, 0, 18075, 18076, 7, 2, + 0, 0, 18076, 18077, 7, 7, 0, 0, 18077, 2422, 1, 0, 0, 0, 18078, 18079, + 7, 2, 0, 0, 18079, 18080, 7, 3, 0, 0, 18080, 18081, 7, 0, 0, 0, 18081, + 18082, 5, 95, 0, 0, 18082, 18083, 7, 22, 0, 0, 18083, 18084, 7, 3, 0, 0, + 18084, 18085, 7, 12, 0, 0, 18085, 18086, 7, 4, 0, 0, 18086, 18087, 7, 6, + 0, 0, 18087, 18088, 5, 95, 0, 0, 18088, 18089, 7, 4, 0, 0, 18089, 18090, + 7, 12, 0, 0, 18090, 18091, 7, 14, 0, 0, 18091, 18092, 7, 6, 0, 0, 18092, + 2424, 1, 0, 0, 0, 18093, 18094, 7, 2, 0, 0, 18094, 18095, 7, 3, 0, 0, 18095, + 18096, 7, 9, 0, 0, 18096, 18097, 7, 6, 0, 0, 18097, 18098, 7, 3, 0, 0, + 18098, 18099, 7, 6, 0, 0, 18099, 18100, 7, 9, 0, 0, 18100, 2426, 1, 0, + 0, 0, 18101, 18102, 7, 2, 0, 0, 18102, 18103, 7, 3, 0, 0, 18103, 18104, + 7, 9, 0, 0, 18104, 18105, 7, 6, 0, 0, 18105, 18106, 7, 3, 0, 0, 18106, + 18107, 7, 6, 0, 0, 18107, 18108, 7, 9, 0, 0, 18108, 18109, 5, 95, 0, 0, + 18109, 18110, 7, 15, 0, 0, 18110, 18111, 7, 3, 0, 0, 18111, 18112, 7, 6, + 0, 0, 18112, 18113, 7, 9, 0, 0, 18113, 18114, 7, 12, 0, 0, 18114, 18115, + 7, 8, 0, 0, 18115, 18116, 7, 0, 0, 0, 18116, 18117, 7, 4, 0, 0, 18117, + 18118, 7, 6, 0, 0, 18118, 18119, 7, 5, 0, 0, 18119, 2428, 1, 0, 0, 0, 18120, + 18121, 7, 2, 0, 0, 18121, 18122, 7, 3, 0, 0, 18122, 18123, 7, 9, 0, 0, + 18123, 18124, 7, 6, 0, 0, 18124, 18125, 7, 3, 0, 0, 18125, 2430, 1, 0, + 0, 0, 18126, 18127, 7, 2, 0, 0, 18127, 18128, 7, 3, 0, 0, 18128, 18129, + 7, 9, 0, 0, 18129, 18130, 7, 12, 0, 0, 18130, 18131, 7, 7, 0, 0, 18131, + 18132, 7, 0, 0, 0, 18132, 18133, 7, 11, 0, 0, 18133, 18134, 7, 12, 0, 0, + 18134, 18135, 7, 4, 0, 0, 18135, 18136, 7, 18, 0, 0, 18136, 2432, 1, 0, + 0, 0, 18137, 18138, 7, 2, 0, 0, 18138, 18139, 7, 3, 0, 0, 18139, 18140, + 5, 95, 0, 0, 18140, 18141, 7, 6, 0, 0, 18141, 18142, 7, 25, 0, 0, 18142, + 18143, 7, 15, 0, 0, 18143, 18144, 7, 0, 0, 0, 18144, 18145, 7, 7, 0, 0, + 18145, 18146, 7, 9, 0, 0, 18146, 2434, 1, 0, 0, 0, 18147, 18148, 7, 2, + 0, 0, 18148, 18149, 7, 3, 0, 0, 18149, 18150, 7, 17, 0, 0, 18150, 18151, + 7, 0, 0, 0, 18151, 18152, 7, 7, 0, 0, 18152, 18153, 7, 12, 0, 0, 18153, + 18154, 7, 23, 0, 0, 18154, 18155, 7, 0, 0, 0, 18155, 18156, 7, 4, 0, 0, + 18156, 18157, 7, 12, 0, 0, 18157, 18158, 7, 2, 0, 0, 18158, 18159, 7, 7, + 0, 0, 18159, 2436, 1, 0, 0, 0, 18160, 18161, 7, 2, 0, 0, 18161, 18162, + 7, 3, 0, 0, 18162, 2438, 1, 0, 0, 0, 18163, 18164, 7, 2, 0, 0, 18164, 18165, + 7, 3, 0, 0, 18165, 18166, 5, 95, 0, 0, 18166, 18167, 7, 15, 0, 0, 18167, + 18168, 7, 3, 0, 0, 18168, 18169, 7, 6, 0, 0, 18169, 18170, 7, 9, 0, 0, + 18170, 18171, 7, 12, 0, 0, 18171, 18172, 7, 8, 0, 0, 18172, 18173, 7, 0, + 0, 0, 18173, 18174, 7, 4, 0, 0, 18174, 18175, 7, 6, 0, 0, 18175, 18176, + 7, 5, 0, 0, 18176, 2440, 1, 0, 0, 0, 18177, 18178, 7, 2, 0, 0, 18178, 18179, + 7, 5, 0, 0, 18179, 18180, 7, 6, 0, 0, 18180, 18181, 7, 3, 0, 0, 18181, + 18182, 7, 3, 0, 0, 18182, 18183, 7, 2, 0, 0, 18183, 18184, 7, 3, 0, 0, + 18184, 2442, 1, 0, 0, 0, 18185, 18186, 7, 2, 0, 0, 18186, 18187, 7, 4, + 0, 0, 18187, 18188, 7, 19, 0, 0, 18188, 18189, 7, 6, 0, 0, 18189, 18190, + 7, 3, 0, 0, 18190, 2444, 1, 0, 0, 0, 18191, 18192, 7, 2, 0, 0, 18192, 18193, + 7, 10, 0, 0, 18193, 18194, 7, 4, 0, 0, 18194, 18195, 7, 6, 0, 0, 18195, + 18196, 7, 3, 0, 0, 18196, 18197, 5, 95, 0, 0, 18197, 18198, 7, 20, 0, 0, + 18198, 18199, 7, 2, 0, 0, 18199, 18200, 7, 12, 0, 0, 18200, 18201, 7, 7, + 0, 0, 18201, 18202, 5, 95, 0, 0, 18202, 18203, 7, 4, 0, 0, 18203, 18204, + 7, 2, 0, 0, 18204, 18205, 5, 95, 0, 0, 18205, 18206, 7, 0, 0, 0, 18206, + 18207, 7, 7, 0, 0, 18207, 18208, 7, 4, 0, 0, 18208, 18209, 7, 12, 0, 0, + 18209, 2446, 1, 0, 0, 0, 18210, 18211, 7, 2, 0, 0, 18211, 18212, 7, 10, + 0, 0, 18212, 18213, 7, 4, 0, 0, 18213, 18214, 7, 6, 0, 0, 18214, 18215, + 7, 3, 0, 0, 18215, 18216, 5, 95, 0, 0, 18216, 18217, 7, 20, 0, 0, 18217, + 18218, 7, 2, 0, 0, 18218, 18219, 7, 12, 0, 0, 18219, 18220, 7, 7, 0, 0, + 18220, 18221, 5, 95, 0, 0, 18221, 18222, 7, 4, 0, 0, 18222, 18223, 7, 2, + 0, 0, 18223, 18224, 5, 95, 0, 0, 18224, 18225, 7, 12, 0, 0, 18225, 18226, + 7, 7, 0, 0, 18226, 18227, 7, 7, 0, 0, 18227, 18228, 7, 6, 0, 0, 18228, + 18229, 7, 3, 0, 0, 18229, 2448, 1, 0, 0, 0, 18230, 18231, 7, 2, 0, 0, 18231, + 18232, 7, 10, 0, 0, 18232, 18233, 7, 4, 0, 0, 18233, 18234, 7, 6, 0, 0, + 18234, 18235, 7, 3, 0, 0, 18235, 2450, 1, 0, 0, 0, 18236, 18237, 7, 2, + 0, 0, 18237, 18238, 7, 10, 0, 0, 18238, 18239, 7, 4, 0, 0, 18239, 18240, + 7, 11, 0, 0, 18240, 18241, 7, 12, 0, 0, 18241, 18242, 7, 7, 0, 0, 18242, + 18243, 7, 6, 0, 0, 18243, 18244, 5, 95, 0, 0, 18244, 18245, 7, 11, 0, 0, + 18245, 18246, 7, 6, 0, 0, 18246, 18247, 7, 0, 0, 0, 18247, 18248, 7, 16, + 0, 0, 18248, 2452, 1, 0, 0, 0, 18249, 18250, 7, 2, 0, 0, 18250, 18251, + 7, 10, 0, 0, 18251, 18252, 7, 4, 0, 0, 18252, 18253, 7, 11, 0, 0, 18253, + 18254, 7, 12, 0, 0, 18254, 18255, 7, 7, 0, 0, 18255, 18256, 7, 6, 0, 0, + 18256, 2454, 1, 0, 0, 0, 18257, 18258, 7, 2, 0, 0, 18258, 18259, 7, 10, + 0, 0, 18259, 18260, 7, 4, 0, 0, 18260, 18261, 5, 95, 0, 0, 18261, 18262, + 7, 2, 0, 0, 18262, 18263, 7, 16, 0, 0, 18263, 18264, 5, 95, 0, 0, 18264, + 18265, 7, 11, 0, 0, 18265, 18266, 7, 12, 0, 0, 18266, 18267, 7, 7, 0, 0, + 18267, 18268, 7, 6, 0, 0, 18268, 2456, 1, 0, 0, 0, 18269, 18270, 7, 2, + 0, 0, 18270, 18271, 7, 10, 0, 0, 18271, 18272, 7, 4, 0, 0, 18272, 2458, + 1, 0, 0, 0, 18273, 18274, 7, 2, 0, 0, 18274, 18275, 7, 13, 0, 0, 18275, + 18276, 7, 6, 0, 0, 18276, 18277, 7, 3, 0, 0, 18277, 18278, 7, 16, 0, 0, + 18278, 18279, 7, 11, 0, 0, 18279, 18280, 7, 2, 0, 0, 18280, 18281, 7, 22, + 0, 0, 18281, 18282, 5, 95, 0, 0, 18282, 18283, 7, 7, 0, 0, 18283, 18284, + 7, 2, 0, 0, 18284, 18285, 7, 14, 0, 0, 18285, 18286, 7, 2, 0, 0, 18286, + 18287, 7, 13, 0, 0, 18287, 18288, 7, 6, 0, 0, 18288, 2460, 1, 0, 0, 0, + 18289, 18290, 7, 2, 0, 0, 18290, 18291, 7, 13, 0, 0, 18291, 18292, 7, 6, + 0, 0, 18292, 18293, 7, 3, 0, 0, 18293, 18294, 7, 16, 0, 0, 18294, 18295, + 7, 11, 0, 0, 18295, 18296, 7, 2, 0, 0, 18296, 18297, 7, 22, 0, 0, 18297, + 2462, 1, 0, 0, 0, 18298, 18299, 7, 2, 0, 0, 18299, 18300, 7, 13, 0, 0, + 18300, 18301, 7, 6, 0, 0, 18301, 18302, 7, 3, 0, 0, 18302, 18303, 7, 11, + 0, 0, 18303, 18304, 7, 0, 0, 0, 18304, 18305, 7, 15, 0, 0, 18305, 18306, + 7, 5, 0, 0, 18306, 2464, 1, 0, 0, 0, 18307, 18308, 7, 2, 0, 0, 18308, 18309, + 7, 13, 0, 0, 18309, 18310, 7, 6, 0, 0, 18310, 18311, 7, 3, 0, 0, 18311, + 2466, 1, 0, 0, 0, 18312, 18313, 7, 2, 0, 0, 18313, 18314, 7, 13, 0, 0, + 18314, 18315, 7, 6, 0, 0, 18315, 18316, 7, 3, 0, 0, 18316, 18317, 7, 3, + 0, 0, 18317, 18318, 7, 12, 0, 0, 18318, 18319, 7, 9, 0, 0, 18319, 18320, + 7, 12, 0, 0, 18320, 18321, 7, 7, 0, 0, 18321, 18322, 7, 17, 0, 0, 18322, + 2468, 1, 0, 0, 0, 18323, 18324, 7, 2, 0, 0, 18324, 18325, 7, 22, 0, 0, + 18325, 18326, 7, 7, 0, 0, 18326, 18327, 7, 6, 0, 0, 18327, 18328, 7, 3, + 0, 0, 18328, 2470, 1, 0, 0, 0, 18329, 18330, 7, 2, 0, 0, 18330, 18331, + 7, 22, 0, 0, 18331, 18332, 7, 7, 0, 0, 18332, 18333, 7, 6, 0, 0, 18333, + 18334, 7, 3, 0, 0, 18334, 18335, 7, 5, 0, 0, 18335, 18336, 7, 19, 0, 0, + 18336, 18337, 7, 12, 0, 0, 18337, 18338, 7, 15, 0, 0, 18338, 2472, 1, 0, + 0, 0, 18339, 18340, 7, 2, 0, 0, 18340, 18341, 7, 22, 0, 0, 18341, 18342, + 7, 7, 0, 0, 18342, 2474, 1, 0, 0, 0, 18343, 18344, 7, 15, 0, 0, 18344, + 2476, 1, 0, 0, 0, 18345, 18346, 7, 15, 0, 0, 18346, 18347, 7, 0, 0, 0, + 18347, 18348, 7, 8, 0, 0, 18348, 18349, 7, 21, 0, 0, 18349, 18350, 7, 0, + 0, 0, 18350, 18351, 7, 17, 0, 0, 18351, 18352, 7, 6, 0, 0, 18352, 2478, + 1, 0, 0, 0, 18353, 18354, 7, 15, 0, 0, 18354, 18355, 7, 0, 0, 0, 18355, + 18356, 7, 8, 0, 0, 18356, 18357, 7, 21, 0, 0, 18357, 18358, 7, 0, 0, 0, + 18358, 18359, 7, 17, 0, 0, 18359, 18360, 7, 6, 0, 0, 18360, 18361, 7, 5, + 0, 0, 18361, 2480, 1, 0, 0, 0, 18362, 18363, 7, 15, 0, 0, 18363, 18364, + 7, 0, 0, 0, 18364, 18365, 7, 3, 0, 0, 18365, 18366, 7, 0, 0, 0, 18366, + 18367, 7, 11, 0, 0, 18367, 18368, 7, 11, 0, 0, 18368, 18369, 7, 6, 0, 0, + 18369, 18370, 7, 11, 0, 0, 18370, 18371, 5, 95, 0, 0, 18371, 18372, 7, + 6, 0, 0, 18372, 18373, 7, 7, 0, 0, 18373, 18374, 7, 0, 0, 0, 18374, 18375, + 7, 1, 0, 0, 18375, 18376, 7, 11, 0, 0, 18376, 18377, 7, 6, 0, 0, 18377, + 2482, 1, 0, 0, 0, 18378, 18379, 7, 15, 0, 0, 18379, 18380, 7, 0, 0, 0, + 18380, 18381, 7, 3, 0, 0, 18381, 18382, 7, 0, 0, 0, 18382, 18383, 7, 11, + 0, 0, 18383, 18384, 7, 11, 0, 0, 18384, 18385, 7, 6, 0, 0, 18385, 18386, + 7, 11, 0, 0, 18386, 18387, 5, 95, 0, 0, 18387, 18388, 7, 12, 0, 0, 18388, + 18389, 7, 7, 0, 0, 18389, 18390, 7, 9, 0, 0, 18390, 18391, 7, 6, 0, 0, + 18391, 18392, 7, 25, 0, 0, 18392, 2484, 1, 0, 0, 0, 18393, 18394, 7, 15, + 0, 0, 18394, 18395, 7, 0, 0, 0, 18395, 18396, 7, 3, 0, 0, 18396, 18397, + 7, 0, 0, 0, 18397, 18398, 7, 11, 0, 0, 18398, 18399, 7, 11, 0, 0, 18399, + 18400, 7, 6, 0, 0, 18400, 18401, 7, 11, 0, 0, 18401, 2486, 1, 0, 0, 0, + 18402, 18403, 7, 15, 0, 0, 18403, 18404, 7, 0, 0, 0, 18404, 18405, 7, 3, + 0, 0, 18405, 18406, 7, 0, 0, 0, 18406, 18407, 7, 14, 0, 0, 18407, 18408, + 7, 6, 0, 0, 18408, 18409, 7, 4, 0, 0, 18409, 18410, 7, 6, 0, 0, 18410, + 18411, 7, 3, 0, 0, 18411, 18412, 7, 5, 0, 0, 18412, 2488, 1, 0, 0, 0, 18413, + 18414, 7, 15, 0, 0, 18414, 18415, 7, 0, 0, 0, 18415, 18416, 7, 3, 0, 0, + 18416, 18417, 7, 0, 0, 0, 18417, 18418, 7, 14, 0, 0, 18418, 2490, 1, 0, + 0, 0, 18419, 18420, 7, 15, 0, 0, 18420, 18421, 7, 0, 0, 0, 18421, 18422, + 7, 3, 0, 0, 18422, 18423, 7, 6, 0, 0, 18423, 18424, 7, 7, 0, 0, 18424, + 18425, 7, 4, 0, 0, 18425, 2492, 1, 0, 0, 0, 18426, 18427, 7, 15, 0, 0, + 18427, 18428, 7, 0, 0, 0, 18428, 18429, 7, 3, 0, 0, 18429, 18430, 7, 6, + 0, 0, 18430, 18431, 7, 7, 0, 0, 18431, 18432, 7, 4, 0, 0, 18432, 18433, + 5, 95, 0, 0, 18433, 18434, 7, 11, 0, 0, 18434, 18435, 7, 6, 0, 0, 18435, + 18436, 7, 13, 0, 0, 18436, 18437, 7, 6, 0, 0, 18437, 18438, 7, 11, 0, 0, + 18438, 18439, 5, 95, 0, 0, 18439, 18440, 7, 7, 0, 0, 18440, 18441, 7, 0, + 0, 0, 18441, 18442, 7, 14, 0, 0, 18442, 18443, 7, 6, 0, 0, 18443, 2494, + 1, 0, 0, 0, 18444, 18445, 7, 15, 0, 0, 18445, 18446, 7, 0, 0, 0, 18446, + 18447, 7, 3, 0, 0, 18447, 18448, 7, 6, 0, 0, 18448, 18449, 7, 7, 0, 0, + 18449, 18450, 7, 4, 0, 0, 18450, 18451, 5, 95, 0, 0, 18451, 18452, 7, 10, + 0, 0, 18452, 18453, 7, 7, 0, 0, 18453, 18454, 7, 12, 0, 0, 18454, 18455, + 7, 24, 0, 0, 18455, 18456, 7, 10, 0, 0, 18456, 18457, 7, 6, 0, 0, 18457, + 18458, 5, 95, 0, 0, 18458, 18459, 7, 7, 0, 0, 18459, 18460, 7, 0, 0, 0, + 18460, 18461, 7, 14, 0, 0, 18461, 18462, 7, 6, 0, 0, 18462, 2496, 1, 0, + 0, 0, 18463, 18464, 7, 15, 0, 0, 18464, 18465, 7, 0, 0, 0, 18465, 18466, + 7, 3, 0, 0, 18466, 18467, 7, 12, 0, 0, 18467, 18468, 7, 4, 0, 0, 18468, + 18469, 7, 18, 0, 0, 18469, 2498, 1, 0, 0, 0, 18470, 18471, 7, 15, 0, 0, + 18471, 18472, 7, 0, 0, 0, 18472, 18473, 7, 3, 0, 0, 18473, 18474, 7, 4, + 0, 0, 18474, 18475, 7, 12, 0, 0, 18475, 18476, 7, 0, 0, 0, 18476, 18477, + 7, 11, 0, 0, 18477, 18478, 5, 95, 0, 0, 18478, 18479, 7, 20, 0, 0, 18479, + 18480, 7, 2, 0, 0, 18480, 18481, 7, 12, 0, 0, 18481, 18482, 7, 7, 0, 0, + 18482, 2500, 1, 0, 0, 0, 18483, 18484, 7, 15, 0, 0, 18484, 18485, 7, 0, + 0, 0, 18485, 18486, 7, 3, 0, 0, 18486, 18487, 7, 4, 0, 0, 18487, 18488, + 7, 12, 0, 0, 18488, 18489, 7, 0, 0, 0, 18489, 18490, 7, 11, 0, 0, 18490, + 18491, 7, 11, 0, 0, 18491, 18492, 7, 18, 0, 0, 18492, 2502, 1, 0, 0, 0, + 18493, 18494, 7, 15, 0, 0, 18494, 18495, 7, 0, 0, 0, 18495, 18496, 7, 3, + 0, 0, 18496, 18497, 7, 4, 0, 0, 18497, 18498, 7, 12, 0, 0, 18498, 18499, + 7, 0, 0, 0, 18499, 18500, 7, 11, 0, 0, 18500, 2504, 1, 0, 0, 0, 18501, + 18502, 7, 15, 0, 0, 18502, 18503, 7, 0, 0, 0, 18503, 18504, 7, 3, 0, 0, + 18504, 18505, 7, 4, 0, 0, 18505, 18506, 7, 12, 0, 0, 18506, 18507, 7, 0, + 0, 0, 18507, 18508, 7, 11, 0, 0, 18508, 18509, 5, 95, 0, 0, 18509, 18510, + 7, 3, 0, 0, 18510, 18511, 7, 2, 0, 0, 18511, 18512, 7, 11, 0, 0, 18512, + 18513, 7, 11, 0, 0, 18513, 18514, 7, 10, 0, 0, 18514, 18515, 7, 15, 0, + 0, 18515, 18516, 5, 95, 0, 0, 18516, 18517, 7, 15, 0, 0, 18517, 18518, + 7, 10, 0, 0, 18518, 18519, 7, 5, 0, 0, 18519, 18520, 7, 19, 0, 0, 18520, + 18521, 7, 9, 0, 0, 18521, 18522, 7, 2, 0, 0, 18522, 18523, 7, 22, 0, 0, + 18523, 18524, 7, 7, 0, 0, 18524, 2506, 1, 0, 0, 0, 18525, 18526, 7, 15, + 0, 0, 18526, 18527, 7, 0, 0, 0, 18527, 18528, 7, 3, 0, 0, 18528, 18529, + 7, 4, 0, 0, 18529, 18530, 7, 12, 0, 0, 18530, 18531, 7, 4, 0, 0, 18531, + 18532, 7, 12, 0, 0, 18532, 18533, 7, 2, 0, 0, 18533, 18534, 7, 7, 0, 0, + 18534, 18535, 5, 95, 0, 0, 18535, 18536, 7, 19, 0, 0, 18536, 18537, 7, + 0, 0, 0, 18537, 18538, 7, 5, 0, 0, 18538, 18539, 7, 19, 0, 0, 18539, 2508, + 1, 0, 0, 0, 18540, 18541, 7, 15, 0, 0, 18541, 18542, 7, 0, 0, 0, 18542, + 18543, 7, 3, 0, 0, 18543, 18544, 7, 4, 0, 0, 18544, 18545, 7, 12, 0, 0, + 18545, 18546, 7, 4, 0, 0, 18546, 18547, 7, 12, 0, 0, 18547, 18548, 7, 2, + 0, 0, 18548, 18549, 7, 7, 0, 0, 18549, 18550, 5, 95, 0, 0, 18550, 18551, + 7, 11, 0, 0, 18551, 18552, 7, 12, 0, 0, 18552, 18553, 7, 5, 0, 0, 18553, + 18554, 7, 4, 0, 0, 18554, 2510, 1, 0, 0, 0, 18555, 18556, 7, 15, 0, 0, + 18556, 18557, 7, 0, 0, 0, 18557, 18558, 7, 3, 0, 0, 18558, 18559, 7, 4, + 0, 0, 18559, 18560, 7, 12, 0, 0, 18560, 18561, 7, 4, 0, 0, 18561, 18562, + 7, 12, 0, 0, 18562, 18563, 7, 2, 0, 0, 18563, 18564, 7, 7, 0, 0, 18564, + 2512, 1, 0, 0, 0, 18565, 18566, 7, 15, 0, 0, 18566, 18567, 7, 0, 0, 0, + 18567, 18568, 7, 3, 0, 0, 18568, 18569, 7, 4, 0, 0, 18569, 18570, 7, 12, + 0, 0, 18570, 18571, 7, 4, 0, 0, 18571, 18572, 7, 12, 0, 0, 18572, 18573, + 7, 2, 0, 0, 18573, 18574, 7, 7, 0, 0, 18574, 18575, 5, 95, 0, 0, 18575, + 18576, 7, 3, 0, 0, 18576, 18577, 7, 0, 0, 0, 18577, 18578, 7, 7, 0, 0, + 18578, 18579, 7, 17, 0, 0, 18579, 18580, 7, 6, 0, 0, 18580, 2514, 1, 0, + 0, 0, 18581, 18582, 7, 15, 0, 0, 18582, 18583, 7, 0, 0, 0, 18583, 18584, + 7, 3, 0, 0, 18584, 18585, 7, 4, 0, 0, 18585, 18586, 7, 12, 0, 0, 18586, + 18587, 7, 4, 0, 0, 18587, 18588, 7, 12, 0, 0, 18588, 18589, 7, 2, 0, 0, + 18589, 18590, 7, 7, 0, 0, 18590, 18591, 7, 5, 0, 0, 18591, 2516, 1, 0, + 0, 0, 18592, 18593, 7, 15, 0, 0, 18593, 18594, 7, 0, 0, 0, 18594, 18595, + 7, 3, 0, 0, 18595, 18596, 7, 4, 0, 0, 18596, 18597, 5, 36, 0, 0, 18597, + 18598, 7, 7, 0, 0, 18598, 18599, 7, 10, 0, 0, 18599, 18600, 7, 14, 0, 0, + 18600, 18601, 5, 36, 0, 0, 18601, 18602, 7, 12, 0, 0, 18602, 18603, 7, + 7, 0, 0, 18603, 18604, 7, 5, 0, 0, 18604, 18605, 7, 4, 0, 0, 18605, 2518, + 1, 0, 0, 0, 18606, 18607, 7, 15, 0, 0, 18607, 18608, 7, 0, 0, 0, 18608, + 18609, 7, 5, 0, 0, 18609, 18610, 7, 5, 0, 0, 18610, 18611, 7, 12, 0, 0, + 18611, 18612, 7, 7, 0, 0, 18612, 18613, 7, 17, 0, 0, 18613, 2520, 1, 0, + 0, 0, 18614, 18615, 7, 15, 0, 0, 18615, 18616, 7, 0, 0, 0, 18616, 18617, + 7, 5, 0, 0, 18617, 18618, 7, 5, 0, 0, 18618, 18619, 7, 22, 0, 0, 18619, + 18620, 7, 2, 0, 0, 18620, 18621, 7, 3, 0, 0, 18621, 18622, 7, 9, 0, 0, + 18622, 18623, 5, 95, 0, 0, 18623, 18624, 7, 17, 0, 0, 18624, 18625, 7, + 3, 0, 0, 18625, 18626, 7, 0, 0, 0, 18626, 18627, 7, 8, 0, 0, 18627, 18628, + 7, 6, 0, 0, 18628, 18629, 5, 95, 0, 0, 18629, 18630, 7, 4, 0, 0, 18630, + 18631, 7, 12, 0, 0, 18631, 18632, 7, 14, 0, 0, 18632, 18633, 7, 6, 0, 0, + 18633, 2522, 1, 0, 0, 0, 18634, 18635, 7, 15, 0, 0, 18635, 18636, 7, 0, + 0, 0, 18636, 18637, 7, 5, 0, 0, 18637, 18638, 7, 5, 0, 0, 18638, 18639, + 7, 22, 0, 0, 18639, 18640, 7, 2, 0, 0, 18640, 18641, 7, 3, 0, 0, 18641, + 18642, 7, 9, 0, 0, 18642, 18643, 5, 95, 0, 0, 18643, 18644, 7, 11, 0, 0, + 18644, 18645, 7, 12, 0, 0, 18645, 18646, 7, 16, 0, 0, 18646, 18647, 7, + 6, 0, 0, 18647, 18648, 5, 95, 0, 0, 18648, 18649, 7, 4, 0, 0, 18649, 18650, + 7, 12, 0, 0, 18650, 18651, 7, 14, 0, 0, 18651, 18652, 7, 6, 0, 0, 18652, + 2524, 1, 0, 0, 0, 18653, 18654, 7, 15, 0, 0, 18654, 18655, 7, 0, 0, 0, + 18655, 18656, 7, 5, 0, 0, 18656, 18657, 7, 5, 0, 0, 18657, 18658, 7, 22, + 0, 0, 18658, 18659, 7, 2, 0, 0, 18659, 18660, 7, 3, 0, 0, 18660, 18661, + 7, 9, 0, 0, 18661, 18662, 5, 95, 0, 0, 18662, 18663, 7, 11, 0, 0, 18663, + 18664, 7, 2, 0, 0, 18664, 18665, 7, 8, 0, 0, 18665, 18666, 7, 21, 0, 0, + 18666, 18667, 5, 95, 0, 0, 18667, 18668, 7, 4, 0, 0, 18668, 18669, 7, 12, + 0, 0, 18669, 18670, 7, 14, 0, 0, 18670, 18671, 7, 6, 0, 0, 18671, 2526, + 1, 0, 0, 0, 18672, 18673, 7, 15, 0, 0, 18673, 18674, 7, 0, 0, 0, 18674, + 18675, 7, 5, 0, 0, 18675, 18676, 7, 5, 0, 0, 18676, 18677, 7, 22, 0, 0, + 18677, 18678, 7, 2, 0, 0, 18678, 18679, 7, 3, 0, 0, 18679, 18680, 7, 9, + 0, 0, 18680, 2528, 1, 0, 0, 0, 18681, 18682, 7, 15, 0, 0, 18682, 18683, + 7, 0, 0, 0, 18683, 18684, 7, 5, 0, 0, 18684, 18685, 7, 5, 0, 0, 18685, + 18686, 7, 22, 0, 0, 18686, 18687, 7, 2, 0, 0, 18687, 18688, 7, 3, 0, 0, + 18688, 18689, 7, 9, 0, 0, 18689, 18690, 5, 95, 0, 0, 18690, 18691, 7, 3, + 0, 0, 18691, 18692, 7, 6, 0, 0, 18692, 18693, 7, 10, 0, 0, 18693, 18694, + 7, 5, 0, 0, 18694, 18695, 7, 6, 0, 0, 18695, 18696, 5, 95, 0, 0, 18696, + 18697, 7, 14, 0, 0, 18697, 18698, 7, 0, 0, 0, 18698, 18699, 7, 25, 0, 0, + 18699, 2530, 1, 0, 0, 0, 18700, 18701, 7, 15, 0, 0, 18701, 18702, 7, 0, + 0, 0, 18702, 18703, 7, 5, 0, 0, 18703, 18704, 7, 5, 0, 0, 18704, 18705, + 7, 22, 0, 0, 18705, 18706, 7, 2, 0, 0, 18706, 18707, 7, 3, 0, 0, 18707, + 18708, 7, 9, 0, 0, 18708, 18709, 5, 95, 0, 0, 18709, 18710, 7, 3, 0, 0, + 18710, 18711, 7, 6, 0, 0, 18711, 18712, 7, 10, 0, 0, 18712, 18713, 7, 5, + 0, 0, 18713, 18714, 7, 6, 0, 0, 18714, 18715, 5, 95, 0, 0, 18715, 18716, + 7, 4, 0, 0, 18716, 18717, 7, 12, 0, 0, 18717, 18718, 7, 14, 0, 0, 18718, + 18719, 7, 6, 0, 0, 18719, 2532, 1, 0, 0, 0, 18720, 18721, 7, 15, 0, 0, + 18721, 18722, 7, 0, 0, 0, 18722, 18723, 7, 5, 0, 0, 18723, 18724, 7, 5, + 0, 0, 18724, 18725, 7, 22, 0, 0, 18725, 18726, 7, 2, 0, 0, 18726, 18727, + 7, 3, 0, 0, 18727, 18728, 7, 9, 0, 0, 18728, 18729, 5, 95, 0, 0, 18729, + 18730, 7, 3, 0, 0, 18730, 18731, 7, 2, 0, 0, 18731, 18732, 7, 11, 0, 0, + 18732, 18733, 7, 11, 0, 0, 18733, 18734, 7, 2, 0, 0, 18734, 18735, 7, 13, + 0, 0, 18735, 18736, 7, 6, 0, 0, 18736, 18737, 7, 3, 0, 0, 18737, 18738, + 5, 95, 0, 0, 18738, 18739, 7, 4, 0, 0, 18739, 18740, 7, 12, 0, 0, 18740, + 18741, 7, 14, 0, 0, 18741, 18742, 7, 6, 0, 0, 18742, 2534, 1, 0, 0, 0, + 18743, 18744, 7, 15, 0, 0, 18744, 18745, 7, 0, 0, 0, 18745, 18746, 7, 5, + 0, 0, 18746, 18747, 7, 5, 0, 0, 18747, 18748, 7, 22, 0, 0, 18748, 18749, + 7, 2, 0, 0, 18749, 18750, 7, 3, 0, 0, 18750, 18751, 7, 9, 0, 0, 18751, + 18752, 5, 95, 0, 0, 18752, 18753, 7, 13, 0, 0, 18753, 18754, 7, 6, 0, 0, + 18754, 18755, 7, 3, 0, 0, 18755, 18756, 7, 12, 0, 0, 18756, 18757, 7, 16, + 0, 0, 18757, 18758, 7, 18, 0, 0, 18758, 18759, 5, 95, 0, 0, 18759, 18760, + 7, 16, 0, 0, 18760, 18761, 7, 10, 0, 0, 18761, 18762, 7, 7, 0, 0, 18762, + 18763, 7, 8, 0, 0, 18763, 18764, 7, 4, 0, 0, 18764, 18765, 7, 12, 0, 0, + 18765, 18766, 7, 2, 0, 0, 18766, 18767, 7, 7, 0, 0, 18767, 2536, 1, 0, + 0, 0, 18768, 18769, 7, 15, 0, 0, 18769, 18770, 7, 0, 0, 0, 18770, 18771, + 7, 5, 0, 0, 18771, 18772, 7, 4, 0, 0, 18772, 2538, 1, 0, 0, 0, 18773, 18774, + 7, 15, 0, 0, 18774, 18775, 7, 0, 0, 0, 18775, 18776, 7, 4, 0, 0, 18776, + 18777, 7, 8, 0, 0, 18777, 18778, 7, 19, 0, 0, 18778, 2540, 1, 0, 0, 0, + 18779, 18780, 7, 15, 0, 0, 18780, 18781, 7, 0, 0, 0, 18781, 18782, 7, 4, + 0, 0, 18782, 18783, 7, 19, 0, 0, 18783, 2542, 1, 0, 0, 0, 18784, 18785, + 7, 15, 0, 0, 18785, 18786, 7, 0, 0, 0, 18786, 18787, 7, 4, 0, 0, 18787, + 18788, 7, 19, 0, 0, 18788, 18789, 5, 95, 0, 0, 18789, 18790, 7, 15, 0, + 0, 18790, 18791, 7, 3, 0, 0, 18791, 18792, 7, 6, 0, 0, 18792, 18793, 7, + 16, 0, 0, 18793, 18794, 7, 12, 0, 0, 18794, 18795, 7, 25, 0, 0, 18795, + 2544, 1, 0, 0, 0, 18796, 18797, 7, 15, 0, 0, 18797, 18798, 7, 0, 0, 0, + 18798, 18799, 7, 4, 0, 0, 18799, 18800, 7, 19, 0, 0, 18800, 18801, 7, 5, + 0, 0, 18801, 2546, 1, 0, 0, 0, 18802, 18803, 7, 15, 0, 0, 18803, 18804, + 7, 0, 0, 0, 18804, 18805, 7, 4, 0, 0, 18805, 18806, 7, 4, 0, 0, 18806, + 18807, 7, 6, 0, 0, 18807, 18808, 7, 3, 0, 0, 18808, 18809, 7, 7, 0, 0, + 18809, 2548, 1, 0, 0, 0, 18810, 18811, 7, 15, 0, 0, 18811, 18812, 7, 1, + 0, 0, 18812, 18813, 7, 11, 0, 0, 18813, 18814, 5, 95, 0, 0, 18814, 18815, + 7, 19, 0, 0, 18815, 18816, 7, 5, 0, 0, 18816, 18817, 5, 95, 0, 0, 18817, + 18818, 7, 1, 0, 0, 18818, 18819, 7, 6, 0, 0, 18819, 18820, 7, 17, 0, 0, + 18820, 18821, 7, 12, 0, 0, 18821, 18822, 7, 7, 0, 0, 18822, 2550, 1, 0, + 0, 0, 18823, 18824, 7, 15, 0, 0, 18824, 18825, 7, 1, 0, 0, 18825, 18826, + 7, 11, 0, 0, 18826, 18827, 5, 95, 0, 0, 18827, 18828, 7, 19, 0, 0, 18828, + 18829, 7, 5, 0, 0, 18829, 18830, 5, 95, 0, 0, 18830, 18831, 7, 6, 0, 0, + 18831, 18832, 7, 7, 0, 0, 18832, 18833, 7, 9, 0, 0, 18833, 2552, 1, 0, + 0, 0, 18834, 18835, 7, 15, 0, 0, 18835, 18836, 7, 8, 0, 0, 18836, 18837, + 7, 4, 0, 0, 18837, 18838, 7, 16, 0, 0, 18838, 18839, 7, 3, 0, 0, 18839, + 18840, 7, 6, 0, 0, 18840, 18841, 7, 6, 0, 0, 18841, 2554, 1, 0, 0, 0, 18842, + 18843, 7, 15, 0, 0, 18843, 18844, 7, 8, 0, 0, 18844, 18845, 7, 4, 0, 0, + 18845, 18846, 7, 12, 0, 0, 18846, 18847, 7, 7, 0, 0, 18847, 18848, 7, 8, + 0, 0, 18848, 18849, 7, 3, 0, 0, 18849, 18850, 7, 6, 0, 0, 18850, 18851, + 7, 0, 0, 0, 18851, 18852, 7, 5, 0, 0, 18852, 18853, 7, 6, 0, 0, 18853, + 2556, 1, 0, 0, 0, 18854, 18855, 7, 15, 0, 0, 18855, 18856, 7, 8, 0, 0, + 18856, 18857, 7, 4, 0, 0, 18857, 18858, 7, 4, 0, 0, 18858, 18859, 7, 19, + 0, 0, 18859, 18860, 7, 3, 0, 0, 18860, 18861, 7, 6, 0, 0, 18861, 18862, + 7, 5, 0, 0, 18862, 18863, 7, 19, 0, 0, 18863, 18864, 7, 2, 0, 0, 18864, + 18865, 7, 11, 0, 0, 18865, 18866, 7, 9, 0, 0, 18866, 2558, 1, 0, 0, 0, + 18867, 18868, 7, 15, 0, 0, 18868, 18869, 7, 8, 0, 0, 18869, 18870, 7, 4, + 0, 0, 18870, 18871, 7, 10, 0, 0, 18871, 18872, 7, 5, 0, 0, 18872, 18873, + 7, 6, 0, 0, 18873, 18874, 7, 9, 0, 0, 18874, 2560, 1, 0, 0, 0, 18875, 18876, + 7, 15, 0, 0, 18876, 18877, 7, 8, 0, 0, 18877, 18878, 7, 4, 0, 0, 18878, + 18879, 7, 13, 0, 0, 18879, 18880, 7, 6, 0, 0, 18880, 18881, 7, 3, 0, 0, + 18881, 18882, 7, 5, 0, 0, 18882, 18883, 7, 12, 0, 0, 18883, 18884, 7, 2, + 0, 0, 18884, 18885, 7, 7, 0, 0, 18885, 2562, 1, 0, 0, 0, 18886, 18887, + 7, 15, 0, 0, 18887, 18888, 7, 6, 0, 0, 18888, 18889, 7, 7, 0, 0, 18889, + 18890, 7, 9, 0, 0, 18890, 18891, 7, 12, 0, 0, 18891, 18892, 7, 7, 0, 0, + 18892, 18893, 7, 17, 0, 0, 18893, 2564, 1, 0, 0, 0, 18894, 18898, 5, 37, + 0, 0, 18895, 18897, 3, 4885, 2442, 0, 18896, 18895, 1, 0, 0, 0, 18897, + 18900, 1, 0, 0, 0, 18898, 18896, 1, 0, 0, 0, 18898, 18899, 1, 0, 0, 0, + 18899, 18901, 1, 0, 0, 0, 18900, 18898, 1, 0, 0, 0, 18901, 18902, 7, 16, + 0, 0, 18902, 18903, 7, 2, 0, 0, 18903, 18904, 7, 10, 0, 0, 18904, 18905, + 7, 7, 0, 0, 18905, 18906, 7, 9, 0, 0, 18906, 2566, 1, 0, 0, 0, 18907, 18911, + 5, 37, 0, 0, 18908, 18910, 3, 4885, 2442, 0, 18909, 18908, 1, 0, 0, 0, + 18910, 18913, 1, 0, 0, 0, 18911, 18909, 1, 0, 0, 0, 18911, 18912, 1, 0, + 0, 0, 18912, 18914, 1, 0, 0, 0, 18913, 18911, 1, 0, 0, 0, 18914, 18915, + 7, 12, 0, 0, 18915, 18916, 7, 5, 0, 0, 18916, 18917, 7, 2, 0, 0, 18917, + 18918, 7, 15, 0, 0, 18918, 18919, 7, 6, 0, 0, 18919, 18920, 7, 7, 0, 0, + 18920, 2568, 1, 0, 0, 0, 18921, 18925, 5, 37, 0, 0, 18922, 18924, 3, 4885, + 2442, 0, 18923, 18922, 1, 0, 0, 0, 18924, 18927, 1, 0, 0, 0, 18925, 18923, + 1, 0, 0, 0, 18925, 18926, 1, 0, 0, 0, 18926, 18928, 1, 0, 0, 0, 18927, + 18925, 1, 0, 0, 0, 18928, 18929, 7, 7, 0, 0, 18929, 18930, 7, 2, 0, 0, + 18930, 18931, 7, 4, 0, 0, 18931, 18932, 7, 16, 0, 0, 18932, 18933, 7, 2, + 0, 0, 18933, 18934, 7, 10, 0, 0, 18934, 18935, 7, 7, 0, 0, 18935, 18936, + 7, 9, 0, 0, 18936, 2570, 1, 0, 0, 0, 18937, 18938, 7, 15, 0, 0, 18938, + 18939, 7, 6, 0, 0, 18939, 18940, 7, 3, 0, 0, 18940, 18941, 7, 8, 0, 0, + 18941, 18942, 7, 6, 0, 0, 18942, 18943, 7, 7, 0, 0, 18943, 18944, 7, 4, + 0, 0, 18944, 2572, 1, 0, 0, 0, 18945, 18946, 7, 15, 0, 0, 18946, 18947, + 7, 6, 0, 0, 18947, 18948, 7, 3, 0, 0, 18948, 18949, 7, 8, 0, 0, 18949, + 18950, 7, 6, 0, 0, 18950, 18951, 7, 7, 0, 0, 18951, 18952, 7, 4, 0, 0, + 18952, 18953, 5, 95, 0, 0, 18953, 18954, 7, 3, 0, 0, 18954, 18955, 7, 0, + 0, 0, 18955, 18956, 7, 7, 0, 0, 18956, 18957, 7, 21, 0, 0, 18957, 18958, + 7, 14, 0, 0, 18958, 2574, 1, 0, 0, 0, 18959, 18963, 5, 37, 0, 0, 18960, + 18962, 3, 4885, 2442, 0, 18961, 18960, 1, 0, 0, 0, 18962, 18965, 1, 0, + 0, 0, 18963, 18961, 1, 0, 0, 0, 18963, 18964, 1, 0, 0, 0, 18964, 18966, + 1, 0, 0, 0, 18965, 18963, 1, 0, 0, 0, 18966, 18967, 7, 3, 0, 0, 18967, + 18968, 7, 2, 0, 0, 18968, 18969, 7, 22, 0, 0, 18969, 18970, 7, 8, 0, 0, + 18970, 18971, 7, 2, 0, 0, 18971, 18972, 7, 10, 0, 0, 18972, 18973, 7, 7, + 0, 0, 18973, 18974, 7, 4, 0, 0, 18974, 2576, 1, 0, 0, 0, 18975, 18979, + 5, 37, 0, 0, 18976, 18978, 3, 4885, 2442, 0, 18977, 18976, 1, 0, 0, 0, + 18978, 18981, 1, 0, 0, 0, 18979, 18977, 1, 0, 0, 0, 18979, 18980, 1, 0, + 0, 0, 18980, 18982, 1, 0, 0, 0, 18981, 18979, 1, 0, 0, 0, 18982, 18983, + 7, 3, 0, 0, 18983, 18984, 7, 2, 0, 0, 18984, 18985, 7, 22, 0, 0, 18985, + 18986, 7, 4, 0, 0, 18986, 18987, 7, 18, 0, 0, 18987, 18988, 7, 15, 0, 0, + 18988, 18989, 7, 6, 0, 0, 18989, 2578, 1, 0, 0, 0, 18990, 18994, 5, 37, + 0, 0, 18991, 18993, 3, 4885, 2442, 0, 18992, 18991, 1, 0, 0, 0, 18993, + 18996, 1, 0, 0, 0, 18994, 18992, 1, 0, 0, 0, 18994, 18995, 1, 0, 0, 0, + 18995, 18997, 1, 0, 0, 0, 18996, 18994, 1, 0, 0, 0, 18997, 18998, 7, 4, + 0, 0, 18998, 18999, 7, 18, 0, 0, 18999, 19000, 7, 15, 0, 0, 19000, 19001, + 7, 6, 0, 0, 19001, 2580, 1, 0, 0, 0, 19002, 19003, 7, 15, 0, 0, 19003, + 19004, 7, 6, 0, 0, 19004, 19005, 7, 3, 0, 0, 19005, 19006, 7, 16, 0, 0, + 19006, 19007, 7, 2, 0, 0, 19007, 19008, 7, 3, 0, 0, 19008, 19009, 7, 14, + 0, 0, 19009, 19010, 7, 0, 0, 0, 19010, 19011, 7, 7, 0, 0, 19011, 19012, + 7, 8, 0, 0, 19012, 19013, 7, 6, 0, 0, 19013, 2582, 1, 0, 0, 0, 19014, 19015, + 7, 15, 0, 0, 19015, 19016, 7, 6, 0, 0, 19016, 19017, 7, 3, 0, 0, 19017, + 19018, 7, 12, 0, 0, 19018, 19019, 7, 2, 0, 0, 19019, 19020, 7, 9, 0, 0, + 19020, 2584, 1, 0, 0, 0, 19021, 19022, 7, 15, 0, 0, 19022, 19023, 7, 6, + 0, 0, 19023, 19024, 7, 3, 0, 0, 19024, 19025, 7, 14, 0, 0, 19025, 19026, + 7, 0, 0, 0, 19026, 19027, 7, 7, 0, 0, 19027, 19028, 7, 6, 0, 0, 19028, + 19029, 7, 7, 0, 0, 19029, 19030, 7, 4, 0, 0, 19030, 2586, 1, 0, 0, 0, 19031, + 19032, 7, 15, 0, 0, 19032, 19033, 7, 6, 0, 0, 19033, 19034, 7, 3, 0, 0, + 19034, 19035, 7, 14, 0, 0, 19035, 19036, 7, 12, 0, 0, 19036, 19037, 7, + 5, 0, 0, 19037, 19038, 7, 5, 0, 0, 19038, 19039, 7, 12, 0, 0, 19039, 19040, + 7, 2, 0, 0, 19040, 19041, 7, 7, 0, 0, 19041, 2588, 1, 0, 0, 0, 19042, 19043, + 7, 15, 0, 0, 19043, 19044, 7, 6, 0, 0, 19044, 19045, 7, 3, 0, 0, 19045, + 19046, 7, 14, 0, 0, 19046, 19047, 7, 10, 0, 0, 19047, 19048, 7, 4, 0, 0, + 19048, 19049, 7, 6, 0, 0, 19049, 2590, 1, 0, 0, 0, 19050, 19051, 7, 15, + 0, 0, 19051, 19052, 7, 6, 0, 0, 19052, 19053, 7, 3, 0, 0, 19053, 2592, + 1, 0, 0, 0, 19054, 19055, 7, 15, 0, 0, 19055, 19056, 7, 16, 0, 0, 19056, + 19057, 7, 12, 0, 0, 19057, 19058, 7, 11, 0, 0, 19058, 19059, 7, 6, 0, 0, + 19059, 2594, 1, 0, 0, 0, 19060, 19061, 7, 15, 0, 0, 19061, 19062, 7, 19, + 0, 0, 19062, 19063, 7, 18, 0, 0, 19063, 19064, 7, 5, 0, 0, 19064, 19065, + 7, 12, 0, 0, 19065, 19066, 7, 8, 0, 0, 19066, 19067, 7, 0, 0, 0, 19067, + 19068, 7, 11, 0, 0, 19068, 2596, 1, 0, 0, 0, 19069, 19070, 7, 15, 0, 0, + 19070, 19071, 7, 12, 0, 0, 19071, 19072, 7, 21, 0, 0, 19072, 19073, 7, + 6, 0, 0, 19073, 19074, 7, 18, 0, 0, 19074, 2598, 1, 0, 0, 0, 19075, 19076, + 7, 15, 0, 0, 19076, 19077, 7, 12, 0, 0, 19077, 19078, 7, 15, 0, 0, 19078, + 19079, 7, 6, 0, 0, 19079, 19080, 7, 11, 0, 0, 19080, 19081, 7, 12, 0, 0, + 19081, 19082, 7, 7, 0, 0, 19082, 19083, 7, 6, 0, 0, 19083, 19084, 7, 9, + 0, 0, 19084, 2600, 1, 0, 0, 0, 19085, 19086, 7, 15, 0, 0, 19086, 19087, + 7, 12, 0, 0, 19087, 19088, 7, 15, 0, 0, 19088, 19089, 7, 6, 0, 0, 19089, + 2602, 1, 0, 0, 0, 19090, 19091, 7, 15, 0, 0, 19091, 19092, 7, 12, 0, 0, + 19092, 19093, 7, 13, 0, 0, 19093, 19094, 5, 95, 0, 0, 19094, 19095, 7, + 17, 0, 0, 19095, 19096, 7, 1, 0, 0, 19096, 2604, 1, 0, 0, 0, 19097, 19098, + 7, 15, 0, 0, 19098, 19099, 7, 12, 0, 0, 19099, 19100, 7, 13, 0, 0, 19100, + 19101, 7, 2, 0, 0, 19101, 19102, 7, 4, 0, 0, 19102, 2606, 1, 0, 0, 0, 19103, + 19104, 7, 15, 0, 0, 19104, 19105, 7, 12, 0, 0, 19105, 19106, 7, 13, 0, + 0, 19106, 19107, 5, 95, 0, 0, 19107, 19108, 7, 5, 0, 0, 19108, 19109, 7, + 5, 0, 0, 19109, 19110, 7, 16, 0, 0, 19110, 2608, 1, 0, 0, 0, 19111, 19112, + 7, 15, 0, 0, 19112, 19113, 7, 11, 0, 0, 19113, 19114, 7, 0, 0, 0, 19114, + 19115, 7, 8, 0, 0, 19115, 19116, 7, 6, 0, 0, 19116, 19117, 5, 95, 0, 0, + 19117, 19118, 7, 9, 0, 0, 19118, 19119, 7, 12, 0, 0, 19119, 19120, 7, 5, + 0, 0, 19120, 19121, 7, 4, 0, 0, 19121, 19122, 7, 12, 0, 0, 19122, 19123, + 7, 7, 0, 0, 19123, 19124, 7, 8, 0, 0, 19124, 19125, 7, 4, 0, 0, 19125, + 2610, 1, 0, 0, 0, 19126, 19127, 7, 15, 0, 0, 19127, 19128, 7, 11, 0, 0, + 19128, 19129, 7, 0, 0, 0, 19129, 19130, 7, 8, 0, 0, 19130, 19131, 7, 6, + 0, 0, 19131, 19132, 5, 95, 0, 0, 19132, 19133, 7, 17, 0, 0, 19133, 19134, + 7, 3, 0, 0, 19134, 19135, 7, 2, 0, 0, 19135, 19136, 7, 10, 0, 0, 19136, + 19137, 7, 15, 0, 0, 19137, 19138, 5, 95, 0, 0, 19138, 19139, 7, 1, 0, 0, + 19139, 19140, 7, 18, 0, 0, 19140, 2612, 1, 0, 0, 0, 19141, 19142, 7, 15, + 0, 0, 19142, 19143, 7, 11, 0, 0, 19143, 19144, 7, 0, 0, 0, 19144, 19145, + 7, 7, 0, 0, 19145, 2614, 1, 0, 0, 0, 19146, 19147, 7, 15, 0, 0, 19147, + 19148, 7, 11, 0, 0, 19148, 19149, 7, 5, 0, 0, 19149, 19150, 7, 8, 0, 0, + 19150, 19151, 7, 2, 0, 0, 19151, 19152, 7, 15, 0, 0, 19152, 19153, 7, 6, + 0, 0, 19153, 19154, 5, 95, 0, 0, 19154, 19155, 7, 5, 0, 0, 19155, 19156, + 7, 6, 0, 0, 19156, 19157, 7, 4, 0, 0, 19157, 19158, 7, 4, 0, 0, 19158, + 19159, 7, 12, 0, 0, 19159, 19160, 7, 7, 0, 0, 19160, 19161, 7, 17, 0, 0, + 19161, 19162, 7, 5, 0, 0, 19162, 2616, 1, 0, 0, 0, 19163, 19164, 7, 15, + 0, 0, 19164, 19165, 7, 11, 0, 0, 19165, 19166, 7, 5, 0, 0, 19166, 19167, + 5, 95, 0, 0, 19167, 19168, 7, 12, 0, 0, 19168, 19169, 7, 7, 0, 0, 19169, + 19170, 7, 4, 0, 0, 19170, 19171, 7, 6, 0, 0, 19171, 19172, 7, 17, 0, 0, + 19172, 19173, 7, 6, 0, 0, 19173, 19174, 7, 3, 0, 0, 19174, 2618, 1, 0, + 0, 0, 19175, 19176, 7, 15, 0, 0, 19176, 19177, 7, 11, 0, 0, 19177, 19178, + 7, 5, 0, 0, 19178, 19179, 7, 24, 0, 0, 19179, 19180, 7, 11, 0, 0, 19180, + 19181, 5, 95, 0, 0, 19181, 19182, 7, 8, 0, 0, 19182, 19183, 7, 8, 0, 0, + 19183, 19184, 7, 16, 0, 0, 19184, 19185, 7, 11, 0, 0, 19185, 19186, 7, + 0, 0, 0, 19186, 19187, 7, 17, 0, 0, 19187, 19188, 7, 5, 0, 0, 19188, 2620, + 1, 0, 0, 0, 19189, 19190, 7, 15, 0, 0, 19190, 19191, 7, 11, 0, 0, 19191, + 19192, 7, 5, 0, 0, 19192, 19193, 7, 24, 0, 0, 19193, 19194, 7, 11, 0, 0, + 19194, 19195, 5, 95, 0, 0, 19195, 19196, 7, 8, 0, 0, 19196, 19197, 7, 2, + 0, 0, 19197, 19198, 7, 9, 0, 0, 19198, 19199, 7, 6, 0, 0, 19199, 19200, + 5, 95, 0, 0, 19200, 19201, 7, 4, 0, 0, 19201, 19202, 7, 18, 0, 0, 19202, + 19203, 7, 15, 0, 0, 19203, 19204, 7, 6, 0, 0, 19204, 2622, 1, 0, 0, 0, + 19205, 19206, 7, 15, 0, 0, 19206, 19207, 7, 11, 0, 0, 19207, 19208, 7, + 5, 0, 0, 19208, 19209, 7, 24, 0, 0, 19209, 19210, 7, 11, 0, 0, 19210, 19211, + 5, 95, 0, 0, 19211, 19212, 7, 9, 0, 0, 19212, 19213, 7, 6, 0, 0, 19213, + 19214, 7, 1, 0, 0, 19214, 19215, 7, 10, 0, 0, 19215, 19216, 7, 17, 0, 0, + 19216, 2624, 1, 0, 0, 0, 19217, 19218, 7, 15, 0, 0, 19218, 19219, 7, 11, + 0, 0, 19219, 19220, 7, 5, 0, 0, 19220, 19221, 7, 24, 0, 0, 19221, 19222, + 7, 11, 0, 0, 19222, 19223, 5, 95, 0, 0, 19223, 19224, 7, 2, 0, 0, 19224, + 19225, 7, 15, 0, 0, 19225, 19226, 7, 4, 0, 0, 19226, 19227, 7, 12, 0, 0, + 19227, 19228, 7, 14, 0, 0, 19228, 19229, 7, 12, 0, 0, 19229, 19230, 7, + 23, 0, 0, 19230, 19231, 7, 6, 0, 0, 19231, 19232, 5, 95, 0, 0, 19232, 19233, + 7, 11, 0, 0, 19233, 19234, 7, 6, 0, 0, 19234, 19235, 7, 13, 0, 0, 19235, + 19236, 7, 6, 0, 0, 19236, 19237, 7, 11, 0, 0, 19237, 2626, 1, 0, 0, 0, + 19238, 19239, 7, 15, 0, 0, 19239, 19240, 7, 11, 0, 0, 19240, 19241, 7, + 5, 0, 0, 19241, 19242, 7, 24, 0, 0, 19242, 19243, 7, 11, 0, 0, 19243, 19244, + 5, 95, 0, 0, 19244, 19245, 7, 22, 0, 0, 19245, 19246, 7, 0, 0, 0, 19246, + 19247, 7, 3, 0, 0, 19247, 19248, 7, 7, 0, 0, 19248, 19249, 7, 12, 0, 0, + 19249, 19250, 7, 7, 0, 0, 19250, 19251, 7, 17, 0, 0, 19251, 19252, 7, 5, + 0, 0, 19252, 2628, 1, 0, 0, 0, 19253, 19254, 7, 15, 0, 0, 19254, 19255, + 7, 11, 0, 0, 19255, 19256, 7, 10, 0, 0, 19256, 19257, 7, 17, 0, 0, 19257, + 19258, 7, 17, 0, 0, 19258, 19259, 7, 0, 0, 0, 19259, 19260, 7, 1, 0, 0, + 19260, 19261, 7, 11, 0, 0, 19261, 19262, 7, 6, 0, 0, 19262, 2630, 1, 0, + 0, 0, 19263, 19264, 7, 15, 0, 0, 19264, 19265, 7, 14, 0, 0, 19265, 19266, + 7, 6, 0, 0, 19266, 19267, 7, 14, 0, 0, 19267, 2632, 1, 0, 0, 0, 19268, + 19269, 7, 15, 0, 0, 19269, 19270, 7, 2, 0, 0, 19270, 19271, 7, 12, 0, 0, + 19271, 19272, 7, 7, 0, 0, 19272, 19273, 7, 4, 0, 0, 19273, 2634, 1, 0, + 0, 0, 19274, 19275, 7, 15, 0, 0, 19275, 19276, 7, 2, 0, 0, 19276, 19277, + 7, 11, 0, 0, 19277, 19278, 7, 12, 0, 0, 19278, 19279, 7, 8, 0, 0, 19279, + 19280, 7, 18, 0, 0, 19280, 2636, 1, 0, 0, 0, 19281, 19282, 7, 15, 0, 0, + 19282, 19283, 7, 2, 0, 0, 19283, 19284, 7, 2, 0, 0, 19284, 19285, 7, 11, + 0, 0, 19285, 19286, 5, 95, 0, 0, 19286, 19287, 5, 49, 0, 0, 19287, 19288, + 5, 54, 0, 0, 19288, 19289, 7, 21, 0, 0, 19289, 2638, 1, 0, 0, 0, 19290, + 19291, 7, 15, 0, 0, 19291, 19292, 7, 2, 0, 0, 19292, 19293, 7, 2, 0, 0, + 19293, 19294, 7, 11, 0, 0, 19294, 19295, 5, 95, 0, 0, 19295, 19296, 5, + 50, 0, 0, 19296, 19297, 7, 21, 0, 0, 19297, 2640, 1, 0, 0, 0, 19298, 19299, + 7, 15, 0, 0, 19299, 19300, 7, 2, 0, 0, 19300, 19301, 7, 2, 0, 0, 19301, + 19302, 7, 11, 0, 0, 19302, 19303, 5, 95, 0, 0, 19303, 19304, 5, 51, 0, + 0, 19304, 19305, 5, 50, 0, 0, 19305, 19306, 7, 21, 0, 0, 19306, 2642, 1, + 0, 0, 0, 19307, 19308, 7, 15, 0, 0, 19308, 19309, 7, 2, 0, 0, 19309, 19310, + 7, 2, 0, 0, 19310, 19311, 7, 11, 0, 0, 19311, 19312, 5, 95, 0, 0, 19312, + 19313, 5, 52, 0, 0, 19313, 19314, 7, 21, 0, 0, 19314, 2644, 1, 0, 0, 0, + 19315, 19316, 7, 15, 0, 0, 19316, 19317, 7, 2, 0, 0, 19317, 19318, 7, 2, + 0, 0, 19318, 19319, 7, 11, 0, 0, 19319, 19320, 5, 95, 0, 0, 19320, 19321, + 5, 56, 0, 0, 19321, 19322, 7, 21, 0, 0, 19322, 2646, 1, 0, 0, 0, 19323, + 19324, 7, 15, 0, 0, 19324, 19325, 7, 2, 0, 0, 19325, 19326, 7, 5, 0, 0, + 19326, 19327, 7, 12, 0, 0, 19327, 19328, 7, 4, 0, 0, 19328, 19329, 7, 12, + 0, 0, 19329, 19330, 7, 13, 0, 0, 19330, 19331, 7, 6, 0, 0, 19331, 19332, + 7, 7, 0, 0, 19332, 2648, 1, 0, 0, 0, 19333, 19334, 7, 15, 0, 0, 19334, + 19335, 7, 2, 0, 0, 19335, 19336, 7, 5, 0, 0, 19336, 19337, 7, 12, 0, 0, + 19337, 19338, 7, 4, 0, 0, 19338, 19339, 7, 12, 0, 0, 19339, 19340, 7, 13, + 0, 0, 19340, 19341, 7, 6, 0, 0, 19341, 2650, 1, 0, 0, 0, 19342, 19343, + 7, 15, 0, 0, 19343, 19344, 7, 2, 0, 0, 19344, 19345, 7, 5, 0, 0, 19345, + 19346, 7, 4, 0, 0, 19346, 19347, 5, 95, 0, 0, 19347, 19348, 7, 4, 0, 0, + 19348, 19349, 7, 3, 0, 0, 19349, 19350, 7, 0, 0, 0, 19350, 19351, 7, 7, + 0, 0, 19351, 19352, 7, 5, 0, 0, 19352, 19353, 7, 0, 0, 0, 19353, 19354, + 7, 8, 0, 0, 19354, 19355, 7, 4, 0, 0, 19355, 19356, 7, 12, 0, 0, 19356, + 19357, 7, 2, 0, 0, 19357, 19358, 7, 7, 0, 0, 19358, 2652, 1, 0, 0, 0, 19359, + 19360, 7, 15, 0, 0, 19360, 19361, 7, 2, 0, 0, 19361, 19362, 7, 22, 0, 0, + 19362, 19363, 7, 6, 0, 0, 19363, 19364, 7, 3, 0, 0, 19364, 19365, 7, 14, + 0, 0, 19365, 19366, 7, 10, 0, 0, 19366, 19367, 7, 11, 0, 0, 19367, 19368, + 7, 4, 0, 0, 19368, 19369, 7, 12, 0, 0, 19369, 19370, 7, 5, 0, 0, 19370, + 19371, 7, 6, 0, 0, 19371, 19372, 7, 4, 0, 0, 19372, 19373, 5, 95, 0, 0, + 19373, 19374, 7, 1, 0, 0, 19374, 19375, 7, 18, 0, 0, 19375, 19376, 5, 95, + 0, 0, 19376, 19377, 7, 8, 0, 0, 19377, 19378, 7, 0, 0, 0, 19378, 19379, + 7, 3, 0, 0, 19379, 19380, 7, 9, 0, 0, 19380, 19381, 7, 12, 0, 0, 19381, + 19382, 7, 7, 0, 0, 19382, 19383, 7, 0, 0, 0, 19383, 19384, 7, 11, 0, 0, + 19384, 19385, 7, 12, 0, 0, 19385, 19386, 7, 4, 0, 0, 19386, 19387, 7, 18, + 0, 0, 19387, 2654, 1, 0, 0, 0, 19388, 19389, 7, 15, 0, 0, 19389, 19390, + 7, 2, 0, 0, 19390, 19391, 7, 22, 0, 0, 19391, 19392, 7, 6, 0, 0, 19392, + 19393, 7, 3, 0, 0, 19393, 19394, 7, 14, 0, 0, 19394, 19395, 7, 10, 0, 0, + 19395, 19396, 7, 11, 0, 0, 19396, 19397, 7, 4, 0, 0, 19397, 19398, 7, 12, + 0, 0, 19398, 19399, 7, 5, 0, 0, 19399, 19400, 7, 6, 0, 0, 19400, 19401, + 7, 4, 0, 0, 19401, 2656, 1, 0, 0, 0, 19402, 19403, 7, 15, 0, 0, 19403, + 19404, 7, 2, 0, 0, 19404, 19405, 7, 22, 0, 0, 19405, 19406, 7, 6, 0, 0, + 19406, 19407, 7, 3, 0, 0, 19407, 2658, 1, 0, 0, 0, 19408, 19409, 7, 15, + 0, 0, 19409, 19410, 7, 24, 0, 0, 19410, 19411, 5, 95, 0, 0, 19411, 19412, + 7, 8, 0, 0, 19412, 19413, 7, 2, 0, 0, 19413, 19414, 7, 7, 0, 0, 19414, + 19415, 7, 8, 0, 0, 19415, 19416, 7, 10, 0, 0, 19416, 19417, 7, 3, 0, 0, + 19417, 19418, 7, 3, 0, 0, 19418, 19419, 7, 6, 0, 0, 19419, 19420, 7, 7, + 0, 0, 19420, 19421, 7, 4, 0, 0, 19421, 19422, 5, 95, 0, 0, 19422, 19423, + 7, 10, 0, 0, 19423, 19424, 7, 7, 0, 0, 19424, 19425, 7, 12, 0, 0, 19425, + 19426, 7, 2, 0, 0, 19426, 19427, 7, 7, 0, 0, 19427, 2660, 1, 0, 0, 0, 19428, + 19429, 7, 15, 0, 0, 19429, 19430, 7, 24, 0, 0, 19430, 19431, 5, 95, 0, + 0, 19431, 19432, 7, 9, 0, 0, 19432, 19433, 7, 12, 0, 0, 19433, 19434, 7, + 5, 0, 0, 19434, 19435, 7, 4, 0, 0, 19435, 19436, 7, 3, 0, 0, 19436, 19437, + 7, 12, 0, 0, 19437, 19438, 7, 1, 0, 0, 19438, 19439, 7, 10, 0, 0, 19439, + 19440, 7, 4, 0, 0, 19440, 19441, 7, 6, 0, 0, 19441, 2662, 1, 0, 0, 0, 19442, + 19443, 7, 15, 0, 0, 19443, 19444, 7, 24, 0, 0, 19444, 19445, 5, 95, 0, + 0, 19445, 19446, 7, 9, 0, 0, 19446, 19447, 7, 12, 0, 0, 19447, 19448, 7, + 5, 0, 0, 19448, 19449, 7, 4, 0, 0, 19449, 19450, 7, 3, 0, 0, 19450, 19451, + 7, 12, 0, 0, 19451, 19452, 7, 1, 0, 0, 19452, 19453, 7, 10, 0, 0, 19453, + 19454, 7, 4, 0, 0, 19454, 19455, 7, 6, 0, 0, 19455, 19456, 5, 95, 0, 0, + 19456, 19457, 7, 22, 0, 0, 19457, 19458, 7, 12, 0, 0, 19458, 19459, 7, + 7, 0, 0, 19459, 19460, 7, 9, 0, 0, 19460, 19461, 7, 2, 0, 0, 19461, 19462, + 7, 22, 0, 0, 19462, 2664, 1, 0, 0, 0, 19463, 19464, 7, 15, 0, 0, 19464, + 19465, 7, 24, 0, 0, 19465, 19466, 5, 95, 0, 0, 19466, 19467, 7, 16, 0, + 0, 19467, 19468, 7, 12, 0, 0, 19468, 19469, 7, 11, 0, 0, 19469, 19470, + 7, 4, 0, 0, 19470, 19471, 7, 6, 0, 0, 19471, 19472, 7, 3, 0, 0, 19472, + 2666, 1, 0, 0, 0, 19473, 19474, 7, 15, 0, 0, 19474, 19475, 7, 24, 0, 0, + 19475, 19476, 5, 95, 0, 0, 19476, 19477, 7, 14, 0, 0, 19477, 19478, 7, + 0, 0, 0, 19478, 19479, 7, 15, 0, 0, 19479, 2668, 1, 0, 0, 0, 19480, 19481, + 7, 15, 0, 0, 19481, 19482, 7, 24, 0, 0, 19482, 19483, 5, 95, 0, 0, 19483, + 19484, 7, 7, 0, 0, 19484, 19485, 7, 2, 0, 0, 19485, 19486, 7, 14, 0, 0, + 19486, 19487, 7, 0, 0, 0, 19487, 19488, 7, 15, 0, 0, 19488, 2670, 1, 0, + 0, 0, 19489, 19490, 7, 15, 0, 0, 19490, 19491, 7, 24, 0, 0, 19491, 19492, + 5, 95, 0, 0, 19492, 19493, 7, 3, 0, 0, 19493, 19494, 7, 6, 0, 0, 19494, + 19495, 7, 15, 0, 0, 19495, 19496, 7, 11, 0, 0, 19496, 19497, 7, 12, 0, + 0, 19497, 19498, 7, 8, 0, 0, 19498, 19499, 7, 0, 0, 0, 19499, 19500, 7, + 4, 0, 0, 19500, 19501, 7, 6, 0, 0, 19501, 2672, 1, 0, 0, 0, 19502, 19503, + 7, 15, 0, 0, 19503, 19504, 7, 24, 0, 0, 19504, 19505, 5, 95, 0, 0, 19505, + 19506, 7, 5, 0, 0, 19506, 19507, 7, 21, 0, 0, 19507, 19508, 7, 6, 0, 0, + 19508, 19509, 7, 22, 0, 0, 19509, 2674, 1, 0, 0, 0, 19510, 19511, 7, 15, + 0, 0, 19511, 19512, 7, 3, 0, 0, 19512, 19513, 7, 0, 0, 0, 19513, 19514, + 7, 17, 0, 0, 19514, 19515, 7, 14, 0, 0, 19515, 19516, 7, 0, 0, 0, 19516, + 2676, 1, 0, 0, 0, 19517, 19518, 7, 15, 0, 0, 19518, 19519, 7, 3, 0, 0, + 19519, 19520, 7, 6, 0, 0, 19520, 19521, 7, 1, 0, 0, 19521, 19522, 7, 10, + 0, 0, 19522, 19523, 7, 12, 0, 0, 19523, 19524, 7, 11, 0, 0, 19524, 19525, + 7, 4, 0, 0, 19525, 2678, 1, 0, 0, 0, 19526, 19527, 7, 15, 0, 0, 19527, + 19528, 7, 3, 0, 0, 19528, 19529, 7, 6, 0, 0, 19529, 19530, 7, 8, 0, 0, + 19530, 19531, 7, 6, 0, 0, 19531, 19532, 7, 9, 0, 0, 19532, 19533, 7, 6, + 0, 0, 19533, 19534, 7, 5, 0, 0, 19534, 2680, 1, 0, 0, 0, 19535, 19536, + 7, 15, 0, 0, 19536, 19537, 7, 3, 0, 0, 19537, 19538, 7, 6, 0, 0, 19538, + 19539, 7, 8, 0, 0, 19539, 19540, 7, 6, 0, 0, 19540, 19541, 7, 9, 0, 0, + 19541, 19542, 7, 12, 0, 0, 19542, 19543, 7, 7, 0, 0, 19543, 19544, 7, 17, + 0, 0, 19544, 2682, 1, 0, 0, 0, 19545, 19546, 7, 15, 0, 0, 19546, 19547, + 7, 3, 0, 0, 19547, 19548, 7, 6, 0, 0, 19548, 19549, 7, 8, 0, 0, 19549, + 19550, 7, 12, 0, 0, 19550, 19551, 7, 5, 0, 0, 19551, 19552, 7, 12, 0, 0, + 19552, 19553, 7, 2, 0, 0, 19553, 19554, 7, 7, 0, 0, 19554, 2684, 1, 0, + 0, 0, 19555, 19556, 7, 15, 0, 0, 19556, 19557, 7, 3, 0, 0, 19557, 19558, + 7, 6, 0, 0, 19558, 19559, 7, 8, 0, 0, 19559, 19560, 7, 2, 0, 0, 19560, + 19561, 7, 14, 0, 0, 19561, 19562, 7, 15, 0, 0, 19562, 19563, 7, 10, 0, + 0, 19563, 19564, 7, 4, 0, 0, 19564, 19565, 7, 6, 0, 0, 19565, 19566, 5, + 95, 0, 0, 19566, 19567, 7, 5, 0, 0, 19567, 19568, 7, 10, 0, 0, 19568, 19569, + 7, 1, 0, 0, 19569, 19570, 7, 24, 0, 0, 19570, 19571, 7, 10, 0, 0, 19571, + 19572, 7, 6, 0, 0, 19572, 19573, 7, 3, 0, 0, 19573, 19574, 7, 18, 0, 0, + 19574, 2686, 1, 0, 0, 0, 19575, 19576, 7, 15, 0, 0, 19576, 19577, 7, 3, + 0, 0, 19577, 19578, 7, 6, 0, 0, 19578, 19579, 7, 9, 0, 0, 19579, 19580, + 7, 12, 0, 0, 19580, 19581, 7, 8, 0, 0, 19581, 19582, 7, 0, 0, 0, 19582, + 19583, 7, 4, 0, 0, 19583, 19584, 7, 6, 0, 0, 19584, 19585, 5, 95, 0, 0, + 19585, 19586, 7, 3, 0, 0, 19586, 19587, 7, 6, 0, 0, 19587, 19588, 7, 2, + 0, 0, 19588, 19589, 7, 3, 0, 0, 19589, 19590, 7, 9, 0, 0, 19590, 19591, + 7, 6, 0, 0, 19591, 19592, 7, 3, 0, 0, 19592, 19593, 7, 5, 0, 0, 19593, + 2688, 1, 0, 0, 0, 19594, 19595, 7, 15, 0, 0, 19595, 19596, 7, 3, 0, 0, + 19596, 19597, 7, 6, 0, 0, 19597, 19598, 7, 11, 0, 0, 19598, 19599, 7, 2, + 0, 0, 19599, 19600, 7, 0, 0, 0, 19600, 19601, 7, 9, 0, 0, 19601, 2690, + 1, 0, 0, 0, 19602, 19603, 7, 15, 0, 0, 19603, 19604, 7, 3, 0, 0, 19604, + 19605, 7, 6, 0, 0, 19605, 19606, 7, 15, 0, 0, 19606, 19607, 7, 0, 0, 0, + 19607, 19608, 7, 3, 0, 0, 19608, 19609, 7, 6, 0, 0, 19609, 2692, 1, 0, + 0, 0, 19610, 19611, 7, 15, 0, 0, 19611, 19612, 7, 3, 0, 0, 19612, 19613, + 7, 6, 0, 0, 19613, 19614, 7, 5, 0, 0, 19614, 19615, 7, 6, 0, 0, 19615, + 19616, 7, 7, 0, 0, 19616, 19617, 7, 4, 0, 0, 19617, 19618, 7, 7, 0, 0, + 19618, 19619, 7, 7, 0, 0, 19619, 19620, 7, 13, 0, 0, 19620, 2694, 1, 0, + 0, 0, 19621, 19622, 7, 15, 0, 0, 19622, 19623, 7, 3, 0, 0, 19623, 19624, + 7, 6, 0, 0, 19624, 19625, 7, 5, 0, 0, 19625, 19626, 7, 6, 0, 0, 19626, + 19627, 7, 7, 0, 0, 19627, 19628, 7, 4, 0, 0, 19628, 2696, 1, 0, 0, 0, 19629, + 19630, 7, 15, 0, 0, 19630, 19631, 7, 3, 0, 0, 19631, 19632, 7, 6, 0, 0, + 19632, 19633, 7, 5, 0, 0, 19633, 19634, 7, 6, 0, 0, 19634, 19635, 7, 7, + 0, 0, 19635, 19636, 7, 4, 0, 0, 19636, 19637, 7, 13, 0, 0, 19637, 2698, + 1, 0, 0, 0, 19638, 19639, 7, 15, 0, 0, 19639, 19640, 7, 3, 0, 0, 19640, + 19641, 7, 6, 0, 0, 19641, 19642, 7, 5, 0, 0, 19642, 19643, 7, 6, 0, 0, + 19643, 19644, 7, 3, 0, 0, 19644, 19645, 7, 13, 0, 0, 19645, 19646, 7, 6, + 0, 0, 19646, 19647, 5, 95, 0, 0, 19647, 19648, 7, 2, 0, 0, 19648, 19649, + 7, 12, 0, 0, 19649, 19650, 7, 9, 0, 0, 19650, 2700, 1, 0, 0, 0, 19651, + 19652, 7, 15, 0, 0, 19652, 19653, 7, 3, 0, 0, 19653, 19654, 7, 6, 0, 0, + 19654, 19655, 7, 5, 0, 0, 19655, 19656, 7, 6, 0, 0, 19656, 19657, 7, 3, + 0, 0, 19657, 19658, 7, 13, 0, 0, 19658, 19659, 7, 6, 0, 0, 19659, 2702, + 1, 0, 0, 0, 19660, 19661, 7, 15, 0, 0, 19661, 19662, 7, 3, 0, 0, 19662, + 19663, 7, 6, 0, 0, 19663, 19664, 7, 4, 0, 0, 19664, 19665, 7, 4, 0, 0, + 19665, 19666, 7, 18, 0, 0, 19666, 2704, 1, 0, 0, 0, 19667, 19668, 7, 15, + 0, 0, 19668, 19669, 7, 3, 0, 0, 19669, 19670, 7, 6, 0, 0, 19670, 19671, + 7, 13, 0, 0, 19671, 19672, 7, 12, 0, 0, 19672, 19673, 7, 2, 0, 0, 19673, + 19674, 7, 10, 0, 0, 19674, 19675, 7, 5, 0, 0, 19675, 2706, 1, 0, 0, 0, + 19676, 19677, 7, 15, 0, 0, 19677, 19678, 7, 3, 0, 0, 19678, 19679, 7, 6, + 0, 0, 19679, 19680, 7, 13, 0, 0, 19680, 2708, 1, 0, 0, 0, 19681, 19682, + 7, 15, 0, 0, 19682, 19683, 7, 3, 0, 0, 19683, 19684, 7, 12, 0, 0, 19684, + 19685, 7, 14, 0, 0, 19685, 19686, 7, 0, 0, 0, 19686, 19687, 7, 3, 0, 0, + 19687, 19688, 7, 18, 0, 0, 19688, 2710, 1, 0, 0, 0, 19689, 19690, 7, 15, + 0, 0, 19690, 19691, 7, 3, 0, 0, 19691, 19692, 7, 12, 0, 0, 19692, 19693, + 7, 7, 0, 0, 19693, 19694, 7, 4, 0, 0, 19694, 19695, 7, 1, 0, 0, 19695, + 19696, 7, 11, 0, 0, 19696, 19697, 7, 2, 0, 0, 19697, 19698, 7, 1, 0, 0, + 19698, 19699, 7, 4, 0, 0, 19699, 19700, 7, 2, 0, 0, 19700, 19701, 7, 8, + 0, 0, 19701, 19702, 7, 11, 0, 0, 19702, 19703, 7, 2, 0, 0, 19703, 19704, + 7, 1, 0, 0, 19704, 2712, 1, 0, 0, 0, 19705, 19706, 7, 15, 0, 0, 19706, + 19707, 7, 3, 0, 0, 19707, 19708, 7, 12, 0, 0, 19708, 19709, 7, 2, 0, 0, + 19709, 19710, 7, 3, 0, 0, 19710, 19711, 7, 12, 0, 0, 19711, 19712, 7, 4, + 0, 0, 19712, 19713, 7, 18, 0, 0, 19713, 2714, 1, 0, 0, 0, 19714, 19715, + 7, 15, 0, 0, 19715, 19716, 7, 3, 0, 0, 19716, 19717, 7, 12, 0, 0, 19717, + 19718, 7, 2, 0, 0, 19718, 19719, 7, 3, 0, 0, 19719, 2716, 1, 0, 0, 0, 19720, + 19721, 7, 15, 0, 0, 19721, 19722, 7, 3, 0, 0, 19722, 19723, 7, 12, 0, 0, + 19723, 19724, 7, 13, 0, 0, 19724, 19725, 7, 0, 0, 0, 19725, 19726, 7, 4, + 0, 0, 19726, 19727, 7, 6, 0, 0, 19727, 2718, 1, 0, 0, 0, 19728, 19729, + 7, 15, 0, 0, 19729, 19730, 7, 3, 0, 0, 19730, 19731, 7, 12, 0, 0, 19731, + 19732, 7, 13, 0, 0, 19732, 19733, 7, 0, 0, 0, 19733, 19734, 7, 4, 0, 0, + 19734, 19735, 7, 6, 0, 0, 19735, 19736, 5, 95, 0, 0, 19736, 19737, 7, 5, + 0, 0, 19737, 19738, 7, 17, 0, 0, 19738, 19739, 7, 0, 0, 0, 19739, 2720, + 1, 0, 0, 0, 19740, 19741, 7, 15, 0, 0, 19741, 19742, 7, 3, 0, 0, 19742, + 19743, 7, 12, 0, 0, 19743, 19744, 7, 13, 0, 0, 19744, 19745, 7, 12, 0, + 0, 19745, 19746, 7, 11, 0, 0, 19746, 19747, 7, 6, 0, 0, 19747, 19748, 7, + 17, 0, 0, 19748, 19749, 7, 6, 0, 0, 19749, 19750, 7, 9, 0, 0, 19750, 2722, + 1, 0, 0, 0, 19751, 19752, 7, 15, 0, 0, 19752, 19753, 7, 3, 0, 0, 19753, + 19754, 7, 12, 0, 0, 19754, 19755, 7, 13, 0, 0, 19755, 19756, 7, 12, 0, + 0, 19756, 19757, 7, 11, 0, 0, 19757, 19758, 7, 6, 0, 0, 19758, 19759, 7, + 17, 0, 0, 19759, 19760, 7, 6, 0, 0, 19760, 2724, 1, 0, 0, 0, 19761, 19762, + 7, 15, 0, 0, 19762, 19763, 7, 3, 0, 0, 19763, 19764, 7, 12, 0, 0, 19764, + 19765, 7, 13, 0, 0, 19765, 19766, 7, 12, 0, 0, 19766, 19767, 7, 11, 0, + 0, 19767, 19768, 7, 6, 0, 0, 19768, 19769, 7, 17, 0, 0, 19769, 19770, 7, + 6, 0, 0, 19770, 19771, 7, 5, 0, 0, 19771, 2726, 1, 0, 0, 0, 19772, 19773, + 7, 15, 0, 0, 19773, 19774, 7, 3, 0, 0, 19774, 19775, 7, 2, 0, 0, 19775, + 19776, 7, 8, 0, 0, 19776, 19777, 7, 6, 0, 0, 19777, 19778, 7, 9, 0, 0, + 19778, 19779, 7, 10, 0, 0, 19779, 19780, 7, 3, 0, 0, 19780, 19781, 7, 0, + 0, 0, 19781, 19782, 7, 11, 0, 0, 19782, 2728, 1, 0, 0, 0, 19783, 19784, + 7, 15, 0, 0, 19784, 19785, 7, 3, 0, 0, 19785, 19786, 7, 2, 0, 0, 19786, + 19787, 7, 8, 0, 0, 19787, 19788, 7, 6, 0, 0, 19788, 19789, 7, 9, 0, 0, + 19789, 19790, 7, 10, 0, 0, 19790, 19791, 7, 3, 0, 0, 19791, 19792, 7, 6, + 0, 0, 19792, 2730, 1, 0, 0, 0, 19793, 19794, 7, 15, 0, 0, 19794, 19795, + 7, 3, 0, 0, 19795, 19796, 7, 2, 0, 0, 19796, 19797, 7, 8, 0, 0, 19797, + 19798, 7, 6, 0, 0, 19798, 19799, 7, 5, 0, 0, 19799, 19800, 7, 5, 0, 0, + 19800, 2732, 1, 0, 0, 0, 19801, 19802, 7, 15, 0, 0, 19802, 19803, 7, 3, + 0, 0, 19803, 19804, 7, 2, 0, 0, 19804, 19805, 7, 16, 0, 0, 19805, 19806, + 7, 12, 0, 0, 19806, 19807, 7, 11, 0, 0, 19807, 19808, 7, 6, 0, 0, 19808, + 2734, 1, 0, 0, 0, 19809, 19810, 7, 15, 0, 0, 19810, 19811, 7, 3, 0, 0, + 19811, 19812, 7, 2, 0, 0, 19812, 19813, 7, 17, 0, 0, 19813, 19814, 7, 3, + 0, 0, 19814, 19815, 7, 0, 0, 0, 19815, 19816, 7, 14, 0, 0, 19816, 2736, + 1, 0, 0, 0, 19817, 19818, 7, 15, 0, 0, 19818, 19819, 7, 3, 0, 0, 19819, + 19820, 7, 2, 0, 0, 19820, 19821, 7, 20, 0, 0, 19821, 19822, 7, 6, 0, 0, + 19822, 19823, 7, 8, 0, 0, 19823, 19824, 7, 4, 0, 0, 19824, 2738, 1, 0, + 0, 0, 19825, 19826, 7, 15, 0, 0, 19826, 19827, 7, 3, 0, 0, 19827, 19828, + 7, 2, 0, 0, 19828, 19829, 7, 15, 0, 0, 19829, 19830, 7, 0, 0, 0, 19830, + 19831, 7, 17, 0, 0, 19831, 19832, 7, 0, 0, 0, 19832, 19833, 7, 4, 0, 0, + 19833, 19834, 7, 6, 0, 0, 19834, 2740, 1, 0, 0, 0, 19835, 19836, 7, 15, + 0, 0, 19836, 19837, 7, 3, 0, 0, 19837, 19838, 7, 2, 0, 0, 19838, 19839, + 7, 15, 0, 0, 19839, 19840, 7, 6, 0, 0, 19840, 19841, 7, 3, 0, 0, 19841, + 19842, 7, 4, 0, 0, 19842, 19843, 7, 18, 0, 0, 19843, 2742, 1, 0, 0, 0, + 19844, 19845, 7, 15, 0, 0, 19845, 19846, 7, 3, 0, 0, 19846, 19847, 7, 2, + 0, 0, 19847, 19848, 7, 4, 0, 0, 19848, 19849, 7, 6, 0, 0, 19849, 19850, + 7, 8, 0, 0, 19850, 19851, 7, 4, 0, 0, 19851, 19852, 7, 6, 0, 0, 19852, + 19853, 7, 9, 0, 0, 19853, 2744, 1, 0, 0, 0, 19854, 19855, 7, 15, 0, 0, + 19855, 19856, 7, 3, 0, 0, 19856, 19857, 7, 2, 0, 0, 19857, 19858, 7, 4, + 0, 0, 19858, 19859, 7, 6, 0, 0, 19859, 19860, 7, 8, 0, 0, 19860, 19861, + 7, 4, 0, 0, 19861, 19862, 7, 12, 0, 0, 19862, 19863, 7, 2, 0, 0, 19863, + 19864, 7, 7, 0, 0, 19864, 2746, 1, 0, 0, 0, 19865, 19866, 7, 15, 0, 0, + 19866, 19867, 7, 3, 0, 0, 19867, 19868, 7, 2, 0, 0, 19868, 19869, 7, 4, + 0, 0, 19869, 19870, 7, 2, 0, 0, 19870, 19871, 7, 8, 0, 0, 19871, 19872, + 7, 2, 0, 0, 19872, 19873, 7, 11, 0, 0, 19873, 2748, 1, 0, 0, 0, 19874, + 19875, 7, 15, 0, 0, 19875, 19876, 7, 3, 0, 0, 19876, 19877, 7, 2, 0, 0, + 19877, 19878, 7, 25, 0, 0, 19878, 19879, 7, 18, 0, 0, 19879, 2750, 1, 0, + 0, 0, 19880, 19881, 7, 15, 0, 0, 19881, 19882, 7, 3, 0, 0, 19882, 19883, + 7, 10, 0, 0, 19883, 19884, 7, 7, 0, 0, 19884, 19885, 7, 12, 0, 0, 19885, + 19886, 7, 7, 0, 0, 19886, 19887, 7, 17, 0, 0, 19887, 2752, 1, 0, 0, 0, + 19888, 19889, 7, 15, 0, 0, 19889, 19890, 7, 10, 0, 0, 19890, 19891, 7, + 1, 0, 0, 19891, 19892, 7, 11, 0, 0, 19892, 19893, 7, 12, 0, 0, 19893, 19894, + 7, 8, 0, 0, 19894, 2754, 1, 0, 0, 0, 19895, 19896, 7, 15, 0, 0, 19896, + 19897, 7, 10, 0, 0, 19897, 19898, 7, 11, 0, 0, 19898, 19899, 7, 11, 0, + 0, 19899, 19900, 5, 95, 0, 0, 19900, 19901, 7, 15, 0, 0, 19901, 19902, + 7, 3, 0, 0, 19902, 19903, 7, 6, 0, 0, 19903, 19904, 7, 9, 0, 0, 19904, + 2756, 1, 0, 0, 0, 19905, 19906, 7, 15, 0, 0, 19906, 19907, 7, 10, 0, 0, + 19907, 19908, 7, 3, 0, 0, 19908, 19909, 7, 17, 0, 0, 19909, 19910, 7, 6, + 0, 0, 19910, 2758, 1, 0, 0, 0, 19911, 19912, 7, 15, 0, 0, 19912, 19913, + 7, 10, 0, 0, 19913, 19914, 7, 5, 0, 0, 19914, 19915, 7, 19, 0, 0, 19915, + 19916, 5, 95, 0, 0, 19916, 19917, 7, 15, 0, 0, 19917, 19918, 7, 3, 0, 0, + 19918, 19919, 7, 6, 0, 0, 19919, 19920, 7, 9, 0, 0, 19920, 2760, 1, 0, + 0, 0, 19921, 19922, 7, 15, 0, 0, 19922, 19923, 7, 10, 0, 0, 19923, 19924, + 7, 5, 0, 0, 19924, 19925, 7, 19, 0, 0, 19925, 19926, 5, 95, 0, 0, 19926, + 19927, 7, 5, 0, 0, 19927, 19928, 7, 10, 0, 0, 19928, 19929, 7, 1, 0, 0, + 19929, 19930, 7, 24, 0, 0, 19930, 2762, 1, 0, 0, 0, 19931, 19932, 7, 15, + 0, 0, 19932, 19933, 7, 25, 0, 0, 19933, 19934, 5, 95, 0, 0, 19934, 19935, + 7, 16, 0, 0, 19935, 19936, 7, 0, 0, 0, 19936, 19937, 7, 10, 0, 0, 19937, + 19938, 7, 11, 0, 0, 19938, 19939, 7, 4, 0, 0, 19939, 19940, 5, 95, 0, 0, + 19940, 19941, 7, 4, 0, 0, 19941, 19942, 7, 2, 0, 0, 19942, 19943, 7, 11, + 0, 0, 19943, 19944, 7, 6, 0, 0, 19944, 19945, 7, 3, 0, 0, 19945, 19946, + 7, 0, 0, 0, 19946, 19947, 7, 7, 0, 0, 19947, 19948, 7, 8, 0, 0, 19948, + 19949, 7, 6, 0, 0, 19949, 2764, 1, 0, 0, 0, 19950, 19951, 7, 15, 0, 0, + 19951, 19952, 7, 25, 0, 0, 19952, 19953, 5, 95, 0, 0, 19953, 19954, 7, + 17, 0, 0, 19954, 19955, 7, 3, 0, 0, 19955, 19956, 7, 0, 0, 0, 19956, 19957, + 7, 7, 0, 0, 19957, 19958, 7, 10, 0, 0, 19958, 19959, 7, 11, 0, 0, 19959, + 19960, 7, 6, 0, 0, 19960, 2766, 1, 0, 0, 0, 19961, 19962, 7, 15, 0, 0, + 19962, 19963, 7, 25, 0, 0, 19963, 19964, 5, 95, 0, 0, 19964, 19965, 7, + 20, 0, 0, 19965, 19966, 7, 2, 0, 0, 19966, 19967, 7, 12, 0, 0, 19967, 19968, + 7, 7, 0, 0, 19968, 19969, 5, 95, 0, 0, 19969, 19970, 7, 16, 0, 0, 19970, + 19971, 7, 12, 0, 0, 19971, 19972, 7, 11, 0, 0, 19972, 19973, 7, 4, 0, 0, + 19973, 19974, 7, 6, 0, 0, 19974, 19975, 7, 3, 0, 0, 19975, 2768, 1, 0, + 0, 0, 19976, 19977, 7, 24, 0, 0, 19977, 19978, 7, 1, 0, 0, 19978, 19979, + 5, 95, 0, 0, 19979, 19980, 7, 7, 0, 0, 19980, 19981, 7, 0, 0, 0, 19981, + 19982, 7, 14, 0, 0, 19982, 19983, 7, 6, 0, 0, 19983, 2770, 1, 0, 0, 0, + 19984, 19985, 7, 24, 0, 0, 19985, 19986, 7, 10, 0, 0, 19986, 19987, 7, + 0, 0, 0, 19987, 19988, 7, 3, 0, 0, 19988, 19989, 7, 4, 0, 0, 19989, 19990, + 7, 6, 0, 0, 19990, 19991, 7, 3, 0, 0, 19991, 19992, 7, 5, 0, 0, 19992, + 2772, 1, 0, 0, 0, 19993, 19994, 7, 24, 0, 0, 19994, 19995, 7, 10, 0, 0, + 19995, 19996, 7, 6, 0, 0, 19996, 19997, 7, 3, 0, 0, 19997, 19998, 7, 18, + 0, 0, 19998, 19999, 5, 95, 0, 0, 19999, 20000, 7, 1, 0, 0, 20000, 20001, + 7, 11, 0, 0, 20001, 20002, 7, 2, 0, 0, 20002, 20003, 7, 8, 0, 0, 20003, + 20004, 7, 21, 0, 0, 20004, 2774, 1, 0, 0, 0, 20005, 20006, 7, 24, 0, 0, + 20006, 20007, 7, 10, 0, 0, 20007, 20008, 7, 6, 0, 0, 20008, 20009, 7, 3, + 0, 0, 20009, 20010, 7, 18, 0, 0, 20010, 2776, 1, 0, 0, 0, 20011, 20012, + 7, 24, 0, 0, 20012, 20013, 7, 10, 0, 0, 20013, 20014, 7, 6, 0, 0, 20014, + 20015, 7, 10, 0, 0, 20015, 20016, 7, 6, 0, 0, 20016, 20017, 5, 95, 0, 0, + 20017, 20018, 7, 8, 0, 0, 20018, 20019, 7, 10, 0, 0, 20019, 20020, 7, 3, + 0, 0, 20020, 20021, 7, 3, 0, 0, 20021, 2778, 1, 0, 0, 0, 20022, 20023, + 7, 24, 0, 0, 20023, 20024, 7, 10, 0, 0, 20024, 20025, 7, 6, 0, 0, 20025, + 20026, 7, 10, 0, 0, 20026, 20027, 7, 6, 0, 0, 20027, 2780, 1, 0, 0, 0, + 20028, 20029, 7, 24, 0, 0, 20029, 20030, 7, 10, 0, 0, 20030, 20031, 7, + 6, 0, 0, 20031, 20032, 7, 10, 0, 0, 20032, 20033, 7, 6, 0, 0, 20033, 20034, + 5, 95, 0, 0, 20034, 20035, 7, 3, 0, 0, 20035, 20036, 7, 2, 0, 0, 20036, + 20037, 7, 22, 0, 0, 20037, 20038, 7, 15, 0, 0, 20038, 2782, 1, 0, 0, 0, + 20039, 20040, 7, 24, 0, 0, 20040, 20041, 7, 10, 0, 0, 20041, 20042, 7, + 12, 0, 0, 20042, 20043, 7, 6, 0, 0, 20043, 20044, 7, 5, 0, 0, 20044, 20045, + 7, 8, 0, 0, 20045, 20046, 7, 6, 0, 0, 20046, 2784, 1, 0, 0, 0, 20047, 20048, + 7, 24, 0, 0, 20048, 20049, 7, 10, 0, 0, 20049, 20050, 7, 2, 0, 0, 20050, + 20051, 7, 3, 0, 0, 20051, 20052, 7, 10, 0, 0, 20052, 20053, 7, 14, 0, 0, + 20053, 2786, 1, 0, 0, 0, 20054, 20055, 7, 24, 0, 0, 20055, 20056, 7, 10, + 0, 0, 20056, 20057, 7, 2, 0, 0, 20057, 20058, 7, 4, 0, 0, 20058, 20059, + 7, 0, 0, 0, 20059, 2788, 1, 0, 0, 0, 20060, 20061, 7, 24, 0, 0, 20061, + 20062, 7, 10, 0, 0, 20062, 20063, 7, 2, 0, 0, 20063, 20064, 7, 4, 0, 0, + 20064, 20065, 7, 0, 0, 0, 20065, 20066, 7, 17, 0, 0, 20066, 20067, 7, 3, + 0, 0, 20067, 20068, 7, 2, 0, 0, 20068, 20069, 7, 10, 0, 0, 20069, 20070, + 7, 15, 0, 0, 20070, 2790, 1, 0, 0, 0, 20071, 20072, 7, 3, 0, 0, 20072, + 20073, 7, 0, 0, 0, 20073, 20074, 7, 12, 0, 0, 20074, 20075, 7, 5, 0, 0, + 20075, 20076, 7, 6, 0, 0, 20076, 2792, 1, 0, 0, 0, 20077, 20078, 7, 3, + 0, 0, 20078, 20079, 7, 0, 0, 0, 20079, 20080, 7, 7, 0, 0, 20080, 20081, + 7, 9, 0, 0, 20081, 20082, 7, 2, 0, 0, 20082, 20083, 7, 14, 0, 0, 20083, + 20084, 5, 95, 0, 0, 20084, 20085, 7, 11, 0, 0, 20085, 20086, 7, 2, 0, 0, + 20086, 20087, 7, 8, 0, 0, 20087, 20088, 7, 0, 0, 0, 20088, 20089, 7, 11, + 0, 0, 20089, 2794, 1, 0, 0, 0, 20090, 20091, 7, 3, 0, 0, 20091, 20092, + 7, 0, 0, 0, 20092, 20093, 7, 7, 0, 0, 20093, 20094, 7, 9, 0, 0, 20094, + 20095, 7, 2, 0, 0, 20095, 20096, 7, 14, 0, 0, 20096, 2796, 1, 0, 0, 0, + 20097, 20098, 7, 3, 0, 0, 20098, 20099, 7, 0, 0, 0, 20099, 20100, 7, 7, + 0, 0, 20100, 20101, 7, 17, 0, 0, 20101, 20102, 7, 6, 0, 0, 20102, 2798, + 1, 0, 0, 0, 20103, 20104, 7, 3, 0, 0, 20104, 20105, 7, 0, 0, 0, 20105, + 20106, 7, 7, 0, 0, 20106, 20107, 7, 21, 0, 0, 20107, 20108, 7, 14, 0, 0, + 20108, 2800, 1, 0, 0, 0, 20109, 20110, 7, 3, 0, 0, 20110, 20111, 7, 0, + 0, 0, 20111, 20112, 7, 15, 0, 0, 20112, 20113, 7, 12, 0, 0, 20113, 20114, + 7, 9, 0, 0, 20114, 20115, 7, 11, 0, 0, 20115, 20116, 7, 18, 0, 0, 20116, + 2802, 1, 0, 0, 0, 20117, 20118, 7, 3, 0, 0, 20118, 20119, 7, 0, 0, 0, 20119, + 20120, 7, 22, 0, 0, 20120, 2804, 1, 0, 0, 0, 20121, 20122, 7, 3, 0, 0, + 20122, 20123, 7, 0, 0, 0, 20123, 20124, 7, 22, 0, 0, 20124, 20125, 7, 4, + 0, 0, 20125, 20126, 7, 2, 0, 0, 20126, 20127, 7, 19, 0, 0, 20127, 20128, + 7, 6, 0, 0, 20128, 20129, 7, 25, 0, 0, 20129, 2806, 1, 0, 0, 0, 20130, + 20131, 7, 3, 0, 0, 20131, 20132, 7, 0, 0, 0, 20132, 20133, 7, 22, 0, 0, + 20133, 20134, 7, 4, 0, 0, 20134, 20135, 7, 2, 0, 0, 20135, 20136, 7, 7, + 0, 0, 20136, 20137, 7, 19, 0, 0, 20137, 20138, 7, 6, 0, 0, 20138, 20139, + 7, 25, 0, 0, 20139, 2808, 1, 0, 0, 0, 20140, 20141, 7, 3, 0, 0, 20141, + 20142, 7, 1, 0, 0, 20142, 20143, 7, 0, 0, 0, 20143, 2810, 1, 0, 0, 0, 20144, + 20145, 7, 3, 0, 0, 20145, 20146, 7, 1, 0, 0, 20146, 20147, 7, 2, 0, 0, + 20147, 20148, 5, 95, 0, 0, 20148, 20149, 7, 2, 0, 0, 20149, 20150, 7, 10, + 0, 0, 20150, 20151, 7, 4, 0, 0, 20151, 20152, 7, 11, 0, 0, 20152, 20153, + 7, 12, 0, 0, 20153, 20154, 7, 7, 0, 0, 20154, 20155, 7, 6, 0, 0, 20155, + 2812, 1, 0, 0, 0, 20156, 20157, 7, 3, 0, 0, 20157, 20158, 7, 9, 0, 0, 20158, + 20159, 7, 1, 0, 0, 20159, 20160, 7, 0, 0, 0, 20160, 2814, 1, 0, 0, 0, 20161, + 20162, 7, 3, 0, 0, 20162, 20163, 7, 6, 0, 0, 20163, 20164, 7, 0, 0, 0, + 20164, 20165, 7, 9, 0, 0, 20165, 2816, 1, 0, 0, 0, 20166, 20167, 7, 3, + 0, 0, 20167, 20168, 7, 6, 0, 0, 20168, 20169, 7, 0, 0, 0, 20169, 20170, + 7, 9, 0, 0, 20170, 20171, 7, 5, 0, 0, 20171, 2818, 1, 0, 0, 0, 20172, 20173, + 7, 3, 0, 0, 20173, 20174, 7, 6, 0, 0, 20174, 20175, 7, 0, 0, 0, 20175, + 20176, 7, 11, 0, 0, 20176, 20177, 7, 14, 0, 0, 20177, 2820, 1, 0, 0, 0, + 20178, 20179, 7, 3, 0, 0, 20179, 20180, 7, 6, 0, 0, 20180, 20181, 7, 0, + 0, 0, 20181, 20182, 7, 11, 0, 0, 20182, 2822, 1, 0, 0, 0, 20183, 20184, + 7, 3, 0, 0, 20184, 20185, 7, 6, 0, 0, 20185, 20186, 7, 1, 0, 0, 20186, + 20187, 7, 0, 0, 0, 20187, 20188, 7, 11, 0, 0, 20188, 20189, 7, 0, 0, 0, + 20189, 20190, 7, 7, 0, 0, 20190, 20191, 7, 8, 0, 0, 20191, 20192, 7, 6, + 0, 0, 20192, 2824, 1, 0, 0, 0, 20193, 20194, 7, 3, 0, 0, 20194, 20195, + 7, 6, 0, 0, 20195, 20196, 7, 1, 0, 0, 20196, 20197, 7, 10, 0, 0, 20197, + 20198, 7, 12, 0, 0, 20198, 20199, 7, 11, 0, 0, 20199, 20200, 7, 9, 0, 0, + 20200, 2826, 1, 0, 0, 0, 20201, 20202, 7, 3, 0, 0, 20202, 20203, 7, 6, + 0, 0, 20203, 20204, 7, 8, 0, 0, 20204, 20205, 7, 2, 0, 0, 20205, 20206, + 7, 3, 0, 0, 20206, 20207, 7, 9, 0, 0, 20207, 2828, 1, 0, 0, 0, 20208, 20209, + 7, 3, 0, 0, 20209, 20210, 7, 6, 0, 0, 20210, 20211, 7, 8, 0, 0, 20211, + 20212, 7, 2, 0, 0, 20212, 20213, 7, 3, 0, 0, 20213, 20214, 7, 9, 0, 0, + 20214, 20215, 7, 5, 0, 0, 20215, 20216, 5, 95, 0, 0, 20216, 20217, 7, 15, + 0, 0, 20217, 20218, 7, 6, 0, 0, 20218, 20219, 7, 3, 0, 0, 20219, 20220, + 5, 95, 0, 0, 20220, 20221, 7, 1, 0, 0, 20221, 20222, 7, 11, 0, 0, 20222, + 20223, 7, 2, 0, 0, 20223, 20224, 7, 8, 0, 0, 20224, 20225, 7, 21, 0, 0, + 20225, 2830, 1, 0, 0, 0, 20226, 20227, 7, 3, 0, 0, 20227, 20228, 7, 6, + 0, 0, 20228, 20229, 7, 8, 0, 0, 20229, 20230, 7, 2, 0, 0, 20230, 20231, + 7, 13, 0, 0, 20231, 20232, 7, 6, 0, 0, 20232, 20233, 7, 3, 0, 0, 20233, + 20234, 7, 0, 0, 0, 20234, 20235, 7, 1, 0, 0, 20235, 20236, 7, 11, 0, 0, + 20236, 20237, 7, 6, 0, 0, 20237, 2832, 1, 0, 0, 0, 20238, 20239, 7, 3, + 0, 0, 20239, 20240, 7, 6, 0, 0, 20240, 20241, 7, 8, 0, 0, 20241, 20242, + 7, 2, 0, 0, 20242, 20243, 7, 13, 0, 0, 20243, 20244, 7, 6, 0, 0, 20244, + 20245, 7, 3, 0, 0, 20245, 2834, 1, 0, 0, 0, 20246, 20247, 7, 3, 0, 0, 20247, + 20248, 7, 6, 0, 0, 20248, 20249, 7, 8, 0, 0, 20249, 20250, 7, 2, 0, 0, + 20250, 20251, 7, 13, 0, 0, 20251, 20252, 7, 6, 0, 0, 20252, 20253, 7, 3, + 0, 0, 20253, 20254, 7, 18, 0, 0, 20254, 2836, 1, 0, 0, 0, 20255, 20256, + 7, 3, 0, 0, 20256, 20257, 7, 6, 0, 0, 20257, 20258, 7, 8, 0, 0, 20258, + 20259, 7, 18, 0, 0, 20259, 20260, 7, 8, 0, 0, 20260, 20261, 7, 11, 0, 0, + 20261, 20262, 7, 6, 0, 0, 20262, 20263, 7, 1, 0, 0, 20263, 20264, 7, 12, + 0, 0, 20264, 20265, 7, 7, 0, 0, 20265, 2838, 1, 0, 0, 0, 20266, 20267, + 7, 3, 0, 0, 20267, 20268, 7, 6, 0, 0, 20268, 20269, 7, 8, 0, 0, 20269, + 20270, 7, 18, 0, 0, 20270, 20271, 7, 8, 0, 0, 20271, 20272, 7, 11, 0, 0, + 20272, 20273, 7, 6, 0, 0, 20273, 2840, 1, 0, 0, 0, 20274, 20275, 7, 3, + 0, 0, 20275, 20276, 7, 6, 0, 0, 20276, 20277, 7, 9, 0, 0, 20277, 20278, + 7, 0, 0, 0, 20278, 20279, 7, 8, 0, 0, 20279, 20280, 7, 4, 0, 0, 20280, + 20281, 7, 12, 0, 0, 20281, 20282, 7, 2, 0, 0, 20282, 20283, 7, 7, 0, 0, + 20283, 2842, 1, 0, 0, 0, 20284, 20285, 7, 3, 0, 0, 20285, 20286, 7, 6, + 0, 0, 20286, 20287, 7, 9, 0, 0, 20287, 20288, 7, 6, 0, 0, 20288, 20289, + 7, 16, 0, 0, 20289, 20290, 7, 12, 0, 0, 20290, 20291, 7, 7, 0, 0, 20291, + 20292, 7, 6, 0, 0, 20292, 2844, 1, 0, 0, 0, 20293, 20294, 7, 3, 0, 0, 20294, + 20295, 7, 6, 0, 0, 20295, 20296, 7, 9, 0, 0, 20296, 20297, 7, 2, 0, 0, + 20297, 2846, 1, 0, 0, 0, 20298, 20299, 7, 3, 0, 0, 20299, 20300, 7, 6, + 0, 0, 20300, 20301, 7, 9, 0, 0, 20301, 20302, 7, 10, 0, 0, 20302, 20303, + 7, 8, 0, 0, 20303, 20304, 7, 6, 0, 0, 20304, 20305, 7, 9, 0, 0, 20305, + 2848, 1, 0, 0, 0, 20306, 20307, 7, 3, 0, 0, 20307, 20308, 7, 6, 0, 0, 20308, + 20309, 7, 9, 0, 0, 20309, 20310, 7, 10, 0, 0, 20310, 20311, 7, 7, 0, 0, + 20311, 20312, 7, 9, 0, 0, 20312, 20313, 7, 0, 0, 0, 20313, 20314, 7, 7, + 0, 0, 20314, 20315, 7, 8, 0, 0, 20315, 20316, 7, 18, 0, 0, 20316, 2850, + 1, 0, 0, 0, 20317, 20318, 7, 3, 0, 0, 20318, 20319, 7, 6, 0, 0, 20319, + 20320, 7, 16, 0, 0, 20320, 20321, 5, 95, 0, 0, 20321, 20322, 7, 8, 0, 0, + 20322, 20323, 7, 0, 0, 0, 20323, 20324, 7, 5, 0, 0, 20324, 20325, 7, 8, + 0, 0, 20325, 20326, 7, 0, 0, 0, 20326, 20327, 7, 9, 0, 0, 20327, 20328, + 7, 6, 0, 0, 20328, 20329, 5, 95, 0, 0, 20329, 20330, 7, 8, 0, 0, 20330, + 20331, 7, 10, 0, 0, 20331, 20332, 7, 3, 0, 0, 20332, 20333, 7, 5, 0, 0, + 20333, 20334, 7, 2, 0, 0, 20334, 20335, 7, 3, 0, 0, 20335, 2852, 1, 0, + 0, 0, 20336, 20337, 7, 3, 0, 0, 20337, 20338, 7, 6, 0, 0, 20338, 20339, + 7, 16, 0, 0, 20339, 20340, 7, 6, 0, 0, 20340, 20341, 7, 3, 0, 0, 20341, + 20342, 7, 6, 0, 0, 20342, 20343, 7, 7, 0, 0, 20343, 20344, 7, 8, 0, 0, + 20344, 20345, 7, 6, 0, 0, 20345, 20346, 7, 9, 0, 0, 20346, 2854, 1, 0, + 0, 0, 20347, 20348, 7, 3, 0, 0, 20348, 20349, 7, 6, 0, 0, 20349, 20350, + 7, 16, 0, 0, 20350, 20351, 7, 6, 0, 0, 20351, 20352, 7, 3, 0, 0, 20352, + 20353, 7, 6, 0, 0, 20353, 20354, 7, 7, 0, 0, 20354, 20355, 7, 8, 0, 0, + 20355, 20356, 7, 6, 0, 0, 20356, 2856, 1, 0, 0, 0, 20357, 20358, 7, 3, + 0, 0, 20358, 20359, 7, 6, 0, 0, 20359, 20360, 7, 16, 0, 0, 20360, 20361, + 7, 6, 0, 0, 20361, 20362, 7, 3, 0, 0, 20362, 20363, 7, 6, 0, 0, 20363, + 20364, 7, 7, 0, 0, 20364, 20365, 7, 8, 0, 0, 20365, 20366, 7, 6, 0, 0, + 20366, 20367, 7, 5, 0, 0, 20367, 2858, 1, 0, 0, 0, 20368, 20369, 7, 3, + 0, 0, 20369, 20370, 7, 6, 0, 0, 20370, 20371, 7, 16, 0, 0, 20371, 20372, + 7, 6, 0, 0, 20372, 20373, 7, 3, 0, 0, 20373, 20374, 7, 6, 0, 0, 20374, + 20375, 7, 7, 0, 0, 20375, 20376, 7, 8, 0, 0, 20376, 20377, 7, 12, 0, 0, + 20377, 20378, 7, 7, 0, 0, 20378, 20379, 7, 17, 0, 0, 20379, 2860, 1, 0, + 0, 0, 20380, 20381, 7, 3, 0, 0, 20381, 20382, 7, 6, 0, 0, 20382, 20383, + 7, 16, 0, 0, 20383, 2862, 1, 0, 0, 0, 20384, 20385, 7, 3, 0, 0, 20385, + 20386, 7, 6, 0, 0, 20386, 20387, 7, 16, 0, 0, 20387, 20388, 7, 3, 0, 0, + 20388, 20389, 7, 6, 0, 0, 20389, 20390, 7, 5, 0, 0, 20390, 20391, 7, 19, + 0, 0, 20391, 2864, 1, 0, 0, 0, 20392, 20393, 7, 3, 0, 0, 20393, 20394, + 7, 6, 0, 0, 20394, 20395, 7, 16, 0, 0, 20395, 20396, 7, 4, 0, 0, 20396, + 20397, 7, 2, 0, 0, 20397, 20398, 7, 19, 0, 0, 20398, 20399, 7, 6, 0, 0, + 20399, 20400, 7, 25, 0, 0, 20400, 2866, 1, 0, 0, 0, 20401, 20402, 7, 3, + 0, 0, 20402, 20403, 7, 6, 0, 0, 20403, 20404, 7, 17, 0, 0, 20404, 20405, + 7, 6, 0, 0, 20405, 20406, 7, 25, 0, 0, 20406, 20407, 7, 15, 0, 0, 20407, + 20408, 5, 95, 0, 0, 20408, 20409, 7, 8, 0, 0, 20409, 20410, 7, 2, 0, 0, + 20410, 20411, 7, 10, 0, 0, 20411, 20412, 7, 7, 0, 0, 20412, 20413, 7, 4, + 0, 0, 20413, 2868, 1, 0, 0, 0, 20414, 20415, 7, 3, 0, 0, 20415, 20416, + 7, 6, 0, 0, 20416, 20417, 7, 17, 0, 0, 20417, 20418, 7, 6, 0, 0, 20418, + 20419, 7, 25, 0, 0, 20419, 20420, 7, 15, 0, 0, 20420, 20421, 5, 95, 0, + 0, 20421, 20422, 7, 12, 0, 0, 20422, 20423, 7, 7, 0, 0, 20423, 20424, 7, + 5, 0, 0, 20424, 20425, 7, 4, 0, 0, 20425, 20426, 7, 3, 0, 0, 20426, 2870, + 1, 0, 0, 0, 20427, 20428, 7, 3, 0, 0, 20428, 20429, 7, 6, 0, 0, 20429, + 20430, 7, 17, 0, 0, 20430, 20431, 7, 6, 0, 0, 20431, 20432, 7, 25, 0, 0, + 20432, 20433, 7, 15, 0, 0, 20433, 20434, 5, 95, 0, 0, 20434, 20435, 7, + 11, 0, 0, 20435, 20436, 7, 12, 0, 0, 20436, 20437, 7, 21, 0, 0, 20437, + 20438, 7, 6, 0, 0, 20438, 2872, 1, 0, 0, 0, 20439, 20440, 7, 3, 0, 0, 20440, + 20441, 7, 6, 0, 0, 20441, 20442, 7, 17, 0, 0, 20442, 20443, 7, 6, 0, 0, + 20443, 20444, 7, 25, 0, 0, 20444, 20445, 7, 15, 0, 0, 20445, 20446, 5, + 95, 0, 0, 20446, 20447, 7, 3, 0, 0, 20447, 20448, 7, 6, 0, 0, 20448, 20449, + 7, 15, 0, 0, 20449, 20450, 7, 11, 0, 0, 20450, 20451, 7, 0, 0, 0, 20451, + 20452, 7, 8, 0, 0, 20452, 20453, 7, 6, 0, 0, 20453, 2874, 1, 0, 0, 0, 20454, + 20455, 7, 3, 0, 0, 20455, 20456, 7, 6, 0, 0, 20456, 20457, 7, 17, 0, 0, + 20457, 20458, 7, 6, 0, 0, 20458, 20459, 7, 25, 0, 0, 20459, 20460, 7, 15, + 0, 0, 20460, 20461, 5, 95, 0, 0, 20461, 20462, 7, 5, 0, 0, 20462, 20463, + 7, 10, 0, 0, 20463, 20464, 7, 1, 0, 0, 20464, 20465, 7, 5, 0, 0, 20465, + 20466, 7, 4, 0, 0, 20466, 20467, 7, 3, 0, 0, 20467, 2876, 1, 0, 0, 0, 20468, + 20469, 7, 3, 0, 0, 20469, 20470, 7, 6, 0, 0, 20470, 20471, 7, 17, 0, 0, + 20471, 20472, 7, 12, 0, 0, 20472, 20473, 7, 5, 0, 0, 20473, 20474, 7, 4, + 0, 0, 20474, 20475, 7, 6, 0, 0, 20475, 20476, 7, 3, 0, 0, 20476, 2878, + 1, 0, 0, 0, 20477, 20478, 7, 3, 0, 0, 20478, 20479, 7, 6, 0, 0, 20479, + 20480, 7, 17, 0, 0, 20480, 20481, 7, 3, 0, 0, 20481, 20482, 5, 95, 0, 0, + 20482, 20483, 7, 0, 0, 0, 20483, 20484, 7, 13, 0, 0, 20484, 20485, 7, 17, + 0, 0, 20485, 20486, 7, 25, 0, 0, 20486, 2880, 1, 0, 0, 0, 20487, 20488, + 7, 3, 0, 0, 20488, 20489, 7, 6, 0, 0, 20489, 20490, 7, 17, 0, 0, 20490, + 20491, 7, 3, 0, 0, 20491, 20492, 5, 95, 0, 0, 20492, 20493, 7, 0, 0, 0, + 20493, 20494, 7, 13, 0, 0, 20494, 20495, 7, 17, 0, 0, 20495, 20496, 7, + 18, 0, 0, 20496, 2882, 1, 0, 0, 0, 20497, 20498, 7, 3, 0, 0, 20498, 20499, + 7, 6, 0, 0, 20499, 20500, 7, 17, 0, 0, 20500, 20501, 7, 3, 0, 0, 20501, + 20502, 5, 95, 0, 0, 20502, 20503, 7, 8, 0, 0, 20503, 20504, 7, 2, 0, 0, + 20504, 20505, 7, 10, 0, 0, 20505, 20506, 7, 7, 0, 0, 20506, 20507, 7, 4, + 0, 0, 20507, 2884, 1, 0, 0, 0, 20508, 20509, 7, 3, 0, 0, 20509, 20510, + 7, 6, 0, 0, 20510, 20511, 7, 17, 0, 0, 20511, 20512, 7, 3, 0, 0, 20512, + 20513, 5, 95, 0, 0, 20513, 20514, 7, 12, 0, 0, 20514, 20515, 7, 7, 0, 0, + 20515, 20516, 7, 4, 0, 0, 20516, 20517, 7, 6, 0, 0, 20517, 20518, 7, 3, + 0, 0, 20518, 20519, 7, 8, 0, 0, 20519, 20520, 7, 6, 0, 0, 20520, 20521, + 7, 15, 0, 0, 20521, 20522, 7, 4, 0, 0, 20522, 2886, 1, 0, 0, 0, 20523, + 20524, 7, 3, 0, 0, 20524, 20525, 7, 6, 0, 0, 20525, 20526, 7, 17, 0, 0, + 20526, 20527, 7, 3, 0, 0, 20527, 20528, 5, 95, 0, 0, 20528, 20529, 7, 3, + 0, 0, 20529, 20530, 5, 50, 0, 0, 20530, 2888, 1, 0, 0, 0, 20531, 20532, + 7, 3, 0, 0, 20532, 20533, 7, 6, 0, 0, 20533, 20534, 7, 17, 0, 0, 20534, + 20535, 7, 3, 0, 0, 20535, 20536, 5, 95, 0, 0, 20536, 20537, 7, 5, 0, 0, + 20537, 20538, 7, 11, 0, 0, 20538, 20539, 7, 2, 0, 0, 20539, 20540, 7, 15, + 0, 0, 20540, 20541, 7, 6, 0, 0, 20541, 2890, 1, 0, 0, 0, 20542, 20543, + 7, 3, 0, 0, 20543, 20544, 7, 6, 0, 0, 20544, 20545, 7, 17, 0, 0, 20545, + 20546, 7, 3, 0, 0, 20546, 20547, 5, 95, 0, 0, 20547, 20548, 7, 5, 0, 0, + 20548, 20549, 7, 25, 0, 0, 20549, 20550, 7, 25, 0, 0, 20550, 2892, 1, 0, + 0, 0, 20551, 20552, 7, 3, 0, 0, 20552, 20553, 7, 6, 0, 0, 20553, 20554, + 7, 17, 0, 0, 20554, 20555, 7, 3, 0, 0, 20555, 20556, 5, 95, 0, 0, 20556, + 20557, 7, 5, 0, 0, 20557, 20558, 7, 25, 0, 0, 20558, 20559, 7, 18, 0, 0, + 20559, 2894, 1, 0, 0, 0, 20560, 20561, 7, 3, 0, 0, 20561, 20562, 7, 6, + 0, 0, 20562, 20563, 7, 17, 0, 0, 20563, 20564, 7, 3, 0, 0, 20564, 20565, + 5, 95, 0, 0, 20565, 20566, 7, 5, 0, 0, 20566, 20567, 7, 18, 0, 0, 20567, + 20568, 7, 18, 0, 0, 20568, 2896, 1, 0, 0, 0, 20569, 20570, 7, 3, 0, 0, + 20570, 20571, 7, 6, 0, 0, 20571, 20572, 7, 17, 0, 0, 20572, 20573, 7, 10, + 0, 0, 20573, 20574, 7, 11, 0, 0, 20574, 20575, 7, 0, 0, 0, 20575, 20576, + 7, 3, 0, 0, 20576, 2898, 1, 0, 0, 0, 20577, 20578, 7, 3, 0, 0, 20578, 20579, + 7, 6, 0, 0, 20579, 20580, 7, 20, 0, 0, 20580, 20581, 7, 6, 0, 0, 20581, + 20582, 7, 8, 0, 0, 20582, 20583, 7, 4, 0, 0, 20583, 2900, 1, 0, 0, 0, 20584, + 20585, 7, 3, 0, 0, 20585, 20586, 7, 6, 0, 0, 20586, 20587, 7, 21, 0, 0, + 20587, 20588, 7, 6, 0, 0, 20588, 20589, 7, 18, 0, 0, 20589, 2902, 1, 0, + 0, 0, 20590, 20591, 7, 3, 0, 0, 20591, 20592, 7, 6, 0, 0, 20592, 20593, + 7, 11, 0, 0, 20593, 20594, 7, 0, 0, 0, 20594, 20595, 7, 4, 0, 0, 20595, + 20596, 7, 12, 0, 0, 20596, 20597, 7, 2, 0, 0, 20597, 20598, 7, 7, 0, 0, + 20598, 20599, 7, 0, 0, 0, 20599, 20600, 7, 11, 0, 0, 20600, 2904, 1, 0, + 0, 0, 20601, 20602, 7, 3, 0, 0, 20602, 20603, 7, 6, 0, 0, 20603, 20604, + 7, 11, 0, 0, 20604, 20605, 7, 12, 0, 0, 20605, 20606, 7, 6, 0, 0, 20606, + 20607, 7, 5, 0, 0, 20607, 20608, 5, 95, 0, 0, 20608, 20609, 7, 2, 0, 0, + 20609, 20610, 7, 7, 0, 0, 20610, 2906, 1, 0, 0, 0, 20611, 20612, 7, 3, + 0, 0, 20612, 20613, 7, 6, 0, 0, 20613, 20614, 7, 11, 0, 0, 20614, 20615, + 7, 2, 0, 0, 20615, 20616, 7, 8, 0, 0, 20616, 20617, 7, 0, 0, 0, 20617, + 20618, 7, 4, 0, 0, 20618, 20619, 7, 6, 0, 0, 20619, 2908, 1, 0, 0, 0, 20620, + 20621, 7, 3, 0, 0, 20621, 20622, 7, 6, 0, 0, 20622, 20623, 7, 11, 0, 0, + 20623, 20624, 7, 18, 0, 0, 20624, 2910, 1, 0, 0, 0, 20625, 20626, 7, 3, + 0, 0, 20626, 20627, 7, 6, 0, 0, 20627, 20628, 7, 14, 0, 0, 20628, 20629, + 7, 0, 0, 0, 20629, 20630, 7, 12, 0, 0, 20630, 20631, 7, 7, 0, 0, 20631, + 20632, 7, 9, 0, 0, 20632, 20633, 7, 6, 0, 0, 20633, 20634, 7, 3, 0, 0, + 20634, 2912, 1, 0, 0, 0, 20635, 20636, 7, 3, 0, 0, 20636, 20637, 7, 6, + 0, 0, 20637, 20638, 7, 14, 0, 0, 20638, 20639, 7, 2, 0, 0, 20639, 20640, + 7, 4, 0, 0, 20640, 20641, 7, 6, 0, 0, 20641, 2914, 1, 0, 0, 0, 20642, 20643, + 7, 3, 0, 0, 20643, 20644, 7, 6, 0, 0, 20644, 20645, 7, 14, 0, 0, 20645, + 20646, 7, 2, 0, 0, 20646, 20647, 7, 4, 0, 0, 20647, 20648, 7, 6, 0, 0, + 20648, 20649, 5, 95, 0, 0, 20649, 20650, 7, 14, 0, 0, 20650, 20651, 7, + 0, 0, 0, 20651, 20652, 7, 15, 0, 0, 20652, 20653, 7, 15, 0, 0, 20653, 20654, + 7, 6, 0, 0, 20654, 20655, 7, 9, 0, 0, 20655, 2916, 1, 0, 0, 0, 20656, 20657, + 7, 3, 0, 0, 20657, 20658, 7, 6, 0, 0, 20658, 20659, 7, 14, 0, 0, 20659, + 20660, 7, 2, 0, 0, 20660, 20661, 7, 13, 0, 0, 20661, 20662, 7, 6, 0, 0, + 20662, 2918, 1, 0, 0, 0, 20663, 20664, 7, 3, 0, 0, 20664, 20665, 7, 6, + 0, 0, 20665, 20666, 7, 7, 0, 0, 20666, 20667, 7, 0, 0, 0, 20667, 20668, + 7, 14, 0, 0, 20668, 20669, 7, 6, 0, 0, 20669, 2920, 1, 0, 0, 0, 20670, + 20671, 7, 3, 0, 0, 20671, 20672, 7, 6, 0, 0, 20672, 20673, 7, 15, 0, 0, + 20673, 20674, 7, 0, 0, 0, 20674, 20675, 7, 12, 0, 0, 20675, 20676, 7, 3, + 0, 0, 20676, 2922, 1, 0, 0, 0, 20677, 20678, 7, 3, 0, 0, 20678, 20679, + 7, 6, 0, 0, 20679, 20680, 7, 15, 0, 0, 20680, 20681, 7, 6, 0, 0, 20681, + 20682, 7, 0, 0, 0, 20682, 20683, 7, 4, 0, 0, 20683, 2924, 1, 0, 0, 0, 20684, + 20685, 7, 3, 0, 0, 20685, 20686, 7, 6, 0, 0, 20686, 20687, 7, 15, 0, 0, + 20687, 20688, 7, 11, 0, 0, 20688, 20689, 7, 0, 0, 0, 20689, 20690, 7, 8, + 0, 0, 20690, 20691, 7, 6, 0, 0, 20691, 2926, 1, 0, 0, 0, 20692, 20693, + 7, 3, 0, 0, 20693, 20694, 7, 6, 0, 0, 20694, 20695, 7, 15, 0, 0, 20695, + 20696, 7, 11, 0, 0, 20696, 20697, 7, 12, 0, 0, 20697, 20698, 7, 8, 0, 0, + 20698, 20699, 7, 0, 0, 0, 20699, 20700, 7, 4, 0, 0, 20700, 20701, 7, 12, + 0, 0, 20701, 20702, 7, 2, 0, 0, 20702, 20703, 7, 7, 0, 0, 20703, 2928, + 1, 0, 0, 0, 20704, 20705, 7, 3, 0, 0, 20705, 20706, 7, 6, 0, 0, 20706, + 20707, 7, 24, 0, 0, 20707, 20708, 7, 10, 0, 0, 20708, 20709, 7, 12, 0, + 0, 20709, 20710, 7, 3, 0, 0, 20710, 20711, 7, 6, 0, 0, 20711, 20712, 7, + 9, 0, 0, 20712, 2930, 1, 0, 0, 0, 20713, 20714, 7, 3, 0, 0, 20714, 20715, + 7, 6, 0, 0, 20715, 20716, 7, 5, 0, 0, 20716, 20717, 7, 6, 0, 0, 20717, + 20718, 7, 4, 0, 0, 20718, 20719, 7, 11, 0, 0, 20719, 20720, 7, 2, 0, 0, + 20720, 20721, 7, 17, 0, 0, 20721, 20722, 7, 5, 0, 0, 20722, 2932, 1, 0, + 0, 0, 20723, 20724, 7, 3, 0, 0, 20724, 20725, 7, 6, 0, 0, 20725, 20726, + 7, 5, 0, 0, 20726, 20727, 7, 6, 0, 0, 20727, 20728, 7, 4, 0, 0, 20728, + 2934, 1, 0, 0, 0, 20729, 20730, 7, 3, 0, 0, 20730, 20731, 7, 6, 0, 0, 20731, + 20732, 7, 5, 0, 0, 20732, 20733, 7, 12, 0, 0, 20733, 20734, 7, 23, 0, 0, + 20734, 20735, 7, 6, 0, 0, 20735, 2936, 1, 0, 0, 0, 20736, 20737, 7, 3, + 0, 0, 20737, 20738, 7, 6, 0, 0, 20738, 20739, 7, 5, 0, 0, 20739, 20740, + 7, 2, 0, 0, 20740, 20741, 7, 11, 0, 0, 20741, 20742, 7, 13, 0, 0, 20742, + 20743, 7, 6, 0, 0, 20743, 2938, 1, 0, 0, 0, 20744, 20745, 7, 3, 0, 0, 20745, + 20746, 7, 6, 0, 0, 20746, 20747, 7, 5, 0, 0, 20747, 20748, 7, 2, 0, 0, + 20748, 20749, 7, 11, 0, 0, 20749, 20750, 7, 13, 0, 0, 20750, 20751, 7, + 6, 0, 0, 20751, 20752, 7, 3, 0, 0, 20752, 2940, 1, 0, 0, 0, 20753, 20754, + 7, 3, 0, 0, 20754, 20755, 7, 6, 0, 0, 20755, 20756, 7, 5, 0, 0, 20756, + 20757, 7, 2, 0, 0, 20757, 20758, 7, 10, 0, 0, 20758, 20759, 7, 3, 0, 0, + 20759, 20760, 7, 8, 0, 0, 20760, 20761, 7, 6, 0, 0, 20761, 2942, 1, 0, + 0, 0, 20762, 20763, 7, 3, 0, 0, 20763, 20764, 7, 6, 0, 0, 20764, 20765, + 7, 5, 0, 0, 20765, 20766, 7, 15, 0, 0, 20766, 20767, 7, 6, 0, 0, 20767, + 20768, 7, 8, 0, 0, 20768, 20769, 7, 4, 0, 0, 20769, 2944, 1, 0, 0, 0, 20770, + 20771, 7, 3, 0, 0, 20771, 20772, 7, 6, 0, 0, 20772, 20773, 7, 5, 0, 0, + 20773, 20774, 7, 4, 0, 0, 20774, 20775, 7, 0, 0, 0, 20775, 20776, 7, 3, + 0, 0, 20776, 20777, 7, 4, 0, 0, 20777, 2946, 1, 0, 0, 0, 20778, 20779, + 7, 3, 0, 0, 20779, 20780, 7, 6, 0, 0, 20780, 20781, 7, 5, 0, 0, 20781, + 20782, 7, 4, 0, 0, 20782, 20783, 7, 2, 0, 0, 20783, 20784, 7, 3, 0, 0, + 20784, 20785, 7, 6, 0, 0, 20785, 20786, 5, 95, 0, 0, 20786, 20787, 7, 0, + 0, 0, 20787, 20788, 7, 5, 0, 0, 20788, 20789, 5, 95, 0, 0, 20789, 20790, + 7, 12, 0, 0, 20790, 20791, 7, 7, 0, 0, 20791, 20792, 7, 4, 0, 0, 20792, + 20793, 7, 6, 0, 0, 20793, 20794, 7, 3, 0, 0, 20794, 20795, 7, 13, 0, 0, + 20795, 20796, 7, 0, 0, 0, 20796, 20797, 7, 11, 0, 0, 20797, 20798, 7, 5, + 0, 0, 20798, 2948, 1, 0, 0, 0, 20799, 20800, 7, 3, 0, 0, 20800, 20801, + 7, 6, 0, 0, 20801, 20802, 7, 5, 0, 0, 20802, 20803, 7, 4, 0, 0, 20803, + 20804, 7, 2, 0, 0, 20804, 20805, 7, 3, 0, 0, 20805, 20806, 7, 6, 0, 0, + 20806, 2950, 1, 0, 0, 0, 20807, 20808, 7, 3, 0, 0, 20808, 20809, 7, 6, + 0, 0, 20809, 20810, 7, 5, 0, 0, 20810, 20811, 7, 4, 0, 0, 20811, 20812, + 7, 3, 0, 0, 20812, 20813, 7, 12, 0, 0, 20813, 20814, 7, 8, 0, 0, 20814, + 20815, 7, 4, 0, 0, 20815, 20816, 5, 95, 0, 0, 20816, 20817, 7, 0, 0, 0, + 20817, 20818, 7, 11, 0, 0, 20818, 20819, 7, 11, 0, 0, 20819, 20820, 5, + 95, 0, 0, 20820, 20821, 7, 3, 0, 0, 20821, 20822, 7, 6, 0, 0, 20822, 20823, + 7, 16, 0, 0, 20823, 20824, 5, 95, 0, 0, 20824, 20825, 7, 8, 0, 0, 20825, + 20826, 7, 2, 0, 0, 20826, 20827, 7, 7, 0, 0, 20827, 20828, 7, 5, 0, 0, + 20828, 2952, 1, 0, 0, 0, 20829, 20830, 7, 3, 0, 0, 20830, 20831, 7, 6, + 0, 0, 20831, 20832, 7, 5, 0, 0, 20832, 20833, 7, 4, 0, 0, 20833, 20834, + 7, 3, 0, 0, 20834, 20835, 7, 12, 0, 0, 20835, 20836, 7, 8, 0, 0, 20836, + 20837, 7, 4, 0, 0, 20837, 20838, 7, 6, 0, 0, 20838, 20839, 7, 9, 0, 0, + 20839, 2954, 1, 0, 0, 0, 20840, 20841, 7, 3, 0, 0, 20841, 20842, 7, 6, + 0, 0, 20842, 20843, 7, 5, 0, 0, 20843, 20844, 7, 4, 0, 0, 20844, 20845, + 7, 3, 0, 0, 20845, 20846, 7, 12, 0, 0, 20846, 20847, 7, 8, 0, 0, 20847, + 20848, 7, 4, 0, 0, 20848, 20849, 5, 95, 0, 0, 20849, 20850, 7, 3, 0, 0, + 20850, 20851, 7, 6, 0, 0, 20851, 20852, 7, 16, 0, 0, 20852, 20853, 7, 6, + 0, 0, 20853, 20854, 7, 3, 0, 0, 20854, 20855, 7, 6, 0, 0, 20855, 20856, + 7, 7, 0, 0, 20856, 20857, 7, 8, 0, 0, 20857, 20858, 7, 6, 0, 0, 20858, + 20859, 7, 5, 0, 0, 20859, 2956, 1, 0, 0, 0, 20860, 20861, 7, 3, 0, 0, 20861, + 20862, 7, 6, 0, 0, 20862, 20863, 7, 5, 0, 0, 20863, 20864, 7, 4, 0, 0, + 20864, 20865, 7, 3, 0, 0, 20865, 20866, 7, 12, 0, 0, 20866, 20867, 7, 8, + 0, 0, 20867, 20868, 7, 4, 0, 0, 20868, 2958, 1, 0, 0, 0, 20869, 20870, + 7, 3, 0, 0, 20870, 20871, 7, 6, 0, 0, 20871, 20872, 7, 5, 0, 0, 20872, + 20873, 7, 10, 0, 0, 20873, 20874, 7, 11, 0, 0, 20874, 20875, 7, 4, 0, 0, + 20875, 20876, 5, 95, 0, 0, 20876, 20877, 7, 8, 0, 0, 20877, 20878, 7, 0, + 0, 0, 20878, 20879, 7, 8, 0, 0, 20879, 20880, 7, 19, 0, 0, 20880, 20881, + 7, 6, 0, 0, 20881, 2960, 1, 0, 0, 0, 20882, 20883, 7, 3, 0, 0, 20883, 20884, + 7, 6, 0, 0, 20884, 20885, 7, 5, 0, 0, 20885, 20886, 7, 10, 0, 0, 20886, + 20887, 7, 11, 0, 0, 20887, 20888, 7, 4, 0, 0, 20888, 2962, 1, 0, 0, 0, + 20889, 20890, 7, 3, 0, 0, 20890, 20891, 7, 6, 0, 0, 20891, 20892, 7, 5, + 0, 0, 20892, 20893, 7, 10, 0, 0, 20893, 20894, 7, 14, 0, 0, 20894, 20895, + 7, 0, 0, 0, 20895, 20896, 7, 1, 0, 0, 20896, 20897, 7, 11, 0, 0, 20897, + 20898, 7, 6, 0, 0, 20898, 2964, 1, 0, 0, 0, 20899, 20900, 7, 3, 0, 0, 20900, + 20901, 7, 6, 0, 0, 20901, 20902, 7, 5, 0, 0, 20902, 20903, 7, 10, 0, 0, + 20903, 20904, 7, 14, 0, 0, 20904, 20905, 7, 6, 0, 0, 20905, 2966, 1, 0, + 0, 0, 20906, 20907, 7, 3, 0, 0, 20907, 20908, 7, 6, 0, 0, 20908, 20909, + 7, 4, 0, 0, 20909, 20910, 7, 6, 0, 0, 20910, 20911, 7, 7, 0, 0, 20911, + 20912, 7, 4, 0, 0, 20912, 20913, 7, 12, 0, 0, 20913, 20914, 7, 2, 0, 0, + 20914, 20915, 7, 7, 0, 0, 20915, 2968, 1, 0, 0, 0, 20916, 20917, 7, 3, + 0, 0, 20917, 20918, 7, 6, 0, 0, 20918, 20919, 7, 4, 0, 0, 20919, 20920, + 7, 3, 0, 0, 20920, 20921, 7, 18, 0, 0, 20921, 20922, 5, 95, 0, 0, 20922, + 20923, 7, 2, 0, 0, 20923, 20924, 7, 7, 0, 0, 20924, 20925, 5, 95, 0, 0, + 20925, 20926, 7, 3, 0, 0, 20926, 20927, 7, 2, 0, 0, 20927, 20928, 7, 22, + 0, 0, 20928, 20929, 5, 95, 0, 0, 20929, 20930, 7, 8, 0, 0, 20930, 20931, + 7, 19, 0, 0, 20931, 20932, 7, 0, 0, 0, 20932, 20933, 7, 7, 0, 0, 20933, + 20934, 7, 17, 0, 0, 20934, 20935, 7, 6, 0, 0, 20935, 2970, 1, 0, 0, 0, + 20936, 20937, 7, 3, 0, 0, 20937, 20938, 7, 6, 0, 0, 20938, 20939, 7, 4, + 0, 0, 20939, 20940, 7, 10, 0, 0, 20940, 20941, 7, 3, 0, 0, 20941, 20942, + 7, 7, 0, 0, 20942, 20943, 7, 12, 0, 0, 20943, 20944, 7, 7, 0, 0, 20944, + 20945, 7, 17, 0, 0, 20945, 2972, 1, 0, 0, 0, 20946, 20947, 7, 3, 0, 0, + 20947, 20948, 7, 6, 0, 0, 20948, 20949, 7, 4, 0, 0, 20949, 20950, 7, 10, + 0, 0, 20950, 20951, 7, 3, 0, 0, 20951, 20952, 7, 7, 0, 0, 20952, 2974, + 1, 0, 0, 0, 20953, 20954, 7, 3, 0, 0, 20954, 20955, 7, 6, 0, 0, 20955, + 20956, 7, 10, 0, 0, 20956, 20957, 7, 5, 0, 0, 20957, 20958, 7, 6, 0, 0, + 20958, 2976, 1, 0, 0, 0, 20959, 20960, 7, 3, 0, 0, 20960, 20961, 7, 6, + 0, 0, 20961, 20962, 7, 13, 0, 0, 20962, 20963, 7, 6, 0, 0, 20963, 20964, + 7, 3, 0, 0, 20964, 20965, 7, 5, 0, 0, 20965, 20966, 7, 6, 0, 0, 20966, + 2978, 1, 0, 0, 0, 20967, 20968, 7, 3, 0, 0, 20968, 20969, 7, 6, 0, 0, 20969, + 20970, 7, 13, 0, 0, 20970, 20971, 7, 2, 0, 0, 20971, 20972, 7, 21, 0, 0, + 20972, 20973, 7, 6, 0, 0, 20973, 2980, 1, 0, 0, 0, 20974, 20975, 7, 3, + 0, 0, 20975, 20976, 7, 6, 0, 0, 20976, 20977, 7, 22, 0, 0, 20977, 20978, + 7, 3, 0, 0, 20978, 20979, 7, 12, 0, 0, 20979, 20980, 7, 4, 0, 0, 20980, + 20981, 7, 6, 0, 0, 20981, 20982, 5, 95, 0, 0, 20982, 20983, 7, 2, 0, 0, + 20983, 20984, 7, 3, 0, 0, 20984, 20985, 5, 95, 0, 0, 20985, 20986, 7, 6, + 0, 0, 20986, 20987, 7, 3, 0, 0, 20987, 20988, 7, 3, 0, 0, 20988, 20989, + 7, 2, 0, 0, 20989, 20990, 7, 3, 0, 0, 20990, 2982, 1, 0, 0, 0, 20991, 20992, + 7, 3, 0, 0, 20992, 20993, 7, 6, 0, 0, 20993, 20994, 7, 22, 0, 0, 20994, + 20995, 7, 3, 0, 0, 20995, 20996, 7, 12, 0, 0, 20996, 20997, 7, 4, 0, 0, + 20997, 20998, 7, 6, 0, 0, 20998, 2984, 1, 0, 0, 0, 20999, 21000, 7, 3, + 0, 0, 21000, 21001, 7, 12, 0, 0, 21001, 21002, 7, 17, 0, 0, 21002, 21003, + 7, 19, 0, 0, 21003, 21004, 7, 4, 0, 0, 21004, 2986, 1, 0, 0, 0, 21005, + 21006, 7, 3, 0, 0, 21006, 21007, 7, 2, 0, 0, 21007, 21008, 7, 11, 0, 0, + 21008, 21009, 7, 6, 0, 0, 21009, 2988, 1, 0, 0, 0, 21010, 21011, 7, 3, + 0, 0, 21011, 21012, 7, 2, 0, 0, 21012, 21013, 7, 11, 0, 0, 21013, 21014, + 7, 6, 0, 0, 21014, 21015, 7, 5, 0, 0, 21015, 21016, 7, 6, 0, 0, 21016, + 21017, 7, 4, 0, 0, 21017, 2990, 1, 0, 0, 0, 21018, 21019, 7, 3, 0, 0, 21019, + 21020, 7, 2, 0, 0, 21020, 21021, 7, 11, 0, 0, 21021, 21022, 7, 6, 0, 0, + 21022, 21023, 7, 5, 0, 0, 21023, 2992, 1, 0, 0, 0, 21024, 21025, 7, 3, + 0, 0, 21025, 21026, 7, 2, 0, 0, 21026, 21027, 7, 11, 0, 0, 21027, 21028, + 7, 11, 0, 0, 21028, 21029, 7, 1, 0, 0, 21029, 21030, 7, 0, 0, 0, 21030, + 21031, 7, 8, 0, 0, 21031, 21032, 7, 21, 0, 0, 21032, 2994, 1, 0, 0, 0, + 21033, 21034, 7, 3, 0, 0, 21034, 21035, 7, 2, 0, 0, 21035, 21036, 7, 11, + 0, 0, 21036, 21037, 7, 11, 0, 0, 21037, 21038, 7, 12, 0, 0, 21038, 21039, + 7, 7, 0, 0, 21039, 21040, 7, 17, 0, 0, 21040, 2996, 1, 0, 0, 0, 21041, + 21042, 7, 3, 0, 0, 21042, 21043, 7, 2, 0, 0, 21043, 21044, 7, 11, 0, 0, + 21044, 21045, 7, 11, 0, 0, 21045, 21046, 7, 10, 0, 0, 21046, 21047, 7, + 15, 0, 0, 21047, 2998, 1, 0, 0, 0, 21048, 21049, 7, 3, 0, 0, 21049, 21050, + 7, 2, 0, 0, 21050, 21051, 7, 22, 0, 0, 21051, 21052, 7, 9, 0, 0, 21052, + 21053, 7, 6, 0, 0, 21053, 21054, 7, 15, 0, 0, 21054, 21055, 7, 6, 0, 0, + 21055, 21056, 7, 7, 0, 0, 21056, 21057, 7, 9, 0, 0, 21057, 21058, 7, 6, + 0, 0, 21058, 21059, 7, 7, 0, 0, 21059, 21060, 7, 8, 0, 0, 21060, 21061, + 7, 12, 0, 0, 21061, 21062, 7, 6, 0, 0, 21062, 21063, 7, 5, 0, 0, 21063, + 3000, 1, 0, 0, 0, 21064, 21065, 7, 3, 0, 0, 21065, 21066, 7, 2, 0, 0, 21066, + 21067, 7, 22, 0, 0, 21067, 21068, 7, 12, 0, 0, 21068, 21069, 7, 9, 0, 0, + 21069, 21070, 5, 95, 0, 0, 21070, 21071, 7, 14, 0, 0, 21071, 21072, 7, + 0, 0, 0, 21072, 21073, 7, 15, 0, 0, 21073, 21074, 7, 15, 0, 0, 21074, 21075, + 7, 12, 0, 0, 21075, 21076, 7, 7, 0, 0, 21076, 21077, 7, 17, 0, 0, 21077, + 21078, 5, 95, 0, 0, 21078, 21079, 7, 4, 0, 0, 21079, 21080, 7, 0, 0, 0, + 21080, 21081, 7, 1, 0, 0, 21081, 21082, 7, 11, 0, 0, 21082, 21083, 7, 6, + 0, 0, 21083, 3002, 1, 0, 0, 0, 21084, 21085, 7, 3, 0, 0, 21085, 21086, + 7, 2, 0, 0, 21086, 21087, 7, 22, 0, 0, 21087, 21088, 7, 12, 0, 0, 21088, + 21089, 7, 9, 0, 0, 21089, 3004, 1, 0, 0, 0, 21090, 21091, 7, 3, 0, 0, 21091, + 21092, 7, 2, 0, 0, 21092, 21093, 7, 22, 0, 0, 21093, 21094, 7, 12, 0, 0, + 21094, 21095, 7, 9, 0, 0, 21095, 21096, 7, 4, 0, 0, 21096, 21097, 7, 2, + 0, 0, 21097, 21098, 7, 8, 0, 0, 21098, 21099, 7, 19, 0, 0, 21099, 21100, + 7, 0, 0, 0, 21100, 21101, 7, 3, 0, 0, 21101, 3006, 1, 0, 0, 0, 21102, 21103, + 7, 3, 0, 0, 21103, 21104, 7, 2, 0, 0, 21104, 21105, 7, 22, 0, 0, 21105, + 21106, 7, 12, 0, 0, 21106, 21107, 7, 9, 0, 0, 21107, 21108, 7, 4, 0, 0, + 21108, 21109, 7, 2, 0, 0, 21109, 21110, 7, 7, 0, 0, 21110, 21111, 7, 8, + 0, 0, 21111, 21112, 7, 19, 0, 0, 21112, 21113, 7, 0, 0, 0, 21113, 21114, + 7, 3, 0, 0, 21114, 3008, 1, 0, 0, 0, 21115, 21116, 7, 3, 0, 0, 21116, 21117, + 7, 2, 0, 0, 21117, 21118, 7, 22, 0, 0, 21118, 21119, 5, 95, 0, 0, 21119, + 21120, 7, 11, 0, 0, 21120, 21121, 7, 6, 0, 0, 21121, 21122, 7, 7, 0, 0, + 21122, 21123, 7, 17, 0, 0, 21123, 21124, 7, 4, 0, 0, 21124, 21125, 7, 19, + 0, 0, 21125, 3010, 1, 0, 0, 0, 21126, 21127, 7, 3, 0, 0, 21127, 21128, + 7, 2, 0, 0, 21128, 21129, 7, 22, 0, 0, 21129, 21130, 7, 7, 0, 0, 21130, + 21131, 7, 10, 0, 0, 21131, 21132, 7, 14, 0, 0, 21132, 3012, 1, 0, 0, 0, + 21133, 21134, 7, 3, 0, 0, 21134, 21135, 7, 2, 0, 0, 21135, 21136, 7, 22, + 0, 0, 21136, 3014, 1, 0, 0, 0, 21137, 21138, 7, 3, 0, 0, 21138, 21139, + 7, 2, 0, 0, 21139, 21140, 7, 22, 0, 0, 21140, 21141, 7, 5, 0, 0, 21141, + 3016, 1, 0, 0, 0, 21142, 21143, 7, 3, 0, 0, 21143, 21144, 7, 15, 0, 0, + 21144, 21145, 7, 0, 0, 0, 21145, 21146, 7, 9, 0, 0, 21146, 3018, 1, 0, + 0, 0, 21147, 21148, 7, 3, 0, 0, 21148, 21149, 7, 4, 0, 0, 21149, 21150, + 7, 3, 0, 0, 21150, 21151, 7, 12, 0, 0, 21151, 21152, 7, 14, 0, 0, 21152, + 3020, 1, 0, 0, 0, 21153, 21154, 7, 3, 0, 0, 21154, 21155, 7, 10, 0, 0, + 21155, 21156, 7, 11, 0, 0, 21156, 21157, 7, 6, 0, 0, 21157, 3022, 1, 0, + 0, 0, 21158, 21159, 7, 3, 0, 0, 21159, 21160, 7, 10, 0, 0, 21160, 21161, + 7, 11, 0, 0, 21161, 21162, 7, 6, 0, 0, 21162, 21163, 7, 5, 0, 0, 21163, + 3024, 1, 0, 0, 0, 21164, 21165, 7, 3, 0, 0, 21165, 21166, 7, 10, 0, 0, + 21166, 21167, 7, 7, 0, 0, 21167, 21168, 7, 7, 0, 0, 21168, 21169, 7, 12, + 0, 0, 21169, 21170, 7, 7, 0, 0, 21170, 21171, 7, 17, 0, 0, 21171, 3026, + 1, 0, 0, 0, 21172, 21173, 7, 5, 0, 0, 21173, 21174, 7, 0, 0, 0, 21174, + 21175, 7, 11, 0, 0, 21175, 21176, 7, 4, 0, 0, 21176, 3028, 1, 0, 0, 0, + 21177, 21178, 7, 5, 0, 0, 21178, 21179, 7, 0, 0, 0, 21179, 21180, 7, 14, + 0, 0, 21180, 21181, 7, 15, 0, 0, 21181, 21182, 7, 11, 0, 0, 21182, 21183, + 7, 6, 0, 0, 21183, 3030, 1, 0, 0, 0, 21184, 21185, 7, 5, 0, 0, 21185, 21186, + 7, 0, 0, 0, 21186, 21187, 7, 13, 0, 0, 21187, 21188, 7, 6, 0, 0, 21188, + 21189, 5, 95, 0, 0, 21189, 21190, 7, 0, 0, 0, 21190, 21191, 7, 5, 0, 0, + 21191, 21192, 5, 95, 0, 0, 21192, 21193, 7, 12, 0, 0, 21193, 21194, 7, + 7, 0, 0, 21194, 21195, 7, 4, 0, 0, 21195, 21196, 7, 6, 0, 0, 21196, 21197, + 7, 3, 0, 0, 21197, 21198, 7, 13, 0, 0, 21198, 21199, 7, 0, 0, 0, 21199, + 21200, 7, 11, 0, 0, 21200, 21201, 7, 5, 0, 0, 21201, 3032, 1, 0, 0, 0, + 21202, 21203, 7, 5, 0, 0, 21203, 21204, 7, 0, 0, 0, 21204, 21205, 7, 13, + 0, 0, 21205, 21206, 7, 6, 0, 0, 21206, 21207, 7, 15, 0, 0, 21207, 21208, + 7, 2, 0, 0, 21208, 21209, 7, 12, 0, 0, 21209, 21210, 7, 7, 0, 0, 21210, + 21211, 7, 4, 0, 0, 21211, 3034, 1, 0, 0, 0, 21212, 21213, 7, 5, 0, 0, 21213, + 21214, 7, 0, 0, 0, 21214, 21215, 7, 13, 0, 0, 21215, 21216, 7, 6, 0, 0, + 21216, 3036, 1, 0, 0, 0, 21217, 21218, 7, 5, 0, 0, 21218, 21219, 7, 1, + 0, 0, 21219, 21220, 5, 52, 0, 0, 21220, 3038, 1, 0, 0, 0, 21221, 21222, + 7, 5, 0, 0, 21222, 21223, 7, 8, 0, 0, 21223, 21224, 7, 0, 0, 0, 21224, + 21225, 7, 11, 0, 0, 21225, 21226, 7, 6, 0, 0, 21226, 21227, 5, 95, 0, 0, + 21227, 21228, 7, 3, 0, 0, 21228, 21229, 7, 2, 0, 0, 21229, 21230, 7, 22, + 0, 0, 21230, 21231, 7, 5, 0, 0, 21231, 3040, 1, 0, 0, 0, 21232, 21233, + 7, 5, 0, 0, 21233, 21234, 7, 8, 0, 0, 21234, 21235, 7, 0, 0, 0, 21235, + 21236, 7, 11, 0, 0, 21236, 21237, 7, 6, 0, 0, 21237, 3042, 1, 0, 0, 0, + 21238, 21239, 7, 5, 0, 0, 21239, 21240, 7, 8, 0, 0, 21240, 21241, 7, 0, + 0, 0, 21241, 21242, 7, 7, 0, 0, 21242, 21243, 5, 95, 0, 0, 21243, 21244, + 7, 12, 0, 0, 21244, 21245, 7, 7, 0, 0, 21245, 21246, 7, 5, 0, 0, 21246, + 21247, 7, 4, 0, 0, 21247, 21248, 7, 0, 0, 0, 21248, 21249, 7, 7, 0, 0, + 21249, 21250, 7, 8, 0, 0, 21250, 21251, 7, 6, 0, 0, 21251, 21252, 7, 5, + 0, 0, 21252, 3044, 1, 0, 0, 0, 21253, 21254, 7, 5, 0, 0, 21254, 21255, + 7, 8, 0, 0, 21255, 21256, 7, 0, 0, 0, 21256, 21257, 7, 7, 0, 0, 21257, + 3046, 1, 0, 0, 0, 21258, 21259, 7, 5, 0, 0, 21259, 21260, 7, 8, 0, 0, 21260, + 21261, 7, 19, 0, 0, 21261, 21262, 7, 6, 0, 0, 21262, 21263, 7, 9, 0, 0, + 21263, 21264, 7, 10, 0, 0, 21264, 21265, 7, 11, 0, 0, 21265, 21266, 7, + 6, 0, 0, 21266, 21267, 7, 3, 0, 0, 21267, 3048, 1, 0, 0, 0, 21268, 21269, + 7, 5, 0, 0, 21269, 21270, 7, 8, 0, 0, 21270, 21271, 7, 19, 0, 0, 21271, + 21272, 7, 6, 0, 0, 21272, 21273, 7, 14, 0, 0, 21273, 21274, 7, 0, 0, 0, + 21274, 21275, 7, 8, 0, 0, 21275, 21276, 7, 19, 0, 0, 21276, 21277, 7, 6, + 0, 0, 21277, 21278, 7, 8, 0, 0, 21278, 21279, 7, 21, 0, 0, 21279, 3050, + 1, 0, 0, 0, 21280, 21281, 7, 5, 0, 0, 21281, 21282, 7, 8, 0, 0, 21282, + 21283, 7, 19, 0, 0, 21283, 21284, 7, 6, 0, 0, 21284, 21285, 7, 14, 0, 0, + 21285, 21286, 7, 0, 0, 0, 21286, 3052, 1, 0, 0, 0, 21287, 21288, 7, 5, + 0, 0, 21288, 21289, 7, 8, 0, 0, 21289, 21290, 7, 7, 0, 0, 21290, 21291, + 5, 95, 0, 0, 21291, 21292, 7, 0, 0, 0, 21292, 21293, 7, 5, 0, 0, 21293, + 21294, 7, 8, 0, 0, 21294, 21295, 7, 6, 0, 0, 21295, 21296, 7, 7, 0, 0, + 21296, 21297, 7, 9, 0, 0, 21297, 21298, 7, 12, 0, 0, 21298, 21299, 7, 7, + 0, 0, 21299, 21300, 7, 17, 0, 0, 21300, 3054, 1, 0, 0, 0, 21301, 21302, + 7, 5, 0, 0, 21302, 21303, 7, 8, 0, 0, 21303, 21304, 7, 7, 0, 0, 21304, + 3056, 1, 0, 0, 0, 21305, 21306, 7, 5, 0, 0, 21306, 21307, 7, 8, 0, 0, 21307, + 21308, 7, 2, 0, 0, 21308, 21309, 7, 15, 0, 0, 21309, 21310, 7, 6, 0, 0, + 21310, 3058, 1, 0, 0, 0, 21311, 21312, 7, 5, 0, 0, 21312, 21313, 7, 8, + 0, 0, 21313, 21314, 7, 3, 0, 0, 21314, 21315, 7, 10, 0, 0, 21315, 21316, + 7, 1, 0, 0, 21316, 3060, 1, 0, 0, 0, 21317, 21318, 7, 5, 0, 0, 21318, 21319, + 7, 9, 0, 0, 21319, 21320, 5, 95, 0, 0, 21320, 21321, 7, 0, 0, 0, 21321, + 21322, 7, 11, 0, 0, 21322, 21323, 7, 11, 0, 0, 21323, 3062, 1, 0, 0, 0, + 21324, 21325, 7, 5, 0, 0, 21325, 21326, 7, 9, 0, 0, 21326, 21327, 5, 95, + 0, 0, 21327, 21328, 7, 12, 0, 0, 21328, 21329, 7, 7, 0, 0, 21329, 21330, + 7, 19, 0, 0, 21330, 21331, 7, 12, 0, 0, 21331, 21332, 7, 1, 0, 0, 21332, + 21333, 7, 12, 0, 0, 21333, 21334, 7, 4, 0, 0, 21334, 3064, 1, 0, 0, 0, + 21335, 21336, 7, 5, 0, 0, 21336, 21337, 7, 9, 0, 0, 21337, 21338, 7, 2, + 0, 0, 21338, 21339, 5, 95, 0, 0, 21339, 21340, 7, 17, 0, 0, 21340, 21341, + 7, 6, 0, 0, 21341, 21342, 7, 2, 0, 0, 21342, 21343, 7, 14, 0, 0, 21343, + 21344, 5, 95, 0, 0, 21344, 21345, 7, 14, 0, 0, 21345, 21346, 7, 1, 0, 0, + 21346, 21347, 7, 3, 0, 0, 21347, 3066, 1, 0, 0, 0, 21348, 21349, 7, 5, + 0, 0, 21349, 21350, 7, 9, 0, 0, 21350, 21351, 7, 2, 0, 0, 21351, 21352, + 5, 95, 0, 0, 21352, 21353, 7, 17, 0, 0, 21353, 21354, 7, 6, 0, 0, 21354, + 21355, 7, 2, 0, 0, 21355, 21356, 7, 14, 0, 0, 21356, 21357, 7, 6, 0, 0, + 21357, 21358, 7, 4, 0, 0, 21358, 21359, 7, 3, 0, 0, 21359, 21360, 7, 18, + 0, 0, 21360, 3068, 1, 0, 0, 0, 21361, 21362, 7, 5, 0, 0, 21362, 21363, + 7, 9, 0, 0, 21363, 21364, 5, 95, 0, 0, 21364, 21365, 7, 5, 0, 0, 21365, + 21366, 7, 19, 0, 0, 21366, 21367, 7, 2, 0, 0, 21367, 21368, 7, 22, 0, 0, + 21368, 3070, 1, 0, 0, 0, 21369, 21370, 7, 5, 0, 0, 21370, 21371, 7, 6, + 0, 0, 21371, 21372, 7, 0, 0, 0, 21372, 21373, 7, 3, 0, 0, 21373, 21374, + 7, 8, 0, 0, 21374, 21375, 7, 19, 0, 0, 21375, 3072, 1, 0, 0, 0, 21376, + 21377, 7, 5, 0, 0, 21377, 21378, 7, 6, 0, 0, 21378, 21379, 7, 8, 0, 0, + 21379, 21380, 7, 2, 0, 0, 21380, 21381, 7, 7, 0, 0, 21381, 21382, 7, 9, + 0, 0, 21382, 3074, 1, 0, 0, 0, 21383, 21384, 7, 5, 0, 0, 21384, 21385, + 7, 6, 0, 0, 21385, 21386, 7, 8, 0, 0, 21386, 21387, 7, 2, 0, 0, 21387, + 21388, 7, 7, 0, 0, 21388, 21389, 7, 9, 0, 0, 21389, 21390, 7, 5, 0, 0, + 21390, 3076, 1, 0, 0, 0, 21391, 21392, 7, 5, 0, 0, 21392, 21393, 7, 6, + 0, 0, 21393, 21394, 7, 8, 0, 0, 21394, 21395, 7, 3, 0, 0, 21395, 21396, + 7, 6, 0, 0, 21396, 21397, 7, 4, 0, 0, 21397, 3078, 1, 0, 0, 0, 21398, 21399, + 7, 5, 0, 0, 21399, 21400, 7, 6, 0, 0, 21400, 21401, 7, 8, 0, 0, 21401, + 21402, 7, 10, 0, 0, 21402, 21403, 7, 3, 0, 0, 21403, 21404, 7, 6, 0, 0, + 21404, 21405, 7, 16, 0, 0, 21405, 21406, 7, 12, 0, 0, 21406, 21407, 7, + 11, 0, 0, 21407, 21408, 7, 6, 0, 0, 21408, 21409, 5, 95, 0, 0, 21409, 21410, + 7, 9, 0, 0, 21410, 21411, 7, 1, 0, 0, 21411, 21412, 7, 0, 0, 0, 21412, + 3080, 1, 0, 0, 0, 21413, 21414, 7, 5, 0, 0, 21414, 21415, 7, 6, 0, 0, 21415, + 21416, 7, 8, 0, 0, 21416, 21417, 7, 10, 0, 0, 21417, 21418, 7, 3, 0, 0, + 21418, 21419, 7, 6, 0, 0, 21419, 21420, 7, 16, 0, 0, 21420, 21421, 7, 12, + 0, 0, 21421, 21422, 7, 11, 0, 0, 21422, 21423, 7, 6, 0, 0, 21423, 3082, + 1, 0, 0, 0, 21424, 21425, 7, 5, 0, 0, 21425, 21426, 7, 6, 0, 0, 21426, + 21427, 7, 8, 0, 0, 21427, 21428, 7, 10, 0, 0, 21428, 21429, 7, 3, 0, 0, + 21429, 21430, 7, 12, 0, 0, 21430, 21431, 7, 4, 0, 0, 21431, 21432, 7, 18, + 0, 0, 21432, 3084, 1, 0, 0, 0, 21433, 21434, 7, 5, 0, 0, 21434, 21435, + 7, 6, 0, 0, 21435, 21436, 7, 6, 0, 0, 21436, 21437, 7, 9, 0, 0, 21437, + 3086, 1, 0, 0, 0, 21438, 21439, 7, 5, 0, 0, 21439, 21440, 7, 6, 0, 0, 21440, + 21441, 7, 17, 0, 0, 21441, 21442, 5, 95, 0, 0, 21442, 21443, 7, 1, 0, 0, + 21443, 21444, 7, 11, 0, 0, 21444, 21445, 7, 2, 0, 0, 21445, 21446, 7, 8, + 0, 0, 21446, 21447, 7, 21, 0, 0, 21447, 3088, 1, 0, 0, 0, 21448, 21449, + 7, 5, 0, 0, 21449, 21450, 7, 6, 0, 0, 21450, 21451, 7, 17, 0, 0, 21451, + 21452, 5, 95, 0, 0, 21452, 21453, 7, 16, 0, 0, 21453, 21454, 7, 12, 0, + 0, 21454, 21455, 7, 11, 0, 0, 21455, 21456, 7, 6, 0, 0, 21456, 3090, 1, + 0, 0, 0, 21457, 21458, 7, 5, 0, 0, 21458, 21459, 7, 6, 0, 0, 21459, 21460, + 7, 17, 0, 0, 21460, 21461, 7, 14, 0, 0, 21461, 21462, 7, 6, 0, 0, 21462, + 21463, 7, 7, 0, 0, 21463, 21464, 7, 4, 0, 0, 21464, 3092, 1, 0, 0, 0, 21465, + 21466, 7, 5, 0, 0, 21466, 21467, 7, 6, 0, 0, 21467, 21468, 7, 11, 0, 0, + 21468, 21469, 7, 6, 0, 0, 21469, 21470, 7, 8, 0, 0, 21470, 21471, 7, 4, + 0, 0, 21471, 21472, 7, 12, 0, 0, 21472, 21473, 7, 13, 0, 0, 21473, 21474, + 7, 12, 0, 0, 21474, 21475, 7, 4, 0, 0, 21475, 21476, 7, 18, 0, 0, 21476, + 3094, 1, 0, 0, 0, 21477, 21478, 7, 5, 0, 0, 21478, 21479, 7, 6, 0, 0, 21479, + 21480, 7, 11, 0, 0, 21480, 21481, 7, 6, 0, 0, 21481, 21482, 7, 8, 0, 0, + 21482, 21483, 7, 4, 0, 0, 21483, 3096, 1, 0, 0, 0, 21484, 21485, 7, 5, + 0, 0, 21485, 21486, 7, 6, 0, 0, 21486, 21487, 7, 11, 0, 0, 21487, 21488, + 7, 16, 0, 0, 21488, 3098, 1, 0, 0, 0, 21489, 21490, 7, 5, 0, 0, 21490, + 21491, 7, 6, 0, 0, 21491, 21492, 7, 14, 0, 0, 21492, 21493, 7, 12, 0, 0, + 21493, 21494, 7, 20, 0, 0, 21494, 21495, 7, 2, 0, 0, 21495, 21496, 7, 12, + 0, 0, 21496, 21497, 7, 7, 0, 0, 21497, 21498, 5, 95, 0, 0, 21498, 21499, + 7, 9, 0, 0, 21499, 21500, 7, 3, 0, 0, 21500, 21501, 7, 12, 0, 0, 21501, + 21502, 7, 13, 0, 0, 21502, 21503, 7, 6, 0, 0, 21503, 21504, 7, 3, 0, 0, + 21504, 3100, 1, 0, 0, 0, 21505, 21506, 7, 5, 0, 0, 21506, 21507, 7, 6, + 0, 0, 21507, 21508, 7, 14, 0, 0, 21508, 21509, 7, 12, 0, 0, 21509, 21510, + 7, 20, 0, 0, 21510, 21511, 7, 2, 0, 0, 21511, 21512, 7, 12, 0, 0, 21512, + 21513, 7, 7, 0, 0, 21513, 3102, 1, 0, 0, 0, 21514, 21515, 7, 5, 0, 0, 21515, + 21516, 7, 6, 0, 0, 21516, 21517, 7, 14, 0, 0, 21517, 21518, 7, 12, 0, 0, + 21518, 21519, 5, 95, 0, 0, 21519, 21520, 7, 4, 0, 0, 21520, 21521, 7, 2, + 0, 0, 21521, 21522, 5, 95, 0, 0, 21522, 21523, 7, 12, 0, 0, 21523, 21524, + 7, 7, 0, 0, 21524, 21525, 7, 7, 0, 0, 21525, 21526, 7, 6, 0, 0, 21526, + 21527, 7, 3, 0, 0, 21527, 3104, 1, 0, 0, 0, 21528, 21529, 7, 5, 0, 0, 21529, + 21530, 7, 6, 0, 0, 21530, 21531, 7, 24, 0, 0, 21531, 21532, 7, 10, 0, 0, + 21532, 21533, 7, 6, 0, 0, 21533, 21534, 7, 7, 0, 0, 21534, 21535, 7, 8, + 0, 0, 21535, 21536, 7, 6, 0, 0, 21536, 21537, 7, 9, 0, 0, 21537, 3106, + 1, 0, 0, 0, 21538, 21539, 7, 5, 0, 0, 21539, 21540, 7, 6, 0, 0, 21540, + 21541, 7, 24, 0, 0, 21541, 21542, 7, 10, 0, 0, 21542, 21543, 7, 6, 0, 0, + 21543, 21544, 7, 7, 0, 0, 21544, 21545, 7, 8, 0, 0, 21545, 21546, 7, 6, + 0, 0, 21546, 3108, 1, 0, 0, 0, 21547, 21548, 7, 5, 0, 0, 21548, 21549, + 7, 6, 0, 0, 21549, 21550, 7, 24, 0, 0, 21550, 21551, 7, 10, 0, 0, 21551, + 21552, 7, 6, 0, 0, 21552, 21553, 7, 7, 0, 0, 21553, 21554, 7, 4, 0, 0, + 21554, 21555, 7, 12, 0, 0, 21555, 21556, 7, 0, 0, 0, 21556, 21557, 7, 11, + 0, 0, 21557, 3110, 1, 0, 0, 0, 21558, 21559, 7, 5, 0, 0, 21559, 21560, + 7, 6, 0, 0, 21560, 21561, 7, 3, 0, 0, 21561, 21562, 7, 12, 0, 0, 21562, + 21563, 7, 0, 0, 0, 21563, 21564, 7, 11, 0, 0, 21564, 21565, 7, 12, 0, 0, + 21565, 21566, 7, 23, 0, 0, 21566, 21567, 7, 0, 0, 0, 21567, 21568, 7, 1, + 0, 0, 21568, 21569, 7, 11, 0, 0, 21569, 21570, 7, 6, 0, 0, 21570, 3112, + 1, 0, 0, 0, 21571, 21572, 7, 5, 0, 0, 21572, 21573, 7, 6, 0, 0, 21573, + 21574, 7, 3, 0, 0, 21574, 21575, 7, 12, 0, 0, 21575, 21576, 7, 0, 0, 0, + 21576, 21577, 7, 11, 0, 0, 21577, 21578, 7, 11, 0, 0, 21578, 21579, 7, + 18, 0, 0, 21579, 21580, 5, 95, 0, 0, 21580, 21581, 7, 3, 0, 0, 21581, 21582, + 7, 6, 0, 0, 21582, 21583, 7, 10, 0, 0, 21583, 21584, 7, 5, 0, 0, 21584, + 21585, 7, 0, 0, 0, 21585, 21586, 7, 1, 0, 0, 21586, 21587, 7, 11, 0, 0, + 21587, 21588, 7, 6, 0, 0, 21588, 3114, 1, 0, 0, 0, 21589, 21590, 7, 5, + 0, 0, 21590, 21591, 7, 6, 0, 0, 21591, 21592, 7, 3, 0, 0, 21592, 21593, + 7, 12, 0, 0, 21593, 21594, 7, 0, 0, 0, 21594, 21595, 7, 11, 0, 0, 21595, + 3116, 1, 0, 0, 0, 21596, 21597, 7, 5, 0, 0, 21597, 21598, 7, 6, 0, 0, 21598, + 21599, 7, 3, 0, 0, 21599, 21600, 7, 13, 0, 0, 21600, 21601, 7, 6, 0, 0, + 21601, 21602, 7, 3, 0, 0, 21602, 21603, 7, 6, 0, 0, 21603, 21604, 7, 3, + 0, 0, 21604, 21605, 7, 3, 0, 0, 21605, 21606, 7, 2, 0, 0, 21606, 21607, + 7, 3, 0, 0, 21607, 3118, 1, 0, 0, 0, 21608, 21609, 7, 5, 0, 0, 21609, 21610, + 7, 6, 0, 0, 21610, 21611, 7, 3, 0, 0, 21611, 21612, 7, 13, 0, 0, 21612, + 21613, 7, 12, 0, 0, 21613, 21614, 7, 8, 0, 0, 21614, 21615, 7, 6, 0, 0, + 21615, 21616, 5, 95, 0, 0, 21616, 21617, 7, 7, 0, 0, 21617, 21618, 7, 0, + 0, 0, 21618, 21619, 7, 14, 0, 0, 21619, 21620, 7, 6, 0, 0, 21620, 21621, + 5, 95, 0, 0, 21621, 21622, 7, 8, 0, 0, 21622, 21623, 7, 2, 0, 0, 21623, + 21624, 7, 7, 0, 0, 21624, 21625, 7, 13, 0, 0, 21625, 21626, 7, 6, 0, 0, + 21626, 21627, 7, 3, 0, 0, 21627, 21628, 7, 4, 0, 0, 21628, 3120, 1, 0, + 0, 0, 21629, 21630, 7, 5, 0, 0, 21630, 21631, 7, 6, 0, 0, 21631, 21632, + 7, 3, 0, 0, 21632, 21633, 7, 13, 0, 0, 21633, 21634, 7, 12, 0, 0, 21634, + 21635, 7, 8, 0, 0, 21635, 21636, 7, 6, 0, 0, 21636, 3122, 1, 0, 0, 0, 21637, + 21638, 7, 5, 0, 0, 21638, 21639, 7, 6, 0, 0, 21639, 21640, 7, 3, 0, 0, + 21640, 21641, 7, 13, 0, 0, 21641, 21642, 7, 12, 0, 0, 21642, 21643, 7, + 8, 0, 0, 21643, 21644, 7, 6, 0, 0, 21644, 21645, 7, 5, 0, 0, 21645, 3124, + 1, 0, 0, 0, 21646, 21647, 7, 5, 0, 0, 21647, 21648, 7, 6, 0, 0, 21648, + 21649, 7, 5, 0, 0, 21649, 21650, 7, 5, 0, 0, 21650, 21651, 7, 12, 0, 0, + 21651, 21652, 7, 2, 0, 0, 21652, 21653, 7, 7, 0, 0, 21653, 21654, 5, 95, + 0, 0, 21654, 21655, 7, 8, 0, 0, 21655, 21656, 7, 0, 0, 0, 21656, 21657, + 7, 8, 0, 0, 21657, 21658, 7, 19, 0, 0, 21658, 21659, 7, 6, 0, 0, 21659, + 21660, 7, 9, 0, 0, 21660, 21661, 5, 95, 0, 0, 21661, 21662, 7, 8, 0, 0, + 21662, 21663, 7, 10, 0, 0, 21663, 21664, 7, 3, 0, 0, 21664, 21665, 7, 5, + 0, 0, 21665, 21666, 7, 2, 0, 0, 21666, 21667, 7, 3, 0, 0, 21667, 21668, + 7, 5, 0, 0, 21668, 3126, 1, 0, 0, 0, 21669, 21670, 7, 5, 0, 0, 21670, 21671, + 7, 6, 0, 0, 21671, 21672, 7, 5, 0, 0, 21672, 21673, 7, 5, 0, 0, 21673, + 21674, 7, 12, 0, 0, 21674, 21675, 7, 2, 0, 0, 21675, 21676, 7, 7, 0, 0, + 21676, 3128, 1, 0, 0, 0, 21677, 21678, 7, 5, 0, 0, 21678, 21679, 7, 6, + 0, 0, 21679, 21680, 7, 5, 0, 0, 21680, 21681, 7, 5, 0, 0, 21681, 21682, + 7, 12, 0, 0, 21682, 21683, 7, 2, 0, 0, 21683, 21684, 7, 7, 0, 0, 21684, + 21685, 7, 5, 0, 0, 21685, 21686, 5, 95, 0, 0, 21686, 21687, 7, 15, 0, 0, + 21687, 21688, 7, 6, 0, 0, 21688, 21689, 7, 3, 0, 0, 21689, 21690, 5, 95, + 0, 0, 21690, 21691, 7, 10, 0, 0, 21691, 21692, 7, 5, 0, 0, 21692, 21693, + 7, 6, 0, 0, 21693, 21694, 7, 3, 0, 0, 21694, 3130, 1, 0, 0, 0, 21695, 21696, + 7, 5, 0, 0, 21696, 21697, 7, 6, 0, 0, 21697, 21698, 7, 5, 0, 0, 21698, + 21699, 7, 5, 0, 0, 21699, 21700, 7, 12, 0, 0, 21700, 21701, 7, 2, 0, 0, + 21701, 21702, 7, 7, 0, 0, 21702, 21703, 7, 4, 0, 0, 21703, 21704, 7, 12, + 0, 0, 21704, 21705, 7, 14, 0, 0, 21705, 21706, 7, 6, 0, 0, 21706, 21707, + 7, 23, 0, 0, 21707, 21708, 7, 2, 0, 0, 21708, 21709, 7, 7, 0, 0, 21709, + 21710, 7, 6, 0, 0, 21710, 3132, 1, 0, 0, 0, 21711, 21712, 7, 5, 0, 0, 21712, + 21713, 7, 6, 0, 0, 21713, 21714, 7, 5, 0, 0, 21714, 21715, 7, 5, 0, 0, + 21715, 21716, 7, 12, 0, 0, 21716, 21717, 7, 2, 0, 0, 21717, 21718, 7, 7, + 0, 0, 21718, 21719, 7, 4, 0, 0, 21719, 21720, 7, 23, 0, 0, 21720, 21721, + 7, 7, 0, 0, 21721, 21722, 7, 0, 0, 0, 21722, 21723, 7, 14, 0, 0, 21723, + 21724, 7, 6, 0, 0, 21724, 3134, 1, 0, 0, 0, 21725, 21726, 7, 5, 0, 0, 21726, + 21727, 7, 6, 0, 0, 21727, 21728, 7, 4, 0, 0, 21728, 3136, 1, 0, 0, 0, 21729, + 21730, 7, 5, 0, 0, 21730, 21731, 7, 6, 0, 0, 21731, 21732, 7, 4, 0, 0, + 21732, 21733, 7, 5, 0, 0, 21733, 3138, 1, 0, 0, 0, 21734, 21735, 7, 5, + 0, 0, 21735, 21736, 7, 6, 0, 0, 21736, 21737, 7, 4, 0, 0, 21737, 21738, + 7, 4, 0, 0, 21738, 21739, 7, 12, 0, 0, 21739, 21740, 7, 7, 0, 0, 21740, + 21741, 7, 17, 0, 0, 21741, 21742, 7, 5, 0, 0, 21742, 3140, 1, 0, 0, 0, + 21743, 21744, 7, 5, 0, 0, 21744, 21745, 7, 6, 0, 0, 21745, 21746, 7, 4, + 0, 0, 21746, 21747, 5, 95, 0, 0, 21747, 21748, 7, 4, 0, 0, 21748, 21749, + 7, 2, 0, 0, 21749, 21750, 5, 95, 0, 0, 21750, 21751, 7, 20, 0, 0, 21751, + 21752, 7, 2, 0, 0, 21752, 21753, 7, 12, 0, 0, 21753, 21754, 7, 7, 0, 0, + 21754, 3142, 1, 0, 0, 0, 21755, 21756, 7, 5, 0, 0, 21756, 21757, 7, 6, + 0, 0, 21757, 21758, 7, 13, 0, 0, 21758, 21759, 7, 6, 0, 0, 21759, 21760, + 7, 3, 0, 0, 21760, 21761, 7, 6, 0, 0, 21761, 3144, 1, 0, 0, 0, 21762, 21763, + 7, 5, 0, 0, 21763, 21764, 7, 19, 0, 0, 21764, 21765, 7, 0, 0, 0, 21765, + 21766, 7, 3, 0, 0, 21766, 21767, 7, 9, 0, 0, 21767, 21768, 7, 5, 0, 0, + 21768, 21769, 7, 15, 0, 0, 21769, 21770, 7, 0, 0, 0, 21770, 21771, 7, 8, + 0, 0, 21771, 21772, 7, 6, 0, 0, 21772, 3146, 1, 0, 0, 0, 21773, 21774, + 7, 5, 0, 0, 21774, 21775, 7, 19, 0, 0, 21775, 21776, 7, 0, 0, 0, 21776, + 21777, 7, 3, 0, 0, 21777, 21778, 7, 6, 0, 0, 21778, 21779, 7, 9, 0, 0, + 21779, 21780, 5, 95, 0, 0, 21780, 21781, 7, 15, 0, 0, 21781, 21782, 7, + 2, 0, 0, 21782, 21783, 7, 2, 0, 0, 21783, 21784, 7, 11, 0, 0, 21784, 3148, + 1, 0, 0, 0, 21785, 21786, 7, 5, 0, 0, 21786, 21787, 7, 19, 0, 0, 21787, + 21788, 7, 0, 0, 0, 21788, 21789, 7, 3, 0, 0, 21789, 21790, 7, 6, 0, 0, + 21790, 21791, 7, 9, 0, 0, 21791, 3150, 1, 0, 0, 0, 21792, 21793, 7, 5, + 0, 0, 21793, 21794, 7, 19, 0, 0, 21794, 21795, 7, 0, 0, 0, 21795, 21796, + 7, 3, 0, 0, 21796, 21797, 7, 6, 0, 0, 21797, 3152, 1, 0, 0, 0, 21798, 21799, + 7, 5, 0, 0, 21799, 21800, 7, 19, 0, 0, 21800, 21801, 7, 0, 0, 0, 21801, + 21802, 7, 3, 0, 0, 21802, 21803, 7, 12, 0, 0, 21803, 21804, 7, 7, 0, 0, + 21804, 21805, 7, 17, 0, 0, 21805, 3154, 1, 0, 0, 0, 21806, 21807, 7, 5, + 0, 0, 21807, 21808, 7, 19, 0, 0, 21808, 21809, 7, 6, 0, 0, 21809, 21810, + 7, 11, 0, 0, 21810, 21811, 7, 16, 0, 0, 21811, 21812, 7, 11, 0, 0, 21812, + 21813, 7, 12, 0, 0, 21813, 21814, 7, 16, 0, 0, 21814, 21815, 7, 6, 0, 0, + 21815, 3156, 1, 0, 0, 0, 21816, 21817, 7, 5, 0, 0, 21817, 21818, 7, 19, + 0, 0, 21818, 21819, 7, 2, 0, 0, 21819, 21820, 7, 22, 0, 0, 21820, 3158, + 1, 0, 0, 0, 21821, 21822, 7, 5, 0, 0, 21822, 21823, 7, 19, 0, 0, 21823, + 21824, 7, 3, 0, 0, 21824, 21825, 7, 12, 0, 0, 21825, 21826, 7, 7, 0, 0, + 21826, 21827, 7, 21, 0, 0, 21827, 3160, 1, 0, 0, 0, 21828, 21829, 7, 5, + 0, 0, 21829, 21830, 7, 19, 0, 0, 21830, 21831, 7, 10, 0, 0, 21831, 21832, + 7, 4, 0, 0, 21832, 21833, 7, 9, 0, 0, 21833, 21834, 7, 2, 0, 0, 21834, + 21835, 7, 22, 0, 0, 21835, 21836, 7, 7, 0, 0, 21836, 3162, 1, 0, 0, 0, + 21837, 21838, 7, 5, 0, 0, 21838, 21839, 7, 12, 0, 0, 21839, 21840, 7, 1, + 0, 0, 21840, 21841, 7, 11, 0, 0, 21841, 21842, 7, 12, 0, 0, 21842, 21843, + 7, 7, 0, 0, 21843, 21844, 7, 17, 0, 0, 21844, 21845, 7, 5, 0, 0, 21845, + 3164, 1, 0, 0, 0, 21846, 21847, 7, 5, 0, 0, 21847, 21848, 7, 12, 0, 0, + 21848, 21849, 7, 9, 0, 0, 21849, 3166, 1, 0, 0, 0, 21850, 21851, 7, 5, + 0, 0, 21851, 21852, 7, 12, 0, 0, 21852, 21853, 7, 4, 0, 0, 21853, 21854, + 7, 6, 0, 0, 21854, 3168, 1, 0, 0, 0, 21855, 21856, 7, 5, 0, 0, 21856, 21857, + 7, 12, 0, 0, 21857, 21858, 7, 17, 0, 0, 21858, 21859, 7, 7, 0, 0, 21859, + 21860, 7, 0, 0, 0, 21860, 21861, 7, 11, 0, 0, 21861, 21862, 5, 95, 0, 0, + 21862, 21863, 7, 8, 0, 0, 21863, 21864, 7, 2, 0, 0, 21864, 21865, 7, 14, + 0, 0, 21865, 21866, 7, 15, 0, 0, 21866, 21867, 7, 2, 0, 0, 21867, 21868, + 7, 7, 0, 0, 21868, 21869, 7, 6, 0, 0, 21869, 21870, 7, 7, 0, 0, 21870, + 21871, 7, 4, 0, 0, 21871, 3170, 1, 0, 0, 0, 21872, 21873, 7, 5, 0, 0, 21873, + 21874, 7, 12, 0, 0, 21874, 21875, 7, 17, 0, 0, 21875, 21876, 7, 7, 0, 0, + 21876, 21877, 7, 0, 0, 0, 21877, 21878, 7, 11, 0, 0, 21878, 21879, 5, 95, + 0, 0, 21879, 21880, 7, 16, 0, 0, 21880, 21881, 7, 10, 0, 0, 21881, 21882, + 7, 7, 0, 0, 21882, 21883, 7, 8, 0, 0, 21883, 21884, 7, 4, 0, 0, 21884, + 21885, 7, 12, 0, 0, 21885, 21886, 7, 2, 0, 0, 21886, 21887, 7, 7, 0, 0, + 21887, 3172, 1, 0, 0, 0, 21888, 21889, 7, 5, 0, 0, 21889, 21890, 7, 12, + 0, 0, 21890, 21891, 7, 17, 0, 0, 21891, 21892, 7, 7, 0, 0, 21892, 3174, + 1, 0, 0, 0, 21893, 21894, 7, 5, 0, 0, 21894, 21895, 7, 12, 0, 0, 21895, + 21896, 7, 17, 0, 0, 21896, 21897, 7, 7, 0, 0, 21897, 21898, 7, 4, 0, 0, + 21898, 21899, 7, 18, 0, 0, 21899, 21900, 7, 15, 0, 0, 21900, 21901, 7, + 6, 0, 0, 21901, 3176, 1, 0, 0, 0, 21902, 21903, 7, 5, 0, 0, 21903, 21904, + 7, 12, 0, 0, 21904, 21905, 7, 14, 0, 0, 21905, 21906, 7, 15, 0, 0, 21906, + 21907, 7, 11, 0, 0, 21907, 21908, 7, 6, 0, 0, 21908, 21909, 5, 95, 0, 0, + 21909, 21910, 7, 12, 0, 0, 21910, 21911, 7, 7, 0, 0, 21911, 21912, 7, 4, + 0, 0, 21912, 21913, 7, 6, 0, 0, 21913, 21914, 7, 17, 0, 0, 21914, 21915, + 7, 6, 0, 0, 21915, 21916, 7, 3, 0, 0, 21916, 3178, 1, 0, 0, 0, 21917, 21918, + 7, 5, 0, 0, 21918, 21919, 7, 12, 0, 0, 21919, 21920, 7, 14, 0, 0, 21920, + 21921, 7, 15, 0, 0, 21921, 21922, 7, 11, 0, 0, 21922, 21923, 7, 6, 0, 0, + 21923, 3180, 1, 0, 0, 0, 21924, 21925, 7, 5, 0, 0, 21925, 21926, 7, 12, + 0, 0, 21926, 21927, 7, 7, 0, 0, 21927, 21928, 7, 17, 0, 0, 21928, 21929, + 7, 11, 0, 0, 21929, 21930, 7, 6, 0, 0, 21930, 3182, 1, 0, 0, 0, 21931, + 21932, 7, 5, 0, 0, 21932, 21933, 7, 12, 0, 0, 21933, 21934, 7, 7, 0, 0, + 21934, 21935, 7, 17, 0, 0, 21935, 21936, 7, 11, 0, 0, 21936, 21937, 7, + 6, 0, 0, 21937, 21938, 7, 4, 0, 0, 21938, 21939, 7, 0, 0, 0, 21939, 21940, + 7, 5, 0, 0, 21940, 21941, 7, 21, 0, 0, 21941, 3184, 1, 0, 0, 0, 21942, + 21943, 7, 5, 0, 0, 21943, 21944, 7, 12, 0, 0, 21944, 21945, 7, 7, 0, 0, + 21945, 21946, 7, 19, 0, 0, 21946, 3186, 1, 0, 0, 0, 21947, 21948, 7, 5, + 0, 0, 21948, 21949, 7, 12, 0, 0, 21949, 21950, 7, 7, 0, 0, 21950, 3188, + 1, 0, 0, 0, 21951, 21952, 7, 5, 0, 0, 21952, 21953, 7, 12, 0, 0, 21953, + 21954, 7, 23, 0, 0, 21954, 21955, 7, 6, 0, 0, 21955, 3190, 1, 0, 0, 0, + 21956, 21957, 7, 5, 0, 0, 21957, 21958, 7, 21, 0, 0, 21958, 21959, 7, 12, + 0, 0, 21959, 21960, 7, 15, 0, 0, 21960, 21961, 5, 95, 0, 0, 21961, 21962, + 7, 6, 0, 0, 21962, 21963, 7, 25, 0, 0, 21963, 21964, 7, 4, 0, 0, 21964, + 21965, 5, 95, 0, 0, 21965, 21966, 7, 2, 0, 0, 21966, 21967, 7, 15, 0, 0, + 21967, 21968, 7, 4, 0, 0, 21968, 21969, 7, 12, 0, 0, 21969, 21970, 7, 14, + 0, 0, 21970, 21971, 7, 12, 0, 0, 21971, 21972, 7, 23, 0, 0, 21972, 21973, + 7, 6, 0, 0, 21973, 21974, 7, 3, 0, 0, 21974, 3192, 1, 0, 0, 0, 21975, 21976, + 7, 5, 0, 0, 21976, 21977, 7, 21, 0, 0, 21977, 21978, 7, 12, 0, 0, 21978, + 21979, 7, 15, 0, 0, 21979, 3194, 1, 0, 0, 0, 21980, 21981, 7, 5, 0, 0, + 21981, 21982, 7, 21, 0, 0, 21982, 21983, 7, 12, 0, 0, 21983, 21984, 7, + 15, 0, 0, 21984, 21985, 5, 95, 0, 0, 21985, 21986, 7, 10, 0, 0, 21986, + 21987, 7, 7, 0, 0, 21987, 21988, 7, 24, 0, 0, 21988, 21989, 5, 95, 0, 0, + 21989, 21990, 7, 10, 0, 0, 21990, 21991, 7, 7, 0, 0, 21991, 21992, 7, 10, + 0, 0, 21992, 21993, 7, 5, 0, 0, 21993, 21994, 7, 0, 0, 0, 21994, 21995, + 7, 1, 0, 0, 21995, 21996, 7, 11, 0, 0, 21996, 21997, 7, 6, 0, 0, 21997, + 21998, 5, 95, 0, 0, 21998, 21999, 7, 12, 0, 0, 21999, 22000, 7, 9, 0, 0, + 22000, 22001, 7, 25, 0, 0, 22001, 3196, 1, 0, 0, 0, 22002, 22003, 7, 5, + 0, 0, 22003, 22004, 7, 21, 0, 0, 22004, 22005, 7, 12, 0, 0, 22005, 22006, + 7, 15, 0, 0, 22006, 22007, 5, 95, 0, 0, 22007, 22008, 7, 10, 0, 0, 22008, + 22009, 7, 7, 0, 0, 22009, 22010, 7, 10, 0, 0, 22010, 22011, 7, 5, 0, 0, + 22011, 22012, 7, 0, 0, 0, 22012, 22013, 7, 1, 0, 0, 22013, 22014, 7, 11, + 0, 0, 22014, 22015, 7, 6, 0, 0, 22015, 22016, 5, 95, 0, 0, 22016, 22017, + 7, 12, 0, 0, 22017, 22018, 7, 7, 0, 0, 22018, 22019, 7, 9, 0, 0, 22019, + 22020, 7, 6, 0, 0, 22020, 22021, 7, 25, 0, 0, 22021, 22022, 7, 6, 0, 0, + 22022, 22023, 7, 5, 0, 0, 22023, 3198, 1, 0, 0, 0, 22024, 22025, 7, 5, + 0, 0, 22025, 22026, 7, 14, 0, 0, 22026, 22027, 7, 0, 0, 0, 22027, 22028, + 7, 11, 0, 0, 22028, 22029, 7, 11, 0, 0, 22029, 22030, 7, 16, 0, 0, 22030, + 22031, 7, 12, 0, 0, 22031, 22032, 7, 11, 0, 0, 22032, 22033, 7, 6, 0, 0, + 22033, 3200, 1, 0, 0, 0, 22034, 22035, 7, 5, 0, 0, 22035, 22036, 7, 14, + 0, 0, 22036, 22037, 7, 0, 0, 0, 22037, 22038, 7, 11, 0, 0, 22038, 22039, + 7, 11, 0, 0, 22039, 22040, 7, 12, 0, 0, 22040, 22041, 7, 7, 0, 0, 22041, + 22042, 7, 4, 0, 0, 22042, 3202, 1, 0, 0, 0, 22043, 22044, 7, 5, 0, 0, 22044, + 22045, 7, 7, 0, 0, 22045, 22046, 7, 0, 0, 0, 22046, 22047, 7, 15, 0, 0, + 22047, 22048, 7, 5, 0, 0, 22048, 22049, 7, 19, 0, 0, 22049, 22050, 7, 2, + 0, 0, 22050, 22051, 7, 4, 0, 0, 22051, 3204, 1, 0, 0, 0, 22052, 22053, + 7, 5, 0, 0, 22053, 22054, 7, 2, 0, 0, 22054, 22055, 7, 14, 0, 0, 22055, + 22056, 7, 6, 0, 0, 22056, 3206, 1, 0, 0, 0, 22057, 22058, 7, 5, 0, 0, 22058, + 22059, 7, 2, 0, 0, 22059, 22060, 7, 3, 0, 0, 22060, 22061, 7, 4, 0, 0, + 22061, 3208, 1, 0, 0, 0, 22062, 22063, 7, 5, 0, 0, 22063, 22064, 7, 2, + 0, 0, 22064, 22065, 7, 10, 0, 0, 22065, 22066, 7, 7, 0, 0, 22066, 22067, + 7, 9, 0, 0, 22067, 22068, 7, 6, 0, 0, 22068, 22069, 7, 25, 0, 0, 22069, + 3210, 1, 0, 0, 0, 22070, 22071, 7, 5, 0, 0, 22071, 22072, 7, 2, 0, 0, 22072, + 22073, 7, 10, 0, 0, 22073, 22074, 7, 3, 0, 0, 22074, 22075, 7, 8, 0, 0, + 22075, 22076, 7, 6, 0, 0, 22076, 22077, 5, 95, 0, 0, 22077, 22078, 7, 16, + 0, 0, 22078, 22079, 7, 12, 0, 0, 22079, 22080, 7, 11, 0, 0, 22080, 22081, + 7, 6, 0, 0, 22081, 22082, 5, 95, 0, 0, 22082, 22083, 7, 9, 0, 0, 22083, + 22084, 7, 12, 0, 0, 22084, 22085, 7, 3, 0, 0, 22085, 22086, 7, 6, 0, 0, + 22086, 22087, 7, 8, 0, 0, 22087, 22088, 7, 4, 0, 0, 22088, 22089, 7, 2, + 0, 0, 22089, 22090, 7, 3, 0, 0, 22090, 22091, 7, 18, 0, 0, 22091, 3212, + 1, 0, 0, 0, 22092, 22093, 7, 5, 0, 0, 22093, 22094, 7, 2, 0, 0, 22094, + 22095, 7, 10, 0, 0, 22095, 22096, 7, 3, 0, 0, 22096, 22097, 7, 8, 0, 0, + 22097, 22098, 7, 6, 0, 0, 22098, 22099, 5, 95, 0, 0, 22099, 22100, 7, 16, + 0, 0, 22100, 22101, 7, 12, 0, 0, 22101, 22102, 7, 11, 0, 0, 22102, 22103, + 7, 6, 0, 0, 22103, 22104, 5, 95, 0, 0, 22104, 22105, 7, 7, 0, 0, 22105, + 22106, 7, 0, 0, 0, 22106, 22107, 7, 14, 0, 0, 22107, 22108, 7, 6, 0, 0, + 22108, 22109, 5, 95, 0, 0, 22109, 22110, 7, 8, 0, 0, 22110, 22111, 7, 2, + 0, 0, 22111, 22112, 7, 7, 0, 0, 22112, 22113, 7, 13, 0, 0, 22113, 22114, + 7, 6, 0, 0, 22114, 22115, 7, 3, 0, 0, 22115, 22116, 7, 4, 0, 0, 22116, + 3214, 1, 0, 0, 0, 22117, 22118, 7, 5, 0, 0, 22118, 22119, 7, 2, 0, 0, 22119, + 22120, 7, 10, 0, 0, 22120, 22121, 7, 3, 0, 0, 22121, 22122, 7, 8, 0, 0, + 22122, 22123, 7, 6, 0, 0, 22123, 3216, 1, 0, 0, 0, 22124, 22125, 7, 5, + 0, 0, 22125, 22126, 7, 15, 0, 0, 22126, 22127, 7, 0, 0, 0, 22127, 22128, + 7, 8, 0, 0, 22128, 22129, 7, 6, 0, 0, 22129, 3218, 1, 0, 0, 0, 22130, 22131, + 7, 5, 0, 0, 22131, 22132, 7, 15, 0, 0, 22132, 22133, 7, 6, 0, 0, 22133, + 22134, 7, 8, 0, 0, 22134, 22135, 7, 12, 0, 0, 22135, 22136, 7, 16, 0, 0, + 22136, 22137, 7, 12, 0, 0, 22137, 22138, 7, 8, 0, 0, 22138, 22139, 7, 0, + 0, 0, 22139, 22140, 7, 4, 0, 0, 22140, 22141, 7, 12, 0, 0, 22141, 22142, + 7, 2, 0, 0, 22142, 22143, 7, 7, 0, 0, 22143, 3220, 1, 0, 0, 0, 22144, 22145, + 7, 5, 0, 0, 22145, 22146, 7, 15, 0, 0, 22146, 22147, 7, 16, 0, 0, 22147, + 22148, 7, 12, 0, 0, 22148, 22149, 7, 11, 0, 0, 22149, 22150, 7, 6, 0, 0, + 22150, 3222, 1, 0, 0, 0, 22151, 22152, 7, 5, 0, 0, 22152, 22153, 7, 15, + 0, 0, 22153, 22154, 7, 11, 0, 0, 22154, 22155, 7, 12, 0, 0, 22155, 22156, + 7, 4, 0, 0, 22156, 3224, 1, 0, 0, 0, 22157, 22158, 7, 5, 0, 0, 22158, 22159, + 7, 15, 0, 0, 22159, 22160, 7, 3, 0, 0, 22160, 22161, 7, 6, 0, 0, 22161, + 22162, 7, 0, 0, 0, 22162, 22163, 7, 9, 0, 0, 22163, 22164, 7, 5, 0, 0, + 22164, 22165, 7, 19, 0, 0, 22165, 22166, 7, 6, 0, 0, 22166, 22167, 7, 6, + 0, 0, 22167, 22168, 7, 4, 0, 0, 22168, 3226, 1, 0, 0, 0, 22169, 22170, + 7, 5, 0, 0, 22170, 22171, 7, 24, 0, 0, 22171, 22172, 7, 11, 0, 0, 22172, + 22173, 7, 9, 0, 0, 22173, 22174, 7, 0, 0, 0, 22174, 22175, 7, 4, 0, 0, + 22175, 22176, 7, 0, 0, 0, 22176, 3228, 1, 0, 0, 0, 22177, 22178, 7, 5, + 0, 0, 22178, 22179, 7, 24, 0, 0, 22179, 22180, 7, 11, 0, 0, 22180, 22181, + 7, 6, 0, 0, 22181, 22182, 7, 3, 0, 0, 22182, 22183, 7, 3, 0, 0, 22183, + 22184, 7, 2, 0, 0, 22184, 22185, 7, 3, 0, 0, 22185, 3230, 1, 0, 0, 0, 22186, + 22187, 7, 5, 0, 0, 22187, 22188, 7, 24, 0, 0, 22188, 22189, 7, 11, 0, 0, + 22189, 22190, 7, 11, 0, 0, 22190, 22191, 7, 9, 0, 0, 22191, 22192, 7, 3, + 0, 0, 22192, 3232, 1, 0, 0, 0, 22193, 22194, 7, 5, 0, 0, 22194, 22195, + 7, 24, 0, 0, 22195, 22196, 7, 11, 0, 0, 22196, 3234, 1, 0, 0, 0, 22197, + 22198, 7, 5, 0, 0, 22198, 22199, 7, 24, 0, 0, 22199, 22200, 7, 11, 0, 0, + 22200, 22201, 5, 95, 0, 0, 22201, 22202, 7, 14, 0, 0, 22202, 22203, 7, + 0, 0, 0, 22203, 22204, 7, 8, 0, 0, 22204, 22205, 7, 3, 0, 0, 22205, 22206, + 7, 2, 0, 0, 22206, 3236, 1, 0, 0, 0, 22207, 22208, 7, 5, 0, 0, 22208, 22209, + 7, 24, 0, 0, 22209, 22210, 7, 11, 0, 0, 22210, 22211, 5, 95, 0, 0, 22211, + 22212, 7, 4, 0, 0, 22212, 22213, 7, 3, 0, 0, 22213, 22214, 7, 0, 0, 0, + 22214, 22215, 7, 8, 0, 0, 22215, 22216, 7, 6, 0, 0, 22216, 3238, 1, 0, + 0, 0, 22217, 22218, 7, 5, 0, 0, 22218, 22219, 7, 24, 0, 0, 22219, 22220, + 7, 11, 0, 0, 22220, 22221, 5, 95, 0, 0, 22221, 22222, 7, 4, 0, 0, 22222, + 22223, 7, 3, 0, 0, 22223, 22224, 7, 0, 0, 0, 22224, 22225, 7, 7, 0, 0, + 22225, 22226, 7, 5, 0, 0, 22226, 22227, 7, 11, 0, 0, 22227, 22228, 7, 0, + 0, 0, 22228, 22229, 7, 4, 0, 0, 22229, 22230, 7, 12, 0, 0, 22230, 22231, + 7, 2, 0, 0, 22231, 22232, 7, 7, 0, 0, 22232, 22233, 5, 95, 0, 0, 22233, + 22234, 7, 15, 0, 0, 22234, 22235, 7, 3, 0, 0, 22235, 22236, 7, 2, 0, 0, + 22236, 22237, 7, 16, 0, 0, 22237, 22238, 7, 12, 0, 0, 22238, 22239, 7, + 11, 0, 0, 22239, 22240, 7, 6, 0, 0, 22240, 3240, 1, 0, 0, 0, 22241, 22242, + 7, 5, 0, 0, 22242, 22243, 7, 24, 0, 0, 22243, 22244, 7, 3, 0, 0, 22244, + 22245, 7, 4, 0, 0, 22245, 3242, 1, 0, 0, 0, 22246, 22247, 7, 5, 0, 0, 22247, + 22248, 7, 4, 0, 0, 22248, 22249, 7, 0, 0, 0, 22249, 22250, 7, 11, 0, 0, + 22250, 22251, 7, 6, 0, 0, 22251, 3244, 1, 0, 0, 0, 22252, 22253, 7, 5, + 0, 0, 22253, 22254, 7, 4, 0, 0, 22254, 22255, 7, 0, 0, 0, 22255, 22256, + 7, 7, 0, 0, 22256, 22257, 7, 9, 0, 0, 22257, 22258, 7, 0, 0, 0, 22258, + 22259, 7, 11, 0, 0, 22259, 22260, 7, 2, 0, 0, 22260, 22261, 7, 7, 0, 0, + 22261, 22262, 7, 6, 0, 0, 22262, 3246, 1, 0, 0, 0, 22263, 22264, 7, 5, + 0, 0, 22264, 22265, 7, 4, 0, 0, 22265, 22266, 7, 0, 0, 0, 22266, 22267, + 7, 7, 0, 0, 22267, 22268, 7, 9, 0, 0, 22268, 22269, 7, 0, 0, 0, 22269, + 22270, 7, 3, 0, 0, 22270, 22271, 7, 9, 0, 0, 22271, 3248, 1, 0, 0, 0, 22272, + 22273, 7, 5, 0, 0, 22273, 22274, 7, 4, 0, 0, 22274, 22275, 7, 0, 0, 0, + 22275, 22276, 7, 7, 0, 0, 22276, 22277, 7, 9, 0, 0, 22277, 22278, 7, 0, + 0, 0, 22278, 22279, 7, 3, 0, 0, 22279, 22280, 7, 9, 0, 0, 22280, 22281, + 5, 95, 0, 0, 22281, 22282, 7, 19, 0, 0, 22282, 22283, 7, 0, 0, 0, 22283, + 22284, 7, 5, 0, 0, 22284, 22285, 7, 19, 0, 0, 22285, 3250, 1, 0, 0, 0, + 22286, 22287, 7, 5, 0, 0, 22287, 22288, 7, 4, 0, 0, 22288, 22289, 7, 0, + 0, 0, 22289, 22290, 7, 7, 0, 0, 22290, 22291, 7, 9, 0, 0, 22291, 22292, + 7, 1, 0, 0, 22292, 22293, 7, 18, 0, 0, 22293, 22294, 5, 95, 0, 0, 22294, + 22295, 7, 14, 0, 0, 22295, 22296, 7, 0, 0, 0, 22296, 22297, 7, 25, 0, 0, + 22297, 22298, 5, 95, 0, 0, 22298, 22299, 7, 9, 0, 0, 22299, 22300, 7, 0, + 0, 0, 22300, 22301, 7, 4, 0, 0, 22301, 22302, 7, 0, 0, 0, 22302, 22303, + 5, 95, 0, 0, 22303, 22304, 7, 9, 0, 0, 22304, 22305, 7, 6, 0, 0, 22305, + 22306, 7, 11, 0, 0, 22306, 22307, 7, 0, 0, 0, 22307, 22308, 7, 18, 0, 0, + 22308, 3252, 1, 0, 0, 0, 22309, 22310, 7, 5, 0, 0, 22310, 22311, 7, 4, + 0, 0, 22311, 22312, 7, 0, 0, 0, 22312, 22313, 7, 7, 0, 0, 22313, 22314, + 7, 9, 0, 0, 22314, 22315, 7, 1, 0, 0, 22315, 22316, 7, 18, 0, 0, 22316, + 22317, 7, 5, 0, 0, 22317, 3254, 1, 0, 0, 0, 22318, 22319, 7, 5, 0, 0, 22319, + 22320, 7, 4, 0, 0, 22320, 22321, 7, 0, 0, 0, 22321, 22322, 7, 7, 0, 0, + 22322, 22323, 7, 9, 0, 0, 22323, 22324, 7, 1, 0, 0, 22324, 22325, 7, 18, + 0, 0, 22325, 3256, 1, 0, 0, 0, 22326, 22327, 7, 5, 0, 0, 22327, 22328, + 7, 4, 0, 0, 22328, 22329, 7, 0, 0, 0, 22329, 22330, 7, 3, 0, 0, 22330, + 3258, 1, 0, 0, 0, 22331, 22332, 7, 5, 0, 0, 22332, 22333, 7, 4, 0, 0, 22333, + 22334, 7, 0, 0, 0, 22334, 22335, 7, 3, 0, 0, 22335, 22336, 5, 95, 0, 0, + 22336, 22337, 7, 4, 0, 0, 22337, 22338, 7, 3, 0, 0, 22338, 22339, 7, 0, + 0, 0, 22339, 22340, 7, 7, 0, 0, 22340, 22341, 7, 5, 0, 0, 22341, 22342, + 7, 16, 0, 0, 22342, 22343, 7, 2, 0, 0, 22343, 22344, 7, 3, 0, 0, 22344, + 22345, 7, 14, 0, 0, 22345, 22346, 7, 0, 0, 0, 22346, 22347, 7, 4, 0, 0, + 22347, 22348, 7, 12, 0, 0, 22348, 22349, 7, 2, 0, 0, 22349, 22350, 7, 7, + 0, 0, 22350, 3260, 1, 0, 0, 0, 22351, 22352, 7, 5, 0, 0, 22352, 22353, + 7, 4, 0, 0, 22353, 22354, 7, 0, 0, 0, 22354, 22355, 7, 3, 0, 0, 22355, + 22356, 7, 4, 0, 0, 22356, 3262, 1, 0, 0, 0, 22357, 22358, 7, 5, 0, 0, 22358, + 22359, 7, 4, 0, 0, 22359, 22360, 7, 0, 0, 0, 22360, 22361, 7, 3, 0, 0, + 22361, 22362, 7, 4, 0, 0, 22362, 22363, 7, 10, 0, 0, 22363, 22364, 7, 15, + 0, 0, 22364, 3264, 1, 0, 0, 0, 22365, 22366, 7, 5, 0, 0, 22366, 22367, + 7, 4, 0, 0, 22367, 22368, 7, 0, 0, 0, 22368, 22369, 7, 4, 0, 0, 22369, + 22370, 7, 6, 0, 0, 22370, 22371, 7, 14, 0, 0, 22371, 22372, 7, 6, 0, 0, + 22372, 22373, 7, 7, 0, 0, 22373, 22374, 7, 4, 0, 0, 22374, 22375, 5, 95, + 0, 0, 22375, 22376, 7, 12, 0, 0, 22376, 22377, 7, 9, 0, 0, 22377, 3266, + 1, 0, 0, 0, 22378, 22379, 7, 5, 0, 0, 22379, 22380, 7, 4, 0, 0, 22380, + 22381, 7, 0, 0, 0, 22381, 22382, 7, 4, 0, 0, 22382, 22383, 7, 6, 0, 0, + 22383, 22384, 7, 14, 0, 0, 22384, 22385, 7, 6, 0, 0, 22385, 22386, 7, 7, + 0, 0, 22386, 22387, 7, 4, 0, 0, 22387, 22388, 5, 95, 0, 0, 22388, 22389, + 7, 24, 0, 0, 22389, 22390, 7, 10, 0, 0, 22390, 22391, 7, 6, 0, 0, 22391, + 22392, 7, 10, 0, 0, 22392, 22393, 7, 12, 0, 0, 22393, 22394, 7, 7, 0, 0, + 22394, 22395, 7, 17, 0, 0, 22395, 3268, 1, 0, 0, 0, 22396, 22397, 7, 5, + 0, 0, 22397, 22398, 7, 4, 0, 0, 22398, 22399, 7, 0, 0, 0, 22399, 22400, + 7, 4, 0, 0, 22400, 22401, 7, 6, 0, 0, 22401, 22402, 7, 14, 0, 0, 22402, + 22403, 7, 6, 0, 0, 22403, 22404, 7, 7, 0, 0, 22404, 22405, 7, 4, 0, 0, + 22405, 22406, 7, 5, 0, 0, 22406, 3270, 1, 0, 0, 0, 22407, 22408, 7, 5, + 0, 0, 22408, 22409, 7, 4, 0, 0, 22409, 22410, 7, 0, 0, 0, 22410, 22411, + 7, 4, 0, 0, 22411, 22412, 7, 6, 0, 0, 22412, 22413, 7, 14, 0, 0, 22413, + 22414, 7, 6, 0, 0, 22414, 22415, 7, 7, 0, 0, 22415, 22416, 7, 4, 0, 0, + 22416, 3272, 1, 0, 0, 0, 22417, 22418, 7, 5, 0, 0, 22418, 22419, 7, 4, + 0, 0, 22419, 22420, 7, 0, 0, 0, 22420, 22421, 7, 4, 0, 0, 22421, 22422, + 7, 6, 0, 0, 22422, 3274, 1, 0, 0, 0, 22423, 22424, 7, 5, 0, 0, 22424, 22425, + 7, 4, 0, 0, 22425, 22426, 7, 0, 0, 0, 22426, 22427, 7, 4, 0, 0, 22427, + 22428, 7, 12, 0, 0, 22428, 22429, 7, 8, 0, 0, 22429, 3276, 1, 0, 0, 0, + 22430, 22431, 7, 5, 0, 0, 22431, 22432, 7, 4, 0, 0, 22432, 22433, 7, 0, + 0, 0, 22433, 22434, 7, 4, 0, 0, 22434, 22435, 7, 12, 0, 0, 22435, 22436, + 7, 5, 0, 0, 22436, 22437, 7, 4, 0, 0, 22437, 22438, 7, 12, 0, 0, 22438, + 22439, 7, 8, 0, 0, 22439, 22440, 7, 5, 0, 0, 22440, 3278, 1, 0, 0, 0, 22441, + 22442, 7, 5, 0, 0, 22442, 22443, 7, 4, 0, 0, 22443, 22444, 7, 0, 0, 0, + 22444, 22445, 7, 4, 0, 0, 22445, 22446, 7, 5, 0, 0, 22446, 22447, 5, 95, + 0, 0, 22447, 22448, 7, 1, 0, 0, 22448, 22449, 7, 12, 0, 0, 22449, 22450, + 7, 7, 0, 0, 22450, 22451, 7, 2, 0, 0, 22451, 22452, 7, 14, 0, 0, 22452, + 22453, 7, 12, 0, 0, 22453, 22454, 7, 0, 0, 0, 22454, 22455, 7, 11, 0, 0, + 22455, 22456, 5, 95, 0, 0, 22456, 22457, 7, 4, 0, 0, 22457, 22458, 7, 6, + 0, 0, 22458, 22459, 7, 5, 0, 0, 22459, 22460, 7, 4, 0, 0, 22460, 3280, + 1, 0, 0, 0, 22461, 22462, 7, 5, 0, 0, 22462, 22463, 7, 4, 0, 0, 22463, + 22464, 7, 0, 0, 0, 22464, 22465, 7, 4, 0, 0, 22465, 22466, 7, 5, 0, 0, + 22466, 22467, 5, 95, 0, 0, 22467, 22468, 7, 8, 0, 0, 22468, 22469, 7, 3, + 0, 0, 22469, 22470, 7, 2, 0, 0, 22470, 22471, 7, 5, 0, 0, 22471, 22472, + 7, 5, 0, 0, 22472, 22473, 7, 4, 0, 0, 22473, 22474, 7, 0, 0, 0, 22474, + 22475, 7, 1, 0, 0, 22475, 3282, 1, 0, 0, 0, 22476, 22477, 7, 5, 0, 0, 22477, + 22478, 7, 4, 0, 0, 22478, 22479, 7, 0, 0, 0, 22479, 22480, 7, 4, 0, 0, + 22480, 22481, 7, 5, 0, 0, 22481, 22482, 5, 95, 0, 0, 22482, 22483, 7, 16, + 0, 0, 22483, 22484, 5, 95, 0, 0, 22484, 22485, 7, 4, 0, 0, 22485, 22486, + 7, 6, 0, 0, 22486, 22487, 7, 5, 0, 0, 22487, 22488, 7, 4, 0, 0, 22488, + 3284, 1, 0, 0, 0, 22489, 22490, 7, 5, 0, 0, 22490, 22491, 7, 4, 0, 0, 22491, + 22492, 7, 0, 0, 0, 22492, 22493, 7, 4, 0, 0, 22493, 22494, 7, 5, 0, 0, + 22494, 22495, 5, 95, 0, 0, 22495, 22496, 7, 21, 0, 0, 22496, 22497, 7, + 5, 0, 0, 22497, 22498, 5, 95, 0, 0, 22498, 22499, 7, 4, 0, 0, 22499, 22500, + 7, 6, 0, 0, 22500, 22501, 7, 5, 0, 0, 22501, 22502, 7, 4, 0, 0, 22502, + 3286, 1, 0, 0, 0, 22503, 22504, 7, 5, 0, 0, 22504, 22505, 7, 4, 0, 0, 22505, + 22506, 7, 0, 0, 0, 22506, 22507, 7, 4, 0, 0, 22507, 22508, 7, 5, 0, 0, + 22508, 22509, 5, 95, 0, 0, 22509, 22510, 7, 14, 0, 0, 22510, 22511, 7, + 2, 0, 0, 22511, 22512, 7, 9, 0, 0, 22512, 22513, 7, 6, 0, 0, 22513, 3288, + 1, 0, 0, 0, 22514, 22515, 7, 5, 0, 0, 22515, 22516, 7, 4, 0, 0, 22516, + 22517, 7, 0, 0, 0, 22517, 22518, 7, 4, 0, 0, 22518, 22519, 7, 5, 0, 0, + 22519, 22520, 5, 95, 0, 0, 22520, 22521, 7, 14, 0, 0, 22521, 22522, 7, + 22, 0, 0, 22522, 22523, 5, 95, 0, 0, 22523, 22524, 7, 4, 0, 0, 22524, 22525, + 7, 6, 0, 0, 22525, 22526, 7, 5, 0, 0, 22526, 22527, 7, 4, 0, 0, 22527, + 3290, 1, 0, 0, 0, 22528, 22529, 7, 5, 0, 0, 22529, 22530, 7, 4, 0, 0, 22530, + 22531, 7, 0, 0, 0, 22531, 22532, 7, 4, 0, 0, 22532, 22533, 7, 5, 0, 0, + 22533, 22534, 5, 95, 0, 0, 22534, 22535, 7, 2, 0, 0, 22535, 22536, 7, 7, + 0, 0, 22536, 22537, 7, 6, 0, 0, 22537, 22538, 5, 95, 0, 0, 22538, 22539, + 7, 22, 0, 0, 22539, 22540, 7, 0, 0, 0, 22540, 22541, 7, 18, 0, 0, 22541, + 22542, 5, 95, 0, 0, 22542, 22543, 7, 0, 0, 0, 22543, 22544, 7, 7, 0, 0, + 22544, 22545, 7, 2, 0, 0, 22545, 22546, 7, 13, 0, 0, 22546, 22547, 7, 0, + 0, 0, 22547, 3292, 1, 0, 0, 0, 22548, 22549, 7, 5, 0, 0, 22549, 22550, + 7, 4, 0, 0, 22550, 22551, 7, 0, 0, 0, 22551, 22552, 7, 4, 0, 0, 22552, + 22553, 7, 5, 0, 0, 22553, 22554, 5, 95, 0, 0, 22554, 22555, 7, 4, 0, 0, + 22555, 22556, 5, 95, 0, 0, 22556, 22557, 7, 4, 0, 0, 22557, 22558, 7, 6, + 0, 0, 22558, 22559, 7, 5, 0, 0, 22559, 22560, 7, 4, 0, 0, 22560, 22561, + 5, 95, 0, 0, 22561, 22562, 7, 12, 0, 0, 22562, 22563, 7, 7, 0, 0, 22563, + 22564, 7, 9, 0, 0, 22564, 22565, 7, 6, 0, 0, 22565, 22566, 7, 15, 0, 0, + 22566, 3294, 1, 0, 0, 0, 22567, 22568, 7, 5, 0, 0, 22568, 22569, 7, 4, + 0, 0, 22569, 22570, 7, 0, 0, 0, 22570, 22571, 7, 4, 0, 0, 22571, 22572, + 7, 5, 0, 0, 22572, 22573, 5, 95, 0, 0, 22573, 22574, 7, 4, 0, 0, 22574, + 22575, 5, 95, 0, 0, 22575, 22576, 7, 4, 0, 0, 22576, 22577, 7, 6, 0, 0, + 22577, 22578, 7, 5, 0, 0, 22578, 22579, 7, 4, 0, 0, 22579, 22580, 5, 95, + 0, 0, 22580, 22581, 7, 12, 0, 0, 22581, 22582, 7, 7, 0, 0, 22582, 22583, + 7, 9, 0, 0, 22583, 22584, 7, 6, 0, 0, 22584, 22585, 7, 15, 0, 0, 22585, + 22586, 7, 10, 0, 0, 22586, 3296, 1, 0, 0, 0, 22587, 22588, 7, 5, 0, 0, + 22588, 22589, 7, 4, 0, 0, 22589, 22590, 7, 0, 0, 0, 22590, 22591, 7, 4, + 0, 0, 22591, 22592, 7, 5, 0, 0, 22592, 22593, 5, 95, 0, 0, 22593, 22594, + 7, 4, 0, 0, 22594, 22595, 5, 95, 0, 0, 22595, 22596, 7, 4, 0, 0, 22596, + 22597, 7, 6, 0, 0, 22597, 22598, 7, 5, 0, 0, 22598, 22599, 7, 4, 0, 0, + 22599, 22600, 5, 95, 0, 0, 22600, 22601, 7, 2, 0, 0, 22601, 22602, 7, 7, + 0, 0, 22602, 22603, 7, 6, 0, 0, 22603, 3298, 1, 0, 0, 0, 22604, 22605, + 7, 5, 0, 0, 22605, 22606, 7, 4, 0, 0, 22606, 22607, 7, 0, 0, 0, 22607, + 22608, 7, 4, 0, 0, 22608, 22609, 7, 5, 0, 0, 22609, 22610, 5, 95, 0, 0, + 22610, 22611, 7, 4, 0, 0, 22611, 22612, 5, 95, 0, 0, 22612, 22613, 7, 4, + 0, 0, 22613, 22614, 7, 6, 0, 0, 22614, 22615, 7, 5, 0, 0, 22615, 22616, + 7, 4, 0, 0, 22616, 22617, 5, 95, 0, 0, 22617, 22618, 7, 15, 0, 0, 22618, + 22619, 7, 0, 0, 0, 22619, 22620, 7, 12, 0, 0, 22620, 22621, 7, 3, 0, 0, + 22621, 22622, 7, 6, 0, 0, 22622, 22623, 7, 9, 0, 0, 22623, 3300, 1, 0, + 0, 0, 22624, 22625, 7, 5, 0, 0, 22625, 22626, 7, 4, 0, 0, 22626, 22627, + 7, 0, 0, 0, 22627, 22628, 7, 4, 0, 0, 22628, 22629, 7, 5, 0, 0, 22629, + 22630, 5, 95, 0, 0, 22630, 22631, 7, 22, 0, 0, 22631, 22632, 7, 5, 0, 0, + 22632, 22633, 7, 3, 0, 0, 22633, 22634, 5, 95, 0, 0, 22634, 22635, 7, 4, + 0, 0, 22635, 22636, 7, 6, 0, 0, 22636, 22637, 7, 5, 0, 0, 22637, 22638, + 7, 4, 0, 0, 22638, 3302, 1, 0, 0, 0, 22639, 22640, 7, 5, 0, 0, 22640, 22641, + 7, 4, 0, 0, 22641, 22642, 7, 9, 0, 0, 22642, 22643, 7, 9, 0, 0, 22643, + 22644, 7, 6, 0, 0, 22644, 22645, 7, 13, 0, 0, 22645, 22646, 5, 95, 0, 0, + 22646, 22647, 7, 15, 0, 0, 22647, 22648, 7, 2, 0, 0, 22648, 22649, 7, 15, + 0, 0, 22649, 3304, 1, 0, 0, 0, 22650, 22651, 7, 5, 0, 0, 22651, 22652, + 7, 4, 0, 0, 22652, 22653, 7, 9, 0, 0, 22653, 22654, 7, 9, 0, 0, 22654, + 22655, 7, 6, 0, 0, 22655, 22656, 7, 13, 0, 0, 22656, 22657, 5, 95, 0, 0, + 22657, 22658, 7, 5, 0, 0, 22658, 22659, 7, 0, 0, 0, 22659, 22660, 7, 14, + 0, 0, 22660, 22661, 7, 15, 0, 0, 22661, 3306, 1, 0, 0, 0, 22662, 22663, + 7, 5, 0, 0, 22663, 22664, 7, 4, 0, 0, 22664, 22665, 7, 2, 0, 0, 22665, + 22666, 7, 15, 0, 0, 22666, 3308, 1, 0, 0, 0, 22667, 22668, 7, 5, 0, 0, + 22668, 22669, 7, 4, 0, 0, 22669, 22670, 7, 2, 0, 0, 22670, 22671, 7, 3, + 0, 0, 22671, 22672, 7, 0, 0, 0, 22672, 22673, 7, 17, 0, 0, 22673, 22674, + 7, 6, 0, 0, 22674, 3310, 1, 0, 0, 0, 22675, 22676, 7, 5, 0, 0, 22676, 22677, + 7, 4, 0, 0, 22677, 22678, 7, 2, 0, 0, 22678, 22679, 7, 3, 0, 0, 22679, + 22680, 7, 6, 0, 0, 22680, 3312, 1, 0, 0, 0, 22681, 22682, 7, 5, 0, 0, 22682, + 22683, 7, 4, 0, 0, 22683, 22684, 7, 3, 0, 0, 22684, 22685, 7, 6, 0, 0, + 22685, 22686, 7, 0, 0, 0, 22686, 22687, 7, 14, 0, 0, 22687, 22688, 7, 5, + 0, 0, 22688, 3314, 1, 0, 0, 0, 22689, 22690, 7, 5, 0, 0, 22690, 22691, + 7, 4, 0, 0, 22691, 22692, 7, 3, 0, 0, 22692, 22693, 7, 6, 0, 0, 22693, + 22694, 7, 0, 0, 0, 22694, 22695, 7, 14, 0, 0, 22695, 3316, 1, 0, 0, 0, + 22696, 22697, 7, 5, 0, 0, 22697, 22698, 7, 4, 0, 0, 22698, 22699, 7, 3, + 0, 0, 22699, 22700, 7, 12, 0, 0, 22700, 22701, 7, 8, 0, 0, 22701, 22702, + 7, 4, 0, 0, 22702, 3318, 1, 0, 0, 0, 22703, 22704, 7, 5, 0, 0, 22704, 22705, + 7, 4, 0, 0, 22705, 22706, 7, 3, 0, 0, 22706, 22707, 7, 12, 0, 0, 22707, + 22708, 7, 7, 0, 0, 22708, 22709, 7, 17, 0, 0, 22709, 3320, 1, 0, 0, 0, + 22710, 22711, 7, 5, 0, 0, 22711, 22712, 7, 4, 0, 0, 22712, 22713, 7, 3, + 0, 0, 22713, 22714, 7, 12, 0, 0, 22714, 22715, 7, 15, 0, 0, 22715, 22716, + 7, 6, 0, 0, 22716, 22717, 5, 95, 0, 0, 22717, 22718, 7, 8, 0, 0, 22718, + 22719, 7, 2, 0, 0, 22719, 22720, 7, 11, 0, 0, 22720, 22721, 7, 10, 0, 0, + 22721, 22722, 7, 14, 0, 0, 22722, 22723, 7, 7, 0, 0, 22723, 22724, 7, 5, + 0, 0, 22724, 3322, 1, 0, 0, 0, 22725, 22726, 7, 5, 0, 0, 22726, 22727, + 7, 4, 0, 0, 22727, 22728, 7, 3, 0, 0, 22728, 22729, 7, 12, 0, 0, 22729, + 22730, 7, 15, 0, 0, 22730, 22731, 7, 6, 0, 0, 22731, 22732, 5, 95, 0, 0, + 22732, 22733, 7, 22, 0, 0, 22733, 22734, 7, 12, 0, 0, 22734, 22735, 7, + 9, 0, 0, 22735, 22736, 7, 4, 0, 0, 22736, 22737, 7, 19, 0, 0, 22737, 3324, + 1, 0, 0, 0, 22738, 22739, 7, 5, 0, 0, 22739, 22740, 7, 4, 0, 0, 22740, + 22741, 7, 3, 0, 0, 22741, 22742, 7, 12, 0, 0, 22742, 22743, 7, 15, 0, 0, + 22743, 3326, 1, 0, 0, 0, 22744, 22745, 7, 5, 0, 0, 22745, 22746, 7, 4, + 0, 0, 22746, 22747, 7, 3, 0, 0, 22747, 22748, 7, 10, 0, 0, 22748, 22749, + 7, 8, 0, 0, 22749, 22750, 7, 4, 0, 0, 22750, 22751, 7, 10, 0, 0, 22751, + 22752, 7, 3, 0, 0, 22752, 22753, 7, 6, 0, 0, 22753, 3328, 1, 0, 0, 0, 22754, + 22755, 7, 5, 0, 0, 22755, 22756, 7, 10, 0, 0, 22756, 22757, 7, 1, 0, 0, + 22757, 22758, 7, 14, 0, 0, 22758, 22759, 7, 10, 0, 0, 22759, 22760, 7, + 11, 0, 0, 22760, 22761, 7, 4, 0, 0, 22761, 22762, 7, 12, 0, 0, 22762, 22763, + 7, 5, 0, 0, 22763, 22764, 7, 6, 0, 0, 22764, 22765, 7, 4, 0, 0, 22765, + 3330, 1, 0, 0, 0, 22766, 22767, 7, 5, 0, 0, 22767, 22768, 7, 10, 0, 0, + 22768, 22769, 7, 1, 0, 0, 22769, 22770, 7, 15, 0, 0, 22770, 22771, 7, 0, + 0, 0, 22771, 22772, 7, 3, 0, 0, 22772, 22773, 7, 4, 0, 0, 22773, 22774, + 7, 12, 0, 0, 22774, 22775, 7, 4, 0, 0, 22775, 22776, 7, 12, 0, 0, 22776, + 22777, 7, 2, 0, 0, 22777, 22778, 7, 7, 0, 0, 22778, 22779, 5, 95, 0, 0, + 22779, 22780, 7, 3, 0, 0, 22780, 22781, 7, 6, 0, 0, 22781, 22782, 7, 11, + 0, 0, 22782, 3332, 1, 0, 0, 0, 22783, 22784, 7, 5, 0, 0, 22784, 22785, + 7, 10, 0, 0, 22785, 22786, 7, 1, 0, 0, 22786, 22787, 7, 15, 0, 0, 22787, + 22788, 7, 0, 0, 0, 22788, 22789, 7, 3, 0, 0, 22789, 22790, 7, 4, 0, 0, + 22790, 22791, 7, 12, 0, 0, 22791, 22792, 7, 4, 0, 0, 22792, 22793, 7, 12, + 0, 0, 22793, 22794, 7, 2, 0, 0, 22794, 22795, 7, 7, 0, 0, 22795, 22796, + 7, 5, 0, 0, 22796, 3334, 1, 0, 0, 0, 22797, 22798, 7, 5, 0, 0, 22798, 22799, + 7, 10, 0, 0, 22799, 22800, 7, 1, 0, 0, 22800, 22801, 7, 15, 0, 0, 22801, + 22802, 7, 0, 0, 0, 22802, 22803, 7, 3, 0, 0, 22803, 22804, 7, 4, 0, 0, + 22804, 22805, 7, 12, 0, 0, 22805, 22806, 7, 4, 0, 0, 22806, 22807, 7, 12, + 0, 0, 22807, 22808, 7, 2, 0, 0, 22808, 22809, 7, 7, 0, 0, 22809, 3336, + 1, 0, 0, 0, 22810, 22811, 7, 5, 0, 0, 22811, 22812, 7, 10, 0, 0, 22812, + 22813, 7, 1, 0, 0, 22813, 22814, 7, 24, 0, 0, 22814, 22815, 7, 10, 0, 0, + 22815, 22816, 7, 6, 0, 0, 22816, 22817, 7, 3, 0, 0, 22817, 22818, 7, 12, + 0, 0, 22818, 22819, 7, 6, 0, 0, 22819, 22820, 7, 5, 0, 0, 22820, 3338, + 1, 0, 0, 0, 22821, 22822, 7, 5, 0, 0, 22822, 22823, 7, 10, 0, 0, 22823, + 22824, 7, 1, 0, 0, 22824, 22825, 7, 24, 0, 0, 22825, 22826, 7, 10, 0, 0, + 22826, 22827, 7, 6, 0, 0, 22827, 22828, 7, 3, 0, 0, 22828, 22829, 7, 18, + 0, 0, 22829, 22830, 5, 95, 0, 0, 22830, 22831, 7, 15, 0, 0, 22831, 22832, + 7, 3, 0, 0, 22832, 22833, 7, 10, 0, 0, 22833, 22834, 7, 7, 0, 0, 22834, + 22835, 7, 12, 0, 0, 22835, 22836, 7, 7, 0, 0, 22836, 22837, 7, 17, 0, 0, + 22837, 3340, 1, 0, 0, 0, 22838, 22839, 7, 5, 0, 0, 22839, 22840, 7, 10, + 0, 0, 22840, 22841, 7, 1, 0, 0, 22841, 22842, 7, 5, 0, 0, 22842, 22843, + 7, 8, 0, 0, 22843, 22844, 7, 3, 0, 0, 22844, 22845, 7, 12, 0, 0, 22845, + 22846, 7, 1, 0, 0, 22846, 22847, 7, 6, 0, 0, 22847, 3342, 1, 0, 0, 0, 22848, + 22849, 7, 5, 0, 0, 22849, 22850, 7, 10, 0, 0, 22850, 22851, 7, 1, 0, 0, + 22851, 22852, 7, 5, 0, 0, 22852, 22853, 7, 6, 0, 0, 22853, 22854, 7, 4, + 0, 0, 22854, 3344, 1, 0, 0, 0, 22855, 22856, 7, 5, 0, 0, 22856, 22857, + 7, 10, 0, 0, 22857, 22858, 7, 1, 0, 0, 22858, 22859, 7, 5, 0, 0, 22859, + 22860, 7, 4, 0, 0, 22860, 22861, 7, 12, 0, 0, 22861, 22862, 7, 4, 0, 0, + 22862, 22863, 7, 10, 0, 0, 22863, 22864, 7, 4, 0, 0, 22864, 22865, 7, 0, + 0, 0, 22865, 22866, 7, 1, 0, 0, 22866, 22867, 7, 11, 0, 0, 22867, 22868, + 7, 6, 0, 0, 22868, 3346, 1, 0, 0, 0, 22869, 22870, 7, 5, 0, 0, 22870, 22871, + 7, 10, 0, 0, 22871, 22872, 7, 1, 0, 0, 22872, 22873, 7, 5, 0, 0, 22873, + 22874, 7, 4, 0, 0, 22874, 22875, 7, 3, 0, 0, 22875, 22876, 5, 50, 0, 0, + 22876, 3348, 1, 0, 0, 0, 22877, 22878, 7, 5, 0, 0, 22878, 22879, 7, 10, + 0, 0, 22879, 22880, 7, 1, 0, 0, 22880, 22881, 7, 5, 0, 0, 22881, 22882, + 7, 4, 0, 0, 22882, 22883, 7, 3, 0, 0, 22883, 22884, 5, 52, 0, 0, 22884, + 3350, 1, 0, 0, 0, 22885, 22886, 7, 5, 0, 0, 22886, 22887, 7, 10, 0, 0, + 22887, 22888, 7, 1, 0, 0, 22888, 22889, 7, 5, 0, 0, 22889, 22890, 7, 4, + 0, 0, 22890, 22891, 7, 3, 0, 0, 22891, 22892, 7, 1, 0, 0, 22892, 3352, + 1, 0, 0, 0, 22893, 22894, 7, 5, 0, 0, 22894, 22895, 7, 10, 0, 0, 22895, + 22896, 7, 1, 0, 0, 22896, 22897, 7, 5, 0, 0, 22897, 22898, 7, 4, 0, 0, + 22898, 22899, 7, 3, 0, 0, 22899, 22900, 7, 8, 0, 0, 22900, 3354, 1, 0, + 0, 0, 22901, 22902, 7, 5, 0, 0, 22902, 22903, 7, 10, 0, 0, 22903, 22904, + 7, 1, 0, 0, 22904, 22905, 7, 4, 0, 0, 22905, 22906, 7, 18, 0, 0, 22906, + 22907, 7, 15, 0, 0, 22907, 22908, 7, 6, 0, 0, 22908, 3356, 1, 0, 0, 0, + 22909, 22910, 7, 5, 0, 0, 22910, 22911, 7, 10, 0, 0, 22911, 22912, 7, 8, + 0, 0, 22912, 22913, 7, 8, 0, 0, 22913, 22914, 7, 6, 0, 0, 22914, 22915, + 7, 5, 0, 0, 22915, 22916, 7, 5, 0, 0, 22916, 22917, 7, 16, 0, 0, 22917, + 22918, 7, 10, 0, 0, 22918, 22919, 7, 11, 0, 0, 22919, 3358, 1, 0, 0, 0, + 22920, 22921, 7, 5, 0, 0, 22921, 22922, 7, 10, 0, 0, 22922, 22923, 7, 8, + 0, 0, 22923, 22924, 7, 8, 0, 0, 22924, 22925, 7, 6, 0, 0, 22925, 22926, + 7, 5, 0, 0, 22926, 22927, 7, 5, 0, 0, 22927, 3360, 1, 0, 0, 0, 22928, 22929, + 7, 5, 0, 0, 22929, 22930, 7, 10, 0, 0, 22930, 22931, 7, 14, 0, 0, 22931, + 22932, 7, 14, 0, 0, 22932, 22933, 7, 0, 0, 0, 22933, 22934, 7, 3, 0, 0, + 22934, 22935, 7, 18, 0, 0, 22935, 3362, 1, 0, 0, 0, 22936, 22937, 7, 5, + 0, 0, 22937, 22938, 7, 10, 0, 0, 22938, 22939, 7, 15, 0, 0, 22939, 22940, + 7, 15, 0, 0, 22940, 22941, 7, 11, 0, 0, 22941, 22942, 7, 6, 0, 0, 22942, + 22943, 7, 14, 0, 0, 22943, 22944, 7, 6, 0, 0, 22944, 22945, 7, 7, 0, 0, + 22945, 22946, 7, 4, 0, 0, 22946, 22947, 7, 0, 0, 0, 22947, 22948, 7, 11, + 0, 0, 22948, 3364, 1, 0, 0, 0, 22949, 22950, 7, 5, 0, 0, 22950, 22951, + 7, 10, 0, 0, 22951, 22952, 7, 5, 0, 0, 22952, 22953, 7, 15, 0, 0, 22953, + 22954, 7, 6, 0, 0, 22954, 22955, 7, 7, 0, 0, 22955, 22956, 7, 9, 0, 0, + 22956, 3366, 1, 0, 0, 0, 22957, 22958, 7, 5, 0, 0, 22958, 22959, 7, 22, + 0, 0, 22959, 22960, 7, 0, 0, 0, 22960, 22961, 7, 15, 0, 0, 22961, 22962, + 5, 95, 0, 0, 22962, 22963, 7, 20, 0, 0, 22963, 22964, 7, 2, 0, 0, 22964, + 22965, 7, 12, 0, 0, 22965, 22966, 7, 7, 0, 0, 22966, 22967, 5, 95, 0, 0, + 22967, 22968, 7, 12, 0, 0, 22968, 22969, 7, 7, 0, 0, 22969, 22970, 7, 15, + 0, 0, 22970, 22971, 7, 10, 0, 0, 22971, 22972, 7, 4, 0, 0, 22972, 22973, + 7, 5, 0, 0, 22973, 3368, 1, 0, 0, 0, 22974, 22975, 7, 5, 0, 0, 22975, 22976, + 7, 22, 0, 0, 22976, 22977, 7, 12, 0, 0, 22977, 22978, 7, 4, 0, 0, 22978, + 22979, 7, 8, 0, 0, 22979, 22980, 7, 19, 0, 0, 22980, 22981, 7, 2, 0, 0, + 22981, 22982, 7, 13, 0, 0, 22982, 22983, 7, 6, 0, 0, 22983, 22984, 7, 3, + 0, 0, 22984, 3370, 1, 0, 0, 0, 22985, 22986, 7, 5, 0, 0, 22986, 22987, + 7, 22, 0, 0, 22987, 22988, 7, 12, 0, 0, 22988, 22989, 7, 4, 0, 0, 22989, + 22990, 7, 8, 0, 0, 22990, 22991, 7, 19, 0, 0, 22991, 3372, 1, 0, 0, 0, + 22992, 22993, 7, 5, 0, 0, 22993, 22994, 7, 18, 0, 0, 22994, 22995, 7, 7, + 0, 0, 22995, 22996, 7, 8, 0, 0, 22996, 22997, 7, 19, 0, 0, 22997, 22998, + 7, 3, 0, 0, 22998, 22999, 7, 2, 0, 0, 22999, 23000, 7, 7, 0, 0, 23000, + 23001, 7, 2, 0, 0, 23001, 23002, 7, 10, 0, 0, 23002, 23003, 7, 5, 0, 0, + 23003, 3374, 1, 0, 0, 0, 23004, 23005, 7, 5, 0, 0, 23005, 23006, 7, 18, + 0, 0, 23006, 23007, 7, 7, 0, 0, 23007, 23008, 7, 8, 0, 0, 23008, 3376, + 1, 0, 0, 0, 23009, 23010, 7, 5, 0, 0, 23010, 23011, 7, 18, 0, 0, 23011, + 23012, 7, 7, 0, 0, 23012, 23013, 7, 2, 0, 0, 23013, 23014, 7, 7, 0, 0, + 23014, 23015, 7, 18, 0, 0, 23015, 23016, 7, 14, 0, 0, 23016, 3378, 1, 0, + 0, 0, 23017, 23018, 7, 5, 0, 0, 23018, 23019, 7, 18, 0, 0, 23019, 23020, + 7, 5, 0, 0, 23020, 3380, 1, 0, 0, 0, 23021, 23022, 7, 5, 0, 0, 23022, 23023, + 7, 18, 0, 0, 23023, 23024, 7, 5, 0, 0, 23024, 23025, 7, 0, 0, 0, 23025, + 23026, 7, 5, 0, 0, 23026, 23027, 7, 14, 0, 0, 23027, 3382, 1, 0, 0, 0, + 23028, 23029, 7, 5, 0, 0, 23029, 23030, 7, 18, 0, 0, 23030, 23031, 7, 5, + 0, 0, 23031, 23032, 5, 95, 0, 0, 23032, 23033, 7, 0, 0, 0, 23033, 23034, + 7, 10, 0, 0, 23034, 23035, 7, 9, 0, 0, 23035, 23036, 7, 12, 0, 0, 23036, + 23037, 7, 4, 0, 0, 23037, 3384, 1, 0, 0, 0, 23038, 23039, 7, 5, 0, 0, 23039, + 23040, 7, 18, 0, 0, 23040, 23041, 7, 5, 0, 0, 23041, 23042, 7, 0, 0, 0, + 23042, 23043, 7, 10, 0, 0, 23043, 23044, 7, 25, 0, 0, 23044, 3386, 1, 0, + 0, 0, 23045, 23046, 7, 5, 0, 0, 23046, 23047, 7, 18, 0, 0, 23047, 23048, + 7, 5, 0, 0, 23048, 23049, 7, 1, 0, 0, 23049, 23050, 7, 0, 0, 0, 23050, + 23051, 7, 8, 0, 0, 23051, 23052, 7, 21, 0, 0, 23052, 23053, 7, 10, 0, 0, + 23053, 23054, 7, 15, 0, 0, 23054, 3388, 1, 0, 0, 0, 23055, 23056, 7, 5, + 0, 0, 23056, 23057, 7, 18, 0, 0, 23057, 23058, 7, 5, 0, 0, 23058, 23059, + 5, 95, 0, 0, 23059, 23060, 7, 8, 0, 0, 23060, 23061, 7, 19, 0, 0, 23061, + 23062, 7, 6, 0, 0, 23062, 23063, 7, 8, 0, 0, 23063, 23064, 7, 21, 0, 0, + 23064, 23065, 7, 0, 0, 0, 23065, 23066, 7, 8, 0, 0, 23066, 23067, 7, 11, + 0, 0, 23067, 3390, 1, 0, 0, 0, 23068, 23069, 7, 5, 0, 0, 23069, 23070, + 7, 18, 0, 0, 23070, 23071, 7, 5, 0, 0, 23071, 23072, 5, 95, 0, 0, 23072, + 23073, 7, 8, 0, 0, 23073, 23074, 7, 19, 0, 0, 23074, 23075, 7, 6, 0, 0, + 23075, 23076, 7, 8, 0, 0, 23076, 23077, 7, 21, 0, 0, 23077, 23078, 5, 95, + 0, 0, 23078, 23079, 7, 15, 0, 0, 23079, 23080, 7, 3, 0, 0, 23080, 23081, + 7, 12, 0, 0, 23081, 23082, 7, 13, 0, 0, 23082, 23083, 7, 12, 0, 0, 23083, + 23084, 7, 11, 0, 0, 23084, 23085, 7, 6, 0, 0, 23085, 23086, 7, 17, 0, 0, + 23086, 23087, 7, 6, 0, 0, 23087, 3392, 1, 0, 0, 0, 23088, 23089, 7, 5, + 0, 0, 23089, 23090, 7, 18, 0, 0, 23090, 23091, 7, 5, 0, 0, 23091, 23092, + 5, 95, 0, 0, 23092, 23093, 7, 8, 0, 0, 23093, 23094, 7, 2, 0, 0, 23094, + 23095, 7, 7, 0, 0, 23095, 23096, 7, 7, 0, 0, 23096, 23097, 7, 6, 0, 0, + 23097, 23098, 7, 8, 0, 0, 23098, 23099, 7, 4, 0, 0, 23099, 23100, 5, 95, + 0, 0, 23100, 23101, 7, 1, 0, 0, 23101, 23102, 7, 18, 0, 0, 23102, 23103, + 5, 95, 0, 0, 23103, 23104, 7, 15, 0, 0, 23104, 23105, 7, 0, 0, 0, 23105, + 23106, 7, 4, 0, 0, 23106, 23107, 7, 19, 0, 0, 23107, 3394, 1, 0, 0, 0, + 23108, 23109, 7, 5, 0, 0, 23109, 23110, 7, 18, 0, 0, 23110, 23111, 7, 5, + 0, 0, 23111, 23112, 5, 95, 0, 0, 23112, 23113, 7, 8, 0, 0, 23113, 23114, + 7, 2, 0, 0, 23114, 23115, 7, 7, 0, 0, 23115, 23116, 7, 4, 0, 0, 23116, + 23117, 7, 6, 0, 0, 23117, 23118, 7, 25, 0, 0, 23118, 23119, 7, 4, 0, 0, + 23119, 3396, 1, 0, 0, 0, 23120, 23121, 7, 5, 0, 0, 23121, 23122, 7, 18, + 0, 0, 23122, 23123, 7, 5, 0, 0, 23123, 23124, 7, 9, 0, 0, 23124, 23125, + 7, 0, 0, 0, 23125, 23126, 7, 4, 0, 0, 23126, 23127, 7, 6, 0, 0, 23127, + 3398, 1, 0, 0, 0, 23128, 23129, 7, 5, 0, 0, 23129, 23130, 7, 18, 0, 0, + 23130, 23131, 7, 5, 0, 0, 23131, 23132, 7, 9, 0, 0, 23132, 23133, 7, 1, + 0, 0, 23133, 23134, 7, 0, 0, 0, 23134, 3400, 1, 0, 0, 0, 23135, 23136, + 7, 5, 0, 0, 23136, 23137, 7, 18, 0, 0, 23137, 23138, 7, 5, 0, 0, 23138, + 23139, 5, 95, 0, 0, 23139, 23140, 7, 9, 0, 0, 23140, 23141, 7, 1, 0, 0, + 23141, 23142, 7, 10, 0, 0, 23142, 23143, 7, 3, 0, 0, 23143, 23144, 7, 12, + 0, 0, 23144, 23145, 7, 17, 0, 0, 23145, 23146, 7, 6, 0, 0, 23146, 23147, + 7, 7, 0, 0, 23147, 3402, 1, 0, 0, 0, 23148, 23149, 7, 5, 0, 0, 23149, 23150, + 7, 18, 0, 0, 23150, 23151, 7, 5, 0, 0, 23151, 23152, 7, 9, 0, 0, 23152, + 23153, 7, 17, 0, 0, 23153, 3404, 1, 0, 0, 0, 23154, 23155, 7, 5, 0, 0, + 23155, 23156, 7, 18, 0, 0, 23156, 23157, 7, 5, 0, 0, 23157, 23158, 5, 95, + 0, 0, 23158, 23159, 7, 9, 0, 0, 23159, 23160, 7, 11, 0, 0, 23160, 23161, + 5, 95, 0, 0, 23161, 23162, 7, 8, 0, 0, 23162, 23163, 7, 10, 0, 0, 23163, + 23164, 7, 3, 0, 0, 23164, 23165, 7, 5, 0, 0, 23165, 23166, 7, 2, 0, 0, + 23166, 23167, 7, 3, 0, 0, 23167, 3406, 1, 0, 0, 0, 23168, 23169, 7, 5, + 0, 0, 23169, 23170, 7, 18, 0, 0, 23170, 23171, 7, 5, 0, 0, 23171, 23172, + 5, 95, 0, 0, 23172, 23173, 7, 9, 0, 0, 23173, 23174, 7, 14, 0, 0, 23174, + 23175, 5, 95, 0, 0, 23175, 23176, 7, 3, 0, 0, 23176, 23177, 7, 25, 0, 0, + 23177, 23178, 7, 16, 0, 0, 23178, 23179, 7, 2, 0, 0, 23179, 23180, 7, 3, + 0, 0, 23180, 23181, 7, 14, 0, 0, 23181, 23182, 5, 95, 0, 0, 23182, 23183, + 7, 8, 0, 0, 23183, 23184, 7, 19, 0, 0, 23184, 23185, 7, 3, 0, 0, 23185, + 3408, 1, 0, 0, 0, 23186, 23187, 7, 5, 0, 0, 23187, 23188, 7, 18, 0, 0, + 23188, 23189, 7, 5, 0, 0, 23189, 23190, 5, 95, 0, 0, 23190, 23191, 7, 9, + 0, 0, 23191, 23192, 7, 14, 0, 0, 23192, 23193, 5, 95, 0, 0, 23193, 23194, + 7, 3, 0, 0, 23194, 23195, 7, 25, 0, 0, 23195, 23196, 7, 16, 0, 0, 23196, + 23197, 7, 2, 0, 0, 23197, 23198, 7, 3, 0, 0, 23198, 23199, 7, 14, 0, 0, + 23199, 23200, 5, 95, 0, 0, 23200, 23201, 7, 7, 0, 0, 23201, 23202, 7, 10, + 0, 0, 23202, 23203, 7, 14, 0, 0, 23203, 3410, 1, 0, 0, 0, 23204, 23205, + 7, 5, 0, 0, 23205, 23206, 7, 18, 0, 0, 23206, 23207, 7, 5, 0, 0, 23207, + 23208, 5, 95, 0, 0, 23208, 23209, 7, 9, 0, 0, 23209, 23210, 7, 2, 0, 0, + 23210, 23211, 7, 14, 0, 0, 23211, 23212, 5, 95, 0, 0, 23212, 23213, 7, + 8, 0, 0, 23213, 23214, 7, 2, 0, 0, 23214, 23215, 7, 14, 0, 0, 23215, 23216, + 7, 15, 0, 0, 23216, 23217, 7, 0, 0, 0, 23217, 23218, 7, 3, 0, 0, 23218, + 23219, 7, 6, 0, 0, 23219, 3412, 1, 0, 0, 0, 23220, 23221, 7, 5, 0, 0, 23221, + 23222, 7, 18, 0, 0, 23222, 23223, 7, 5, 0, 0, 23223, 23224, 5, 95, 0, 0, + 23224, 23225, 7, 9, 0, 0, 23225, 23226, 7, 5, 0, 0, 23226, 23227, 7, 4, + 0, 0, 23227, 23228, 5, 95, 0, 0, 23228, 23229, 7, 15, 0, 0, 23229, 23230, + 7, 3, 0, 0, 23230, 23231, 7, 12, 0, 0, 23231, 23232, 7, 14, 0, 0, 23232, + 23233, 5, 50, 0, 0, 23233, 23234, 7, 5, 0, 0, 23234, 23235, 7, 6, 0, 0, + 23235, 23236, 7, 8, 0, 0, 23236, 3414, 1, 0, 0, 0, 23237, 23238, 7, 5, + 0, 0, 23238, 23239, 7, 18, 0, 0, 23239, 23240, 7, 5, 0, 0, 23240, 23241, + 5, 95, 0, 0, 23241, 23242, 7, 9, 0, 0, 23242, 23243, 7, 5, 0, 0, 23243, + 23244, 7, 4, 0, 0, 23244, 23245, 5, 95, 0, 0, 23245, 23246, 7, 5, 0, 0, + 23246, 23247, 7, 6, 0, 0, 23247, 23248, 7, 8, 0, 0, 23248, 23249, 5, 50, + 0, 0, 23249, 23250, 7, 15, 0, 0, 23250, 23251, 7, 3, 0, 0, 23251, 23252, + 7, 12, 0, 0, 23252, 23253, 7, 14, 0, 0, 23253, 3416, 1, 0, 0, 0, 23254, + 23255, 7, 5, 0, 0, 23255, 23256, 7, 18, 0, 0, 23256, 23257, 7, 5, 0, 0, + 23257, 23258, 5, 95, 0, 0, 23258, 23259, 7, 6, 0, 0, 23259, 23260, 7, 4, + 0, 0, 23260, 23261, 5, 95, 0, 0, 23261, 23262, 7, 1, 0, 0, 23262, 23263, + 7, 16, 0, 0, 23263, 23264, 7, 12, 0, 0, 23264, 23265, 7, 11, 0, 0, 23265, + 23266, 7, 6, 0, 0, 23266, 23267, 5, 95, 0, 0, 23267, 23268, 7, 4, 0, 0, + 23268, 23269, 7, 2, 0, 0, 23269, 23270, 5, 95, 0, 0, 23270, 23271, 7, 3, + 0, 0, 23271, 23272, 7, 0, 0, 0, 23272, 23273, 7, 22, 0, 0, 23273, 3418, + 1, 0, 0, 0, 23274, 23275, 7, 5, 0, 0, 23275, 23276, 7, 18, 0, 0, 23276, + 23277, 7, 5, 0, 0, 23277, 23278, 5, 95, 0, 0, 23278, 23279, 7, 6, 0, 0, + 23279, 23280, 7, 4, 0, 0, 23280, 23281, 5, 95, 0, 0, 23281, 23282, 7, 1, + 0, 0, 23282, 23283, 7, 11, 0, 0, 23283, 23284, 7, 2, 0, 0, 23284, 23285, + 7, 1, 0, 0, 23285, 23286, 5, 95, 0, 0, 23286, 23287, 7, 4, 0, 0, 23287, + 23288, 7, 2, 0, 0, 23288, 23289, 5, 95, 0, 0, 23289, 23290, 7, 12, 0, 0, + 23290, 23291, 7, 14, 0, 0, 23291, 23292, 7, 0, 0, 0, 23292, 23293, 7, 17, + 0, 0, 23293, 23294, 7, 6, 0, 0, 23294, 3420, 1, 0, 0, 0, 23295, 23296, + 7, 5, 0, 0, 23296, 23297, 7, 18, 0, 0, 23297, 23298, 7, 5, 0, 0, 23298, + 23299, 5, 95, 0, 0, 23299, 23300, 7, 6, 0, 0, 23300, 23301, 7, 4, 0, 0, + 23301, 23302, 5, 95, 0, 0, 23302, 23303, 7, 12, 0, 0, 23303, 23304, 7, + 14, 0, 0, 23304, 23305, 7, 0, 0, 0, 23305, 23306, 7, 17, 0, 0, 23306, 23307, + 7, 6, 0, 0, 23307, 23308, 5, 95, 0, 0, 23308, 23309, 7, 4, 0, 0, 23309, + 23310, 7, 2, 0, 0, 23310, 23311, 5, 95, 0, 0, 23311, 23312, 7, 1, 0, 0, + 23312, 23313, 7, 11, 0, 0, 23313, 23314, 7, 2, 0, 0, 23314, 23315, 7, 1, + 0, 0, 23315, 3422, 1, 0, 0, 0, 23316, 23317, 7, 5, 0, 0, 23317, 23318, + 7, 18, 0, 0, 23318, 23319, 7, 5, 0, 0, 23319, 23320, 5, 95, 0, 0, 23320, + 23321, 7, 6, 0, 0, 23321, 23322, 7, 4, 0, 0, 23322, 23323, 5, 95, 0, 0, + 23323, 23324, 7, 3, 0, 0, 23324, 23325, 7, 0, 0, 0, 23325, 23326, 7, 22, + 0, 0, 23326, 23327, 5, 95, 0, 0, 23327, 23328, 7, 4, 0, 0, 23328, 23329, + 7, 2, 0, 0, 23329, 23330, 5, 95, 0, 0, 23330, 23331, 7, 1, 0, 0, 23331, + 23332, 7, 16, 0, 0, 23332, 23333, 7, 12, 0, 0, 23333, 23334, 7, 11, 0, + 0, 23334, 23335, 7, 6, 0, 0, 23335, 3424, 1, 0, 0, 0, 23336, 23337, 7, + 5, 0, 0, 23337, 23338, 7, 18, 0, 0, 23338, 23339, 7, 5, 0, 0, 23339, 23340, + 5, 95, 0, 0, 23340, 23341, 7, 6, 0, 0, 23341, 23342, 7, 25, 0, 0, 23342, + 23343, 7, 4, 0, 0, 23343, 23344, 7, 15, 0, 0, 23344, 23345, 7, 9, 0, 0, + 23345, 23346, 7, 4, 0, 0, 23346, 23347, 7, 25, 0, 0, 23347, 23348, 7, 4, + 0, 0, 23348, 3426, 1, 0, 0, 0, 23349, 23350, 7, 5, 0, 0, 23350, 23351, + 7, 18, 0, 0, 23351, 23352, 7, 5, 0, 0, 23352, 23353, 5, 95, 0, 0, 23353, + 23354, 7, 6, 0, 0, 23354, 23355, 7, 25, 0, 0, 23355, 23356, 7, 4, 0, 0, + 23356, 23357, 7, 3, 0, 0, 23357, 23358, 7, 0, 0, 0, 23358, 23359, 7, 8, + 0, 0, 23359, 23360, 7, 4, 0, 0, 23360, 23361, 5, 95, 0, 0, 23361, 23362, + 7, 10, 0, 0, 23362, 23363, 7, 4, 0, 0, 23363, 23364, 7, 8, 0, 0, 23364, + 3428, 1, 0, 0, 0, 23365, 23366, 7, 5, 0, 0, 23366, 23367, 7, 18, 0, 0, + 23367, 23368, 7, 5, 0, 0, 23368, 23369, 5, 95, 0, 0, 23369, 23370, 7, 16, + 0, 0, 23370, 23371, 7, 1, 0, 0, 23371, 23372, 7, 4, 0, 0, 23372, 23373, + 5, 95, 0, 0, 23373, 23374, 7, 12, 0, 0, 23374, 23375, 7, 7, 0, 0, 23375, + 23376, 7, 5, 0, 0, 23376, 23377, 7, 9, 0, 0, 23377, 23378, 7, 6, 0, 0, + 23378, 23379, 7, 11, 0, 0, 23379, 3430, 1, 0, 0, 0, 23380, 23381, 7, 5, + 0, 0, 23381, 23382, 7, 18, 0, 0, 23382, 23383, 7, 5, 0, 0, 23383, 23384, + 5, 95, 0, 0, 23384, 23385, 7, 16, 0, 0, 23385, 23386, 7, 12, 0, 0, 23386, + 23387, 7, 11, 0, 0, 23387, 23388, 7, 4, 0, 0, 23388, 23389, 7, 6, 0, 0, + 23389, 23390, 7, 3, 0, 0, 23390, 23391, 5, 95, 0, 0, 23391, 23392, 7, 0, + 0, 0, 23392, 23393, 7, 8, 0, 0, 23393, 23394, 7, 11, 0, 0, 23394, 23395, + 7, 5, 0, 0, 23395, 3432, 1, 0, 0, 0, 23396, 23397, 7, 5, 0, 0, 23397, 23398, + 7, 18, 0, 0, 23398, 23399, 7, 5, 0, 0, 23399, 23400, 5, 95, 0, 0, 23400, + 23401, 7, 16, 0, 0, 23401, 23402, 7, 7, 0, 0, 23402, 23403, 7, 14, 0, 0, + 23403, 23404, 7, 0, 0, 0, 23404, 23405, 7, 4, 0, 0, 23405, 23406, 7, 8, + 0, 0, 23406, 23407, 7, 19, 0, 0, 23407, 23408, 7, 6, 0, 0, 23408, 23409, + 7, 5, 0, 0, 23409, 3434, 1, 0, 0, 0, 23410, 23411, 7, 5, 0, 0, 23411, 23412, + 7, 18, 0, 0, 23412, 23413, 7, 5, 0, 0, 23413, 23414, 5, 95, 0, 0, 23414, + 23415, 7, 16, 0, 0, 23415, 23416, 7, 7, 0, 0, 23416, 23417, 7, 3, 0, 0, + 23417, 23418, 7, 6, 0, 0, 23418, 23419, 7, 15, 0, 0, 23419, 23420, 7, 11, + 0, 0, 23420, 23421, 7, 0, 0, 0, 23421, 23422, 7, 8, 0, 0, 23422, 23423, + 7, 6, 0, 0, 23423, 3436, 1, 0, 0, 0, 23424, 23425, 7, 5, 0, 0, 23425, 23426, + 7, 18, 0, 0, 23426, 23427, 7, 5, 0, 0, 23427, 23428, 5, 95, 0, 0, 23428, + 23429, 7, 17, 0, 0, 23429, 23430, 7, 6, 0, 0, 23430, 23431, 7, 4, 0, 0, + 23431, 23432, 5, 95, 0, 0, 23432, 23433, 7, 0, 0, 0, 23433, 23434, 7, 8, + 0, 0, 23434, 23435, 7, 11, 0, 0, 23435, 23436, 7, 12, 0, 0, 23436, 23437, + 7, 9, 0, 0, 23437, 23438, 7, 5, 0, 0, 23438, 3438, 1, 0, 0, 0, 23439, 23440, + 7, 5, 0, 0, 23440, 23441, 7, 18, 0, 0, 23441, 23442, 7, 5, 0, 0, 23442, + 23443, 5, 95, 0, 0, 23443, 23444, 7, 17, 0, 0, 23444, 23445, 7, 6, 0, 0, + 23445, 23446, 7, 4, 0, 0, 23446, 23447, 5, 95, 0, 0, 23447, 23448, 7, 8, + 0, 0, 23448, 23449, 7, 2, 0, 0, 23449, 23450, 7, 11, 0, 0, 23450, 23451, + 5, 95, 0, 0, 23451, 23452, 7, 0, 0, 0, 23452, 23453, 7, 8, 0, 0, 23453, + 23454, 7, 11, 0, 0, 23454, 23455, 7, 12, 0, 0, 23455, 23456, 7, 9, 0, 0, + 23456, 23457, 7, 5, 0, 0, 23457, 3440, 1, 0, 0, 0, 23458, 23459, 7, 5, + 0, 0, 23459, 23460, 7, 18, 0, 0, 23460, 23461, 7, 5, 0, 0, 23461, 23462, + 5, 95, 0, 0, 23462, 23463, 7, 17, 0, 0, 23463, 23464, 7, 6, 0, 0, 23464, + 23465, 7, 4, 0, 0, 23465, 23466, 5, 95, 0, 0, 23466, 23467, 7, 15, 0, 0, + 23467, 23468, 7, 3, 0, 0, 23468, 23469, 7, 12, 0, 0, 23469, 23470, 7, 13, + 0, 0, 23470, 23471, 7, 12, 0, 0, 23471, 23472, 7, 11, 0, 0, 23472, 23473, + 7, 6, 0, 0, 23473, 23474, 7, 17, 0, 0, 23474, 23475, 7, 6, 0, 0, 23475, + 23476, 7, 5, 0, 0, 23476, 3442, 1, 0, 0, 0, 23477, 23478, 7, 5, 0, 0, 23478, + 23479, 7, 18, 0, 0, 23479, 23480, 7, 5, 0, 0, 23480, 23481, 5, 95, 0, 0, + 23481, 23482, 7, 17, 0, 0, 23482, 23483, 7, 6, 0, 0, 23483, 23484, 7, 4, + 0, 0, 23484, 23485, 7, 4, 0, 0, 23485, 23486, 7, 2, 0, 0, 23486, 23487, + 7, 21, 0, 0, 23487, 23488, 7, 6, 0, 0, 23488, 23489, 7, 7, 0, 0, 23489, + 23490, 7, 12, 0, 0, 23490, 23491, 7, 9, 0, 0, 23491, 3444, 1, 0, 0, 0, + 23492, 23493, 7, 5, 0, 0, 23493, 23494, 7, 18, 0, 0, 23494, 23495, 7, 5, + 0, 0, 23495, 23496, 5, 95, 0, 0, 23496, 23497, 7, 17, 0, 0, 23497, 23498, + 7, 6, 0, 0, 23498, 23499, 7, 4, 0, 0, 23499, 23500, 7, 25, 0, 0, 23500, + 23501, 7, 4, 0, 0, 23501, 23502, 7, 12, 0, 0, 23502, 23503, 7, 13, 0, 0, + 23503, 23504, 7, 0, 0, 0, 23504, 23505, 7, 11, 0, 0, 23505, 3446, 1, 0, + 0, 0, 23506, 23507, 7, 5, 0, 0, 23507, 23508, 7, 18, 0, 0, 23508, 23509, + 7, 5, 0, 0, 23509, 23510, 5, 95, 0, 0, 23510, 23511, 7, 17, 0, 0, 23511, + 23512, 7, 10, 0, 0, 23512, 23513, 7, 12, 0, 0, 23513, 23514, 7, 9, 0, 0, + 23514, 3448, 1, 0, 0, 0, 23515, 23516, 7, 5, 0, 0, 23516, 23517, 7, 18, + 0, 0, 23517, 23518, 7, 5, 0, 0, 23518, 23519, 7, 17, 0, 0, 23519, 23520, + 7, 10, 0, 0, 23520, 23521, 7, 12, 0, 0, 23521, 23522, 7, 9, 0, 0, 23522, + 3450, 1, 0, 0, 0, 23523, 23524, 7, 5, 0, 0, 23524, 23525, 7, 18, 0, 0, + 23525, 23526, 7, 5, 0, 0, 23526, 23527, 7, 21, 0, 0, 23527, 23528, 7, 14, + 0, 0, 23528, 3452, 1, 0, 0, 0, 23529, 23530, 7, 5, 0, 0, 23530, 23531, + 7, 18, 0, 0, 23531, 23532, 7, 5, 0, 0, 23532, 23533, 5, 95, 0, 0, 23533, + 23534, 7, 14, 0, 0, 23534, 23535, 7, 0, 0, 0, 23535, 23536, 7, 21, 0, 0, + 23536, 23537, 7, 6, 0, 0, 23537, 23538, 5, 95, 0, 0, 23538, 23539, 7, 25, + 0, 0, 23539, 23540, 7, 14, 0, 0, 23540, 23541, 7, 11, 0, 0, 23541, 23542, + 7, 7, 0, 0, 23542, 23543, 7, 2, 0, 0, 23543, 23544, 7, 9, 0, 0, 23544, + 23545, 7, 6, 0, 0, 23545, 23546, 7, 12, 0, 0, 23546, 23547, 7, 9, 0, 0, + 23547, 3454, 1, 0, 0, 0, 23548, 23549, 7, 5, 0, 0, 23549, 23550, 7, 18, + 0, 0, 23550, 23551, 7, 5, 0, 0, 23551, 23552, 5, 95, 0, 0, 23552, 23553, + 7, 14, 0, 0, 23553, 23554, 7, 0, 0, 0, 23554, 23555, 7, 21, 0, 0, 23555, + 23556, 7, 6, 0, 0, 23556, 23557, 7, 25, 0, 0, 23557, 23558, 7, 14, 0, 0, + 23558, 23559, 7, 11, 0, 0, 23559, 3456, 1, 0, 0, 0, 23560, 23561, 7, 5, + 0, 0, 23561, 23562, 7, 18, 0, 0, 23562, 23563, 7, 5, 0, 0, 23563, 23564, + 5, 95, 0, 0, 23564, 23565, 7, 14, 0, 0, 23565, 23566, 7, 21, 0, 0, 23566, + 23567, 7, 25, 0, 0, 23567, 23568, 7, 14, 0, 0, 23568, 23569, 7, 11, 0, + 0, 23569, 23570, 7, 0, 0, 0, 23570, 23571, 7, 4, 0, 0, 23571, 23572, 7, + 4, 0, 0, 23572, 23573, 7, 3, 0, 0, 23573, 3458, 1, 0, 0, 0, 23574, 23575, + 7, 5, 0, 0, 23575, 23576, 7, 18, 0, 0, 23576, 23577, 7, 5, 0, 0, 23577, + 23578, 5, 95, 0, 0, 23578, 23579, 7, 14, 0, 0, 23579, 23580, 7, 21, 0, + 0, 23580, 23581, 7, 25, 0, 0, 23581, 23582, 7, 4, 0, 0, 23582, 23583, 7, + 12, 0, 0, 23583, 3460, 1, 0, 0, 0, 23584, 23585, 7, 5, 0, 0, 23585, 23586, + 7, 18, 0, 0, 23586, 23587, 7, 5, 0, 0, 23587, 23588, 7, 2, 0, 0, 23588, + 23589, 7, 1, 0, 0, 23589, 23590, 7, 20, 0, 0, 23590, 3462, 1, 0, 0, 0, + 23591, 23592, 7, 5, 0, 0, 23592, 23593, 7, 18, 0, 0, 23593, 23594, 7, 5, + 0, 0, 23594, 23595, 5, 95, 0, 0, 23595, 23596, 7, 2, 0, 0, 23596, 23597, + 7, 15, 0, 0, 23597, 23598, 5, 95, 0, 0, 23598, 23599, 7, 0, 0, 0, 23599, + 23600, 7, 9, 0, 0, 23600, 23601, 7, 4, 0, 0, 23601, 23602, 5, 50, 0, 0, + 23602, 23603, 7, 1, 0, 0, 23603, 23604, 7, 12, 0, 0, 23604, 23605, 7, 7, + 0, 0, 23605, 3464, 1, 0, 0, 0, 23606, 23607, 7, 5, 0, 0, 23607, 23608, + 7, 18, 0, 0, 23608, 23609, 7, 5, 0, 0, 23609, 23610, 5, 95, 0, 0, 23610, + 23611, 7, 2, 0, 0, 23611, 23612, 7, 15, 0, 0, 23612, 23613, 5, 95, 0, 0, + 23613, 23614, 7, 0, 0, 0, 23614, 23615, 7, 9, 0, 0, 23615, 23616, 7, 4, + 0, 0, 23616, 23617, 7, 8, 0, 0, 23617, 23618, 7, 2, 0, 0, 23618, 23619, + 7, 7, 0, 0, 23619, 23620, 7, 5, 0, 0, 23620, 3466, 1, 0, 0, 0, 23621, 23622, + 7, 5, 0, 0, 23622, 23623, 7, 18, 0, 0, 23623, 23624, 7, 5, 0, 0, 23624, + 23625, 5, 95, 0, 0, 23625, 23626, 7, 2, 0, 0, 23626, 23627, 7, 15, 0, 0, + 23627, 23628, 5, 95, 0, 0, 23628, 23629, 7, 0, 0, 0, 23629, 23630, 7, 11, + 0, 0, 23630, 23631, 7, 5, 0, 0, 23631, 23632, 7, 8, 0, 0, 23632, 23633, + 7, 3, 0, 0, 23633, 23634, 7, 13, 0, 0, 23634, 23635, 7, 0, 0, 0, 23635, + 23636, 7, 11, 0, 0, 23636, 3468, 1, 0, 0, 0, 23637, 23638, 7, 5, 0, 0, + 23638, 23639, 7, 18, 0, 0, 23639, 23640, 7, 5, 0, 0, 23640, 23641, 5, 95, + 0, 0, 23641, 23642, 7, 2, 0, 0, 23642, 23643, 7, 15, 0, 0, 23643, 23644, + 5, 95, 0, 0, 23644, 23645, 7, 0, 0, 0, 23645, 23646, 7, 4, 0, 0, 23646, + 23647, 7, 17, 0, 0, 23647, 3470, 1, 0, 0, 0, 23648, 23649, 7, 5, 0, 0, + 23649, 23650, 7, 18, 0, 0, 23650, 23651, 7, 5, 0, 0, 23651, 23652, 5, 95, + 0, 0, 23652, 23653, 7, 2, 0, 0, 23653, 23654, 7, 15, 0, 0, 23654, 23655, + 5, 95, 0, 0, 23655, 23656, 7, 1, 0, 0, 23656, 23657, 7, 12, 0, 0, 23657, + 23658, 7, 7, 0, 0, 23658, 23659, 5, 50, 0, 0, 23659, 23660, 7, 0, 0, 0, + 23660, 23661, 7, 9, 0, 0, 23661, 23662, 7, 4, 0, 0, 23662, 3472, 1, 0, + 0, 0, 23663, 23664, 7, 5, 0, 0, 23664, 23665, 7, 18, 0, 0, 23665, 23666, + 7, 5, 0, 0, 23666, 23667, 5, 95, 0, 0, 23667, 23668, 7, 2, 0, 0, 23668, + 23669, 7, 15, 0, 0, 23669, 23670, 5, 95, 0, 0, 23670, 23671, 7, 1, 0, 0, + 23671, 23672, 7, 12, 0, 0, 23672, 23673, 7, 4, 0, 0, 23673, 23674, 7, 13, + 0, 0, 23674, 23675, 7, 6, 0, 0, 23675, 23676, 7, 8, 0, 0, 23676, 3474, + 1, 0, 0, 0, 23677, 23678, 7, 5, 0, 0, 23678, 23679, 7, 18, 0, 0, 23679, + 23680, 7, 5, 0, 0, 23680, 23681, 5, 95, 0, 0, 23681, 23682, 7, 2, 0, 0, + 23682, 23683, 7, 15, 0, 0, 23683, 23684, 5, 95, 0, 0, 23684, 23685, 7, + 1, 0, 0, 23685, 23686, 7, 11, 0, 0, 23686, 23687, 5, 50, 0, 0, 23687, 23688, + 7, 3, 0, 0, 23688, 3476, 1, 0, 0, 0, 23689, 23690, 7, 5, 0, 0, 23690, 23691, + 7, 18, 0, 0, 23691, 23692, 7, 5, 0, 0, 23692, 23693, 5, 95, 0, 0, 23693, + 23694, 7, 2, 0, 0, 23694, 23695, 7, 15, 0, 0, 23695, 23696, 5, 95, 0, 0, + 23696, 23697, 7, 1, 0, 0, 23697, 23698, 7, 11, 0, 0, 23698, 23699, 7, 2, + 0, 0, 23699, 23700, 7, 2, 0, 0, 23700, 23701, 7, 14, 0, 0, 23701, 23702, + 5, 95, 0, 0, 23702, 23703, 7, 16, 0, 0, 23703, 23704, 7, 12, 0, 0, 23704, + 23705, 7, 11, 0, 0, 23705, 23706, 7, 4, 0, 0, 23706, 23707, 7, 6, 0, 0, + 23707, 23708, 7, 3, 0, 0, 23708, 23709, 5, 95, 0, 0, 23709, 23710, 7, 11, + 0, 0, 23710, 23711, 7, 12, 0, 0, 23711, 23712, 7, 5, 0, 0, 23712, 23713, + 7, 4, 0, 0, 23713, 3478, 1, 0, 0, 0, 23714, 23715, 7, 5, 0, 0, 23715, 23716, + 7, 18, 0, 0, 23716, 23717, 7, 5, 0, 0, 23717, 23718, 5, 95, 0, 0, 23718, + 23719, 7, 2, 0, 0, 23719, 23720, 7, 15, 0, 0, 23720, 23721, 5, 95, 0, 0, + 23721, 23722, 7, 1, 0, 0, 23722, 23723, 7, 11, 0, 0, 23723, 23724, 7, 2, + 0, 0, 23724, 23725, 7, 2, 0, 0, 23725, 23726, 7, 14, 0, 0, 23726, 23727, + 5, 95, 0, 0, 23727, 23728, 7, 16, 0, 0, 23728, 23729, 7, 12, 0, 0, 23729, + 23730, 7, 11, 0, 0, 23730, 23731, 7, 4, 0, 0, 23731, 23732, 7, 6, 0, 0, + 23732, 23733, 7, 3, 0, 0, 23733, 3480, 1, 0, 0, 0, 23734, 23735, 7, 5, + 0, 0, 23735, 23736, 7, 18, 0, 0, 23736, 23737, 7, 5, 0, 0, 23737, 23738, + 5, 95, 0, 0, 23738, 23739, 7, 2, 0, 0, 23739, 23740, 7, 15, 0, 0, 23740, + 23741, 5, 95, 0, 0, 23741, 23742, 7, 8, 0, 0, 23742, 23743, 5, 50, 0, 0, + 23743, 23744, 7, 8, 0, 0, 23744, 3482, 1, 0, 0, 0, 23745, 23746, 7, 5, + 0, 0, 23746, 23747, 7, 18, 0, 0, 23747, 23748, 7, 5, 0, 0, 23748, 23749, + 5, 95, 0, 0, 23749, 23750, 7, 2, 0, 0, 23750, 23751, 7, 15, 0, 0, 23751, + 23752, 5, 95, 0, 0, 23752, 23753, 7, 8, 0, 0, 23753, 23754, 7, 0, 0, 0, + 23754, 23755, 7, 5, 0, 0, 23755, 23756, 7, 4, 0, 0, 23756, 3484, 1, 0, + 0, 0, 23757, 23758, 7, 5, 0, 0, 23758, 23759, 7, 18, 0, 0, 23759, 23760, + 7, 5, 0, 0, 23760, 23761, 5, 95, 0, 0, 23761, 23762, 7, 2, 0, 0, 23762, + 23763, 7, 15, 0, 0, 23763, 23764, 5, 95, 0, 0, 23764, 23765, 7, 8, 0, 0, + 23765, 23766, 7, 6, 0, 0, 23766, 23767, 7, 17, 0, 0, 23767, 3486, 1, 0, + 0, 0, 23768, 23769, 7, 5, 0, 0, 23769, 23770, 7, 18, 0, 0, 23770, 23771, + 7, 5, 0, 0, 23771, 23772, 5, 95, 0, 0, 23772, 23773, 7, 2, 0, 0, 23773, + 23774, 7, 15, 0, 0, 23774, 23775, 5, 95, 0, 0, 23775, 23776, 7, 8, 0, 0, + 23776, 23777, 7, 11, 0, 0, 23777, 23778, 5, 50, 0, 0, 23778, 23779, 7, + 8, 0, 0, 23779, 3488, 1, 0, 0, 0, 23780, 23781, 7, 5, 0, 0, 23781, 23782, + 7, 18, 0, 0, 23782, 23783, 7, 5, 0, 0, 23783, 23784, 5, 95, 0, 0, 23784, + 23785, 7, 2, 0, 0, 23785, 23786, 7, 15, 0, 0, 23786, 23787, 5, 95, 0, 0, + 23787, 23788, 7, 8, 0, 0, 23788, 23789, 7, 2, 0, 0, 23789, 23790, 7, 14, + 0, 0, 23790, 23791, 7, 1, 0, 0, 23791, 23792, 7, 12, 0, 0, 23792, 23793, + 7, 7, 0, 0, 23793, 23794, 7, 6, 0, 0, 23794, 23795, 7, 9, 0, 0, 23795, + 23796, 5, 95, 0, 0, 23796, 23797, 7, 19, 0, 0, 23797, 23798, 7, 0, 0, 0, + 23798, 23799, 7, 5, 0, 0, 23799, 23800, 7, 19, 0, 0, 23800, 3490, 1, 0, + 0, 0, 23801, 23802, 7, 5, 0, 0, 23802, 23803, 7, 18, 0, 0, 23803, 23804, + 7, 5, 0, 0, 23804, 23805, 5, 95, 0, 0, 23805, 23806, 7, 2, 0, 0, 23806, + 23807, 7, 15, 0, 0, 23807, 23808, 5, 95, 0, 0, 23808, 23809, 7, 8, 0, 0, + 23809, 23810, 7, 2, 0, 0, 23810, 23811, 7, 14, 0, 0, 23811, 23812, 7, 15, + 0, 0, 23812, 3492, 1, 0, 0, 0, 23813, 23814, 7, 5, 0, 0, 23814, 23815, + 7, 18, 0, 0, 23815, 23816, 7, 5, 0, 0, 23816, 23817, 5, 95, 0, 0, 23817, + 23818, 7, 2, 0, 0, 23818, 23819, 7, 15, 0, 0, 23819, 23820, 5, 95, 0, 0, + 23820, 23821, 7, 8, 0, 0, 23821, 23822, 7, 2, 0, 0, 23822, 23823, 7, 7, + 0, 0, 23823, 23824, 7, 13, 0, 0, 23824, 23825, 7, 6, 0, 0, 23825, 23826, + 7, 3, 0, 0, 23826, 23827, 7, 4, 0, 0, 23827, 3494, 1, 0, 0, 0, 23828, 23829, + 7, 5, 0, 0, 23829, 23830, 7, 18, 0, 0, 23830, 23831, 7, 5, 0, 0, 23831, + 23832, 5, 95, 0, 0, 23832, 23833, 7, 2, 0, 0, 23833, 23834, 7, 15, 0, 0, + 23834, 23835, 5, 95, 0, 0, 23835, 23836, 7, 8, 0, 0, 23836, 23837, 7, 2, + 0, 0, 23837, 23838, 7, 10, 0, 0, 23838, 23839, 7, 7, 0, 0, 23839, 23840, + 7, 4, 0, 0, 23840, 23841, 7, 8, 0, 0, 23841, 23842, 7, 19, 0, 0, 23842, + 23843, 7, 17, 0, 0, 23843, 3496, 1, 0, 0, 0, 23844, 23845, 7, 5, 0, 0, + 23845, 23846, 7, 18, 0, 0, 23846, 23847, 7, 5, 0, 0, 23847, 23848, 5, 95, + 0, 0, 23848, 23849, 7, 2, 0, 0, 23849, 23850, 7, 15, 0, 0, 23850, 23851, + 5, 95, 0, 0, 23851, 23852, 7, 8, 0, 0, 23852, 23853, 7, 5, 0, 0, 23853, + 23854, 7, 8, 0, 0, 23854, 23855, 7, 2, 0, 0, 23855, 23856, 7, 7, 0, 0, + 23856, 23857, 7, 13, 0, 0, 23857, 3498, 1, 0, 0, 0, 23858, 23859, 7, 5, + 0, 0, 23859, 23860, 7, 18, 0, 0, 23860, 23861, 7, 5, 0, 0, 23861, 23862, + 5, 95, 0, 0, 23862, 23863, 7, 2, 0, 0, 23863, 23864, 7, 15, 0, 0, 23864, + 23865, 5, 95, 0, 0, 23865, 23866, 7, 8, 0, 0, 23866, 23867, 7, 5, 0, 0, + 23867, 23868, 7, 8, 0, 0, 23868, 23869, 7, 2, 0, 0, 23869, 23870, 7, 7, + 0, 0, 23870, 23871, 7, 13, 0, 0, 23871, 23872, 7, 4, 0, 0, 23872, 23873, + 7, 6, 0, 0, 23873, 23874, 7, 5, 0, 0, 23874, 23875, 7, 4, 0, 0, 23875, + 3500, 1, 0, 0, 0, 23876, 23877, 7, 5, 0, 0, 23877, 23878, 7, 18, 0, 0, + 23878, 23879, 7, 5, 0, 0, 23879, 23880, 5, 95, 0, 0, 23880, 23881, 7, 2, + 0, 0, 23881, 23882, 7, 15, 0, 0, 23882, 23883, 5, 95, 0, 0, 23883, 23884, + 7, 8, 0, 0, 23884, 23885, 7, 5, 0, 0, 23885, 23886, 7, 3, 0, 0, 23886, + 3502, 1, 0, 0, 0, 23887, 23888, 7, 5, 0, 0, 23888, 23889, 7, 18, 0, 0, + 23889, 23890, 7, 5, 0, 0, 23890, 23891, 5, 95, 0, 0, 23891, 23892, 7, 2, + 0, 0, 23892, 23893, 7, 15, 0, 0, 23893, 23894, 5, 95, 0, 0, 23894, 23895, + 7, 8, 0, 0, 23895, 23896, 7, 5, 0, 0, 23896, 23897, 7, 25, 0, 0, 23897, + 23898, 5, 95, 0, 0, 23898, 23899, 7, 15, 0, 0, 23899, 23900, 7, 0, 0, 0, + 23900, 23901, 7, 4, 0, 0, 23901, 23902, 7, 8, 0, 0, 23902, 23903, 7, 19, + 0, 0, 23903, 3504, 1, 0, 0, 0, 23904, 23905, 7, 5, 0, 0, 23905, 23906, + 7, 18, 0, 0, 23906, 23907, 7, 5, 0, 0, 23907, 23908, 5, 95, 0, 0, 23908, + 23909, 7, 2, 0, 0, 23909, 23910, 7, 15, 0, 0, 23910, 23911, 5, 95, 0, 0, + 23911, 23912, 7, 8, 0, 0, 23912, 23913, 7, 18, 0, 0, 23913, 23914, 7, 8, + 0, 0, 23914, 23915, 7, 11, 0, 0, 23915, 23916, 7, 6, 0, 0, 23916, 23917, + 7, 9, 0, 0, 23917, 23918, 5, 95, 0, 0, 23918, 23919, 7, 5, 0, 0, 23919, + 23920, 7, 6, 0, 0, 23920, 23921, 7, 24, 0, 0, 23921, 3506, 1, 0, 0, 0, + 23922, 23923, 7, 5, 0, 0, 23923, 23924, 7, 18, 0, 0, 23924, 23925, 7, 5, + 0, 0, 23925, 23926, 5, 95, 0, 0, 23926, 23927, 7, 2, 0, 0, 23927, 23928, + 7, 15, 0, 0, 23928, 23929, 5, 95, 0, 0, 23929, 23930, 7, 9, 0, 0, 23930, + 23931, 7, 6, 0, 0, 23931, 23932, 7, 8, 0, 0, 23932, 23933, 7, 2, 0, 0, + 23933, 23934, 7, 14, 0, 0, 23934, 23935, 7, 15, 0, 0, 23935, 3508, 1, 0, + 0, 0, 23936, 23937, 7, 5, 0, 0, 23937, 23938, 7, 18, 0, 0, 23938, 23939, + 7, 5, 0, 0, 23939, 23940, 5, 95, 0, 0, 23940, 23941, 7, 2, 0, 0, 23941, + 23942, 7, 15, 0, 0, 23942, 23943, 5, 95, 0, 0, 23943, 23944, 7, 9, 0, 0, + 23944, 23945, 7, 6, 0, 0, 23945, 23946, 7, 5, 0, 0, 23946, 23947, 7, 8, + 0, 0, 23947, 23948, 7, 6, 0, 0, 23948, 23949, 7, 7, 0, 0, 23949, 23950, + 7, 9, 0, 0, 23950, 3510, 1, 0, 0, 0, 23951, 23952, 7, 5, 0, 0, 23952, 23953, + 7, 18, 0, 0, 23953, 23954, 7, 5, 0, 0, 23954, 23955, 5, 95, 0, 0, 23955, + 23956, 7, 2, 0, 0, 23956, 23957, 7, 15, 0, 0, 23957, 23958, 5, 95, 0, 0, + 23958, 23959, 7, 9, 0, 0, 23959, 23960, 7, 12, 0, 0, 23960, 23961, 7, 5, + 0, 0, 23961, 23962, 7, 4, 0, 0, 23962, 23963, 7, 12, 0, 0, 23963, 23964, + 7, 7, 0, 0, 23964, 23965, 7, 8, 0, 0, 23965, 23966, 7, 4, 0, 0, 23966, + 3512, 1, 0, 0, 0, 23967, 23968, 7, 5, 0, 0, 23968, 23969, 7, 18, 0, 0, + 23969, 23970, 7, 5, 0, 0, 23970, 23971, 5, 95, 0, 0, 23971, 23972, 7, 2, + 0, 0, 23972, 23973, 7, 15, 0, 0, 23973, 23974, 5, 95, 0, 0, 23974, 23975, + 7, 9, 0, 0, 23975, 23976, 7, 3, 0, 0, 23976, 23977, 7, 0, 0, 0, 23977, + 3514, 1, 0, 0, 0, 23978, 23979, 7, 5, 0, 0, 23979, 23980, 7, 18, 0, 0, + 23980, 23981, 7, 5, 0, 0, 23981, 23982, 5, 95, 0, 0, 23982, 23983, 7, 2, + 0, 0, 23983, 23984, 7, 15, 0, 0, 23984, 23985, 5, 95, 0, 0, 23985, 23986, + 7, 9, 0, 0, 23986, 23987, 7, 10, 0, 0, 23987, 23988, 7, 14, 0, 0, 23988, + 23989, 7, 15, 0, 0, 23989, 3516, 1, 0, 0, 0, 23990, 23991, 7, 5, 0, 0, + 23991, 23992, 7, 18, 0, 0, 23992, 23993, 7, 5, 0, 0, 23993, 23994, 5, 95, + 0, 0, 23994, 23995, 7, 2, 0, 0, 23995, 23996, 7, 15, 0, 0, 23996, 23997, + 5, 95, 0, 0, 23997, 23998, 7, 9, 0, 0, 23998, 23999, 7, 13, 0, 0, 23999, + 24000, 5, 95, 0, 0, 24000, 24001, 7, 8, 0, 0, 24001, 24002, 7, 19, 0, 0, + 24002, 24003, 7, 6, 0, 0, 24003, 24004, 7, 8, 0, 0, 24004, 24005, 7, 21, + 0, 0, 24005, 3518, 1, 0, 0, 0, 24006, 24007, 7, 5, 0, 0, 24007, 24008, + 7, 18, 0, 0, 24008, 24009, 7, 5, 0, 0, 24009, 24010, 5, 95, 0, 0, 24010, + 24011, 7, 2, 0, 0, 24011, 24012, 7, 15, 0, 0, 24012, 24013, 5, 95, 0, 0, + 24013, 24014, 7, 6, 0, 0, 24014, 24015, 7, 7, 0, 0, 24015, 24016, 7, 16, + 0, 0, 24016, 24017, 7, 2, 0, 0, 24017, 24018, 7, 3, 0, 0, 24018, 24019, + 7, 8, 0, 0, 24019, 24020, 7, 6, 0, 0, 24020, 24021, 5, 95, 0, 0, 24021, + 24022, 7, 7, 0, 0, 24022, 24023, 7, 2, 0, 0, 24023, 24024, 7, 4, 0, 0, + 24024, 24025, 5, 95, 0, 0, 24025, 24026, 7, 7, 0, 0, 24026, 24027, 7, 10, + 0, 0, 24027, 24028, 7, 11, 0, 0, 24028, 24029, 7, 11, 0, 0, 24029, 24030, + 5, 36, 0, 0, 24030, 3520, 1, 0, 0, 0, 24031, 24032, 7, 5, 0, 0, 24032, + 24033, 7, 18, 0, 0, 24033, 24034, 7, 5, 0, 0, 24034, 24035, 7, 2, 0, 0, + 24035, 24036, 7, 15, 0, 0, 24036, 24037, 7, 6, 0, 0, 24037, 24038, 7, 3, + 0, 0, 24038, 3522, 1, 0, 0, 0, 24039, 24040, 7, 5, 0, 0, 24040, 24041, + 7, 18, 0, 0, 24041, 24042, 7, 5, 0, 0, 24042, 24043, 5, 95, 0, 0, 24043, + 24044, 7, 2, 0, 0, 24044, 24045, 7, 15, 0, 0, 24045, 24046, 5, 95, 0, 0, + 24046, 24047, 7, 6, 0, 0, 24047, 24048, 7, 25, 0, 0, 24048, 24049, 7, 4, + 0, 0, 24049, 24050, 7, 3, 0, 0, 24050, 24051, 7, 0, 0, 0, 24051, 24052, + 7, 8, 0, 0, 24052, 24053, 7, 4, 0, 0, 24053, 3524, 1, 0, 0, 0, 24054, 24055, + 7, 5, 0, 0, 24055, 24056, 7, 18, 0, 0, 24056, 24057, 7, 5, 0, 0, 24057, + 24058, 5, 95, 0, 0, 24058, 24059, 7, 2, 0, 0, 24059, 24060, 7, 15, 0, 0, + 24060, 24061, 5, 95, 0, 0, 24061, 24062, 7, 17, 0, 0, 24062, 24063, 7, + 3, 0, 0, 24063, 24064, 7, 2, 0, 0, 24064, 24065, 7, 10, 0, 0, 24065, 24066, + 7, 15, 0, 0, 24066, 24067, 7, 12, 0, 0, 24067, 24068, 7, 7, 0, 0, 24068, + 24069, 7, 17, 0, 0, 24069, 3526, 1, 0, 0, 0, 24070, 24071, 7, 5, 0, 0, + 24071, 24072, 7, 18, 0, 0, 24072, 24073, 7, 5, 0, 0, 24073, 24074, 5, 95, + 0, 0, 24074, 24075, 7, 2, 0, 0, 24075, 24076, 7, 15, 0, 0, 24076, 24077, + 5, 95, 0, 0, 24077, 24078, 7, 17, 0, 0, 24078, 24079, 7, 10, 0, 0, 24079, + 24080, 7, 12, 0, 0, 24080, 24081, 7, 9, 0, 0, 24081, 3528, 1, 0, 0, 0, + 24082, 24083, 7, 5, 0, 0, 24083, 24084, 7, 18, 0, 0, 24084, 24085, 7, 5, + 0, 0, 24085, 24086, 5, 95, 0, 0, 24086, 24087, 7, 2, 0, 0, 24087, 24088, + 7, 15, 0, 0, 24088, 24089, 5, 95, 0, 0, 24089, 24090, 7, 19, 0, 0, 24090, + 24091, 7, 0, 0, 0, 24091, 24092, 7, 5, 0, 0, 24092, 24093, 7, 19, 0, 0, + 24093, 3530, 1, 0, 0, 0, 24094, 24095, 7, 5, 0, 0, 24095, 24096, 7, 18, + 0, 0, 24096, 24097, 7, 5, 0, 0, 24097, 24098, 5, 95, 0, 0, 24098, 24099, + 7, 2, 0, 0, 24099, 24100, 7, 15, 0, 0, 24100, 24101, 5, 95, 0, 0, 24101, + 24102, 7, 12, 0, 0, 24102, 24103, 7, 12, 0, 0, 24103, 24104, 7, 25, 0, + 0, 24104, 3532, 1, 0, 0, 0, 24105, 24106, 7, 5, 0, 0, 24106, 24107, 7, + 18, 0, 0, 24107, 24108, 7, 5, 0, 0, 24108, 24109, 5, 95, 0, 0, 24109, 24110, + 7, 2, 0, 0, 24110, 24111, 7, 15, 0, 0, 24111, 24112, 5, 95, 0, 0, 24112, + 24113, 7, 12, 0, 0, 24113, 24114, 7, 4, 0, 0, 24114, 24115, 7, 3, 0, 0, + 24115, 3534, 1, 0, 0, 0, 24116, 24117, 7, 5, 0, 0, 24117, 24118, 7, 18, + 0, 0, 24118, 24119, 7, 5, 0, 0, 24119, 24120, 5, 95, 0, 0, 24120, 24121, + 7, 2, 0, 0, 24121, 24122, 7, 15, 0, 0, 24122, 24123, 5, 95, 0, 0, 24123, + 24124, 7, 21, 0, 0, 24124, 24125, 7, 6, 0, 0, 24125, 24126, 7, 18, 0, 0, + 24126, 24127, 5, 95, 0, 0, 24127, 24128, 7, 13, 0, 0, 24128, 24129, 7, + 6, 0, 0, 24129, 24130, 7, 8, 0, 0, 24130, 24131, 7, 4, 0, 0, 24131, 24132, + 7, 2, 0, 0, 24132, 24133, 7, 3, 0, 0, 24133, 24134, 5, 95, 0, 0, 24134, + 24135, 7, 8, 0, 0, 24135, 24136, 7, 3, 0, 0, 24136, 24137, 7, 6, 0, 0, + 24137, 24138, 7, 0, 0, 0, 24138, 24139, 7, 4, 0, 0, 24139, 24140, 7, 6, + 0, 0, 24140, 3536, 1, 0, 0, 0, 24141, 24142, 7, 5, 0, 0, 24142, 24143, + 7, 18, 0, 0, 24143, 24144, 7, 5, 0, 0, 24144, 24145, 5, 95, 0, 0, 24145, + 24146, 7, 2, 0, 0, 24146, 24147, 7, 15, 0, 0, 24147, 24148, 5, 95, 0, 0, + 24148, 24149, 7, 21, 0, 0, 24149, 24150, 7, 6, 0, 0, 24150, 24151, 7, 18, + 0, 0, 24151, 24152, 5, 95, 0, 0, 24152, 24153, 7, 13, 0, 0, 24153, 24154, + 7, 6, 0, 0, 24154, 24155, 7, 8, 0, 0, 24155, 24156, 7, 4, 0, 0, 24156, + 24157, 7, 2, 0, 0, 24157, 24158, 7, 3, 0, 0, 24158, 24159, 5, 95, 0, 0, + 24159, 24160, 7, 16, 0, 0, 24160, 24161, 7, 12, 0, 0, 24161, 24162, 7, + 11, 0, 0, 24162, 24163, 7, 4, 0, 0, 24163, 24164, 7, 6, 0, 0, 24164, 24165, + 7, 3, 0, 0, 24165, 24166, 5, 95, 0, 0, 24166, 24167, 7, 11, 0, 0, 24167, + 24168, 7, 12, 0, 0, 24168, 24169, 7, 5, 0, 0, 24169, 24170, 7, 4, 0, 0, + 24170, 3538, 1, 0, 0, 0, 24171, 24172, 7, 5, 0, 0, 24172, 24173, 7, 18, + 0, 0, 24173, 24174, 7, 5, 0, 0, 24174, 24175, 5, 95, 0, 0, 24175, 24176, + 7, 2, 0, 0, 24176, 24177, 7, 15, 0, 0, 24177, 24178, 5, 95, 0, 0, 24178, + 24179, 7, 21, 0, 0, 24179, 24180, 7, 6, 0, 0, 24180, 24181, 7, 18, 0, 0, + 24181, 24182, 5, 95, 0, 0, 24182, 24183, 7, 13, 0, 0, 24183, 24184, 7, + 6, 0, 0, 24184, 24185, 7, 8, 0, 0, 24185, 24186, 7, 4, 0, 0, 24186, 24187, + 7, 2, 0, 0, 24187, 24188, 7, 3, 0, 0, 24188, 24189, 5, 95, 0, 0, 24189, + 24190, 7, 16, 0, 0, 24190, 24191, 7, 12, 0, 0, 24191, 24192, 7, 11, 0, + 0, 24192, 24193, 7, 4, 0, 0, 24193, 24194, 7, 6, 0, 0, 24194, 24195, 7, + 3, 0, 0, 24195, 3540, 1, 0, 0, 0, 24196, 24197, 7, 5, 0, 0, 24197, 24198, + 7, 18, 0, 0, 24198, 24199, 7, 5, 0, 0, 24199, 24200, 5, 95, 0, 0, 24200, + 24201, 7, 2, 0, 0, 24201, 24202, 7, 15, 0, 0, 24202, 24203, 5, 95, 0, 0, + 24203, 24204, 7, 21, 0, 0, 24204, 24205, 7, 6, 0, 0, 24205, 24206, 7, 18, + 0, 0, 24206, 24207, 5, 95, 0, 0, 24207, 24208, 7, 13, 0, 0, 24208, 24209, + 7, 6, 0, 0, 24209, 24210, 7, 8, 0, 0, 24210, 24211, 7, 4, 0, 0, 24211, + 24212, 7, 2, 0, 0, 24212, 24213, 7, 3, 0, 0, 24213, 24214, 5, 95, 0, 0, + 24214, 24215, 7, 5, 0, 0, 24215, 24216, 7, 10, 0, 0, 24216, 24217, 7, 8, + 0, 0, 24217, 24218, 7, 8, 0, 0, 24218, 24219, 7, 6, 0, 0, 24219, 24220, + 7, 6, 0, 0, 24220, 24221, 7, 9, 0, 0, 24221, 24222, 7, 6, 0, 0, 24222, + 24223, 7, 9, 0, 0, 24223, 3542, 1, 0, 0, 0, 24224, 24225, 7, 5, 0, 0, 24225, + 24226, 7, 18, 0, 0, 24226, 24227, 7, 5, 0, 0, 24227, 24228, 5, 95, 0, 0, + 24228, 24229, 7, 2, 0, 0, 24229, 24230, 7, 15, 0, 0, 24230, 24231, 5, 95, + 0, 0, 24231, 24232, 7, 21, 0, 0, 24232, 24233, 7, 6, 0, 0, 24233, 24234, + 7, 18, 0, 0, 24234, 24235, 5, 95, 0, 0, 24235, 24236, 7, 13, 0, 0, 24236, + 24237, 7, 6, 0, 0, 24237, 24238, 7, 8, 0, 0, 24238, 24239, 7, 4, 0, 0, + 24239, 24240, 7, 2, 0, 0, 24240, 24241, 7, 3, 0, 0, 24241, 24242, 5, 95, + 0, 0, 24242, 24243, 7, 10, 0, 0, 24243, 24244, 7, 5, 0, 0, 24244, 24245, + 7, 6, 0, 0, 24245, 3544, 1, 0, 0, 0, 24246, 24247, 7, 5, 0, 0, 24247, 24248, + 7, 18, 0, 0, 24248, 24249, 7, 5, 0, 0, 24249, 24250, 5, 95, 0, 0, 24250, + 24251, 7, 2, 0, 0, 24251, 24252, 7, 15, 0, 0, 24252, 24253, 5, 95, 0, 0, + 24253, 24254, 7, 11, 0, 0, 24254, 24255, 7, 1, 0, 0, 24255, 24256, 7, 12, + 0, 0, 24256, 24257, 7, 9, 0, 0, 24257, 3546, 1, 0, 0, 0, 24258, 24259, + 7, 5, 0, 0, 24259, 24260, 7, 18, 0, 0, 24260, 24261, 7, 5, 0, 0, 24261, + 24262, 5, 95, 0, 0, 24262, 24263, 7, 2, 0, 0, 24263, 24264, 7, 15, 0, 0, + 24264, 24265, 5, 95, 0, 0, 24265, 24266, 7, 11, 0, 0, 24266, 24267, 7, + 2, 0, 0, 24267, 24268, 7, 1, 0, 0, 24268, 24269, 7, 11, 0, 0, 24269, 24270, + 7, 2, 0, 0, 24270, 24271, 7, 8, 0, 0, 24271, 24272, 5, 50, 0, 0, 24272, + 24273, 7, 1, 0, 0, 24273, 24274, 7, 11, 0, 0, 24274, 24275, 7, 2, 0, 0, + 24275, 24276, 7, 1, 0, 0, 24276, 3548, 1, 0, 0, 0, 24277, 24278, 7, 5, + 0, 0, 24278, 24279, 7, 18, 0, 0, 24279, 24280, 7, 5, 0, 0, 24280, 24281, + 5, 95, 0, 0, 24281, 24282, 7, 2, 0, 0, 24282, 24283, 7, 15, 0, 0, 24283, + 24284, 5, 95, 0, 0, 24284, 24285, 7, 11, 0, 0, 24285, 24286, 7, 2, 0, 0, + 24286, 24287, 7, 1, 0, 0, 24287, 24288, 7, 11, 0, 0, 24288, 24289, 7, 2, + 0, 0, 24289, 24290, 7, 8, 0, 0, 24290, 24291, 5, 50, 0, 0, 24291, 24292, + 7, 8, 0, 0, 24292, 24293, 7, 11, 0, 0, 24293, 24294, 7, 2, 0, 0, 24294, + 24295, 7, 1, 0, 0, 24295, 3550, 1, 0, 0, 0, 24296, 24297, 7, 5, 0, 0, 24297, + 24298, 7, 18, 0, 0, 24298, 24299, 7, 5, 0, 0, 24299, 24300, 5, 95, 0, 0, + 24300, 24301, 7, 2, 0, 0, 24301, 24302, 7, 15, 0, 0, 24302, 24303, 5, 95, + 0, 0, 24303, 24304, 7, 11, 0, 0, 24304, 24305, 7, 2, 0, 0, 24305, 24306, + 7, 1, 0, 0, 24306, 24307, 7, 11, 0, 0, 24307, 24308, 7, 2, 0, 0, 24308, + 24309, 7, 8, 0, 0, 24309, 24310, 5, 50, 0, 0, 24310, 24311, 7, 12, 0, 0, + 24311, 24312, 7, 9, 0, 0, 24312, 3552, 1, 0, 0, 0, 24313, 24314, 7, 5, + 0, 0, 24314, 24315, 7, 18, 0, 0, 24315, 24316, 7, 5, 0, 0, 24316, 24317, + 5, 95, 0, 0, 24317, 24318, 7, 2, 0, 0, 24318, 24319, 7, 15, 0, 0, 24319, + 24320, 5, 95, 0, 0, 24320, 24321, 7, 11, 0, 0, 24321, 24322, 7, 2, 0, 0, + 24322, 24323, 7, 1, 0, 0, 24323, 24324, 7, 11, 0, 0, 24324, 24325, 7, 2, + 0, 0, 24325, 24326, 7, 8, 0, 0, 24326, 24327, 5, 50, 0, 0, 24327, 24328, + 7, 7, 0, 0, 24328, 24329, 7, 8, 0, 0, 24329, 24330, 7, 11, 0, 0, 24330, + 24331, 7, 2, 0, 0, 24331, 24332, 7, 1, 0, 0, 24332, 3554, 1, 0, 0, 0, 24333, + 24334, 7, 5, 0, 0, 24334, 24335, 7, 18, 0, 0, 24335, 24336, 7, 5, 0, 0, + 24336, 24337, 5, 95, 0, 0, 24337, 24338, 7, 2, 0, 0, 24338, 24339, 7, 15, + 0, 0, 24339, 24340, 5, 95, 0, 0, 24340, 24341, 7, 11, 0, 0, 24341, 24342, + 7, 2, 0, 0, 24342, 24343, 7, 1, 0, 0, 24343, 24344, 7, 11, 0, 0, 24344, + 24345, 7, 2, 0, 0, 24345, 24346, 7, 8, 0, 0, 24346, 24347, 5, 50, 0, 0, + 24347, 24348, 7, 4, 0, 0, 24348, 24349, 7, 18, 0, 0, 24349, 24350, 7, 15, + 0, 0, 24350, 3556, 1, 0, 0, 0, 24351, 24352, 7, 5, 0, 0, 24352, 24353, + 7, 18, 0, 0, 24353, 24354, 7, 5, 0, 0, 24354, 24355, 5, 95, 0, 0, 24355, + 24356, 7, 2, 0, 0, 24356, 24357, 7, 15, 0, 0, 24357, 24358, 5, 95, 0, 0, + 24358, 24359, 7, 11, 0, 0, 24359, 24360, 7, 5, 0, 0, 24360, 24361, 7, 13, + 0, 0, 24361, 24362, 7, 12, 0, 0, 24362, 3558, 1, 0, 0, 0, 24363, 24364, + 7, 5, 0, 0, 24364, 24365, 7, 18, 0, 0, 24365, 24366, 7, 5, 0, 0, 24366, + 24367, 5, 95, 0, 0, 24367, 24368, 7, 2, 0, 0, 24368, 24369, 7, 15, 0, 0, + 24369, 24370, 5, 95, 0, 0, 24370, 24371, 7, 11, 0, 0, 24371, 24372, 7, + 13, 0, 0, 24372, 24373, 7, 11, 0, 0, 24373, 3560, 1, 0, 0, 0, 24374, 24375, + 7, 5, 0, 0, 24375, 24376, 7, 18, 0, 0, 24376, 24377, 7, 5, 0, 0, 24377, + 24378, 5, 95, 0, 0, 24378, 24379, 7, 2, 0, 0, 24379, 24380, 7, 15, 0, 0, + 24380, 24381, 5, 95, 0, 0, 24381, 24382, 7, 14, 0, 0, 24382, 24383, 7, + 0, 0, 0, 24383, 24384, 7, 21, 0, 0, 24384, 24385, 7, 6, 0, 0, 24385, 24386, + 7, 2, 0, 0, 24386, 24387, 7, 12, 0, 0, 24387, 24388, 7, 9, 0, 0, 24388, + 3562, 1, 0, 0, 0, 24389, 24390, 7, 5, 0, 0, 24390, 24391, 7, 18, 0, 0, + 24391, 24392, 7, 5, 0, 0, 24392, 24393, 5, 95, 0, 0, 24393, 24394, 7, 2, + 0, 0, 24394, 24395, 7, 15, 0, 0, 24395, 24396, 5, 95, 0, 0, 24396, 24397, + 7, 14, 0, 0, 24397, 24398, 7, 0, 0, 0, 24398, 24399, 7, 15, 0, 0, 24399, + 24400, 5, 95, 0, 0, 24400, 24401, 7, 7, 0, 0, 24401, 24402, 7, 2, 0, 0, + 24402, 24403, 7, 7, 0, 0, 24403, 24404, 7, 7, 0, 0, 24404, 24405, 7, 10, + 0, 0, 24405, 24406, 7, 11, 0, 0, 24406, 24407, 7, 11, 0, 0, 24407, 3564, + 1, 0, 0, 0, 24408, 24409, 7, 5, 0, 0, 24409, 24410, 7, 18, 0, 0, 24410, + 24411, 7, 5, 0, 0, 24411, 24412, 5, 95, 0, 0, 24412, 24413, 7, 2, 0, 0, + 24413, 24414, 7, 15, 0, 0, 24414, 24415, 5, 95, 0, 0, 24415, 24416, 7, + 14, 0, 0, 24416, 24417, 7, 5, 0, 0, 24417, 24418, 7, 3, 0, 0, 24418, 3566, + 1, 0, 0, 0, 24419, 24420, 7, 5, 0, 0, 24420, 24421, 7, 18, 0, 0, 24421, + 24422, 7, 5, 0, 0, 24422, 24423, 5, 95, 0, 0, 24423, 24424, 7, 2, 0, 0, + 24424, 24425, 7, 15, 0, 0, 24425, 24426, 5, 95, 0, 0, 24426, 24427, 7, + 7, 0, 0, 24427, 24428, 7, 12, 0, 0, 24428, 24429, 7, 8, 0, 0, 24429, 24430, + 7, 2, 0, 0, 24430, 24431, 7, 14, 0, 0, 24431, 24432, 7, 1, 0, 0, 24432, + 24433, 7, 12, 0, 0, 24433, 24434, 7, 7, 0, 0, 24434, 24435, 7, 6, 0, 0, + 24435, 3568, 1, 0, 0, 0, 24436, 24437, 7, 5, 0, 0, 24437, 24438, 7, 18, + 0, 0, 24438, 24439, 7, 5, 0, 0, 24439, 24440, 5, 95, 0, 0, 24440, 24441, + 7, 2, 0, 0, 24441, 24442, 7, 15, 0, 0, 24442, 24443, 5, 95, 0, 0, 24443, + 24444, 7, 7, 0, 0, 24444, 24445, 7, 12, 0, 0, 24445, 24446, 7, 6, 0, 0, + 24446, 24447, 7, 25, 0, 0, 24447, 24448, 7, 4, 0, 0, 24448, 24449, 7, 3, + 0, 0, 24449, 24450, 7, 0, 0, 0, 24450, 24451, 7, 8, 0, 0, 24451, 24452, + 7, 4, 0, 0, 24452, 3570, 1, 0, 0, 0, 24453, 24454, 7, 5, 0, 0, 24454, 24455, + 7, 18, 0, 0, 24455, 24456, 7, 5, 0, 0, 24456, 24457, 5, 95, 0, 0, 24457, + 24458, 7, 2, 0, 0, 24458, 24459, 7, 15, 0, 0, 24459, 24460, 5, 95, 0, 0, + 24460, 24461, 7, 7, 0, 0, 24461, 24462, 7, 12, 0, 0, 24462, 24463, 7, 12, + 0, 0, 24463, 3572, 1, 0, 0, 0, 24464, 24465, 7, 5, 0, 0, 24465, 24466, + 7, 18, 0, 0, 24466, 24467, 7, 5, 0, 0, 24467, 24468, 5, 95, 0, 0, 24468, + 24469, 7, 2, 0, 0, 24469, 24470, 7, 15, 0, 0, 24470, 24471, 5, 95, 0, 0, + 24471, 24472, 7, 7, 0, 0, 24472, 24473, 7, 12, 0, 0, 24473, 24474, 7, 25, + 0, 0, 24474, 3574, 1, 0, 0, 0, 24475, 24476, 7, 5, 0, 0, 24476, 24477, + 7, 18, 0, 0, 24477, 24478, 7, 5, 0, 0, 24478, 24479, 5, 95, 0, 0, 24479, + 24480, 7, 2, 0, 0, 24480, 24481, 7, 15, 0, 0, 24481, 24482, 5, 95, 0, 0, + 24482, 24483, 7, 7, 0, 0, 24483, 24484, 7, 2, 0, 0, 24484, 24485, 7, 6, + 0, 0, 24485, 24486, 7, 25, 0, 0, 24486, 24487, 7, 15, 0, 0, 24487, 24488, + 7, 0, 0, 0, 24488, 24489, 7, 7, 0, 0, 24489, 24490, 7, 9, 0, 0, 24490, + 3576, 1, 0, 0, 0, 24491, 24492, 7, 5, 0, 0, 24492, 24493, 7, 18, 0, 0, + 24493, 24494, 7, 5, 0, 0, 24494, 24495, 5, 95, 0, 0, 24495, 24496, 7, 2, + 0, 0, 24496, 24497, 7, 15, 0, 0, 24497, 24498, 5, 95, 0, 0, 24498, 24499, + 7, 7, 0, 0, 24499, 24500, 7, 4, 0, 0, 24500, 24501, 7, 8, 0, 0, 24501, + 24502, 7, 12, 0, 0, 24502, 24503, 7, 14, 0, 0, 24503, 24504, 7, 17, 0, + 0, 24504, 24505, 5, 36, 0, 0, 24505, 3578, 1, 0, 0, 0, 24506, 24507, 7, + 5, 0, 0, 24507, 24508, 7, 18, 0, 0, 24508, 24509, 7, 5, 0, 0, 24509, 24510, + 5, 95, 0, 0, 24510, 24511, 7, 2, 0, 0, 24511, 24512, 7, 15, 0, 0, 24512, + 24513, 5, 95, 0, 0, 24513, 24514, 7, 7, 0, 0, 24514, 24515, 7, 10, 0, 0, + 24515, 24516, 7, 14, 0, 0, 24516, 24517, 7, 4, 0, 0, 24517, 24518, 7, 2, + 0, 0, 24518, 24519, 7, 3, 0, 0, 24519, 24520, 7, 0, 0, 0, 24520, 24521, + 7, 22, 0, 0, 24521, 3580, 1, 0, 0, 0, 24522, 24523, 7, 5, 0, 0, 24523, + 24524, 7, 18, 0, 0, 24524, 24525, 7, 5, 0, 0, 24525, 24526, 5, 95, 0, 0, + 24526, 24527, 7, 2, 0, 0, 24527, 24528, 7, 15, 0, 0, 24528, 24529, 5, 95, + 0, 0, 24529, 24530, 7, 2, 0, 0, 24530, 24531, 7, 12, 0, 0, 24531, 24532, + 7, 9, 0, 0, 24532, 24533, 7, 13, 0, 0, 24533, 24534, 7, 0, 0, 0, 24534, + 24535, 7, 11, 0, 0, 24535, 24536, 7, 10, 0, 0, 24536, 24537, 7, 6, 0, 0, + 24537, 3582, 1, 0, 0, 0, 24538, 24539, 7, 5, 0, 0, 24539, 24540, 7, 18, + 0, 0, 24540, 24541, 7, 5, 0, 0, 24541, 24542, 5, 95, 0, 0, 24542, 24543, + 7, 2, 0, 0, 24543, 24544, 7, 15, 0, 0, 24544, 24545, 5, 95, 0, 0, 24545, + 24546, 7, 2, 0, 0, 24546, 24547, 7, 15, 0, 0, 24547, 24548, 7, 7, 0, 0, + 24548, 24549, 7, 5, 0, 0, 24549, 24550, 7, 12, 0, 0, 24550, 24551, 7, 23, + 0, 0, 24551, 24552, 7, 6, 0, 0, 24552, 3584, 1, 0, 0, 0, 24553, 24554, + 7, 5, 0, 0, 24554, 24555, 7, 18, 0, 0, 24555, 24556, 7, 5, 0, 0, 24556, + 24557, 5, 95, 0, 0, 24557, 24558, 7, 2, 0, 0, 24558, 24559, 7, 15, 0, 0, + 24559, 24560, 5, 95, 0, 0, 24560, 24561, 7, 15, 0, 0, 24561, 24562, 7, + 0, 0, 0, 24562, 24563, 7, 3, 0, 0, 24563, 24564, 5, 95, 0, 0, 24564, 24565, + 5, 49, 0, 0, 24565, 3586, 1, 0, 0, 0, 24566, 24567, 7, 5, 0, 0, 24567, + 24568, 7, 18, 0, 0, 24568, 24569, 7, 5, 0, 0, 24569, 24570, 5, 95, 0, 0, + 24570, 24571, 7, 2, 0, 0, 24571, 24572, 7, 15, 0, 0, 24572, 24573, 5, 95, + 0, 0, 24573, 24574, 7, 15, 0, 0, 24574, 24575, 7, 0, 0, 0, 24575, 24576, + 7, 3, 0, 0, 24576, 24577, 7, 17, 0, 0, 24577, 24578, 7, 12, 0, 0, 24578, + 24579, 7, 9, 0, 0, 24579, 24580, 5, 95, 0, 0, 24580, 24581, 5, 49, 0, 0, + 24581, 3588, 1, 0, 0, 0, 24582, 24583, 7, 5, 0, 0, 24583, 24584, 7, 18, + 0, 0, 24584, 24585, 7, 5, 0, 0, 24585, 24586, 5, 95, 0, 0, 24586, 24587, + 7, 2, 0, 0, 24587, 24588, 7, 15, 0, 0, 24588, 24589, 5, 95, 0, 0, 24589, + 24590, 7, 15, 0, 0, 24590, 24591, 7, 0, 0, 0, 24591, 24592, 7, 3, 0, 0, + 24592, 24593, 7, 17, 0, 0, 24593, 24594, 7, 12, 0, 0, 24594, 24595, 7, + 9, 0, 0, 24595, 3590, 1, 0, 0, 0, 24596, 24597, 7, 5, 0, 0, 24597, 24598, + 7, 18, 0, 0, 24598, 24599, 7, 5, 0, 0, 24599, 24600, 5, 95, 0, 0, 24600, + 24601, 7, 2, 0, 0, 24601, 24602, 7, 15, 0, 0, 24602, 24603, 5, 95, 0, 0, + 24603, 24604, 7, 15, 0, 0, 24604, 24605, 7, 0, 0, 0, 24605, 24606, 7, 3, + 0, 0, 24606, 3592, 1, 0, 0, 0, 24607, 24608, 7, 5, 0, 0, 24608, 24609, + 7, 18, 0, 0, 24609, 24610, 7, 5, 0, 0, 24610, 24611, 5, 95, 0, 0, 24611, + 24612, 7, 2, 0, 0, 24612, 24613, 7, 15, 0, 0, 24613, 24614, 5, 95, 0, 0, + 24614, 24615, 7, 15, 0, 0, 24615, 24616, 7, 0, 0, 0, 24616, 24617, 7, 3, + 0, 0, 24617, 24618, 7, 4, 0, 0, 24618, 24619, 5, 95, 0, 0, 24619, 24620, + 7, 12, 0, 0, 24620, 24621, 7, 9, 0, 0, 24621, 3594, 1, 0, 0, 0, 24622, + 24623, 7, 5, 0, 0, 24623, 24624, 7, 18, 0, 0, 24624, 24625, 7, 5, 0, 0, + 24625, 24626, 5, 95, 0, 0, 24626, 24627, 7, 2, 0, 0, 24627, 24628, 7, 15, + 0, 0, 24628, 24629, 5, 95, 0, 0, 24629, 24630, 7, 15, 0, 0, 24630, 24631, + 7, 12, 0, 0, 24631, 24632, 7, 13, 0, 0, 24632, 24633, 7, 2, 0, 0, 24633, + 24634, 7, 4, 0, 0, 24634, 3596, 1, 0, 0, 0, 24635, 24636, 7, 5, 0, 0, 24636, + 24637, 7, 18, 0, 0, 24637, 24638, 7, 5, 0, 0, 24638, 24639, 5, 95, 0, 0, + 24639, 24640, 7, 2, 0, 0, 24640, 24641, 7, 15, 0, 0, 24641, 24642, 5, 95, + 0, 0, 24642, 24643, 7, 3, 0, 0, 24643, 24644, 5, 50, 0, 0, 24644, 24645, + 7, 2, 0, 0, 24645, 3598, 1, 0, 0, 0, 24646, 24647, 7, 5, 0, 0, 24647, 24648, + 7, 18, 0, 0, 24648, 24649, 7, 5, 0, 0, 24649, 24650, 5, 95, 0, 0, 24650, + 24651, 7, 2, 0, 0, 24651, 24652, 7, 15, 0, 0, 24652, 24653, 5, 95, 0, 0, + 24653, 24654, 7, 3, 0, 0, 24654, 24655, 7, 0, 0, 0, 24655, 24656, 7, 22, + 0, 0, 24656, 24657, 7, 4, 0, 0, 24657, 24658, 7, 2, 0, 0, 24658, 24659, + 7, 7, 0, 0, 24659, 24660, 7, 10, 0, 0, 24660, 24661, 7, 14, 0, 0, 24661, + 3600, 1, 0, 0, 0, 24662, 24663, 7, 5, 0, 0, 24663, 24664, 7, 18, 0, 0, + 24664, 24665, 7, 5, 0, 0, 24665, 24666, 5, 95, 0, 0, 24666, 24667, 7, 2, + 0, 0, 24667, 24668, 7, 15, 0, 0, 24668, 24669, 5, 95, 0, 0, 24669, 24670, + 7, 3, 0, 0, 24670, 24671, 7, 9, 0, 0, 24671, 24672, 7, 4, 0, 0, 24672, + 24673, 7, 14, 0, 0, 24673, 3602, 1, 0, 0, 0, 24674, 24675, 7, 5, 0, 0, + 24675, 24676, 7, 18, 0, 0, 24676, 24677, 7, 5, 0, 0, 24677, 24678, 5, 95, + 0, 0, 24678, 24679, 7, 2, 0, 0, 24679, 24680, 7, 15, 0, 0, 24680, 24681, + 5, 95, 0, 0, 24681, 24682, 7, 3, 0, 0, 24682, 24683, 7, 6, 0, 0, 24683, + 24684, 7, 16, 0, 0, 24684, 3604, 1, 0, 0, 0, 24685, 24686, 7, 5, 0, 0, + 24686, 24687, 7, 18, 0, 0, 24687, 24688, 7, 5, 0, 0, 24688, 24689, 5, 95, + 0, 0, 24689, 24690, 7, 2, 0, 0, 24690, 24691, 7, 15, 0, 0, 24691, 24692, + 5, 95, 0, 0, 24692, 24693, 7, 3, 0, 0, 24693, 24694, 7, 14, 0, 0, 24694, + 24695, 7, 4, 0, 0, 24695, 24696, 7, 9, 0, 0, 24696, 3606, 1, 0, 0, 0, 24697, + 24698, 7, 5, 0, 0, 24698, 24699, 7, 18, 0, 0, 24699, 24700, 7, 5, 0, 0, + 24700, 24701, 5, 95, 0, 0, 24701, 24702, 7, 2, 0, 0, 24702, 24703, 7, 15, + 0, 0, 24703, 24704, 5, 95, 0, 0, 24704, 24705, 7, 3, 0, 0, 24705, 24706, + 7, 2, 0, 0, 24706, 24707, 7, 22, 0, 0, 24707, 24708, 7, 12, 0, 0, 24708, + 24709, 7, 9, 0, 0, 24709, 24710, 7, 4, 0, 0, 24710, 24711, 7, 2, 0, 0, + 24711, 24712, 7, 2, 0, 0, 24712, 24713, 7, 1, 0, 0, 24713, 24714, 7, 20, + 0, 0, 24714, 3608, 1, 0, 0, 0, 24715, 24716, 7, 5, 0, 0, 24716, 24717, + 7, 18, 0, 0, 24717, 24718, 7, 5, 0, 0, 24718, 24719, 5, 95, 0, 0, 24719, + 24720, 7, 2, 0, 0, 24720, 24721, 7, 15, 0, 0, 24721, 24722, 5, 95, 0, 0, + 24722, 24723, 7, 3, 0, 0, 24723, 24724, 7, 15, 0, 0, 24724, 24725, 7, 1, + 0, 0, 24725, 3610, 1, 0, 0, 0, 24726, 24727, 7, 5, 0, 0, 24727, 24728, + 7, 18, 0, 0, 24728, 24729, 7, 5, 0, 0, 24729, 24730, 5, 95, 0, 0, 24730, + 24731, 7, 2, 0, 0, 24731, 24732, 7, 15, 0, 0, 24732, 24733, 7, 4, 0, 0, + 24733, 24734, 7, 11, 0, 0, 24734, 24735, 7, 2, 0, 0, 24735, 24736, 7, 1, + 0, 0, 24736, 24737, 7, 15, 0, 0, 24737, 24738, 7, 3, 0, 0, 24738, 24739, + 7, 1, 0, 0, 24739, 24740, 7, 5, 0, 0, 24740, 24741, 7, 8, 0, 0, 24741, + 3612, 1, 0, 0, 0, 24742, 24743, 7, 5, 0, 0, 24743, 24744, 7, 18, 0, 0, + 24744, 24745, 7, 5, 0, 0, 24745, 24746, 5, 95, 0, 0, 24746, 24747, 7, 2, + 0, 0, 24747, 24748, 7, 15, 0, 0, 24748, 24749, 5, 95, 0, 0, 24749, 24750, + 7, 4, 0, 0, 24750, 24751, 7, 2, 0, 0, 24751, 24752, 7, 5, 0, 0, 24752, + 24753, 7, 6, 0, 0, 24753, 24754, 7, 4, 0, 0, 24754, 24755, 7, 12, 0, 0, + 24755, 24756, 7, 9, 0, 0, 24756, 3614, 1, 0, 0, 0, 24757, 24758, 7, 5, + 0, 0, 24758, 24759, 7, 18, 0, 0, 24759, 24760, 7, 5, 0, 0, 24760, 24761, + 5, 95, 0, 0, 24761, 24762, 7, 2, 0, 0, 24762, 24763, 7, 15, 0, 0, 24763, + 24764, 5, 95, 0, 0, 24764, 24765, 7, 4, 0, 0, 24765, 24766, 7, 15, 0, 0, + 24766, 24767, 7, 3, 0, 0, 24767, 3616, 1, 0, 0, 0, 24768, 24769, 7, 5, + 0, 0, 24769, 24770, 7, 18, 0, 0, 24770, 24771, 7, 5, 0, 0, 24771, 24772, + 5, 95, 0, 0, 24772, 24773, 7, 2, 0, 0, 24773, 24774, 7, 15, 0, 0, 24774, + 24775, 5, 95, 0, 0, 24775, 24776, 7, 4, 0, 0, 24776, 24777, 7, 3, 0, 0, + 24777, 24778, 7, 4, 0, 0, 24778, 24779, 7, 1, 0, 0, 24779, 3618, 1, 0, + 0, 0, 24780, 24781, 7, 5, 0, 0, 24781, 24782, 7, 18, 0, 0, 24782, 24783, + 7, 5, 0, 0, 24783, 24784, 5, 95, 0, 0, 24784, 24785, 7, 2, 0, 0, 24785, + 24786, 7, 15, 0, 0, 24786, 24787, 7, 4, 0, 0, 24787, 24788, 7, 25, 0, 0, + 24788, 24789, 7, 12, 0, 0, 24789, 24790, 7, 8, 0, 0, 24790, 24791, 7, 14, + 0, 0, 24791, 24792, 7, 15, 0, 0, 24792, 3620, 1, 0, 0, 0, 24793, 24794, + 7, 5, 0, 0, 24794, 24795, 7, 18, 0, 0, 24795, 24796, 7, 5, 0, 0, 24796, + 24797, 5, 95, 0, 0, 24797, 24798, 7, 2, 0, 0, 24798, 24799, 7, 15, 0, 0, + 24799, 24800, 7, 4, 0, 0, 24800, 24801, 7, 25, 0, 0, 24801, 24802, 7, 24, + 0, 0, 24802, 24803, 7, 8, 0, 0, 24803, 24804, 7, 0, 0, 0, 24804, 24805, + 7, 5, 0, 0, 24805, 24806, 7, 4, 0, 0, 24806, 24807, 7, 0, 0, 0, 24807, + 24808, 7, 5, 0, 0, 24808, 24809, 7, 7, 0, 0, 24809, 24810, 7, 24, 0, 0, + 24810, 3622, 1, 0, 0, 0, 24811, 24812, 7, 5, 0, 0, 24812, 24813, 7, 18, + 0, 0, 24813, 24814, 7, 5, 0, 0, 24814, 24815, 5, 95, 0, 0, 24815, 24816, + 7, 2, 0, 0, 24816, 24817, 7, 15, 0, 0, 24817, 24818, 5, 95, 0, 0, 24818, + 24819, 7, 10, 0, 0, 24819, 24820, 7, 7, 0, 0, 24820, 24821, 7, 9, 0, 0, + 24821, 24822, 7, 6, 0, 0, 24822, 24823, 7, 5, 0, 0, 24823, 24824, 7, 8, + 0, 0, 24824, 24825, 7, 6, 0, 0, 24825, 24826, 7, 7, 0, 0, 24826, 24827, + 7, 9, 0, 0, 24827, 3624, 1, 0, 0, 0, 24828, 24829, 7, 5, 0, 0, 24829, 24830, + 7, 18, 0, 0, 24830, 24831, 7, 5, 0, 0, 24831, 24832, 5, 95, 0, 0, 24832, + 24833, 7, 2, 0, 0, 24833, 24834, 7, 15, 0, 0, 24834, 24835, 5, 95, 0, 0, + 24835, 24836, 7, 13, 0, 0, 24836, 24837, 7, 6, 0, 0, 24837, 24838, 7, 8, + 0, 0, 24838, 24839, 7, 0, 0, 0, 24839, 24840, 7, 7, 0, 0, 24840, 24841, + 7, 9, 0, 0, 24841, 3626, 1, 0, 0, 0, 24842, 24843, 7, 5, 0, 0, 24843, 24844, + 7, 18, 0, 0, 24844, 24845, 7, 5, 0, 0, 24845, 24846, 5, 95, 0, 0, 24846, + 24847, 7, 2, 0, 0, 24847, 24848, 7, 15, 0, 0, 24848, 24849, 5, 95, 0, 0, + 24849, 24850, 7, 13, 0, 0, 24850, 24851, 7, 6, 0, 0, 24851, 24852, 7, 8, + 0, 0, 24852, 24853, 7, 1, 0, 0, 24853, 24854, 7, 12, 0, 0, 24854, 24855, + 7, 4, 0, 0, 24855, 3628, 1, 0, 0, 0, 24856, 24857, 7, 5, 0, 0, 24857, 24858, + 7, 18, 0, 0, 24858, 24859, 7, 5, 0, 0, 24859, 24860, 5, 95, 0, 0, 24860, + 24861, 7, 2, 0, 0, 24861, 24862, 7, 15, 0, 0, 24862, 24863, 5, 95, 0, 0, + 24863, 24864, 7, 13, 0, 0, 24864, 24865, 7, 6, 0, 0, 24865, 24866, 7, 8, + 0, 0, 24866, 24867, 7, 2, 0, 0, 24867, 24868, 7, 3, 0, 0, 24868, 3630, + 1, 0, 0, 0, 24869, 24870, 7, 5, 0, 0, 24870, 24871, 7, 18, 0, 0, 24871, + 24872, 7, 5, 0, 0, 24872, 24873, 5, 95, 0, 0, 24873, 24874, 7, 2, 0, 0, + 24874, 24875, 7, 15, 0, 0, 24875, 24876, 5, 95, 0, 0, 24876, 24877, 7, + 13, 0, 0, 24877, 24878, 7, 6, 0, 0, 24878, 24879, 7, 8, 0, 0, 24879, 24880, + 7, 25, 0, 0, 24880, 24881, 7, 2, 0, 0, 24881, 24882, 7, 3, 0, 0, 24882, + 3632, 1, 0, 0, 0, 24883, 24884, 7, 5, 0, 0, 24884, 24885, 7, 18, 0, 0, + 24885, 24886, 7, 5, 0, 0, 24886, 24887, 5, 95, 0, 0, 24887, 24888, 7, 2, + 0, 0, 24888, 24889, 7, 15, 0, 0, 24889, 24890, 5, 95, 0, 0, 24890, 24891, + 7, 13, 0, 0, 24891, 24892, 7, 6, 0, 0, 24892, 24893, 7, 3, 0, 0, 24893, + 24894, 7, 5, 0, 0, 24894, 24895, 7, 12, 0, 0, 24895, 24896, 7, 2, 0, 0, + 24896, 24897, 7, 7, 0, 0, 24897, 3634, 1, 0, 0, 0, 24898, 24899, 7, 5, + 0, 0, 24899, 24900, 7, 18, 0, 0, 24900, 24901, 7, 5, 0, 0, 24901, 24902, + 5, 95, 0, 0, 24902, 24903, 7, 2, 0, 0, 24903, 24904, 7, 15, 0, 0, 24904, + 24905, 5, 95, 0, 0, 24905, 24906, 7, 13, 0, 0, 24906, 24907, 7, 3, 0, 0, + 24907, 24908, 7, 6, 0, 0, 24908, 24909, 7, 16, 0, 0, 24909, 3636, 1, 0, + 0, 0, 24910, 24911, 7, 5, 0, 0, 24911, 24912, 7, 18, 0, 0, 24912, 24913, + 7, 5, 0, 0, 24913, 24914, 5, 95, 0, 0, 24914, 24915, 7, 2, 0, 0, 24915, + 24916, 7, 15, 0, 0, 24916, 24917, 5, 95, 0, 0, 24917, 24918, 7, 13, 0, + 0, 24918, 24919, 7, 13, 0, 0, 24919, 24920, 7, 9, 0, 0, 24920, 3638, 1, + 0, 0, 0, 24921, 24922, 7, 5, 0, 0, 24922, 24923, 7, 18, 0, 0, 24923, 24924, + 7, 5, 0, 0, 24924, 24925, 5, 95, 0, 0, 24925, 24926, 7, 2, 0, 0, 24926, + 24927, 7, 15, 0, 0, 24927, 24928, 5, 95, 0, 0, 24928, 24929, 7, 25, 0, + 0, 24929, 24930, 7, 14, 0, 0, 24930, 24931, 7, 11, 0, 0, 24931, 24932, + 7, 8, 0, 0, 24932, 24933, 7, 2, 0, 0, 24933, 24934, 7, 7, 0, 0, 24934, + 24935, 7, 5, 0, 0, 24935, 24936, 5, 95, 0, 0, 24936, 24937, 7, 16, 0, 0, + 24937, 24938, 7, 2, 0, 0, 24938, 24939, 7, 3, 0, 0, 24939, 24940, 5, 95, + 0, 0, 24940, 24941, 7, 8, 0, 0, 24941, 24942, 7, 5, 0, 0, 24942, 24943, + 7, 25, 0, 0, 24943, 3640, 1, 0, 0, 0, 24944, 24945, 7, 5, 0, 0, 24945, + 24946, 7, 18, 0, 0, 24946, 24947, 7, 5, 0, 0, 24947, 24948, 5, 95, 0, 0, + 24948, 24949, 7, 2, 0, 0, 24949, 24950, 7, 15, 0, 0, 24950, 24951, 5, 95, + 0, 0, 24951, 24952, 7, 25, 0, 0, 24952, 24953, 7, 15, 0, 0, 24953, 24954, + 7, 4, 0, 0, 24954, 24955, 7, 19, 0, 0, 24955, 24956, 7, 0, 0, 0, 24956, + 24957, 7, 4, 0, 0, 24957, 24958, 7, 17, 0, 0, 24958, 3642, 1, 0, 0, 0, + 24959, 24960, 7, 5, 0, 0, 24960, 24961, 7, 18, 0, 0, 24961, 24962, 7, 5, + 0, 0, 24962, 24963, 5, 95, 0, 0, 24963, 24964, 7, 2, 0, 0, 24964, 24965, + 7, 15, 0, 0, 24965, 24966, 5, 95, 0, 0, 24966, 24967, 7, 25, 0, 0, 24967, + 24968, 7, 15, 0, 0, 24968, 24969, 7, 4, 0, 0, 24969, 24970, 7, 19, 0, 0, + 24970, 24971, 7, 12, 0, 0, 24971, 24972, 7, 9, 0, 0, 24972, 24973, 7, 25, + 0, 0, 24973, 3644, 1, 0, 0, 0, 24974, 24975, 7, 5, 0, 0, 24975, 24976, + 7, 18, 0, 0, 24976, 24977, 7, 5, 0, 0, 24977, 24978, 5, 95, 0, 0, 24978, + 24979, 7, 2, 0, 0, 24979, 24980, 7, 15, 0, 0, 24980, 24981, 5, 95, 0, 0, + 24981, 24982, 7, 25, 0, 0, 24982, 24983, 7, 15, 0, 0, 24983, 24984, 7, + 4, 0, 0, 24984, 24985, 7, 19, 0, 0, 24985, 24986, 7, 2, 0, 0, 24986, 24987, + 7, 15, 0, 0, 24987, 3646, 1, 0, 0, 0, 24988, 24989, 7, 5, 0, 0, 24989, + 24990, 7, 18, 0, 0, 24990, 24991, 7, 5, 0, 0, 24991, 24992, 5, 95, 0, 0, + 24992, 24993, 7, 2, 0, 0, 24993, 24994, 7, 15, 0, 0, 24994, 24995, 5, 95, + 0, 0, 24995, 24996, 7, 25, 0, 0, 24996, 24997, 7, 4, 0, 0, 24997, 24998, + 7, 25, 0, 0, 24998, 24999, 7, 4, 0, 0, 24999, 25000, 5, 50, 0, 0, 25000, + 25001, 7, 5, 0, 0, 25001, 25002, 7, 24, 0, 0, 25002, 25003, 7, 11, 0, 0, + 25003, 25004, 7, 4, 0, 0, 25004, 3648, 1, 0, 0, 0, 25005, 25006, 7, 5, + 0, 0, 25006, 25007, 7, 18, 0, 0, 25007, 25008, 7, 5, 0, 0, 25008, 25009, + 5, 95, 0, 0, 25009, 25010, 7, 2, 0, 0, 25010, 25011, 7, 15, 0, 0, 25011, + 25012, 5, 95, 0, 0, 25012, 25013, 7, 23, 0, 0, 25013, 25014, 7, 2, 0, 0, + 25014, 25015, 7, 7, 0, 0, 25015, 25016, 7, 6, 0, 0, 25016, 25017, 5, 95, + 0, 0, 25017, 25018, 7, 12, 0, 0, 25018, 25019, 7, 9, 0, 0, 25019, 3650, + 1, 0, 0, 0, 25020, 25021, 7, 5, 0, 0, 25021, 25022, 7, 18, 0, 0, 25022, + 25023, 7, 5, 0, 0, 25023, 25024, 5, 95, 0, 0, 25024, 25025, 7, 2, 0, 0, + 25025, 25026, 7, 3, 0, 0, 25026, 25027, 7, 9, 0, 0, 25027, 25028, 7, 6, + 0, 0, 25028, 25029, 7, 3, 0, 0, 25029, 25030, 7, 21, 0, 0, 25030, 25031, + 7, 6, 0, 0, 25031, 25032, 7, 18, 0, 0, 25032, 25033, 5, 95, 0, 0, 25033, + 25034, 7, 9, 0, 0, 25034, 25035, 7, 6, 0, 0, 25035, 25036, 7, 15, 0, 0, + 25036, 25037, 7, 4, 0, 0, 25037, 25038, 7, 19, 0, 0, 25038, 3652, 1, 0, + 0, 0, 25039, 25040, 7, 5, 0, 0, 25040, 25041, 7, 18, 0, 0, 25041, 25042, + 7, 5, 0, 0, 25042, 25043, 5, 95, 0, 0, 25043, 25044, 7, 2, 0, 0, 25044, + 25045, 7, 3, 0, 0, 25045, 25046, 7, 9, 0, 0, 25046, 25047, 7, 6, 0, 0, + 25047, 25048, 7, 3, 0, 0, 25048, 25049, 7, 21, 0, 0, 25049, 25050, 7, 6, + 0, 0, 25050, 25051, 7, 18, 0, 0, 25051, 25052, 5, 95, 0, 0, 25052, 25053, + 7, 14, 0, 0, 25053, 25054, 7, 0, 0, 0, 25054, 25055, 7, 25, 0, 0, 25055, + 25056, 7, 8, 0, 0, 25056, 25057, 7, 19, 0, 0, 25057, 25058, 7, 12, 0, 0, + 25058, 25059, 7, 11, 0, 0, 25059, 25060, 7, 9, 0, 0, 25060, 3654, 1, 0, + 0, 0, 25061, 25062, 7, 5, 0, 0, 25062, 25063, 7, 18, 0, 0, 25063, 25064, + 7, 5, 0, 0, 25064, 25065, 5, 95, 0, 0, 25065, 25066, 7, 2, 0, 0, 25066, + 25067, 7, 3, 0, 0, 25067, 25068, 7, 9, 0, 0, 25068, 25069, 7, 6, 0, 0, + 25069, 25070, 7, 3, 0, 0, 25070, 25071, 7, 21, 0, 0, 25071, 25072, 7, 6, + 0, 0, 25072, 25073, 7, 18, 0, 0, 25073, 25074, 5, 95, 0, 0, 25074, 25075, + 7, 15, 0, 0, 25075, 25076, 7, 0, 0, 0, 25076, 25077, 7, 3, 0, 0, 25077, + 25078, 7, 6, 0, 0, 25078, 25079, 7, 7, 0, 0, 25079, 25080, 7, 4, 0, 0, + 25080, 3656, 1, 0, 0, 0, 25081, 25082, 7, 5, 0, 0, 25082, 25083, 7, 18, + 0, 0, 25083, 25084, 7, 5, 0, 0, 25084, 25085, 5, 95, 0, 0, 25085, 25086, + 7, 15, 0, 0, 25086, 25087, 7, 0, 0, 0, 25087, 25088, 7, 3, 0, 0, 25088, + 25089, 7, 0, 0, 0, 25089, 25090, 7, 11, 0, 0, 25090, 25091, 7, 11, 0, 0, + 25091, 25092, 7, 6, 0, 0, 25092, 25093, 7, 11, 0, 0, 25093, 25094, 5, 95, + 0, 0, 25094, 25095, 7, 4, 0, 0, 25095, 25096, 7, 25, 0, 0, 25096, 25097, + 7, 7, 0, 0, 25097, 3658, 1, 0, 0, 0, 25098, 25099, 7, 5, 0, 0, 25099, 25100, + 7, 18, 0, 0, 25100, 25101, 7, 5, 0, 0, 25101, 25102, 5, 95, 0, 0, 25102, + 25103, 7, 15, 0, 0, 25103, 25104, 7, 0, 0, 0, 25104, 25105, 7, 4, 0, 0, + 25105, 25106, 7, 19, 0, 0, 25106, 25107, 7, 12, 0, 0, 25107, 25108, 7, + 9, 0, 0, 25108, 25109, 5, 95, 0, 0, 25109, 25110, 7, 12, 0, 0, 25110, 25111, + 7, 5, 0, 0, 25111, 25112, 5, 95, 0, 0, 25112, 25113, 7, 0, 0, 0, 25113, + 25114, 7, 4, 0, 0, 25114, 25115, 7, 4, 0, 0, 25115, 25116, 7, 3, 0, 0, + 25116, 3660, 1, 0, 0, 0, 25117, 25118, 7, 5, 0, 0, 25118, 25119, 7, 18, + 0, 0, 25119, 25120, 7, 5, 0, 0, 25120, 25121, 5, 95, 0, 0, 25121, 25122, + 7, 15, 0, 0, 25122, 25123, 7, 0, 0, 0, 25123, 25124, 7, 4, 0, 0, 25124, + 25125, 7, 19, 0, 0, 25125, 25126, 7, 12, 0, 0, 25126, 25127, 7, 9, 0, 0, + 25127, 25128, 5, 95, 0, 0, 25128, 25129, 7, 12, 0, 0, 25129, 25130, 7, + 5, 0, 0, 25130, 25131, 5, 95, 0, 0, 25131, 25132, 7, 7, 0, 0, 25132, 25133, + 7, 14, 0, 0, 25133, 25134, 7, 5, 0, 0, 25134, 25135, 7, 15, 0, 0, 25135, + 25136, 7, 8, 0, 0, 25136, 3662, 1, 0, 0, 0, 25137, 25138, 7, 5, 0, 0, 25138, + 25139, 7, 18, 0, 0, 25139, 25140, 7, 5, 0, 0, 25140, 25141, 5, 95, 0, 0, + 25141, 25142, 7, 15, 0, 0, 25142, 25143, 7, 0, 0, 0, 25143, 25144, 7, 4, + 0, 0, 25144, 25145, 7, 19, 0, 0, 25145, 25146, 7, 12, 0, 0, 25146, 25147, + 7, 9, 0, 0, 25147, 25148, 5, 95, 0, 0, 25148, 25149, 7, 11, 0, 0, 25149, + 25150, 7, 0, 0, 0, 25150, 25151, 7, 5, 0, 0, 25151, 25152, 7, 4, 0, 0, + 25152, 25153, 7, 7, 0, 0, 25153, 25154, 7, 0, 0, 0, 25154, 25155, 7, 14, + 0, 0, 25155, 25156, 7, 6, 0, 0, 25156, 3664, 1, 0, 0, 0, 25157, 25158, + 7, 5, 0, 0, 25158, 25159, 7, 18, 0, 0, 25159, 25160, 7, 5, 0, 0, 25160, + 25161, 5, 95, 0, 0, 25161, 25162, 7, 15, 0, 0, 25162, 25163, 7, 0, 0, 0, + 25163, 25164, 7, 4, 0, 0, 25164, 25165, 7, 19, 0, 0, 25165, 25166, 7, 12, + 0, 0, 25166, 25167, 7, 9, 0, 0, 25167, 25168, 5, 95, 0, 0, 25168, 25169, + 7, 11, 0, 0, 25169, 25170, 7, 0, 0, 0, 25170, 25171, 7, 5, 0, 0, 25171, + 25172, 7, 4, 0, 0, 25172, 25173, 7, 7, 0, 0, 25173, 25174, 7, 14, 0, 0, + 25174, 25175, 7, 5, 0, 0, 25175, 25176, 7, 15, 0, 0, 25176, 25177, 7, 8, + 0, 0, 25177, 3666, 1, 0, 0, 0, 25178, 25179, 7, 5, 0, 0, 25179, 25180, + 7, 18, 0, 0, 25180, 25181, 7, 5, 0, 0, 25181, 25182, 5, 95, 0, 0, 25182, + 25183, 7, 15, 0, 0, 25183, 25184, 7, 0, 0, 0, 25184, 25185, 7, 4, 0, 0, + 25185, 25186, 7, 19, 0, 0, 25186, 25187, 5, 95, 0, 0, 25187, 25188, 7, + 3, 0, 0, 25188, 25189, 7, 6, 0, 0, 25189, 25190, 7, 13, 0, 0, 25190, 25191, + 7, 6, 0, 0, 25191, 25192, 7, 3, 0, 0, 25192, 25193, 7, 5, 0, 0, 25193, + 25194, 7, 6, 0, 0, 25194, 3668, 1, 0, 0, 0, 25195, 25196, 7, 5, 0, 0, 25196, + 25197, 7, 18, 0, 0, 25197, 25198, 7, 5, 0, 0, 25198, 25199, 5, 95, 0, 0, + 25199, 25200, 7, 15, 0, 0, 25200, 25201, 7, 25, 0, 0, 25201, 25202, 7, + 24, 0, 0, 25202, 25203, 7, 6, 0, 0, 25203, 25204, 7, 25, 0, 0, 25204, 25205, + 7, 4, 0, 0, 25205, 25206, 7, 3, 0, 0, 25206, 25207, 7, 0, 0, 0, 25207, + 25208, 7, 8, 0, 0, 25208, 25209, 7, 4, 0, 0, 25209, 3670, 1, 0, 0, 0, 25210, + 25211, 7, 5, 0, 0, 25211, 25212, 7, 18, 0, 0, 25212, 25213, 7, 5, 0, 0, + 25213, 25214, 5, 95, 0, 0, 25214, 25215, 7, 3, 0, 0, 25215, 25216, 7, 0, + 0, 0, 25216, 25217, 7, 22, 0, 0, 25217, 25218, 5, 95, 0, 0, 25218, 25219, + 7, 4, 0, 0, 25219, 25220, 7, 2, 0, 0, 25220, 25221, 5, 95, 0, 0, 25221, + 25222, 7, 25, 0, 0, 25222, 25223, 7, 5, 0, 0, 25223, 25224, 7, 12, 0, 0, + 25224, 25225, 7, 9, 0, 0, 25225, 3672, 1, 0, 0, 0, 25226, 25227, 7, 5, + 0, 0, 25227, 25228, 7, 18, 0, 0, 25228, 25229, 7, 5, 0, 0, 25229, 25230, + 5, 95, 0, 0, 25230, 25231, 7, 3, 0, 0, 25231, 25232, 7, 12, 0, 0, 25232, + 25233, 7, 9, 0, 0, 25233, 25234, 5, 95, 0, 0, 25234, 25235, 7, 2, 0, 0, + 25235, 25236, 7, 3, 0, 0, 25236, 25237, 7, 9, 0, 0, 25237, 25238, 7, 6, + 0, 0, 25238, 25239, 7, 3, 0, 0, 25239, 3674, 1, 0, 0, 0, 25240, 25241, + 7, 5, 0, 0, 25241, 25242, 7, 18, 0, 0, 25242, 25243, 7, 5, 0, 0, 25243, + 25244, 5, 95, 0, 0, 25244, 25245, 7, 3, 0, 0, 25245, 25246, 7, 2, 0, 0, + 25246, 25247, 7, 22, 0, 0, 25247, 25248, 5, 95, 0, 0, 25248, 25249, 7, + 9, 0, 0, 25249, 25250, 7, 6, 0, 0, 25250, 25251, 7, 11, 0, 0, 25251, 25252, + 7, 4, 0, 0, 25252, 25253, 7, 0, 0, 0, 25253, 3676, 1, 0, 0, 0, 25254, 25255, + 7, 5, 0, 0, 25255, 25256, 7, 18, 0, 0, 25256, 25257, 7, 5, 0, 0, 25257, + 25258, 5, 95, 0, 0, 25258, 25259, 7, 5, 0, 0, 25259, 25260, 7, 8, 0, 0, + 25260, 25261, 5, 95, 0, 0, 25261, 25262, 5, 50, 0, 0, 25262, 25263, 5, + 95, 0, 0, 25263, 25264, 7, 25, 0, 0, 25264, 25265, 7, 14, 0, 0, 25265, + 25266, 7, 11, 0, 0, 25266, 25267, 7, 4, 0, 0, 25267, 3678, 1, 0, 0, 0, + 25268, 25269, 7, 5, 0, 0, 25269, 25270, 7, 18, 0, 0, 25270, 25271, 7, 5, + 0, 0, 25271, 25272, 5, 95, 0, 0, 25272, 25273, 7, 5, 0, 0, 25273, 25274, + 7, 18, 0, 0, 25274, 25275, 7, 7, 0, 0, 25275, 25276, 7, 3, 0, 0, 25276, + 25277, 7, 8, 0, 0, 25277, 25278, 7, 12, 0, 0, 25278, 25279, 7, 3, 0, 0, + 25279, 25280, 7, 6, 0, 0, 25280, 25281, 7, 9, 0, 0, 25281, 25282, 7, 2, + 0, 0, 25282, 3680, 1, 0, 0, 0, 25283, 25284, 7, 5, 0, 0, 25284, 25285, + 7, 18, 0, 0, 25285, 25286, 7, 5, 0, 0, 25286, 25287, 7, 4, 0, 0, 25287, + 25288, 7, 6, 0, 0, 25288, 25289, 7, 14, 0, 0, 25289, 25290, 5, 95, 0, 0, + 25290, 25291, 7, 9, 0, 0, 25291, 25292, 7, 6, 0, 0, 25292, 25293, 7, 16, + 0, 0, 25293, 25294, 7, 12, 0, 0, 25294, 25295, 7, 7, 0, 0, 25295, 25296, + 7, 6, 0, 0, 25296, 25297, 7, 9, 0, 0, 25297, 3682, 1, 0, 0, 0, 25298, 25299, + 7, 5, 0, 0, 25299, 25300, 7, 18, 0, 0, 25300, 25301, 7, 5, 0, 0, 25301, + 25302, 7, 4, 0, 0, 25302, 25303, 7, 6, 0, 0, 25303, 25304, 7, 14, 0, 0, + 25304, 3684, 1, 0, 0, 0, 25305, 25306, 7, 5, 0, 0, 25306, 25307, 7, 18, + 0, 0, 25307, 25308, 7, 5, 0, 0, 25308, 25309, 7, 4, 0, 0, 25309, 25310, + 7, 12, 0, 0, 25310, 25311, 7, 14, 0, 0, 25311, 25312, 7, 6, 0, 0, 25312, + 25313, 7, 5, 0, 0, 25313, 25314, 7, 4, 0, 0, 25314, 25315, 7, 0, 0, 0, + 25315, 25316, 7, 14, 0, 0, 25316, 25317, 7, 15, 0, 0, 25317, 3686, 1, 0, + 0, 0, 25318, 25319, 7, 5, 0, 0, 25319, 25320, 7, 18, 0, 0, 25320, 25321, + 7, 5, 0, 0, 25321, 25322, 5, 95, 0, 0, 25322, 25323, 7, 4, 0, 0, 25323, + 25324, 7, 18, 0, 0, 25324, 25325, 7, 15, 0, 0, 25325, 25326, 7, 6, 0, 0, + 25326, 25327, 7, 12, 0, 0, 25327, 25328, 7, 9, 0, 0, 25328, 3688, 1, 0, + 0, 0, 25329, 25330, 7, 5, 0, 0, 25330, 25331, 7, 18, 0, 0, 25331, 25332, + 7, 5, 0, 0, 25332, 25333, 5, 95, 0, 0, 25333, 25334, 7, 10, 0, 0, 25334, + 25335, 7, 14, 0, 0, 25335, 25336, 7, 0, 0, 0, 25336, 25337, 7, 21, 0, 0, + 25337, 25338, 7, 6, 0, 0, 25338, 25339, 7, 25, 0, 0, 25339, 25340, 7, 14, + 0, 0, 25340, 25341, 7, 11, 0, 0, 25341, 3690, 1, 0, 0, 0, 25342, 25343, + 7, 5, 0, 0, 25343, 25344, 7, 18, 0, 0, 25344, 25345, 7, 5, 0, 0, 25345, + 25346, 5, 95, 0, 0, 25346, 25347, 7, 25, 0, 0, 25347, 25348, 7, 14, 0, + 0, 25348, 25349, 7, 11, 0, 0, 25349, 25350, 7, 0, 0, 0, 25350, 25351, 7, + 7, 0, 0, 25351, 25352, 7, 0, 0, 0, 25352, 25353, 7, 11, 0, 0, 25353, 25354, + 7, 18, 0, 0, 25354, 25355, 7, 23, 0, 0, 25355, 25356, 7, 6, 0, 0, 25356, + 3692, 1, 0, 0, 0, 25357, 25358, 7, 5, 0, 0, 25358, 25359, 7, 18, 0, 0, + 25359, 25360, 7, 5, 0, 0, 25360, 25361, 5, 95, 0, 0, 25361, 25362, 7, 25, + 0, 0, 25362, 25363, 7, 14, 0, 0, 25363, 25364, 7, 11, 0, 0, 25364, 25365, + 7, 8, 0, 0, 25365, 25366, 7, 2, 0, 0, 25366, 25367, 7, 7, 0, 0, 25367, + 25368, 7, 4, 0, 0, 25368, 25369, 7, 0, 0, 0, 25369, 25370, 7, 12, 0, 0, + 25370, 25371, 7, 7, 0, 0, 25371, 25372, 7, 5, 0, 0, 25372, 3694, 1, 0, + 0, 0, 25373, 25374, 7, 5, 0, 0, 25374, 25375, 7, 18, 0, 0, 25375, 25376, + 7, 5, 0, 0, 25376, 25377, 5, 95, 0, 0, 25377, 25378, 7, 25, 0, 0, 25378, + 25379, 7, 14, 0, 0, 25379, 25380, 7, 11, 0, 0, 25380, 25381, 7, 8, 0, 0, + 25381, 25382, 7, 2, 0, 0, 25382, 25383, 7, 7, 0, 0, 25383, 25384, 7, 13, + 0, 0, 25384, 3696, 1, 0, 0, 0, 25385, 25386, 7, 5, 0, 0, 25386, 25387, + 7, 18, 0, 0, 25387, 25388, 7, 5, 0, 0, 25388, 25389, 5, 95, 0, 0, 25389, + 25390, 7, 25, 0, 0, 25390, 25391, 7, 14, 0, 0, 25391, 25392, 7, 11, 0, + 0, 25392, 25393, 7, 6, 0, 0, 25393, 25394, 7, 25, 0, 0, 25394, 25395, 7, + 7, 0, 0, 25395, 25396, 7, 5, 0, 0, 25396, 25397, 7, 10, 0, 0, 25397, 25398, + 7, 3, 0, 0, 25398, 25399, 7, 12, 0, 0, 25399, 3698, 1, 0, 0, 0, 25400, + 25401, 7, 5, 0, 0, 25401, 25402, 7, 18, 0, 0, 25402, 25403, 7, 5, 0, 0, + 25403, 25404, 5, 95, 0, 0, 25404, 25405, 7, 25, 0, 0, 25405, 25406, 7, + 14, 0, 0, 25406, 25407, 7, 11, 0, 0, 25407, 25408, 7, 17, 0, 0, 25408, + 25409, 7, 6, 0, 0, 25409, 25410, 7, 7, 0, 0, 25410, 3700, 1, 0, 0, 0, 25411, + 25412, 7, 5, 0, 0, 25412, 25413, 7, 18, 0, 0, 25413, 25414, 7, 5, 0, 0, + 25414, 25415, 5, 95, 0, 0, 25415, 25416, 7, 25, 0, 0, 25416, 25417, 7, + 14, 0, 0, 25417, 25418, 7, 11, 0, 0, 25418, 25419, 7, 12, 0, 0, 25419, + 25420, 5, 95, 0, 0, 25420, 25421, 7, 11, 0, 0, 25421, 25422, 7, 2, 0, 0, + 25422, 25423, 7, 8, 0, 0, 25423, 25424, 5, 95, 0, 0, 25424, 25425, 7, 12, + 0, 0, 25425, 25426, 7, 5, 0, 0, 25426, 25427, 7, 7, 0, 0, 25427, 25428, + 7, 2, 0, 0, 25428, 25429, 7, 9, 0, 0, 25429, 25430, 7, 6, 0, 0, 25430, + 3702, 1, 0, 0, 0, 25431, 25432, 7, 5, 0, 0, 25432, 25433, 7, 18, 0, 0, + 25433, 25434, 7, 5, 0, 0, 25434, 25435, 5, 95, 0, 0, 25435, 25436, 7, 25, + 0, 0, 25436, 25437, 7, 14, 0, 0, 25437, 25438, 7, 11, 0, 0, 25438, 25439, + 7, 12, 0, 0, 25439, 25440, 5, 95, 0, 0, 25440, 25441, 7, 11, 0, 0, 25441, + 25442, 7, 2, 0, 0, 25442, 25443, 7, 8, 0, 0, 25443, 25444, 5, 95, 0, 0, + 25444, 25445, 7, 12, 0, 0, 25445, 25446, 7, 5, 0, 0, 25446, 25447, 7, 4, + 0, 0, 25447, 25448, 7, 6, 0, 0, 25448, 25449, 7, 25, 0, 0, 25449, 25450, + 7, 4, 0, 0, 25450, 3704, 1, 0, 0, 0, 25451, 25452, 7, 5, 0, 0, 25452, 25453, + 7, 18, 0, 0, 25453, 25454, 7, 5, 0, 0, 25454, 25455, 5, 95, 0, 0, 25455, + 25456, 7, 25, 0, 0, 25456, 25457, 7, 14, 0, 0, 25457, 25458, 7, 11, 0, + 0, 25458, 25459, 7, 12, 0, 0, 25459, 25460, 7, 7, 0, 0, 25460, 25461, 7, + 5, 0, 0, 25461, 25462, 7, 4, 0, 0, 25462, 25463, 7, 3, 0, 0, 25463, 3706, + 1, 0, 0, 0, 25464, 25465, 7, 5, 0, 0, 25465, 25466, 7, 18, 0, 0, 25466, + 25467, 7, 5, 0, 0, 25467, 25468, 5, 95, 0, 0, 25468, 25469, 7, 25, 0, 0, + 25469, 25470, 7, 14, 0, 0, 25470, 25471, 7, 11, 0, 0, 25471, 25472, 7, + 11, 0, 0, 25472, 25473, 7, 2, 0, 0, 25473, 25474, 7, 8, 0, 0, 25474, 25475, + 7, 0, 0, 0, 25475, 25476, 7, 4, 0, 0, 25476, 25477, 7, 2, 0, 0, 25477, + 25478, 7, 3, 0, 0, 25478, 25479, 5, 95, 0, 0, 25479, 25480, 7, 17, 0, 0, + 25480, 25481, 7, 6, 0, 0, 25481, 25482, 7, 4, 0, 0, 25482, 25483, 7, 5, + 0, 0, 25483, 25484, 7, 13, 0, 0, 25484, 25485, 7, 0, 0, 0, 25485, 25486, + 7, 11, 0, 0, 25486, 3708, 1, 0, 0, 0, 25487, 25488, 7, 5, 0, 0, 25488, + 25489, 7, 18, 0, 0, 25489, 25490, 7, 5, 0, 0, 25490, 25491, 5, 95, 0, 0, + 25491, 25492, 7, 25, 0, 0, 25492, 25493, 7, 14, 0, 0, 25493, 25494, 7, + 11, 0, 0, 25494, 25495, 7, 7, 0, 0, 25495, 25496, 7, 2, 0, 0, 25496, 25497, + 7, 9, 0, 0, 25497, 25498, 7, 6, 0, 0, 25498, 25499, 7, 12, 0, 0, 25499, + 25500, 7, 9, 0, 0, 25500, 25501, 5, 95, 0, 0, 25501, 25502, 7, 17, 0, 0, + 25502, 25503, 7, 6, 0, 0, 25503, 25504, 7, 4, 0, 0, 25504, 25505, 7, 8, + 0, 0, 25505, 25506, 7, 12, 0, 0, 25506, 25507, 7, 9, 0, 0, 25507, 3710, + 1, 0, 0, 0, 25508, 25509, 7, 5, 0, 0, 25509, 25510, 7, 18, 0, 0, 25510, + 25511, 7, 5, 0, 0, 25511, 25512, 5, 95, 0, 0, 25512, 25513, 7, 25, 0, 0, + 25513, 25514, 7, 14, 0, 0, 25514, 25515, 7, 11, 0, 0, 25515, 25516, 7, + 7, 0, 0, 25516, 25517, 7, 2, 0, 0, 25517, 25518, 7, 9, 0, 0, 25518, 25519, + 7, 6, 0, 0, 25519, 25520, 7, 12, 0, 0, 25520, 25521, 7, 9, 0, 0, 25521, + 25522, 5, 95, 0, 0, 25522, 25523, 7, 17, 0, 0, 25523, 25524, 7, 6, 0, 0, + 25524, 25525, 7, 4, 0, 0, 25525, 25526, 7, 11, 0, 0, 25526, 25527, 7, 2, + 0, 0, 25527, 25528, 7, 8, 0, 0, 25528, 25529, 7, 0, 0, 0, 25529, 25530, + 7, 4, 0, 0, 25530, 25531, 7, 2, 0, 0, 25531, 25532, 7, 3, 0, 0, 25532, + 3712, 1, 0, 0, 0, 25533, 25534, 7, 5, 0, 0, 25534, 25535, 7, 18, 0, 0, + 25535, 25536, 7, 5, 0, 0, 25536, 25537, 5, 95, 0, 0, 25537, 25538, 7, 25, + 0, 0, 25538, 25539, 7, 14, 0, 0, 25539, 25540, 7, 11, 0, 0, 25540, 25541, + 7, 7, 0, 0, 25541, 25542, 7, 2, 0, 0, 25542, 25543, 7, 9, 0, 0, 25543, + 25544, 7, 6, 0, 0, 25544, 25545, 7, 12, 0, 0, 25545, 25546, 7, 9, 0, 0, + 25546, 25547, 5, 95, 0, 0, 25547, 25548, 7, 17, 0, 0, 25548, 25549, 7, + 6, 0, 0, 25549, 25550, 7, 4, 0, 0, 25550, 25551, 7, 2, 0, 0, 25551, 25552, + 7, 21, 0, 0, 25552, 25553, 7, 6, 0, 0, 25553, 25554, 7, 18, 0, 0, 25554, + 3714, 1, 0, 0, 0, 25555, 25556, 7, 5, 0, 0, 25556, 25557, 7, 18, 0, 0, + 25557, 25558, 7, 5, 0, 0, 25558, 25559, 5, 95, 0, 0, 25559, 25560, 7, 25, + 0, 0, 25560, 25561, 7, 14, 0, 0, 25561, 25562, 7, 11, 0, 0, 25562, 25563, + 7, 7, 0, 0, 25563, 25564, 7, 2, 0, 0, 25564, 25565, 7, 9, 0, 0, 25565, + 25566, 7, 6, 0, 0, 25566, 25567, 7, 12, 0, 0, 25567, 25568, 7, 9, 0, 0, + 25568, 25569, 5, 95, 0, 0, 25569, 25570, 7, 17, 0, 0, 25570, 25571, 7, + 6, 0, 0, 25571, 25572, 7, 4, 0, 0, 25572, 25573, 7, 15, 0, 0, 25573, 25574, + 7, 0, 0, 0, 25574, 25575, 7, 4, 0, 0, 25575, 25576, 7, 19, 0, 0, 25576, + 25577, 7, 12, 0, 0, 25577, 25578, 7, 9, 0, 0, 25578, 3716, 1, 0, 0, 0, + 25579, 25580, 7, 5, 0, 0, 25580, 25581, 7, 18, 0, 0, 25581, 25582, 7, 5, + 0, 0, 25582, 25583, 5, 95, 0, 0, 25583, 25584, 7, 25, 0, 0, 25584, 25585, + 7, 14, 0, 0, 25585, 25586, 7, 11, 0, 0, 25586, 25587, 7, 7, 0, 0, 25587, + 25588, 7, 2, 0, 0, 25588, 25589, 7, 9, 0, 0, 25589, 25590, 7, 6, 0, 0, + 25590, 25591, 7, 12, 0, 0, 25591, 25592, 7, 9, 0, 0, 25592, 25593, 5, 95, + 0, 0, 25593, 25594, 7, 17, 0, 0, 25594, 25595, 7, 6, 0, 0, 25595, 25596, + 7, 4, 0, 0, 25596, 25597, 7, 15, 0, 0, 25597, 25598, 7, 4, 0, 0, 25598, + 25599, 7, 3, 0, 0, 25599, 25600, 7, 12, 0, 0, 25600, 25601, 7, 9, 0, 0, + 25601, 3718, 1, 0, 0, 0, 25602, 25603, 7, 5, 0, 0, 25603, 25604, 7, 18, + 0, 0, 25604, 25605, 7, 5, 0, 0, 25605, 25606, 5, 95, 0, 0, 25606, 25607, + 7, 25, 0, 0, 25607, 25608, 7, 14, 0, 0, 25608, 25609, 7, 11, 0, 0, 25609, + 25610, 7, 7, 0, 0, 25610, 25611, 7, 2, 0, 0, 25611, 25612, 7, 9, 0, 0, + 25612, 25613, 7, 6, 0, 0, 25613, 25614, 7, 12, 0, 0, 25614, 25615, 7, 9, + 0, 0, 25615, 25616, 5, 95, 0, 0, 25616, 25617, 7, 17, 0, 0, 25617, 25618, + 7, 6, 0, 0, 25618, 25619, 7, 4, 0, 0, 25619, 25620, 7, 3, 0, 0, 25620, + 25621, 7, 12, 0, 0, 25621, 25622, 7, 9, 0, 0, 25622, 3720, 1, 0, 0, 0, + 25623, 25624, 7, 5, 0, 0, 25624, 25625, 7, 18, 0, 0, 25625, 25626, 7, 5, + 0, 0, 25626, 25627, 5, 95, 0, 0, 25627, 25628, 7, 25, 0, 0, 25628, 25629, + 7, 14, 0, 0, 25629, 25630, 7, 11, 0, 0, 25630, 25631, 7, 7, 0, 0, 25631, + 25632, 7, 2, 0, 0, 25632, 25633, 7, 9, 0, 0, 25633, 25634, 7, 6, 0, 0, + 25634, 25635, 7, 12, 0, 0, 25635, 25636, 7, 9, 0, 0, 25636, 25637, 5, 95, + 0, 0, 25637, 25638, 7, 17, 0, 0, 25638, 25639, 7, 6, 0, 0, 25639, 25640, + 7, 4, 0, 0, 25640, 25641, 7, 5, 0, 0, 25641, 25642, 7, 13, 0, 0, 25642, + 25643, 7, 0, 0, 0, 25643, 25644, 7, 11, 0, 0, 25644, 3722, 1, 0, 0, 0, + 25645, 25646, 7, 5, 0, 0, 25646, 25647, 7, 18, 0, 0, 25647, 25648, 7, 5, + 0, 0, 25648, 25649, 5, 95, 0, 0, 25649, 25650, 7, 25, 0, 0, 25650, 25651, + 7, 14, 0, 0, 25651, 25652, 7, 11, 0, 0, 25652, 25653, 7, 7, 0, 0, 25653, + 25654, 7, 2, 0, 0, 25654, 25655, 7, 9, 0, 0, 25655, 25656, 7, 6, 0, 0, + 25656, 25657, 7, 12, 0, 0, 25657, 25658, 7, 9, 0, 0, 25658, 25659, 5, 95, + 0, 0, 25659, 25660, 7, 17, 0, 0, 25660, 25661, 7, 6, 0, 0, 25661, 25662, + 7, 4, 0, 0, 25662, 25663, 7, 4, 0, 0, 25663, 25664, 7, 12, 0, 0, 25664, + 25665, 7, 9, 0, 0, 25665, 3724, 1, 0, 0, 0, 25666, 25667, 7, 5, 0, 0, 25667, + 25668, 7, 18, 0, 0, 25668, 25669, 7, 5, 0, 0, 25669, 25670, 5, 95, 0, 0, + 25670, 25671, 7, 25, 0, 0, 25671, 25672, 7, 14, 0, 0, 25672, 25673, 7, + 11, 0, 0, 25673, 25674, 7, 7, 0, 0, 25674, 25675, 7, 2, 0, 0, 25675, 25676, + 7, 9, 0, 0, 25676, 25677, 7, 6, 0, 0, 25677, 25678, 7, 12, 0, 0, 25678, + 25679, 7, 9, 0, 0, 25679, 3726, 1, 0, 0, 0, 25680, 25681, 7, 5, 0, 0, 25681, + 25682, 7, 18, 0, 0, 25682, 25683, 7, 5, 0, 0, 25683, 25684, 5, 95, 0, 0, + 25684, 25685, 7, 25, 0, 0, 25685, 25686, 7, 14, 0, 0, 25686, 25687, 7, + 11, 0, 0, 25687, 25688, 7, 4, 0, 0, 25688, 25689, 5, 95, 0, 0, 25689, 25690, + 5, 50, 0, 0, 25690, 25691, 5, 95, 0, 0, 25691, 25692, 7, 5, 0, 0, 25692, + 25693, 7, 8, 0, 0, 25693, 3728, 1, 0, 0, 0, 25694, 25695, 7, 5, 0, 0, 25695, + 25696, 7, 18, 0, 0, 25696, 25697, 7, 5, 0, 0, 25697, 25698, 5, 95, 0, 0, + 25698, 25699, 7, 25, 0, 0, 25699, 25700, 7, 14, 0, 0, 25700, 25701, 7, + 11, 0, 0, 25701, 25702, 7, 4, 0, 0, 25702, 25703, 7, 3, 0, 0, 25703, 25704, + 7, 0, 0, 0, 25704, 25705, 7, 7, 0, 0, 25705, 25706, 7, 5, 0, 0, 25706, + 25707, 7, 11, 0, 0, 25707, 25708, 7, 0, 0, 0, 25708, 25709, 7, 4, 0, 0, + 25709, 25710, 7, 6, 0, 0, 25710, 3730, 1, 0, 0, 0, 25711, 25712, 7, 5, + 0, 0, 25712, 25713, 7, 18, 0, 0, 25713, 25714, 7, 5, 0, 0, 25714, 25715, + 5, 95, 0, 0, 25715, 25716, 7, 25, 0, 0, 25716, 25717, 7, 14, 0, 0, 25717, + 25718, 7, 11, 0, 0, 25718, 25719, 7, 4, 0, 0, 25719, 25720, 7, 18, 0, 0, + 25720, 25721, 7, 15, 0, 0, 25721, 25722, 7, 6, 0, 0, 25722, 25723, 5, 50, + 0, 0, 25723, 25724, 7, 5, 0, 0, 25724, 25725, 7, 24, 0, 0, 25725, 25726, + 7, 11, 0, 0, 25726, 3732, 1, 0, 0, 0, 25727, 25728, 7, 5, 0, 0, 25728, + 25729, 7, 18, 0, 0, 25729, 25730, 7, 5, 0, 0, 25730, 25731, 5, 95, 0, 0, + 25731, 25732, 7, 25, 0, 0, 25732, 25733, 7, 24, 0, 0, 25733, 25734, 5, + 95, 0, 0, 25734, 25735, 7, 0, 0, 0, 25735, 25736, 7, 5, 0, 0, 25736, 25737, + 7, 24, 0, 0, 25737, 25738, 7, 11, 0, 0, 25738, 25739, 7, 8, 0, 0, 25739, + 25740, 7, 7, 0, 0, 25740, 25741, 7, 13, 0, 0, 25741, 3734, 1, 0, 0, 0, + 25742, 25743, 7, 5, 0, 0, 25743, 25744, 7, 18, 0, 0, 25744, 25745, 7, 5, + 0, 0, 25745, 25746, 5, 95, 0, 0, 25746, 25747, 7, 25, 0, 0, 25747, 25748, + 7, 24, 0, 0, 25748, 25749, 5, 95, 0, 0, 25749, 25750, 7, 0, 0, 0, 25750, + 25751, 7, 4, 0, 0, 25751, 25752, 7, 2, 0, 0, 25752, 25753, 7, 14, 0, 0, + 25753, 25754, 7, 8, 0, 0, 25754, 25755, 7, 7, 0, 0, 25755, 25756, 7, 13, + 0, 0, 25756, 25757, 7, 8, 0, 0, 25757, 25758, 7, 19, 0, 0, 25758, 25759, + 7, 21, 0, 0, 25759, 3736, 1, 0, 0, 0, 25760, 25761, 7, 5, 0, 0, 25761, + 25762, 7, 18, 0, 0, 25762, 25763, 7, 5, 0, 0, 25763, 25764, 5, 95, 0, 0, + 25764, 25765, 7, 25, 0, 0, 25765, 25766, 7, 24, 0, 0, 25766, 25767, 7, + 1, 0, 0, 25767, 25768, 7, 0, 0, 0, 25768, 25769, 7, 5, 0, 0, 25769, 25770, + 7, 6, 0, 0, 25770, 25771, 7, 10, 0, 0, 25771, 25772, 7, 3, 0, 0, 25772, + 25773, 7, 12, 0, 0, 25773, 3738, 1, 0, 0, 0, 25774, 25775, 7, 5, 0, 0, + 25775, 25776, 7, 18, 0, 0, 25776, 25777, 7, 5, 0, 0, 25777, 25778, 5, 95, + 0, 0, 25778, 25779, 7, 25, 0, 0, 25779, 25780, 7, 24, 0, 0, 25780, 25781, + 7, 8, 0, 0, 25781, 25782, 7, 0, 0, 0, 25782, 25783, 7, 5, 0, 0, 25783, + 25784, 7, 4, 0, 0, 25784, 25785, 7, 0, 0, 0, 25785, 25786, 7, 1, 0, 0, + 25786, 25787, 7, 11, 0, 0, 25787, 25788, 7, 6, 0, 0, 25788, 25789, 7, 6, + 0, 0, 25789, 25790, 7, 3, 0, 0, 25790, 25791, 7, 3, 0, 0, 25791, 25792, + 7, 19, 0, 0, 25792, 3740, 1, 0, 0, 0, 25793, 25794, 7, 5, 0, 0, 25794, + 25795, 7, 18, 0, 0, 25795, 25796, 7, 5, 0, 0, 25796, 25797, 5, 95, 0, 0, + 25797, 25798, 7, 25, 0, 0, 25798, 25799, 7, 24, 0, 0, 25799, 25800, 7, + 8, 0, 0, 25800, 25801, 7, 2, 0, 0, 25801, 25802, 7, 9, 0, 0, 25802, 25803, + 7, 6, 0, 0, 25803, 25804, 7, 15, 0, 0, 25804, 25805, 5, 50, 0, 0, 25805, + 25806, 7, 5, 0, 0, 25806, 25807, 7, 4, 0, 0, 25807, 25808, 7, 3, 0, 0, + 25808, 3742, 1, 0, 0, 0, 25809, 25810, 7, 5, 0, 0, 25810, 25811, 7, 18, + 0, 0, 25811, 25812, 7, 5, 0, 0, 25812, 25813, 5, 95, 0, 0, 25813, 25814, + 7, 25, 0, 0, 25814, 25815, 7, 24, 0, 0, 25815, 25816, 7, 8, 0, 0, 25816, + 25817, 7, 2, 0, 0, 25817, 25818, 7, 9, 0, 0, 25818, 25819, 7, 6, 0, 0, + 25819, 25820, 7, 15, 0, 0, 25820, 25821, 7, 6, 0, 0, 25821, 25822, 7, 24, + 0, 0, 25822, 3744, 1, 0, 0, 0, 25823, 25824, 7, 5, 0, 0, 25824, 25825, + 7, 18, 0, 0, 25825, 25826, 7, 5, 0, 0, 25826, 25827, 5, 95, 0, 0, 25827, + 25828, 7, 25, 0, 0, 25828, 25829, 7, 24, 0, 0, 25829, 25830, 7, 8, 0, 0, + 25830, 25831, 7, 2, 0, 0, 25831, 25832, 7, 7, 0, 0, 25832, 25833, 5, 50, + 0, 0, 25833, 25834, 7, 5, 0, 0, 25834, 25835, 7, 6, 0, 0, 25835, 25836, + 7, 24, 0, 0, 25836, 3746, 1, 0, 0, 0, 25837, 25838, 7, 5, 0, 0, 25838, + 25839, 7, 18, 0, 0, 25839, 25840, 7, 5, 0, 0, 25840, 25841, 5, 95, 0, 0, + 25841, 25842, 7, 25, 0, 0, 25842, 25843, 7, 24, 0, 0, 25843, 25844, 7, + 8, 0, 0, 25844, 25845, 7, 2, 0, 0, 25845, 25846, 7, 7, 0, 0, 25846, 25847, + 7, 8, 0, 0, 25847, 25848, 7, 0, 0, 0, 25848, 25849, 7, 4, 0, 0, 25849, + 3748, 1, 0, 0, 0, 25850, 25851, 7, 5, 0, 0, 25851, 25852, 7, 18, 0, 0, + 25852, 25853, 7, 5, 0, 0, 25853, 25854, 5, 95, 0, 0, 25854, 25855, 7, 25, + 0, 0, 25855, 25856, 7, 24, 0, 0, 25856, 25857, 7, 9, 0, 0, 25857, 25858, + 7, 6, 0, 0, 25858, 25859, 7, 11, 0, 0, 25859, 25860, 7, 6, 0, 0, 25860, + 25861, 7, 4, 0, 0, 25861, 25862, 7, 6, 0, 0, 25862, 3750, 1, 0, 0, 0, 25863, + 25864, 7, 5, 0, 0, 25864, 25865, 7, 18, 0, 0, 25865, 25866, 7, 5, 0, 0, + 25866, 25867, 5, 95, 0, 0, 25867, 25868, 7, 25, 0, 0, 25868, 25869, 7, + 24, 0, 0, 25869, 25870, 7, 9, 0, 0, 25870, 25871, 7, 16, 0, 0, 25871, 25872, + 7, 11, 0, 0, 25872, 25873, 7, 4, 0, 0, 25873, 25874, 7, 8, 0, 0, 25874, + 25875, 7, 2, 0, 0, 25875, 25876, 7, 11, 0, 0, 25876, 25877, 7, 0, 0, 0, + 25877, 25878, 7, 4, 0, 0, 25878, 25879, 7, 12, 0, 0, 25879, 25880, 7, 2, + 0, 0, 25880, 25881, 7, 7, 0, 0, 25881, 3752, 1, 0, 0, 0, 25882, 25883, + 7, 5, 0, 0, 25883, 25884, 7, 18, 0, 0, 25884, 25885, 7, 5, 0, 0, 25885, + 25886, 5, 95, 0, 0, 25886, 25887, 7, 25, 0, 0, 25887, 25888, 7, 24, 0, + 0, 25888, 25889, 7, 9, 0, 0, 25889, 25890, 7, 2, 0, 0, 25890, 25891, 7, + 8, 0, 0, 25891, 3754, 1, 0, 0, 0, 25892, 25893, 7, 5, 0, 0, 25893, 25894, + 7, 18, 0, 0, 25894, 25895, 7, 5, 0, 0, 25895, 25896, 5, 95, 0, 0, 25896, + 25897, 7, 25, 0, 0, 25897, 25898, 7, 24, 0, 0, 25898, 25899, 7, 9, 0, 0, + 25899, 25900, 7, 2, 0, 0, 25900, 25901, 7, 8, 0, 0, 25901, 25902, 7, 10, + 0, 0, 25902, 25903, 7, 3, 0, 0, 25903, 25904, 7, 12, 0, 0, 25904, 3756, + 1, 0, 0, 0, 25905, 25906, 7, 5, 0, 0, 25906, 25907, 7, 18, 0, 0, 25907, + 25908, 7, 5, 0, 0, 25908, 25909, 5, 95, 0, 0, 25909, 25910, 7, 25, 0, 0, + 25910, 25911, 7, 24, 0, 0, 25911, 25912, 7, 9, 0, 0, 25912, 25913, 7, 10, + 0, 0, 25913, 25914, 7, 3, 0, 0, 25914, 25915, 7, 9, 0, 0, 25915, 25916, + 7, 12, 0, 0, 25916, 25917, 7, 13, 0, 0, 25917, 3758, 1, 0, 0, 0, 25918, + 25919, 7, 5, 0, 0, 25919, 25920, 7, 18, 0, 0, 25920, 25921, 7, 5, 0, 0, + 25921, 25922, 5, 95, 0, 0, 25922, 25923, 7, 25, 0, 0, 25923, 25924, 7, + 24, 0, 0, 25924, 25925, 7, 6, 0, 0, 25925, 25926, 7, 9, 0, 0, 25926, 25927, + 5, 52, 0, 0, 25927, 25928, 7, 10, 0, 0, 25928, 25929, 7, 3, 0, 0, 25929, + 25930, 7, 12, 0, 0, 25930, 3760, 1, 0, 0, 0, 25931, 25932, 7, 5, 0, 0, + 25932, 25933, 7, 18, 0, 0, 25933, 25934, 7, 5, 0, 0, 25934, 25935, 5, 95, + 0, 0, 25935, 25936, 7, 25, 0, 0, 25936, 25937, 7, 24, 0, 0, 25937, 25938, + 7, 6, 0, 0, 25938, 25939, 7, 7, 0, 0, 25939, 25940, 7, 9, 0, 0, 25940, + 25941, 7, 5, 0, 0, 25941, 25942, 7, 22, 0, 0, 25942, 25943, 7, 12, 0, 0, + 25943, 25944, 7, 4, 0, 0, 25944, 25945, 7, 19, 0, 0, 25945, 3762, 1, 0, + 0, 0, 25946, 25947, 7, 5, 0, 0, 25947, 25948, 7, 18, 0, 0, 25948, 25949, + 7, 5, 0, 0, 25949, 25950, 5, 95, 0, 0, 25950, 25951, 7, 25, 0, 0, 25951, + 25952, 7, 24, 0, 0, 25952, 25953, 7, 6, 0, 0, 25953, 25954, 7, 3, 0, 0, + 25954, 25955, 7, 3, 0, 0, 25955, 25956, 7, 19, 0, 0, 25956, 3764, 1, 0, + 0, 0, 25957, 25958, 7, 5, 0, 0, 25958, 25959, 7, 18, 0, 0, 25959, 25960, + 7, 5, 0, 0, 25960, 25961, 5, 95, 0, 0, 25961, 25962, 7, 25, 0, 0, 25962, + 25963, 7, 24, 0, 0, 25963, 25964, 7, 6, 0, 0, 25964, 25965, 7, 3, 0, 0, + 25965, 25966, 7, 3, 0, 0, 25966, 3766, 1, 0, 0, 0, 25967, 25968, 7, 5, + 0, 0, 25968, 25969, 7, 18, 0, 0, 25969, 25970, 7, 5, 0, 0, 25970, 25971, + 5, 95, 0, 0, 25971, 25972, 7, 25, 0, 0, 25972, 25973, 7, 24, 0, 0, 25973, + 25974, 7, 6, 0, 0, 25974, 25975, 7, 5, 0, 0, 25975, 25976, 7, 19, 0, 0, + 25976, 25977, 7, 4, 0, 0, 25977, 25978, 7, 14, 0, 0, 25978, 25979, 7, 11, + 0, 0, 25979, 25980, 7, 10, 0, 0, 25980, 25981, 7, 3, 0, 0, 25981, 25982, + 7, 12, 0, 0, 25982, 3768, 1, 0, 0, 0, 25983, 25984, 7, 5, 0, 0, 25984, + 25985, 7, 18, 0, 0, 25985, 25986, 7, 5, 0, 0, 25986, 25987, 5, 95, 0, 0, + 25987, 25988, 7, 25, 0, 0, 25988, 25989, 7, 24, 0, 0, 25989, 25990, 7, + 6, 0, 0, 25990, 25991, 7, 25, 0, 0, 25991, 25992, 7, 11, 0, 0, 25992, 25993, + 7, 2, 0, 0, 25993, 25994, 7, 1, 0, 0, 25994, 25995, 7, 13, 0, 0, 25995, + 25996, 7, 0, 0, 0, 25996, 25997, 7, 11, 0, 0, 25997, 3770, 1, 0, 0, 0, + 25998, 25999, 7, 5, 0, 0, 25999, 26000, 7, 18, 0, 0, 26000, 26001, 7, 5, + 0, 0, 26001, 26002, 5, 95, 0, 0, 26002, 26003, 7, 25, 0, 0, 26003, 26004, + 7, 24, 0, 0, 26004, 26005, 7, 6, 0, 0, 26005, 26006, 7, 25, 0, 0, 26006, + 26007, 7, 5, 0, 0, 26007, 26008, 7, 4, 0, 0, 26008, 26009, 7, 22, 0, 0, + 26009, 26010, 7, 3, 0, 0, 26010, 26011, 7, 15, 0, 0, 26011, 3772, 1, 0, + 0, 0, 26012, 26013, 7, 5, 0, 0, 26013, 26014, 7, 18, 0, 0, 26014, 26015, + 7, 5, 0, 0, 26015, 26016, 5, 95, 0, 0, 26016, 26017, 7, 25, 0, 0, 26017, + 26018, 7, 24, 0, 0, 26018, 26019, 7, 6, 0, 0, 26019, 26020, 7, 25, 0, 0, + 26020, 26021, 7, 4, 0, 0, 26021, 26022, 7, 3, 0, 0, 26022, 26023, 7, 0, + 0, 0, 26023, 26024, 7, 8, 0, 0, 26024, 26025, 7, 4, 0, 0, 26025, 3774, + 1, 0, 0, 0, 26026, 26027, 7, 5, 0, 0, 26027, 26028, 7, 18, 0, 0, 26028, + 26029, 7, 5, 0, 0, 26029, 26030, 5, 95, 0, 0, 26030, 26031, 7, 25, 0, 0, + 26031, 26032, 7, 24, 0, 0, 26032, 26033, 7, 6, 0, 0, 26033, 26034, 7, 25, + 0, 0, 26034, 26035, 7, 4, 0, 0, 26035, 26036, 7, 3, 0, 0, 26036, 26037, + 7, 3, 0, 0, 26037, 26038, 7, 6, 0, 0, 26038, 26039, 7, 16, 0, 0, 26039, + 3776, 1, 0, 0, 0, 26040, 26041, 7, 5, 0, 0, 26041, 26042, 7, 18, 0, 0, + 26042, 26043, 7, 5, 0, 0, 26043, 26044, 5, 95, 0, 0, 26044, 26045, 7, 25, + 0, 0, 26045, 26046, 7, 24, 0, 0, 26046, 26047, 7, 6, 0, 0, 26047, 26048, + 7, 25, 0, 0, 26048, 26049, 7, 13, 0, 0, 26049, 26050, 7, 0, 0, 0, 26050, + 26051, 7, 11, 0, 0, 26051, 3778, 1, 0, 0, 0, 26052, 26053, 7, 5, 0, 0, + 26053, 26054, 7, 18, 0, 0, 26054, 26055, 7, 5, 0, 0, 26055, 26056, 5, 95, + 0, 0, 26056, 26057, 7, 25, 0, 0, 26057, 26058, 7, 24, 0, 0, 26058, 26059, + 7, 16, 0, 0, 26059, 26060, 7, 1, 0, 0, 26060, 26061, 5, 50, 0, 0, 26061, + 26062, 7, 5, 0, 0, 26062, 26063, 7, 4, 0, 0, 26063, 26064, 7, 3, 0, 0, + 26064, 3780, 1, 0, 0, 0, 26065, 26066, 7, 5, 0, 0, 26066, 26067, 7, 18, + 0, 0, 26067, 26068, 7, 5, 0, 0, 26068, 26069, 5, 95, 0, 0, 26069, 26070, + 7, 25, 0, 0, 26070, 26071, 7, 24, 0, 0, 26071, 26072, 7, 16, 0, 0, 26072, + 26073, 7, 7, 0, 0, 26073, 26074, 7, 1, 0, 0, 26074, 26075, 7, 2, 0, 0, + 26075, 26076, 7, 2, 0, 0, 26076, 26077, 7, 11, 0, 0, 26077, 3782, 1, 0, + 0, 0, 26078, 26079, 7, 5, 0, 0, 26079, 26080, 7, 18, 0, 0, 26080, 26081, + 7, 5, 0, 0, 26081, 26082, 5, 95, 0, 0, 26082, 26083, 7, 25, 0, 0, 26083, + 26084, 7, 24, 0, 0, 26084, 26085, 7, 16, 0, 0, 26085, 26086, 7, 7, 0, 0, + 26086, 26087, 7, 8, 0, 0, 26087, 26088, 7, 14, 0, 0, 26088, 26089, 7, 15, + 0, 0, 26089, 3784, 1, 0, 0, 0, 26090, 26091, 7, 5, 0, 0, 26091, 26092, + 7, 18, 0, 0, 26092, 26093, 7, 5, 0, 0, 26093, 26094, 5, 95, 0, 0, 26094, + 26095, 7, 25, 0, 0, 26095, 26096, 7, 24, 0, 0, 26096, 26097, 7, 16, 0, + 0, 26097, 26098, 7, 7, 0, 0, 26098, 26099, 7, 9, 0, 0, 26099, 26100, 7, + 0, 0, 0, 26100, 26101, 7, 4, 0, 0, 26101, 26102, 7, 12, 0, 0, 26102, 26103, + 7, 14, 0, 0, 26103, 3786, 1, 0, 0, 0, 26104, 26105, 7, 5, 0, 0, 26105, + 26106, 7, 18, 0, 0, 26106, 26107, 7, 5, 0, 0, 26107, 26108, 5, 95, 0, 0, + 26108, 26109, 7, 25, 0, 0, 26109, 26110, 7, 24, 0, 0, 26110, 26111, 7, + 16, 0, 0, 26111, 26112, 7, 7, 0, 0, 26112, 26113, 7, 11, 0, 0, 26113, 26114, + 7, 7, 0, 0, 26114, 26115, 7, 0, 0, 0, 26115, 26116, 7, 14, 0, 0, 26116, + 26117, 7, 6, 0, 0, 26117, 3788, 1, 0, 0, 0, 26118, 26119, 7, 5, 0, 0, 26119, + 26120, 7, 18, 0, 0, 26120, 26121, 7, 5, 0, 0, 26121, 26122, 5, 95, 0, 0, + 26122, 26123, 7, 25, 0, 0, 26123, 26124, 7, 24, 0, 0, 26124, 26125, 7, + 16, 0, 0, 26125, 26126, 7, 7, 0, 0, 26126, 26127, 7, 7, 0, 0, 26127, 26128, + 7, 14, 0, 0, 26128, 3790, 1, 0, 0, 0, 26129, 26130, 7, 5, 0, 0, 26130, + 26131, 7, 18, 0, 0, 26131, 26132, 7, 5, 0, 0, 26132, 26133, 5, 95, 0, 0, + 26133, 26134, 7, 25, 0, 0, 26134, 26135, 7, 24, 0, 0, 26135, 26136, 7, + 16, 0, 0, 26136, 26137, 7, 7, 0, 0, 26137, 26138, 7, 7, 0, 0, 26138, 26139, + 7, 5, 0, 0, 26139, 26140, 7, 10, 0, 0, 26140, 26141, 7, 3, 0, 0, 26141, + 26142, 7, 12, 0, 0, 26142, 3792, 1, 0, 0, 0, 26143, 26144, 7, 5, 0, 0, + 26144, 26145, 7, 18, 0, 0, 26145, 26146, 7, 5, 0, 0, 26146, 26147, 5, 95, + 0, 0, 26147, 26148, 7, 25, 0, 0, 26148, 26149, 7, 24, 0, 0, 26149, 26150, + 7, 16, 0, 0, 26150, 26151, 7, 7, 0, 0, 26151, 26152, 7, 15, 0, 0, 26152, + 26153, 7, 3, 0, 0, 26153, 26154, 7, 6, 0, 0, 26154, 26155, 7, 9, 0, 0, + 26155, 26156, 7, 4, 0, 0, 26156, 26157, 7, 3, 0, 0, 26157, 26158, 7, 10, + 0, 0, 26158, 26159, 7, 4, 0, 0, 26159, 26160, 7, 19, 0, 0, 26160, 3794, + 1, 0, 0, 0, 26161, 26162, 7, 5, 0, 0, 26162, 26163, 7, 18, 0, 0, 26163, + 26164, 7, 5, 0, 0, 26164, 26165, 5, 95, 0, 0, 26165, 26166, 7, 25, 0, 0, + 26166, 26167, 7, 24, 0, 0, 26167, 26168, 7, 16, 0, 0, 26168, 26169, 7, + 7, 0, 0, 26169, 26170, 7, 24, 0, 0, 26170, 26171, 7, 7, 0, 0, 26171, 26172, + 7, 14, 0, 0, 26172, 3796, 1, 0, 0, 0, 26173, 26174, 7, 5, 0, 0, 26174, + 26175, 7, 18, 0, 0, 26175, 26176, 7, 5, 0, 0, 26176, 26177, 5, 95, 0, 0, + 26177, 26178, 7, 25, 0, 0, 26178, 26179, 7, 24, 0, 0, 26179, 26180, 7, + 16, 0, 0, 26180, 26181, 7, 7, 0, 0, 26181, 26182, 7, 3, 0, 0, 26182, 26183, + 7, 2, 0, 0, 26183, 26184, 7, 2, 0, 0, 26184, 26185, 7, 4, 0, 0, 26185, + 3798, 1, 0, 0, 0, 26186, 26187, 7, 5, 0, 0, 26187, 26188, 7, 18, 0, 0, + 26188, 26189, 7, 5, 0, 0, 26189, 26190, 5, 95, 0, 0, 26190, 26191, 7, 25, + 0, 0, 26191, 26192, 7, 24, 0, 0, 26192, 26193, 7, 16, 0, 0, 26193, 26194, + 7, 2, 0, 0, 26194, 26195, 7, 3, 0, 0, 26195, 26196, 7, 14, 0, 0, 26196, + 26197, 7, 0, 0, 0, 26197, 26198, 7, 4, 0, 0, 26198, 26199, 7, 7, 0, 0, + 26199, 26200, 7, 10, 0, 0, 26200, 26201, 7, 14, 0, 0, 26201, 3800, 1, 0, + 0, 0, 26202, 26203, 7, 5, 0, 0, 26203, 26204, 7, 18, 0, 0, 26204, 26205, + 7, 5, 0, 0, 26205, 26206, 5, 95, 0, 0, 26206, 26207, 7, 25, 0, 0, 26207, + 26208, 7, 24, 0, 0, 26208, 26209, 7, 16, 0, 0, 26209, 26210, 7, 4, 0, 0, + 26210, 26211, 7, 8, 0, 0, 26211, 26212, 7, 2, 0, 0, 26212, 26213, 7, 7, + 0, 0, 26213, 26214, 7, 4, 0, 0, 26214, 26215, 7, 0, 0, 0, 26215, 26216, + 7, 12, 0, 0, 26216, 26217, 7, 7, 0, 0, 26217, 3802, 1, 0, 0, 0, 26218, + 26219, 7, 5, 0, 0, 26219, 26220, 7, 18, 0, 0, 26220, 26221, 7, 5, 0, 0, + 26221, 26222, 5, 95, 0, 0, 26222, 26223, 7, 25, 0, 0, 26223, 26224, 7, + 24, 0, 0, 26224, 26225, 7, 16, 0, 0, 26225, 26226, 7, 10, 0, 0, 26226, + 26227, 7, 7, 0, 0, 26227, 26228, 7, 8, 0, 0, 26228, 26229, 7, 3, 0, 0, + 26229, 3804, 1, 0, 0, 0, 26230, 26231, 7, 5, 0, 0, 26231, 26232, 7, 18, + 0, 0, 26232, 26233, 7, 5, 0, 0, 26233, 26234, 5, 95, 0, 0, 26234, 26235, + 7, 25, 0, 0, 26235, 26236, 7, 24, 0, 0, 26236, 26237, 7, 17, 0, 0, 26237, + 26238, 7, 6, 0, 0, 26238, 26239, 7, 4, 0, 0, 26239, 26240, 7, 8, 0, 0, + 26240, 26241, 7, 2, 0, 0, 26241, 26242, 7, 7, 0, 0, 26242, 26243, 7, 4, + 0, 0, 26243, 26244, 7, 6, 0, 0, 26244, 26245, 7, 7, 0, 0, 26245, 26246, + 7, 4, 0, 0, 26246, 3806, 1, 0, 0, 0, 26247, 26248, 7, 5, 0, 0, 26248, 26249, + 7, 18, 0, 0, 26249, 26250, 7, 5, 0, 0, 26250, 26251, 5, 95, 0, 0, 26251, + 26252, 7, 25, 0, 0, 26252, 26253, 7, 24, 0, 0, 26253, 26254, 7, 12, 0, + 0, 26254, 26255, 7, 7, 0, 0, 26255, 26256, 7, 9, 0, 0, 26256, 26257, 7, + 25, 0, 0, 26257, 26258, 7, 2, 0, 0, 26258, 26259, 7, 16, 0, 0, 26259, 3808, + 1, 0, 0, 0, 26260, 26261, 7, 5, 0, 0, 26261, 26262, 7, 18, 0, 0, 26262, + 26263, 7, 5, 0, 0, 26263, 26264, 5, 95, 0, 0, 26264, 26265, 7, 25, 0, 0, + 26265, 26266, 7, 24, 0, 0, 26266, 26267, 7, 12, 0, 0, 26267, 26268, 7, + 7, 0, 0, 26268, 26269, 7, 5, 0, 0, 26269, 26270, 7, 6, 0, 0, 26270, 26271, + 7, 3, 0, 0, 26271, 26272, 7, 4, 0, 0, 26272, 3810, 1, 0, 0, 0, 26273, 26274, + 7, 5, 0, 0, 26274, 26275, 7, 18, 0, 0, 26275, 26276, 7, 5, 0, 0, 26276, + 26277, 5, 95, 0, 0, 26277, 26278, 7, 25, 0, 0, 26278, 26279, 7, 24, 0, + 0, 26279, 26280, 7, 12, 0, 0, 26280, 26281, 7, 7, 0, 0, 26281, 26282, 7, + 5, 0, 0, 26282, 26283, 7, 15, 0, 0, 26283, 26284, 7, 16, 0, 0, 26284, 26285, + 7, 25, 0, 0, 26285, 3812, 1, 0, 0, 0, 26286, 26287, 7, 5, 0, 0, 26287, + 26288, 7, 18, 0, 0, 26288, 26289, 7, 5, 0, 0, 26289, 26290, 5, 95, 0, 0, + 26290, 26291, 7, 25, 0, 0, 26291, 26292, 7, 24, 0, 0, 26292, 26293, 7, + 12, 0, 0, 26293, 26294, 7, 3, 0, 0, 26294, 26295, 7, 12, 0, 0, 26295, 26296, + 5, 50, 0, 0, 26296, 26297, 7, 10, 0, 0, 26297, 26298, 7, 3, 0, 0, 26298, + 26299, 7, 12, 0, 0, 26299, 3814, 1, 0, 0, 0, 26300, 26301, 7, 5, 0, 0, + 26301, 26302, 7, 18, 0, 0, 26302, 26303, 7, 5, 0, 0, 26303, 26304, 5, 95, + 0, 0, 26304, 26305, 7, 25, 0, 0, 26305, 26306, 7, 24, 0, 0, 26306, 26307, + 7, 11, 0, 0, 26307, 26308, 7, 0, 0, 0, 26308, 26309, 7, 7, 0, 0, 26309, + 26310, 7, 17, 0, 0, 26310, 3816, 1, 0, 0, 0, 26311, 26312, 7, 5, 0, 0, + 26312, 26313, 7, 18, 0, 0, 26313, 26314, 7, 5, 0, 0, 26314, 26315, 5, 95, + 0, 0, 26315, 26316, 7, 25, 0, 0, 26316, 26317, 7, 24, 0, 0, 26317, 26318, + 7, 11, 0, 0, 26318, 26319, 7, 11, 0, 0, 26319, 26320, 7, 7, 0, 0, 26320, + 26321, 7, 14, 0, 0, 26321, 26322, 7, 16, 0, 0, 26322, 26323, 7, 3, 0, 0, + 26323, 26324, 7, 14, 0, 0, 26324, 26325, 7, 24, 0, 0, 26325, 26326, 7, + 7, 0, 0, 26326, 26327, 7, 14, 0, 0, 26327, 3818, 1, 0, 0, 0, 26328, 26329, + 7, 5, 0, 0, 26329, 26330, 7, 18, 0, 0, 26330, 26331, 7, 5, 0, 0, 26331, + 26332, 5, 95, 0, 0, 26332, 26333, 7, 25, 0, 0, 26333, 26334, 7, 24, 0, + 0, 26334, 26335, 7, 14, 0, 0, 26335, 26336, 7, 21, 0, 0, 26336, 26337, + 7, 7, 0, 0, 26337, 26338, 7, 2, 0, 0, 26338, 26339, 7, 9, 0, 0, 26339, + 26340, 7, 6, 0, 0, 26340, 26341, 7, 3, 0, 0, 26341, 26342, 7, 6, 0, 0, + 26342, 26343, 7, 16, 0, 0, 26343, 3820, 1, 0, 0, 0, 26344, 26345, 7, 5, + 0, 0, 26345, 26346, 7, 18, 0, 0, 26346, 26347, 7, 5, 0, 0, 26347, 26348, + 5, 95, 0, 0, 26348, 26349, 7, 25, 0, 0, 26349, 26350, 7, 24, 0, 0, 26350, + 26351, 7, 7, 0, 0, 26351, 26352, 7, 12, 0, 0, 26352, 26353, 7, 11, 0, 0, + 26353, 26354, 7, 11, 0, 0, 26354, 26355, 7, 6, 0, 0, 26355, 26356, 7, 9, + 0, 0, 26356, 3822, 1, 0, 0, 0, 26357, 26358, 7, 5, 0, 0, 26358, 26359, + 7, 18, 0, 0, 26359, 26360, 7, 5, 0, 0, 26360, 26361, 5, 95, 0, 0, 26361, + 26362, 7, 25, 0, 0, 26362, 26363, 7, 24, 0, 0, 26363, 26364, 7, 7, 0, 0, + 26364, 26365, 7, 2, 0, 0, 26365, 26366, 7, 9, 0, 0, 26366, 26367, 7, 6, + 0, 0, 26367, 26368, 7, 7, 0, 0, 26368, 26369, 7, 0, 0, 0, 26369, 26370, + 7, 14, 0, 0, 26370, 26371, 7, 6, 0, 0, 26371, 3824, 1, 0, 0, 0, 26372, + 26373, 7, 5, 0, 0, 26373, 26374, 7, 18, 0, 0, 26374, 26375, 7, 5, 0, 0, + 26375, 26376, 5, 95, 0, 0, 26376, 26377, 7, 25, 0, 0, 26377, 26378, 7, + 24, 0, 0, 26378, 26379, 7, 7, 0, 0, 26379, 26380, 7, 2, 0, 0, 26380, 26381, + 7, 3, 0, 0, 26381, 26382, 7, 14, 0, 0, 26382, 26383, 7, 5, 0, 0, 26383, + 26384, 7, 15, 0, 0, 26384, 26385, 7, 0, 0, 0, 26385, 26386, 7, 8, 0, 0, + 26386, 26387, 7, 6, 0, 0, 26387, 3826, 1, 0, 0, 0, 26388, 26389, 7, 5, + 0, 0, 26389, 26390, 7, 18, 0, 0, 26390, 26391, 7, 5, 0, 0, 26391, 26392, + 5, 95, 0, 0, 26392, 26393, 7, 25, 0, 0, 26393, 26394, 7, 24, 0, 0, 26394, + 26395, 7, 7, 0, 0, 26395, 26396, 7, 2, 0, 0, 26396, 26397, 7, 3, 0, 0, + 26397, 26398, 7, 14, 0, 0, 26398, 26399, 7, 10, 0, 0, 26399, 26400, 7, + 8, 0, 0, 26400, 26401, 7, 2, 0, 0, 26401, 26402, 7, 9, 0, 0, 26402, 26403, + 7, 6, 0, 0, 26403, 3828, 1, 0, 0, 0, 26404, 26405, 7, 5, 0, 0, 26405, 26406, + 7, 18, 0, 0, 26406, 26407, 7, 5, 0, 0, 26407, 26408, 5, 95, 0, 0, 26408, + 26409, 7, 25, 0, 0, 26409, 26410, 7, 24, 0, 0, 26410, 26411, 5, 95, 0, + 0, 26411, 26412, 7, 7, 0, 0, 26412, 26413, 7, 3, 0, 0, 26413, 26414, 7, + 7, 0, 0, 26414, 26415, 7, 17, 0, 0, 26415, 3830, 1, 0, 0, 0, 26416, 26417, + 7, 5, 0, 0, 26417, 26418, 7, 18, 0, 0, 26418, 26419, 7, 5, 0, 0, 26419, + 26420, 5, 95, 0, 0, 26420, 26421, 7, 25, 0, 0, 26421, 26422, 7, 24, 0, + 0, 26422, 26423, 7, 7, 0, 0, 26423, 26424, 7, 5, 0, 0, 26424, 26425, 7, + 15, 0, 0, 26425, 26426, 5, 52, 0, 0, 26426, 26427, 7, 15, 0, 0, 26427, + 26428, 7, 16, 0, 0, 26428, 26429, 7, 25, 0, 0, 26429, 3832, 1, 0, 0, 0, + 26430, 26431, 7, 5, 0, 0, 26431, 26432, 7, 18, 0, 0, 26432, 26433, 7, 5, + 0, 0, 26433, 26434, 5, 95, 0, 0, 26434, 26435, 7, 25, 0, 0, 26435, 26436, + 7, 24, 0, 0, 26436, 26437, 7, 7, 0, 0, 26437, 26438, 7, 5, 0, 0, 26438, + 26439, 7, 15, 0, 0, 26439, 26440, 7, 16, 0, 0, 26440, 26441, 7, 3, 0, 0, + 26441, 26442, 7, 14, 0, 0, 26442, 26443, 7, 24, 0, 0, 26443, 26444, 7, + 7, 0, 0, 26444, 26445, 7, 14, 0, 0, 26445, 3834, 1, 0, 0, 0, 26446, 26447, + 7, 5, 0, 0, 26447, 26448, 7, 18, 0, 0, 26448, 26449, 7, 5, 0, 0, 26449, + 26450, 5, 95, 0, 0, 26450, 26451, 7, 25, 0, 0, 26451, 26452, 7, 24, 0, + 0, 26452, 26453, 7, 15, 0, 0, 26453, 26454, 7, 16, 0, 0, 26454, 26455, + 7, 25, 0, 0, 26455, 26456, 7, 16, 0, 0, 26456, 26457, 7, 3, 0, 0, 26457, + 26458, 7, 14, 0, 0, 26458, 26459, 7, 24, 0, 0, 26459, 26460, 7, 7, 0, 0, + 26460, 26461, 7, 14, 0, 0, 26461, 3836, 1, 0, 0, 0, 26462, 26463, 7, 5, + 0, 0, 26463, 26464, 7, 18, 0, 0, 26464, 26465, 7, 5, 0, 0, 26465, 26466, + 5, 95, 0, 0, 26466, 26467, 7, 25, 0, 0, 26467, 26468, 7, 24, 0, 0, 26468, + 26469, 5, 95, 0, 0, 26469, 26470, 7, 15, 0, 0, 26470, 26471, 7, 21, 0, + 0, 26471, 26472, 7, 5, 0, 0, 26472, 26473, 7, 24, 0, 0, 26473, 26474, 7, + 11, 0, 0, 26474, 26475, 5, 50, 0, 0, 26475, 26476, 7, 25, 0, 0, 26476, + 26477, 7, 14, 0, 0, 26477, 26478, 7, 11, 0, 0, 26478, 3838, 1, 0, 0, 0, + 26479, 26480, 7, 5, 0, 0, 26480, 26481, 7, 18, 0, 0, 26481, 26482, 7, 5, + 0, 0, 26482, 26483, 5, 95, 0, 0, 26483, 26484, 7, 25, 0, 0, 26484, 26485, + 7, 24, 0, 0, 26485, 26486, 7, 15, 0, 0, 26486, 26487, 7, 2, 0, 0, 26487, + 26488, 7, 11, 0, 0, 26488, 26489, 7, 18, 0, 0, 26489, 26490, 7, 0, 0, 0, + 26490, 26491, 7, 1, 0, 0, 26491, 26492, 7, 5, 0, 0, 26492, 3840, 1, 0, + 0, 0, 26493, 26494, 7, 5, 0, 0, 26494, 26495, 7, 18, 0, 0, 26495, 26496, + 7, 5, 0, 0, 26496, 26497, 5, 95, 0, 0, 26497, 26498, 7, 25, 0, 0, 26498, + 26499, 7, 24, 0, 0, 26499, 26500, 7, 15, 0, 0, 26500, 26501, 7, 2, 0, 0, + 26501, 26502, 7, 11, 0, 0, 26502, 26503, 7, 18, 0, 0, 26503, 26504, 7, + 0, 0, 0, 26504, 26505, 7, 9, 0, 0, 26505, 26506, 7, 9, 0, 0, 26506, 3842, + 1, 0, 0, 0, 26507, 26508, 7, 5, 0, 0, 26508, 26509, 7, 18, 0, 0, 26509, + 26510, 7, 5, 0, 0, 26510, 26511, 5, 95, 0, 0, 26511, 26512, 7, 25, 0, 0, + 26512, 26513, 7, 24, 0, 0, 26513, 26514, 7, 15, 0, 0, 26514, 26515, 7, + 2, 0, 0, 26515, 26516, 7, 11, 0, 0, 26516, 26517, 7, 18, 0, 0, 26517, 26518, + 7, 8, 0, 0, 26518, 26519, 7, 6, 0, 0, 26519, 26520, 7, 11, 0, 0, 26520, + 3844, 1, 0, 0, 0, 26521, 26522, 7, 5, 0, 0, 26522, 26523, 7, 18, 0, 0, + 26523, 26524, 7, 5, 0, 0, 26524, 26525, 5, 95, 0, 0, 26525, 26526, 7, 25, + 0, 0, 26526, 26527, 7, 24, 0, 0, 26527, 26528, 7, 15, 0, 0, 26528, 26529, + 7, 2, 0, 0, 26529, 26530, 7, 11, 0, 0, 26530, 26531, 7, 18, 0, 0, 26531, + 26532, 7, 8, 0, 0, 26532, 26533, 7, 5, 0, 0, 26533, 26534, 7, 4, 0, 0, + 26534, 26535, 7, 1, 0, 0, 26535, 26536, 7, 11, 0, 0, 26536, 3846, 1, 0, + 0, 0, 26537, 26538, 7, 5, 0, 0, 26538, 26539, 7, 18, 0, 0, 26539, 26540, + 7, 5, 0, 0, 26540, 26541, 5, 95, 0, 0, 26541, 26542, 7, 25, 0, 0, 26542, + 26543, 7, 24, 0, 0, 26543, 26544, 7, 15, 0, 0, 26544, 26545, 7, 2, 0, 0, + 26545, 26546, 7, 11, 0, 0, 26546, 26547, 7, 18, 0, 0, 26547, 26548, 7, + 8, 0, 0, 26548, 26549, 7, 5, 0, 0, 26549, 26550, 7, 4, 0, 0, 26550, 3848, + 1, 0, 0, 0, 26551, 26552, 7, 5, 0, 0, 26552, 26553, 7, 18, 0, 0, 26553, + 26554, 7, 5, 0, 0, 26554, 26555, 5, 95, 0, 0, 26555, 26556, 7, 25, 0, 0, + 26556, 26557, 7, 24, 0, 0, 26557, 26558, 7, 15, 0, 0, 26558, 26559, 7, + 2, 0, 0, 26559, 26560, 7, 11, 0, 0, 26560, 26561, 7, 18, 0, 0, 26561, 26562, + 7, 9, 0, 0, 26562, 26563, 7, 12, 0, 0, 26563, 26564, 7, 13, 0, 0, 26564, + 3850, 1, 0, 0, 0, 26565, 26566, 7, 5, 0, 0, 26566, 26567, 7, 18, 0, 0, + 26567, 26568, 7, 5, 0, 0, 26568, 26569, 5, 95, 0, 0, 26569, 26570, 7, 25, + 0, 0, 26570, 26571, 7, 24, 0, 0, 26571, 26572, 7, 15, 0, 0, 26572, 26573, + 7, 2, 0, 0, 26573, 26574, 7, 11, 0, 0, 26574, 26575, 7, 18, 0, 0, 26575, + 26576, 7, 16, 0, 0, 26576, 26577, 7, 11, 0, 0, 26577, 26578, 7, 3, 0, 0, + 26578, 3852, 1, 0, 0, 0, 26579, 26580, 7, 5, 0, 0, 26580, 26581, 7, 18, + 0, 0, 26581, 26582, 7, 5, 0, 0, 26582, 26583, 5, 95, 0, 0, 26583, 26584, + 7, 25, 0, 0, 26584, 26585, 7, 24, 0, 0, 26585, 26586, 7, 15, 0, 0, 26586, + 26587, 7, 2, 0, 0, 26587, 26588, 7, 11, 0, 0, 26588, 26589, 7, 18, 0, 0, + 26589, 26590, 7, 14, 0, 0, 26590, 26591, 7, 2, 0, 0, 26591, 26592, 7, 9, + 0, 0, 26592, 3854, 1, 0, 0, 0, 26593, 26594, 7, 5, 0, 0, 26594, 26595, + 7, 18, 0, 0, 26595, 26596, 7, 5, 0, 0, 26596, 26597, 5, 95, 0, 0, 26597, + 26598, 7, 25, 0, 0, 26598, 26599, 7, 24, 0, 0, 26599, 26600, 7, 15, 0, + 0, 26600, 26601, 7, 2, 0, 0, 26601, 26602, 7, 11, 0, 0, 26602, 26603, 7, + 18, 0, 0, 26603, 26604, 7, 14, 0, 0, 26604, 26605, 7, 10, 0, 0, 26605, + 26606, 7, 11, 0, 0, 26606, 3856, 1, 0, 0, 0, 26607, 26608, 7, 5, 0, 0, + 26608, 26609, 7, 18, 0, 0, 26609, 26610, 7, 5, 0, 0, 26610, 26611, 5, 95, + 0, 0, 26611, 26612, 7, 25, 0, 0, 26612, 26613, 7, 24, 0, 0, 26613, 26614, + 7, 15, 0, 0, 26614, 26615, 7, 2, 0, 0, 26615, 26616, 7, 11, 0, 0, 26616, + 26617, 7, 18, 0, 0, 26617, 26618, 7, 3, 0, 0, 26618, 26619, 7, 7, 0, 0, + 26619, 26620, 7, 9, 0, 0, 26620, 3858, 1, 0, 0, 0, 26621, 26622, 7, 5, + 0, 0, 26622, 26623, 7, 18, 0, 0, 26623, 26624, 7, 5, 0, 0, 26624, 26625, + 5, 95, 0, 0, 26625, 26626, 7, 25, 0, 0, 26626, 26627, 7, 24, 0, 0, 26627, + 26628, 7, 15, 0, 0, 26628, 26629, 7, 2, 0, 0, 26629, 26630, 7, 11, 0, 0, + 26630, 26631, 7, 18, 0, 0, 26631, 26632, 7, 5, 0, 0, 26632, 26633, 7, 24, + 0, 0, 26633, 26634, 7, 3, 0, 0, 26634, 26635, 7, 4, 0, 0, 26635, 3860, + 1, 0, 0, 0, 26636, 26637, 7, 5, 0, 0, 26637, 26638, 7, 18, 0, 0, 26638, + 26639, 7, 5, 0, 0, 26639, 26640, 5, 95, 0, 0, 26640, 26641, 7, 25, 0, 0, + 26641, 26642, 7, 24, 0, 0, 26642, 26643, 7, 15, 0, 0, 26643, 26644, 7, + 2, 0, 0, 26644, 26645, 7, 11, 0, 0, 26645, 26646, 7, 18, 0, 0, 26646, 26647, + 7, 5, 0, 0, 26647, 26648, 7, 10, 0, 0, 26648, 26649, 7, 1, 0, 0, 26649, + 3862, 1, 0, 0, 0, 26650, 26651, 7, 5, 0, 0, 26651, 26652, 7, 18, 0, 0, + 26652, 26653, 7, 5, 0, 0, 26653, 26654, 5, 95, 0, 0, 26654, 26655, 7, 25, + 0, 0, 26655, 26656, 7, 24, 0, 0, 26656, 26657, 7, 15, 0, 0, 26657, 26658, + 7, 2, 0, 0, 26658, 26659, 7, 11, 0, 0, 26659, 26660, 7, 18, 0, 0, 26660, + 26661, 7, 10, 0, 0, 26661, 26662, 7, 14, 0, 0, 26662, 26663, 7, 10, 0, + 0, 26663, 26664, 7, 5, 0, 0, 26664, 3864, 1, 0, 0, 0, 26665, 26666, 7, + 5, 0, 0, 26666, 26667, 7, 18, 0, 0, 26667, 26668, 7, 5, 0, 0, 26668, 26669, + 5, 95, 0, 0, 26669, 26670, 7, 25, 0, 0, 26670, 26671, 7, 24, 0, 0, 26671, + 26672, 7, 15, 0, 0, 26672, 26673, 7, 2, 0, 0, 26673, 26674, 7, 11, 0, 0, + 26674, 26675, 7, 18, 0, 0, 26675, 26676, 7, 10, 0, 0, 26676, 26677, 7, + 15, 0, 0, 26677, 26678, 7, 11, 0, 0, 26678, 26679, 7, 5, 0, 0, 26679, 3866, + 1, 0, 0, 0, 26680, 26681, 7, 5, 0, 0, 26681, 26682, 7, 18, 0, 0, 26682, + 26683, 7, 5, 0, 0, 26683, 26684, 5, 95, 0, 0, 26684, 26685, 7, 25, 0, 0, + 26685, 26686, 7, 24, 0, 0, 26686, 26687, 7, 15, 0, 0, 26687, 26688, 7, + 2, 0, 0, 26688, 26689, 7, 11, 0, 0, 26689, 26690, 7, 18, 0, 0, 26690, 26691, + 7, 13, 0, 0, 26691, 26692, 7, 6, 0, 0, 26692, 26693, 7, 24, 0, 0, 26693, + 3868, 1, 0, 0, 0, 26694, 26695, 7, 5, 0, 0, 26695, 26696, 7, 18, 0, 0, + 26696, 26697, 7, 5, 0, 0, 26697, 26698, 5, 95, 0, 0, 26698, 26699, 7, 25, + 0, 0, 26699, 26700, 7, 24, 0, 0, 26700, 26701, 7, 15, 0, 0, 26701, 26702, + 7, 2, 0, 0, 26702, 26703, 7, 11, 0, 0, 26703, 26704, 7, 18, 0, 0, 26704, + 26705, 7, 13, 0, 0, 26705, 26706, 7, 17, 0, 0, 26706, 26707, 7, 6, 0, 0, + 26707, 3870, 1, 0, 0, 0, 26708, 26709, 7, 5, 0, 0, 26709, 26710, 7, 18, + 0, 0, 26710, 26711, 7, 5, 0, 0, 26711, 26712, 5, 95, 0, 0, 26712, 26713, + 7, 25, 0, 0, 26713, 26714, 7, 24, 0, 0, 26714, 26715, 7, 15, 0, 0, 26715, + 26716, 7, 2, 0, 0, 26716, 26717, 7, 11, 0, 0, 26717, 26718, 7, 18, 0, 0, + 26718, 26719, 7, 13, 0, 0, 26719, 26720, 7, 17, 0, 0, 26720, 26721, 7, + 4, 0, 0, 26721, 3872, 1, 0, 0, 0, 26722, 26723, 7, 5, 0, 0, 26723, 26724, + 7, 18, 0, 0, 26724, 26725, 7, 5, 0, 0, 26725, 26726, 5, 95, 0, 0, 26726, + 26727, 7, 25, 0, 0, 26727, 26728, 7, 24, 0, 0, 26728, 26729, 7, 15, 0, + 0, 26729, 26730, 7, 2, 0, 0, 26730, 26731, 7, 11, 0, 0, 26731, 26732, 7, + 18, 0, 0, 26732, 26733, 7, 13, 0, 0, 26733, 26734, 7, 11, 0, 0, 26734, + 26735, 7, 6, 0, 0, 26735, 3874, 1, 0, 0, 0, 26736, 26737, 7, 5, 0, 0, 26737, + 26738, 7, 18, 0, 0, 26738, 26739, 7, 5, 0, 0, 26739, 26740, 5, 95, 0, 0, + 26740, 26741, 7, 25, 0, 0, 26741, 26742, 7, 24, 0, 0, 26742, 26743, 7, + 15, 0, 0, 26743, 26744, 7, 2, 0, 0, 26744, 26745, 7, 11, 0, 0, 26745, 26746, + 7, 18, 0, 0, 26746, 26747, 7, 13, 0, 0, 26747, 26748, 7, 11, 0, 0, 26748, + 26749, 7, 4, 0, 0, 26749, 3876, 1, 0, 0, 0, 26750, 26751, 7, 5, 0, 0, 26751, + 26752, 7, 18, 0, 0, 26752, 26753, 7, 5, 0, 0, 26753, 26754, 5, 95, 0, 0, + 26754, 26755, 7, 25, 0, 0, 26755, 26756, 7, 24, 0, 0, 26756, 26757, 7, + 15, 0, 0, 26757, 26758, 7, 2, 0, 0, 26758, 26759, 7, 11, 0, 0, 26759, 26760, + 7, 18, 0, 0, 26760, 26761, 7, 13, 0, 0, 26761, 26762, 7, 7, 0, 0, 26762, + 26763, 7, 6, 0, 0, 26763, 3878, 1, 0, 0, 0, 26764, 26765, 7, 5, 0, 0, 26765, + 26766, 7, 18, 0, 0, 26766, 26767, 7, 5, 0, 0, 26767, 26768, 5, 95, 0, 0, + 26768, 26769, 7, 25, 0, 0, 26769, 26770, 7, 24, 0, 0, 26770, 26771, 7, + 3, 0, 0, 26771, 26772, 7, 6, 0, 0, 26772, 26773, 7, 16, 0, 0, 26773, 26774, + 5, 50, 0, 0, 26774, 26775, 7, 13, 0, 0, 26775, 26776, 7, 0, 0, 0, 26776, + 26777, 7, 11, 0, 0, 26777, 3880, 1, 0, 0, 0, 26778, 26779, 7, 5, 0, 0, + 26779, 26780, 7, 18, 0, 0, 26780, 26781, 7, 5, 0, 0, 26781, 26782, 5, 95, + 0, 0, 26782, 26783, 7, 25, 0, 0, 26783, 26784, 7, 24, 0, 0, 26784, 26785, + 7, 3, 0, 0, 26785, 26786, 7, 6, 0, 0, 26786, 26787, 7, 7, 0, 0, 26787, + 26788, 7, 0, 0, 0, 26788, 26789, 7, 14, 0, 0, 26789, 26790, 7, 6, 0, 0, + 26790, 3882, 1, 0, 0, 0, 26791, 26792, 7, 5, 0, 0, 26792, 26793, 7, 18, + 0, 0, 26793, 26794, 7, 5, 0, 0, 26794, 26795, 5, 95, 0, 0, 26795, 26796, + 7, 25, 0, 0, 26796, 26797, 7, 24, 0, 0, 26797, 26798, 7, 3, 0, 0, 26798, + 26799, 7, 6, 0, 0, 26799, 26800, 7, 15, 0, 0, 26800, 26801, 7, 11, 0, 0, + 26801, 26802, 7, 0, 0, 0, 26802, 26803, 7, 8, 0, 0, 26803, 26804, 7, 6, + 0, 0, 26804, 3884, 1, 0, 0, 0, 26805, 26806, 7, 5, 0, 0, 26806, 26807, + 7, 18, 0, 0, 26807, 26808, 7, 5, 0, 0, 26808, 26809, 5, 95, 0, 0, 26809, + 26810, 7, 25, 0, 0, 26810, 26811, 7, 24, 0, 0, 26811, 26812, 7, 3, 0, 0, + 26812, 26813, 7, 6, 0, 0, 26813, 26814, 7, 5, 0, 0, 26814, 26815, 7, 13, + 0, 0, 26815, 26816, 7, 10, 0, 0, 26816, 26817, 7, 3, 0, 0, 26817, 26818, + 7, 12, 0, 0, 26818, 3886, 1, 0, 0, 0, 26819, 26820, 7, 5, 0, 0, 26820, + 26821, 7, 18, 0, 0, 26821, 26822, 7, 5, 0, 0, 26822, 26823, 5, 95, 0, 0, + 26823, 26824, 7, 25, 0, 0, 26824, 26825, 7, 24, 0, 0, 26825, 26826, 7, + 3, 0, 0, 26826, 26827, 7, 7, 0, 0, 26827, 26828, 7, 9, 0, 0, 26828, 26829, + 7, 19, 0, 0, 26829, 26830, 7, 0, 0, 0, 26830, 26831, 7, 11, 0, 0, 26831, + 26832, 7, 16, 0, 0, 26832, 26833, 5, 50, 0, 0, 26833, 26834, 7, 6, 0, 0, + 26834, 26835, 7, 13, 0, 0, 26835, 26836, 7, 7, 0, 0, 26836, 3888, 1, 0, + 0, 0, 26837, 26838, 7, 5, 0, 0, 26838, 26839, 7, 18, 0, 0, 26839, 26840, + 7, 5, 0, 0, 26840, 26841, 5, 95, 0, 0, 26841, 26842, 7, 25, 0, 0, 26842, + 26843, 7, 24, 0, 0, 26843, 26844, 7, 3, 0, 0, 26844, 26845, 7, 5, 0, 0, + 26845, 26846, 7, 11, 0, 0, 26846, 26847, 7, 13, 0, 0, 26847, 26848, 7, + 24, 0, 0, 26848, 26849, 7, 7, 0, 0, 26849, 26850, 7, 14, 0, 0, 26850, 3890, + 1, 0, 0, 0, 26851, 26852, 7, 5, 0, 0, 26852, 26853, 7, 18, 0, 0, 26853, + 26854, 7, 5, 0, 0, 26854, 26855, 5, 95, 0, 0, 26855, 26856, 7, 25, 0, 0, + 26856, 26857, 7, 24, 0, 0, 26857, 26858, 7, 3, 0, 0, 26858, 26859, 7, 18, + 0, 0, 26859, 26860, 7, 6, 0, 0, 26860, 26861, 7, 7, 0, 0, 26861, 26862, + 7, 13, 0, 0, 26862, 26863, 7, 15, 0, 0, 26863, 26864, 7, 17, 0, 0, 26864, + 26865, 7, 6, 0, 0, 26865, 26866, 7, 4, 0, 0, 26866, 3892, 1, 0, 0, 0, 26867, + 26868, 7, 5, 0, 0, 26868, 26869, 7, 18, 0, 0, 26869, 26870, 7, 5, 0, 0, + 26870, 26871, 5, 95, 0, 0, 26871, 26872, 7, 25, 0, 0, 26872, 26873, 7, + 24, 0, 0, 26873, 26874, 7, 3, 0, 0, 26874, 26875, 7, 18, 0, 0, 26875, 26876, + 7, 13, 0, 0, 26876, 26877, 7, 0, 0, 0, 26877, 26878, 7, 3, 0, 0, 26878, + 26879, 7, 17, 0, 0, 26879, 26880, 7, 6, 0, 0, 26880, 26881, 7, 4, 0, 0, + 26881, 3894, 1, 0, 0, 0, 26882, 26883, 7, 5, 0, 0, 26883, 26884, 7, 18, + 0, 0, 26884, 26885, 7, 5, 0, 0, 26885, 26886, 5, 95, 0, 0, 26886, 26887, + 7, 25, 0, 0, 26887, 26888, 7, 24, 0, 0, 26888, 26889, 7, 3, 0, 0, 26889, + 26890, 7, 18, 0, 0, 26890, 26891, 7, 22, 0, 0, 26891, 26892, 7, 3, 0, 0, + 26892, 26893, 7, 15, 0, 0, 26893, 3896, 1, 0, 0, 0, 26894, 26895, 7, 5, + 0, 0, 26895, 26896, 7, 18, 0, 0, 26896, 26897, 7, 5, 0, 0, 26897, 26898, + 5, 95, 0, 0, 26898, 26899, 7, 25, 0, 0, 26899, 26900, 7, 24, 0, 0, 26900, + 26901, 7, 5, 0, 0, 26901, 26902, 7, 6, 0, 0, 26902, 26903, 7, 24, 0, 0, + 26903, 26904, 5, 50, 0, 0, 26904, 26905, 7, 8, 0, 0, 26905, 26906, 7, 2, + 0, 0, 26906, 26907, 7, 7, 0, 0, 26907, 26908, 5, 52, 0, 0, 26908, 26909, + 7, 25, 0, 0, 26909, 26910, 7, 8, 0, 0, 26910, 3898, 1, 0, 0, 0, 26911, + 26912, 7, 5, 0, 0, 26912, 26913, 7, 18, 0, 0, 26913, 26914, 7, 5, 0, 0, + 26914, 26915, 5, 95, 0, 0, 26915, 26916, 7, 25, 0, 0, 26916, 26917, 7, + 24, 0, 0, 26917, 26918, 7, 5, 0, 0, 26918, 26919, 7, 6, 0, 0, 26919, 26920, + 7, 24, 0, 0, 26920, 26921, 5, 50, 0, 0, 26921, 26922, 7, 8, 0, 0, 26922, + 26923, 7, 2, 0, 0, 26923, 26924, 7, 7, 0, 0, 26924, 3900, 1, 0, 0, 0, 26925, + 26926, 7, 5, 0, 0, 26926, 26927, 7, 18, 0, 0, 26927, 26928, 7, 5, 0, 0, + 26928, 26929, 5, 95, 0, 0, 26929, 26930, 7, 25, 0, 0, 26930, 26931, 7, + 24, 0, 0, 26931, 26932, 7, 5, 0, 0, 26932, 26933, 7, 6, 0, 0, 26933, 26934, + 7, 24, 0, 0, 26934, 26935, 7, 9, 0, 0, 26935, 26936, 7, 6, 0, 0, 26936, + 26937, 7, 6, 0, 0, 26937, 26938, 7, 15, 0, 0, 26938, 26939, 7, 6, 0, 0, + 26939, 26940, 7, 24, 0, 0, 26940, 3902, 1, 0, 0, 0, 26941, 26942, 7, 5, + 0, 0, 26942, 26943, 7, 18, 0, 0, 26943, 26944, 7, 5, 0, 0, 26944, 26945, + 5, 95, 0, 0, 26945, 26946, 7, 25, 0, 0, 26946, 26947, 7, 24, 0, 0, 26947, + 26948, 7, 5, 0, 0, 26948, 26949, 7, 6, 0, 0, 26949, 26950, 7, 24, 0, 0, + 26950, 26951, 7, 12, 0, 0, 26951, 26952, 7, 7, 0, 0, 26952, 26953, 7, 5, + 0, 0, 26953, 26954, 7, 1, 0, 0, 26954, 3904, 1, 0, 0, 0, 26955, 26956, + 7, 5, 0, 0, 26956, 26957, 7, 18, 0, 0, 26957, 26958, 7, 5, 0, 0, 26958, + 26959, 5, 95, 0, 0, 26959, 26960, 7, 25, 0, 0, 26960, 26961, 7, 24, 0, + 0, 26961, 26962, 7, 5, 0, 0, 26962, 26963, 7, 6, 0, 0, 26963, 26964, 7, + 24, 0, 0, 26964, 26965, 7, 3, 0, 0, 26965, 26966, 7, 14, 0, 0, 26966, 3906, + 1, 0, 0, 0, 26967, 26968, 7, 5, 0, 0, 26968, 26969, 7, 18, 0, 0, 26969, + 26970, 7, 5, 0, 0, 26970, 26971, 5, 95, 0, 0, 26971, 26972, 7, 25, 0, 0, + 26972, 26973, 7, 24, 0, 0, 26973, 26974, 7, 5, 0, 0, 26974, 26975, 7, 6, + 0, 0, 26975, 26976, 7, 24, 0, 0, 26976, 26977, 7, 3, 0, 0, 26977, 26978, + 7, 13, 0, 0, 26978, 26979, 7, 5, 0, 0, 26979, 3908, 1, 0, 0, 0, 26980, + 26981, 7, 5, 0, 0, 26981, 26982, 7, 18, 0, 0, 26982, 26983, 7, 5, 0, 0, + 26983, 26984, 5, 95, 0, 0, 26984, 26985, 7, 25, 0, 0, 26985, 26986, 7, + 24, 0, 0, 26986, 26987, 7, 5, 0, 0, 26987, 26988, 7, 6, 0, 0, 26988, 26989, + 7, 24, 0, 0, 26989, 26990, 7, 5, 0, 0, 26990, 26991, 7, 10, 0, 0, 26991, + 26992, 7, 1, 0, 0, 26992, 3910, 1, 0, 0, 0, 26993, 26994, 7, 5, 0, 0, 26994, + 26995, 7, 18, 0, 0, 26995, 26996, 7, 5, 0, 0, 26996, 26997, 5, 95, 0, 0, + 26997, 26998, 7, 25, 0, 0, 26998, 26999, 7, 24, 0, 0, 26999, 27000, 7, + 5, 0, 0, 27000, 27001, 7, 6, 0, 0, 27001, 27002, 7, 24, 0, 0, 27002, 27003, + 7, 4, 0, 0, 27003, 27004, 7, 18, 0, 0, 27004, 27005, 7, 15, 0, 0, 27005, + 27006, 7, 14, 0, 0, 27006, 27007, 7, 0, 0, 0, 27007, 27008, 7, 4, 0, 0, + 27008, 27009, 7, 8, 0, 0, 27009, 27010, 7, 19, 0, 0, 27010, 3912, 1, 0, + 0, 0, 27011, 27012, 7, 5, 0, 0, 27012, 27013, 7, 18, 0, 0, 27013, 27014, + 7, 5, 0, 0, 27014, 27015, 5, 95, 0, 0, 27015, 27016, 7, 25, 0, 0, 27016, + 27017, 7, 24, 0, 0, 27017, 27018, 7, 5, 0, 0, 27018, 27019, 7, 4, 0, 0, + 27019, 27020, 7, 0, 0, 0, 27020, 27021, 7, 3, 0, 0, 27021, 27022, 7, 4, + 0, 0, 27022, 27023, 7, 5, 0, 0, 27023, 27024, 7, 22, 0, 0, 27024, 27025, + 7, 12, 0, 0, 27025, 27026, 7, 4, 0, 0, 27026, 27027, 7, 19, 0, 0, 27027, + 3914, 1, 0, 0, 0, 27028, 27029, 7, 5, 0, 0, 27029, 27030, 7, 18, 0, 0, + 27030, 27031, 7, 5, 0, 0, 27031, 27032, 5, 95, 0, 0, 27032, 27033, 7, 25, + 0, 0, 27033, 27034, 7, 24, 0, 0, 27034, 27035, 7, 5, 0, 0, 27035, 27036, + 7, 4, 0, 0, 27036, 27037, 7, 0, 0, 0, 27037, 27038, 7, 4, 0, 0, 27038, + 27039, 7, 1, 0, 0, 27039, 27040, 7, 10, 0, 0, 27040, 27041, 7, 3, 0, 0, + 27041, 27042, 7, 12, 0, 0, 27042, 3916, 1, 0, 0, 0, 27043, 27044, 7, 5, + 0, 0, 27044, 27045, 7, 18, 0, 0, 27045, 27046, 7, 5, 0, 0, 27046, 27047, + 5, 95, 0, 0, 27047, 27048, 7, 25, 0, 0, 27048, 27049, 7, 24, 0, 0, 27049, + 27050, 7, 5, 0, 0, 27050, 27051, 7, 4, 0, 0, 27051, 27052, 7, 3, 0, 0, + 27052, 27053, 5, 50, 0, 0, 27053, 27054, 7, 8, 0, 0, 27054, 27055, 7, 2, + 0, 0, 27055, 27056, 7, 9, 0, 0, 27056, 27057, 7, 6, 0, 0, 27057, 27058, + 7, 15, 0, 0, 27058, 3918, 1, 0, 0, 0, 27059, 27060, 7, 5, 0, 0, 27060, + 27061, 7, 18, 0, 0, 27061, 27062, 7, 5, 0, 0, 27062, 27063, 5, 95, 0, 0, + 27063, 27064, 7, 25, 0, 0, 27064, 27065, 7, 24, 0, 0, 27065, 27066, 7, + 5, 0, 0, 27066, 27067, 7, 4, 0, 0, 27067, 27068, 7, 3, 0, 0, 27068, 27069, + 7, 20, 0, 0, 27069, 27070, 7, 2, 0, 0, 27070, 27071, 7, 12, 0, 0, 27071, + 27072, 7, 7, 0, 0, 27072, 3920, 1, 0, 0, 0, 27073, 27074, 7, 5, 0, 0, 27074, + 27075, 7, 18, 0, 0, 27075, 27076, 7, 5, 0, 0, 27076, 27077, 5, 95, 0, 0, + 27077, 27078, 7, 25, 0, 0, 27078, 27079, 7, 24, 0, 0, 27079, 27080, 7, + 5, 0, 0, 27080, 27081, 7, 10, 0, 0, 27081, 27082, 7, 1, 0, 0, 27082, 27083, + 7, 5, 0, 0, 27083, 27084, 7, 4, 0, 0, 27084, 27085, 7, 3, 0, 0, 27085, + 27086, 7, 0, 0, 0, 27086, 27087, 7, 16, 0, 0, 27087, 27088, 7, 4, 0, 0, + 27088, 3922, 1, 0, 0, 0, 27089, 27090, 7, 5, 0, 0, 27090, 27091, 7, 18, + 0, 0, 27091, 27092, 7, 5, 0, 0, 27092, 27093, 5, 95, 0, 0, 27093, 27094, + 7, 25, 0, 0, 27094, 27095, 7, 24, 0, 0, 27095, 27096, 7, 5, 0, 0, 27096, + 27097, 7, 10, 0, 0, 27097, 27098, 7, 1, 0, 0, 27098, 27099, 7, 5, 0, 0, + 27099, 27100, 7, 4, 0, 0, 27100, 27101, 7, 3, 0, 0, 27101, 27102, 7, 1, + 0, 0, 27102, 27103, 7, 6, 0, 0, 27103, 27104, 7, 16, 0, 0, 27104, 3924, + 1, 0, 0, 0, 27105, 27106, 7, 5, 0, 0, 27106, 27107, 7, 18, 0, 0, 27107, + 27108, 7, 5, 0, 0, 27108, 27109, 5, 95, 0, 0, 27109, 27110, 7, 25, 0, 0, + 27110, 27111, 7, 24, 0, 0, 27111, 27112, 7, 4, 0, 0, 27112, 27113, 7, 2, + 0, 0, 27113, 27114, 7, 21, 0, 0, 27114, 27115, 7, 6, 0, 0, 27115, 27116, + 7, 7, 0, 0, 27116, 27117, 7, 12, 0, 0, 27117, 27118, 7, 23, 0, 0, 27118, + 27119, 7, 6, 0, 0, 27119, 3926, 1, 0, 0, 0, 27120, 27121, 7, 5, 0, 0, 27121, + 27122, 7, 18, 0, 0, 27122, 27123, 7, 5, 0, 0, 27123, 27124, 5, 95, 0, 0, + 27124, 27125, 7, 25, 0, 0, 27125, 27126, 7, 24, 0, 0, 27126, 27127, 7, + 4, 0, 0, 27127, 27128, 7, 3, 0, 0, 27128, 27129, 7, 6, 0, 0, 27129, 27130, + 7, 0, 0, 0, 27130, 27131, 7, 4, 0, 0, 27131, 27132, 7, 0, 0, 0, 27132, + 27133, 7, 5, 0, 0, 27133, 3928, 1, 0, 0, 0, 27134, 27135, 7, 5, 0, 0, 27135, + 27136, 7, 18, 0, 0, 27136, 27137, 7, 5, 0, 0, 27137, 27138, 5, 95, 0, 0, + 27138, 27139, 7, 25, 0, 0, 27139, 27140, 7, 24, 0, 0, 27140, 27141, 5, + 95, 0, 0, 27141, 27142, 7, 10, 0, 0, 27142, 27143, 7, 15, 0, 0, 27143, + 27144, 7, 21, 0, 0, 27144, 27145, 7, 25, 0, 0, 27145, 27146, 7, 14, 0, + 0, 27146, 27147, 7, 11, 0, 0, 27147, 27148, 5, 50, 0, 0, 27148, 27149, + 7, 5, 0, 0, 27149, 27150, 7, 24, 0, 0, 27150, 27151, 7, 11, 0, 0, 27151, + 3930, 1, 0, 0, 0, 27152, 27153, 7, 5, 0, 0, 27153, 27154, 7, 18, 0, 0, + 27154, 27155, 7, 5, 0, 0, 27155, 27156, 5, 95, 0, 0, 27156, 27157, 7, 25, + 0, 0, 27157, 27158, 7, 24, 0, 0, 27158, 27159, 7, 25, 0, 0, 27159, 27160, + 7, 16, 0, 0, 27160, 27161, 7, 2, 0, 0, 27161, 27162, 7, 3, 0, 0, 27162, + 27163, 7, 14, 0, 0, 27163, 3932, 1, 0, 0, 0, 27164, 27165, 7, 5, 0, 0, + 27165, 27166, 7, 18, 0, 0, 27166, 27167, 7, 5, 0, 0, 27167, 27168, 5, 95, + 0, 0, 27168, 27169, 7, 25, 0, 0, 27169, 27170, 7, 5, 0, 0, 27170, 27171, + 7, 12, 0, 0, 27171, 27172, 7, 9, 0, 0, 27172, 27173, 5, 95, 0, 0, 27173, + 27174, 7, 4, 0, 0, 27174, 27175, 7, 2, 0, 0, 27175, 27176, 5, 95, 0, 0, + 27176, 27177, 7, 3, 0, 0, 27177, 27178, 7, 0, 0, 0, 27178, 27179, 7, 22, + 0, 0, 27179, 3934, 1, 0, 0, 0, 27180, 27181, 7, 5, 0, 0, 27181, 27182, + 7, 18, 0, 0, 27182, 27183, 7, 5, 0, 0, 27183, 27184, 5, 95, 0, 0, 27184, + 27185, 7, 23, 0, 0, 27185, 27186, 7, 14, 0, 0, 27186, 27187, 7, 0, 0, 0, + 27187, 27188, 7, 15, 0, 0, 27188, 27189, 5, 95, 0, 0, 27189, 27190, 7, + 16, 0, 0, 27190, 27191, 7, 12, 0, 0, 27191, 27192, 7, 11, 0, 0, 27192, + 27193, 7, 4, 0, 0, 27193, 27194, 7, 6, 0, 0, 27194, 27195, 7, 3, 0, 0, + 27195, 3936, 1, 0, 0, 0, 27196, 27197, 7, 5, 0, 0, 27197, 27198, 7, 18, + 0, 0, 27198, 27199, 7, 5, 0, 0, 27199, 27200, 5, 95, 0, 0, 27200, 27201, + 7, 23, 0, 0, 27201, 27202, 7, 14, 0, 0, 27202, 27203, 7, 0, 0, 0, 27203, + 27204, 7, 15, 0, 0, 27204, 27205, 5, 95, 0, 0, 27205, 27206, 7, 3, 0, 0, + 27206, 27207, 7, 6, 0, 0, 27207, 27208, 7, 16, 0, 0, 27208, 27209, 7, 3, + 0, 0, 27209, 27210, 7, 6, 0, 0, 27210, 27211, 7, 5, 0, 0, 27211, 27212, + 7, 19, 0, 0, 27212, 3938, 1, 0, 0, 0, 27213, 27214, 7, 4, 0, 0, 27214, + 3940, 1, 0, 0, 0, 27215, 27216, 7, 4, 0, 0, 27216, 27217, 7, 0, 0, 0, 27217, + 27218, 7, 1, 0, 0, 27218, 27219, 7, 11, 0, 0, 27219, 27220, 7, 6, 0, 0, + 27220, 27221, 5, 95, 0, 0, 27221, 27222, 7, 11, 0, 0, 27222, 27223, 7, + 2, 0, 0, 27223, 27224, 7, 2, 0, 0, 27224, 27225, 7, 21, 0, 0, 27225, 27226, + 7, 10, 0, 0, 27226, 27227, 7, 15, 0, 0, 27227, 27228, 5, 95, 0, 0, 27228, + 27229, 7, 1, 0, 0, 27229, 27230, 7, 18, 0, 0, 27230, 27231, 5, 95, 0, 0, + 27231, 27232, 7, 7, 0, 0, 27232, 27233, 7, 11, 0, 0, 27233, 3942, 1, 0, + 0, 0, 27234, 27235, 7, 4, 0, 0, 27235, 27236, 7, 0, 0, 0, 27236, 27237, + 7, 1, 0, 0, 27237, 27238, 7, 11, 0, 0, 27238, 27239, 7, 6, 0, 0, 27239, + 27240, 7, 5, 0, 0, 27240, 27241, 7, 15, 0, 0, 27241, 27242, 7, 0, 0, 0, + 27242, 27243, 7, 8, 0, 0, 27243, 27244, 7, 6, 0, 0, 27244, 27245, 5, 95, + 0, 0, 27245, 27246, 7, 7, 0, 0, 27246, 27247, 7, 2, 0, 0, 27247, 3944, + 1, 0, 0, 0, 27248, 27249, 7, 4, 0, 0, 27249, 27250, 7, 0, 0, 0, 27250, + 27251, 7, 1, 0, 0, 27251, 27252, 7, 11, 0, 0, 27252, 27253, 7, 6, 0, 0, + 27253, 27254, 7, 5, 0, 0, 27254, 27255, 7, 15, 0, 0, 27255, 27256, 7, 0, + 0, 0, 27256, 27257, 7, 8, 0, 0, 27257, 27258, 7, 6, 0, 0, 27258, 3946, + 1, 0, 0, 0, 27259, 27260, 7, 4, 0, 0, 27260, 27261, 7, 0, 0, 0, 27261, + 27262, 7, 1, 0, 0, 27262, 27263, 7, 11, 0, 0, 27263, 27264, 7, 6, 0, 0, + 27264, 27265, 7, 5, 0, 0, 27265, 3948, 1, 0, 0, 0, 27266, 27267, 7, 4, + 0, 0, 27267, 27268, 7, 0, 0, 0, 27268, 27269, 7, 1, 0, 0, 27269, 27270, + 7, 11, 0, 0, 27270, 27271, 7, 6, 0, 0, 27271, 27272, 5, 95, 0, 0, 27272, + 27273, 7, 5, 0, 0, 27273, 27274, 7, 4, 0, 0, 27274, 27275, 7, 0, 0, 0, + 27275, 27276, 7, 4, 0, 0, 27276, 27277, 7, 5, 0, 0, 27277, 3950, 1, 0, + 0, 0, 27278, 27279, 7, 4, 0, 0, 27279, 27280, 7, 0, 0, 0, 27280, 27281, + 7, 1, 0, 0, 27281, 27282, 7, 11, 0, 0, 27282, 27283, 7, 6, 0, 0, 27283, + 3952, 1, 0, 0, 0, 27284, 27285, 7, 4, 0, 0, 27285, 27286, 7, 0, 0, 0, 27286, + 27287, 7, 1, 0, 0, 27287, 27288, 7, 7, 0, 0, 27288, 27289, 7, 2, 0, 0, + 27289, 3954, 1, 0, 0, 0, 27290, 27291, 7, 4, 0, 0, 27291, 27292, 7, 0, + 0, 0, 27292, 27293, 7, 17, 0, 0, 27293, 3956, 1, 0, 0, 0, 27294, 27295, + 7, 4, 0, 0, 27295, 27296, 7, 0, 0, 0, 27296, 27297, 7, 7, 0, 0, 27297, + 27298, 7, 19, 0, 0, 27298, 3958, 1, 0, 0, 0, 27299, 27300, 7, 4, 0, 0, + 27300, 27301, 7, 0, 0, 0, 27301, 27302, 7, 7, 0, 0, 27302, 3960, 1, 0, + 0, 0, 27303, 27304, 7, 4, 0, 0, 27304, 27305, 7, 1, 0, 0, 27305, 27306, + 7, 11, 0, 0, 27306, 27307, 5, 36, 0, 0, 27307, 27308, 7, 2, 0, 0, 27308, + 27309, 7, 3, 0, 0, 27309, 27310, 5, 36, 0, 0, 27310, 27311, 7, 12, 0, 0, + 27311, 27312, 7, 9, 0, 0, 27312, 27313, 7, 25, 0, 0, 27313, 27314, 5, 36, + 0, 0, 27314, 27315, 7, 15, 0, 0, 27315, 27316, 7, 0, 0, 0, 27316, 27317, + 7, 3, 0, 0, 27317, 27318, 7, 4, 0, 0, 27318, 27319, 5, 36, 0, 0, 27319, + 27320, 7, 7, 0, 0, 27320, 27321, 7, 10, 0, 0, 27321, 27322, 7, 14, 0, 0, + 27322, 3962, 1, 0, 0, 0, 27323, 27324, 7, 4, 0, 0, 27324, 27325, 7, 6, + 0, 0, 27325, 27326, 7, 14, 0, 0, 27326, 27327, 7, 15, 0, 0, 27327, 27328, + 7, 16, 0, 0, 27328, 27329, 7, 12, 0, 0, 27329, 27330, 7, 11, 0, 0, 27330, + 27331, 7, 6, 0, 0, 27331, 3964, 1, 0, 0, 0, 27332, 27333, 7, 4, 0, 0, 27333, + 27334, 7, 6, 0, 0, 27334, 27335, 7, 14, 0, 0, 27335, 27336, 7, 15, 0, 0, + 27336, 27337, 7, 11, 0, 0, 27337, 27338, 7, 0, 0, 0, 27338, 27339, 7, 4, + 0, 0, 27339, 27340, 7, 6, 0, 0, 27340, 3966, 1, 0, 0, 0, 27341, 27342, + 7, 4, 0, 0, 27342, 27343, 7, 6, 0, 0, 27343, 27344, 7, 14, 0, 0, 27344, + 27345, 7, 15, 0, 0, 27345, 27346, 7, 2, 0, 0, 27346, 27347, 7, 3, 0, 0, + 27347, 27348, 7, 0, 0, 0, 27348, 27349, 7, 3, 0, 0, 27349, 27350, 7, 18, + 0, 0, 27350, 3968, 1, 0, 0, 0, 27351, 27352, 7, 4, 0, 0, 27352, 27353, + 7, 6, 0, 0, 27353, 27354, 7, 14, 0, 0, 27354, 27355, 7, 15, 0, 0, 27355, + 27356, 5, 95, 0, 0, 27356, 27357, 7, 4, 0, 0, 27357, 27358, 7, 0, 0, 0, + 27358, 27359, 7, 1, 0, 0, 27359, 27360, 7, 11, 0, 0, 27360, 27361, 7, 6, + 0, 0, 27361, 3970, 1, 0, 0, 0, 27362, 27363, 7, 4, 0, 0, 27363, 27364, + 7, 6, 0, 0, 27364, 27365, 7, 5, 0, 0, 27365, 27366, 7, 4, 0, 0, 27366, + 3972, 1, 0, 0, 0, 27367, 27368, 7, 4, 0, 0, 27368, 27369, 7, 6, 0, 0, 27369, + 27370, 7, 25, 0, 0, 27370, 27371, 7, 4, 0, 0, 27371, 3974, 1, 0, 0, 0, + 27372, 27373, 7, 4, 0, 0, 27373, 27374, 7, 19, 0, 0, 27374, 27375, 7, 0, + 0, 0, 27375, 27376, 7, 7, 0, 0, 27376, 3976, 1, 0, 0, 0, 27377, 27378, + 7, 4, 0, 0, 27378, 27379, 7, 19, 0, 0, 27379, 27380, 7, 6, 0, 0, 27380, + 27381, 7, 7, 0, 0, 27381, 3978, 1, 0, 0, 0, 27382, 27383, 7, 4, 0, 0, 27383, + 27384, 7, 19, 0, 0, 27384, 27385, 7, 6, 0, 0, 27385, 3980, 1, 0, 0, 0, + 27386, 27387, 7, 4, 0, 0, 27387, 27388, 7, 19, 0, 0, 27388, 27389, 7, 3, + 0, 0, 27389, 27390, 7, 6, 0, 0, 27390, 27391, 7, 0, 0, 0, 27391, 27392, + 7, 9, 0, 0, 27392, 3982, 1, 0, 0, 0, 27393, 27394, 7, 4, 0, 0, 27394, 27395, + 7, 19, 0, 0, 27395, 27396, 7, 3, 0, 0, 27396, 27397, 7, 2, 0, 0, 27397, + 27398, 7, 10, 0, 0, 27398, 27399, 7, 17, 0, 0, 27399, 27400, 7, 19, 0, + 0, 27400, 3984, 1, 0, 0, 0, 27401, 27402, 7, 4, 0, 0, 27402, 27403, 7, + 12, 0, 0, 27403, 27404, 7, 6, 0, 0, 27404, 27405, 7, 3, 0, 0, 27405, 3986, + 1, 0, 0, 0, 27406, 27407, 7, 4, 0, 0, 27407, 27408, 7, 12, 0, 0, 27408, + 27409, 7, 6, 0, 0, 27409, 27410, 7, 5, 0, 0, 27410, 3988, 1, 0, 0, 0, 27411, + 27412, 7, 4, 0, 0, 27412, 27413, 7, 12, 0, 0, 27413, 27414, 7, 14, 0, 0, + 27414, 27415, 7, 6, 0, 0, 27415, 27416, 7, 2, 0, 0, 27416, 27417, 7, 10, + 0, 0, 27417, 27418, 7, 4, 0, 0, 27418, 3990, 1, 0, 0, 0, 27419, 27420, + 7, 4, 0, 0, 27420, 27421, 7, 12, 0, 0, 27421, 27422, 7, 14, 0, 0, 27422, + 27423, 7, 6, 0, 0, 27423, 27424, 7, 5, 0, 0, 27424, 27425, 7, 4, 0, 0, + 27425, 27426, 7, 0, 0, 0, 27426, 27427, 7, 14, 0, 0, 27427, 27428, 7, 15, + 0, 0, 27428, 27429, 5, 95, 0, 0, 27429, 27430, 7, 11, 0, 0, 27430, 27431, + 7, 4, 0, 0, 27431, 27432, 7, 23, 0, 0, 27432, 27433, 5, 95, 0, 0, 27433, + 27434, 7, 10, 0, 0, 27434, 27435, 7, 7, 0, 0, 27435, 27436, 7, 8, 0, 0, + 27436, 27437, 7, 2, 0, 0, 27437, 27438, 7, 7, 0, 0, 27438, 27439, 7, 5, + 0, 0, 27439, 27440, 7, 4, 0, 0, 27440, 27441, 7, 3, 0, 0, 27441, 27442, + 7, 0, 0, 0, 27442, 27443, 7, 12, 0, 0, 27443, 27444, 7, 7, 0, 0, 27444, + 27445, 7, 6, 0, 0, 27445, 27446, 7, 9, 0, 0, 27446, 3992, 1, 0, 0, 0, 27447, + 27448, 7, 4, 0, 0, 27448, 27449, 7, 12, 0, 0, 27449, 27450, 7, 14, 0, 0, + 27450, 27451, 7, 6, 0, 0, 27451, 27452, 7, 5, 0, 0, 27452, 27453, 7, 4, + 0, 0, 27453, 27454, 7, 0, 0, 0, 27454, 27455, 7, 14, 0, 0, 27455, 27456, + 7, 15, 0, 0, 27456, 3994, 1, 0, 0, 0, 27457, 27458, 7, 4, 0, 0, 27458, + 27459, 7, 12, 0, 0, 27459, 27460, 7, 14, 0, 0, 27460, 27461, 7, 6, 0, 0, + 27461, 27462, 7, 5, 0, 0, 27462, 27463, 7, 4, 0, 0, 27463, 27464, 7, 0, + 0, 0, 27464, 27465, 7, 14, 0, 0, 27465, 27466, 7, 15, 0, 0, 27466, 27467, + 5, 95, 0, 0, 27467, 27468, 7, 4, 0, 0, 27468, 27469, 7, 23, 0, 0, 27469, + 27470, 5, 95, 0, 0, 27470, 27471, 7, 10, 0, 0, 27471, 27472, 7, 7, 0, 0, + 27472, 27473, 7, 8, 0, 0, 27473, 27474, 7, 2, 0, 0, 27474, 27475, 7, 7, + 0, 0, 27475, 27476, 7, 5, 0, 0, 27476, 27477, 7, 4, 0, 0, 27477, 27478, + 7, 3, 0, 0, 27478, 27479, 7, 0, 0, 0, 27479, 27480, 7, 12, 0, 0, 27480, + 27481, 7, 7, 0, 0, 27481, 27482, 7, 6, 0, 0, 27482, 27483, 7, 9, 0, 0, + 27483, 3996, 1, 0, 0, 0, 27484, 27485, 7, 4, 0, 0, 27485, 27486, 7, 12, + 0, 0, 27486, 27487, 7, 14, 0, 0, 27487, 27488, 7, 6, 0, 0, 27488, 27489, + 7, 5, 0, 0, 27489, 27490, 7, 4, 0, 0, 27490, 27491, 7, 0, 0, 0, 27491, + 27492, 7, 14, 0, 0, 27492, 27493, 7, 15, 0, 0, 27493, 27494, 5, 95, 0, + 0, 27494, 27495, 7, 10, 0, 0, 27495, 27496, 7, 7, 0, 0, 27496, 27497, 7, + 8, 0, 0, 27497, 27498, 7, 2, 0, 0, 27498, 27499, 7, 7, 0, 0, 27499, 27500, + 7, 5, 0, 0, 27500, 27501, 7, 4, 0, 0, 27501, 27502, 7, 3, 0, 0, 27502, + 27503, 7, 0, 0, 0, 27503, 27504, 7, 12, 0, 0, 27504, 27505, 7, 7, 0, 0, + 27505, 27506, 7, 6, 0, 0, 27506, 27507, 7, 9, 0, 0, 27507, 3998, 1, 0, + 0, 0, 27508, 27509, 7, 4, 0, 0, 27509, 27510, 7, 12, 0, 0, 27510, 27511, + 7, 14, 0, 0, 27511, 27512, 7, 6, 0, 0, 27512, 27513, 7, 5, 0, 0, 27513, + 4000, 1, 0, 0, 0, 27514, 27515, 7, 4, 0, 0, 27515, 27516, 7, 12, 0, 0, + 27516, 27517, 7, 14, 0, 0, 27517, 27518, 7, 6, 0, 0, 27518, 4002, 1, 0, + 0, 0, 27519, 27520, 7, 4, 0, 0, 27520, 27521, 7, 12, 0, 0, 27521, 27522, + 7, 14, 0, 0, 27522, 27523, 7, 6, 0, 0, 27523, 27524, 7, 23, 0, 0, 27524, + 27525, 7, 2, 0, 0, 27525, 27526, 7, 7, 0, 0, 27526, 27527, 7, 6, 0, 0, + 27527, 4004, 1, 0, 0, 0, 27528, 27529, 7, 4, 0, 0, 27529, 27530, 7, 12, + 0, 0, 27530, 27531, 7, 14, 0, 0, 27531, 27532, 7, 6, 0, 0, 27532, 27533, + 7, 23, 0, 0, 27533, 27534, 7, 2, 0, 0, 27534, 27535, 7, 7, 0, 0, 27535, + 27536, 7, 6, 0, 0, 27536, 27537, 5, 95, 0, 0, 27537, 27538, 7, 0, 0, 0, + 27538, 27539, 7, 1, 0, 0, 27539, 27540, 7, 1, 0, 0, 27540, 27541, 7, 3, + 0, 0, 27541, 4006, 1, 0, 0, 0, 27542, 27543, 7, 4, 0, 0, 27543, 27544, + 7, 12, 0, 0, 27544, 27545, 7, 14, 0, 0, 27545, 27546, 7, 6, 0, 0, 27546, + 27547, 7, 23, 0, 0, 27547, 27548, 7, 2, 0, 0, 27548, 27549, 7, 7, 0, 0, + 27549, 27550, 7, 6, 0, 0, 27550, 27551, 5, 95, 0, 0, 27551, 27552, 7, 19, + 0, 0, 27552, 27553, 7, 2, 0, 0, 27553, 27554, 7, 10, 0, 0, 27554, 27555, + 7, 3, 0, 0, 27555, 4008, 1, 0, 0, 0, 27556, 27557, 7, 4, 0, 0, 27557, 27558, + 7, 12, 0, 0, 27558, 27559, 7, 14, 0, 0, 27559, 27560, 7, 6, 0, 0, 27560, + 27561, 7, 23, 0, 0, 27561, 27562, 7, 2, 0, 0, 27562, 27563, 7, 7, 0, 0, + 27563, 27564, 7, 6, 0, 0, 27564, 27565, 5, 95, 0, 0, 27565, 27566, 7, 14, + 0, 0, 27566, 27567, 7, 12, 0, 0, 27567, 27568, 7, 7, 0, 0, 27568, 27569, + 7, 10, 0, 0, 27569, 27570, 7, 4, 0, 0, 27570, 27571, 7, 6, 0, 0, 27571, + 4010, 1, 0, 0, 0, 27572, 27573, 7, 4, 0, 0, 27573, 27574, 7, 12, 0, 0, + 27574, 27575, 7, 14, 0, 0, 27575, 27576, 7, 6, 0, 0, 27576, 27577, 7, 23, + 0, 0, 27577, 27578, 7, 2, 0, 0, 27578, 27579, 7, 7, 0, 0, 27579, 27580, + 7, 6, 0, 0, 27580, 27581, 5, 95, 0, 0, 27581, 27582, 7, 2, 0, 0, 27582, + 27583, 7, 16, 0, 0, 27583, 27584, 7, 16, 0, 0, 27584, 27585, 7, 5, 0, 0, + 27585, 27586, 7, 6, 0, 0, 27586, 27587, 7, 4, 0, 0, 27587, 4012, 1, 0, + 0, 0, 27588, 27589, 7, 4, 0, 0, 27589, 27590, 7, 12, 0, 0, 27590, 27591, + 7, 14, 0, 0, 27591, 27592, 7, 6, 0, 0, 27592, 27593, 7, 23, 0, 0, 27593, + 27594, 7, 2, 0, 0, 27594, 27595, 7, 7, 0, 0, 27595, 27596, 7, 6, 0, 0, + 27596, 27597, 5, 95, 0, 0, 27597, 27598, 7, 3, 0, 0, 27598, 27599, 7, 6, + 0, 0, 27599, 27600, 7, 17, 0, 0, 27600, 27601, 7, 12, 0, 0, 27601, 27602, + 7, 2, 0, 0, 27602, 27603, 7, 7, 0, 0, 27603, 4014, 1, 0, 0, 0, 27604, 27605, + 7, 4, 0, 0, 27605, 27606, 7, 12, 0, 0, 27606, 27607, 7, 14, 0, 0, 27607, + 27608, 7, 6, 0, 0, 27608, 27609, 5, 95, 0, 0, 27609, 27610, 7, 23, 0, 0, + 27610, 27611, 7, 2, 0, 0, 27611, 27612, 7, 7, 0, 0, 27612, 27613, 7, 6, + 0, 0, 27613, 4016, 1, 0, 0, 0, 27614, 27615, 7, 4, 0, 0, 27615, 27616, + 7, 12, 0, 0, 27616, 27617, 7, 14, 0, 0, 27617, 27618, 7, 12, 0, 0, 27618, + 27619, 7, 7, 0, 0, 27619, 27620, 7, 17, 0, 0, 27620, 4018, 1, 0, 0, 0, + 27621, 27622, 7, 4, 0, 0, 27622, 27623, 7, 12, 0, 0, 27623, 27624, 7, 13, + 0, 0, 27624, 27625, 5, 95, 0, 0, 27625, 27626, 7, 17, 0, 0, 27626, 27627, + 7, 1, 0, 0, 27627, 4020, 1, 0, 0, 0, 27628, 27629, 7, 4, 0, 0, 27629, 27630, + 7, 12, 0, 0, 27630, 27631, 7, 13, 0, 0, 27631, 27632, 5, 95, 0, 0, 27632, + 27633, 7, 5, 0, 0, 27633, 27634, 7, 5, 0, 0, 27634, 27635, 7, 16, 0, 0, + 27635, 4022, 1, 0, 0, 0, 27636, 27637, 7, 4, 0, 0, 27637, 27638, 7, 2, + 0, 0, 27638, 27639, 5, 95, 0, 0, 27639, 27640, 7, 0, 0, 0, 27640, 27641, + 7, 8, 0, 0, 27641, 27642, 7, 11, 0, 0, 27642, 27643, 7, 12, 0, 0, 27643, + 27644, 7, 9, 0, 0, 27644, 4024, 1, 0, 0, 0, 27645, 27646, 7, 4, 0, 0, 27646, + 27647, 7, 2, 0, 0, 27647, 27648, 5, 95, 0, 0, 27648, 27649, 7, 1, 0, 0, + 27649, 27650, 7, 12, 0, 0, 27650, 27651, 7, 7, 0, 0, 27651, 27652, 7, 0, + 0, 0, 27652, 27653, 7, 3, 0, 0, 27653, 27654, 7, 18, 0, 0, 27654, 27655, + 5, 95, 0, 0, 27655, 27656, 7, 9, 0, 0, 27656, 27657, 7, 2, 0, 0, 27657, + 27658, 7, 10, 0, 0, 27658, 27659, 7, 1, 0, 0, 27659, 27660, 7, 11, 0, 0, + 27660, 27661, 7, 6, 0, 0, 27661, 4026, 1, 0, 0, 0, 27662, 27663, 7, 4, + 0, 0, 27663, 27664, 7, 2, 0, 0, 27664, 27665, 5, 95, 0, 0, 27665, 27666, + 7, 1, 0, 0, 27666, 27667, 7, 12, 0, 0, 27667, 27668, 7, 7, 0, 0, 27668, + 27669, 7, 0, 0, 0, 27669, 27670, 7, 3, 0, 0, 27670, 27671, 7, 18, 0, 0, + 27671, 27672, 5, 95, 0, 0, 27672, 27673, 7, 16, 0, 0, 27673, 27674, 7, + 11, 0, 0, 27674, 27675, 7, 2, 0, 0, 27675, 27676, 7, 0, 0, 0, 27676, 27677, + 7, 4, 0, 0, 27677, 4028, 1, 0, 0, 0, 27678, 27679, 7, 4, 0, 0, 27679, 27680, + 7, 2, 0, 0, 27680, 27681, 5, 95, 0, 0, 27681, 27682, 7, 1, 0, 0, 27682, + 27683, 7, 11, 0, 0, 27683, 27684, 7, 2, 0, 0, 27684, 27685, 7, 1, 0, 0, + 27685, 4030, 1, 0, 0, 0, 27686, 27687, 7, 4, 0, 0, 27687, 27688, 7, 2, + 0, 0, 27688, 27689, 5, 95, 0, 0, 27689, 27690, 7, 8, 0, 0, 27690, 27691, + 7, 11, 0, 0, 27691, 27692, 7, 2, 0, 0, 27692, 27693, 7, 1, 0, 0, 27693, + 4032, 1, 0, 0, 0, 27694, 27695, 7, 4, 0, 0, 27695, 27696, 7, 2, 0, 0, 27696, + 27697, 5, 95, 0, 0, 27697, 27698, 7, 9, 0, 0, 27698, 27699, 7, 5, 0, 0, + 27699, 27700, 7, 12, 0, 0, 27700, 27701, 7, 7, 0, 0, 27701, 27702, 7, 4, + 0, 0, 27702, 27703, 7, 6, 0, 0, 27703, 27704, 7, 3, 0, 0, 27704, 27705, + 7, 13, 0, 0, 27705, 27706, 7, 0, 0, 0, 27706, 27707, 7, 11, 0, 0, 27707, + 4034, 1, 0, 0, 0, 27708, 27709, 7, 4, 0, 0, 27709, 27710, 7, 2, 0, 0, 27710, + 27711, 5, 95, 0, 0, 27711, 27712, 7, 11, 0, 0, 27712, 27713, 7, 2, 0, 0, + 27713, 27714, 7, 1, 0, 0, 27714, 4036, 1, 0, 0, 0, 27715, 27716, 7, 4, + 0, 0, 27716, 27717, 7, 2, 0, 0, 27717, 27718, 5, 95, 0, 0, 27718, 27719, + 7, 14, 0, 0, 27719, 27720, 7, 10, 0, 0, 27720, 27721, 7, 11, 0, 0, 27721, + 27722, 7, 4, 0, 0, 27722, 27723, 7, 12, 0, 0, 27723, 27724, 5, 95, 0, 0, + 27724, 27725, 7, 1, 0, 0, 27725, 27726, 7, 18, 0, 0, 27726, 27727, 7, 4, + 0, 0, 27727, 27728, 7, 6, 0, 0, 27728, 4038, 1, 0, 0, 0, 27729, 27730, + 7, 4, 0, 0, 27730, 27731, 7, 2, 0, 0, 27731, 27732, 5, 95, 0, 0, 27732, + 27733, 7, 7, 0, 0, 27733, 27734, 7, 8, 0, 0, 27734, 27735, 7, 19, 0, 0, + 27735, 27736, 7, 0, 0, 0, 27736, 27737, 7, 3, 0, 0, 27737, 4040, 1, 0, + 0, 0, 27738, 27739, 7, 4, 0, 0, 27739, 27740, 7, 2, 0, 0, 27740, 27741, + 5, 95, 0, 0, 27741, 27742, 7, 7, 0, 0, 27742, 27743, 7, 8, 0, 0, 27743, + 27744, 7, 11, 0, 0, 27744, 27745, 7, 2, 0, 0, 27745, 27746, 7, 1, 0, 0, + 27746, 4042, 1, 0, 0, 0, 27747, 27748, 7, 4, 0, 0, 27748, 27749, 7, 2, + 0, 0, 27749, 27750, 5, 95, 0, 0, 27750, 27751, 7, 7, 0, 0, 27751, 27752, + 7, 10, 0, 0, 27752, 27753, 7, 14, 0, 0, 27753, 27754, 7, 1, 0, 0, 27754, + 27755, 7, 6, 0, 0, 27755, 27756, 7, 3, 0, 0, 27756, 4044, 1, 0, 0, 0, 27757, + 27758, 7, 4, 0, 0, 27758, 27759, 7, 2, 0, 0, 27759, 27760, 7, 15, 0, 0, + 27760, 27761, 7, 11, 0, 0, 27761, 27762, 7, 6, 0, 0, 27762, 27763, 7, 13, + 0, 0, 27763, 27764, 7, 6, 0, 0, 27764, 27765, 7, 11, 0, 0, 27765, 4046, + 1, 0, 0, 0, 27766, 27767, 7, 4, 0, 0, 27767, 27768, 7, 2, 0, 0, 27768, + 27769, 5, 95, 0, 0, 27769, 27770, 7, 5, 0, 0, 27770, 27771, 7, 12, 0, 0, + 27771, 27772, 7, 7, 0, 0, 27772, 27773, 7, 17, 0, 0, 27773, 27774, 7, 11, + 0, 0, 27774, 27775, 7, 6, 0, 0, 27775, 27776, 5, 95, 0, 0, 27776, 27777, + 7, 1, 0, 0, 27777, 27778, 7, 18, 0, 0, 27778, 27779, 7, 4, 0, 0, 27779, + 27780, 7, 6, 0, 0, 27780, 4048, 1, 0, 0, 0, 27781, 27782, 7, 4, 0, 0, 27782, + 27783, 7, 2, 0, 0, 27783, 27784, 5, 95, 0, 0, 27784, 27785, 7, 4, 0, 0, + 27785, 27786, 7, 12, 0, 0, 27786, 27787, 7, 14, 0, 0, 27787, 27788, 7, + 6, 0, 0, 27788, 27789, 7, 5, 0, 0, 27789, 27790, 7, 4, 0, 0, 27790, 27791, + 7, 0, 0, 0, 27791, 27792, 7, 14, 0, 0, 27792, 27793, 7, 15, 0, 0, 27793, + 4050, 1, 0, 0, 0, 27794, 27795, 7, 4, 0, 0, 27795, 27796, 7, 2, 0, 0, 27796, + 27797, 5, 95, 0, 0, 27797, 27798, 7, 4, 0, 0, 27798, 27799, 7, 12, 0, 0, + 27799, 27800, 7, 14, 0, 0, 27800, 27801, 7, 6, 0, 0, 27801, 27802, 7, 5, + 0, 0, 27802, 27803, 7, 4, 0, 0, 27803, 27804, 7, 0, 0, 0, 27804, 27805, + 7, 14, 0, 0, 27805, 27806, 7, 15, 0, 0, 27806, 27807, 5, 95, 0, 0, 27807, + 27808, 7, 4, 0, 0, 27808, 27809, 7, 23, 0, 0, 27809, 4052, 1, 0, 0, 0, + 27810, 27811, 7, 4, 0, 0, 27811, 27812, 7, 2, 0, 0, 27812, 27813, 5, 95, + 0, 0, 27813, 27814, 7, 4, 0, 0, 27814, 27815, 7, 12, 0, 0, 27815, 27816, + 7, 14, 0, 0, 27816, 27817, 7, 6, 0, 0, 27817, 4054, 1, 0, 0, 0, 27818, + 27819, 7, 4, 0, 0, 27819, 27820, 7, 2, 0, 0, 27820, 27821, 5, 95, 0, 0, + 27821, 27822, 7, 4, 0, 0, 27822, 27823, 7, 12, 0, 0, 27823, 27824, 7, 14, + 0, 0, 27824, 27825, 7, 6, 0, 0, 27825, 27826, 5, 95, 0, 0, 27826, 27827, + 7, 4, 0, 0, 27827, 27828, 7, 23, 0, 0, 27828, 4056, 1, 0, 0, 0, 27829, + 27830, 7, 4, 0, 0, 27830, 27831, 7, 2, 0, 0, 27831, 4058, 1, 0, 0, 0, 27832, + 27833, 7, 4, 0, 0, 27833, 27834, 7, 2, 0, 0, 27834, 27835, 5, 95, 0, 0, + 27835, 27836, 7, 18, 0, 0, 27836, 27837, 7, 14, 0, 0, 27837, 27838, 7, + 12, 0, 0, 27838, 27839, 7, 7, 0, 0, 27839, 27840, 7, 4, 0, 0, 27840, 27841, + 7, 6, 0, 0, 27841, 27842, 7, 3, 0, 0, 27842, 27843, 7, 13, 0, 0, 27843, + 27844, 7, 0, 0, 0, 27844, 27845, 7, 11, 0, 0, 27845, 4060, 1, 0, 0, 0, + 27846, 27847, 7, 4, 0, 0, 27847, 27848, 7, 3, 0, 0, 27848, 27849, 7, 0, + 0, 0, 27849, 27850, 7, 8, 0, 0, 27850, 27851, 7, 6, 0, 0, 27851, 4062, + 1, 0, 0, 0, 27852, 27853, 7, 4, 0, 0, 27853, 27854, 7, 3, 0, 0, 27854, + 27855, 7, 0, 0, 0, 27855, 27856, 7, 8, 0, 0, 27856, 27857, 7, 12, 0, 0, + 27857, 27858, 7, 7, 0, 0, 27858, 27859, 7, 17, 0, 0, 27859, 4064, 1, 0, + 0, 0, 27860, 27861, 7, 4, 0, 0, 27861, 27862, 7, 3, 0, 0, 27862, 27863, + 7, 0, 0, 0, 27863, 27864, 7, 8, 0, 0, 27864, 27865, 7, 21, 0, 0, 27865, + 27866, 7, 12, 0, 0, 27866, 27867, 7, 7, 0, 0, 27867, 27868, 7, 17, 0, 0, + 27868, 4066, 1, 0, 0, 0, 27869, 27870, 7, 4, 0, 0, 27870, 27871, 7, 3, + 0, 0, 27871, 27872, 7, 0, 0, 0, 27872, 27873, 7, 12, 0, 0, 27873, 27874, + 7, 11, 0, 0, 27874, 27875, 7, 12, 0, 0, 27875, 27876, 7, 7, 0, 0, 27876, + 27877, 7, 17, 0, 0, 27877, 4068, 1, 0, 0, 0, 27878, 27879, 7, 4, 0, 0, + 27879, 27880, 7, 3, 0, 0, 27880, 27881, 7, 0, 0, 0, 27881, 27882, 7, 7, + 0, 0, 27882, 27883, 7, 5, 0, 0, 27883, 27884, 7, 0, 0, 0, 27884, 27885, + 7, 8, 0, 0, 27885, 27886, 7, 4, 0, 0, 27886, 27887, 7, 12, 0, 0, 27887, + 27888, 7, 2, 0, 0, 27888, 27889, 7, 7, 0, 0, 27889, 4070, 1, 0, 0, 0, 27890, + 27891, 7, 4, 0, 0, 27891, 27892, 7, 3, 0, 0, 27892, 27893, 7, 0, 0, 0, + 27893, 27894, 7, 7, 0, 0, 27894, 27895, 7, 5, 0, 0, 27895, 27896, 7, 16, + 0, 0, 27896, 27897, 7, 2, 0, 0, 27897, 27898, 7, 3, 0, 0, 27898, 27899, + 7, 14, 0, 0, 27899, 4072, 1, 0, 0, 0, 27900, 27901, 7, 4, 0, 0, 27901, + 27902, 7, 3, 0, 0, 27902, 27903, 7, 0, 0, 0, 27903, 27904, 7, 7, 0, 0, + 27904, 27905, 7, 5, 0, 0, 27905, 27906, 7, 16, 0, 0, 27906, 27907, 7, 2, + 0, 0, 27907, 27908, 7, 3, 0, 0, 27908, 27909, 7, 14, 0, 0, 27909, 27910, + 5, 95, 0, 0, 27910, 27911, 7, 9, 0, 0, 27911, 27912, 7, 12, 0, 0, 27912, + 27913, 7, 5, 0, 0, 27913, 27914, 7, 4, 0, 0, 27914, 27915, 7, 12, 0, 0, + 27915, 27916, 7, 7, 0, 0, 27916, 27917, 7, 8, 0, 0, 27917, 27918, 7, 4, + 0, 0, 27918, 27919, 5, 95, 0, 0, 27919, 27920, 7, 0, 0, 0, 27920, 27921, + 7, 17, 0, 0, 27921, 27922, 7, 17, 0, 0, 27922, 4074, 1, 0, 0, 0, 27923, + 27924, 7, 4, 0, 0, 27924, 27925, 7, 3, 0, 0, 27925, 27926, 7, 0, 0, 0, + 27926, 27927, 7, 7, 0, 0, 27927, 27928, 7, 5, 0, 0, 27928, 27929, 7, 12, + 0, 0, 27929, 27930, 7, 4, 0, 0, 27930, 27931, 7, 12, 0, 0, 27931, 27932, + 7, 2, 0, 0, 27932, 27933, 7, 7, 0, 0, 27933, 27934, 7, 0, 0, 0, 27934, + 27935, 7, 11, 0, 0, 27935, 4076, 1, 0, 0, 0, 27936, 27937, 7, 4, 0, 0, + 27937, 27938, 7, 3, 0, 0, 27938, 27939, 7, 0, 0, 0, 27939, 27940, 7, 7, + 0, 0, 27940, 27941, 7, 5, 0, 0, 27941, 27942, 7, 12, 0, 0, 27942, 27943, + 7, 4, 0, 0, 27943, 27944, 7, 12, 0, 0, 27944, 27945, 7, 2, 0, 0, 27945, + 27946, 7, 7, 0, 0, 27946, 4078, 1, 0, 0, 0, 27947, 27948, 7, 4, 0, 0, 27948, + 27949, 7, 3, 0, 0, 27949, 27950, 7, 0, 0, 0, 27950, 27951, 7, 7, 0, 0, + 27951, 27952, 7, 5, 0, 0, 27952, 27953, 7, 11, 0, 0, 27953, 27954, 7, 0, + 0, 0, 27954, 27955, 7, 4, 0, 0, 27955, 27956, 7, 6, 0, 0, 27956, 4080, + 1, 0, 0, 0, 27957, 27958, 7, 4, 0, 0, 27958, 27959, 7, 3, 0, 0, 27959, + 27960, 7, 0, 0, 0, 27960, 27961, 7, 7, 0, 0, 27961, 27962, 7, 5, 0, 0, + 27962, 27963, 7, 11, 0, 0, 27963, 27964, 7, 0, 0, 0, 27964, 27965, 7, 4, + 0, 0, 27965, 27966, 7, 12, 0, 0, 27966, 27967, 7, 2, 0, 0, 27967, 27968, + 7, 7, 0, 0, 27968, 4082, 1, 0, 0, 0, 27969, 27970, 7, 4, 0, 0, 27970, 27971, + 7, 3, 0, 0, 27971, 27972, 7, 6, 0, 0, 27972, 27973, 7, 0, 0, 0, 27973, + 27974, 7, 4, 0, 0, 27974, 4084, 1, 0, 0, 0, 27975, 27976, 7, 4, 0, 0, 27976, + 27977, 7, 3, 0, 0, 27977, 27978, 7, 12, 0, 0, 27978, 27979, 7, 17, 0, 0, + 27979, 27980, 7, 17, 0, 0, 27980, 27981, 7, 6, 0, 0, 27981, 27982, 7, 3, + 0, 0, 27982, 27983, 7, 5, 0, 0, 27983, 4086, 1, 0, 0, 0, 27984, 27985, + 7, 4, 0, 0, 27985, 27986, 7, 3, 0, 0, 27986, 27987, 7, 12, 0, 0, 27987, + 27988, 7, 17, 0, 0, 27988, 27989, 7, 17, 0, 0, 27989, 27990, 7, 6, 0, 0, + 27990, 27991, 7, 3, 0, 0, 27991, 4088, 1, 0, 0, 0, 27992, 27993, 7, 4, + 0, 0, 27993, 27994, 7, 3, 0, 0, 27994, 27995, 7, 10, 0, 0, 27995, 27996, + 7, 6, 0, 0, 27996, 4090, 1, 0, 0, 0, 27997, 27998, 7, 4, 0, 0, 27998, 27999, + 7, 3, 0, 0, 27999, 28000, 7, 10, 0, 0, 28000, 28001, 7, 7, 0, 0, 28001, + 28002, 7, 8, 0, 0, 28002, 28003, 7, 0, 0, 0, 28003, 28004, 7, 4, 0, 0, + 28004, 28005, 7, 6, 0, 0, 28005, 4092, 1, 0, 0, 0, 28006, 28007, 7, 4, + 0, 0, 28007, 28008, 7, 3, 0, 0, 28008, 28009, 7, 10, 0, 0, 28009, 28010, + 7, 7, 0, 0, 28010, 28011, 7, 8, 0, 0, 28011, 4094, 1, 0, 0, 0, 28012, 28013, + 7, 4, 0, 0, 28013, 28014, 7, 3, 0, 0, 28014, 28015, 7, 10, 0, 0, 28015, + 28016, 7, 5, 0, 0, 28016, 28017, 7, 4, 0, 0, 28017, 28018, 7, 6, 0, 0, + 28018, 28019, 7, 9, 0, 0, 28019, 4096, 1, 0, 0, 0, 28020, 28021, 7, 4, + 0, 0, 28021, 28022, 7, 3, 0, 0, 28022, 28023, 7, 10, 0, 0, 28023, 28024, + 7, 5, 0, 0, 28024, 28025, 7, 4, 0, 0, 28025, 4098, 1, 0, 0, 0, 28026, 28027, + 7, 4, 0, 0, 28027, 28028, 7, 10, 0, 0, 28028, 28029, 7, 7, 0, 0, 28029, + 28030, 7, 12, 0, 0, 28030, 28031, 7, 7, 0, 0, 28031, 28032, 7, 17, 0, 0, + 28032, 4100, 1, 0, 0, 0, 28033, 28034, 7, 4, 0, 0, 28034, 28035, 7, 25, + 0, 0, 28035, 4102, 1, 0, 0, 0, 28036, 28037, 7, 4, 0, 0, 28037, 28038, + 7, 18, 0, 0, 28038, 28039, 7, 15, 0, 0, 28039, 28040, 7, 6, 0, 0, 28040, + 28041, 7, 5, 0, 0, 28041, 4104, 1, 0, 0, 0, 28042, 28043, 7, 4, 0, 0, 28043, + 28044, 7, 18, 0, 0, 28044, 28045, 7, 15, 0, 0, 28045, 28046, 7, 6, 0, 0, + 28046, 4106, 1, 0, 0, 0, 28047, 28048, 7, 4, 0, 0, 28048, 28049, 7, 23, + 0, 0, 28049, 28050, 5, 95, 0, 0, 28050, 28051, 7, 2, 0, 0, 28051, 28052, + 7, 16, 0, 0, 28052, 28053, 7, 16, 0, 0, 28053, 28054, 7, 5, 0, 0, 28054, + 28055, 7, 6, 0, 0, 28055, 28056, 7, 4, 0, 0, 28056, 4108, 1, 0, 0, 0, 28057, + 28058, 7, 10, 0, 0, 28058, 28059, 7, 1, 0, 0, 28059, 28060, 5, 50, 0, 0, + 28060, 4110, 1, 0, 0, 0, 28061, 28062, 7, 10, 0, 0, 28062, 28063, 7, 1, + 0, 0, 28063, 28064, 7, 0, 0, 0, 28064, 4112, 1, 0, 0, 0, 28065, 28066, + 7, 10, 0, 0, 28066, 28067, 7, 8, 0, 0, 28067, 28068, 7, 5, 0, 0, 28068, + 28069, 5, 50, 0, 0, 28069, 4114, 1, 0, 0, 0, 28070, 28071, 7, 10, 0, 0, + 28071, 28072, 7, 12, 0, 0, 28072, 28073, 7, 9, 0, 0, 28073, 4116, 1, 0, + 0, 0, 28074, 28075, 7, 10, 0, 0, 28075, 28076, 7, 7, 0, 0, 28076, 28077, + 7, 0, 0, 0, 28077, 28078, 7, 3, 0, 0, 28078, 28079, 7, 8, 0, 0, 28079, + 28080, 7, 19, 0, 0, 28080, 28081, 7, 12, 0, 0, 28081, 28082, 7, 13, 0, + 0, 28082, 28083, 7, 6, 0, 0, 28083, 28084, 7, 9, 0, 0, 28084, 4118, 1, + 0, 0, 0, 28085, 28086, 7, 10, 0, 0, 28086, 28087, 7, 7, 0, 0, 28087, 28088, + 7, 1, 0, 0, 28088, 28089, 7, 2, 0, 0, 28089, 28090, 7, 10, 0, 0, 28090, + 28091, 7, 7, 0, 0, 28091, 28092, 7, 9, 0, 0, 28092, 28093, 7, 6, 0, 0, + 28093, 28094, 7, 9, 0, 0, 28094, 4120, 1, 0, 0, 0, 28095, 28096, 7, 10, + 0, 0, 28096, 28097, 7, 7, 0, 0, 28097, 28098, 7, 1, 0, 0, 28098, 28099, + 7, 2, 0, 0, 28099, 28100, 7, 10, 0, 0, 28100, 28101, 7, 7, 0, 0, 28101, + 28102, 7, 9, 0, 0, 28102, 4122, 1, 0, 0, 0, 28103, 28104, 7, 10, 0, 0, + 28104, 28105, 7, 7, 0, 0, 28105, 28106, 7, 8, 0, 0, 28106, 28107, 7, 2, + 0, 0, 28107, 28108, 7, 7, 0, 0, 28108, 28109, 7, 9, 0, 0, 28109, 28110, + 7, 12, 0, 0, 28110, 28111, 7, 4, 0, 0, 28111, 28112, 7, 12, 0, 0, 28112, + 28113, 7, 2, 0, 0, 28113, 28114, 7, 7, 0, 0, 28114, 28115, 7, 0, 0, 0, + 28115, 28116, 7, 11, 0, 0, 28116, 4124, 1, 0, 0, 0, 28117, 28118, 7, 10, + 0, 0, 28118, 28119, 7, 7, 0, 0, 28119, 28120, 7, 9, 0, 0, 28120, 28121, + 7, 6, 0, 0, 28121, 28122, 7, 3, 0, 0, 28122, 4126, 1, 0, 0, 0, 28123, 28124, + 7, 10, 0, 0, 28124, 28125, 7, 7, 0, 0, 28125, 28126, 7, 9, 0, 0, 28126, + 28127, 7, 2, 0, 0, 28127, 4128, 1, 0, 0, 0, 28128, 28129, 7, 10, 0, 0, + 28129, 28130, 7, 7, 0, 0, 28130, 28131, 7, 9, 0, 0, 28131, 28132, 7, 3, + 0, 0, 28132, 28133, 7, 2, 0, 0, 28133, 28134, 7, 15, 0, 0, 28134, 4130, + 1, 0, 0, 0, 28135, 28136, 7, 10, 0, 0, 28136, 28137, 7, 7, 0, 0, 28137, + 28138, 7, 12, 0, 0, 28138, 28139, 7, 16, 0, 0, 28139, 28140, 7, 2, 0, 0, + 28140, 28141, 7, 3, 0, 0, 28141, 28142, 7, 14, 0, 0, 28142, 4132, 1, 0, + 0, 0, 28143, 28144, 7, 10, 0, 0, 28144, 28145, 7, 7, 0, 0, 28145, 28146, + 7, 12, 0, 0, 28146, 28147, 7, 2, 0, 0, 28147, 28148, 7, 7, 0, 0, 28148, + 4134, 1, 0, 0, 0, 28149, 28150, 7, 10, 0, 0, 28150, 28151, 7, 7, 0, 0, + 28151, 28152, 7, 12, 0, 0, 28152, 28153, 7, 24, 0, 0, 28153, 28154, 7, + 10, 0, 0, 28154, 28155, 7, 6, 0, 0, 28155, 4136, 1, 0, 0, 0, 28156, 28157, + 7, 10, 0, 0, 28157, 28158, 7, 7, 0, 0, 28158, 28159, 7, 12, 0, 0, 28159, + 28160, 7, 5, 0, 0, 28160, 28161, 7, 4, 0, 0, 28161, 28162, 7, 3, 0, 0, + 28162, 4138, 1, 0, 0, 0, 28163, 28164, 7, 10, 0, 0, 28164, 28165, 7, 7, + 0, 0, 28165, 28166, 7, 11, 0, 0, 28166, 28167, 7, 12, 0, 0, 28167, 28168, + 7, 14, 0, 0, 28168, 28169, 7, 12, 0, 0, 28169, 28170, 7, 4, 0, 0, 28170, + 28171, 7, 6, 0, 0, 28171, 28172, 7, 9, 0, 0, 28172, 4140, 1, 0, 0, 0, 28173, + 28174, 7, 10, 0, 0, 28174, 28175, 7, 7, 0, 0, 28175, 28176, 7, 11, 0, 0, + 28176, 28177, 7, 2, 0, 0, 28177, 28178, 7, 0, 0, 0, 28178, 28179, 7, 9, + 0, 0, 28179, 4142, 1, 0, 0, 0, 28180, 28181, 7, 10, 0, 0, 28181, 28182, + 7, 7, 0, 0, 28182, 28183, 7, 11, 0, 0, 28183, 28184, 7, 2, 0, 0, 28184, + 28185, 7, 8, 0, 0, 28185, 28186, 7, 21, 0, 0, 28186, 4144, 1, 0, 0, 0, + 28187, 28188, 7, 10, 0, 0, 28188, 28189, 7, 7, 0, 0, 28189, 28190, 7, 14, + 0, 0, 28190, 28191, 7, 0, 0, 0, 28191, 28192, 7, 4, 0, 0, 28192, 28193, + 7, 8, 0, 0, 28193, 28194, 7, 19, 0, 0, 28194, 28195, 7, 6, 0, 0, 28195, + 28196, 7, 9, 0, 0, 28196, 4146, 1, 0, 0, 0, 28197, 28198, 7, 10, 0, 0, + 28198, 28199, 7, 7, 0, 0, 28199, 28200, 7, 7, 0, 0, 28200, 28201, 7, 6, + 0, 0, 28201, 28202, 7, 5, 0, 0, 28202, 28203, 7, 4, 0, 0, 28203, 28204, + 5, 95, 0, 0, 28204, 28205, 7, 12, 0, 0, 28205, 28206, 7, 7, 0, 0, 28206, + 28207, 7, 7, 0, 0, 28207, 28208, 7, 6, 0, 0, 28208, 28209, 7, 3, 0, 0, + 28209, 28210, 7, 20, 0, 0, 28210, 28211, 5, 95, 0, 0, 28211, 28212, 7, + 9, 0, 0, 28212, 28213, 7, 12, 0, 0, 28213, 28214, 7, 5, 0, 0, 28214, 28215, + 7, 4, 0, 0, 28215, 28216, 7, 12, 0, 0, 28216, 28217, 7, 7, 0, 0, 28217, + 28218, 7, 8, 0, 0, 28218, 28219, 7, 4, 0, 0, 28219, 28220, 5, 95, 0, 0, + 28220, 28221, 7, 13, 0, 0, 28221, 28222, 7, 12, 0, 0, 28222, 28223, 7, + 6, 0, 0, 28223, 28224, 7, 22, 0, 0, 28224, 4148, 1, 0, 0, 0, 28225, 28226, + 7, 10, 0, 0, 28226, 28227, 7, 7, 0, 0, 28227, 28228, 7, 7, 0, 0, 28228, + 28229, 7, 6, 0, 0, 28229, 28230, 7, 5, 0, 0, 28230, 28231, 7, 4, 0, 0, + 28231, 28232, 5, 95, 0, 0, 28232, 28233, 7, 7, 0, 0, 28233, 28234, 7, 2, + 0, 0, 28234, 28235, 7, 5, 0, 0, 28235, 28236, 7, 6, 0, 0, 28236, 28237, + 7, 14, 0, 0, 28237, 28238, 7, 12, 0, 0, 28238, 28239, 7, 20, 0, 0, 28239, + 28240, 5, 95, 0, 0, 28240, 28241, 7, 7, 0, 0, 28241, 28242, 7, 2, 0, 0, + 28242, 28243, 7, 9, 0, 0, 28243, 28244, 7, 12, 0, 0, 28244, 28245, 7, 5, + 0, 0, 28245, 28246, 7, 4, 0, 0, 28246, 28247, 7, 12, 0, 0, 28247, 28248, + 7, 7, 0, 0, 28248, 28249, 7, 8, 0, 0, 28249, 28250, 7, 4, 0, 0, 28250, + 28251, 7, 13, 0, 0, 28251, 28252, 7, 12, 0, 0, 28252, 28253, 7, 6, 0, 0, + 28253, 28254, 7, 22, 0, 0, 28254, 4150, 1, 0, 0, 0, 28255, 28256, 7, 10, + 0, 0, 28256, 28257, 7, 7, 0, 0, 28257, 28258, 7, 7, 0, 0, 28258, 28259, + 7, 6, 0, 0, 28259, 28260, 7, 5, 0, 0, 28260, 28261, 7, 4, 0, 0, 28261, + 28262, 5, 95, 0, 0, 28262, 28263, 7, 5, 0, 0, 28263, 28264, 7, 6, 0, 0, + 28264, 28265, 7, 14, 0, 0, 28265, 28266, 7, 12, 0, 0, 28266, 28267, 7, + 20, 0, 0, 28267, 28268, 5, 95, 0, 0, 28268, 28269, 7, 13, 0, 0, 28269, + 28270, 7, 12, 0, 0, 28270, 28271, 7, 6, 0, 0, 28271, 28272, 7, 22, 0, 0, + 28272, 4152, 1, 0, 0, 0, 28273, 28274, 7, 10, 0, 0, 28274, 28275, 7, 7, + 0, 0, 28275, 28276, 7, 7, 0, 0, 28276, 28277, 7, 6, 0, 0, 28277, 28278, + 7, 5, 0, 0, 28278, 28279, 7, 4, 0, 0, 28279, 4154, 1, 0, 0, 0, 28280, 28281, + 7, 10, 0, 0, 28281, 28282, 7, 7, 0, 0, 28282, 28283, 7, 15, 0, 0, 28283, + 28284, 7, 0, 0, 0, 28284, 28285, 7, 8, 0, 0, 28285, 28286, 7, 21, 0, 0, + 28286, 28287, 7, 6, 0, 0, 28287, 28288, 7, 9, 0, 0, 28288, 4156, 1, 0, + 0, 0, 28289, 28290, 7, 10, 0, 0, 28290, 28291, 7, 7, 0, 0, 28291, 28292, + 7, 15, 0, 0, 28292, 28293, 7, 12, 0, 0, 28293, 28294, 7, 13, 0, 0, 28294, + 28295, 7, 2, 0, 0, 28295, 28296, 7, 4, 0, 0, 28296, 4158, 1, 0, 0, 0, 28297, + 28298, 7, 10, 0, 0, 28298, 28299, 7, 7, 0, 0, 28299, 28300, 7, 15, 0, 0, + 28300, 28301, 7, 11, 0, 0, 28301, 28302, 7, 10, 0, 0, 28302, 28303, 7, + 17, 0, 0, 28303, 4160, 1, 0, 0, 0, 28304, 28305, 7, 10, 0, 0, 28305, 28306, + 7, 7, 0, 0, 28306, 28307, 7, 15, 0, 0, 28307, 28308, 7, 3, 0, 0, 28308, + 28309, 7, 2, 0, 0, 28309, 28310, 7, 4, 0, 0, 28310, 28311, 7, 6, 0, 0, + 28311, 28312, 7, 8, 0, 0, 28312, 28313, 7, 4, 0, 0, 28313, 28314, 7, 6, + 0, 0, 28314, 28315, 7, 9, 0, 0, 28315, 4162, 1, 0, 0, 0, 28316, 28317, + 7, 10, 0, 0, 28317, 28318, 7, 7, 0, 0, 28318, 28319, 7, 24, 0, 0, 28319, + 28320, 7, 10, 0, 0, 28320, 28321, 7, 12, 0, 0, 28321, 28322, 7, 6, 0, 0, + 28322, 28323, 7, 5, 0, 0, 28323, 28324, 7, 8, 0, 0, 28324, 28325, 7, 6, + 0, 0, 28325, 4164, 1, 0, 0, 0, 28326, 28327, 7, 10, 0, 0, 28327, 28328, + 7, 7, 0, 0, 28328, 28329, 7, 3, 0, 0, 28329, 28330, 7, 6, 0, 0, 28330, + 28331, 7, 8, 0, 0, 28331, 28332, 7, 2, 0, 0, 28332, 28333, 7, 13, 0, 0, + 28333, 28334, 7, 6, 0, 0, 28334, 28335, 7, 3, 0, 0, 28335, 28336, 7, 0, + 0, 0, 28336, 28337, 7, 1, 0, 0, 28337, 28338, 7, 11, 0, 0, 28338, 28339, + 7, 6, 0, 0, 28339, 4166, 1, 0, 0, 0, 28340, 28341, 7, 10, 0, 0, 28341, + 28342, 7, 7, 0, 0, 28342, 28343, 7, 3, 0, 0, 28343, 28344, 7, 6, 0, 0, + 28344, 28345, 7, 5, 0, 0, 28345, 28346, 7, 4, 0, 0, 28346, 28347, 7, 3, + 0, 0, 28347, 28348, 7, 12, 0, 0, 28348, 28349, 7, 8, 0, 0, 28349, 28350, + 7, 4, 0, 0, 28350, 28351, 7, 6, 0, 0, 28351, 28352, 7, 9, 0, 0, 28352, + 4168, 1, 0, 0, 0, 28353, 28354, 7, 10, 0, 0, 28354, 28355, 7, 7, 0, 0, + 28355, 28356, 7, 5, 0, 0, 28356, 28357, 7, 10, 0, 0, 28357, 28358, 7, 1, + 0, 0, 28358, 28359, 7, 5, 0, 0, 28359, 28360, 7, 8, 0, 0, 28360, 28361, + 7, 3, 0, 0, 28361, 28362, 7, 12, 0, 0, 28362, 28363, 7, 1, 0, 0, 28363, + 28364, 7, 6, 0, 0, 28364, 4170, 1, 0, 0, 0, 28365, 28366, 7, 10, 0, 0, + 28366, 28367, 7, 7, 0, 0, 28367, 28368, 7, 4, 0, 0, 28368, 28369, 7, 12, + 0, 0, 28369, 28370, 7, 11, 0, 0, 28370, 4172, 1, 0, 0, 0, 28371, 28372, + 7, 10, 0, 0, 28372, 28373, 7, 7, 0, 0, 28373, 28374, 7, 10, 0, 0, 28374, + 28375, 7, 5, 0, 0, 28375, 28376, 7, 0, 0, 0, 28376, 28377, 7, 1, 0, 0, + 28377, 28378, 7, 11, 0, 0, 28378, 28379, 7, 6, 0, 0, 28379, 4174, 1, 0, + 0, 0, 28380, 28381, 7, 10, 0, 0, 28381, 28382, 7, 7, 0, 0, 28382, 28383, + 7, 10, 0, 0, 28383, 28384, 7, 5, 0, 0, 28384, 28385, 7, 6, 0, 0, 28385, + 28386, 7, 9, 0, 0, 28386, 4176, 1, 0, 0, 0, 28387, 28388, 7, 10, 0, 0, + 28388, 28389, 7, 15, 0, 0, 28389, 28390, 7, 9, 0, 0, 28390, 28391, 7, 0, + 0, 0, 28391, 28392, 7, 4, 0, 0, 28392, 28393, 7, 0, 0, 0, 28393, 28394, + 7, 1, 0, 0, 28394, 28395, 7, 11, 0, 0, 28395, 28396, 7, 6, 0, 0, 28396, + 4178, 1, 0, 0, 0, 28397, 28398, 7, 10, 0, 0, 28398, 28399, 7, 15, 0, 0, + 28399, 28400, 7, 9, 0, 0, 28400, 28401, 7, 0, 0, 0, 28401, 28402, 7, 4, + 0, 0, 28402, 28403, 7, 6, 0, 0, 28403, 28404, 7, 9, 0, 0, 28404, 4180, + 1, 0, 0, 0, 28405, 28406, 7, 10, 0, 0, 28406, 28407, 7, 15, 0, 0, 28407, + 28408, 7, 9, 0, 0, 28408, 28409, 7, 0, 0, 0, 28409, 28410, 7, 4, 0, 0, + 28410, 28411, 7, 6, 0, 0, 28411, 4182, 1, 0, 0, 0, 28412, 28413, 7, 10, + 0, 0, 28413, 28414, 7, 15, 0, 0, 28414, 28415, 7, 9, 0, 0, 28415, 28416, + 7, 0, 0, 0, 28416, 28417, 7, 4, 0, 0, 28417, 28418, 7, 6, 0, 0, 28418, + 28419, 7, 25, 0, 0, 28419, 28420, 7, 14, 0, 0, 28420, 28421, 7, 11, 0, + 0, 28421, 4184, 1, 0, 0, 0, 28422, 28423, 7, 10, 0, 0, 28423, 28424, 7, + 15, 0, 0, 28424, 28425, 7, 9, 0, 0, 28425, 28426, 5, 95, 0, 0, 28426, 28427, + 7, 12, 0, 0, 28427, 28428, 7, 7, 0, 0, 28428, 28429, 7, 9, 0, 0, 28429, + 28430, 7, 6, 0, 0, 28430, 28431, 7, 25, 0, 0, 28431, 28432, 7, 6, 0, 0, + 28432, 28433, 7, 5, 0, 0, 28433, 4186, 1, 0, 0, 0, 28434, 28435, 7, 10, + 0, 0, 28435, 28436, 7, 15, 0, 0, 28436, 28437, 7, 9, 0, 0, 28437, 28438, + 5, 95, 0, 0, 28438, 28439, 7, 20, 0, 0, 28439, 28440, 7, 2, 0, 0, 28440, + 28441, 7, 12, 0, 0, 28441, 28442, 7, 7, 0, 0, 28442, 28443, 7, 12, 0, 0, + 28443, 28444, 7, 7, 0, 0, 28444, 28445, 7, 9, 0, 0, 28445, 28446, 7, 6, + 0, 0, 28446, 28447, 7, 25, 0, 0, 28447, 4188, 1, 0, 0, 0, 28448, 28449, + 7, 10, 0, 0, 28449, 28450, 7, 15, 0, 0, 28450, 28451, 7, 17, 0, 0, 28451, + 28452, 7, 3, 0, 0, 28452, 28453, 7, 0, 0, 0, 28453, 28454, 7, 9, 0, 0, + 28454, 28455, 7, 6, 0, 0, 28455, 4190, 1, 0, 0, 0, 28456, 28457, 7, 10, + 0, 0, 28457, 28458, 7, 15, 0, 0, 28458, 28459, 7, 15, 0, 0, 28459, 28460, + 7, 6, 0, 0, 28460, 28461, 7, 3, 0, 0, 28461, 4192, 1, 0, 0, 0, 28462, 28463, + 7, 10, 0, 0, 28463, 28464, 7, 15, 0, 0, 28464, 28465, 7, 5, 0, 0, 28465, + 28466, 7, 6, 0, 0, 28466, 28467, 7, 3, 0, 0, 28467, 28468, 7, 4, 0, 0, + 28468, 4194, 1, 0, 0, 0, 28469, 28470, 7, 10, 0, 0, 28470, 28471, 7, 3, + 0, 0, 28471, 28472, 7, 2, 0, 0, 28472, 28473, 7, 22, 0, 0, 28473, 28474, + 7, 12, 0, 0, 28474, 28475, 7, 9, 0, 0, 28475, 4196, 1, 0, 0, 0, 28476, + 28477, 7, 10, 0, 0, 28477, 28478, 7, 5, 0, 0, 28478, 28479, 7, 0, 0, 0, + 28479, 28480, 7, 1, 0, 0, 28480, 28481, 7, 11, 0, 0, 28481, 28482, 7, 6, + 0, 0, 28482, 4198, 1, 0, 0, 0, 28483, 28484, 7, 10, 0, 0, 28484, 28485, + 7, 5, 0, 0, 28485, 28486, 7, 0, 0, 0, 28486, 28487, 7, 17, 0, 0, 28487, + 28488, 7, 6, 0, 0, 28488, 4200, 1, 0, 0, 0, 28489, 28490, 7, 10, 0, 0, + 28490, 28491, 7, 5, 0, 0, 28491, 28492, 7, 6, 0, 0, 28492, 28493, 5, 95, + 0, 0, 28493, 28494, 7, 0, 0, 0, 28494, 28495, 7, 7, 0, 0, 28495, 28496, + 7, 4, 0, 0, 28496, 28497, 7, 12, 0, 0, 28497, 4202, 1, 0, 0, 0, 28498, + 28499, 7, 10, 0, 0, 28499, 28500, 7, 5, 0, 0, 28500, 28501, 7, 6, 0, 0, + 28501, 28502, 5, 95, 0, 0, 28502, 28503, 7, 8, 0, 0, 28503, 28504, 7, 2, + 0, 0, 28504, 28505, 7, 7, 0, 0, 28505, 28506, 7, 8, 0, 0, 28506, 28507, + 7, 0, 0, 0, 28507, 28508, 7, 4, 0, 0, 28508, 4204, 1, 0, 0, 0, 28509, 28510, + 7, 10, 0, 0, 28510, 28511, 7, 5, 0, 0, 28511, 28512, 7, 6, 0, 0, 28512, + 28513, 5, 95, 0, 0, 28513, 28514, 7, 8, 0, 0, 28514, 28515, 7, 10, 0, 0, + 28515, 28516, 7, 1, 0, 0, 28516, 28517, 7, 6, 0, 0, 28517, 4206, 1, 0, + 0, 0, 28518, 28519, 7, 10, 0, 0, 28519, 28520, 7, 5, 0, 0, 28520, 28521, + 7, 6, 0, 0, 28521, 28522, 5, 95, 0, 0, 28522, 28523, 7, 19, 0, 0, 28523, + 28524, 7, 0, 0, 0, 28524, 28525, 7, 5, 0, 0, 28525, 28526, 7, 19, 0, 0, + 28526, 28527, 5, 95, 0, 0, 28527, 28528, 7, 0, 0, 0, 28528, 28529, 7, 17, + 0, 0, 28529, 28530, 7, 17, 0, 0, 28530, 28531, 7, 3, 0, 0, 28531, 28532, + 7, 6, 0, 0, 28532, 28533, 7, 17, 0, 0, 28533, 28534, 7, 0, 0, 0, 28534, + 28535, 7, 4, 0, 0, 28535, 28536, 7, 12, 0, 0, 28536, 28537, 7, 2, 0, 0, + 28537, 28538, 7, 7, 0, 0, 28538, 4208, 1, 0, 0, 0, 28539, 28540, 7, 10, + 0, 0, 28540, 28541, 7, 5, 0, 0, 28541, 28542, 7, 6, 0, 0, 28542, 28543, + 5, 95, 0, 0, 28543, 28544, 7, 19, 0, 0, 28544, 28545, 7, 0, 0, 0, 28545, + 28546, 7, 5, 0, 0, 28546, 28547, 7, 19, 0, 0, 28547, 28548, 5, 95, 0, 0, + 28548, 28549, 7, 17, 0, 0, 28549, 28550, 7, 1, 0, 0, 28550, 28551, 7, 18, + 0, 0, 28551, 28552, 5, 95, 0, 0, 28552, 28553, 7, 16, 0, 0, 28553, 28554, + 7, 2, 0, 0, 28554, 28555, 7, 3, 0, 0, 28555, 28556, 5, 95, 0, 0, 28556, + 28557, 7, 15, 0, 0, 28557, 28558, 7, 10, 0, 0, 28558, 28559, 7, 5, 0, 0, + 28559, 28560, 7, 19, 0, 0, 28560, 28561, 7, 9, 0, 0, 28561, 28562, 7, 2, + 0, 0, 28562, 28563, 7, 22, 0, 0, 28563, 28564, 7, 7, 0, 0, 28564, 4210, + 1, 0, 0, 0, 28565, 28566, 7, 10, 0, 0, 28566, 28567, 7, 5, 0, 0, 28567, + 28568, 7, 6, 0, 0, 28568, 28569, 5, 95, 0, 0, 28569, 28570, 7, 19, 0, 0, + 28570, 28571, 7, 0, 0, 0, 28571, 28572, 7, 5, 0, 0, 28572, 28573, 7, 19, + 0, 0, 28573, 4212, 1, 0, 0, 0, 28574, 28575, 7, 10, 0, 0, 28575, 28576, + 7, 5, 0, 0, 28576, 28577, 7, 6, 0, 0, 28577, 28578, 5, 95, 0, 0, 28578, + 28579, 7, 19, 0, 0, 28579, 28580, 7, 12, 0, 0, 28580, 28581, 7, 9, 0, 0, + 28581, 28582, 7, 9, 0, 0, 28582, 28583, 7, 6, 0, 0, 28583, 28584, 7, 7, + 0, 0, 28584, 28585, 5, 95, 0, 0, 28585, 28586, 7, 15, 0, 0, 28586, 28587, + 7, 0, 0, 0, 28587, 28588, 7, 3, 0, 0, 28588, 28589, 7, 4, 0, 0, 28589, + 28590, 7, 12, 0, 0, 28590, 28591, 7, 4, 0, 0, 28591, 28592, 7, 12, 0, 0, + 28592, 28593, 7, 2, 0, 0, 28593, 28594, 7, 7, 0, 0, 28594, 28595, 7, 5, + 0, 0, 28595, 4214, 1, 0, 0, 0, 28596, 28597, 7, 10, 0, 0, 28597, 28598, + 7, 5, 0, 0, 28598, 28599, 7, 6, 0, 0, 28599, 28600, 5, 95, 0, 0, 28600, + 28601, 7, 12, 0, 0, 28601, 28602, 7, 7, 0, 0, 28602, 28603, 7, 13, 0, 0, + 28603, 28604, 7, 12, 0, 0, 28604, 28605, 7, 5, 0, 0, 28605, 28606, 7, 12, + 0, 0, 28606, 28607, 7, 1, 0, 0, 28607, 28608, 7, 11, 0, 0, 28608, 28609, + 7, 6, 0, 0, 28609, 28610, 5, 95, 0, 0, 28610, 28611, 7, 12, 0, 0, 28611, + 28612, 7, 7, 0, 0, 28612, 28613, 7, 9, 0, 0, 28613, 28614, 7, 6, 0, 0, + 28614, 28615, 7, 25, 0, 0, 28615, 28616, 7, 6, 0, 0, 28616, 28617, 7, 5, + 0, 0, 28617, 4216, 1, 0, 0, 0, 28618, 28619, 7, 10, 0, 0, 28619, 28620, + 7, 5, 0, 0, 28620, 28621, 7, 6, 0, 0, 28621, 28622, 5, 95, 0, 0, 28622, + 28623, 7, 14, 0, 0, 28623, 28624, 7, 6, 0, 0, 28624, 28625, 7, 3, 0, 0, + 28625, 28626, 7, 17, 0, 0, 28626, 28627, 7, 6, 0, 0, 28627, 28628, 5, 95, + 0, 0, 28628, 28629, 7, 8, 0, 0, 28629, 28630, 7, 0, 0, 0, 28630, 28631, + 7, 3, 0, 0, 28631, 28632, 7, 4, 0, 0, 28632, 28633, 7, 6, 0, 0, 28633, + 28634, 7, 5, 0, 0, 28634, 28635, 7, 12, 0, 0, 28635, 28636, 7, 0, 0, 0, + 28636, 28637, 7, 7, 0, 0, 28637, 4218, 1, 0, 0, 0, 28638, 28639, 7, 10, + 0, 0, 28639, 28640, 7, 5, 0, 0, 28640, 28641, 7, 6, 0, 0, 28641, 28642, + 5, 95, 0, 0, 28642, 28643, 7, 14, 0, 0, 28643, 28644, 7, 6, 0, 0, 28644, + 28645, 7, 3, 0, 0, 28645, 28646, 7, 17, 0, 0, 28646, 28647, 7, 6, 0, 0, + 28647, 4220, 1, 0, 0, 0, 28648, 28649, 7, 10, 0, 0, 28649, 28650, 7, 5, + 0, 0, 28650, 28651, 7, 6, 0, 0, 28651, 28652, 5, 95, 0, 0, 28652, 28653, + 7, 7, 0, 0, 28653, 28654, 7, 11, 0, 0, 28654, 4222, 1, 0, 0, 0, 28655, + 28656, 7, 10, 0, 0, 28656, 28657, 7, 5, 0, 0, 28657, 28658, 7, 6, 0, 0, + 28658, 28659, 5, 95, 0, 0, 28659, 28660, 7, 7, 0, 0, 28660, 28661, 7, 11, + 0, 0, 28661, 28662, 5, 95, 0, 0, 28662, 28663, 7, 22, 0, 0, 28663, 28664, + 7, 12, 0, 0, 28664, 28665, 7, 4, 0, 0, 28665, 28666, 7, 19, 0, 0, 28666, + 28667, 5, 95, 0, 0, 28667, 28668, 7, 12, 0, 0, 28668, 28669, 7, 7, 0, 0, + 28669, 28670, 7, 9, 0, 0, 28670, 28671, 7, 6, 0, 0, 28671, 28672, 7, 25, + 0, 0, 28672, 4224, 1, 0, 0, 0, 28673, 28674, 7, 10, 0, 0, 28674, 28675, + 7, 5, 0, 0, 28675, 28676, 7, 6, 0, 0, 28676, 28677, 5, 95, 0, 0, 28677, + 28678, 7, 15, 0, 0, 28678, 28679, 7, 3, 0, 0, 28679, 28680, 7, 12, 0, 0, + 28680, 28681, 7, 13, 0, 0, 28681, 28682, 7, 0, 0, 0, 28682, 28683, 7, 4, + 0, 0, 28683, 28684, 7, 6, 0, 0, 28684, 28685, 5, 95, 0, 0, 28685, 28686, + 7, 2, 0, 0, 28686, 28687, 7, 10, 0, 0, 28687, 28688, 7, 4, 0, 0, 28688, + 28689, 7, 11, 0, 0, 28689, 28690, 7, 12, 0, 0, 28690, 28691, 7, 7, 0, 0, + 28691, 28692, 7, 6, 0, 0, 28692, 28693, 7, 5, 0, 0, 28693, 4226, 1, 0, + 0, 0, 28694, 28695, 7, 10, 0, 0, 28695, 28696, 7, 5, 0, 0, 28696, 28697, + 7, 6, 0, 0, 28697, 28698, 7, 3, 0, 0, 28698, 28699, 5, 95, 0, 0, 28699, + 28700, 7, 9, 0, 0, 28700, 28701, 7, 0, 0, 0, 28701, 28702, 7, 4, 0, 0, + 28702, 28703, 7, 0, 0, 0, 28703, 4228, 1, 0, 0, 0, 28704, 28705, 7, 10, + 0, 0, 28705, 28706, 7, 5, 0, 0, 28706, 28707, 7, 6, 0, 0, 28707, 28708, + 7, 3, 0, 0, 28708, 28709, 5, 95, 0, 0, 28709, 28710, 7, 9, 0, 0, 28710, + 28711, 7, 6, 0, 0, 28711, 28712, 7, 16, 0, 0, 28712, 28713, 7, 12, 0, 0, + 28713, 28714, 7, 7, 0, 0, 28714, 28715, 7, 6, 0, 0, 28715, 28716, 7, 9, + 0, 0, 28716, 4230, 1, 0, 0, 0, 28717, 28718, 7, 10, 0, 0, 28718, 28719, + 7, 5, 0, 0, 28719, 28720, 7, 6, 0, 0, 28720, 28721, 7, 3, 0, 0, 28721, + 28722, 7, 6, 0, 0, 28722, 28723, 7, 7, 0, 0, 28723, 28724, 7, 13, 0, 0, + 28724, 4232, 1, 0, 0, 0, 28725, 28726, 7, 10, 0, 0, 28726, 28727, 7, 5, + 0, 0, 28727, 28728, 7, 6, 0, 0, 28728, 28729, 7, 3, 0, 0, 28729, 28730, + 7, 17, 0, 0, 28730, 28731, 7, 3, 0, 0, 28731, 28732, 7, 2, 0, 0, 28732, + 28733, 7, 10, 0, 0, 28733, 28734, 7, 15, 0, 0, 28734, 4234, 1, 0, 0, 0, + 28735, 28736, 7, 10, 0, 0, 28736, 28737, 7, 5, 0, 0, 28737, 28738, 7, 6, + 0, 0, 28738, 28739, 7, 3, 0, 0, 28739, 28740, 5, 95, 0, 0, 28740, 28741, + 7, 3, 0, 0, 28741, 28742, 7, 6, 0, 0, 28742, 28743, 7, 8, 0, 0, 28743, + 28744, 7, 18, 0, 0, 28744, 28745, 7, 8, 0, 0, 28745, 28746, 7, 11, 0, 0, + 28746, 28747, 7, 6, 0, 0, 28747, 28748, 7, 1, 0, 0, 28748, 28749, 7, 12, + 0, 0, 28749, 28750, 7, 7, 0, 0, 28750, 4236, 1, 0, 0, 0, 28751, 28752, + 7, 10, 0, 0, 28752, 28753, 7, 5, 0, 0, 28753, 28754, 7, 6, 0, 0, 28754, + 28755, 7, 3, 0, 0, 28755, 28756, 7, 5, 0, 0, 28756, 4238, 1, 0, 0, 0, 28757, + 28758, 7, 10, 0, 0, 28758, 28759, 7, 5, 0, 0, 28759, 28760, 7, 6, 0, 0, + 28760, 28761, 7, 3, 0, 0, 28761, 28762, 5, 95, 0, 0, 28762, 28763, 7, 4, + 0, 0, 28763, 28764, 7, 0, 0, 0, 28764, 28765, 7, 1, 0, 0, 28765, 28766, + 7, 11, 0, 0, 28766, 28767, 7, 6, 0, 0, 28767, 28768, 7, 5, 0, 0, 28768, + 28769, 7, 15, 0, 0, 28769, 28770, 7, 0, 0, 0, 28770, 28771, 7, 8, 0, 0, + 28771, 28772, 7, 6, 0, 0, 28772, 28773, 7, 5, 0, 0, 28773, 4240, 1, 0, + 0, 0, 28774, 28775, 7, 10, 0, 0, 28775, 28776, 7, 5, 0, 0, 28776, 28777, + 7, 6, 0, 0, 28777, 28778, 7, 3, 0, 0, 28778, 4242, 1, 0, 0, 0, 28779, 28780, + 7, 10, 0, 0, 28780, 28781, 7, 5, 0, 0, 28781, 28782, 7, 6, 0, 0, 28782, + 28783, 5, 95, 0, 0, 28783, 28784, 7, 5, 0, 0, 28784, 28785, 7, 6, 0, 0, + 28785, 28786, 7, 14, 0, 0, 28786, 28787, 7, 12, 0, 0, 28787, 4244, 1, 0, + 0, 0, 28788, 28789, 7, 10, 0, 0, 28789, 28790, 7, 5, 0, 0, 28790, 28791, + 7, 6, 0, 0, 28791, 28792, 5, 95, 0, 0, 28792, 28793, 7, 5, 0, 0, 28793, + 28794, 7, 4, 0, 0, 28794, 28795, 7, 2, 0, 0, 28795, 28796, 7, 3, 0, 0, + 28796, 28797, 7, 6, 0, 0, 28797, 28798, 7, 9, 0, 0, 28798, 28799, 5, 95, + 0, 0, 28799, 28800, 7, 2, 0, 0, 28800, 28801, 7, 10, 0, 0, 28801, 28802, + 7, 4, 0, 0, 28802, 28803, 7, 11, 0, 0, 28803, 28804, 7, 12, 0, 0, 28804, + 28805, 7, 7, 0, 0, 28805, 28806, 7, 6, 0, 0, 28806, 28807, 7, 5, 0, 0, + 28807, 4246, 1, 0, 0, 0, 28808, 28809, 7, 10, 0, 0, 28809, 28810, 7, 5, + 0, 0, 28810, 28811, 7, 6, 0, 0, 28811, 28812, 5, 95, 0, 0, 28812, 28813, + 7, 4, 0, 0, 28813, 28814, 7, 4, 0, 0, 28814, 28815, 7, 4, 0, 0, 28815, + 28816, 5, 95, 0, 0, 28816, 28817, 7, 16, 0, 0, 28817, 28818, 7, 2, 0, 0, + 28818, 28819, 7, 3, 0, 0, 28819, 28820, 5, 95, 0, 0, 28820, 28821, 7, 17, + 0, 0, 28821, 28822, 7, 5, 0, 0, 28822, 28823, 7, 6, 0, 0, 28823, 28824, + 7, 4, 0, 0, 28824, 28825, 7, 5, 0, 0, 28825, 4248, 1, 0, 0, 0, 28826, 28827, + 7, 10, 0, 0, 28827, 28828, 7, 5, 0, 0, 28828, 28829, 7, 6, 0, 0, 28829, + 4250, 1, 0, 0, 0, 28830, 28831, 7, 10, 0, 0, 28831, 28832, 7, 5, 0, 0, + 28832, 28833, 7, 6, 0, 0, 28833, 28834, 5, 95, 0, 0, 28834, 28835, 7, 13, + 0, 0, 28835, 28836, 7, 6, 0, 0, 28836, 28837, 7, 8, 0, 0, 28837, 28838, + 7, 4, 0, 0, 28838, 28839, 7, 2, 0, 0, 28839, 28840, 7, 3, 0, 0, 28840, + 28841, 5, 95, 0, 0, 28841, 28842, 7, 0, 0, 0, 28842, 28843, 7, 17, 0, 0, + 28843, 28844, 7, 17, 0, 0, 28844, 28845, 7, 3, 0, 0, 28845, 28846, 7, 6, + 0, 0, 28846, 28847, 7, 17, 0, 0, 28847, 28848, 7, 0, 0, 0, 28848, 28849, + 7, 4, 0, 0, 28849, 28850, 7, 12, 0, 0, 28850, 28851, 7, 2, 0, 0, 28851, + 28852, 7, 7, 0, 0, 28852, 4252, 1, 0, 0, 0, 28853, 28854, 7, 10, 0, 0, + 28854, 28855, 7, 5, 0, 0, 28855, 28856, 7, 6, 0, 0, 28856, 28857, 5, 95, + 0, 0, 28857, 28858, 7, 22, 0, 0, 28858, 28859, 7, 6, 0, 0, 28859, 28860, + 7, 0, 0, 0, 28860, 28861, 7, 21, 0, 0, 28861, 28862, 5, 95, 0, 0, 28862, + 28863, 7, 7, 0, 0, 28863, 28864, 7, 0, 0, 0, 28864, 28865, 7, 14, 0, 0, + 28865, 28866, 7, 6, 0, 0, 28866, 28867, 5, 95, 0, 0, 28867, 28868, 7, 3, + 0, 0, 28868, 28869, 7, 6, 0, 0, 28869, 28870, 7, 5, 0, 0, 28870, 28871, + 7, 11, 0, 0, 28871, 4254, 1, 0, 0, 0, 28872, 28873, 7, 10, 0, 0, 28873, + 28874, 7, 5, 0, 0, 28874, 28875, 7, 12, 0, 0, 28875, 28876, 7, 7, 0, 0, + 28876, 28877, 7, 17, 0, 0, 28877, 28878, 5, 95, 0, 0, 28878, 28879, 7, + 7, 0, 0, 28879, 28880, 7, 2, 0, 0, 28880, 28881, 5, 95, 0, 0, 28881, 28882, + 7, 6, 0, 0, 28882, 28883, 7, 25, 0, 0, 28883, 28884, 7, 15, 0, 0, 28884, + 28885, 7, 0, 0, 0, 28885, 28886, 7, 7, 0, 0, 28886, 28887, 7, 9, 0, 0, + 28887, 4256, 1, 0, 0, 0, 28888, 28889, 7, 10, 0, 0, 28889, 28890, 7, 5, + 0, 0, 28890, 28891, 7, 12, 0, 0, 28891, 28892, 7, 7, 0, 0, 28892, 28893, + 7, 17, 0, 0, 28893, 4258, 1, 0, 0, 0, 28894, 28895, 7, 10, 0, 0, 28895, + 28896, 7, 4, 0, 0, 28896, 28897, 7, 16, 0, 0, 28897, 28898, 5, 49, 0, 0, + 28898, 28899, 5, 54, 0, 0, 28899, 28900, 7, 1, 0, 0, 28900, 28901, 7, 6, + 0, 0, 28901, 4260, 1, 0, 0, 0, 28902, 28903, 7, 10, 0, 0, 28903, 28904, + 7, 4, 0, 0, 28904, 28905, 7, 16, 0, 0, 28905, 28906, 5, 49, 0, 0, 28906, + 28907, 5, 54, 0, 0, 28907, 28908, 7, 11, 0, 0, 28908, 28909, 7, 6, 0, 0, + 28909, 4262, 1, 0, 0, 0, 28910, 28911, 7, 10, 0, 0, 28911, 28912, 7, 4, + 0, 0, 28912, 28913, 7, 16, 0, 0, 28913, 28914, 5, 51, 0, 0, 28914, 28915, + 5, 50, 0, 0, 28915, 4264, 1, 0, 0, 0, 28916, 28917, 7, 10, 0, 0, 28917, + 28918, 7, 4, 0, 0, 28918, 28919, 7, 16, 0, 0, 28919, 28920, 5, 56, 0, 0, + 28920, 4266, 1, 0, 0, 0, 28921, 28922, 7, 13, 0, 0, 28922, 28923, 5, 49, + 0, 0, 28923, 4268, 1, 0, 0, 0, 28924, 28925, 7, 13, 0, 0, 28925, 28926, + 5, 50, 0, 0, 28926, 4270, 1, 0, 0, 0, 28927, 28928, 7, 13, 0, 0, 28928, + 28929, 7, 0, 0, 0, 28929, 28930, 7, 11, 0, 0, 28930, 28931, 7, 12, 0, 0, + 28931, 28932, 7, 9, 0, 0, 28932, 28933, 7, 0, 0, 0, 28933, 28934, 7, 4, + 0, 0, 28934, 28935, 7, 6, 0, 0, 28935, 4272, 1, 0, 0, 0, 28936, 28937, + 7, 13, 0, 0, 28937, 28938, 7, 0, 0, 0, 28938, 28939, 7, 11, 0, 0, 28939, + 28940, 7, 12, 0, 0, 28940, 28941, 7, 9, 0, 0, 28941, 28942, 7, 0, 0, 0, + 28942, 28943, 7, 4, 0, 0, 28943, 28944, 7, 6, 0, 0, 28944, 28945, 5, 95, + 0, 0, 28945, 28946, 7, 8, 0, 0, 28946, 28947, 7, 2, 0, 0, 28947, 28948, + 7, 7, 0, 0, 28948, 28949, 7, 13, 0, 0, 28949, 28950, 7, 6, 0, 0, 28950, + 28951, 7, 3, 0, 0, 28951, 28952, 7, 5, 0, 0, 28952, 28953, 7, 12, 0, 0, + 28953, 28954, 7, 2, 0, 0, 28954, 28955, 7, 7, 0, 0, 28955, 4274, 1, 0, + 0, 0, 28956, 28957, 7, 13, 0, 0, 28957, 28958, 7, 0, 0, 0, 28958, 28959, + 7, 11, 0, 0, 28959, 28960, 7, 12, 0, 0, 28960, 28961, 7, 9, 0, 0, 28961, + 28962, 7, 0, 0, 0, 28962, 28963, 7, 4, 0, 0, 28963, 28964, 7, 12, 0, 0, + 28964, 28965, 7, 2, 0, 0, 28965, 28966, 7, 7, 0, 0, 28966, 4276, 1, 0, + 0, 0, 28967, 28968, 7, 13, 0, 0, 28968, 28969, 7, 0, 0, 0, 28969, 28970, + 7, 11, 0, 0, 28970, 28971, 7, 12, 0, 0, 28971, 28972, 7, 9, 0, 0, 28972, + 28973, 5, 95, 0, 0, 28973, 28974, 7, 4, 0, 0, 28974, 28975, 7, 12, 0, 0, + 28975, 28976, 7, 14, 0, 0, 28976, 28977, 7, 6, 0, 0, 28977, 28978, 5, 95, + 0, 0, 28978, 28979, 7, 6, 0, 0, 28979, 28980, 7, 7, 0, 0, 28980, 28981, + 7, 9, 0, 0, 28981, 4278, 1, 0, 0, 0, 28982, 28983, 7, 13, 0, 0, 28983, + 28984, 7, 0, 0, 0, 28984, 28985, 7, 11, 0, 0, 28985, 28986, 7, 10, 0, 0, + 28986, 28987, 7, 6, 0, 0, 28987, 28988, 7, 5, 0, 0, 28988, 4280, 1, 0, + 0, 0, 28989, 28990, 7, 13, 0, 0, 28990, 28991, 7, 0, 0, 0, 28991, 28992, + 7, 11, 0, 0, 28992, 28993, 7, 10, 0, 0, 28993, 28994, 7, 6, 0, 0, 28994, + 4282, 1, 0, 0, 0, 28995, 28996, 7, 13, 0, 0, 28996, 28997, 7, 0, 0, 0, + 28997, 28998, 7, 3, 0, 0, 28998, 28999, 7, 8, 0, 0, 28999, 29000, 7, 19, + 0, 0, 29000, 29001, 7, 0, 0, 0, 29001, 29002, 7, 3, 0, 0, 29002, 29003, + 5, 50, 0, 0, 29003, 4284, 1, 0, 0, 0, 29004, 29005, 7, 13, 0, 0, 29005, + 29006, 7, 0, 0, 0, 29006, 29007, 7, 3, 0, 0, 29007, 29008, 7, 8, 0, 0, + 29008, 29009, 7, 19, 0, 0, 29009, 29010, 7, 0, 0, 0, 29010, 29011, 7, 3, + 0, 0, 29011, 4286, 1, 0, 0, 0, 29012, 29013, 7, 13, 0, 0, 29013, 29014, + 7, 0, 0, 0, 29014, 29015, 7, 3, 0, 0, 29015, 29016, 7, 12, 0, 0, 29016, + 29017, 7, 0, 0, 0, 29017, 29018, 7, 1, 0, 0, 29018, 29019, 7, 11, 0, 0, + 29019, 29020, 7, 6, 0, 0, 29020, 4288, 1, 0, 0, 0, 29021, 29022, 7, 13, + 0, 0, 29022, 29023, 7, 0, 0, 0, 29023, 29024, 7, 3, 0, 0, 29024, 29025, + 5, 95, 0, 0, 29025, 29026, 7, 15, 0, 0, 29026, 29027, 7, 2, 0, 0, 29027, + 29028, 7, 15, 0, 0, 29028, 4290, 1, 0, 0, 0, 29029, 29030, 7, 13, 0, 0, + 29030, 29031, 7, 0, 0, 0, 29031, 29032, 7, 3, 0, 0, 29032, 29033, 7, 3, + 0, 0, 29033, 29034, 7, 0, 0, 0, 29034, 29035, 7, 18, 0, 0, 29035, 29036, + 7, 5, 0, 0, 29036, 4292, 1, 0, 0, 0, 29037, 29038, 7, 13, 0, 0, 29038, + 29039, 7, 0, 0, 0, 29039, 29040, 7, 3, 0, 0, 29040, 29041, 7, 3, 0, 0, + 29041, 29042, 7, 0, 0, 0, 29042, 29043, 7, 18, 0, 0, 29043, 4294, 1, 0, + 0, 0, 29044, 29045, 7, 13, 0, 0, 29045, 29046, 7, 0, 0, 0, 29046, 29047, + 7, 3, 0, 0, 29047, 29048, 5, 95, 0, 0, 29048, 29049, 7, 5, 0, 0, 29049, + 29050, 7, 0, 0, 0, 29050, 29051, 7, 14, 0, 0, 29051, 29052, 7, 15, 0, 0, + 29052, 4296, 1, 0, 0, 0, 29053, 29054, 7, 13, 0, 0, 29054, 29055, 7, 0, + 0, 0, 29055, 29056, 7, 3, 0, 0, 29056, 29057, 7, 18, 0, 0, 29057, 29058, + 7, 12, 0, 0, 29058, 29059, 7, 7, 0, 0, 29059, 29060, 7, 17, 0, 0, 29060, + 4298, 1, 0, 0, 0, 29061, 29062, 7, 13, 0, 0, 29062, 29063, 7, 6, 0, 0, + 29063, 29064, 7, 8, 0, 0, 29064, 29065, 7, 4, 0, 0, 29065, 29066, 7, 2, + 0, 0, 29066, 29067, 7, 3, 0, 0, 29067, 29068, 5, 95, 0, 0, 29068, 29069, + 7, 3, 0, 0, 29069, 29070, 7, 6, 0, 0, 29070, 29071, 7, 0, 0, 0, 29071, + 29072, 7, 9, 0, 0, 29072, 29073, 5, 95, 0, 0, 29073, 29074, 7, 4, 0, 0, + 29074, 29075, 7, 3, 0, 0, 29075, 29076, 7, 0, 0, 0, 29076, 29077, 7, 8, + 0, 0, 29077, 29078, 7, 6, 0, 0, 29078, 4300, 1, 0, 0, 0, 29079, 29080, + 7, 13, 0, 0, 29080, 29081, 7, 6, 0, 0, 29081, 29082, 7, 8, 0, 0, 29082, + 29083, 7, 4, 0, 0, 29083, 29084, 7, 2, 0, 0, 29084, 29085, 7, 3, 0, 0, + 29085, 29086, 5, 95, 0, 0, 29086, 29087, 7, 3, 0, 0, 29087, 29088, 7, 6, + 0, 0, 29088, 29089, 7, 0, 0, 0, 29089, 29090, 7, 9, 0, 0, 29090, 4302, + 1, 0, 0, 0, 29091, 29092, 7, 13, 0, 0, 29092, 29093, 7, 6, 0, 0, 29093, + 29094, 7, 8, 0, 0, 29094, 29095, 7, 4, 0, 0, 29095, 29096, 7, 2, 0, 0, + 29096, 29097, 7, 3, 0, 0, 29097, 29098, 5, 95, 0, 0, 29098, 29099, 7, 4, + 0, 0, 29099, 29100, 7, 3, 0, 0, 29100, 29101, 7, 0, 0, 0, 29101, 29102, + 7, 7, 0, 0, 29102, 29103, 7, 5, 0, 0, 29103, 29104, 7, 16, 0, 0, 29104, + 29105, 7, 2, 0, 0, 29105, 29106, 7, 3, 0, 0, 29106, 29107, 7, 14, 0, 0, + 29107, 29108, 5, 95, 0, 0, 29108, 29109, 7, 9, 0, 0, 29109, 29110, 7, 12, + 0, 0, 29110, 29111, 7, 14, 0, 0, 29111, 29112, 7, 5, 0, 0, 29112, 4304, + 1, 0, 0, 0, 29113, 29114, 7, 13, 0, 0, 29114, 29115, 7, 6, 0, 0, 29115, + 29116, 7, 8, 0, 0, 29116, 29117, 7, 4, 0, 0, 29117, 29118, 7, 2, 0, 0, + 29118, 29119, 7, 3, 0, 0, 29119, 29120, 5, 95, 0, 0, 29120, 29121, 7, 4, + 0, 0, 29121, 29122, 7, 3, 0, 0, 29122, 29123, 7, 0, 0, 0, 29123, 29124, + 7, 7, 0, 0, 29124, 29125, 7, 5, 0, 0, 29125, 29126, 7, 16, 0, 0, 29126, + 29127, 7, 2, 0, 0, 29127, 29128, 7, 3, 0, 0, 29128, 29129, 7, 14, 0, 0, + 29129, 29130, 5, 95, 0, 0, 29130, 29131, 7, 16, 0, 0, 29131, 29132, 7, + 0, 0, 0, 29132, 29133, 7, 8, 0, 0, 29133, 29134, 7, 4, 0, 0, 29134, 4306, + 1, 0, 0, 0, 29135, 29136, 7, 13, 0, 0, 29136, 29137, 7, 6, 0, 0, 29137, + 29138, 7, 8, 0, 0, 29138, 29139, 7, 4, 0, 0, 29139, 29140, 7, 2, 0, 0, + 29140, 29141, 7, 3, 0, 0, 29141, 29142, 5, 95, 0, 0, 29142, 29143, 7, 4, + 0, 0, 29143, 29144, 7, 3, 0, 0, 29144, 29145, 7, 0, 0, 0, 29145, 29146, + 7, 7, 0, 0, 29146, 29147, 7, 5, 0, 0, 29147, 29148, 7, 16, 0, 0, 29148, + 29149, 7, 2, 0, 0, 29149, 29150, 7, 3, 0, 0, 29150, 29151, 7, 14, 0, 0, + 29151, 4308, 1, 0, 0, 0, 29152, 29153, 7, 13, 0, 0, 29153, 29154, 7, 6, + 0, 0, 29154, 29155, 7, 3, 0, 0, 29155, 29156, 7, 12, 0, 0, 29156, 29157, + 7, 16, 0, 0, 29157, 29158, 7, 12, 0, 0, 29158, 29159, 7, 6, 0, 0, 29159, + 29160, 7, 3, 0, 0, 29160, 4310, 1, 0, 0, 0, 29161, 29162, 7, 13, 0, 0, + 29162, 29163, 7, 6, 0, 0, 29163, 29164, 7, 3, 0, 0, 29164, 29165, 7, 12, + 0, 0, 29165, 29166, 7, 16, 0, 0, 29166, 29167, 7, 18, 0, 0, 29167, 4312, + 1, 0, 0, 0, 29168, 29169, 7, 13, 0, 0, 29169, 29170, 7, 6, 0, 0, 29170, + 29171, 7, 3, 0, 0, 29171, 29172, 7, 5, 0, 0, 29172, 29173, 7, 12, 0, 0, + 29173, 29174, 7, 2, 0, 0, 29174, 29175, 7, 7, 0, 0, 29175, 29176, 7, 12, + 0, 0, 29176, 29177, 7, 7, 0, 0, 29177, 29178, 7, 17, 0, 0, 29178, 4314, + 1, 0, 0, 0, 29179, 29180, 7, 13, 0, 0, 29180, 29181, 7, 6, 0, 0, 29181, + 29182, 7, 3, 0, 0, 29182, 29183, 7, 5, 0, 0, 29183, 29184, 7, 12, 0, 0, + 29184, 29185, 7, 2, 0, 0, 29185, 29186, 7, 7, 0, 0, 29186, 29187, 7, 5, + 0, 0, 29187, 29188, 5, 95, 0, 0, 29188, 29189, 7, 6, 0, 0, 29189, 29190, + 7, 7, 0, 0, 29190, 29191, 7, 9, 0, 0, 29191, 29192, 7, 5, 0, 0, 29192, + 29193, 7, 8, 0, 0, 29193, 29194, 7, 7, 0, 0, 29194, 4316, 1, 0, 0, 0, 29195, + 29196, 7, 13, 0, 0, 29196, 29197, 7, 6, 0, 0, 29197, 29198, 7, 3, 0, 0, + 29198, 29199, 7, 5, 0, 0, 29199, 29200, 7, 12, 0, 0, 29200, 29201, 7, 2, + 0, 0, 29201, 29202, 7, 7, 0, 0, 29202, 29203, 7, 5, 0, 0, 29203, 29204, + 5, 95, 0, 0, 29204, 29205, 7, 6, 0, 0, 29205, 29206, 7, 7, 0, 0, 29206, + 29207, 7, 9, 0, 0, 29207, 29208, 7, 4, 0, 0, 29208, 29209, 7, 12, 0, 0, + 29209, 29210, 7, 14, 0, 0, 29210, 29211, 7, 6, 0, 0, 29211, 4318, 1, 0, + 0, 0, 29212, 29213, 7, 13, 0, 0, 29213, 29214, 7, 6, 0, 0, 29214, 29215, + 7, 3, 0, 0, 29215, 29216, 7, 5, 0, 0, 29216, 29217, 7, 12, 0, 0, 29217, + 29218, 7, 2, 0, 0, 29218, 29219, 7, 7, 0, 0, 29219, 29220, 7, 5, 0, 0, + 29220, 29221, 5, 95, 0, 0, 29221, 29222, 7, 2, 0, 0, 29222, 29223, 7, 15, + 0, 0, 29223, 29224, 7, 6, 0, 0, 29224, 29225, 7, 3, 0, 0, 29225, 29226, + 7, 0, 0, 0, 29226, 29227, 7, 4, 0, 0, 29227, 29228, 7, 12, 0, 0, 29228, + 29229, 7, 2, 0, 0, 29229, 29230, 7, 7, 0, 0, 29230, 4320, 1, 0, 0, 0, 29231, + 29232, 7, 13, 0, 0, 29232, 29233, 7, 6, 0, 0, 29233, 29234, 7, 3, 0, 0, + 29234, 29235, 7, 5, 0, 0, 29235, 29236, 7, 12, 0, 0, 29236, 29237, 7, 2, + 0, 0, 29237, 29238, 7, 7, 0, 0, 29238, 29239, 7, 5, 0, 0, 29239, 29240, + 5, 95, 0, 0, 29240, 29241, 7, 5, 0, 0, 29241, 29242, 7, 4, 0, 0, 29242, + 29243, 7, 0, 0, 0, 29243, 29244, 7, 3, 0, 0, 29244, 29245, 7, 4, 0, 0, + 29245, 29246, 7, 5, 0, 0, 29246, 29247, 7, 8, 0, 0, 29247, 29248, 7, 7, + 0, 0, 29248, 4322, 1, 0, 0, 0, 29249, 29250, 7, 13, 0, 0, 29250, 29251, + 7, 6, 0, 0, 29251, 29252, 7, 3, 0, 0, 29252, 29253, 7, 5, 0, 0, 29253, + 29254, 7, 12, 0, 0, 29254, 29255, 7, 2, 0, 0, 29255, 29256, 7, 7, 0, 0, + 29256, 29257, 7, 5, 0, 0, 29257, 29258, 5, 95, 0, 0, 29258, 29259, 7, 5, + 0, 0, 29259, 29260, 7, 4, 0, 0, 29260, 29261, 7, 0, 0, 0, 29261, 29262, + 7, 3, 0, 0, 29262, 29263, 7, 4, 0, 0, 29263, 29264, 7, 4, 0, 0, 29264, + 29265, 7, 12, 0, 0, 29265, 29266, 7, 14, 0, 0, 29266, 29267, 7, 6, 0, 0, + 29267, 4324, 1, 0, 0, 0, 29268, 29269, 7, 13, 0, 0, 29269, 29270, 7, 6, + 0, 0, 29270, 29271, 7, 3, 0, 0, 29271, 29272, 7, 5, 0, 0, 29272, 29273, + 7, 12, 0, 0, 29273, 29274, 7, 2, 0, 0, 29274, 29275, 7, 7, 0, 0, 29275, + 29276, 7, 5, 0, 0, 29276, 4326, 1, 0, 0, 0, 29277, 29278, 7, 13, 0, 0, + 29278, 29279, 7, 6, 0, 0, 29279, 29280, 7, 3, 0, 0, 29280, 29281, 7, 5, + 0, 0, 29281, 29282, 7, 12, 0, 0, 29282, 29283, 7, 2, 0, 0, 29283, 29284, + 7, 7, 0, 0, 29284, 29285, 7, 5, 0, 0, 29285, 29286, 5, 95, 0, 0, 29286, + 29287, 7, 25, 0, 0, 29287, 29288, 7, 12, 0, 0, 29288, 29289, 7, 9, 0, 0, + 29289, 4328, 1, 0, 0, 0, 29290, 29291, 7, 13, 0, 0, 29291, 29292, 7, 6, + 0, 0, 29292, 29293, 7, 3, 0, 0, 29293, 29294, 7, 5, 0, 0, 29294, 29295, + 7, 12, 0, 0, 29295, 29296, 7, 2, 0, 0, 29296, 29297, 7, 7, 0, 0, 29297, + 4330, 1, 0, 0, 0, 29298, 29299, 7, 13, 0, 0, 29299, 29300, 7, 12, 0, 0, + 29300, 29301, 7, 6, 0, 0, 29301, 29302, 7, 22, 0, 0, 29302, 4332, 1, 0, + 0, 0, 29303, 29304, 7, 13, 0, 0, 29304, 29305, 7, 12, 0, 0, 29305, 29306, + 7, 2, 0, 0, 29306, 29307, 7, 11, 0, 0, 29307, 29308, 7, 0, 0, 0, 29308, + 29309, 7, 4, 0, 0, 29309, 29310, 7, 12, 0, 0, 29310, 29311, 7, 2, 0, 0, + 29311, 29312, 7, 7, 0, 0, 29312, 4334, 1, 0, 0, 0, 29313, 29314, 7, 13, + 0, 0, 29314, 29315, 7, 12, 0, 0, 29315, 29316, 7, 3, 0, 0, 29316, 29317, + 7, 4, 0, 0, 29317, 29318, 7, 10, 0, 0, 29318, 29319, 7, 0, 0, 0, 29319, + 29320, 7, 11, 0, 0, 29320, 4336, 1, 0, 0, 0, 29321, 29322, 7, 13, 0, 0, + 29322, 29323, 7, 12, 0, 0, 29323, 29324, 7, 5, 0, 0, 29324, 29325, 7, 12, + 0, 0, 29325, 29326, 7, 1, 0, 0, 29326, 29327, 7, 12, 0, 0, 29327, 29328, + 7, 11, 0, 0, 29328, 29329, 7, 12, 0, 0, 29329, 29330, 7, 4, 0, 0, 29330, + 29331, 7, 18, 0, 0, 29331, 4338, 1, 0, 0, 0, 29332, 29333, 7, 13, 0, 0, + 29333, 29334, 7, 12, 0, 0, 29334, 29335, 7, 5, 0, 0, 29335, 29336, 7, 12, + 0, 0, 29336, 29337, 7, 1, 0, 0, 29337, 29338, 7, 11, 0, 0, 29338, 29339, + 7, 6, 0, 0, 29339, 4340, 1, 0, 0, 0, 29340, 29341, 7, 13, 0, 0, 29341, + 29342, 7, 2, 0, 0, 29342, 29343, 7, 11, 0, 0, 29343, 29344, 7, 10, 0, 0, + 29344, 29345, 7, 14, 0, 0, 29345, 29346, 7, 6, 0, 0, 29346, 4342, 1, 0, + 0, 0, 29347, 29348, 7, 13, 0, 0, 29348, 29349, 7, 5, 0, 0, 29349, 29350, + 7, 12, 0, 0, 29350, 29351, 7, 23, 0, 0, 29351, 29352, 7, 6, 0, 0, 29352, + 4344, 1, 0, 0, 0, 29353, 29354, 7, 22, 0, 0, 29354, 29355, 7, 0, 0, 0, + 29355, 29356, 7, 12, 0, 0, 29356, 29357, 7, 4, 0, 0, 29357, 4346, 1, 0, + 0, 0, 29358, 29359, 7, 22, 0, 0, 29359, 29360, 7, 0, 0, 0, 29360, 29361, + 7, 11, 0, 0, 29361, 29362, 7, 11, 0, 0, 29362, 29363, 7, 6, 0, 0, 29363, + 29364, 7, 4, 0, 0, 29364, 4348, 1, 0, 0, 0, 29365, 29366, 7, 22, 0, 0, + 29366, 29367, 7, 0, 0, 0, 29367, 29368, 7, 3, 0, 0, 29368, 29369, 7, 7, + 0, 0, 29369, 29370, 7, 12, 0, 0, 29370, 29371, 7, 7, 0, 0, 29371, 29372, + 7, 17, 0, 0, 29372, 4350, 1, 0, 0, 0, 29373, 29374, 7, 22, 0, 0, 29374, + 29375, 7, 6, 0, 0, 29375, 29376, 7, 6, 0, 0, 29376, 29377, 7, 21, 0, 0, + 29377, 29378, 7, 5, 0, 0, 29378, 4352, 1, 0, 0, 0, 29379, 29380, 7, 22, + 0, 0, 29380, 29381, 7, 6, 0, 0, 29381, 29382, 7, 6, 0, 0, 29382, 29383, + 7, 21, 0, 0, 29383, 4354, 1, 0, 0, 0, 29384, 29385, 7, 22, 0, 0, 29385, + 29386, 7, 6, 0, 0, 29386, 29387, 7, 11, 0, 0, 29387, 29388, 7, 11, 0, 0, + 29388, 29389, 7, 16, 0, 0, 29389, 29390, 7, 2, 0, 0, 29390, 29391, 7, 3, + 0, 0, 29391, 29392, 7, 14, 0, 0, 29392, 29393, 7, 6, 0, 0, 29393, 29394, + 7, 9, 0, 0, 29394, 4356, 1, 0, 0, 0, 29395, 29396, 7, 22, 0, 0, 29396, + 29397, 7, 19, 0, 0, 29397, 29398, 7, 6, 0, 0, 29398, 29399, 7, 7, 0, 0, + 29399, 29400, 7, 6, 0, 0, 29400, 29401, 7, 13, 0, 0, 29401, 29402, 7, 6, + 0, 0, 29402, 29403, 7, 3, 0, 0, 29403, 4358, 1, 0, 0, 0, 29404, 29405, + 7, 22, 0, 0, 29405, 29406, 7, 19, 0, 0, 29406, 29407, 7, 6, 0, 0, 29407, + 29408, 7, 7, 0, 0, 29408, 4360, 1, 0, 0, 0, 29409, 29410, 7, 22, 0, 0, + 29410, 29411, 7, 19, 0, 0, 29411, 29412, 7, 6, 0, 0, 29412, 29413, 7, 3, + 0, 0, 29413, 29414, 7, 6, 0, 0, 29414, 4362, 1, 0, 0, 0, 29415, 29416, + 7, 22, 0, 0, 29416, 29417, 7, 19, 0, 0, 29417, 29418, 7, 12, 0, 0, 29418, + 29419, 7, 11, 0, 0, 29419, 29420, 7, 6, 0, 0, 29420, 4364, 1, 0, 0, 0, + 29421, 29422, 7, 22, 0, 0, 29422, 29423, 7, 19, 0, 0, 29423, 29424, 7, + 12, 0, 0, 29424, 29425, 7, 4, 0, 0, 29425, 29426, 7, 6, 0, 0, 29426, 29427, + 7, 5, 0, 0, 29427, 29428, 7, 15, 0, 0, 29428, 29429, 7, 0, 0, 0, 29429, + 29430, 7, 8, 0, 0, 29430, 29431, 7, 6, 0, 0, 29431, 4366, 1, 0, 0, 0, 29432, + 29433, 7, 22, 0, 0, 29433, 29434, 7, 12, 0, 0, 29434, 29435, 7, 9, 0, 0, + 29435, 29436, 7, 4, 0, 0, 29436, 29437, 7, 19, 0, 0, 29437, 29438, 5, 95, + 0, 0, 29438, 29439, 7, 1, 0, 0, 29439, 29440, 7, 10, 0, 0, 29440, 29441, + 7, 8, 0, 0, 29441, 29442, 7, 21, 0, 0, 29442, 29443, 7, 6, 0, 0, 29443, + 29444, 7, 4, 0, 0, 29444, 4368, 1, 0, 0, 0, 29445, 29446, 7, 22, 0, 0, + 29446, 29447, 7, 12, 0, 0, 29447, 29448, 7, 4, 0, 0, 29448, 29449, 7, 19, + 0, 0, 29449, 29450, 7, 12, 0, 0, 29450, 29451, 7, 7, 0, 0, 29451, 4370, + 1, 0, 0, 0, 29452, 29453, 7, 22, 0, 0, 29453, 29454, 7, 12, 0, 0, 29454, + 29455, 7, 4, 0, 0, 29455, 29456, 7, 19, 0, 0, 29456, 29457, 7, 2, 0, 0, + 29457, 29458, 7, 10, 0, 0, 29458, 29459, 7, 4, 0, 0, 29459, 4372, 1, 0, + 0, 0, 29460, 29461, 7, 22, 0, 0, 29461, 29462, 7, 12, 0, 0, 29462, 29463, + 7, 4, 0, 0, 29463, 29464, 7, 19, 0, 0, 29464, 29465, 5, 95, 0, 0, 29465, + 29466, 7, 15, 0, 0, 29466, 29467, 7, 11, 0, 0, 29467, 29468, 7, 5, 0, 0, + 29468, 29469, 7, 24, 0, 0, 29469, 29470, 7, 11, 0, 0, 29470, 4374, 1, 0, + 0, 0, 29471, 29472, 7, 22, 0, 0, 29472, 29473, 7, 12, 0, 0, 29473, 29474, + 7, 4, 0, 0, 29474, 29475, 7, 19, 0, 0, 29475, 4376, 1, 0, 0, 0, 29476, + 29477, 7, 22, 0, 0, 29477, 29478, 7, 2, 0, 0, 29478, 29479, 7, 3, 0, 0, + 29479, 29480, 7, 21, 0, 0, 29480, 4378, 1, 0, 0, 0, 29481, 29482, 7, 22, + 0, 0, 29482, 29483, 7, 3, 0, 0, 29483, 29484, 7, 0, 0, 0, 29484, 29485, + 7, 15, 0, 0, 29485, 29486, 7, 15, 0, 0, 29486, 29487, 7, 6, 0, 0, 29487, + 29488, 7, 9, 0, 0, 29488, 4380, 1, 0, 0, 0, 29489, 29490, 7, 22, 0, 0, + 29490, 29491, 7, 3, 0, 0, 29491, 29492, 7, 0, 0, 0, 29492, 29493, 7, 15, + 0, 0, 29493, 29494, 7, 15, 0, 0, 29494, 29495, 7, 6, 0, 0, 29495, 29496, + 7, 3, 0, 0, 29496, 4382, 1, 0, 0, 0, 29497, 29498, 7, 22, 0, 0, 29498, + 29499, 7, 3, 0, 0, 29499, 29500, 7, 12, 0, 0, 29500, 29501, 7, 4, 0, 0, + 29501, 29502, 7, 6, 0, 0, 29502, 4384, 1, 0, 0, 0, 29503, 29504, 7, 25, + 0, 0, 29504, 29505, 7, 9, 0, 0, 29505, 29506, 7, 1, 0, 0, 29506, 29507, + 5, 95, 0, 0, 29507, 29508, 7, 16, 0, 0, 29508, 29509, 7, 0, 0, 0, 29509, + 29510, 7, 5, 0, 0, 29510, 29511, 7, 4, 0, 0, 29511, 29512, 7, 15, 0, 0, + 29512, 29513, 7, 0, 0, 0, 29513, 29514, 7, 4, 0, 0, 29514, 29515, 7, 19, + 0, 0, 29515, 29516, 5, 95, 0, 0, 29516, 29517, 7, 12, 0, 0, 29517, 29518, + 7, 7, 0, 0, 29518, 29519, 7, 5, 0, 0, 29519, 29520, 7, 6, 0, 0, 29520, + 29521, 7, 3, 0, 0, 29521, 29522, 7, 4, 0, 0, 29522, 4386, 1, 0, 0, 0, 29523, + 29524, 7, 25, 0, 0, 29524, 29525, 7, 9, 0, 0, 29525, 29526, 7, 1, 0, 0, + 29526, 4388, 1, 0, 0, 0, 29527, 29528, 7, 25, 0, 0, 29528, 29529, 5, 95, + 0, 0, 29529, 29530, 7, 9, 0, 0, 29530, 29531, 7, 18, 0, 0, 29531, 29532, + 7, 7, 0, 0, 29532, 29533, 5, 95, 0, 0, 29533, 29534, 7, 15, 0, 0, 29534, + 29535, 7, 3, 0, 0, 29535, 29536, 7, 10, 0, 0, 29536, 29537, 7, 7, 0, 0, + 29537, 29538, 7, 6, 0, 0, 29538, 4390, 1, 0, 0, 0, 29539, 29540, 7, 25, + 0, 0, 29540, 29541, 7, 12, 0, 0, 29541, 29542, 7, 9, 0, 0, 29542, 4392, + 1, 0, 0, 0, 29543, 29544, 7, 25, 0, 0, 29544, 29545, 7, 14, 0, 0, 29545, + 29546, 7, 11, 0, 0, 29546, 29547, 5, 50, 0, 0, 29547, 29548, 7, 2, 0, 0, + 29548, 29549, 7, 1, 0, 0, 29549, 29550, 7, 20, 0, 0, 29550, 29551, 7, 6, + 0, 0, 29551, 29552, 7, 8, 0, 0, 29552, 29553, 7, 4, 0, 0, 29553, 4394, + 1, 0, 0, 0, 29554, 29555, 7, 25, 0, 0, 29555, 29556, 7, 14, 0, 0, 29556, + 29557, 7, 11, 0, 0, 29557, 29558, 7, 0, 0, 0, 29558, 29559, 7, 17, 0, 0, + 29559, 29560, 7, 17, 0, 0, 29560, 4396, 1, 0, 0, 0, 29561, 29562, 7, 25, + 0, 0, 29562, 29563, 7, 14, 0, 0, 29563, 29564, 7, 11, 0, 0, 29564, 29565, + 7, 0, 0, 0, 29565, 29566, 7, 4, 0, 0, 29566, 29567, 7, 4, 0, 0, 29567, + 29568, 7, 3, 0, 0, 29568, 29569, 7, 12, 0, 0, 29569, 29570, 7, 1, 0, 0, + 29570, 29571, 7, 10, 0, 0, 29571, 29572, 7, 4, 0, 0, 29572, 29573, 7, 6, + 0, 0, 29573, 29574, 7, 5, 0, 0, 29574, 4398, 1, 0, 0, 0, 29575, 29576, + 7, 25, 0, 0, 29576, 29577, 7, 14, 0, 0, 29577, 29578, 7, 11, 0, 0, 29578, + 29579, 7, 8, 0, 0, 29579, 29580, 7, 0, 0, 0, 29580, 29581, 7, 5, 0, 0, + 29581, 29582, 7, 4, 0, 0, 29582, 4400, 1, 0, 0, 0, 29583, 29584, 7, 25, + 0, 0, 29584, 29585, 7, 14, 0, 0, 29585, 29586, 7, 11, 0, 0, 29586, 29587, + 7, 8, 0, 0, 29587, 29588, 7, 9, 0, 0, 29588, 29589, 7, 0, 0, 0, 29589, + 29590, 7, 4, 0, 0, 29590, 29591, 7, 0, 0, 0, 29591, 4402, 1, 0, 0, 0, 29592, + 29593, 7, 25, 0, 0, 29593, 29594, 7, 14, 0, 0, 29594, 29595, 7, 11, 0, + 0, 29595, 29596, 7, 8, 0, 0, 29596, 29597, 7, 2, 0, 0, 29597, 29598, 7, + 11, 0, 0, 29598, 29599, 7, 0, 0, 0, 29599, 29600, 7, 4, 0, 0, 29600, 29601, + 7, 4, 0, 0, 29601, 29602, 7, 13, 0, 0, 29602, 29603, 7, 0, 0, 0, 29603, + 29604, 7, 11, 0, 0, 29604, 4404, 1, 0, 0, 0, 29605, 29606, 7, 25, 0, 0, + 29606, 29607, 7, 14, 0, 0, 29607, 29608, 7, 11, 0, 0, 29608, 29609, 7, + 8, 0, 0, 29609, 29610, 7, 2, 0, 0, 29610, 29611, 7, 14, 0, 0, 29611, 29612, + 7, 14, 0, 0, 29612, 29613, 7, 6, 0, 0, 29613, 29614, 7, 7, 0, 0, 29614, + 29615, 7, 4, 0, 0, 29615, 4406, 1, 0, 0, 0, 29616, 29617, 7, 25, 0, 0, + 29617, 29618, 7, 14, 0, 0, 29618, 29619, 7, 11, 0, 0, 29619, 29620, 7, + 8, 0, 0, 29620, 29621, 7, 2, 0, 0, 29621, 29622, 7, 7, 0, 0, 29622, 29623, + 7, 8, 0, 0, 29623, 29624, 7, 0, 0, 0, 29624, 29625, 7, 4, 0, 0, 29625, + 4408, 1, 0, 0, 0, 29626, 29627, 7, 25, 0, 0, 29627, 29628, 7, 14, 0, 0, + 29628, 29629, 7, 11, 0, 0, 29629, 29630, 7, 9, 0, 0, 29630, 29631, 7, 12, + 0, 0, 29631, 29632, 7, 16, 0, 0, 29632, 29633, 7, 16, 0, 0, 29633, 4410, + 1, 0, 0, 0, 29634, 29635, 7, 25, 0, 0, 29635, 29636, 7, 14, 0, 0, 29636, + 29637, 7, 11, 0, 0, 29637, 29638, 5, 95, 0, 0, 29638, 29639, 7, 9, 0, 0, + 29639, 29640, 7, 14, 0, 0, 29640, 29641, 7, 11, 0, 0, 29641, 29642, 5, + 95, 0, 0, 29642, 29643, 7, 3, 0, 0, 29643, 29644, 7, 22, 0, 0, 29644, 29645, + 7, 4, 0, 0, 29645, 29646, 5, 95, 0, 0, 29646, 29647, 7, 5, 0, 0, 29647, + 29648, 7, 4, 0, 0, 29648, 29649, 7, 14, 0, 0, 29649, 29650, 7, 4, 0, 0, + 29650, 4412, 1, 0, 0, 0, 29651, 29652, 7, 25, 0, 0, 29652, 29653, 7, 14, + 0, 0, 29653, 29654, 7, 11, 0, 0, 29654, 29655, 7, 6, 0, 0, 29655, 29656, + 7, 11, 0, 0, 29656, 29657, 7, 6, 0, 0, 29657, 29658, 7, 14, 0, 0, 29658, + 29659, 7, 6, 0, 0, 29659, 29660, 7, 7, 0, 0, 29660, 29661, 7, 4, 0, 0, + 29661, 4414, 1, 0, 0, 0, 29662, 29663, 7, 25, 0, 0, 29663, 29664, 7, 14, + 0, 0, 29664, 29665, 7, 11, 0, 0, 29665, 29666, 7, 6, 0, 0, 29666, 29667, + 7, 25, 0, 0, 29667, 29668, 7, 12, 0, 0, 29668, 29669, 7, 5, 0, 0, 29669, + 29670, 7, 4, 0, 0, 29670, 29671, 7, 5, 0, 0, 29671, 29672, 5, 50, 0, 0, + 29672, 4416, 1, 0, 0, 0, 29673, 29674, 7, 25, 0, 0, 29674, 29675, 7, 14, + 0, 0, 29675, 29676, 7, 11, 0, 0, 29676, 29677, 7, 6, 0, 0, 29677, 29678, + 7, 25, 0, 0, 29678, 29679, 7, 12, 0, 0, 29679, 29680, 7, 5, 0, 0, 29680, + 29681, 7, 4, 0, 0, 29681, 29682, 7, 5, 0, 0, 29682, 4418, 1, 0, 0, 0, 29683, + 29684, 7, 25, 0, 0, 29684, 29685, 7, 14, 0, 0, 29685, 29686, 7, 11, 0, + 0, 29686, 29687, 7, 16, 0, 0, 29687, 29688, 7, 2, 0, 0, 29688, 29689, 7, + 3, 0, 0, 29689, 29690, 7, 6, 0, 0, 29690, 29691, 7, 5, 0, 0, 29691, 29692, + 7, 4, 0, 0, 29692, 4420, 1, 0, 0, 0, 29693, 29694, 7, 25, 0, 0, 29694, + 29695, 7, 14, 0, 0, 29695, 29696, 7, 11, 0, 0, 29696, 29697, 7, 12, 0, + 0, 29697, 29698, 7, 7, 0, 0, 29698, 29699, 7, 9, 0, 0, 29699, 29700, 7, + 6, 0, 0, 29700, 29701, 7, 25, 0, 0, 29701, 4422, 1, 0, 0, 0, 29702, 29703, + 7, 25, 0, 0, 29703, 29704, 7, 14, 0, 0, 29704, 29705, 7, 11, 0, 0, 29705, + 29706, 7, 12, 0, 0, 29706, 29707, 7, 7, 0, 0, 29707, 29708, 7, 9, 0, 0, + 29708, 29709, 7, 6, 0, 0, 29709, 29710, 7, 25, 0, 0, 29710, 29711, 5, 95, + 0, 0, 29711, 29712, 7, 3, 0, 0, 29712, 29713, 7, 6, 0, 0, 29713, 29714, + 7, 22, 0, 0, 29714, 29715, 7, 3, 0, 0, 29715, 29716, 7, 12, 0, 0, 29716, + 29717, 7, 4, 0, 0, 29717, 29718, 7, 6, 0, 0, 29718, 29719, 5, 95, 0, 0, + 29719, 29720, 7, 12, 0, 0, 29720, 29721, 7, 7, 0, 0, 29721, 29722, 5, 95, + 0, 0, 29722, 29723, 7, 5, 0, 0, 29723, 29724, 7, 6, 0, 0, 29724, 29725, + 7, 11, 0, 0, 29725, 29726, 7, 6, 0, 0, 29726, 29727, 7, 8, 0, 0, 29727, + 29728, 7, 4, 0, 0, 29728, 4424, 1, 0, 0, 0, 29729, 29730, 7, 25, 0, 0, + 29730, 29731, 7, 14, 0, 0, 29731, 29732, 7, 11, 0, 0, 29732, 29733, 7, + 12, 0, 0, 29733, 29734, 7, 7, 0, 0, 29734, 29735, 7, 9, 0, 0, 29735, 29736, + 7, 6, 0, 0, 29736, 29737, 7, 25, 0, 0, 29737, 29738, 5, 95, 0, 0, 29738, + 29739, 7, 3, 0, 0, 29739, 29740, 7, 6, 0, 0, 29740, 29741, 7, 22, 0, 0, + 29741, 29742, 7, 3, 0, 0, 29742, 29743, 7, 12, 0, 0, 29743, 29744, 7, 4, + 0, 0, 29744, 29745, 7, 6, 0, 0, 29745, 4426, 1, 0, 0, 0, 29746, 29747, + 7, 25, 0, 0, 29747, 29748, 7, 14, 0, 0, 29748, 29749, 7, 11, 0, 0, 29749, + 29750, 7, 12, 0, 0, 29750, 29751, 7, 7, 0, 0, 29751, 29752, 7, 9, 0, 0, + 29752, 29753, 7, 6, 0, 0, 29753, 29754, 7, 25, 0, 0, 29754, 29755, 5, 95, + 0, 0, 29755, 29756, 7, 5, 0, 0, 29756, 29757, 7, 6, 0, 0, 29757, 29758, + 7, 11, 0, 0, 29758, 29759, 5, 95, 0, 0, 29759, 29760, 7, 12, 0, 0, 29760, + 29761, 7, 9, 0, 0, 29761, 29762, 7, 25, 0, 0, 29762, 29763, 5, 95, 0, 0, + 29763, 29764, 7, 4, 0, 0, 29764, 29765, 7, 1, 0, 0, 29765, 29766, 7, 11, + 0, 0, 29766, 4428, 1, 0, 0, 0, 29767, 29768, 7, 25, 0, 0, 29768, 29769, + 7, 14, 0, 0, 29769, 29770, 7, 11, 0, 0, 29770, 29771, 7, 12, 0, 0, 29771, + 29772, 7, 5, 0, 0, 29772, 29773, 7, 7, 0, 0, 29773, 29774, 7, 2, 0, 0, + 29774, 29775, 7, 9, 0, 0, 29775, 29776, 7, 6, 0, 0, 29776, 4430, 1, 0, + 0, 0, 29777, 29778, 7, 25, 0, 0, 29778, 29779, 7, 14, 0, 0, 29779, 29780, + 7, 11, 0, 0, 29780, 29781, 7, 12, 0, 0, 29781, 29782, 7, 5, 0, 0, 29782, + 29783, 7, 13, 0, 0, 29783, 29784, 7, 0, 0, 0, 29784, 29785, 7, 11, 0, 0, + 29785, 29786, 7, 12, 0, 0, 29786, 29787, 7, 9, 0, 0, 29787, 4432, 1, 0, + 0, 0, 29788, 29789, 7, 25, 0, 0, 29789, 29790, 7, 14, 0, 0, 29790, 29791, + 7, 11, 0, 0, 29791, 29792, 7, 7, 0, 0, 29792, 29793, 7, 0, 0, 0, 29793, + 29794, 7, 14, 0, 0, 29794, 29795, 7, 6, 0, 0, 29795, 29796, 7, 5, 0, 0, + 29796, 29797, 7, 15, 0, 0, 29797, 29798, 7, 0, 0, 0, 29798, 29799, 7, 8, + 0, 0, 29799, 29800, 7, 6, 0, 0, 29800, 29801, 7, 5, 0, 0, 29801, 4434, + 1, 0, 0, 0, 29802, 29803, 7, 25, 0, 0, 29803, 29804, 7, 14, 0, 0, 29804, + 29805, 7, 11, 0, 0, 29805, 29806, 7, 15, 0, 0, 29806, 29807, 7, 0, 0, 0, + 29807, 29808, 7, 3, 0, 0, 29808, 29809, 7, 5, 0, 0, 29809, 29810, 7, 6, + 0, 0, 29810, 4436, 1, 0, 0, 0, 29811, 29812, 7, 25, 0, 0, 29812, 29813, + 7, 14, 0, 0, 29813, 29814, 7, 11, 0, 0, 29814, 29815, 7, 15, 0, 0, 29815, + 29816, 7, 0, 0, 0, 29816, 29817, 7, 4, 0, 0, 29817, 29818, 7, 8, 0, 0, + 29818, 29819, 7, 19, 0, 0, 29819, 4438, 1, 0, 0, 0, 29820, 29821, 7, 25, + 0, 0, 29821, 29822, 7, 14, 0, 0, 29822, 29823, 7, 11, 0, 0, 29823, 29824, + 7, 15, 0, 0, 29824, 29825, 7, 12, 0, 0, 29825, 4440, 1, 0, 0, 0, 29826, + 29827, 7, 25, 0, 0, 29827, 29828, 7, 14, 0, 0, 29828, 29829, 7, 11, 0, + 0, 29829, 29830, 7, 24, 0, 0, 29830, 29831, 7, 10, 0, 0, 29831, 29832, + 7, 6, 0, 0, 29832, 29833, 7, 3, 0, 0, 29833, 29834, 7, 18, 0, 0, 29834, + 29835, 7, 13, 0, 0, 29835, 29836, 7, 0, 0, 0, 29836, 29837, 7, 11, 0, 0, + 29837, 4442, 1, 0, 0, 0, 29838, 29839, 7, 25, 0, 0, 29839, 29840, 7, 14, + 0, 0, 29840, 29841, 7, 11, 0, 0, 29841, 29842, 7, 24, 0, 0, 29842, 29843, + 7, 10, 0, 0, 29843, 29844, 7, 6, 0, 0, 29844, 29845, 7, 3, 0, 0, 29845, + 29846, 7, 18, 0, 0, 29846, 4444, 1, 0, 0, 0, 29847, 29848, 7, 25, 0, 0, + 29848, 29849, 7, 14, 0, 0, 29849, 29850, 7, 11, 0, 0, 29850, 29851, 7, + 3, 0, 0, 29851, 29852, 7, 2, 0, 0, 29852, 29853, 7, 2, 0, 0, 29853, 29854, + 7, 4, 0, 0, 29854, 4446, 1, 0, 0, 0, 29855, 29856, 7, 25, 0, 0, 29856, + 29857, 7, 14, 0, 0, 29857, 29858, 7, 11, 0, 0, 29858, 29859, 7, 5, 0, 0, + 29859, 29860, 7, 8, 0, 0, 29860, 29861, 7, 19, 0, 0, 29861, 29862, 7, 6, + 0, 0, 29862, 29863, 7, 14, 0, 0, 29863, 29864, 7, 0, 0, 0, 29864, 4448, + 1, 0, 0, 0, 29865, 29866, 7, 25, 0, 0, 29866, 29867, 7, 14, 0, 0, 29867, + 29868, 7, 11, 0, 0, 29868, 29869, 7, 5, 0, 0, 29869, 29870, 7, 6, 0, 0, + 29870, 29871, 7, 3, 0, 0, 29871, 29872, 7, 12, 0, 0, 29872, 29873, 7, 0, + 0, 0, 29873, 29874, 7, 11, 0, 0, 29874, 29875, 7, 12, 0, 0, 29875, 29876, + 7, 23, 0, 0, 29876, 29877, 7, 6, 0, 0, 29877, 4450, 1, 0, 0, 0, 29878, + 29879, 7, 25, 0, 0, 29879, 29880, 7, 14, 0, 0, 29880, 29881, 7, 11, 0, + 0, 29881, 29882, 7, 4, 0, 0, 29882, 29883, 7, 0, 0, 0, 29883, 29884, 7, + 1, 0, 0, 29884, 29885, 7, 11, 0, 0, 29885, 29886, 7, 6, 0, 0, 29886, 4452, + 1, 0, 0, 0, 29887, 29888, 7, 25, 0, 0, 29888, 29889, 7, 14, 0, 0, 29889, + 29890, 7, 11, 0, 0, 29890, 29891, 7, 4, 0, 0, 29891, 29892, 7, 3, 0, 0, + 29892, 29893, 7, 0, 0, 0, 29893, 29894, 7, 7, 0, 0, 29894, 29895, 7, 5, + 0, 0, 29895, 29896, 7, 16, 0, 0, 29896, 29897, 7, 2, 0, 0, 29897, 29898, + 7, 3, 0, 0, 29898, 29899, 7, 14, 0, 0, 29899, 29900, 7, 1, 0, 0, 29900, + 29901, 7, 11, 0, 0, 29901, 29902, 7, 2, 0, 0, 29902, 29903, 7, 1, 0, 0, + 29903, 4454, 1, 0, 0, 0, 29904, 29905, 7, 25, 0, 0, 29905, 29906, 7, 14, + 0, 0, 29906, 29907, 7, 11, 0, 0, 29907, 29908, 7, 4, 0, 0, 29908, 29909, + 7, 3, 0, 0, 29909, 29910, 7, 0, 0, 0, 29910, 29911, 7, 7, 0, 0, 29911, + 29912, 7, 5, 0, 0, 29912, 29913, 7, 16, 0, 0, 29913, 29914, 7, 2, 0, 0, + 29914, 29915, 7, 3, 0, 0, 29915, 29916, 7, 14, 0, 0, 29916, 4456, 1, 0, + 0, 0, 29917, 29918, 7, 25, 0, 0, 29918, 29919, 7, 14, 0, 0, 29919, 29920, + 7, 11, 0, 0, 29920, 29921, 7, 4, 0, 0, 29921, 29922, 7, 18, 0, 0, 29922, + 29923, 7, 15, 0, 0, 29923, 29924, 7, 6, 0, 0, 29924, 4458, 1, 0, 0, 0, + 29925, 29926, 7, 25, 0, 0, 29926, 29927, 7, 14, 0, 0, 29927, 29928, 7, + 11, 0, 0, 29928, 4460, 1, 0, 0, 0, 29929, 29930, 7, 25, 0, 0, 29930, 29931, + 7, 15, 0, 0, 29931, 29932, 7, 0, 0, 0, 29932, 29933, 7, 4, 0, 0, 29933, + 29934, 7, 19, 0, 0, 29934, 29935, 7, 4, 0, 0, 29935, 29936, 7, 0, 0, 0, + 29936, 29937, 7, 1, 0, 0, 29937, 29938, 7, 11, 0, 0, 29938, 29939, 7, 6, + 0, 0, 29939, 4462, 1, 0, 0, 0, 29940, 29941, 7, 25, 0, 0, 29941, 29942, + 7, 5, 0, 0, 29942, 29943, 5, 95, 0, 0, 29943, 29944, 7, 5, 0, 0, 29944, + 29945, 7, 18, 0, 0, 29945, 29946, 7, 5, 0, 0, 29946, 29947, 5, 95, 0, 0, + 29947, 29948, 7, 8, 0, 0, 29948, 29949, 7, 2, 0, 0, 29949, 29950, 7, 7, + 0, 0, 29950, 29951, 7, 4, 0, 0, 29951, 29952, 7, 6, 0, 0, 29952, 29953, + 7, 25, 0, 0, 29953, 29954, 7, 4, 0, 0, 29954, 4464, 1, 0, 0, 0, 29955, + 29956, 7, 25, 0, 0, 29956, 29957, 7, 5, 0, 0, 29957, 4466, 1, 0, 0, 0, + 29958, 29959, 7, 18, 0, 0, 29959, 29960, 7, 6, 0, 0, 29960, 29961, 7, 0, + 0, 0, 29961, 29962, 7, 3, 0, 0, 29962, 29963, 7, 5, 0, 0, 29963, 4468, + 1, 0, 0, 0, 29964, 29965, 7, 18, 0, 0, 29965, 29966, 7, 6, 0, 0, 29966, + 29967, 7, 0, 0, 0, 29967, 29968, 7, 3, 0, 0, 29968, 4470, 1, 0, 0, 0, 29969, + 29970, 7, 18, 0, 0, 29970, 29971, 7, 6, 0, 0, 29971, 29972, 7, 5, 0, 0, + 29972, 4472, 1, 0, 0, 0, 29973, 29974, 7, 18, 0, 0, 29974, 29975, 7, 14, + 0, 0, 29975, 29976, 7, 12, 0, 0, 29976, 29977, 7, 7, 0, 0, 29977, 29978, + 7, 4, 0, 0, 29978, 29979, 7, 6, 0, 0, 29979, 29980, 7, 3, 0, 0, 29980, + 29981, 7, 13, 0, 0, 29981, 29982, 7, 0, 0, 0, 29982, 29983, 7, 11, 0, 0, + 29983, 29984, 5, 95, 0, 0, 29984, 29985, 7, 10, 0, 0, 29985, 29986, 7, + 7, 0, 0, 29986, 29987, 7, 8, 0, 0, 29987, 29988, 7, 2, 0, 0, 29988, 29989, + 7, 7, 0, 0, 29989, 29990, 7, 5, 0, 0, 29990, 29991, 7, 4, 0, 0, 29991, + 29992, 7, 3, 0, 0, 29992, 29993, 7, 0, 0, 0, 29993, 29994, 7, 12, 0, 0, + 29994, 29995, 7, 7, 0, 0, 29995, 29996, 7, 6, 0, 0, 29996, 29997, 7, 9, + 0, 0, 29997, 4474, 1, 0, 0, 0, 29998, 29999, 7, 23, 0, 0, 29999, 30000, + 7, 2, 0, 0, 30000, 30001, 7, 7, 0, 0, 30001, 30002, 7, 6, 0, 0, 30002, + 30003, 7, 14, 0, 0, 30003, 30004, 7, 0, 0, 0, 30004, 30005, 7, 15, 0, 0, + 30005, 4476, 1, 0, 0, 0, 30006, 30007, 7, 23, 0, 0, 30007, 30008, 7, 2, + 0, 0, 30008, 30009, 7, 7, 0, 0, 30009, 30010, 7, 6, 0, 0, 30010, 4478, + 1, 0, 0, 0, 30011, 30012, 7, 15, 0, 0, 30012, 30013, 7, 3, 0, 0, 30013, + 30014, 7, 6, 0, 0, 30014, 30015, 7, 9, 0, 0, 30015, 30016, 7, 12, 0, 0, + 30016, 30017, 7, 8, 0, 0, 30017, 30018, 7, 4, 0, 0, 30018, 30019, 7, 12, + 0, 0, 30019, 30020, 7, 2, 0, 0, 30020, 30021, 7, 7, 0, 0, 30021, 4480, + 1, 0, 0, 0, 30022, 30023, 7, 15, 0, 0, 30023, 30024, 7, 3, 0, 0, 30024, + 30025, 7, 6, 0, 0, 30025, 30026, 7, 9, 0, 0, 30026, 30027, 7, 12, 0, 0, + 30027, 30028, 7, 8, 0, 0, 30028, 30029, 7, 4, 0, 0, 30029, 30030, 7, 12, + 0, 0, 30030, 30031, 7, 2, 0, 0, 30031, 30032, 7, 7, 0, 0, 30032, 30033, + 5, 95, 0, 0, 30033, 30034, 7, 1, 0, 0, 30034, 30035, 7, 2, 0, 0, 30035, + 30036, 7, 10, 0, 0, 30036, 30037, 7, 7, 0, 0, 30037, 30038, 7, 9, 0, 0, + 30038, 30039, 7, 5, 0, 0, 30039, 4482, 1, 0, 0, 0, 30040, 30041, 7, 15, + 0, 0, 30041, 30042, 7, 3, 0, 0, 30042, 30043, 7, 6, 0, 0, 30043, 30044, + 7, 9, 0, 0, 30044, 30045, 7, 12, 0, 0, 30045, 30046, 7, 8, 0, 0, 30046, + 30047, 7, 4, 0, 0, 30047, 30048, 7, 12, 0, 0, 30048, 30049, 7, 2, 0, 0, + 30049, 30050, 7, 7, 0, 0, 30050, 30051, 5, 95, 0, 0, 30051, 30052, 7, 8, + 0, 0, 30052, 30053, 7, 2, 0, 0, 30053, 30054, 7, 5, 0, 0, 30054, 30055, + 7, 4, 0, 0, 30055, 4484, 1, 0, 0, 0, 30056, 30057, 7, 15, 0, 0, 30057, + 30058, 7, 3, 0, 0, 30058, 30059, 7, 6, 0, 0, 30059, 30060, 7, 9, 0, 0, + 30060, 30061, 7, 12, 0, 0, 30061, 30062, 7, 8, 0, 0, 30062, 30063, 7, 4, + 0, 0, 30063, 30064, 7, 12, 0, 0, 30064, 30065, 7, 2, 0, 0, 30065, 30066, + 7, 7, 0, 0, 30066, 30067, 5, 95, 0, 0, 30067, 30068, 7, 9, 0, 0, 30068, + 30069, 7, 6, 0, 0, 30069, 30070, 7, 4, 0, 0, 30070, 30071, 7, 0, 0, 0, + 30071, 30072, 7, 12, 0, 0, 30072, 30073, 7, 11, 0, 0, 30073, 30074, 7, + 5, 0, 0, 30074, 4486, 1, 0, 0, 0, 30075, 30076, 7, 15, 0, 0, 30076, 30077, + 7, 3, 0, 0, 30077, 30078, 7, 6, 0, 0, 30078, 30079, 7, 9, 0, 0, 30079, + 30080, 7, 12, 0, 0, 30080, 30081, 7, 8, 0, 0, 30081, 30082, 7, 4, 0, 0, + 30082, 30083, 7, 12, 0, 0, 30083, 30084, 7, 2, 0, 0, 30084, 30085, 7, 7, + 0, 0, 30085, 30086, 5, 95, 0, 0, 30086, 30087, 7, 15, 0, 0, 30087, 30088, + 7, 3, 0, 0, 30088, 30089, 7, 2, 0, 0, 30089, 30090, 7, 1, 0, 0, 30090, + 30091, 7, 0, 0, 0, 30091, 30092, 7, 1, 0, 0, 30092, 30093, 7, 12, 0, 0, + 30093, 30094, 7, 11, 0, 0, 30094, 30095, 7, 12, 0, 0, 30095, 30096, 7, + 4, 0, 0, 30096, 30097, 7, 18, 0, 0, 30097, 4488, 1, 0, 0, 0, 30098, 30099, + 7, 15, 0, 0, 30099, 30100, 7, 3, 0, 0, 30100, 30101, 7, 6, 0, 0, 30101, + 30102, 7, 9, 0, 0, 30102, 30103, 7, 12, 0, 0, 30103, 30104, 7, 8, 0, 0, + 30104, 30105, 7, 4, 0, 0, 30105, 30106, 7, 12, 0, 0, 30106, 30107, 7, 2, + 0, 0, 30107, 30108, 7, 7, 0, 0, 30108, 30109, 5, 95, 0, 0, 30109, 30110, + 7, 5, 0, 0, 30110, 30111, 7, 6, 0, 0, 30111, 30112, 7, 4, 0, 0, 30112, + 4490, 1, 0, 0, 0, 30113, 30114, 7, 1, 0, 0, 30114, 30115, 7, 11, 0, 0, + 30115, 30116, 7, 2, 0, 0, 30116, 30117, 7, 8, 0, 0, 30117, 30118, 7, 21, + 0, 0, 30118, 30119, 7, 8, 0, 0, 30119, 30120, 7, 19, 0, 0, 30120, 30121, + 7, 0, 0, 0, 30121, 30122, 7, 12, 0, 0, 30122, 30123, 7, 7, 0, 0, 30123, + 4492, 1, 0, 0, 0, 30124, 30125, 7, 8, 0, 0, 30125, 30126, 7, 2, 0, 0, 30126, + 30127, 7, 11, 0, 0, 30127, 30128, 7, 11, 0, 0, 30128, 30129, 7, 0, 0, 0, + 30129, 30130, 7, 4, 0, 0, 30130, 30131, 7, 6, 0, 0, 30131, 4494, 1, 0, + 0, 0, 30132, 30133, 7, 8, 0, 0, 30133, 30134, 7, 2, 0, 0, 30134, 30135, + 7, 11, 0, 0, 30135, 30136, 7, 11, 0, 0, 30136, 30137, 7, 0, 0, 0, 30137, + 30138, 7, 4, 0, 0, 30138, 30139, 7, 12, 0, 0, 30139, 30140, 7, 2, 0, 0, + 30140, 30141, 7, 7, 0, 0, 30141, 4496, 1, 0, 0, 0, 30142, 30143, 7, 9, + 0, 0, 30143, 30144, 7, 6, 0, 0, 30144, 30145, 7, 16, 0, 0, 30145, 30146, + 7, 12, 0, 0, 30146, 30147, 7, 7, 0, 0, 30147, 30148, 7, 12, 0, 0, 30148, + 30149, 7, 4, 0, 0, 30149, 30150, 7, 12, 0, 0, 30150, 30151, 7, 2, 0, 0, + 30151, 30152, 7, 7, 0, 0, 30152, 4498, 1, 0, 0, 0, 30153, 30154, 7, 9, + 0, 0, 30154, 30155, 7, 10, 0, 0, 30155, 30156, 7, 15, 0, 0, 30156, 30157, + 7, 11, 0, 0, 30157, 30158, 7, 12, 0, 0, 30158, 30159, 7, 8, 0, 0, 30159, + 30160, 7, 0, 0, 0, 30160, 30161, 7, 4, 0, 0, 30161, 30162, 7, 6, 0, 0, + 30162, 30163, 7, 9, 0, 0, 30163, 4500, 1, 0, 0, 0, 30164, 30165, 7, 6, + 0, 0, 30165, 30166, 7, 25, 0, 0, 30166, 30167, 7, 4, 0, 0, 30167, 30168, + 7, 6, 0, 0, 30168, 30169, 7, 7, 0, 0, 30169, 30170, 7, 9, 0, 0, 30170, + 30171, 7, 6, 0, 0, 30171, 30172, 7, 9, 0, 0, 30172, 4502, 1, 0, 0, 0, 30173, + 30174, 7, 19, 0, 0, 30174, 30175, 7, 0, 0, 0, 30175, 30176, 7, 5, 0, 0, + 30176, 30177, 7, 19, 0, 0, 30177, 30178, 7, 12, 0, 0, 30178, 30179, 7, + 7, 0, 0, 30179, 30180, 7, 17, 0, 0, 30180, 4504, 1, 0, 0, 0, 30181, 30182, + 7, 12, 0, 0, 30182, 30183, 7, 9, 0, 0, 30183, 30184, 7, 11, 0, 0, 30184, + 30185, 7, 6, 0, 0, 30185, 4506, 1, 0, 0, 0, 30186, 30187, 7, 12, 0, 0, + 30187, 30188, 7, 14, 0, 0, 30188, 30189, 7, 14, 0, 0, 30189, 30190, 7, + 10, 0, 0, 30190, 30191, 7, 4, 0, 0, 30191, 30192, 7, 0, 0, 0, 30192, 30193, + 7, 1, 0, 0, 30193, 30194, 7, 11, 0, 0, 30194, 30195, 7, 6, 0, 0, 30195, + 4508, 1, 0, 0, 0, 30196, 30197, 7, 2, 0, 0, 30197, 30198, 7, 3, 0, 0, 30198, + 30199, 7, 0, 0, 0, 30199, 30200, 7, 8, 0, 0, 30200, 30201, 7, 11, 0, 0, + 30201, 30202, 7, 6, 0, 0, 30202, 30203, 5, 95, 0, 0, 30203, 30204, 7, 9, + 0, 0, 30204, 30205, 7, 0, 0, 0, 30205, 30206, 7, 4, 0, 0, 30206, 30207, + 7, 0, 0, 0, 30207, 30208, 7, 15, 0, 0, 30208, 30209, 7, 10, 0, 0, 30209, + 30210, 7, 14, 0, 0, 30210, 30211, 7, 15, 0, 0, 30211, 4510, 1, 0, 0, 0, + 30212, 30213, 7, 2, 0, 0, 30213, 30214, 7, 3, 0, 0, 30214, 30215, 7, 0, + 0, 0, 30215, 30216, 7, 8, 0, 0, 30216, 30217, 7, 11, 0, 0, 30217, 30218, + 7, 6, 0, 0, 30218, 30219, 5, 95, 0, 0, 30219, 30220, 7, 19, 0, 0, 30220, + 30221, 7, 9, 0, 0, 30221, 30222, 7, 16, 0, 0, 30222, 30223, 7, 5, 0, 0, + 30223, 4512, 1, 0, 0, 0, 30224, 30225, 7, 2, 0, 0, 30225, 30226, 7, 3, + 0, 0, 30226, 30227, 7, 0, 0, 0, 30227, 30228, 7, 8, 0, 0, 30228, 30229, + 7, 11, 0, 0, 30229, 30230, 7, 6, 0, 0, 30230, 30231, 5, 95, 0, 0, 30231, + 30232, 7, 19, 0, 0, 30232, 30233, 7, 12, 0, 0, 30233, 30234, 7, 13, 0, + 0, 30234, 30235, 7, 6, 0, 0, 30235, 4514, 1, 0, 0, 0, 30236, 30237, 7, + 2, 0, 0, 30237, 30238, 7, 3, 0, 0, 30238, 30239, 7, 0, 0, 0, 30239, 30240, + 7, 8, 0, 0, 30240, 30241, 7, 11, 0, 0, 30241, 30242, 7, 6, 0, 0, 30242, + 30243, 5, 95, 0, 0, 30243, 30244, 7, 11, 0, 0, 30244, 30245, 7, 2, 0, 0, + 30245, 30246, 7, 0, 0, 0, 30246, 30247, 7, 9, 0, 0, 30247, 30248, 7, 6, + 0, 0, 30248, 30249, 7, 3, 0, 0, 30249, 4516, 1, 0, 0, 0, 30250, 30251, + 5, 34, 0, 0, 30251, 30252, 7, 5, 0, 0, 30252, 30253, 7, 19, 0, 0, 30253, + 30254, 7, 0, 0, 0, 30254, 30255, 5, 50, 0, 0, 30255, 30256, 5, 95, 0, 0, + 30256, 30257, 5, 53, 0, 0, 30257, 30258, 5, 49, 0, 0, 30258, 30259, 5, + 50, 0, 0, 30259, 30260, 5, 34, 0, 0, 30260, 4518, 1, 0, 0, 0, 30261, 30262, + 7, 5, 0, 0, 30262, 30263, 7, 19, 0, 0, 30263, 30264, 7, 0, 0, 0, 30264, + 30265, 7, 3, 0, 0, 30265, 30266, 7, 9, 0, 0, 30266, 30267, 7, 6, 0, 0, + 30267, 30268, 7, 9, 0, 0, 30268, 4520, 1, 0, 0, 0, 30269, 30270, 5, 34, + 0, 0, 30270, 30271, 7, 13, 0, 0, 30271, 30272, 5, 49, 0, 0, 30272, 30273, + 5, 34, 0, 0, 30273, 4522, 1, 0, 0, 0, 30274, 30275, 7, 12, 0, 0, 30275, + 30276, 7, 5, 0, 0, 30276, 30277, 7, 2, 0, 0, 30277, 30278, 7, 11, 0, 0, + 30278, 30279, 7, 0, 0, 0, 30279, 30280, 7, 4, 0, 0, 30280, 30281, 7, 6, + 0, 0, 30281, 4524, 1, 0, 0, 0, 30282, 30283, 7, 3, 0, 0, 30283, 30284, + 7, 2, 0, 0, 30284, 30285, 7, 2, 0, 0, 30285, 30286, 7, 4, 0, 0, 30286, + 4526, 1, 0, 0, 0, 30287, 30288, 7, 10, 0, 0, 30288, 30289, 7, 7, 0, 0, + 30289, 30290, 7, 12, 0, 0, 30290, 30291, 7, 4, 0, 0, 30291, 30292, 7, 6, + 0, 0, 30292, 4528, 1, 0, 0, 0, 30293, 30294, 7, 0, 0, 0, 30294, 30295, + 7, 11, 0, 0, 30295, 30296, 7, 17, 0, 0, 30296, 30297, 7, 2, 0, 0, 30297, + 30298, 7, 3, 0, 0, 30298, 30299, 7, 12, 0, 0, 30299, 30300, 7, 4, 0, 0, + 30300, 30301, 7, 19, 0, 0, 30301, 30302, 7, 14, 0, 0, 30302, 4530, 1, 0, + 0, 0, 30303, 30304, 7, 8, 0, 0, 30304, 30305, 7, 10, 0, 0, 30305, 30306, + 7, 14, 0, 0, 30306, 30307, 7, 6, 0, 0, 30307, 30308, 5, 95, 0, 0, 30308, + 30309, 7, 9, 0, 0, 30309, 30310, 7, 12, 0, 0, 30310, 30311, 7, 5, 0, 0, + 30311, 30312, 7, 4, 0, 0, 30312, 4532, 1, 0, 0, 0, 30313, 30314, 7, 9, + 0, 0, 30314, 30315, 7, 6, 0, 0, 30315, 30316, 7, 7, 0, 0, 30316, 30317, + 7, 5, 0, 0, 30317, 30318, 7, 6, 0, 0, 30318, 30319, 5, 95, 0, 0, 30319, + 30320, 7, 3, 0, 0, 30320, 30321, 7, 0, 0, 0, 30321, 30322, 7, 7, 0, 0, + 30322, 30323, 7, 21, 0, 0, 30323, 4534, 1, 0, 0, 0, 30324, 30325, 7, 11, + 0, 0, 30325, 30326, 7, 12, 0, 0, 30326, 30327, 7, 5, 0, 0, 30327, 30328, + 7, 4, 0, 0, 30328, 30329, 7, 0, 0, 0, 30329, 30330, 7, 17, 0, 0, 30330, + 30331, 7, 17, 0, 0, 30331, 4536, 1, 0, 0, 0, 30332, 30333, 7, 15, 0, 0, + 30333, 30334, 7, 6, 0, 0, 30334, 30335, 7, 3, 0, 0, 30335, 30336, 7, 8, + 0, 0, 30336, 30337, 7, 6, 0, 0, 30337, 30338, 7, 7, 0, 0, 30338, 30339, + 7, 4, 0, 0, 30339, 30340, 5, 95, 0, 0, 30340, 30341, 7, 3, 0, 0, 30341, + 30342, 7, 0, 0, 0, 30342, 30343, 7, 7, 0, 0, 30343, 30344, 7, 21, 0, 0, + 30344, 4538, 1, 0, 0, 0, 30345, 30346, 7, 15, 0, 0, 30346, 30347, 7, 6, + 0, 0, 30347, 30348, 7, 3, 0, 0, 30348, 30349, 7, 8, 0, 0, 30349, 30350, + 7, 6, 0, 0, 30350, 30351, 7, 7, 0, 0, 30351, 30352, 7, 4, 0, 0, 30352, + 30353, 7, 12, 0, 0, 30353, 30354, 7, 11, 0, 0, 30354, 30355, 7, 6, 0, 0, + 30355, 30356, 5, 95, 0, 0, 30356, 30357, 7, 8, 0, 0, 30357, 30358, 7, 2, + 0, 0, 30358, 30359, 7, 7, 0, 0, 30359, 30360, 7, 4, 0, 0, 30360, 4540, + 1, 0, 0, 0, 30361, 30362, 7, 15, 0, 0, 30362, 30363, 7, 6, 0, 0, 30363, + 30364, 7, 3, 0, 0, 30364, 30365, 7, 8, 0, 0, 30365, 30366, 7, 6, 0, 0, + 30366, 30367, 7, 7, 0, 0, 30367, 30368, 7, 4, 0, 0, 30368, 30369, 7, 12, + 0, 0, 30369, 30370, 7, 11, 0, 0, 30370, 30371, 7, 6, 0, 0, 30371, 30372, + 5, 95, 0, 0, 30372, 30373, 7, 9, 0, 0, 30373, 30374, 7, 12, 0, 0, 30374, + 30375, 7, 5, 0, 0, 30375, 30376, 7, 8, 0, 0, 30376, 4542, 1, 0, 0, 0, 30377, + 30378, 7, 3, 0, 0, 30378, 30379, 7, 0, 0, 0, 30379, 30380, 7, 7, 0, 0, + 30380, 30381, 7, 21, 0, 0, 30381, 4544, 1, 0, 0, 0, 30382, 30383, 7, 0, + 0, 0, 30383, 30384, 7, 13, 0, 0, 30384, 30385, 7, 17, 0, 0, 30385, 4546, + 1, 0, 0, 0, 30386, 30387, 7, 8, 0, 0, 30387, 30388, 7, 2, 0, 0, 30388, + 30389, 7, 3, 0, 0, 30389, 30390, 7, 3, 0, 0, 30390, 4548, 1, 0, 0, 0, 30391, + 30392, 7, 8, 0, 0, 30392, 30393, 7, 2, 0, 0, 30393, 30394, 7, 13, 0, 0, + 30394, 30395, 7, 0, 0, 0, 30395, 30396, 7, 3, 0, 0, 30396, 30397, 5, 95, + 0, 0, 30397, 4550, 1, 0, 0, 0, 30398, 30399, 7, 9, 0, 0, 30399, 30400, + 7, 6, 0, 0, 30400, 30401, 7, 8, 0, 0, 30401, 30402, 7, 2, 0, 0, 30402, + 30403, 7, 9, 0, 0, 30403, 30404, 7, 6, 0, 0, 30404, 4552, 1, 0, 0, 0, 30405, + 30406, 7, 11, 0, 0, 30406, 30407, 7, 0, 0, 0, 30407, 30408, 7, 17, 0, 0, + 30408, 4554, 1, 0, 0, 0, 30409, 30410, 7, 11, 0, 0, 30410, 30411, 7, 0, + 0, 0, 30411, 30412, 7, 17, 0, 0, 30412, 30413, 5, 95, 0, 0, 30413, 30414, + 7, 9, 0, 0, 30414, 30415, 7, 12, 0, 0, 30415, 30416, 7, 16, 0, 0, 30416, + 30417, 7, 16, 0, 0, 30417, 4556, 1, 0, 0, 0, 30418, 30419, 7, 11, 0, 0, + 30419, 30420, 7, 0, 0, 0, 30420, 30421, 7, 17, 0, 0, 30421, 30422, 5, 95, + 0, 0, 30422, 30423, 7, 9, 0, 0, 30423, 30424, 7, 12, 0, 0, 30424, 30425, + 7, 16, 0, 0, 30425, 30426, 7, 16, 0, 0, 30426, 30427, 5, 95, 0, 0, 30427, + 30428, 7, 15, 0, 0, 30428, 30429, 7, 6, 0, 0, 30429, 30430, 7, 3, 0, 0, + 30430, 30431, 7, 8, 0, 0, 30431, 30432, 7, 6, 0, 0, 30432, 30433, 7, 7, + 0, 0, 30433, 30434, 7, 4, 0, 0, 30434, 4558, 1, 0, 0, 0, 30435, 30436, + 7, 11, 0, 0, 30436, 30437, 7, 6, 0, 0, 30437, 30438, 7, 0, 0, 0, 30438, + 30439, 7, 9, 0, 0, 30439, 4560, 1, 0, 0, 0, 30440, 30441, 7, 14, 0, 0, + 30441, 30442, 7, 0, 0, 0, 30442, 30443, 7, 25, 0, 0, 30443, 4562, 1, 0, + 0, 0, 30444, 30445, 7, 14, 0, 0, 30445, 30446, 7, 6, 0, 0, 30446, 30447, + 7, 9, 0, 0, 30447, 30448, 7, 12, 0, 0, 30448, 30449, 7, 0, 0, 0, 30449, + 30450, 7, 7, 0, 0, 30450, 4564, 1, 0, 0, 0, 30451, 30452, 7, 14, 0, 0, + 30452, 30453, 7, 6, 0, 0, 30453, 30454, 7, 14, 0, 0, 30454, 30455, 7, 2, + 0, 0, 30455, 30456, 7, 15, 0, 0, 30456, 30457, 7, 4, 0, 0, 30457, 30458, + 7, 12, 0, 0, 30458, 30459, 7, 14, 0, 0, 30459, 30460, 7, 12, 0, 0, 30460, + 30461, 7, 23, 0, 0, 30461, 30462, 7, 6, 0, 0, 30462, 4566, 1, 0, 0, 0, + 30463, 30464, 7, 14, 0, 0, 30464, 30465, 7, 12, 0, 0, 30465, 30466, 7, + 7, 0, 0, 30466, 4568, 1, 0, 0, 0, 30467, 30468, 7, 7, 0, 0, 30468, 30469, + 7, 4, 0, 0, 30469, 30470, 7, 12, 0, 0, 30470, 30471, 7, 11, 0, 0, 30471, + 30472, 7, 6, 0, 0, 30472, 4570, 1, 0, 0, 0, 30473, 30474, 7, 7, 0, 0, 30474, + 30475, 7, 13, 0, 0, 30475, 30476, 7, 11, 0, 0, 30476, 4572, 1, 0, 0, 0, + 30477, 30478, 7, 3, 0, 0, 30478, 30479, 7, 0, 0, 0, 30479, 30480, 7, 4, + 0, 0, 30480, 30481, 7, 12, 0, 0, 30481, 30482, 7, 2, 0, 0, 30482, 30483, + 5, 95, 0, 0, 30483, 30484, 7, 4, 0, 0, 30484, 30485, 7, 2, 0, 0, 30485, + 30486, 5, 95, 0, 0, 30486, 30487, 7, 3, 0, 0, 30487, 30488, 7, 6, 0, 0, + 30488, 30489, 7, 15, 0, 0, 30489, 30490, 7, 2, 0, 0, 30490, 30491, 7, 3, + 0, 0, 30491, 30492, 7, 4, 0, 0, 30492, 4574, 1, 0, 0, 0, 30493, 30494, + 7, 3, 0, 0, 30494, 30495, 7, 6, 0, 0, 30495, 30496, 7, 17, 0, 0, 30496, + 30497, 7, 3, 0, 0, 30497, 30498, 5, 95, 0, 0, 30498, 4576, 1, 0, 0, 0, + 30499, 30500, 7, 3, 0, 0, 30500, 30501, 7, 2, 0, 0, 30501, 30502, 7, 10, + 0, 0, 30502, 30503, 7, 7, 0, 0, 30503, 30504, 7, 9, 0, 0, 30504, 4578, + 1, 0, 0, 0, 30505, 30506, 7, 3, 0, 0, 30506, 30507, 7, 2, 0, 0, 30507, + 30508, 7, 22, 0, 0, 30508, 30509, 5, 95, 0, 0, 30509, 30510, 7, 7, 0, 0, + 30510, 30511, 7, 10, 0, 0, 30511, 30512, 7, 14, 0, 0, 30512, 30513, 7, + 1, 0, 0, 30513, 30514, 7, 6, 0, 0, 30514, 30515, 7, 3, 0, 0, 30515, 4580, + 1, 0, 0, 0, 30516, 30517, 7, 5, 0, 0, 30517, 30518, 7, 10, 0, 0, 30518, + 30519, 7, 1, 0, 0, 30519, 30520, 7, 5, 0, 0, 30520, 30521, 7, 4, 0, 0, + 30521, 30522, 7, 3, 0, 0, 30522, 4582, 1, 0, 0, 0, 30523, 30524, 7, 4, + 0, 0, 30524, 30525, 7, 2, 0, 0, 30525, 30526, 5, 95, 0, 0, 30526, 30527, + 7, 8, 0, 0, 30527, 30528, 7, 19, 0, 0, 30528, 30529, 7, 0, 0, 0, 30529, + 30530, 7, 3, 0, 0, 30530, 4584, 1, 0, 0, 0, 30531, 30532, 7, 4, 0, 0, 30532, + 30533, 7, 3, 0, 0, 30533, 30534, 7, 12, 0, 0, 30534, 30535, 7, 14, 0, 0, + 30535, 4586, 1, 0, 0, 0, 30536, 30537, 7, 5, 0, 0, 30537, 30538, 7, 10, + 0, 0, 30538, 30539, 7, 14, 0, 0, 30539, 4588, 1, 0, 0, 0, 30540, 30541, + 7, 5, 0, 0, 30541, 30542, 7, 4, 0, 0, 30542, 30543, 7, 9, 0, 0, 30543, + 30544, 7, 9, 0, 0, 30544, 30545, 7, 6, 0, 0, 30545, 30546, 7, 13, 0, 0, + 30546, 4590, 1, 0, 0, 0, 30547, 30548, 7, 13, 0, 0, 30548, 30549, 7, 0, + 0, 0, 30549, 30550, 7, 3, 0, 0, 30550, 30551, 5, 95, 0, 0, 30551, 4592, + 1, 0, 0, 0, 30552, 30553, 7, 13, 0, 0, 30553, 30554, 7, 0, 0, 0, 30554, + 30555, 7, 3, 0, 0, 30555, 30556, 7, 12, 0, 0, 30556, 30557, 7, 0, 0, 0, + 30557, 30558, 7, 7, 0, 0, 30558, 30559, 7, 8, 0, 0, 30559, 30560, 7, 6, + 0, 0, 30560, 4594, 1, 0, 0, 0, 30561, 30562, 7, 11, 0, 0, 30562, 30563, + 7, 6, 0, 0, 30563, 30564, 7, 0, 0, 0, 30564, 30565, 7, 5, 0, 0, 30565, + 30566, 7, 4, 0, 0, 30566, 4596, 1, 0, 0, 0, 30567, 30568, 7, 17, 0, 0, + 30568, 30569, 7, 3, 0, 0, 30569, 30570, 7, 6, 0, 0, 30570, 30571, 7, 0, + 0, 0, 30571, 30572, 7, 4, 0, 0, 30572, 30573, 7, 6, 0, 0, 30573, 30574, + 7, 5, 0, 0, 30574, 30575, 7, 4, 0, 0, 30575, 4598, 1, 0, 0, 0, 30576, 30577, + 7, 4, 0, 0, 30577, 30578, 7, 2, 0, 0, 30578, 30579, 5, 95, 0, 0, 30579, + 30580, 7, 9, 0, 0, 30580, 30581, 7, 0, 0, 0, 30581, 30582, 7, 4, 0, 0, + 30582, 30583, 7, 6, 0, 0, 30583, 4600, 1, 0, 0, 0, 30584, 30585, 7, 9, + 0, 0, 30585, 30586, 7, 6, 0, 0, 30586, 30587, 7, 16, 0, 0, 30587, 30588, + 7, 0, 0, 0, 30588, 30589, 7, 10, 0, 0, 30589, 30590, 7, 11, 0, 0, 30590, + 30591, 7, 4, 0, 0, 30591, 30592, 7, 12, 0, 0, 30592, 30593, 7, 16, 0, 0, + 30593, 4602, 1, 0, 0, 0, 30594, 30595, 7, 11, 0, 0, 30595, 30596, 7, 11, + 0, 0, 30596, 30597, 7, 5, 0, 0, 30597, 4604, 1, 0, 0, 0, 30598, 30599, + 7, 6, 0, 0, 30599, 30600, 7, 7, 0, 0, 30600, 30601, 7, 8, 0, 0, 30601, + 30602, 7, 11, 0, 0, 30602, 30603, 7, 2, 0, 0, 30603, 30604, 7, 5, 0, 0, + 30604, 30605, 7, 6, 0, 0, 30605, 30606, 7, 9, 0, 0, 30606, 4606, 1, 0, + 0, 0, 30607, 30608, 7, 4, 0, 0, 30608, 30609, 7, 6, 0, 0, 30609, 30610, + 7, 3, 0, 0, 30610, 30611, 7, 14, 0, 0, 30611, 30612, 7, 12, 0, 0, 30612, + 30613, 7, 7, 0, 0, 30613, 30614, 7, 0, 0, 0, 30614, 30615, 7, 4, 0, 0, + 30615, 30616, 7, 6, 0, 0, 30616, 30617, 7, 9, 0, 0, 30617, 4608, 1, 0, + 0, 0, 30618, 30619, 7, 2, 0, 0, 30619, 30620, 7, 15, 0, 0, 30620, 30621, + 7, 4, 0, 0, 30621, 30622, 7, 12, 0, 0, 30622, 30623, 7, 2, 0, 0, 30623, + 30624, 7, 7, 0, 0, 30624, 30625, 7, 0, 0, 0, 30625, 30626, 7, 11, 0, 0, + 30626, 30627, 7, 11, 0, 0, 30627, 30628, 7, 18, 0, 0, 30628, 4610, 1, 0, + 0, 0, 30629, 30630, 7, 11, 0, 0, 30630, 30631, 7, 3, 0, 0, 30631, 30632, + 7, 4, 0, 0, 30632, 30633, 7, 3, 0, 0, 30633, 30634, 7, 12, 0, 0, 30634, + 30635, 7, 14, 0, 0, 30635, 4612, 1, 0, 0, 0, 30636, 30637, 7, 7, 0, 0, + 30637, 30638, 7, 2, 0, 0, 30638, 30639, 7, 4, 0, 0, 30639, 30640, 7, 3, + 0, 0, 30640, 30641, 7, 12, 0, 0, 30641, 30642, 7, 14, 0, 0, 30642, 4614, + 1, 0, 0, 0, 30643, 30644, 7, 11, 0, 0, 30644, 30645, 7, 9, 0, 0, 30645, + 30646, 7, 3, 0, 0, 30646, 30647, 7, 4, 0, 0, 30647, 30648, 7, 3, 0, 0, + 30648, 30649, 7, 12, 0, 0, 30649, 30650, 7, 14, 0, 0, 30650, 4616, 1, 0, + 0, 0, 30651, 30652, 7, 9, 0, 0, 30652, 30653, 7, 0, 0, 0, 30653, 30654, + 7, 4, 0, 0, 30654, 30655, 7, 6, 0, 0, 30655, 30656, 5, 95, 0, 0, 30656, + 30657, 7, 16, 0, 0, 30657, 30658, 7, 2, 0, 0, 30658, 30659, 7, 3, 0, 0, + 30659, 30660, 7, 14, 0, 0, 30660, 30661, 7, 0, 0, 0, 30661, 30662, 7, 4, + 0, 0, 30662, 4618, 1, 0, 0, 0, 30663, 30664, 7, 14, 0, 0, 30664, 30665, + 7, 0, 0, 0, 30665, 30666, 7, 5, 0, 0, 30666, 30667, 7, 21, 0, 0, 30667, + 4620, 1, 0, 0, 0, 30668, 30669, 7, 4, 0, 0, 30669, 30670, 7, 3, 0, 0, 30670, + 30671, 7, 0, 0, 0, 30671, 30672, 7, 7, 0, 0, 30672, 30673, 7, 5, 0, 0, + 30673, 30674, 7, 16, 0, 0, 30674, 30675, 7, 2, 0, 0, 30675, 30676, 7, 3, + 0, 0, 30676, 30677, 7, 14, 0, 0, 30677, 30678, 7, 5, 0, 0, 30678, 4622, + 1, 0, 0, 0, 30679, 30680, 7, 11, 0, 0, 30680, 30681, 7, 2, 0, 0, 30681, + 30682, 7, 1, 0, 0, 30682, 30683, 7, 16, 0, 0, 30683, 30684, 7, 12, 0, 0, + 30684, 30685, 7, 11, 0, 0, 30685, 30686, 7, 6, 0, 0, 30686, 4624, 1, 0, + 0, 0, 30687, 30688, 7, 5, 0, 0, 30688, 30689, 7, 4, 0, 0, 30689, 30690, + 7, 0, 0, 0, 30690, 30691, 7, 3, 0, 0, 30691, 30692, 7, 4, 0, 0, 30692, + 30693, 7, 2, 0, 0, 30693, 30694, 7, 16, 0, 0, 30694, 4626, 1, 0, 0, 0, + 30695, 30696, 7, 8, 0, 0, 30696, 30697, 7, 19, 0, 0, 30697, 30698, 7, 0, + 0, 0, 30698, 30699, 7, 3, 0, 0, 30699, 30700, 7, 0, 0, 0, 30700, 30701, + 7, 8, 0, 0, 30701, 30702, 7, 4, 0, 0, 30702, 30703, 7, 6, 0, 0, 30703, + 30704, 7, 3, 0, 0, 30704, 30705, 7, 5, 0, 0, 30705, 30706, 7, 6, 0, 0, + 30706, 30707, 7, 4, 0, 0, 30707, 4628, 1, 0, 0, 0, 30708, 30709, 7, 3, + 0, 0, 30709, 30710, 7, 6, 0, 0, 30710, 30711, 7, 8, 0, 0, 30711, 30712, + 7, 2, 0, 0, 30712, 30713, 7, 3, 0, 0, 30713, 30714, 7, 9, 0, 0, 30714, + 30715, 7, 5, 0, 0, 30715, 4630, 1, 0, 0, 0, 30716, 30717, 7, 16, 0, 0, + 30717, 30718, 7, 12, 0, 0, 30718, 30719, 7, 25, 0, 0, 30719, 30720, 7, + 6, 0, 0, 30720, 30721, 7, 9, 0, 0, 30721, 4632, 1, 0, 0, 0, 30722, 30723, + 7, 9, 0, 0, 30723, 30724, 7, 6, 0, 0, 30724, 30725, 7, 11, 0, 0, 30725, + 30726, 7, 12, 0, 0, 30726, 30727, 7, 14, 0, 0, 30727, 30728, 7, 12, 0, + 0, 30728, 30729, 7, 4, 0, 0, 30729, 30730, 7, 6, 0, 0, 30730, 30731, 7, + 9, 0, 0, 30731, 4634, 1, 0, 0, 0, 30732, 30733, 7, 25, 0, 0, 30733, 30734, + 7, 14, 0, 0, 30734, 30735, 7, 11, 0, 0, 30735, 30736, 7, 4, 0, 0, 30736, + 30737, 7, 0, 0, 0, 30737, 30738, 7, 17, 0, 0, 30738, 4636, 1, 0, 0, 0, + 30739, 30740, 7, 15, 0, 0, 30740, 30741, 7, 3, 0, 0, 30741, 30742, 7, 6, + 0, 0, 30742, 30743, 7, 15, 0, 0, 30743, 30744, 7, 3, 0, 0, 30744, 30745, + 7, 2, 0, 0, 30745, 30746, 7, 8, 0, 0, 30746, 30747, 7, 6, 0, 0, 30747, + 30748, 7, 5, 0, 0, 30748, 30749, 7, 5, 0, 0, 30749, 30750, 7, 2, 0, 0, + 30750, 30751, 7, 3, 0, 0, 30751, 4638, 1, 0, 0, 0, 30752, 30753, 7, 4, + 0, 0, 30753, 30754, 7, 6, 0, 0, 30754, 30755, 7, 3, 0, 0, 30755, 30756, + 7, 3, 0, 0, 30756, 30757, 7, 12, 0, 0, 30757, 30758, 7, 4, 0, 0, 30758, + 30759, 7, 2, 0, 0, 30759, 30760, 7, 3, 0, 0, 30760, 30761, 7, 18, 0, 0, + 30761, 4640, 1, 0, 0, 0, 30762, 30763, 7, 11, 0, 0, 30763, 30764, 7, 12, + 0, 0, 30764, 30765, 7, 4, 0, 0, 30765, 30766, 7, 4, 0, 0, 30766, 30767, + 7, 11, 0, 0, 30767, 30768, 7, 6, 0, 0, 30768, 4642, 1, 0, 0, 0, 30769, + 30770, 7, 1, 0, 0, 30770, 30771, 7, 12, 0, 0, 30771, 30772, 7, 17, 0, 0, + 30772, 4644, 1, 0, 0, 0, 30773, 30774, 7, 6, 0, 0, 30774, 30775, 7, 7, + 0, 0, 30775, 30776, 7, 9, 0, 0, 30776, 30777, 7, 12, 0, 0, 30777, 30778, + 7, 0, 0, 0, 30778, 30779, 7, 7, 0, 0, 30779, 4646, 1, 0, 0, 0, 30780, 30781, + 7, 1, 0, 0, 30781, 30782, 7, 18, 0, 0, 30782, 30783, 7, 4, 0, 0, 30783, + 30784, 7, 6, 0, 0, 30784, 30785, 7, 2, 0, 0, 30785, 30786, 7, 3, 0, 0, + 30786, 30787, 7, 9, 0, 0, 30787, 30788, 7, 6, 0, 0, 30788, 30789, 7, 3, + 0, 0, 30789, 30790, 7, 14, 0, 0, 30790, 30791, 7, 0, 0, 0, 30791, 30792, + 7, 3, 0, 0, 30792, 30793, 7, 21, 0, 0, 30793, 4648, 1, 0, 0, 0, 30794, + 30795, 7, 7, 0, 0, 30795, 30796, 7, 2, 0, 0, 30796, 30797, 7, 8, 0, 0, + 30797, 30798, 7, 19, 0, 0, 30798, 30799, 7, 6, 0, 0, 30799, 30800, 7, 8, + 0, 0, 30800, 30801, 7, 21, 0, 0, 30801, 4650, 1, 0, 0, 0, 30802, 30803, + 7, 5, 0, 0, 30803, 30804, 7, 12, 0, 0, 30804, 30805, 7, 23, 0, 0, 30805, + 30806, 7, 6, 0, 0, 30806, 30807, 7, 5, 0, 0, 30807, 4652, 1, 0, 0, 0, 30808, + 30809, 7, 0, 0, 0, 30809, 30810, 7, 3, 0, 0, 30810, 30811, 7, 6, 0, 0, + 30811, 4654, 1, 0, 0, 0, 30812, 30813, 7, 1, 0, 0, 30813, 30814, 7, 18, + 0, 0, 30814, 30815, 7, 4, 0, 0, 30815, 30816, 7, 6, 0, 0, 30816, 30817, + 7, 5, 0, 0, 30817, 4656, 1, 0, 0, 0, 30818, 30819, 7, 8, 0, 0, 30819, 30820, + 7, 19, 0, 0, 30820, 30821, 7, 0, 0, 0, 30821, 30822, 7, 3, 0, 0, 30822, + 30823, 7, 0, 0, 0, 30823, 30824, 7, 8, 0, 0, 30824, 30825, 7, 4, 0, 0, + 30825, 30826, 7, 6, 0, 0, 30826, 30827, 7, 3, 0, 0, 30827, 30828, 7, 5, + 0, 0, 30828, 4658, 1, 0, 0, 0, 30829, 30830, 7, 3, 0, 0, 30830, 30831, + 7, 6, 0, 0, 30831, 30832, 7, 0, 0, 0, 30832, 30833, 7, 9, 0, 0, 30833, + 30834, 7, 5, 0, 0, 30834, 30835, 7, 12, 0, 0, 30835, 30836, 7, 23, 0, 0, + 30836, 30837, 7, 6, 0, 0, 30837, 4660, 1, 0, 0, 0, 30838, 30839, 7, 9, + 0, 0, 30839, 30840, 7, 12, 0, 0, 30840, 30841, 7, 5, 0, 0, 30841, 30842, + 7, 0, 0, 0, 30842, 30843, 7, 1, 0, 0, 30843, 30844, 7, 11, 0, 0, 30844, + 30845, 7, 6, 0, 0, 30845, 30846, 5, 95, 0, 0, 30846, 30847, 7, 9, 0, 0, + 30847, 30848, 7, 12, 0, 0, 30848, 30849, 7, 3, 0, 0, 30849, 30850, 7, 6, + 0, 0, 30850, 30851, 7, 8, 0, 0, 30851, 30852, 7, 4, 0, 0, 30852, 30853, + 7, 2, 0, 0, 30853, 30854, 7, 3, 0, 0, 30854, 30855, 7, 18, 0, 0, 30855, + 30856, 5, 95, 0, 0, 30856, 30857, 7, 11, 0, 0, 30857, 30858, 7, 12, 0, + 0, 30858, 30859, 7, 7, 0, 0, 30859, 30860, 7, 21, 0, 0, 30860, 30861, 5, + 95, 0, 0, 30861, 30862, 7, 8, 0, 0, 30862, 30863, 7, 19, 0, 0, 30863, 30864, + 7, 6, 0, 0, 30864, 30865, 7, 8, 0, 0, 30865, 30866, 7, 21, 0, 0, 30866, + 4662, 1, 0, 0, 0, 30867, 30868, 7, 9, 0, 0, 30868, 30869, 7, 0, 0, 0, 30869, + 30870, 7, 4, 0, 0, 30870, 30871, 7, 6, 0, 0, 30871, 30872, 5, 95, 0, 0, + 30872, 30873, 7, 8, 0, 0, 30873, 30874, 7, 0, 0, 0, 30874, 30875, 7, 8, + 0, 0, 30875, 30876, 7, 19, 0, 0, 30876, 30877, 7, 6, 0, 0, 30877, 4664, + 1, 0, 0, 0, 30878, 30879, 7, 16, 0, 0, 30879, 30880, 7, 12, 0, 0, 30880, + 30881, 7, 6, 0, 0, 30881, 30882, 7, 11, 0, 0, 30882, 30883, 7, 9, 0, 0, + 30883, 30884, 5, 95, 0, 0, 30884, 30885, 7, 7, 0, 0, 30885, 30886, 7, 0, + 0, 0, 30886, 30887, 7, 14, 0, 0, 30887, 30888, 7, 6, 0, 0, 30888, 30889, + 7, 5, 0, 0, 30889, 4666, 1, 0, 0, 0, 30890, 30891, 7, 16, 0, 0, 30891, + 30892, 7, 12, 0, 0, 30892, 30893, 7, 11, 0, 0, 30893, 30894, 7, 6, 0, 0, + 30894, 30895, 7, 5, 0, 0, 30895, 4668, 1, 0, 0, 0, 30896, 30897, 7, 12, + 0, 0, 30897, 30898, 7, 2, 0, 0, 30898, 30899, 5, 95, 0, 0, 30899, 30900, + 7, 2, 0, 0, 30900, 30901, 7, 15, 0, 0, 30901, 30902, 7, 4, 0, 0, 30902, + 30903, 7, 12, 0, 0, 30903, 30904, 7, 2, 0, 0, 30904, 30905, 7, 7, 0, 0, + 30905, 30906, 7, 5, 0, 0, 30906, 4670, 1, 0, 0, 0, 30907, 30908, 7, 9, + 0, 0, 30908, 30909, 7, 12, 0, 0, 30909, 30910, 7, 3, 0, 0, 30910, 30911, + 7, 6, 0, 0, 30911, 30912, 7, 8, 0, 0, 30912, 30913, 7, 4, 0, 0, 30913, + 30914, 7, 12, 0, 0, 30914, 30915, 7, 2, 0, 0, 30915, 4672, 1, 0, 0, 0, + 30916, 30917, 7, 7, 0, 0, 30917, 30918, 7, 2, 0, 0, 30918, 30919, 7, 9, + 0, 0, 30919, 30920, 7, 12, 0, 0, 30920, 30921, 7, 3, 0, 0, 30921, 30922, + 7, 6, 0, 0, 30922, 30923, 7, 8, 0, 0, 30923, 30924, 7, 4, 0, 0, 30924, + 30925, 7, 12, 0, 0, 30925, 30926, 7, 2, 0, 0, 30926, 4674, 1, 0, 0, 0, + 30927, 30928, 7, 9, 0, 0, 30928, 30929, 7, 7, 0, 0, 30929, 30930, 7, 16, + 0, 0, 30930, 30931, 7, 5, 0, 0, 30931, 30932, 5, 95, 0, 0, 30932, 30933, + 7, 6, 0, 0, 30933, 30934, 7, 7, 0, 0, 30934, 30935, 7, 0, 0, 0, 30935, + 30936, 7, 1, 0, 0, 30936, 30937, 7, 11, 0, 0, 30937, 30938, 7, 6, 0, 0, + 30938, 4676, 1, 0, 0, 0, 30939, 30940, 7, 9, 0, 0, 30940, 30941, 7, 7, + 0, 0, 30941, 30942, 7, 16, 0, 0, 30942, 30943, 7, 5, 0, 0, 30943, 30944, + 5, 95, 0, 0, 30944, 30945, 7, 9, 0, 0, 30945, 30946, 7, 12, 0, 0, 30946, + 30947, 7, 5, 0, 0, 30947, 30948, 7, 0, 0, 0, 30948, 30949, 7, 1, 0, 0, + 30949, 30950, 7, 11, 0, 0, 30950, 30951, 7, 6, 0, 0, 30951, 4678, 1, 0, + 0, 0, 30952, 30953, 7, 9, 0, 0, 30953, 30954, 7, 7, 0, 0, 30954, 30955, + 7, 16, 0, 0, 30955, 30956, 7, 5, 0, 0, 30956, 30957, 5, 95, 0, 0, 30957, + 30958, 7, 3, 0, 0, 30958, 30959, 7, 6, 0, 0, 30959, 30960, 7, 0, 0, 0, + 30960, 30961, 7, 9, 0, 0, 30961, 30962, 7, 1, 0, 0, 30962, 30963, 7, 10, + 0, 0, 30963, 30964, 7, 16, 0, 0, 30964, 30965, 7, 16, 0, 0, 30965, 30966, + 7, 6, 0, 0, 30966, 30967, 7, 3, 0, 0, 30967, 30968, 7, 5, 0, 0, 30968, + 4680, 1, 0, 0, 0, 30969, 30970, 7, 7, 0, 0, 30970, 30971, 7, 2, 0, 0, 30971, + 30972, 7, 1, 0, 0, 30972, 30973, 7, 0, 0, 0, 30973, 30974, 7, 9, 0, 0, + 30974, 30975, 7, 16, 0, 0, 30975, 30976, 7, 12, 0, 0, 30976, 30977, 7, + 11, 0, 0, 30977, 30978, 7, 6, 0, 0, 30978, 4682, 1, 0, 0, 0, 30979, 30980, + 7, 1, 0, 0, 30980, 30981, 7, 0, 0, 0, 30981, 30982, 7, 9, 0, 0, 30982, + 30983, 7, 16, 0, 0, 30983, 30984, 7, 12, 0, 0, 30984, 30985, 7, 11, 0, + 0, 30985, 30986, 7, 6, 0, 0, 30986, 4684, 1, 0, 0, 0, 30987, 30988, 7, + 7, 0, 0, 30988, 30989, 7, 2, 0, 0, 30989, 30990, 7, 9, 0, 0, 30990, 30991, + 7, 12, 0, 0, 30991, 30992, 7, 5, 0, 0, 30992, 30993, 7, 8, 0, 0, 30993, + 30994, 7, 0, 0, 0, 30994, 30995, 7, 3, 0, 0, 30995, 30996, 7, 9, 0, 0, + 30996, 30997, 7, 16, 0, 0, 30997, 30998, 7, 12, 0, 0, 30998, 30999, 7, + 11, 0, 0, 30999, 31000, 7, 6, 0, 0, 31000, 4686, 1, 0, 0, 0, 31001, 31002, + 7, 9, 0, 0, 31002, 31003, 7, 12, 0, 0, 31003, 31004, 7, 5, 0, 0, 31004, + 31005, 7, 8, 0, 0, 31005, 31006, 7, 0, 0, 0, 31006, 31007, 7, 3, 0, 0, + 31007, 31008, 7, 9, 0, 0, 31008, 31009, 7, 16, 0, 0, 31009, 31010, 7, 12, + 0, 0, 31010, 31011, 7, 11, 0, 0, 31011, 31012, 7, 6, 0, 0, 31012, 4688, + 1, 0, 0, 0, 31013, 31014, 7, 7, 0, 0, 31014, 31015, 7, 2, 0, 0, 31015, + 31016, 7, 11, 0, 0, 31016, 31017, 7, 2, 0, 0, 31017, 31018, 7, 17, 0, 0, + 31018, 31019, 7, 16, 0, 0, 31019, 31020, 7, 12, 0, 0, 31020, 31021, 7, + 11, 0, 0, 31021, 31022, 7, 6, 0, 0, 31022, 4690, 1, 0, 0, 0, 31023, 31024, + 7, 16, 0, 0, 31024, 31025, 7, 12, 0, 0, 31025, 31026, 7, 6, 0, 0, 31026, + 31027, 7, 11, 0, 0, 31027, 31028, 7, 9, 0, 0, 31028, 31029, 7, 5, 0, 0, + 31029, 4692, 1, 0, 0, 0, 31030, 31031, 7, 12, 0, 0, 31031, 31032, 7, 17, + 0, 0, 31032, 31033, 7, 7, 0, 0, 31033, 31034, 7, 2, 0, 0, 31034, 31035, + 7, 3, 0, 0, 31035, 31036, 7, 6, 0, 0, 31036, 31037, 5, 95, 0, 0, 31037, + 31038, 7, 8, 0, 0, 31038, 31039, 7, 19, 0, 0, 31039, 31040, 7, 0, 0, 0, + 31040, 31041, 7, 3, 0, 0, 31041, 31042, 7, 5, 0, 0, 31042, 31043, 5, 95, + 0, 0, 31043, 31044, 7, 0, 0, 0, 31044, 31045, 7, 16, 0, 0, 31045, 31046, + 7, 4, 0, 0, 31046, 31047, 7, 6, 0, 0, 31047, 31048, 7, 3, 0, 0, 31048, + 31049, 5, 95, 0, 0, 31049, 31050, 7, 6, 0, 0, 31050, 31051, 7, 2, 0, 0, + 31051, 31052, 7, 3, 0, 0, 31052, 4694, 1, 0, 0, 0, 31053, 31054, 7, 8, + 0, 0, 31054, 31055, 7, 5, 0, 0, 31055, 31056, 7, 13, 0, 0, 31056, 4696, + 1, 0, 0, 0, 31057, 31058, 7, 6, 0, 0, 31058, 31059, 7, 14, 0, 0, 31059, + 31060, 7, 1, 0, 0, 31060, 31061, 7, 6, 0, 0, 31061, 31062, 7, 9, 0, 0, + 31062, 31063, 7, 9, 0, 0, 31063, 31064, 7, 6, 0, 0, 31064, 31065, 7, 9, + 0, 0, 31065, 4698, 1, 0, 0, 0, 31066, 31067, 7, 2, 0, 0, 31067, 31068, + 7, 13, 0, 0, 31068, 31069, 7, 6, 0, 0, 31069, 31070, 7, 3, 0, 0, 31070, + 31071, 7, 3, 0, 0, 31071, 31072, 7, 12, 0, 0, 31072, 31073, 7, 9, 0, 0, + 31073, 31074, 7, 6, 0, 0, 31074, 4700, 1, 0, 0, 0, 31075, 31076, 7, 4, + 0, 0, 31076, 31077, 7, 19, 0, 0, 31077, 31078, 7, 6, 0, 0, 31078, 31079, + 7, 5, 0, 0, 31079, 31080, 7, 6, 0, 0, 31080, 4702, 1, 0, 0, 0, 31081, 31082, + 7, 16, 0, 0, 31082, 31083, 7, 12, 0, 0, 31083, 31084, 7, 6, 0, 0, 31084, + 31085, 7, 11, 0, 0, 31085, 31086, 7, 9, 0, 0, 31086, 4704, 1, 0, 0, 0, + 31087, 31088, 7, 7, 0, 0, 31088, 31089, 7, 2, 0, 0, 31089, 31090, 7, 7, + 0, 0, 31090, 31091, 7, 10, 0, 0, 31091, 31092, 7, 11, 0, 0, 31092, 31093, + 7, 11, 0, 0, 31093, 31094, 7, 12, 0, 0, 31094, 31095, 7, 16, 0, 0, 31095, + 4706, 1, 0, 0, 0, 31096, 31097, 7, 15, 0, 0, 31097, 31098, 7, 2, 0, 0, + 31098, 31099, 7, 5, 0, 0, 31099, 31100, 7, 12, 0, 0, 31100, 31101, 7, 4, + 0, 0, 31101, 31102, 7, 12, 0, 0, 31102, 31103, 7, 2, 0, 0, 31103, 31104, + 7, 7, 0, 0, 31104, 4708, 1, 0, 0, 0, 31105, 31106, 7, 7, 0, 0, 31106, 31107, + 7, 6, 0, 0, 31107, 31108, 7, 22, 0, 0, 31108, 31109, 7, 11, 0, 0, 31109, + 31110, 7, 12, 0, 0, 31110, 31111, 7, 7, 0, 0, 31111, 31112, 7, 6, 0, 0, + 31112, 4710, 1, 0, 0, 0, 31113, 31114, 7, 9, 0, 0, 31114, 31115, 7, 6, + 0, 0, 31115, 31116, 7, 4, 0, 0, 31116, 31117, 7, 6, 0, 0, 31117, 31118, + 7, 8, 0, 0, 31118, 31119, 7, 4, 0, 0, 31119, 31120, 7, 6, 0, 0, 31120, + 31121, 7, 9, 0, 0, 31121, 4712, 1, 0, 0, 0, 31122, 31123, 7, 10, 0, 0, + 31123, 31124, 7, 7, 0, 0, 31124, 31125, 7, 5, 0, 0, 31125, 31126, 7, 12, + 0, 0, 31126, 31127, 7, 17, 0, 0, 31127, 31128, 7, 7, 0, 0, 31128, 31129, + 7, 6, 0, 0, 31129, 31130, 7, 9, 0, 0, 31130, 4714, 1, 0, 0, 0, 31131, 31132, + 7, 23, 0, 0, 31132, 31133, 7, 2, 0, 0, 31133, 31134, 7, 7, 0, 0, 31134, + 31135, 7, 6, 0, 0, 31135, 31136, 7, 9, 0, 0, 31136, 4716, 1, 0, 0, 0, 31137, + 31138, 7, 2, 0, 0, 31138, 31139, 7, 3, 0, 0, 31139, 31140, 7, 0, 0, 0, + 31140, 31141, 7, 8, 0, 0, 31141, 31142, 7, 11, 0, 0, 31142, 31143, 7, 6, + 0, 0, 31143, 31144, 5, 95, 0, 0, 31144, 31145, 7, 9, 0, 0, 31145, 31146, + 7, 0, 0, 0, 31146, 31147, 7, 4, 0, 0, 31147, 31148, 7, 6, 0, 0, 31148, + 4718, 1, 0, 0, 0, 31149, 31150, 7, 2, 0, 0, 31150, 31151, 7, 3, 0, 0, 31151, + 31152, 7, 0, 0, 0, 31152, 31153, 7, 8, 0, 0, 31153, 31154, 7, 11, 0, 0, + 31154, 31155, 7, 6, 0, 0, 31155, 31156, 5, 95, 0, 0, 31156, 31157, 7, 7, + 0, 0, 31157, 31158, 7, 10, 0, 0, 31158, 31159, 7, 14, 0, 0, 31159, 31160, + 7, 1, 0, 0, 31160, 31161, 7, 6, 0, 0, 31161, 31162, 7, 3, 0, 0, 31162, + 4720, 1, 0, 0, 0, 31163, 31164, 7, 8, 0, 0, 31164, 31165, 7, 2, 0, 0, 31165, + 31166, 7, 10, 0, 0, 31166, 31167, 7, 7, 0, 0, 31167, 31168, 7, 4, 0, 0, + 31168, 31169, 7, 6, 0, 0, 31169, 31170, 7, 9, 0, 0, 31170, 4722, 1, 0, + 0, 0, 31171, 31172, 7, 13, 0, 0, 31172, 31173, 7, 0, 0, 0, 31173, 31174, + 7, 3, 0, 0, 31174, 31175, 7, 3, 0, 0, 31175, 31176, 7, 0, 0, 0, 31176, + 31177, 7, 22, 0, 0, 31177, 4724, 1, 0, 0, 0, 31178, 31179, 7, 13, 0, 0, + 31179, 31180, 7, 0, 0, 0, 31180, 31181, 7, 3, 0, 0, 31181, 31182, 7, 8, + 0, 0, 31182, 31183, 7, 19, 0, 0, 31183, 31184, 7, 0, 0, 0, 31184, 31185, + 7, 3, 0, 0, 31185, 31186, 7, 8, 0, 0, 31186, 4726, 1, 0, 0, 0, 31187, 31188, + 7, 13, 0, 0, 31188, 31189, 7, 0, 0, 0, 31189, 31190, 7, 3, 0, 0, 31190, + 31191, 7, 3, 0, 0, 31191, 31192, 7, 0, 0, 0, 31192, 31193, 7, 22, 0, 0, + 31193, 31194, 7, 8, 0, 0, 31194, 4728, 1, 0, 0, 0, 31195, 31196, 7, 7, + 0, 0, 31196, 31203, 5, 39, 0, 0, 31197, 31202, 8, 26, 0, 0, 31198, 31199, + 5, 39, 0, 0, 31199, 31202, 5, 39, 0, 0, 31200, 31202, 3, 4883, 2441, 0, + 31201, 31197, 1, 0, 0, 0, 31201, 31198, 1, 0, 0, 0, 31201, 31200, 1, 0, + 0, 0, 31202, 31205, 1, 0, 0, 0, 31203, 31201, 1, 0, 0, 0, 31203, 31204, + 1, 0, 0, 0, 31204, 31206, 1, 0, 0, 0, 31205, 31203, 1, 0, 0, 0, 31206, + 31207, 5, 39, 0, 0, 31207, 4730, 1, 0, 0, 0, 31208, 31217, 7, 1, 0, 0, + 31209, 31213, 5, 39, 0, 0, 31210, 31212, 7, 27, 0, 0, 31211, 31210, 1, + 0, 0, 0, 31212, 31215, 1, 0, 0, 0, 31213, 31211, 1, 0, 0, 0, 31213, 31214, + 1, 0, 0, 0, 31214, 31216, 1, 0, 0, 0, 31215, 31213, 1, 0, 0, 0, 31216, + 31218, 5, 39, 0, 0, 31217, 31209, 1, 0, 0, 0, 31218, 31219, 1, 0, 0, 0, + 31219, 31217, 1, 0, 0, 0, 31219, 31220, 1, 0, 0, 0, 31220, 4732, 1, 0, + 0, 0, 31221, 31230, 7, 25, 0, 0, 31222, 31226, 5, 39, 0, 0, 31223, 31225, + 7, 28, 0, 0, 31224, 31223, 1, 0, 0, 0, 31225, 31228, 1, 0, 0, 0, 31226, + 31224, 1, 0, 0, 0, 31226, 31227, 1, 0, 0, 0, 31227, 31229, 1, 0, 0, 0, + 31228, 31226, 1, 0, 0, 0, 31229, 31231, 5, 39, 0, 0, 31230, 31222, 1, 0, + 0, 0, 31231, 31232, 1, 0, 0, 0, 31232, 31230, 1, 0, 0, 0, 31232, 31233, + 1, 0, 0, 0, 31233, 4734, 1, 0, 0, 0, 31234, 31235, 5, 46, 0, 0, 31235, + 31236, 5, 46, 0, 0, 31236, 4736, 1, 0, 0, 0, 31237, 31238, 5, 46, 0, 0, + 31238, 4738, 1, 0, 0, 0, 31239, 31241, 7, 29, 0, 0, 31240, 31239, 1, 0, + 0, 0, 31241, 31242, 1, 0, 0, 0, 31242, 31240, 1, 0, 0, 0, 31242, 31243, + 1, 0, 0, 0, 31243, 4740, 1, 0, 0, 0, 31244, 31257, 3, 4881, 2440, 0, 31245, + 31247, 7, 6, 0, 0, 31246, 31248, 7, 30, 0, 0, 31247, 31246, 1, 0, 0, 0, + 31247, 31248, 1, 0, 0, 0, 31248, 31255, 1, 0, 0, 0, 31249, 31256, 3, 4881, + 2440, 0, 31250, 31252, 7, 29, 0, 0, 31251, 31250, 1, 0, 0, 0, 31252, 31253, + 1, 0, 0, 0, 31253, 31251, 1, 0, 0, 0, 31253, 31254, 1, 0, 0, 0, 31254, + 31256, 1, 0, 0, 0, 31255, 31249, 1, 0, 0, 0, 31255, 31251, 1, 0, 0, 0, + 31256, 31258, 1, 0, 0, 0, 31257, 31245, 1, 0, 0, 0, 31257, 31258, 1, 0, + 0, 0, 31258, 31260, 1, 0, 0, 0, 31259, 31261, 7, 31, 0, 0, 31260, 31259, + 1, 0, 0, 0, 31260, 31261, 1, 0, 0, 0, 31261, 4742, 1, 0, 0, 0, 31262, 31269, + 5, 39, 0, 0, 31263, 31268, 8, 26, 0, 0, 31264, 31265, 5, 39, 0, 0, 31265, + 31268, 5, 39, 0, 0, 31266, 31268, 3, 4883, 2441, 0, 31267, 31263, 1, 0, + 0, 0, 31267, 31264, 1, 0, 0, 0, 31267, 31266, 1, 0, 0, 0, 31268, 31271, + 1, 0, 0, 0, 31269, 31267, 1, 0, 0, 0, 31269, 31270, 1, 0, 0, 0, 31270, + 31272, 1, 0, 0, 0, 31271, 31269, 1, 0, 0, 0, 31272, 31273, 5, 39, 0, 0, + 31273, 4744, 1, 0, 0, 0, 31274, 31275, 7, 24, 0, 0, 31275, 31304, 5, 39, + 0, 0, 31276, 31305, 3, 4747, 2373, 0, 31277, 31305, 3, 4749, 2374, 0, 31278, + 31305, 3, 4751, 2375, 0, 31279, 31305, 3, 4753, 2376, 0, 31280, 31305, + 3, 4755, 2377, 0, 31281, 31305, 3, 4757, 2378, 0, 31282, 31305, 3, 4759, + 2379, 0, 31283, 31305, 3, 4761, 2380, 0, 31284, 31305, 3, 4763, 2381, 0, + 31285, 31305, 3, 4765, 2382, 0, 31286, 31305, 3, 4767, 2383, 0, 31287, + 31305, 3, 4769, 2384, 0, 31288, 31305, 3, 4771, 2385, 0, 31289, 31305, + 3, 4773, 2386, 0, 31290, 31305, 3, 4775, 2387, 0, 31291, 31305, 3, 4777, + 2388, 0, 31292, 31305, 3, 4779, 2389, 0, 31293, 31305, 3, 4781, 2390, 0, + 31294, 31305, 3, 4783, 2391, 0, 31295, 31305, 3, 4785, 2392, 0, 31296, + 31305, 3, 4787, 2393, 0, 31297, 31305, 3, 4789, 2394, 0, 31298, 31305, + 3, 4791, 2395, 0, 31299, 31305, 3, 4793, 2396, 0, 31300, 31305, 3, 4795, + 2397, 0, 31301, 31305, 3, 4797, 2398, 0, 31302, 31305, 3, 4799, 2399, 0, + 31303, 31305, 3, 4801, 2400, 0, 31304, 31276, 1, 0, 0, 0, 31304, 31277, + 1, 0, 0, 0, 31304, 31278, 1, 0, 0, 0, 31304, 31279, 1, 0, 0, 0, 31304, + 31280, 1, 0, 0, 0, 31304, 31281, 1, 0, 0, 0, 31304, 31282, 1, 0, 0, 0, + 31304, 31283, 1, 0, 0, 0, 31304, 31284, 1, 0, 0, 0, 31304, 31285, 1, 0, + 0, 0, 31304, 31286, 1, 0, 0, 0, 31304, 31287, 1, 0, 0, 0, 31304, 31288, + 1, 0, 0, 0, 31304, 31289, 1, 0, 0, 0, 31304, 31290, 1, 0, 0, 0, 31304, + 31291, 1, 0, 0, 0, 31304, 31292, 1, 0, 0, 0, 31304, 31293, 1, 0, 0, 0, + 31304, 31294, 1, 0, 0, 0, 31304, 31295, 1, 0, 0, 0, 31304, 31296, 1, 0, + 0, 0, 31304, 31297, 1, 0, 0, 0, 31304, 31298, 1, 0, 0, 0, 31304, 31299, + 1, 0, 0, 0, 31304, 31300, 1, 0, 0, 0, 31304, 31301, 1, 0, 0, 0, 31304, + 31302, 1, 0, 0, 0, 31304, 31303, 1, 0, 0, 0, 31305, 31306, 1, 0, 0, 0, + 31306, 31307, 5, 39, 0, 0, 31307, 31308, 1, 0, 0, 0, 31308, 31309, 6, 2372, + 0, 0, 31309, 4746, 1, 0, 0, 0, 31310, 31314, 5, 60, 0, 0, 31311, 31313, + 9, 0, 0, 0, 31312, 31311, 1, 0, 0, 0, 31313, 31316, 1, 0, 0, 0, 31314, + 31315, 1, 0, 0, 0, 31314, 31312, 1, 0, 0, 0, 31315, 31317, 1, 0, 0, 0, + 31316, 31314, 1, 0, 0, 0, 31317, 31318, 5, 62, 0, 0, 31318, 4748, 1, 0, + 0, 0, 31319, 31323, 5, 123, 0, 0, 31320, 31322, 9, 0, 0, 0, 31321, 31320, + 1, 0, 0, 0, 31322, 31325, 1, 0, 0, 0, 31323, 31324, 1, 0, 0, 0, 31323, + 31321, 1, 0, 0, 0, 31324, 31326, 1, 0, 0, 0, 31325, 31323, 1, 0, 0, 0, + 31326, 31327, 5, 125, 0, 0, 31327, 4750, 1, 0, 0, 0, 31328, 31332, 5, 91, + 0, 0, 31329, 31331, 9, 0, 0, 0, 31330, 31329, 1, 0, 0, 0, 31331, 31334, + 1, 0, 0, 0, 31332, 31333, 1, 0, 0, 0, 31332, 31330, 1, 0, 0, 0, 31333, + 31335, 1, 0, 0, 0, 31334, 31332, 1, 0, 0, 0, 31335, 31336, 5, 93, 0, 0, + 31336, 4752, 1, 0, 0, 0, 31337, 31341, 5, 40, 0, 0, 31338, 31340, 9, 0, + 0, 0, 31339, 31338, 1, 0, 0, 0, 31340, 31343, 1, 0, 0, 0, 31341, 31342, + 1, 0, 0, 0, 31341, 31339, 1, 0, 0, 0, 31342, 31344, 1, 0, 0, 0, 31343, + 31341, 1, 0, 0, 0, 31344, 31345, 5, 41, 0, 0, 31345, 4754, 1, 0, 0, 0, + 31346, 31350, 5, 33, 0, 0, 31347, 31349, 9, 0, 0, 0, 31348, 31347, 1, 0, + 0, 0, 31349, 31352, 1, 0, 0, 0, 31350, 31351, 1, 0, 0, 0, 31350, 31348, + 1, 0, 0, 0, 31351, 31353, 1, 0, 0, 0, 31352, 31350, 1, 0, 0, 0, 31353, + 31354, 5, 33, 0, 0, 31354, 4756, 1, 0, 0, 0, 31355, 31359, 5, 35, 0, 0, + 31356, 31358, 9, 0, 0, 0, 31357, 31356, 1, 0, 0, 0, 31358, 31361, 1, 0, + 0, 0, 31359, 31360, 1, 0, 0, 0, 31359, 31357, 1, 0, 0, 0, 31360, 31362, + 1, 0, 0, 0, 31361, 31359, 1, 0, 0, 0, 31362, 31363, 5, 35, 0, 0, 31363, + 4758, 1, 0, 0, 0, 31364, 31368, 5, 39, 0, 0, 31365, 31367, 9, 0, 0, 0, + 31366, 31365, 1, 0, 0, 0, 31367, 31370, 1, 0, 0, 0, 31368, 31369, 1, 0, + 0, 0, 31368, 31366, 1, 0, 0, 0, 31369, 31371, 1, 0, 0, 0, 31370, 31368, + 1, 0, 0, 0, 31371, 31372, 5, 39, 0, 0, 31372, 4760, 1, 0, 0, 0, 31373, + 31377, 5, 34, 0, 0, 31374, 31376, 9, 0, 0, 0, 31375, 31374, 1, 0, 0, 0, + 31376, 31379, 1, 0, 0, 0, 31377, 31378, 1, 0, 0, 0, 31377, 31375, 1, 0, + 0, 0, 31378, 31380, 1, 0, 0, 0, 31379, 31377, 1, 0, 0, 0, 31380, 31381, + 5, 34, 0, 0, 31381, 4762, 1, 0, 0, 0, 31382, 31386, 5, 92, 0, 0, 31383, + 31385, 9, 0, 0, 0, 31384, 31383, 1, 0, 0, 0, 31385, 31388, 1, 0, 0, 0, + 31386, 31387, 1, 0, 0, 0, 31386, 31384, 1, 0, 0, 0, 31387, 31389, 1, 0, + 0, 0, 31388, 31386, 1, 0, 0, 0, 31389, 31390, 5, 92, 0, 0, 31390, 4764, + 1, 0, 0, 0, 31391, 31395, 5, 38, 0, 0, 31392, 31394, 9, 0, 0, 0, 31393, + 31392, 1, 0, 0, 0, 31394, 31397, 1, 0, 0, 0, 31395, 31396, 1, 0, 0, 0, + 31395, 31393, 1, 0, 0, 0, 31396, 31398, 1, 0, 0, 0, 31397, 31395, 1, 0, + 0, 0, 31398, 31399, 5, 38, 0, 0, 31399, 4766, 1, 0, 0, 0, 31400, 31404, + 5, 64, 0, 0, 31401, 31403, 9, 0, 0, 0, 31402, 31401, 1, 0, 0, 0, 31403, + 31406, 1, 0, 0, 0, 31404, 31405, 1, 0, 0, 0, 31404, 31402, 1, 0, 0, 0, + 31405, 31407, 1, 0, 0, 0, 31406, 31404, 1, 0, 0, 0, 31407, 31408, 5, 64, + 0, 0, 31408, 4768, 1, 0, 0, 0, 31409, 31413, 5, 96, 0, 0, 31410, 31412, + 9, 0, 0, 0, 31411, 31410, 1, 0, 0, 0, 31412, 31415, 1, 0, 0, 0, 31413, + 31414, 1, 0, 0, 0, 31413, 31411, 1, 0, 0, 0, 31414, 31416, 1, 0, 0, 0, + 31415, 31413, 1, 0, 0, 0, 31416, 31417, 5, 96, 0, 0, 31417, 4770, 1, 0, + 0, 0, 31418, 31422, 5, 94, 0, 0, 31419, 31421, 9, 0, 0, 0, 31420, 31419, + 1, 0, 0, 0, 31421, 31424, 1, 0, 0, 0, 31422, 31423, 1, 0, 0, 0, 31422, + 31420, 1, 0, 0, 0, 31423, 31425, 1, 0, 0, 0, 31424, 31422, 1, 0, 0, 0, + 31425, 31426, 5, 94, 0, 0, 31426, 4772, 1, 0, 0, 0, 31427, 31431, 5, 58, + 0, 0, 31428, 31430, 9, 0, 0, 0, 31429, 31428, 1, 0, 0, 0, 31430, 31433, + 1, 0, 0, 0, 31431, 31432, 1, 0, 0, 0, 31431, 31429, 1, 0, 0, 0, 31432, + 31434, 1, 0, 0, 0, 31433, 31431, 1, 0, 0, 0, 31434, 31435, 5, 58, 0, 0, + 31435, 4774, 1, 0, 0, 0, 31436, 31440, 5, 44, 0, 0, 31437, 31439, 9, 0, + 0, 0, 31438, 31437, 1, 0, 0, 0, 31439, 31442, 1, 0, 0, 0, 31440, 31441, + 1, 0, 0, 0, 31440, 31438, 1, 0, 0, 0, 31441, 31443, 1, 0, 0, 0, 31442, + 31440, 1, 0, 0, 0, 31443, 31444, 5, 44, 0, 0, 31444, 4776, 1, 0, 0, 0, + 31445, 31449, 5, 42, 0, 0, 31446, 31448, 9, 0, 0, 0, 31447, 31446, 1, 0, + 0, 0, 31448, 31451, 1, 0, 0, 0, 31449, 31450, 1, 0, 0, 0, 31449, 31447, + 1, 0, 0, 0, 31450, 31452, 1, 0, 0, 0, 31451, 31449, 1, 0, 0, 0, 31452, + 31453, 5, 42, 0, 0, 31453, 4778, 1, 0, 0, 0, 31454, 31458, 5, 36, 0, 0, + 31455, 31457, 9, 0, 0, 0, 31456, 31455, 1, 0, 0, 0, 31457, 31460, 1, 0, + 0, 0, 31458, 31459, 1, 0, 0, 0, 31458, 31456, 1, 0, 0, 0, 31459, 31461, + 1, 0, 0, 0, 31460, 31458, 1, 0, 0, 0, 31461, 31462, 5, 36, 0, 0, 31462, + 4780, 1, 0, 0, 0, 31463, 31467, 5, 61, 0, 0, 31464, 31466, 9, 0, 0, 0, + 31465, 31464, 1, 0, 0, 0, 31466, 31469, 1, 0, 0, 0, 31467, 31468, 1, 0, + 0, 0, 31467, 31465, 1, 0, 0, 0, 31468, 31470, 1, 0, 0, 0, 31469, 31467, + 1, 0, 0, 0, 31470, 31471, 5, 61, 0, 0, 31471, 4782, 1, 0, 0, 0, 31472, + 31476, 5, 45, 0, 0, 31473, 31475, 9, 0, 0, 0, 31474, 31473, 1, 0, 0, 0, + 31475, 31478, 1, 0, 0, 0, 31476, 31477, 1, 0, 0, 0, 31476, 31474, 1, 0, + 0, 0, 31477, 31479, 1, 0, 0, 0, 31478, 31476, 1, 0, 0, 0, 31479, 31480, + 5, 45, 0, 0, 31480, 4784, 1, 0, 0, 0, 31481, 31485, 5, 37, 0, 0, 31482, + 31484, 9, 0, 0, 0, 31483, 31482, 1, 0, 0, 0, 31484, 31487, 1, 0, 0, 0, + 31485, 31486, 1, 0, 0, 0, 31485, 31483, 1, 0, 0, 0, 31486, 31488, 1, 0, + 0, 0, 31487, 31485, 1, 0, 0, 0, 31488, 31489, 5, 37, 0, 0, 31489, 4786, + 1, 0, 0, 0, 31490, 31494, 5, 43, 0, 0, 31491, 31493, 9, 0, 0, 0, 31492, + 31491, 1, 0, 0, 0, 31493, 31496, 1, 0, 0, 0, 31494, 31495, 1, 0, 0, 0, + 31494, 31492, 1, 0, 0, 0, 31495, 31497, 1, 0, 0, 0, 31496, 31494, 1, 0, + 0, 0, 31497, 31498, 5, 43, 0, 0, 31498, 4788, 1, 0, 0, 0, 31499, 31503, + 5, 46, 0, 0, 31500, 31502, 9, 0, 0, 0, 31501, 31500, 1, 0, 0, 0, 31502, + 31505, 1, 0, 0, 0, 31503, 31504, 1, 0, 0, 0, 31503, 31501, 1, 0, 0, 0, + 31504, 31506, 1, 0, 0, 0, 31505, 31503, 1, 0, 0, 0, 31506, 31507, 5, 46, + 0, 0, 31507, 4790, 1, 0, 0, 0, 31508, 31512, 5, 59, 0, 0, 31509, 31511, + 9, 0, 0, 0, 31510, 31509, 1, 0, 0, 0, 31511, 31514, 1, 0, 0, 0, 31512, + 31513, 1, 0, 0, 0, 31512, 31510, 1, 0, 0, 0, 31513, 31515, 1, 0, 0, 0, + 31514, 31512, 1, 0, 0, 0, 31515, 31516, 5, 59, 0, 0, 31516, 4792, 1, 0, + 0, 0, 31517, 31521, 5, 47, 0, 0, 31518, 31520, 9, 0, 0, 0, 31519, 31518, + 1, 0, 0, 0, 31520, 31523, 1, 0, 0, 0, 31521, 31522, 1, 0, 0, 0, 31521, + 31519, 1, 0, 0, 0, 31522, 31524, 1, 0, 0, 0, 31523, 31521, 1, 0, 0, 0, + 31524, 31525, 5, 47, 0, 0, 31525, 4794, 1, 0, 0, 0, 31526, 31530, 5, 95, + 0, 0, 31527, 31529, 9, 0, 0, 0, 31528, 31527, 1, 0, 0, 0, 31529, 31532, + 1, 0, 0, 0, 31530, 31531, 1, 0, 0, 0, 31530, 31528, 1, 0, 0, 0, 31531, + 31533, 1, 0, 0, 0, 31532, 31530, 1, 0, 0, 0, 31533, 31534, 5, 95, 0, 0, + 31534, 4796, 1, 0, 0, 0, 31535, 31539, 5, 124, 0, 0, 31536, 31538, 9, 0, + 0, 0, 31537, 31536, 1, 0, 0, 0, 31538, 31541, 1, 0, 0, 0, 31539, 31540, + 1, 0, 0, 0, 31539, 31537, 1, 0, 0, 0, 31540, 31542, 1, 0, 0, 0, 31541, + 31539, 1, 0, 0, 0, 31542, 31543, 5, 124, 0, 0, 31543, 4798, 1, 0, 0, 0, + 31544, 31548, 5, 126, 0, 0, 31545, 31547, 9, 0, 0, 0, 31546, 31545, 1, + 0, 0, 0, 31547, 31550, 1, 0, 0, 0, 31548, 31549, 1, 0, 0, 0, 31548, 31546, + 1, 0, 0, 0, 31549, 31551, 1, 0, 0, 0, 31550, 31548, 1, 0, 0, 0, 31551, + 31552, 5, 126, 0, 0, 31552, 4800, 1, 0, 0, 0, 31553, 31557, 5, 63, 0, 0, + 31554, 31556, 9, 0, 0, 0, 31555, 31554, 1, 0, 0, 0, 31556, 31559, 1, 0, + 0, 0, 31557, 31558, 1, 0, 0, 0, 31557, 31555, 1, 0, 0, 0, 31558, 31560, + 1, 0, 0, 0, 31559, 31557, 1, 0, 0, 0, 31560, 31561, 5, 63, 0, 0, 31561, + 4802, 1, 0, 0, 0, 31562, 31566, 5, 34, 0, 0, 31563, 31567, 8, 32, 0, 0, + 31564, 31565, 5, 34, 0, 0, 31565, 31567, 5, 34, 0, 0, 31566, 31563, 1, + 0, 0, 0, 31566, 31564, 1, 0, 0, 0, 31567, 31568, 1, 0, 0, 0, 31568, 31566, + 1, 0, 0, 0, 31568, 31569, 1, 0, 0, 0, 31569, 31570, 1, 0, 0, 0, 31570, + 31571, 5, 34, 0, 0, 31571, 4804, 1, 0, 0, 0, 31572, 31573, 5, 37, 0, 0, + 31573, 4806, 1, 0, 0, 0, 31574, 31575, 5, 38, 0, 0, 31575, 4808, 1, 0, + 0, 0, 31576, 31577, 5, 40, 0, 0, 31577, 4810, 1, 0, 0, 0, 31578, 31579, + 5, 41, 0, 0, 31579, 4812, 1, 0, 0, 0, 31580, 31581, 5, 42, 0, 0, 31581, + 31582, 5, 42, 0, 0, 31582, 4814, 1, 0, 0, 0, 31583, 31584, 5, 42, 0, 0, + 31584, 4816, 1, 0, 0, 0, 31585, 31586, 5, 43, 0, 0, 31586, 4818, 1, 0, + 0, 0, 31587, 31588, 5, 45, 0, 0, 31588, 4820, 1, 0, 0, 0, 31589, 31590, + 5, 44, 0, 0, 31590, 4822, 1, 0, 0, 0, 31591, 31592, 5, 47, 0, 0, 31592, + 4824, 1, 0, 0, 0, 31593, 31594, 5, 64, 0, 0, 31594, 4826, 1, 0, 0, 0, 31595, + 31596, 5, 58, 0, 0, 31596, 31597, 5, 61, 0, 0, 31597, 4828, 1, 0, 0, 0, + 31598, 31599, 5, 35, 0, 0, 31599, 4830, 1, 0, 0, 0, 31600, 31601, 5, 39, + 0, 0, 31601, 4832, 1, 0, 0, 0, 31602, 31603, 5, 58, 0, 0, 31603, 31608, + 3, 4879, 2439, 0, 31604, 31607, 3, 4879, 2439, 0, 31605, 31607, 7, 33, + 0, 0, 31606, 31604, 1, 0, 0, 0, 31606, 31605, 1, 0, 0, 0, 31607, 31610, + 1, 0, 0, 0, 31608, 31606, 1, 0, 0, 0, 31608, 31609, 1, 0, 0, 0, 31609, + 31617, 1, 0, 0, 0, 31610, 31608, 1, 0, 0, 0, 31611, 31612, 5, 58, 0, 0, + 31612, 31617, 3, 4803, 2401, 0, 31613, 31614, 5, 58, 0, 0, 31614, 31617, + 3, 4739, 2369, 0, 31615, 31617, 3, 4877, 2438, 0, 31616, 31602, 1, 0, 0, + 0, 31616, 31611, 1, 0, 0, 0, 31616, 31613, 1, 0, 0, 0, 31616, 31615, 1, + 0, 0, 0, 31617, 4834, 1, 0, 0, 0, 31618, 31619, 5, 33, 0, 0, 31619, 31627, + 5, 61, 0, 0, 31620, 31621, 5, 60, 0, 0, 31621, 31627, 5, 62, 0, 0, 31622, + 31623, 5, 94, 0, 0, 31623, 31627, 5, 61, 0, 0, 31624, 31625, 5, 126, 0, + 0, 31625, 31627, 5, 61, 0, 0, 31626, 31618, 1, 0, 0, 0, 31626, 31620, 1, + 0, 0, 0, 31626, 31622, 1, 0, 0, 0, 31626, 31624, 1, 0, 0, 0, 31627, 4836, + 1, 0, 0, 0, 31628, 31629, 5, 94, 0, 0, 31629, 4838, 1, 0, 0, 0, 31630, + 31631, 5, 126, 0, 0, 31631, 4840, 1, 0, 0, 0, 31632, 31633, 5, 33, 0, 0, + 31633, 4842, 1, 0, 0, 0, 31634, 31635, 5, 62, 0, 0, 31635, 4844, 1, 0, + 0, 0, 31636, 31637, 5, 60, 0, 0, 31637, 4846, 1, 0, 0, 0, 31638, 31639, + 5, 58, 0, 0, 31639, 4848, 1, 0, 0, 0, 31640, 31641, 5, 59, 0, 0, 31641, + 4850, 1, 0, 0, 0, 31642, 31643, 5, 124, 0, 0, 31643, 4852, 1, 0, 0, 0, + 31644, 31645, 5, 61, 0, 0, 31645, 4854, 1, 0, 0, 0, 31646, 31647, 5, 91, + 0, 0, 31647, 4856, 1, 0, 0, 0, 31648, 31649, 5, 93, 0, 0, 31649, 4858, + 1, 0, 0, 0, 31650, 31651, 5, 95, 0, 0, 31651, 4860, 1, 0, 0, 0, 31652, + 31653, 5, 45, 0, 0, 31653, 31654, 5, 45, 0, 0, 31654, 31658, 1, 0, 0, 0, + 31655, 31657, 8, 34, 0, 0, 31656, 31655, 1, 0, 0, 0, 31657, 31660, 1, 0, + 0, 0, 31658, 31656, 1, 0, 0, 0, 31658, 31659, 1, 0, 0, 0, 31659, 31661, + 1, 0, 0, 0, 31660, 31658, 1, 0, 0, 0, 31661, 31662, 3, 4875, 2437, 0, 31662, + 31663, 1, 0, 0, 0, 31663, 31664, 6, 2430, 1, 0, 31664, 4862, 1, 0, 0, 0, + 31665, 31666, 5, 47, 0, 0, 31666, 31667, 5, 42, 0, 0, 31667, 31671, 1, + 0, 0, 0, 31668, 31670, 9, 0, 0, 0, 31669, 31668, 1, 0, 0, 0, 31670, 31673, + 1, 0, 0, 0, 31671, 31672, 1, 0, 0, 0, 31671, 31669, 1, 0, 0, 0, 31672, + 31674, 1, 0, 0, 0, 31673, 31671, 1, 0, 0, 0, 31674, 31675, 5, 42, 0, 0, + 31675, 31676, 5, 47, 0, 0, 31676, 31677, 1, 0, 0, 0, 31677, 31678, 6, 2431, + 1, 0, 31678, 4864, 1, 0, 0, 0, 31679, 31680, 7, 3, 0, 0, 31680, 31681, + 7, 6, 0, 0, 31681, 31682, 7, 14, 0, 0, 31682, 31683, 1, 0, 0, 0, 31683, + 31687, 4, 2432, 0, 0, 31684, 31685, 7, 0, 0, 0, 31685, 31686, 7, 3, 0, + 0, 31686, 31688, 7, 21, 0, 0, 31687, 31684, 1, 0, 0, 0, 31687, 31688, 1, + 0, 0, 0, 31688, 31696, 1, 0, 0, 0, 31689, 31693, 5, 32, 0, 0, 31690, 31692, + 8, 34, 0, 0, 31691, 31690, 1, 0, 0, 0, 31692, 31695, 1, 0, 0, 0, 31693, + 31691, 1, 0, 0, 0, 31693, 31694, 1, 0, 0, 0, 31694, 31697, 1, 0, 0, 0, + 31695, 31693, 1, 0, 0, 0, 31696, 31689, 1, 0, 0, 0, 31696, 31697, 1, 0, + 0, 0, 31697, 31698, 1, 0, 0, 0, 31698, 31699, 3, 4875, 2437, 0, 31699, + 31700, 1, 0, 0, 0, 31700, 31701, 6, 2432, 1, 0, 31701, 4866, 1, 0, 0, 0, + 31702, 31703, 7, 15, 0, 0, 31703, 31704, 7, 3, 0, 0, 31704, 31705, 7, 2, + 0, 0, 31705, 31706, 1, 0, 0, 0, 31706, 31710, 4, 2433, 1, 0, 31707, 31708, + 7, 14, 0, 0, 31708, 31709, 7, 15, 0, 0, 31709, 31711, 7, 4, 0, 0, 31710, + 31707, 1, 0, 0, 0, 31710, 31711, 1, 0, 0, 0, 31711, 31719, 1, 0, 0, 0, + 31712, 31716, 5, 32, 0, 0, 31713, 31715, 8, 34, 0, 0, 31714, 31713, 1, + 0, 0, 0, 31715, 31718, 1, 0, 0, 0, 31716, 31714, 1, 0, 0, 0, 31716, 31717, + 1, 0, 0, 0, 31717, 31720, 1, 0, 0, 0, 31718, 31716, 1, 0, 0, 0, 31719, + 31712, 1, 0, 0, 0, 31719, 31720, 1, 0, 0, 0, 31720, 31721, 1, 0, 0, 0, + 31721, 31722, 3, 4875, 2437, 0, 31722, 4868, 1, 0, 0, 0, 31723, 31724, + 5, 64, 0, 0, 31724, 31726, 4, 2434, 2, 0, 31725, 31727, 5, 64, 0, 0, 31726, + 31725, 1, 0, 0, 0, 31726, 31727, 1, 0, 0, 0, 31727, 31731, 1, 0, 0, 0, + 31728, 31730, 8, 34, 0, 0, 31729, 31728, 1, 0, 0, 0, 31730, 31733, 1, 0, + 0, 0, 31731, 31729, 1, 0, 0, 0, 31731, 31732, 1, 0, 0, 0, 31732, 31734, + 1, 0, 0, 0, 31733, 31731, 1, 0, 0, 0, 31734, 31735, 3, 4875, 2437, 0, 31735, + 4870, 1, 0, 0, 0, 31736, 31739, 3, 4879, 2439, 0, 31737, 31739, 3, 4887, + 2443, 0, 31738, 31736, 1, 0, 0, 0, 31738, 31737, 1, 0, 0, 0, 31739, 31745, + 1, 0, 0, 0, 31740, 31744, 3, 4879, 2439, 0, 31741, 31744, 3, 4887, 2443, + 0, 31742, 31744, 7, 35, 0, 0, 31743, 31740, 1, 0, 0, 0, 31743, 31741, 1, + 0, 0, 0, 31743, 31742, 1, 0, 0, 0, 31744, 31747, 1, 0, 0, 0, 31745, 31743, + 1, 0, 0, 0, 31745, 31746, 1, 0, 0, 0, 31746, 4872, 1, 0, 0, 0, 31747, 31745, + 1, 0, 0, 0, 31748, 31749, 7, 36, 0, 0, 31749, 31750, 1, 0, 0, 0, 31750, + 31751, 6, 2436, 1, 0, 31751, 4874, 1, 0, 0, 0, 31752, 31755, 3, 4883, 2441, + 0, 31753, 31755, 5, 0, 0, 1, 31754, 31752, 1, 0, 0, 0, 31754, 31753, 1, + 0, 0, 0, 31755, 4876, 1, 0, 0, 0, 31756, 31757, 5, 63, 0, 0, 31757, 4878, + 1, 0, 0, 0, 31758, 31759, 7, 37, 0, 0, 31759, 4880, 1, 0, 0, 0, 31760, + 31762, 3, 4739, 2369, 0, 31761, 31760, 1, 0, 0, 0, 31762, 31765, 1, 0, + 0, 0, 31763, 31761, 1, 0, 0, 0, 31763, 31764, 1, 0, 0, 0, 31764, 31767, + 1, 0, 0, 0, 31765, 31763, 1, 0, 0, 0, 31766, 31768, 5, 46, 0, 0, 31767, + 31766, 1, 0, 0, 0, 31767, 31768, 1, 0, 0, 0, 31768, 31770, 1, 0, 0, 0, + 31769, 31771, 3, 4739, 2369, 0, 31770, 31769, 1, 0, 0, 0, 31771, 31772, + 1, 0, 0, 0, 31772, 31770, 1, 0, 0, 0, 31772, 31773, 1, 0, 0, 0, 31773, + 4882, 1, 0, 0, 0, 31774, 31776, 5, 13, 0, 0, 31775, 31774, 1, 0, 0, 0, + 31775, 31776, 1, 0, 0, 0, 31776, 31777, 1, 0, 0, 0, 31777, 31778, 5, 10, + 0, 0, 31778, 4884, 1, 0, 0, 0, 31779, 31780, 7, 38, 0, 0, 31780, 4886, + 1, 0, 0, 0, 31781, 31782, 7, 39, 0, 0, 31782, 4888, 1, 0, 0, 0, 74, 0, + 18898, 18911, 18925, 18963, 18979, 18994, 31201, 31203, 31213, 31219, 31226, + 31232, 31242, 31247, 31253, 31255, 31257, 31260, 31267, 31269, 31304, 31314, + 31323, 31332, 31341, 31350, 31359, 31368, 31377, 31386, 31395, 31404, 31413, + 31422, 31431, 31440, 31449, 31458, 31467, 31476, 31485, 31494, 31503, 31512, + 31521, 31530, 31539, 31548, 31557, 31566, 31568, 31606, 31608, 31616, 31626, + 31658, 31671, 31687, 31693, 31696, 31710, 31716, 31719, 31726, 31731, 31738, + 31743, 31745, 31754, 31763, 31767, 31772, 31775, 2, 7, 2372, 0, 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) + } +} + +// PlSqlLexerInit initializes any static state used to implement PlSqlLexer. By default the +// static state used to implement the lexer is lazily initialized during the first call to +// NewPlSqlLexer(). You can call this function if you wish to initialize the static state ahead +// of time. +func PlSqlLexerInit() { + staticData := &PlSqlLexerLexerStaticData + staticData.once.Do(plsqllexerLexerInit) +} + +// NewPlSqlLexer produces a new lexer instance for the optional input antlr.CharStream. +func NewPlSqlLexer(input antlr.CharStream) *PlSqlLexer { + PlSqlLexerInit() + l := new(PlSqlLexer) + l.BaseLexer = antlr.NewBaseLexer(input) + staticData := &PlSqlLexerLexerStaticData + 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 = "PlSqlLexer.g4" + // TODO: l.EOF = antlr.TokenEOF + + return l +} + +// PlSqlLexer tokens. +const ( + PlSqlLexerABORT = 1 + PlSqlLexerABS = 2 + PlSqlLexerABSENT = 3 + PlSqlLexerACCESS = 4 + PlSqlLexerACCESSED = 5 + PlSqlLexerACCOUNT = 6 + PlSqlLexerACL = 7 + PlSqlLexerACOS = 8 + PlSqlLexerACROSS = 9 + PlSqlLexerACTION = 10 + PlSqlLexerACTIONS = 11 + PlSqlLexerACTIVATE = 12 + PlSqlLexerACTIVE = 13 + PlSqlLexerACTIVE_COMPONENT = 14 + PlSqlLexerACTIVE_DATA = 15 + PlSqlLexerACTIVE_FUNCTION = 16 + PlSqlLexerACTIVE_TAG = 17 + PlSqlLexerACTIVITY = 18 + PlSqlLexerADAPTIVE_PLAN = 19 + PlSqlLexerADD = 20 + PlSqlLexerADD_COLUMN = 21 + PlSqlLexerADD_GROUP = 22 + PlSqlLexerADD_MONTHS = 23 + PlSqlLexerADJ_DATE = 24 + PlSqlLexerADMIN = 25 + PlSqlLexerADMINISTER = 26 + PlSqlLexerADMINISTRATOR = 27 + PlSqlLexerADVANCED = 28 + PlSqlLexerADVISE = 29 + PlSqlLexerADVISOR = 30 + PlSqlLexerAFD_DISKSTRING = 31 + PlSqlLexerAFTER = 32 + PlSqlLexerAGENT = 33 + PlSqlLexerAGGREGATE = 34 + PlSqlLexerA_LETTER = 35 + PlSqlLexerALIAS = 36 + PlSqlLexerALL = 37 + PlSqlLexerALLOCATE = 38 + PlSqlLexerALLOW = 39 + PlSqlLexerALL_ROWS = 40 + PlSqlLexerALTER = 41 + PlSqlLexerALTERNATE = 42 + PlSqlLexerALWAYS = 43 + PlSqlLexerANALYTIC = 44 + PlSqlLexerANALYZE = 45 + PlSqlLexerANCESTOR = 46 + PlSqlLexerANCILLARY = 47 + PlSqlLexerAND = 48 + PlSqlLexerAND_EQUAL = 49 + PlSqlLexerANOMALY = 50 + PlSqlLexerANSI_REARCH = 51 + PlSqlLexerANTIJOIN = 52 + PlSqlLexerANY = 53 + PlSqlLexerANYSCHEMA = 54 + PlSqlLexerAPPEND = 55 + PlSqlLexerAPPENDCHILDXML = 56 + PlSqlLexerAPPEND_VALUES = 57 + PlSqlLexerAPPLICATION = 58 + PlSqlLexerAPPLY = 59 + PlSqlLexerAPPROX_COUNT_DISTINCT = 60 + PlSqlLexerARCHIVAL = 61 + PlSqlLexerARCHIVE = 62 + PlSqlLexerARCHIVED = 63 + PlSqlLexerARCHIVELOG = 64 + PlSqlLexerARRAY = 65 + PlSqlLexerAS = 66 + PlSqlLexerASC = 67 + PlSqlLexerASCII = 68 + PlSqlLexerASCIISTR = 69 + PlSqlLexerASIN = 70 + PlSqlLexerASIS = 71 + PlSqlLexerASSEMBLY = 72 + PlSqlLexerASSIGN = 73 + PlSqlLexerASSOCIATE = 74 + PlSqlLexerASYNC = 75 + PlSqlLexerASYNCHRONOUS = 76 + PlSqlLexerATAN2 = 77 + PlSqlLexerATAN = 78 + PlSqlLexerAT = 79 + PlSqlLexerATTRIBUTE = 80 + PlSqlLexerATTRIBUTES = 81 + PlSqlLexerAUDIT = 82 + PlSqlLexerAUTHENTICATED = 83 + PlSqlLexerAUTHENTICATION = 84 + PlSqlLexerAUTHID = 85 + PlSqlLexerAUTHORIZATION = 86 + PlSqlLexerAUTOALLOCATE = 87 + PlSqlLexerAUTO = 88 + PlSqlLexerAUTOEXTEND = 89 + PlSqlLexerAUTO_LOGIN = 90 + PlSqlLexerAUTOMATIC = 91 + PlSqlLexerAUTONOMOUS_TRANSACTION = 92 + PlSqlLexerAUTO_REOPTIMIZE = 93 + PlSqlLexerAVAILABILITY = 94 + PlSqlLexerAVRO = 95 + PlSqlLexerBACKGROUND = 96 + PlSqlLexerBACKINGFILE = 97 + PlSqlLexerBACKUP = 98 + PlSqlLexerBACKUPS = 99 + PlSqlLexerBASIC = 100 + PlSqlLexerBASICFILE = 101 + PlSqlLexerBATCH = 102 + PlSqlLexerBATCHSIZE = 103 + PlSqlLexerBATCH_TABLE_ACCESS_BY_ROWID = 104 + PlSqlLexerBECOME = 105 + PlSqlLexerBEFORE = 106 + PlSqlLexerBEGIN = 107 + PlSqlLexerBEGINNING = 108 + PlSqlLexerBEGIN_OUTLINE_DATA = 109 + PlSqlLexerBEHALF = 110 + PlSqlLexerBEQUEATH = 111 + PlSqlLexerBETWEEN = 112 + PlSqlLexerBFILE = 113 + PlSqlLexerBFILENAME = 114 + PlSqlLexerBIGFILE = 115 + PlSqlLexerBINARY = 116 + PlSqlLexerBINARY_DOUBLE = 117 + PlSqlLexerBINARY_DOUBLE_INFINITY = 118 + PlSqlLexerBINARY_DOUBLE_NAN = 119 + PlSqlLexerBINARY_FLOAT = 120 + PlSqlLexerBINARY_FLOAT_INFINITY = 121 + PlSqlLexerBINARY_FLOAT_NAN = 122 + PlSqlLexerBINARY_INTEGER = 123 + PlSqlLexerBIND_AWARE = 124 + PlSqlLexerBINDING = 125 + PlSqlLexerBIN_TO_NUM = 126 + PlSqlLexerBITAND = 127 + PlSqlLexerBITMAP_AND = 128 + PlSqlLexerBITMAP = 129 + PlSqlLexerBITMAPS = 130 + PlSqlLexerBITMAP_TREE = 131 + PlSqlLexerBITS = 132 + PlSqlLexerBLOB = 133 + PlSqlLexerBLOCK = 134 + PlSqlLexerBLOCK_RANGE = 135 + PlSqlLexerBLOCKS = 136 + PlSqlLexerBLOCKSIZE = 137 + PlSqlLexerBODY = 138 + PlSqlLexerBOOLEAN = 139 + PlSqlLexerBOTH = 140 + PlSqlLexerBOUND = 141 + PlSqlLexerBRANCH = 142 + PlSqlLexerBREADTH = 143 + PlSqlLexerBROADCAST = 144 + PlSqlLexerBSON = 145 + PlSqlLexerBUFFER = 146 + PlSqlLexerBUFFER_CACHE = 147 + PlSqlLexerBUFFER_POOL = 148 + PlSqlLexerBUILD = 149 + PlSqlLexerBULK = 150 + PlSqlLexerBY = 151 + PlSqlLexerBYPASS_RECURSIVE_CHECK = 152 + PlSqlLexerBYPASS_UJVC = 153 + PlSqlLexerBYTE = 154 + PlSqlLexerCACHE = 155 + PlSqlLexerCACHE_CB = 156 + PlSqlLexerCACHE_INSTANCES = 157 + PlSqlLexerCACHE_TEMP_TABLE = 158 + PlSqlLexerCACHING = 159 + PlSqlLexerCALCULATED = 160 + PlSqlLexerCALLBACK = 161 + PlSqlLexerCALL = 162 + PlSqlLexerCANCEL = 163 + PlSqlLexerCANONICAL = 164 + PlSqlLexerCAPACITY = 165 + PlSqlLexerCAPTION = 166 + PlSqlLexerCARDINALITY = 167 + PlSqlLexerCASCADE = 168 + PlSqlLexerCASE = 169 + PlSqlLexerCAST = 170 + PlSqlLexerCASESENSITIVE = 171 + PlSqlLexerCATEGORY = 172 + PlSqlLexerCDBDEFAULT = 173 + PlSqlLexerCEIL = 174 + PlSqlLexerCELL_FLASH_CACHE = 175 + PlSqlLexerCERTIFICATE = 176 + PlSqlLexerCFILE = 177 + PlSqlLexerCHAINED = 178 + PlSqlLexerCHANGE = 179 + PlSqlLexerCHANGE_DUPKEY_ERROR_INDEX = 180 + PlSqlLexerCHARACTER = 181 + PlSqlLexerCHAR = 182 + PlSqlLexerCHAR_CS = 183 + PlSqlLexerCHARTOROWID = 184 + PlSqlLexerCHECK_ACL_REWRITE = 185 + PlSqlLexerCHECK = 186 + PlSqlLexerCHECKPOINT = 187 + PlSqlLexerCHILD = 188 + PlSqlLexerCHOOSE = 189 + PlSqlLexerCHR = 190 + PlSqlLexerCHUNK = 191 + PlSqlLexerCLASS = 192 + PlSqlLexerCLASSIFICATION = 193 + PlSqlLexerCLASSIFIER = 194 + PlSqlLexerCLAUSE = 195 + PlSqlLexerCLEAN = 196 + PlSqlLexerCLEANUP = 197 + PlSqlLexerCLEAR = 198 + PlSqlLexerC_LETTER = 199 + PlSqlLexerCLIENT = 200 + PlSqlLexerCLOB = 201 + PlSqlLexerCLONE = 202 + PlSqlLexerCLOSE_CACHED_OPEN_CURSORS = 203 + PlSqlLexerCLOSE = 204 + PlSqlLexerCLUSTER_BY_ROWID = 205 + PlSqlLexerCLUSTER = 206 + PlSqlLexerCLUSTER_DETAILS = 207 + PlSqlLexerCLUSTER_DISTANCE = 208 + PlSqlLexerCLUSTER_ID = 209 + PlSqlLexerCLUSTERING = 210 + PlSqlLexerCLUSTERING_FACTOR = 211 + PlSqlLexerCLUSTER_PROBABILITY = 212 + PlSqlLexerCLUSTER_SET = 213 + PlSqlLexerCOALESCE = 214 + PlSqlLexerCOALESCE_SQ = 215 + PlSqlLexerCOARSE = 216 + PlSqlLexerCO_AUTH_IND = 217 + PlSqlLexerCOLD = 218 + PlSqlLexerCOLLECT = 219 + PlSqlLexerCOLUMNAR = 220 + PlSqlLexerCOLUMN_AUTH_INDICATOR = 221 + PlSqlLexerCOLUMN = 222 + PlSqlLexerCOLUMNS = 223 + PlSqlLexerCOLUMN_STATS = 224 + PlSqlLexerCOLUMN_VALUE = 225 + PlSqlLexerCOMMENT = 226 + PlSqlLexerCOMMIT = 227 + PlSqlLexerCOMMITTED = 228 + PlSqlLexerCOMMON = 229 + PlSqlLexerCOMMON_DATA = 230 + PlSqlLexerCOMPACT = 231 + PlSqlLexerCOMPATIBILITY = 232 + PlSqlLexerCOMPILE = 233 + PlSqlLexerCOMPLETE = 234 + PlSqlLexerCOMPLIANCE = 235 + PlSqlLexerCOMPONENT = 236 + PlSqlLexerCOMPONENTS = 237 + PlSqlLexerCOMPOSE = 238 + PlSqlLexerCOMPOSITE = 239 + PlSqlLexerCOMPOSITE_LIMIT = 240 + PlSqlLexerCOMPOUND = 241 + PlSqlLexerCOMPRESS = 242 + PlSqlLexerCOMPUTE = 243 + PlSqlLexerCONCAT = 244 + PlSqlLexerCON_DBID_TO_ID = 245 + PlSqlLexerCONDITIONAL = 246 + PlSqlLexerCONDITION = 247 + PlSqlLexerCONFIRM = 248 + PlSqlLexerCONFORMING = 249 + PlSqlLexerCON_GUID_TO_ID = 250 + PlSqlLexerCON_ID = 251 + PlSqlLexerCON_NAME_TO_ID = 252 + PlSqlLexerCONNECT_BY_CB_WHR_ONLY = 253 + PlSqlLexerCONNECT_BY_COMBINE_SW = 254 + PlSqlLexerCONNECT_BY_COST_BASED = 255 + PlSqlLexerCONNECT_BY_ELIM_DUPS = 256 + PlSqlLexerCONNECT_BY_FILTERING = 257 + PlSqlLexerCONNECT_BY_ISCYCLE = 258 + PlSqlLexerCONNECT_BY_ISLEAF = 259 + PlSqlLexerCONNECT_BY_ROOT = 260 + PlSqlLexerCONNECT = 261 + PlSqlLexerCONNECT_TIME = 262 + PlSqlLexerCONSIDER = 263 + PlSqlLexerCONSISTENT = 264 + PlSqlLexerCONSTANT = 265 + PlSqlLexerCONST = 266 + PlSqlLexerCONSTRAINT = 267 + PlSqlLexerCONSTRAINTS = 268 + PlSqlLexerCONSTRUCTOR = 269 + PlSqlLexerCONTAINER = 270 + PlSqlLexerCONTAINERS = 271 + PlSqlLexerCONTAINERS_DEFAULT = 272 + PlSqlLexerCONTAINER_DATA = 273 + PlSqlLexerCONTAINER_MAP = 274 + PlSqlLexerCONTENT = 275 + PlSqlLexerCONTENTS = 276 + PlSqlLexerCONTEXT = 277 + PlSqlLexerCONTINUE = 278 + PlSqlLexerCONTROLFILE = 279 + PlSqlLexerCON_UID_TO_ID = 280 + PlSqlLexerCONVERT = 281 + PlSqlLexerCONVERSION = 282 + PlSqlLexerCOOKIE = 283 + PlSqlLexerCOPY = 284 + PlSqlLexerCORR_K = 285 + PlSqlLexerCORR_S = 286 + PlSqlLexerCORRUPTION = 287 + PlSqlLexerCORRUPT_XID_ALL = 288 + PlSqlLexerCORRUPT_XID = 289 + PlSqlLexerCOS = 290 + PlSqlLexerCOSH = 291 + PlSqlLexerCOST = 292 + PlSqlLexerCOST_XML_QUERY_REWRITE = 293 + PlSqlLexerCOUNT = 294 + PlSqlLexerCOVAR_POP = 295 + PlSqlLexerCOVAR_SAMP = 296 + PlSqlLexerCPU_COSTING = 297 + PlSqlLexerCPU_PER_CALL = 298 + PlSqlLexerCPU_PER_SESSION = 299 + PlSqlLexerCRASH = 300 + PlSqlLexerCREATE = 301 + PlSqlLexerCREATE_FILE_DEST = 302 + PlSqlLexerCREATE_STORED_OUTLINES = 303 + PlSqlLexerCREATION = 304 + PlSqlLexerCREDENTIAL = 305 + PlSqlLexerCRITICAL = 306 + PlSqlLexerCROSS = 307 + PlSqlLexerCROSSEDITION = 308 + PlSqlLexerCSCONVERT = 309 + PlSqlLexerCUBE_AJ = 310 + PlSqlLexerCUBE = 311 + PlSqlLexerCUBE_GB = 312 + PlSqlLexerCUBE_SJ = 313 + PlSqlLexerCUME_DISTM = 314 + PlSqlLexerCURRENT = 315 + PlSqlLexerCURRENT_DATE = 316 + PlSqlLexerCURRENT_SCHEMA = 317 + PlSqlLexerCURRENT_TIME = 318 + PlSqlLexerCURRENT_TIMESTAMP = 319 + PlSqlLexerCURRENT_USER = 320 + PlSqlLexerCURRENTV = 321 + PlSqlLexerCURSOR = 322 + PlSqlLexerCURSOR_SHARING_EXACT = 323 + PlSqlLexerCURSOR_SPECIFIC_SEGMENT = 324 + PlSqlLexerCUSTOMDATUM = 325 + PlSqlLexerCV = 326 + PlSqlLexerCYCLE = 327 + PlSqlLexerDANGLING = 328 + PlSqlLexerDATABASE = 329 + PlSqlLexerDATA = 330 + PlSqlLexerDATAFILE = 331 + PlSqlLexerDATAFILES = 332 + PlSqlLexerDATAMOVEMENT = 333 + PlSqlLexerDATAOBJNO = 334 + PlSqlLexerDATAOBJ_TO_MAT_PARTITION = 335 + PlSqlLexerDATAOBJ_TO_PARTITION = 336 + PlSqlLexerDATAPUMP = 337 + PlSqlLexerDATA_SECURITY_REWRITE_LIMIT = 338 + PlSqlLexerDATE = 339 + PlSqlLexerDATE_MODE = 340 + PlSqlLexerDAY = 341 + PlSqlLexerDAYS = 342 + PlSqlLexerDBA = 343 + PlSqlLexerDBA_RECYCLEBIN = 344 + PlSqlLexerDBMS_STATS = 345 + PlSqlLexerDB_ROLE_CHANGE = 346 + PlSqlLexerDBTIMEZONE = 347 + PlSqlLexerDB_UNIQUE_NAME = 348 + PlSqlLexerDB_VERSION = 349 + PlSqlLexerDDL = 350 + PlSqlLexerDEALLOCATE = 351 + PlSqlLexerDEBUG = 352 + PlSqlLexerDEBUGGER = 353 + PlSqlLexerDEC = 354 + PlSqlLexerDECIMAL = 355 + PlSqlLexerDECLARE = 356 + PlSqlLexerDECOMPOSE = 357 + PlSqlLexerDECORRELATE = 358 + PlSqlLexerDECR = 359 + PlSqlLexerDECREMENT = 360 + PlSqlLexerDECRYPT = 361 + PlSqlLexerDEDUPLICATE = 362 + PlSqlLexerDEFAULT = 363 + PlSqlLexerDEFAULTS = 364 + PlSqlLexerDEFAULT_COLLATION = 365 + PlSqlLexerDEFAULT_CREDENTIAL = 366 + PlSqlLexerDEFERRABLE = 367 + PlSqlLexerDEFERRED = 368 + PlSqlLexerDEFINED = 369 + PlSqlLexerDEFINE = 370 + PlSqlLexerDEFINER = 371 + PlSqlLexerDEGREE = 372 + PlSqlLexerDELAY = 373 + PlSqlLexerDELEGATE = 374 + PlSqlLexerDELETE_ALL = 375 + PlSqlLexerDELETE = 376 + PlSqlLexerDELETEXML = 377 + PlSqlLexerDEMAND = 378 + PlSqlLexerDENSE_RANKM = 379 + PlSqlLexerDEPENDENT = 380 + PlSqlLexerDEPTH = 381 + PlSqlLexerDEQUEUE = 382 + PlSqlLexerDEREF = 383 + PlSqlLexerDEREF_NO_REWRITE = 384 + PlSqlLexerDESC = 385 + PlSqlLexerDESCRIPTION = 386 + PlSqlLexerDESTROY = 387 + PlSqlLexerDETACHED = 388 + PlSqlLexerDETERMINES = 389 + PlSqlLexerDETERMINISTIC = 390 + PlSqlLexerDICTIONARY = 391 + PlSqlLexerDIMENSION = 392 + PlSqlLexerDIMENSIONS = 393 + PlSqlLexerDIRECT_LOAD = 394 + PlSqlLexerDIRECTORY = 395 + PlSqlLexerDIRECT_PATH = 396 + PlSqlLexerDISABLE_ALL = 397 + PlSqlLexerDISABLE = 398 + PlSqlLexerDISABLE_PARALLEL_DML = 399 + PlSqlLexerDISABLE_PRESET = 400 + PlSqlLexerDISABLE_RPKE = 401 + PlSqlLexerDISALLOW = 402 + PlSqlLexerDISASSOCIATE = 403 + PlSqlLexerDISCARD = 404 + PlSqlLexerDISCONNECT = 405 + PlSqlLexerDISK = 406 + PlSqlLexerDISKGROUP = 407 + PlSqlLexerDISKS = 408 + PlSqlLexerDISMOUNT = 409 + PlSqlLexerDISTINCT = 410 + PlSqlLexerDISTINGUISHED = 411 + PlSqlLexerDISTRIBUTED = 412 + PlSqlLexerDISTRIBUTE = 413 + PlSqlLexerDML = 414 + PlSqlLexerDML_UPDATE = 415 + PlSqlLexerDOCFIDELITY = 416 + PlSqlLexerDOCUMENT = 417 + PlSqlLexerDOMAIN_INDEX_FILTER = 418 + PlSqlLexerDOMAIN_INDEX_NO_SORT = 419 + PlSqlLexerDOMAIN_INDEX_SORT = 420 + PlSqlLexerDOUBLE = 421 + PlSqlLexerDOWNGRADE = 422 + PlSqlLexerDRIVING_SITE = 423 + PlSqlLexerDROP_COLUMN = 424 + PlSqlLexerDROP = 425 + PlSqlLexerDROP_GROUP = 426 + PlSqlLexerDSINTERVAL_UNCONSTRAINED = 427 + PlSqlLexerDST_UPGRADE_INSERT_CONV = 428 + PlSqlLexerDUMP = 429 + PlSqlLexerDUPLICATE = 430 + PlSqlLexerDV = 431 + PlSqlLexerDYNAMIC = 432 + PlSqlLexerDYNAMIC_SAMPLING = 433 + PlSqlLexerDYNAMIC_SAMPLING_EST_CDN = 434 + PlSqlLexerE_LETTER = 435 + PlSqlLexerEACH = 436 + PlSqlLexerEDITIONABLE = 437 + PlSqlLexerEDITION = 438 + PlSqlLexerEDITIONING = 439 + PlSqlLexerEDITIONS = 440 + PlSqlLexerELEMENT = 441 + PlSqlLexerELIM_GROUPBY = 442 + PlSqlLexerELIMINATE_JOIN = 443 + PlSqlLexerELIMINATE_OBY = 444 + PlSqlLexerELIMINATE_OUTER_JOIN = 445 + PlSqlLexerELSE = 446 + PlSqlLexerELSIF = 447 + PlSqlLexerEM = 448 + PlSqlLexerEMPTY_BLOB = 449 + PlSqlLexerEMPTY_CLOB = 450 + PlSqlLexerEMPTY = 451 + PlSqlLexerENABLE_ALL = 452 + PlSqlLexerENABLE = 453 + PlSqlLexerENABLE_PARALLEL_DML = 454 + PlSqlLexerENABLE_PRESET = 455 + PlSqlLexerENCODING = 456 + PlSqlLexerENCRYPT = 457 + PlSqlLexerENCRYPTION = 458 + PlSqlLexerEND = 459 + PlSqlLexerEND_OUTLINE_DATA = 460 + PlSqlLexerENFORCED = 461 + PlSqlLexerENFORCE = 462 + PlSqlLexerENQUEUE = 463 + PlSqlLexerENTERPRISE = 464 + PlSqlLexerENTITYESCAPING = 465 + PlSqlLexerENTRY = 466 + PlSqlLexerEQUIPART = 467 + PlSqlLexerERR = 468 + PlSqlLexerERROR_ARGUMENT = 469 + PlSqlLexerERROR = 470 + PlSqlLexerERROR_ON_OVERLAP_TIME = 471 + PlSqlLexerERRORS = 472 + PlSqlLexerESCAPE = 473 + PlSqlLexerESTIMATE = 474 + PlSqlLexerEVAL = 475 + PlSqlLexerEVALNAME = 476 + PlSqlLexerEVALUATE = 477 + PlSqlLexerEVALUATION = 478 + PlSqlLexerEVENTS = 479 + PlSqlLexerEVERY = 480 + PlSqlLexerEXCEPT = 481 + PlSqlLexerEXCEPTION = 482 + PlSqlLexerEXCEPTION_INIT = 483 + PlSqlLexerEXCEPTIONS = 484 + PlSqlLexerEXCHANGE = 485 + PlSqlLexerEXCLUDE = 486 + PlSqlLexerEXCLUDING = 487 + PlSqlLexerEXCLUSIVE = 488 + PlSqlLexerEXECUTE = 489 + PlSqlLexerEXEMPT = 490 + PlSqlLexerEXISTING = 491 + PlSqlLexerEXISTS = 492 + PlSqlLexerEXISTSNODE = 493 + PlSqlLexerEXIT = 494 + PlSqlLexerEXPAND_GSET_TO_UNION = 495 + PlSqlLexerEXPAND_TABLE = 496 + PlSqlLexerEXP = 497 + PlSqlLexerEXPIRE = 498 + PlSqlLexerEXPLAIN = 499 + PlSqlLexerEXPLOSION = 500 + PlSqlLexerEXPORT = 501 + PlSqlLexerEXPR_CORR_CHECK = 502 + PlSqlLexerEXPRESS = 503 + PlSqlLexerEXTENDS = 504 + PlSqlLexerEXTENT = 505 + PlSqlLexerEXTENTS = 506 + PlSqlLexerEXTERNAL = 507 + PlSqlLexerEXTERNALLY = 508 + PlSqlLexerEXTRACTCLOBXML = 509 + PlSqlLexerEXTRACT = 510 + PlSqlLexerEXTRACTVALUE = 511 + PlSqlLexerEXTRA = 512 + PlSqlLexerFACILITY = 513 + PlSqlLexerFACT = 514 + PlSqlLexerFACTOR = 515 + PlSqlLexerFACTORIZE_JOIN = 516 + PlSqlLexerFAILED = 517 + PlSqlLexerFAILED_LOGIN_ATTEMPTS = 518 + PlSqlLexerFAILGROUP = 519 + PlSqlLexerFAILOVER = 520 + PlSqlLexerFAILURE = 521 + PlSqlLexerFALSE = 522 + PlSqlLexerFAMILY = 523 + PlSqlLexerFAR = 524 + PlSqlLexerFAST = 525 + PlSqlLexerFASTSTART = 526 + PlSqlLexerFBTSCAN = 527 + PlSqlLexerFEATURE = 528 + PlSqlLexerFEATURE_DETAILS = 529 + PlSqlLexerFEATURE_ID = 530 + PlSqlLexerFEATURE_SET = 531 + PlSqlLexerFEATURE_VALUE = 532 + PlSqlLexerFETCH = 533 + PlSqlLexerFILE = 534 + PlSqlLexerFILE_NAME_CONVERT = 535 + PlSqlLexerFILEGROUP = 536 + PlSqlLexerFILESTORE = 537 + PlSqlLexerFILESYSTEM_LIKE_LOGGING = 538 + PlSqlLexerFILTER = 539 + PlSqlLexerFINAL = 540 + PlSqlLexerFINE = 541 + PlSqlLexerFINISH = 542 + PlSqlLexerFIRST = 543 + PlSqlLexerFIRSTM = 544 + PlSqlLexerFIRST_ROWS = 545 + PlSqlLexerFIRST_VALUE = 546 + PlSqlLexerFIXED_VIEW_DATA = 547 + PlSqlLexerFLAGGER = 548 + PlSqlLexerFLASHBACK = 549 + PlSqlLexerFLASH_CACHE = 550 + PlSqlLexerFLOAT = 551 + PlSqlLexerFLOB = 552 + PlSqlLexerFLEX = 553 + PlSqlLexerFLOOR = 554 + PlSqlLexerFLUSH = 555 + PlSqlLexerFOLDER = 556 + PlSqlLexerFOLLOWING = 557 + PlSqlLexerFOLLOWS = 558 + PlSqlLexerFORALL = 559 + PlSqlLexerFORCE = 560 + PlSqlLexerFORCE_XML_QUERY_REWRITE = 561 + PlSqlLexerFOREIGN = 562 + PlSqlLexerFOREVER = 563 + PlSqlLexerFOR = 564 + PlSqlLexerFORMAT = 565 + PlSqlLexerFORWARD = 566 + PlSqlLexerFRAGMENT_NUMBER = 567 + PlSqlLexerFREELIST = 568 + PlSqlLexerFREELISTS = 569 + PlSqlLexerFREEPOOLS = 570 + PlSqlLexerFRESH = 571 + PlSqlLexerFROM = 572 + PlSqlLexerFROM_TZ = 573 + PlSqlLexerFULL = 574 + PlSqlLexerFULL_OUTER_JOIN_TO_OUTER = 575 + PlSqlLexerFUNCTION = 576 + PlSqlLexerFUNCTIONS = 577 + PlSqlLexerFTP = 578 + PlSqlLexerG_LETTER = 579 + PlSqlLexerGATHER_OPTIMIZER_STATISTICS = 580 + PlSqlLexerGATHER_PLAN_STATISTICS = 581 + PlSqlLexerGBY_CONC_ROLLUP = 582 + PlSqlLexerGBY_PUSHDOWN = 583 + PlSqlLexerGENERATED = 584 + PlSqlLexerGET = 585 + PlSqlLexerGLOBAL = 586 + PlSqlLexerGLOBALLY = 587 + PlSqlLexerGLOBAL_NAME = 588 + PlSqlLexerGLOBAL_TOPIC_ENABLED = 589 + PlSqlLexerGOTO = 590 + PlSqlLexerGRANT = 591 + PlSqlLexerGROUP_BY = 592 + PlSqlLexerGROUP = 593 + PlSqlLexerGROUP_ID = 594 + PlSqlLexerGROUPING = 595 + PlSqlLexerGROUPING_ID = 596 + PlSqlLexerGROUPS = 597 + PlSqlLexerGUARANTEED = 598 + PlSqlLexerGUARANTEE = 599 + PlSqlLexerGUARD = 600 + PlSqlLexerHALF_YEARS = 601 + PlSqlLexerHASH_AJ = 602 + PlSqlLexerHASH = 603 + PlSqlLexerHASHKEYS = 604 + PlSqlLexerHASH_SJ = 605 + PlSqlLexerHAVING = 606 + PlSqlLexerHEADER = 607 + PlSqlLexerHEAP = 608 + PlSqlLexerHELP = 609 + PlSqlLexerHEXTORAW = 610 + PlSqlLexerHEXTOREF = 611 + PlSqlLexerHIDDEN_KEYWORD = 612 + PlSqlLexerHIDE = 613 + PlSqlLexerHIER_ORDER = 614 + PlSqlLexerHIERARCHICAL = 615 + PlSqlLexerHIERARCHIES = 616 + PlSqlLexerHIERARCHY = 617 + PlSqlLexerHIGH = 618 + PlSqlLexerHINTSET_BEGIN = 619 + PlSqlLexerHINTSET_END = 620 + PlSqlLexerHOT = 621 + PlSqlLexerHOUR = 622 + PlSqlLexerHOURS = 623 + PlSqlLexerHTTP = 624 + PlSqlLexerHWM_BROKERED = 625 + PlSqlLexerHYBRID = 626 + PlSqlLexerH_LETTER = 627 + PlSqlLexerIDENTIFIED = 628 + PlSqlLexerIDENTIFIER = 629 + PlSqlLexerIDENTITY = 630 + PlSqlLexerIDGENERATORS = 631 + PlSqlLexerID = 632 + PlSqlLexerIDLE_TIME = 633 + PlSqlLexerIF = 634 + PlSqlLexerIGNORE = 635 + PlSqlLexerIGNORE_OPTIM_EMBEDDED_HINTS = 636 + PlSqlLexerIGNORE_ROW_ON_DUPKEY_INDEX = 637 + PlSqlLexerIGNORE_WHERE_CLAUSE = 638 + PlSqlLexerILM = 639 + PlSqlLexerIMMEDIATE = 640 + PlSqlLexerIMPACT = 641 + PlSqlLexerIMPORT = 642 + PlSqlLexerINACTIVE = 643 + PlSqlLexerINACTIVE_ACCOUNT_TIME = 644 + PlSqlLexerINCLUDE = 645 + PlSqlLexerINCLUDE_VERSION = 646 + PlSqlLexerINCLUDING = 647 + PlSqlLexerINCREMENTAL = 648 + PlSqlLexerINCREMENT = 649 + PlSqlLexerINCR = 650 + PlSqlLexerINDENT = 651 + PlSqlLexerINDEX_ASC = 652 + PlSqlLexerINDEX_COMBINE = 653 + PlSqlLexerINDEX_DESC = 654 + PlSqlLexerINDEXED = 655 + PlSqlLexerINDEXES = 656 + PlSqlLexerINDEX_FFS = 657 + PlSqlLexerINDEX_FILTER = 658 + PlSqlLexerINDEX = 659 + PlSqlLexerINDEXING = 660 + PlSqlLexerINDEX_JOIN = 661 + PlSqlLexerINDEX_ROWS = 662 + PlSqlLexerINDEX_RRS = 663 + PlSqlLexerINDEX_RS_ASC = 664 + PlSqlLexerINDEX_RS_DESC = 665 + PlSqlLexerINDEX_RS = 666 + PlSqlLexerINDEX_SCAN = 667 + PlSqlLexerINDEX_SKIP_SCAN = 668 + PlSqlLexerINDEX_SS_ASC = 669 + PlSqlLexerINDEX_SS_DESC = 670 + PlSqlLexerINDEX_SS = 671 + PlSqlLexerINDEX_STATS = 672 + PlSqlLexerINDEXTYPE = 673 + PlSqlLexerINDEXTYPES = 674 + PlSqlLexerINDICATOR = 675 + PlSqlLexerINDICES = 676 + PlSqlLexerINFINITE = 677 + PlSqlLexerINFORMATIONAL = 678 + PlSqlLexerINHERIT = 679 + PlSqlLexerIN = 680 + PlSqlLexerINITCAP = 681 + PlSqlLexerINITIAL = 682 + PlSqlLexerINITIALIZED = 683 + PlSqlLexerINITIALLY = 684 + PlSqlLexerINITRANS = 685 + PlSqlLexerINLINE = 686 + PlSqlLexerINLINE_XMLTYPE_NT = 687 + PlSqlLexerINMEMORY = 688 + PlSqlLexerIN_MEMORY_METADATA = 689 + PlSqlLexerINMEMORY_PRUNING = 690 + PlSqlLexerINNER = 691 + PlSqlLexerINOUT = 692 + PlSqlLexerINPLACE = 693 + PlSqlLexerINSERTCHILDXMLAFTER = 694 + PlSqlLexerINSERTCHILDXMLBEFORE = 695 + PlSqlLexerINSERTCHILDXML = 696 + PlSqlLexerINSERT = 697 + PlSqlLexerINSERTXMLAFTER = 698 + PlSqlLexerINSERTXMLBEFORE = 699 + PlSqlLexerINSTANCE = 700 + PlSqlLexerINSTANCES = 701 + PlSqlLexerINSTANTIABLE = 702 + PlSqlLexerINSTANTLY = 703 + PlSqlLexerINSTEAD = 704 + PlSqlLexerINSTR2 = 705 + PlSqlLexerINSTR4 = 706 + PlSqlLexerINSTRB = 707 + PlSqlLexerINSTRC = 708 + PlSqlLexerINSTR = 709 + PlSqlLexerINTEGER = 710 + PlSqlLexerINTERLEAVED = 711 + PlSqlLexerINTERMEDIATE = 712 + PlSqlLexerINTERNAL_CONVERT = 713 + PlSqlLexerINTERNAL_USE = 714 + PlSqlLexerINTERPRETED = 715 + PlSqlLexerINTERSECT = 716 + PlSqlLexerINTERVAL = 717 + PlSqlLexerINT = 718 + PlSqlLexerINTO = 719 + PlSqlLexerINVALIDATE = 720 + PlSqlLexerINVISIBLE = 721 + PlSqlLexerIN_XQUERY = 722 + PlSqlLexerIS = 723 + PlSqlLexerIS_LEAF = 724 + PlSqlLexerISOLATION = 725 + PlSqlLexerISOLATION_LEVEL = 726 + PlSqlLexerITERATE = 727 + PlSqlLexerITERATION_NUMBER = 728 + PlSqlLexerJAVA = 729 + PlSqlLexerJOB = 730 + PlSqlLexerJOIN = 731 + PlSqlLexerJSON_ARRAYAGG = 732 + PlSqlLexerJSON_ARRAY = 733 + PlSqlLexerJSON_EQUAL = 734 + PlSqlLexerJSON_EXISTS2 = 735 + PlSqlLexerJSON_EXISTS = 736 + PlSqlLexerJSONGET = 737 + PlSqlLexerJSON = 738 + PlSqlLexerJSON_OBJECTAGG = 739 + PlSqlLexerJSON_OBJECT = 740 + PlSqlLexerJSONPARSE = 741 + PlSqlLexerJSON_QUERY = 742 + PlSqlLexerJSON_SERIALIZE = 743 + PlSqlLexerJSON_TABLE = 744 + PlSqlLexerJSON_TEXTCONTAINS2 = 745 + PlSqlLexerJSON_TEXTCONTAINS = 746 + PlSqlLexerJSON_TRANSFORM = 747 + PlSqlLexerJSON_VALUE = 748 + PlSqlLexerK_LETTER = 749 + PlSqlLexerKEEP_DUPLICATES = 750 + PlSqlLexerKEEP = 751 + PlSqlLexerKERBEROS = 752 + PlSqlLexerKEY = 753 + PlSqlLexerKEY_LENGTH = 754 + PlSqlLexerKEYSIZE = 755 + PlSqlLexerKEYS = 756 + PlSqlLexerKEYSTORE = 757 + PlSqlLexerKILL = 758 + PlSqlLexerLABEL = 759 + PlSqlLexerLANGUAGE = 760 + PlSqlLexerLAST_DAY = 761 + PlSqlLexerLAST = 762 + PlSqlLexerLAST_VALUE = 763 + PlSqlLexerLATERAL = 764 + PlSqlLexerLAX = 765 + PlSqlLexerLAYER = 766 + PlSqlLexerLDAP_REGISTRATION_ENABLED = 767 + PlSqlLexerLDAP_REGISTRATION = 768 + PlSqlLexerLDAP_REG_SYNC_INTERVAL = 769 + PlSqlLexerLEAF = 770 + PlSqlLexerLEAD_CDB = 771 + PlSqlLexerLEAD_CDB_URI = 772 + PlSqlLexerLEADING = 773 + PlSqlLexerLEFT = 774 + PlSqlLexerLENGTH2 = 775 + PlSqlLexerLENGTH4 = 776 + PlSqlLexerLENGTHB = 777 + PlSqlLexerLENGTHC = 778 + PlSqlLexerLENGTH = 779 + PlSqlLexerLESS = 780 + PlSqlLexerLEVEL = 781 + PlSqlLexerLEVEL_NAME = 782 + PlSqlLexerLEVELS = 783 + PlSqlLexerLIBRARY = 784 + PlSqlLexerLIFECYCLE = 785 + PlSqlLexerLIFE = 786 + PlSqlLexerLIFETIME = 787 + PlSqlLexerLIKE2 = 788 + PlSqlLexerLIKE4 = 789 + PlSqlLexerLIKEC = 790 + PlSqlLexerLIKE_EXPAND = 791 + PlSqlLexerLIKE = 792 + PlSqlLexerLIMIT = 793 + PlSqlLexerLINEAR = 794 + PlSqlLexerLINK = 795 + PlSqlLexerLIST = 796 + PlSqlLexerLN = 797 + PlSqlLexerLNNVL = 798 + PlSqlLexerLOAD = 799 + PlSqlLexerLOB = 800 + PlSqlLexerLOBNVL = 801 + PlSqlLexerLOBS = 802 + PlSqlLexerLOCAL_INDEXES = 803 + PlSqlLexerLOCAL = 804 + PlSqlLexerLOCALTIME = 805 + PlSqlLexerLOCALTIMESTAMP = 806 + PlSqlLexerLOCATION = 807 + PlSqlLexerLOCATOR = 808 + PlSqlLexerLOCKDOWN = 809 + PlSqlLexerLOCKED = 810 + PlSqlLexerLOCKING = 811 + PlSqlLexerLOCK = 812 + PlSqlLexerLOGFILE = 813 + PlSqlLexerLOGFILES = 814 + PlSqlLexerLOGGING = 815 + PlSqlLexerLOGICAL = 816 + PlSqlLexerLOGICAL_READS_PER_CALL = 817 + PlSqlLexerLOGICAL_READS_PER_SESSION = 818 + PlSqlLexerLOG = 819 + PlSqlLexerLOGMINING = 820 + PlSqlLexerLOGOFF = 821 + PlSqlLexerLOGON = 822 + PlSqlLexerLOG_READ_ONLY_VIOLATIONS = 823 + PlSqlLexerLONG = 824 + PlSqlLexerLOOP = 825 + PlSqlLexerLOST = 826 + PlSqlLexerLOWER = 827 + PlSqlLexerLOW = 828 + PlSqlLexerLPAD = 829 + PlSqlLexerLTRIM = 830 + PlSqlLexerM_LETTER = 831 + PlSqlLexerMAIN = 832 + PlSqlLexerMAKE_REF = 833 + PlSqlLexerMANAGED = 834 + PlSqlLexerMANAGE = 835 + PlSqlLexerMANAGEMENT = 836 + PlSqlLexerMANAGER = 837 + PlSqlLexerMANDATORY = 838 + PlSqlLexerMANUAL = 839 + PlSqlLexerMAP = 840 + PlSqlLexerMAPPING = 841 + PlSqlLexerMASTER = 842 + PlSqlLexerMATCHED = 843 + PlSqlLexerMATCHES = 844 + PlSqlLexerMATCH = 845 + PlSqlLexerMATCH_NUMBER = 846 + PlSqlLexerMATCH_RECOGNIZE = 847 + PlSqlLexerMATERIALIZED = 848 + PlSqlLexerMATERIALIZE = 849 + PlSqlLexerMAXARCHLOGS = 850 + PlSqlLexerMAXDATAFILES = 851 + PlSqlLexerMAXEXTENTS = 852 + PlSqlLexerMAXIMIZE = 853 + PlSqlLexerMAXINSTANCES = 854 + PlSqlLexerMAXLOGFILES = 855 + PlSqlLexerMAXLOGHISTORY = 856 + PlSqlLexerMAXLOGMEMBERS = 857 + PlSqlLexerMAX_SHARED_TEMP_SIZE = 858 + PlSqlLexerMAXSIZE = 859 + PlSqlLexerMAXTRANS = 860 + PlSqlLexerMAXVALUE = 861 + PlSqlLexerMEASURE = 862 + PlSqlLexerMEASURES = 863 + PlSqlLexerMEDIUM = 864 + PlSqlLexerMEMBER = 865 + PlSqlLexerMEMBER_CAPTION = 866 + PlSqlLexerMEMBER_DESCRIPTION = 867 + PlSqlLexerMEMBER_NAME = 868 + PlSqlLexerMEMBER_UNIQUE_NAME = 869 + PlSqlLexerMEMCOMPRESS = 870 + PlSqlLexerMEMORY = 871 + PlSqlLexerMERGEACTIONS = 872 + PlSqlLexerMERGE_AJ = 873 + PlSqlLexerMERGE_CONST_ON = 874 + PlSqlLexerMERGE = 875 + PlSqlLexerMERGE_SJ = 876 + PlSqlLexerMETADATA = 877 + PlSqlLexerMETHOD = 878 + PlSqlLexerMIGRATE = 879 + PlSqlLexerMIGRATION = 880 + PlSqlLexerMINEXTENTS = 881 + PlSqlLexerMINIMIZE = 882 + PlSqlLexerMINIMUM = 883 + PlSqlLexerMINING = 884 + PlSqlLexerMINUS = 885 + PlSqlLexerMINUS_NULL = 886 + PlSqlLexerMINUTE = 887 + PlSqlLexerMINUTES = 888 + PlSqlLexerMINVALUE = 889 + PlSqlLexerMIRRORCOLD = 890 + PlSqlLexerMIRRORHOT = 891 + PlSqlLexerMIRROR = 892 + PlSqlLexerMISSING = 893 + PlSqlLexerMISMATCH = 894 + PlSqlLexerMLSLABEL = 895 + PlSqlLexerMODEL_COMPILE_SUBQUERY = 896 + PlSqlLexerMODEL_DONTVERIFY_UNIQUENESS = 897 + PlSqlLexerMODEL_DYNAMIC_SUBQUERY = 898 + PlSqlLexerMODEL_MIN_ANALYSIS = 899 + PlSqlLexerMODEL = 900 + PlSqlLexerMODEL_NB = 901 + PlSqlLexerMODEL_NO_ANALYSIS = 902 + PlSqlLexerMODEL_PBY = 903 + PlSqlLexerMODEL_PUSH_REF = 904 + PlSqlLexerMODEL_SV = 905 + PlSqlLexerMODE = 906 + PlSqlLexerMODIFICATION = 907 + PlSqlLexerMODIFY_COLUMN_TYPE = 908 + PlSqlLexerMODIFY = 909 + PlSqlLexerMOD = 910 + PlSqlLexerMODULE = 911 + PlSqlLexerMONITORING = 912 + PlSqlLexerMONITOR = 913 + PlSqlLexerMONTH = 914 + PlSqlLexerMONTHS_BETWEEN = 915 + PlSqlLexerMONTHS = 916 + PlSqlLexerMOUNT = 917 + PlSqlLexerMOUNTPATH = 918 + PlSqlLexerMOUNTPOINT = 919 + PlSqlLexerMOVEMENT = 920 + PlSqlLexerMOVE = 921 + PlSqlLexerMULTIDIMENSIONAL = 922 + PlSqlLexerMULTISET = 923 + PlSqlLexerMV_MERGE = 924 + PlSqlLexerNAMED = 925 + PlSqlLexerNAME = 926 + PlSqlLexerNAMESPACE = 927 + PlSqlLexerNAN = 928 + PlSqlLexerNANVL = 929 + PlSqlLexerNATIONAL = 930 + PlSqlLexerNATIVE_FULL_OUTER_JOIN = 931 + PlSqlLexerNATIVE = 932 + PlSqlLexerNATURAL = 933 + PlSqlLexerNATURALN = 934 + PlSqlLexerNAV = 935 + PlSqlLexerNCHAR_CS = 936 + PlSqlLexerNCHAR = 937 + PlSqlLexerNCHR = 938 + PlSqlLexerNCLOB = 939 + PlSqlLexerNEEDED = 940 + PlSqlLexerNEG = 941 + PlSqlLexerNESTED = 942 + PlSqlLexerNESTED_TABLE_FAST_INSERT = 943 + PlSqlLexerNESTED_TABLE_GET_REFS = 944 + PlSqlLexerNESTED_TABLE_ID = 945 + PlSqlLexerNESTED_TABLE_SET_REFS = 946 + PlSqlLexerNESTED_TABLE_SET_SETID = 947 + PlSqlLexerNETWORK = 948 + PlSqlLexerNEVER = 949 + PlSqlLexerNEW = 950 + PlSqlLexerNEW_TIME = 951 + PlSqlLexerNEXT_DAY = 952 + PlSqlLexerNEXT = 953 + PlSqlLexerNL_AJ = 954 + PlSqlLexerNLJ_BATCHING = 955 + PlSqlLexerNLJ_INDEX_FILTER = 956 + PlSqlLexerNLJ_INDEX_SCAN = 957 + PlSqlLexerNLJ_PREFETCH = 958 + PlSqlLexerNLS_CALENDAR = 959 + PlSqlLexerNLS_CHARACTERSET = 960 + PlSqlLexerNLS_CHARSET_DECL_LEN = 961 + PlSqlLexerNLS_CHARSET_ID = 962 + PlSqlLexerNLS_CHARSET_NAME = 963 + PlSqlLexerNLS_COMP = 964 + PlSqlLexerNLS_CURRENCY = 965 + PlSqlLexerNLS_DATE_FORMAT = 966 + PlSqlLexerNLS_DATE_LANGUAGE = 967 + PlSqlLexerNLS_INITCAP = 968 + PlSqlLexerNLS_ISO_CURRENCY = 969 + PlSqlLexerNL_SJ = 970 + PlSqlLexerNLS_LANG = 971 + PlSqlLexerNLS_LANGUAGE = 972 + PlSqlLexerNLS_LENGTH_SEMANTICS = 973 + PlSqlLexerNLS_LOWER = 974 + PlSqlLexerNLS_NCHAR_CONV_EXCP = 975 + PlSqlLexerNLS_NUMERIC_CHARACTERS = 976 + PlSqlLexerNLS_SORT = 977 + PlSqlLexerNLSSORT = 978 + PlSqlLexerNLS_SPECIAL_CHARS = 979 + PlSqlLexerNLS_TERRITORY = 980 + PlSqlLexerNLS_UPPER = 981 + PlSqlLexerNO_ACCESS = 982 + PlSqlLexerNO_ADAPTIVE_PLAN = 983 + PlSqlLexerNO_ANSI_REARCH = 984 + PlSqlLexerNOAPPEND = 985 + PlSqlLexerNOARCHIVELOG = 986 + PlSqlLexerNOAUDIT = 987 + PlSqlLexerNO_AUTO_REOPTIMIZE = 988 + PlSqlLexerNO_BASETABLE_MULTIMV_REWRITE = 989 + PlSqlLexerNO_BATCH_TABLE_ACCESS_BY_ROWID = 990 + PlSqlLexerNO_BIND_AWARE = 991 + PlSqlLexerNO_BUFFER = 992 + PlSqlLexerNOCACHE = 993 + PlSqlLexerNO_CARTESIAN = 994 + PlSqlLexerNO_CHECK_ACL_REWRITE = 995 + PlSqlLexerNO_CLUSTER_BY_ROWID = 996 + PlSqlLexerNO_CLUSTERING = 997 + PlSqlLexerNO_COALESCE_SQ = 998 + PlSqlLexerNO_COMMON_DATA = 999 + PlSqlLexerNOCOMPRESS = 1000 + PlSqlLexerNO_CONNECT_BY_CB_WHR_ONLY = 1001 + PlSqlLexerNO_CONNECT_BY_COMBINE_SW = 1002 + PlSqlLexerNO_CONNECT_BY_COST_BASED = 1003 + PlSqlLexerNO_CONNECT_BY_ELIM_DUPS = 1004 + PlSqlLexerNO_CONNECT_BY_FILTERING = 1005 + PlSqlLexerNOCOPY = 1006 + PlSqlLexerNO_COST_XML_QUERY_REWRITE = 1007 + PlSqlLexerNO_CPU_COSTING = 1008 + PlSqlLexerNOCPU_COSTING = 1009 + PlSqlLexerNOCYCLE = 1010 + PlSqlLexerNO_DATA_SECURITY_REWRITE = 1011 + PlSqlLexerNO_DECORRELATE = 1012 + PlSqlLexerNODELAY = 1013 + PlSqlLexerNO_DOMAIN_INDEX_FILTER = 1014 + PlSqlLexerNO_DST_UPGRADE_INSERT_CONV = 1015 + PlSqlLexerNO_ELIM_GROUPBY = 1016 + PlSqlLexerNO_ELIMINATE_JOIN = 1017 + PlSqlLexerNO_ELIMINATE_OBY = 1018 + PlSqlLexerNO_ELIMINATE_OUTER_JOIN = 1019 + PlSqlLexerNOENTITYESCAPING = 1020 + PlSqlLexerNO_EXPAND_GSET_TO_UNION = 1021 + PlSqlLexerNO_EXPAND = 1022 + PlSqlLexerNO_EXPAND_TABLE = 1023 + PlSqlLexerNO_FACT = 1024 + PlSqlLexerNO_FACTORIZE_JOIN = 1025 + PlSqlLexerNO_FILTERING = 1026 + PlSqlLexerNOFORCE = 1027 + PlSqlLexerNO_FULL_OUTER_JOIN_TO_OUTER = 1028 + PlSqlLexerNO_GATHER_OPTIMIZER_STATISTICS = 1029 + PlSqlLexerNO_GBY_PUSHDOWN = 1030 + PlSqlLexerNOGUARANTEE = 1031 + PlSqlLexerNO_INDEX_FFS = 1032 + PlSqlLexerNO_INDEX = 1033 + PlSqlLexerNO_INDEX_SS = 1034 + PlSqlLexerNO_INMEMORY = 1035 + PlSqlLexerNO_INMEMORY_PRUNING = 1036 + PlSqlLexerNOKEEP = 1037 + PlSqlLexerNO_LOAD = 1038 + PlSqlLexerNOLOCAL = 1039 + PlSqlLexerNOLOGGING = 1040 + PlSqlLexerNOMAPPING = 1041 + PlSqlLexerNOMAXVALUE = 1042 + PlSqlLexerNO_MERGE = 1043 + PlSqlLexerNOMINIMIZE = 1044 + PlSqlLexerNOMINVALUE = 1045 + PlSqlLexerNO_MODEL_PUSH_REF = 1046 + PlSqlLexerNO_MONITORING = 1047 + PlSqlLexerNOMONITORING = 1048 + PlSqlLexerNO_MONITOR = 1049 + PlSqlLexerNO_MULTIMV_REWRITE = 1050 + PlSqlLexerNO_NATIVE_FULL_OUTER_JOIN = 1051 + PlSqlLexerNONBLOCKING = 1052 + PlSqlLexerNONEDITIONABLE = 1053 + PlSqlLexerNONE = 1054 + PlSqlLexerNO_NLJ_BATCHING = 1055 + PlSqlLexerNO_NLJ_PREFETCH = 1056 + PlSqlLexerNO = 1057 + PlSqlLexerNONSCHEMA = 1058 + PlSqlLexerNO_OBJECT_LINK = 1059 + PlSqlLexerNOORDER = 1060 + PlSqlLexerNO_ORDER_ROLLUPS = 1061 + PlSqlLexerNO_OUTER_JOIN_TO_ANTI = 1062 + PlSqlLexerNO_OUTER_JOIN_TO_INNER = 1063 + PlSqlLexerNOOVERRIDE = 1064 + PlSqlLexerNO_PARALLEL_INDEX = 1065 + PlSqlLexerNOPARALLEL_INDEX = 1066 + PlSqlLexerNO_PARALLEL = 1067 + PlSqlLexerNOPARALLEL = 1068 + PlSqlLexerNO_PARTIAL_COMMIT = 1069 + PlSqlLexerNO_PARTIAL_JOIN = 1070 + PlSqlLexerNO_PARTIAL_ROLLUP_PUSHDOWN = 1071 + PlSqlLexerNOPARTITION = 1072 + PlSqlLexerNO_PLACE_DISTINCT = 1073 + PlSqlLexerNO_PLACE_GROUP_BY = 1074 + PlSqlLexerNO_PQ_CONCURRENT_UNION = 1075 + PlSqlLexerNO_PQ_MAP = 1076 + PlSqlLexerNOPROMPT = 1077 + PlSqlLexerNO_PQ_REPLICATE = 1078 + PlSqlLexerNO_PQ_SKEW = 1079 + PlSqlLexerNO_PRUNE_GSETS = 1080 + PlSqlLexerNO_PULL_PRED = 1081 + PlSqlLexerNO_PUSH_PRED = 1082 + PlSqlLexerNO_PUSH_SUBQ = 1083 + PlSqlLexerNO_PX_FAULT_TOLERANCE = 1084 + PlSqlLexerNO_PX_JOIN_FILTER = 1085 + PlSqlLexerNO_QKN_BUFF = 1086 + PlSqlLexerNO_QUERY_TRANSFORMATION = 1087 + PlSqlLexerNO_REF_CASCADE = 1088 + PlSqlLexerNORELOCATE = 1089 + PlSqlLexerNORELY = 1090 + PlSqlLexerNOREPAIR = 1091 + PlSqlLexerNOREPLAY = 1092 + PlSqlLexerNORESETLOGS = 1093 + PlSqlLexerNO_RESULT_CACHE = 1094 + PlSqlLexerNOREVERSE = 1095 + PlSqlLexerNO_REWRITE = 1096 + PlSqlLexerNOREWRITE = 1097 + PlSqlLexerNORMAL = 1098 + PlSqlLexerNO_ROOT_SW_FOR_LOCAL = 1099 + PlSqlLexerNOROWDEPENDENCIES = 1100 + PlSqlLexerNOSCHEMACHECK = 1101 + PlSqlLexerNOSEGMENT = 1102 + PlSqlLexerNO_SEMIJOIN = 1103 + PlSqlLexerNO_SEMI_TO_INNER = 1104 + PlSqlLexerNO_SET_TO_JOIN = 1105 + PlSqlLexerNOSORT = 1106 + PlSqlLexerNO_SQL_TRANSLATION = 1107 + PlSqlLexerNO_SQL_TUNE = 1108 + PlSqlLexerNO_STAR_TRANSFORMATION = 1109 + PlSqlLexerNO_STATEMENT_QUEUING = 1110 + PlSqlLexerNO_STATS_GSETS = 1111 + PlSqlLexerNOSTRICT = 1112 + PlSqlLexerNO_SUBQUERY_PRUNING = 1113 + PlSqlLexerNO_SUBSTRB_PAD = 1114 + PlSqlLexerNO_SWAP_JOIN_INPUTS = 1115 + PlSqlLexerNOSWITCH = 1116 + PlSqlLexerNO_TABLE_LOOKUP_BY_NL = 1117 + PlSqlLexerNO_TEMP_TABLE = 1118 + PlSqlLexerNOTHING = 1119 + PlSqlLexerNOTIFICATION = 1120 + PlSqlLexerNOT = 1121 + PlSqlLexerNO_TRANSFORM_DISTINCT_AGG = 1122 + PlSqlLexerNO_UNNEST = 1123 + PlSqlLexerNO_USE_CUBE = 1124 + PlSqlLexerNO_USE_HASH_AGGREGATION = 1125 + PlSqlLexerNO_USE_HASH_GBY_FOR_PUSHDOWN = 1126 + PlSqlLexerNO_USE_HASH = 1127 + PlSqlLexerNO_USE_INVISIBLE_INDEXES = 1128 + PlSqlLexerNO_USE_MERGE = 1129 + PlSqlLexerNO_USE_NL = 1130 + PlSqlLexerNO_USE_VECTOR_AGGREGATION = 1131 + PlSqlLexerNOVALIDATE = 1132 + PlSqlLexerNO_VECTOR_TRANSFORM_DIMS = 1133 + PlSqlLexerNO_VECTOR_TRANSFORM_FACT = 1134 + PlSqlLexerNO_VECTOR_TRANSFORM = 1135 + PlSqlLexerNOWAIT = 1136 + PlSqlLexerNO_XDB_FASTPATH_INSERT = 1137 + PlSqlLexerNO_XML_DML_REWRITE = 1138 + PlSqlLexerNO_XMLINDEX_REWRITE_IN_SELECT = 1139 + PlSqlLexerNO_XMLINDEX_REWRITE = 1140 + PlSqlLexerNO_XML_QUERY_REWRITE = 1141 + PlSqlLexerNO_ZONEMAP = 1142 + PlSqlLexerNTH_VALUE = 1143 + PlSqlLexerNULLIF = 1144 + PlSqlLexerNULL_ = 1145 + PlSqlLexerNULLS = 1146 + PlSqlLexerNUMBER = 1147 + PlSqlLexerNUMERIC = 1148 + PlSqlLexerNUM_INDEX_KEYS = 1149 + PlSqlLexerNUMTODSINTERVAL = 1150 + PlSqlLexerNUMTOYMINTERVAL = 1151 + PlSqlLexerNVARCHAR2 = 1152 + PlSqlLexerNVL2 = 1153 + PlSqlLexerOBJECT2XML = 1154 + PlSqlLexerOBJECT = 1155 + PlSqlLexerOBJ_ID = 1156 + PlSqlLexerOBJNO = 1157 + PlSqlLexerOBJNO_REUSE = 1158 + PlSqlLexerOCCURENCES = 1159 + PlSqlLexerOFFLINE = 1160 + PlSqlLexerOFF = 1161 + PlSqlLexerOFFSET = 1162 + PlSqlLexerOF = 1163 + PlSqlLexerOIDINDEX = 1164 + PlSqlLexerOID = 1165 + PlSqlLexerOLAP = 1166 + PlSqlLexerOLD = 1167 + PlSqlLexerOLD_PUSH_PRED = 1168 + PlSqlLexerOLS = 1169 + PlSqlLexerOLTP = 1170 + PlSqlLexerOMIT = 1171 + PlSqlLexerONE = 1172 + PlSqlLexerONLINE = 1173 + PlSqlLexerONLY = 1174 + PlSqlLexerON = 1175 + PlSqlLexerOPAQUE = 1176 + PlSqlLexerOPAQUE_TRANSFORM = 1177 + PlSqlLexerOPAQUE_XCANONICAL = 1178 + PlSqlLexerOPCODE = 1179 + PlSqlLexerOPEN = 1180 + PlSqlLexerOPERATIONS = 1181 + PlSqlLexerOPERATOR = 1182 + PlSqlLexerOPT_ESTIMATE = 1183 + PlSqlLexerOPTIMAL = 1184 + PlSqlLexerOPTIMIZE = 1185 + PlSqlLexerOPTIMIZER_FEATURES_ENABLE = 1186 + PlSqlLexerOPTIMIZER_GOAL = 1187 + PlSqlLexerOPTION = 1188 + PlSqlLexerOPT_PARAM = 1189 + PlSqlLexerORA_BRANCH = 1190 + PlSqlLexerORA_CHECK_ACL = 1191 + PlSqlLexerORA_CHECK_PRIVILEGE = 1192 + PlSqlLexerORA_CLUSTERING = 1193 + PlSqlLexerORADATA = 1194 + PlSqlLexerORADEBUG = 1195 + PlSqlLexerORA_DST_AFFECTED = 1196 + PlSqlLexerORA_DST_CONVERT = 1197 + PlSqlLexerORA_DST_ERROR = 1198 + PlSqlLexerORA_GET_ACLIDS = 1199 + PlSqlLexerORA_GET_PRIVILEGES = 1200 + PlSqlLexerORA_HASH = 1201 + PlSqlLexerORA_INVOKING_USERID = 1202 + PlSqlLexerORA_INVOKING_USER = 1203 + PlSqlLexerORA_INVOKING_XS_USER_GUID = 1204 + PlSqlLexerORA_INVOKING_XS_USER = 1205 + PlSqlLexerORA_RAWCOMPARE = 1206 + PlSqlLexerORA_RAWCONCAT = 1207 + PlSqlLexerORA_ROWSCN = 1208 + PlSqlLexerORA_ROWSCN_RAW = 1209 + PlSqlLexerORA_ROWVERSION = 1210 + PlSqlLexerORA_TABVERSION = 1211 + PlSqlLexerORA_WRITE_TIME = 1212 + PlSqlLexerORDERED = 1213 + PlSqlLexerORDERED_PREDICATES = 1214 + PlSqlLexerORDER = 1215 + PlSqlLexerORDINALITY = 1216 + PlSqlLexerOR_EXPAND = 1217 + PlSqlLexerORGANIZATION = 1218 + PlSqlLexerOR = 1219 + PlSqlLexerOR_PREDICATES = 1220 + PlSqlLexerOSERROR = 1221 + PlSqlLexerOTHER = 1222 + PlSqlLexerOUTER_JOIN_TO_ANTI = 1223 + PlSqlLexerOUTER_JOIN_TO_INNER = 1224 + PlSqlLexerOUTER = 1225 + PlSqlLexerOUTLINE_LEAF = 1226 + PlSqlLexerOUTLINE = 1227 + PlSqlLexerOUT_OF_LINE = 1228 + PlSqlLexerOUT = 1229 + PlSqlLexerOVERFLOW_NOMOVE = 1230 + PlSqlLexerOVERFLOW = 1231 + PlSqlLexerOVERLAPS = 1232 + PlSqlLexerOVER = 1233 + PlSqlLexerOVERRIDING = 1234 + PlSqlLexerOWNER = 1235 + PlSqlLexerOWNERSHIP = 1236 + PlSqlLexerOWN = 1237 + PlSqlLexerP_LETTER = 1238 + PlSqlLexerPACKAGE = 1239 + PlSqlLexerPACKAGES = 1240 + PlSqlLexerPARALLEL_ENABLE = 1241 + PlSqlLexerPARALLEL_INDEX = 1242 + PlSqlLexerPARALLEL = 1243 + PlSqlLexerPARAMETERS = 1244 + PlSqlLexerPARAM = 1245 + PlSqlLexerPARENT = 1246 + PlSqlLexerPARENT_LEVEL_NAME = 1247 + PlSqlLexerPARENT_UNIQUE_NAME = 1248 + PlSqlLexerPARITY = 1249 + PlSqlLexerPARTIAL_JOIN = 1250 + PlSqlLexerPARTIALLY = 1251 + PlSqlLexerPARTIAL = 1252 + PlSqlLexerPARTIAL_ROLLUP_PUSHDOWN = 1253 + PlSqlLexerPARTITION_HASH = 1254 + PlSqlLexerPARTITION_LIST = 1255 + PlSqlLexerPARTITION = 1256 + PlSqlLexerPARTITION_RANGE = 1257 + PlSqlLexerPARTITIONS = 1258 + PlSqlLexerPARTNUMINST = 1259 + PlSqlLexerPASSING = 1260 + PlSqlLexerPASSWORD_GRACE_TIME = 1261 + PlSqlLexerPASSWORD_LIFE_TIME = 1262 + PlSqlLexerPASSWORD_LOCK_TIME = 1263 + PlSqlLexerPASSWORD = 1264 + PlSqlLexerPASSWORD_REUSE_MAX = 1265 + PlSqlLexerPASSWORD_REUSE_TIME = 1266 + PlSqlLexerPASSWORD_ROLLOVER_TIME = 1267 + PlSqlLexerPASSWORD_VERIFY_FUNCTION = 1268 + PlSqlLexerPAST = 1269 + PlSqlLexerPATCH = 1270 + PlSqlLexerPATH = 1271 + PlSqlLexerPATH_PREFIX = 1272 + PlSqlLexerPATHS = 1273 + PlSqlLexerPATTERN = 1274 + PlSqlLexerPBL_HS_BEGIN = 1275 + PlSqlLexerPBL_HS_END = 1276 + PlSqlLexerPCTFREE = 1277 + PlSqlLexerPCTINCREASE = 1278 + PlSqlLexerPCTTHRESHOLD = 1279 + PlSqlLexerPCTUSED = 1280 + PlSqlLexerPCTVERSION = 1281 + PlSqlLexerPENDING = 1282 + PlSqlLexerPERCENT_FOUND = 1283 + PlSqlLexerPERCENT_ISOPEN = 1284 + PlSqlLexerPERCENT_NOTFOUND = 1285 + PlSqlLexerPERCENT_KEYWORD = 1286 + PlSqlLexerPERCENT_RANKM = 1287 + PlSqlLexerPERCENT_ROWCOUNT = 1288 + PlSqlLexerPERCENT_ROWTYPE = 1289 + PlSqlLexerPERCENT_TYPE = 1290 + PlSqlLexerPERFORMANCE = 1291 + PlSqlLexerPERIOD_KEYWORD = 1292 + PlSqlLexerPERMANENT = 1293 + PlSqlLexerPERMISSION = 1294 + PlSqlLexerPERMUTE = 1295 + PlSqlLexerPER = 1296 + PlSqlLexerPFILE = 1297 + PlSqlLexerPHYSICAL = 1298 + PlSqlLexerPIKEY = 1299 + PlSqlLexerPIPELINED = 1300 + PlSqlLexerPIPE = 1301 + PlSqlLexerPIV_GB = 1302 + PlSqlLexerPIVOT = 1303 + PlSqlLexerPIV_SSF = 1304 + PlSqlLexerPLACE_DISTINCT = 1305 + PlSqlLexerPLACE_GROUP_BY = 1306 + PlSqlLexerPLAN = 1307 + PlSqlLexerPLSCOPE_SETTINGS = 1308 + PlSqlLexerPLS_INTEGER = 1309 + PlSqlLexerPLSQL_CCFLAGS = 1310 + PlSqlLexerPLSQL_CODE_TYPE = 1311 + PlSqlLexerPLSQL_DEBUG = 1312 + PlSqlLexerPLSQL_OPTIMIZE_LEVEL = 1313 + PlSqlLexerPLSQL_WARNINGS = 1314 + PlSqlLexerPLUGGABLE = 1315 + PlSqlLexerPMEM = 1316 + PlSqlLexerPOINT = 1317 + PlSqlLexerPOLICY = 1318 + PlSqlLexerPOOL_16K = 1319 + PlSqlLexerPOOL_2K = 1320 + PlSqlLexerPOOL_32K = 1321 + PlSqlLexerPOOL_4K = 1322 + PlSqlLexerPOOL_8K = 1323 + PlSqlLexerPOSITIVEN = 1324 + PlSqlLexerPOSITIVE = 1325 + PlSqlLexerPOST_TRANSACTION = 1326 + PlSqlLexerPOWERMULTISET_BY_CARDINALITY = 1327 + PlSqlLexerPOWERMULTISET = 1328 + PlSqlLexerPOWER = 1329 + PlSqlLexerPQ_CONCURRENT_UNION = 1330 + PlSqlLexerPQ_DISTRIBUTE = 1331 + PlSqlLexerPQ_DISTRIBUTE_WINDOW = 1332 + PlSqlLexerPQ_FILTER = 1333 + PlSqlLexerPQ_MAP = 1334 + PlSqlLexerPQ_NOMAP = 1335 + PlSqlLexerPQ_REPLICATE = 1336 + PlSqlLexerPQ_SKEW = 1337 + PlSqlLexerPRAGMA = 1338 + PlSqlLexerPREBUILT = 1339 + PlSqlLexerPRECEDES = 1340 + PlSqlLexerPRECEDING = 1341 + PlSqlLexerPRECISION = 1342 + PlSqlLexerPRECOMPUTE_SUBQUERY = 1343 + PlSqlLexerPREDICATE_REORDERS = 1344 + PlSqlLexerPRELOAD = 1345 + PlSqlLexerPREPARE = 1346 + PlSqlLexerPRESENTNNV = 1347 + PlSqlLexerPRESENT = 1348 + PlSqlLexerPRESENTV = 1349 + PlSqlLexerPRESERVE_OID = 1350 + PlSqlLexerPRESERVE = 1351 + PlSqlLexerPRETTY = 1352 + PlSqlLexerPREVIOUS = 1353 + PlSqlLexerPREV = 1354 + PlSqlLexerPRIMARY = 1355 + PlSqlLexerPRINTBLOBTOCLOB = 1356 + PlSqlLexerPRIORITY = 1357 + PlSqlLexerPRIOR = 1358 + PlSqlLexerPRIVATE = 1359 + PlSqlLexerPRIVATE_SGA = 1360 + PlSqlLexerPRIVILEGED = 1361 + PlSqlLexerPRIVILEGE = 1362 + PlSqlLexerPRIVILEGES = 1363 + PlSqlLexerPROCEDURAL = 1364 + PlSqlLexerPROCEDURE = 1365 + PlSqlLexerPROCESS = 1366 + PlSqlLexerPROFILE = 1367 + PlSqlLexerPROGRAM = 1368 + PlSqlLexerPROJECT = 1369 + PlSqlLexerPROPAGATE = 1370 + PlSqlLexerPROPERTY = 1371 + PlSqlLexerPROTECTED = 1372 + PlSqlLexerPROTECTION = 1373 + PlSqlLexerPROTOCOL = 1374 + PlSqlLexerPROXY = 1375 + PlSqlLexerPRUNING = 1376 + PlSqlLexerPUBLIC = 1377 + PlSqlLexerPULL_PRED = 1378 + PlSqlLexerPURGE = 1379 + PlSqlLexerPUSH_PRED = 1380 + PlSqlLexerPUSH_SUBQ = 1381 + PlSqlLexerPX_FAULT_TOLERANCE = 1382 + PlSqlLexerPX_GRANULE = 1383 + PlSqlLexerPX_JOIN_FILTER = 1384 + PlSqlLexerQB_NAME = 1385 + PlSqlLexerQUARTERS = 1386 + PlSqlLexerQUERY_BLOCK = 1387 + PlSqlLexerQUERY = 1388 + PlSqlLexerQUEUE_CURR = 1389 + PlSqlLexerQUEUE = 1390 + PlSqlLexerQUEUE_ROWP = 1391 + PlSqlLexerQUIESCE = 1392 + PlSqlLexerQUORUM = 1393 + PlSqlLexerQUOTA = 1394 + PlSqlLexerQUOTAGROUP = 1395 + PlSqlLexerRAISE = 1396 + PlSqlLexerRANDOM_LOCAL = 1397 + PlSqlLexerRANDOM = 1398 + PlSqlLexerRANGE = 1399 + PlSqlLexerRANKM = 1400 + PlSqlLexerRAPIDLY = 1401 + PlSqlLexerRAW = 1402 + PlSqlLexerRAWTOHEX = 1403 + PlSqlLexerRAWTONHEX = 1404 + PlSqlLexerRBA = 1405 + PlSqlLexerRBO_OUTLINE = 1406 + PlSqlLexerRDBA = 1407 + PlSqlLexerREAD = 1408 + PlSqlLexerREADS = 1409 + PlSqlLexerREALM = 1410 + PlSqlLexerREAL = 1411 + PlSqlLexerREBALANCE = 1412 + PlSqlLexerREBUILD = 1413 + PlSqlLexerRECORD = 1414 + PlSqlLexerRECORDS_PER_BLOCK = 1415 + PlSqlLexerRECOVERABLE = 1416 + PlSqlLexerRECOVER = 1417 + PlSqlLexerRECOVERY = 1418 + PlSqlLexerRECYCLEBIN = 1419 + PlSqlLexerRECYCLE = 1420 + PlSqlLexerREDACTION = 1421 + PlSqlLexerREDEFINE = 1422 + PlSqlLexerREDO = 1423 + PlSqlLexerREDUCED = 1424 + PlSqlLexerREDUNDANCY = 1425 + PlSqlLexerREF_CASCADE_CURSOR = 1426 + PlSqlLexerREFERENCED = 1427 + PlSqlLexerREFERENCE = 1428 + PlSqlLexerREFERENCES = 1429 + PlSqlLexerREFERENCING = 1430 + PlSqlLexerREF = 1431 + PlSqlLexerREFRESH = 1432 + PlSqlLexerREFTOHEX = 1433 + PlSqlLexerREGEXP_COUNT = 1434 + PlSqlLexerREGEXP_INSTR = 1435 + PlSqlLexerREGEXP_LIKE = 1436 + PlSqlLexerREGEXP_REPLACE = 1437 + PlSqlLexerREGEXP_SUBSTR = 1438 + PlSqlLexerREGISTER = 1439 + PlSqlLexerREGR_AVGX = 1440 + PlSqlLexerREGR_AVGY = 1441 + PlSqlLexerREGR_COUNT = 1442 + PlSqlLexerREGR_INTERCEPT = 1443 + PlSqlLexerREGR_R2 = 1444 + PlSqlLexerREGR_SLOPE = 1445 + PlSqlLexerREGR_SXX = 1446 + PlSqlLexerREGR_SXY = 1447 + PlSqlLexerREGR_SYY = 1448 + PlSqlLexerREGULAR = 1449 + PlSqlLexerREJECT = 1450 + PlSqlLexerREKEY = 1451 + PlSqlLexerRELATIONAL = 1452 + PlSqlLexerRELIES_ON = 1453 + PlSqlLexerRELOCATE = 1454 + PlSqlLexerRELY = 1455 + PlSqlLexerREMAINDER = 1456 + PlSqlLexerREMOTE = 1457 + PlSqlLexerREMOTE_MAPPED = 1458 + PlSqlLexerREMOVE = 1459 + PlSqlLexerRENAME = 1460 + PlSqlLexerREPAIR = 1461 + PlSqlLexerREPEAT = 1462 + PlSqlLexerREPLACE = 1463 + PlSqlLexerREPLICATION = 1464 + PlSqlLexerREQUIRED = 1465 + PlSqlLexerRESETLOGS = 1466 + PlSqlLexerRESET = 1467 + PlSqlLexerRESIZE = 1468 + PlSqlLexerRESOLVE = 1469 + PlSqlLexerRESOLVER = 1470 + PlSqlLexerRESOURCE = 1471 + PlSqlLexerRESPECT = 1472 + PlSqlLexerRESTART = 1473 + PlSqlLexerRESTORE_AS_INTERVALS = 1474 + PlSqlLexerRESTORE = 1475 + PlSqlLexerRESTRICT_ALL_REF_CONS = 1476 + PlSqlLexerRESTRICTED = 1477 + PlSqlLexerRESTRICT_REFERENCES = 1478 + PlSqlLexerRESTRICT = 1479 + PlSqlLexerRESULT_CACHE = 1480 + PlSqlLexerRESULT = 1481 + PlSqlLexerRESUMABLE = 1482 + PlSqlLexerRESUME = 1483 + PlSqlLexerRETENTION = 1484 + PlSqlLexerRETRY_ON_ROW_CHANGE = 1485 + PlSqlLexerRETURNING = 1486 + PlSqlLexerRETURN = 1487 + PlSqlLexerREUSE = 1488 + PlSqlLexerREVERSE = 1489 + PlSqlLexerREVOKE = 1490 + PlSqlLexerREWRITE_OR_ERROR = 1491 + PlSqlLexerREWRITE = 1492 + PlSqlLexerRIGHT = 1493 + PlSqlLexerROLE = 1494 + PlSqlLexerROLESET = 1495 + PlSqlLexerROLES = 1496 + PlSqlLexerROLLBACK = 1497 + PlSqlLexerROLLING = 1498 + PlSqlLexerROLLUP = 1499 + PlSqlLexerROWDEPENDENCIES = 1500 + PlSqlLexerROWID_MAPPING_TABLE = 1501 + PlSqlLexerROWID = 1502 + PlSqlLexerROWIDTOCHAR = 1503 + PlSqlLexerROWIDTONCHAR = 1504 + PlSqlLexerROW_LENGTH = 1505 + PlSqlLexerROWNUM = 1506 + PlSqlLexerROW = 1507 + PlSqlLexerROWS = 1508 + PlSqlLexerRPAD = 1509 + PlSqlLexerRTRIM = 1510 + PlSqlLexerRULE = 1511 + PlSqlLexerRULES = 1512 + PlSqlLexerRUNNING = 1513 + PlSqlLexerSALT = 1514 + PlSqlLexerSAMPLE = 1515 + PlSqlLexerSAVE_AS_INTERVALS = 1516 + PlSqlLexerSAVEPOINT = 1517 + PlSqlLexerSAVE = 1518 + PlSqlLexerSB4 = 1519 + PlSqlLexerSCALE_ROWS = 1520 + PlSqlLexerSCALE = 1521 + PlSqlLexerSCAN_INSTANCES = 1522 + PlSqlLexerSCAN = 1523 + PlSqlLexerSCHEDULER = 1524 + PlSqlLexerSCHEMACHECK = 1525 + PlSqlLexerSCHEMA = 1526 + PlSqlLexerSCN_ASCENDING = 1527 + PlSqlLexerSCN = 1528 + PlSqlLexerSCOPE = 1529 + PlSqlLexerSCRUB = 1530 + PlSqlLexerSD_ALL = 1531 + PlSqlLexerSD_INHIBIT = 1532 + PlSqlLexerSDO_GEOM_MBR = 1533 + PlSqlLexerSDO_GEOMETRY = 1534 + PlSqlLexerSD_SHOW = 1535 + PlSqlLexerSEARCH = 1536 + PlSqlLexerSECOND = 1537 + PlSqlLexerSECONDS = 1538 + PlSqlLexerSECRET = 1539 + PlSqlLexerSECUREFILE_DBA = 1540 + PlSqlLexerSECUREFILE = 1541 + PlSqlLexerSECURITY = 1542 + PlSqlLexerSEED = 1543 + PlSqlLexerSEG_BLOCK = 1544 + PlSqlLexerSEG_FILE = 1545 + PlSqlLexerSEGMENT = 1546 + PlSqlLexerSELECTIVITY = 1547 + PlSqlLexerSELECT = 1548 + PlSqlLexerSELF = 1549 + PlSqlLexerSEMIJOIN_DRIVER = 1550 + PlSqlLexerSEMIJOIN = 1551 + PlSqlLexerSEMI_TO_INNER = 1552 + PlSqlLexerSEQUENCED = 1553 + PlSqlLexerSEQUENCE = 1554 + PlSqlLexerSEQUENTIAL = 1555 + PlSqlLexerSERIALIZABLE = 1556 + PlSqlLexerSERIALLY_REUSABLE = 1557 + PlSqlLexerSERIAL = 1558 + PlSqlLexerSERVERERROR = 1559 + PlSqlLexerSERVICE_NAME_CONVERT = 1560 + PlSqlLexerSERVICE = 1561 + PlSqlLexerSERVICES = 1562 + PlSqlLexerSESSION_CACHED_CURSORS = 1563 + PlSqlLexerSESSION = 1564 + PlSqlLexerSESSIONS_PER_USER = 1565 + PlSqlLexerSESSIONTIMEZONE = 1566 + PlSqlLexerSESSIONTZNAME = 1567 + PlSqlLexerSET = 1568 + PlSqlLexerSETS = 1569 + PlSqlLexerSETTINGS = 1570 + PlSqlLexerSET_TO_JOIN = 1571 + PlSqlLexerSEVERE = 1572 + PlSqlLexerSHARDSPACE = 1573 + PlSqlLexerSHARED_POOL = 1574 + PlSqlLexerSHARED = 1575 + PlSqlLexerSHARE = 1576 + PlSqlLexerSHARING = 1577 + PlSqlLexerSHELFLIFE = 1578 + PlSqlLexerSHOW = 1579 + PlSqlLexerSHRINK = 1580 + PlSqlLexerSHUTDOWN = 1581 + PlSqlLexerSIBLINGS = 1582 + PlSqlLexerSID = 1583 + PlSqlLexerSITE = 1584 + PlSqlLexerSIGNAL_COMPONENT = 1585 + PlSqlLexerSIGNAL_FUNCTION = 1586 + PlSqlLexerSIGN = 1587 + PlSqlLexerSIGNTYPE = 1588 + PlSqlLexerSIMPLE_INTEGER = 1589 + PlSqlLexerSIMPLE = 1590 + PlSqlLexerSINGLE = 1591 + PlSqlLexerSINGLETASK = 1592 + PlSqlLexerSINH = 1593 + PlSqlLexerSIN = 1594 + PlSqlLexerSIZE = 1595 + PlSqlLexerSKIP_EXT_OPTIMIZER = 1596 + PlSqlLexerSKIP_ = 1597 + PlSqlLexerSKIP_UNQ_UNUSABLE_IDX = 1598 + PlSqlLexerSKIP_UNUSABLE_INDEXES = 1599 + PlSqlLexerSMALLFILE = 1600 + PlSqlLexerSMALLINT = 1601 + PlSqlLexerSNAPSHOT = 1602 + PlSqlLexerSOME = 1603 + PlSqlLexerSORT = 1604 + PlSqlLexerSOUNDEX = 1605 + PlSqlLexerSOURCE_FILE_DIRECTORY = 1606 + PlSqlLexerSOURCE_FILE_NAME_CONVERT = 1607 + PlSqlLexerSOURCE = 1608 + PlSqlLexerSPACE_KEYWORD = 1609 + PlSqlLexerSPECIFICATION = 1610 + PlSqlLexerSPFILE = 1611 + PlSqlLexerSPLIT = 1612 + PlSqlLexerSPREADSHEET = 1613 + PlSqlLexerSQLDATA = 1614 + PlSqlLexerSQLERROR = 1615 + PlSqlLexerSQLLDR = 1616 + PlSqlLexerSQL = 1617 + PlSqlLexerSQL_MACRO = 1618 + PlSqlLexerSQL_TRACE = 1619 + PlSqlLexerSQL_TRANSLATION_PROFILE = 1620 + PlSqlLexerSQRT = 1621 + PlSqlLexerSTALE = 1622 + PlSqlLexerSTANDALONE = 1623 + PlSqlLexerSTANDARD = 1624 + PlSqlLexerSTANDARD_HASH = 1625 + PlSqlLexerSTANDBY_MAX_DATA_DELAY = 1626 + PlSqlLexerSTANDBYS = 1627 + PlSqlLexerSTANDBY = 1628 + PlSqlLexerSTAR = 1629 + PlSqlLexerSTAR_TRANSFORMATION = 1630 + PlSqlLexerSTART = 1631 + PlSqlLexerSTARTUP = 1632 + PlSqlLexerSTATEMENT_ID = 1633 + PlSqlLexerSTATEMENT_QUEUING = 1634 + PlSqlLexerSTATEMENTS = 1635 + PlSqlLexerSTATEMENT = 1636 + PlSqlLexerSTATE = 1637 + PlSqlLexerSTATIC = 1638 + PlSqlLexerSTATISTICS = 1639 + PlSqlLexerSTATS_BINOMIAL_TEST = 1640 + PlSqlLexerSTATS_CROSSTAB = 1641 + PlSqlLexerSTATS_F_TEST = 1642 + PlSqlLexerSTATS_KS_TEST = 1643 + PlSqlLexerSTATS_MODE = 1644 + PlSqlLexerSTATS_MW_TEST = 1645 + PlSqlLexerSTATS_ONE_WAY_ANOVA = 1646 + PlSqlLexerSTATS_T_TEST_INDEP = 1647 + PlSqlLexerSTATS_T_TEST_INDEPU = 1648 + PlSqlLexerSTATS_T_TEST_ONE = 1649 + PlSqlLexerSTATS_T_TEST_PAIRED = 1650 + PlSqlLexerSTATS_WSR_TEST = 1651 + PlSqlLexerSTDDEV_POP = 1652 + PlSqlLexerSTDDEV_SAMP = 1653 + PlSqlLexerSTOP = 1654 + PlSqlLexerSTORAGE = 1655 + PlSqlLexerSTORE = 1656 + PlSqlLexerSTREAMS = 1657 + PlSqlLexerSTREAM = 1658 + PlSqlLexerSTRICT = 1659 + PlSqlLexerSTRING = 1660 + PlSqlLexerSTRIPE_COLUMNS = 1661 + PlSqlLexerSTRIPE_WIDTH = 1662 + PlSqlLexerSTRIP = 1663 + PlSqlLexerSTRUCTURE = 1664 + PlSqlLexerSUBMULTISET = 1665 + PlSqlLexerSUBPARTITION_REL = 1666 + PlSqlLexerSUBPARTITIONS = 1667 + PlSqlLexerSUBPARTITION = 1668 + PlSqlLexerSUBQUERIES = 1669 + PlSqlLexerSUBQUERY_PRUNING = 1670 + PlSqlLexerSUBSCRIBE = 1671 + PlSqlLexerSUBSET = 1672 + PlSqlLexerSUBSTITUTABLE = 1673 + PlSqlLexerSUBSTR2 = 1674 + PlSqlLexerSUBSTR4 = 1675 + PlSqlLexerSUBSTRB = 1676 + PlSqlLexerSUBSTRC = 1677 + PlSqlLexerSUBTYPE = 1678 + PlSqlLexerSUCCESSFUL = 1679 + PlSqlLexerSUCCESS = 1680 + PlSqlLexerSUMMARY = 1681 + PlSqlLexerSUPPLEMENTAL = 1682 + PlSqlLexerSUSPEND = 1683 + PlSqlLexerSWAP_JOIN_INPUTS = 1684 + PlSqlLexerSWITCHOVER = 1685 + PlSqlLexerSWITCH = 1686 + PlSqlLexerSYNCHRONOUS = 1687 + PlSqlLexerSYNC = 1688 + PlSqlLexerSYNONYM = 1689 + PlSqlLexerSYS = 1690 + PlSqlLexerSYSASM = 1691 + PlSqlLexerSYS_AUDIT = 1692 + PlSqlLexerSYSAUX = 1693 + PlSqlLexerSYSBACKUP = 1694 + PlSqlLexerSYS_CHECKACL = 1695 + PlSqlLexerSYS_CHECK_PRIVILEGE = 1696 + PlSqlLexerSYS_CONNECT_BY_PATH = 1697 + PlSqlLexerSYS_CONTEXT = 1698 + PlSqlLexerSYSDATE = 1699 + PlSqlLexerSYSDBA = 1700 + PlSqlLexerSYS_DBURIGEN = 1701 + PlSqlLexerSYSDG = 1702 + PlSqlLexerSYS_DL_CURSOR = 1703 + PlSqlLexerSYS_DM_RXFORM_CHR = 1704 + PlSqlLexerSYS_DM_RXFORM_NUM = 1705 + PlSqlLexerSYS_DOM_COMPARE = 1706 + PlSqlLexerSYS_DST_PRIM2SEC = 1707 + PlSqlLexerSYS_DST_SEC2PRIM = 1708 + PlSqlLexerSYS_ET_BFILE_TO_RAW = 1709 + PlSqlLexerSYS_ET_BLOB_TO_IMAGE = 1710 + PlSqlLexerSYS_ET_IMAGE_TO_BLOB = 1711 + PlSqlLexerSYS_ET_RAW_TO_BFILE = 1712 + PlSqlLexerSYS_EXTPDTXT = 1713 + PlSqlLexerSYS_EXTRACT_UTC = 1714 + PlSqlLexerSYS_FBT_INSDEL = 1715 + PlSqlLexerSYS_FILTER_ACLS = 1716 + PlSqlLexerSYS_FNMATCHES = 1717 + PlSqlLexerSYS_FNREPLACE = 1718 + PlSqlLexerSYS_GET_ACLIDS = 1719 + PlSqlLexerSYS_GET_COL_ACLIDS = 1720 + PlSqlLexerSYS_GET_PRIVILEGES = 1721 + PlSqlLexerSYS_GETTOKENID = 1722 + PlSqlLexerSYS_GETXTIVAL = 1723 + PlSqlLexerSYS_GUID = 1724 + PlSqlLexerSYSGUID = 1725 + PlSqlLexerSYSKM = 1726 + PlSqlLexerSYS_MAKE_XMLNODEID = 1727 + PlSqlLexerSYS_MAKEXML = 1728 + PlSqlLexerSYS_MKXMLATTR = 1729 + PlSqlLexerSYS_MKXTI = 1730 + PlSqlLexerSYSOBJ = 1731 + PlSqlLexerSYS_OP_ADT2BIN = 1732 + PlSqlLexerSYS_OP_ADTCONS = 1733 + PlSqlLexerSYS_OP_ALSCRVAL = 1734 + PlSqlLexerSYS_OP_ATG = 1735 + PlSqlLexerSYS_OP_BIN2ADT = 1736 + PlSqlLexerSYS_OP_BITVEC = 1737 + PlSqlLexerSYS_OP_BL2R = 1738 + PlSqlLexerSYS_OP_BLOOM_FILTER_LIST = 1739 + PlSqlLexerSYS_OP_BLOOM_FILTER = 1740 + PlSqlLexerSYS_OP_C2C = 1741 + PlSqlLexerSYS_OP_CAST = 1742 + PlSqlLexerSYS_OP_CEG = 1743 + PlSqlLexerSYS_OP_CL2C = 1744 + PlSqlLexerSYS_OP_COMBINED_HASH = 1745 + PlSqlLexerSYS_OP_COMP = 1746 + PlSqlLexerSYS_OP_CONVERT = 1747 + PlSqlLexerSYS_OP_COUNTCHG = 1748 + PlSqlLexerSYS_OP_CSCONV = 1749 + PlSqlLexerSYS_OP_CSCONVTEST = 1750 + PlSqlLexerSYS_OP_CSR = 1751 + PlSqlLexerSYS_OP_CSX_PATCH = 1752 + PlSqlLexerSYS_OP_CYCLED_SEQ = 1753 + PlSqlLexerSYS_OP_DECOMP = 1754 + PlSqlLexerSYS_OP_DESCEND = 1755 + PlSqlLexerSYS_OP_DISTINCT = 1756 + PlSqlLexerSYS_OP_DRA = 1757 + PlSqlLexerSYS_OP_DUMP = 1758 + PlSqlLexerSYS_OP_DV_CHECK = 1759 + PlSqlLexerSYS_OP_ENFORCE_NOT_NULL = 1760 + PlSqlLexerSYSOPER = 1761 + PlSqlLexerSYS_OP_EXTRACT = 1762 + PlSqlLexerSYS_OP_GROUPING = 1763 + PlSqlLexerSYS_OP_GUID = 1764 + PlSqlLexerSYS_OP_HASH = 1765 + PlSqlLexerSYS_OP_IIX = 1766 + PlSqlLexerSYS_OP_ITR = 1767 + PlSqlLexerSYS_OP_KEY_VECTOR_CREATE = 1768 + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER_LIST = 1769 + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER = 1770 + PlSqlLexerSYS_OP_KEY_VECTOR_SUCCEEDED = 1771 + PlSqlLexerSYS_OP_KEY_VECTOR_USE = 1772 + PlSqlLexerSYS_OP_LBID = 1773 + PlSqlLexerSYS_OP_LOBLOC2BLOB = 1774 + PlSqlLexerSYS_OP_LOBLOC2CLOB = 1775 + PlSqlLexerSYS_OP_LOBLOC2ID = 1776 + PlSqlLexerSYS_OP_LOBLOC2NCLOB = 1777 + PlSqlLexerSYS_OP_LOBLOC2TYP = 1778 + PlSqlLexerSYS_OP_LSVI = 1779 + PlSqlLexerSYS_OP_LVL = 1780 + PlSqlLexerSYS_OP_MAKEOID = 1781 + PlSqlLexerSYS_OP_MAP_NONNULL = 1782 + PlSqlLexerSYS_OP_MSR = 1783 + PlSqlLexerSYS_OP_NICOMBINE = 1784 + PlSqlLexerSYS_OP_NIEXTRACT = 1785 + PlSqlLexerSYS_OP_NII = 1786 + PlSqlLexerSYS_OP_NIX = 1787 + PlSqlLexerSYS_OP_NOEXPAND = 1788 + PlSqlLexerSYS_OP_NTCIMG = 1789 + PlSqlLexerSYS_OP_NUMTORAW = 1790 + PlSqlLexerSYS_OP_OIDVALUE = 1791 + PlSqlLexerSYS_OP_OPNSIZE = 1792 + PlSqlLexerSYS_OP_PAR_1 = 1793 + PlSqlLexerSYS_OP_PARGID_1 = 1794 + PlSqlLexerSYS_OP_PARGID = 1795 + PlSqlLexerSYS_OP_PAR = 1796 + PlSqlLexerSYS_OP_PART_ID = 1797 + PlSqlLexerSYS_OP_PIVOT = 1798 + PlSqlLexerSYS_OP_R2O = 1799 + PlSqlLexerSYS_OP_RAWTONUM = 1800 + PlSqlLexerSYS_OP_RDTM = 1801 + PlSqlLexerSYS_OP_REF = 1802 + PlSqlLexerSYS_OP_RMTD = 1803 + PlSqlLexerSYS_OP_ROWIDTOOBJ = 1804 + PlSqlLexerSYS_OP_RPB = 1805 + PlSqlLexerSYS_OPTLOBPRBSC = 1806 + PlSqlLexerSYS_OP_TOSETID = 1807 + PlSqlLexerSYS_OP_TPR = 1808 + PlSqlLexerSYS_OP_TRTB = 1809 + PlSqlLexerSYS_OPTXICMP = 1810 + PlSqlLexerSYS_OPTXQCASTASNQ = 1811 + PlSqlLexerSYS_OP_UNDESCEND = 1812 + PlSqlLexerSYS_OP_VECAND = 1813 + PlSqlLexerSYS_OP_VECBIT = 1814 + PlSqlLexerSYS_OP_VECOR = 1815 + PlSqlLexerSYS_OP_VECXOR = 1816 + PlSqlLexerSYS_OP_VERSION = 1817 + PlSqlLexerSYS_OP_VREF = 1818 + PlSqlLexerSYS_OP_VVD = 1819 + PlSqlLexerSYS_OP_XMLCONS_FOR_CSX = 1820 + PlSqlLexerSYS_OP_XPTHATG = 1821 + PlSqlLexerSYS_OP_XPTHIDX = 1822 + PlSqlLexerSYS_OP_XPTHOP = 1823 + PlSqlLexerSYS_OP_XTXT2SQLT = 1824 + PlSqlLexerSYS_OP_ZONE_ID = 1825 + PlSqlLexerSYS_ORDERKEY_DEPTH = 1826 + PlSqlLexerSYS_ORDERKEY_MAXCHILD = 1827 + PlSqlLexerSYS_ORDERKEY_PARENT = 1828 + PlSqlLexerSYS_PARALLEL_TXN = 1829 + PlSqlLexerSYS_PATHID_IS_ATTR = 1830 + PlSqlLexerSYS_PATHID_IS_NMSPC = 1831 + PlSqlLexerSYS_PATHID_LASTNAME = 1832 + PlSqlLexerSYS_PATHID_LASTNMSPC = 1833 + PlSqlLexerSYS_PATH_REVERSE = 1834 + PlSqlLexerSYS_PXQEXTRACT = 1835 + PlSqlLexerSYS_RAW_TO_XSID = 1836 + PlSqlLexerSYS_RID_ORDER = 1837 + PlSqlLexerSYS_ROW_DELTA = 1838 + PlSqlLexerSYS_SC_2_XMLT = 1839 + PlSqlLexerSYS_SYNRCIREDO = 1840 + PlSqlLexerSYSTEM_DEFINED = 1841 + PlSqlLexerSYSTEM = 1842 + PlSqlLexerSYSTIMESTAMP = 1843 + PlSqlLexerSYS_TYPEID = 1844 + PlSqlLexerSYS_UMAKEXML = 1845 + PlSqlLexerSYS_XMLANALYZE = 1846 + PlSqlLexerSYS_XMLCONTAINS = 1847 + PlSqlLexerSYS_XMLCONV = 1848 + PlSqlLexerSYS_XMLEXNSURI = 1849 + PlSqlLexerSYS_XMLGEN = 1850 + PlSqlLexerSYS_XMLI_LOC_ISNODE = 1851 + PlSqlLexerSYS_XMLI_LOC_ISTEXT = 1852 + PlSqlLexerSYS_XMLINSTR = 1853 + PlSqlLexerSYS_XMLLOCATOR_GETSVAL = 1854 + PlSqlLexerSYS_XMLNODEID_GETCID = 1855 + PlSqlLexerSYS_XMLNODEID_GETLOCATOR = 1856 + PlSqlLexerSYS_XMLNODEID_GETOKEY = 1857 + PlSqlLexerSYS_XMLNODEID_GETPATHID = 1858 + PlSqlLexerSYS_XMLNODEID_GETPTRID = 1859 + PlSqlLexerSYS_XMLNODEID_GETRID = 1860 + PlSqlLexerSYS_XMLNODEID_GETSVAL = 1861 + PlSqlLexerSYS_XMLNODEID_GETTID = 1862 + PlSqlLexerSYS_XMLNODEID = 1863 + PlSqlLexerSYS_XMLT_2_SC = 1864 + PlSqlLexerSYS_XMLTRANSLATE = 1865 + PlSqlLexerSYS_XMLTYPE2SQL = 1866 + PlSqlLexerSYS_XQ_ASQLCNV = 1867 + PlSqlLexerSYS_XQ_ATOMCNVCHK = 1868 + PlSqlLexerSYS_XQBASEURI = 1869 + PlSqlLexerSYS_XQCASTABLEERRH = 1870 + PlSqlLexerSYS_XQCODEP2STR = 1871 + PlSqlLexerSYS_XQCODEPEQ = 1872 + PlSqlLexerSYS_XQCON2SEQ = 1873 + PlSqlLexerSYS_XQCONCAT = 1874 + PlSqlLexerSYS_XQDELETE = 1875 + PlSqlLexerSYS_XQDFLTCOLATION = 1876 + PlSqlLexerSYS_XQDOC = 1877 + PlSqlLexerSYS_XQDOCURI = 1878 + PlSqlLexerSYS_XQDURDIV = 1879 + PlSqlLexerSYS_XQED4URI = 1880 + PlSqlLexerSYS_XQENDSWITH = 1881 + PlSqlLexerSYS_XQERRH = 1882 + PlSqlLexerSYS_XQERR = 1883 + PlSqlLexerSYS_XQESHTMLURI = 1884 + PlSqlLexerSYS_XQEXLOBVAL = 1885 + PlSqlLexerSYS_XQEXSTWRP = 1886 + PlSqlLexerSYS_XQEXTRACT = 1887 + PlSqlLexerSYS_XQEXTRREF = 1888 + PlSqlLexerSYS_XQEXVAL = 1889 + PlSqlLexerSYS_XQFB2STR = 1890 + PlSqlLexerSYS_XQFNBOOL = 1891 + PlSqlLexerSYS_XQFNCMP = 1892 + PlSqlLexerSYS_XQFNDATIM = 1893 + PlSqlLexerSYS_XQFNLNAME = 1894 + PlSqlLexerSYS_XQFNNM = 1895 + PlSqlLexerSYS_XQFNNSURI = 1896 + PlSqlLexerSYS_XQFNPREDTRUTH = 1897 + PlSqlLexerSYS_XQFNQNM = 1898 + PlSqlLexerSYS_XQFNROOT = 1899 + PlSqlLexerSYS_XQFORMATNUM = 1900 + PlSqlLexerSYS_XQFTCONTAIN = 1901 + PlSqlLexerSYS_XQFUNCR = 1902 + PlSqlLexerSYS_XQGETCONTENT = 1903 + PlSqlLexerSYS_XQINDXOF = 1904 + PlSqlLexerSYS_XQINSERT = 1905 + PlSqlLexerSYS_XQINSPFX = 1906 + PlSqlLexerSYS_XQIRI2URI = 1907 + PlSqlLexerSYS_XQLANG = 1908 + PlSqlLexerSYS_XQLLNMFRMQNM = 1909 + PlSqlLexerSYS_XQMKNODEREF = 1910 + PlSqlLexerSYS_XQNILLED = 1911 + PlSqlLexerSYS_XQNODENAME = 1912 + PlSqlLexerSYS_XQNORMSPACE = 1913 + PlSqlLexerSYS_XQNORMUCODE = 1914 + PlSqlLexerSYS_XQ_NRNG = 1915 + PlSqlLexerSYS_XQNSP4PFX = 1916 + PlSqlLexerSYS_XQNSPFRMQNM = 1917 + PlSqlLexerSYS_XQPFXFRMQNM = 1918 + PlSqlLexerSYS_XQ_PKSQL2XML = 1919 + PlSqlLexerSYS_XQPOLYABS = 1920 + PlSqlLexerSYS_XQPOLYADD = 1921 + PlSqlLexerSYS_XQPOLYCEL = 1922 + PlSqlLexerSYS_XQPOLYCSTBL = 1923 + PlSqlLexerSYS_XQPOLYCST = 1924 + PlSqlLexerSYS_XQPOLYDIV = 1925 + PlSqlLexerSYS_XQPOLYFLR = 1926 + PlSqlLexerSYS_XQPOLYMOD = 1927 + PlSqlLexerSYS_XQPOLYMUL = 1928 + PlSqlLexerSYS_XQPOLYRND = 1929 + PlSqlLexerSYS_XQPOLYSQRT = 1930 + PlSqlLexerSYS_XQPOLYSUB = 1931 + PlSqlLexerSYS_XQPOLYUMUS = 1932 + PlSqlLexerSYS_XQPOLYUPLS = 1933 + PlSqlLexerSYS_XQPOLYVEQ = 1934 + PlSqlLexerSYS_XQPOLYVGE = 1935 + PlSqlLexerSYS_XQPOLYVGT = 1936 + PlSqlLexerSYS_XQPOLYVLE = 1937 + PlSqlLexerSYS_XQPOLYVLT = 1938 + PlSqlLexerSYS_XQPOLYVNE = 1939 + PlSqlLexerSYS_XQREF2VAL = 1940 + PlSqlLexerSYS_XQRENAME = 1941 + PlSqlLexerSYS_XQREPLACE = 1942 + PlSqlLexerSYS_XQRESVURI = 1943 + PlSqlLexerSYS_XQRNDHALF2EVN = 1944 + PlSqlLexerSYS_XQRSLVQNM = 1945 + PlSqlLexerSYS_XQRYENVPGET = 1946 + PlSqlLexerSYS_XQRYVARGET = 1947 + PlSqlLexerSYS_XQRYWRP = 1948 + PlSqlLexerSYS_XQSEQ2CON4XC = 1949 + PlSqlLexerSYS_XQSEQ2CON = 1950 + PlSqlLexerSYS_XQSEQDEEPEQ = 1951 + PlSqlLexerSYS_XQSEQINSB = 1952 + PlSqlLexerSYS_XQSEQRM = 1953 + PlSqlLexerSYS_XQSEQRVS = 1954 + PlSqlLexerSYS_XQSEQSUB = 1955 + PlSqlLexerSYS_XQSEQTYPMATCH = 1956 + PlSqlLexerSYS_XQSTARTSWITH = 1957 + PlSqlLexerSYS_XQSTATBURI = 1958 + PlSqlLexerSYS_XQSTR2CODEP = 1959 + PlSqlLexerSYS_XQSTRJOIN = 1960 + PlSqlLexerSYS_XQSUBSTRAFT = 1961 + PlSqlLexerSYS_XQSUBSTRBEF = 1962 + PlSqlLexerSYS_XQTOKENIZE = 1963 + PlSqlLexerSYS_XQTREATAS = 1964 + PlSqlLexerSYS_XQ_UPKXML2SQL = 1965 + PlSqlLexerSYS_XQXFORM = 1966 + PlSqlLexerSYS_XSID_TO_RAW = 1967 + PlSqlLexerSYS_ZMAP_FILTER = 1968 + PlSqlLexerSYS_ZMAP_REFRESH = 1969 + PlSqlLexerT_LETTER = 1970 + PlSqlLexerTABLE_LOOKUP_BY_NL = 1971 + PlSqlLexerTABLESPACE_NO = 1972 + PlSqlLexerTABLESPACE = 1973 + PlSqlLexerTABLES = 1974 + PlSqlLexerTABLE_STATS = 1975 + PlSqlLexerTABLE = 1976 + PlSqlLexerTABNO = 1977 + PlSqlLexerTAG = 1978 + PlSqlLexerTANH = 1979 + PlSqlLexerTAN = 1980 + PlSqlLexerTBLORIDXPARTNUM = 1981 + PlSqlLexerTEMPFILE = 1982 + PlSqlLexerTEMPLATE = 1983 + PlSqlLexerTEMPORARY = 1984 + PlSqlLexerTEMP_TABLE = 1985 + PlSqlLexerTEST = 1986 + PlSqlLexerTEXT = 1987 + PlSqlLexerTHAN = 1988 + PlSqlLexerTHEN = 1989 + PlSqlLexerTHE = 1990 + PlSqlLexerTHREAD = 1991 + PlSqlLexerTHROUGH = 1992 + PlSqlLexerTIER = 1993 + PlSqlLexerTIES = 1994 + PlSqlLexerTIMEOUT = 1995 + PlSqlLexerTIMESTAMP_LTZ_UNCONSTRAINED = 1996 + PlSqlLexerTIMESTAMP = 1997 + PlSqlLexerTIMESTAMP_TZ_UNCONSTRAINED = 1998 + PlSqlLexerTIMESTAMP_UNCONSTRAINED = 1999 + PlSqlLexerTIMES = 2000 + PlSqlLexerTIME = 2001 + PlSqlLexerTIMEZONE = 2002 + PlSqlLexerTIMEZONE_ABBR = 2003 + PlSqlLexerTIMEZONE_HOUR = 2004 + PlSqlLexerTIMEZONE_MINUTE = 2005 + PlSqlLexerTIMEZONE_OFFSET = 2006 + PlSqlLexerTIMEZONE_REGION = 2007 + PlSqlLexerTIME_ZONE = 2008 + PlSqlLexerTIMING = 2009 + PlSqlLexerTIV_GB = 2010 + PlSqlLexerTIV_SSF = 2011 + PlSqlLexerTO_ACLID = 2012 + PlSqlLexerTO_BINARY_DOUBLE = 2013 + PlSqlLexerTO_BINARY_FLOAT = 2014 + PlSqlLexerTO_BLOB = 2015 + PlSqlLexerTO_CLOB = 2016 + PlSqlLexerTO_DSINTERVAL = 2017 + PlSqlLexerTO_LOB = 2018 + PlSqlLexerTO_MULTI_BYTE = 2019 + PlSqlLexerTO_NCHAR = 2020 + PlSqlLexerTO_NCLOB = 2021 + PlSqlLexerTO_NUMBER = 2022 + PlSqlLexerTOPLEVEL = 2023 + PlSqlLexerTO_SINGLE_BYTE = 2024 + PlSqlLexerTO_TIMESTAMP = 2025 + PlSqlLexerTO_TIMESTAMP_TZ = 2026 + PlSqlLexerTO_TIME = 2027 + PlSqlLexerTO_TIME_TZ = 2028 + PlSqlLexerTO = 2029 + PlSqlLexerTO_YMINTERVAL = 2030 + PlSqlLexerTRACE = 2031 + PlSqlLexerTRACING = 2032 + PlSqlLexerTRACKING = 2033 + PlSqlLexerTRAILING = 2034 + PlSqlLexerTRANSACTION = 2035 + PlSqlLexerTRANSFORM = 2036 + PlSqlLexerTRANSFORM_DISTINCT_AGG = 2037 + PlSqlLexerTRANSITIONAL = 2038 + PlSqlLexerTRANSITION = 2039 + PlSqlLexerTRANSLATE = 2040 + PlSqlLexerTRANSLATION = 2041 + PlSqlLexerTREAT = 2042 + PlSqlLexerTRIGGERS = 2043 + PlSqlLexerTRIGGER = 2044 + PlSqlLexerTRUE = 2045 + PlSqlLexerTRUNCATE = 2046 + PlSqlLexerTRUNC = 2047 + PlSqlLexerTRUSTED = 2048 + PlSqlLexerTRUST = 2049 + PlSqlLexerTUNING = 2050 + PlSqlLexerTX = 2051 + PlSqlLexerTYPES = 2052 + PlSqlLexerTYPE = 2053 + PlSqlLexerTZ_OFFSET = 2054 + PlSqlLexerUB2 = 2055 + PlSqlLexerUBA = 2056 + PlSqlLexerUCS2 = 2057 + PlSqlLexerUID = 2058 + PlSqlLexerUNARCHIVED = 2059 + PlSqlLexerUNBOUNDED = 2060 + PlSqlLexerUNBOUND = 2061 + PlSqlLexerUNCONDITIONAL = 2062 + PlSqlLexerUNDER = 2063 + PlSqlLexerUNDO = 2064 + PlSqlLexerUNDROP = 2065 + PlSqlLexerUNIFORM = 2066 + PlSqlLexerUNION = 2067 + PlSqlLexerUNIQUE = 2068 + PlSqlLexerUNISTR = 2069 + PlSqlLexerUNLIMITED = 2070 + PlSqlLexerUNLOAD = 2071 + PlSqlLexerUNLOCK = 2072 + PlSqlLexerUNMATCHED = 2073 + PlSqlLexerUNNEST_INNERJ_DISTINCT_VIEW = 2074 + PlSqlLexerUNNEST_NOSEMIJ_NODISTINCTVIEW = 2075 + PlSqlLexerUNNEST_SEMIJ_VIEW = 2076 + PlSqlLexerUNNEST = 2077 + PlSqlLexerUNPACKED = 2078 + PlSqlLexerUNPIVOT = 2079 + PlSqlLexerUNPLUG = 2080 + PlSqlLexerUNPROTECTED = 2081 + PlSqlLexerUNQUIESCE = 2082 + PlSqlLexerUNRECOVERABLE = 2083 + PlSqlLexerUNRESTRICTED = 2084 + PlSqlLexerUNSUBSCRIBE = 2085 + PlSqlLexerUNTIL = 2086 + PlSqlLexerUNUSABLE = 2087 + PlSqlLexerUNUSED = 2088 + PlSqlLexerUPDATABLE = 2089 + PlSqlLexerUPDATED = 2090 + PlSqlLexerUPDATE = 2091 + PlSqlLexerUPDATEXML = 2092 + PlSqlLexerUPD_INDEXES = 2093 + PlSqlLexerUPD_JOININDEX = 2094 + PlSqlLexerUPGRADE = 2095 + PlSqlLexerUPPER = 2096 + PlSqlLexerUPSERT = 2097 + PlSqlLexerUROWID = 2098 + PlSqlLexerUSABLE = 2099 + PlSqlLexerUSAGE = 2100 + PlSqlLexerUSE_ANTI = 2101 + PlSqlLexerUSE_CONCAT = 2102 + PlSqlLexerUSE_CUBE = 2103 + PlSqlLexerUSE_HASH_AGGREGATION = 2104 + PlSqlLexerUSE_HASH_GBY_FOR_PUSHDOWN = 2105 + PlSqlLexerUSE_HASH = 2106 + PlSqlLexerUSE_HIDDEN_PARTITIONS = 2107 + PlSqlLexerUSE_INVISIBLE_INDEXES = 2108 + PlSqlLexerUSE_MERGE_CARTESIAN = 2109 + PlSqlLexerUSE_MERGE = 2110 + PlSqlLexerUSE_NL = 2111 + PlSqlLexerUSE_NL_WITH_INDEX = 2112 + PlSqlLexerUSE_PRIVATE_OUTLINES = 2113 + PlSqlLexerUSER_DATA = 2114 + PlSqlLexerUSER_DEFINED = 2115 + PlSqlLexerUSERENV = 2116 + PlSqlLexerUSERGROUP = 2117 + PlSqlLexerUSER_RECYCLEBIN = 2118 + PlSqlLexerUSERS = 2119 + PlSqlLexerUSER_TABLESPACES = 2120 + PlSqlLexerUSER = 2121 + PlSqlLexerUSE_SEMI = 2122 + PlSqlLexerUSE_STORED_OUTLINES = 2123 + PlSqlLexerUSE_TTT_FOR_GSETS = 2124 + PlSqlLexerUSE = 2125 + PlSqlLexerUSE_VECTOR_AGGREGATION = 2126 + PlSqlLexerUSE_WEAK_NAME_RESL = 2127 + PlSqlLexerUSING_NO_EXPAND = 2128 + PlSqlLexerUSING = 2129 + PlSqlLexerUTF16BE = 2130 + PlSqlLexerUTF16LE = 2131 + PlSqlLexerUTF32 = 2132 + PlSqlLexerUTF8 = 2133 + PlSqlLexerV1 = 2134 + PlSqlLexerV2 = 2135 + PlSqlLexerVALIDATE = 2136 + PlSqlLexerVALIDATE_CONVERSION = 2137 + PlSqlLexerVALIDATION = 2138 + PlSqlLexerVALID_TIME_END = 2139 + PlSqlLexerVALUES = 2140 + PlSqlLexerVALUE = 2141 + PlSqlLexerVARCHAR2 = 2142 + PlSqlLexerVARCHAR = 2143 + PlSqlLexerVARIABLE = 2144 + PlSqlLexerVAR_POP = 2145 + PlSqlLexerVARRAYS = 2146 + PlSqlLexerVARRAY = 2147 + PlSqlLexerVAR_SAMP = 2148 + PlSqlLexerVARYING = 2149 + PlSqlLexerVECTOR_READ_TRACE = 2150 + PlSqlLexerVECTOR_READ = 2151 + PlSqlLexerVECTOR_TRANSFORM_DIMS = 2152 + PlSqlLexerVECTOR_TRANSFORM_FACT = 2153 + PlSqlLexerVECTOR_TRANSFORM = 2154 + PlSqlLexerVERIFIER = 2155 + PlSqlLexerVERIFY = 2156 + PlSqlLexerVERSIONING = 2157 + PlSqlLexerVERSIONS_ENDSCN = 2158 + PlSqlLexerVERSIONS_ENDTIME = 2159 + PlSqlLexerVERSIONS_OPERATION = 2160 + PlSqlLexerVERSIONS_STARTSCN = 2161 + PlSqlLexerVERSIONS_STARTTIME = 2162 + PlSqlLexerVERSIONS = 2163 + PlSqlLexerVERSIONS_XID = 2164 + PlSqlLexerVERSION = 2165 + PlSqlLexerVIEW = 2166 + PlSqlLexerVIOLATION = 2167 + PlSqlLexerVIRTUAL = 2168 + PlSqlLexerVISIBILITY = 2169 + PlSqlLexerVISIBLE = 2170 + PlSqlLexerVOLUME = 2171 + PlSqlLexerVSIZE = 2172 + PlSqlLexerWAIT = 2173 + PlSqlLexerWALLET = 2174 + PlSqlLexerWARNING = 2175 + PlSqlLexerWEEKS = 2176 + PlSqlLexerWEEK = 2177 + PlSqlLexerWELLFORMED = 2178 + PlSqlLexerWHENEVER = 2179 + PlSqlLexerWHEN = 2180 + PlSqlLexerWHERE = 2181 + PlSqlLexerWHILE = 2182 + PlSqlLexerWHITESPACE = 2183 + PlSqlLexerWIDTH_BUCKET = 2184 + PlSqlLexerWITHIN = 2185 + PlSqlLexerWITHOUT = 2186 + PlSqlLexerWITH_PLSQL = 2187 + PlSqlLexerWITH = 2188 + PlSqlLexerWORK = 2189 + PlSqlLexerWRAPPED = 2190 + PlSqlLexerWRAPPER = 2191 + PlSqlLexerWRITE = 2192 + PlSqlLexerXDB_FASTPATH_INSERT = 2193 + PlSqlLexerXDB = 2194 + PlSqlLexerX_DYN_PRUNE = 2195 + PlSqlLexerXID = 2196 + PlSqlLexerXML2OBJECT = 2197 + PlSqlLexerXMLAGG = 2198 + PlSqlLexerXMLATTRIBUTES = 2199 + PlSqlLexerXMLCAST = 2200 + PlSqlLexerXMLCDATA = 2201 + PlSqlLexerXMLCOLATTVAL = 2202 + PlSqlLexerXMLCOMMENT = 2203 + PlSqlLexerXMLCONCAT = 2204 + PlSqlLexerXMLDIFF = 2205 + PlSqlLexerXML_DML_RWT_STMT = 2206 + PlSqlLexerXMLELEMENT = 2207 + PlSqlLexerXMLEXISTS2 = 2208 + PlSqlLexerXMLEXISTS = 2209 + PlSqlLexerXMLFOREST = 2210 + PlSqlLexerXMLINDEX = 2211 + PlSqlLexerXMLINDEX_REWRITE_IN_SELECT = 2212 + PlSqlLexerXMLINDEX_REWRITE = 2213 + PlSqlLexerXMLINDEX_SEL_IDX_TBL = 2214 + PlSqlLexerXMLISNODE = 2215 + PlSqlLexerXMLISVALID = 2216 + PlSqlLexerXMLNAMESPACES = 2217 + PlSqlLexerXMLPARSE = 2218 + PlSqlLexerXMLPATCH = 2219 + PlSqlLexerXMLPI = 2220 + PlSqlLexerXMLQUERYVAL = 2221 + PlSqlLexerXMLQUERY = 2222 + PlSqlLexerXMLROOT = 2223 + PlSqlLexerXMLSCHEMA = 2224 + PlSqlLexerXMLSERIALIZE = 2225 + PlSqlLexerXMLTABLE = 2226 + PlSqlLexerXMLTRANSFORMBLOB = 2227 + PlSqlLexerXMLTRANSFORM = 2228 + PlSqlLexerXMLTYPE = 2229 + PlSqlLexerXML = 2230 + PlSqlLexerXPATHTABLE = 2231 + PlSqlLexerXS_SYS_CONTEXT = 2232 + PlSqlLexerXS = 2233 + PlSqlLexerYEARS = 2234 + PlSqlLexerYEAR = 2235 + PlSqlLexerYES = 2236 + PlSqlLexerYMINTERVAL_UNCONSTRAINED = 2237 + PlSqlLexerZONEMAP = 2238 + PlSqlLexerZONE = 2239 + PlSqlLexerPREDICTION = 2240 + PlSqlLexerPREDICTION_BOUNDS = 2241 + PlSqlLexerPREDICTION_COST = 2242 + PlSqlLexerPREDICTION_DETAILS = 2243 + PlSqlLexerPREDICTION_PROBABILITY = 2244 + PlSqlLexerPREDICTION_SET = 2245 + PlSqlLexerBLOCKCHAIN = 2246 + PlSqlLexerCOLLATE = 2247 + PlSqlLexerCOLLATION = 2248 + PlSqlLexerDEFINITION = 2249 + PlSqlLexerDUPLICATED = 2250 + PlSqlLexerEXTENDED = 2251 + PlSqlLexerHASHING = 2252 + PlSqlLexerIDLE = 2253 + PlSqlLexerIMMUTABLE = 2254 + PlSqlLexerORACLE_DATAPUMP = 2255 + PlSqlLexerORACLE_HDFS = 2256 + PlSqlLexerORACLE_HIVE = 2257 + PlSqlLexerORACLE_LOADER = 2258 + PlSqlLexerSHA2_512_Q = 2259 + PlSqlLexerSHARDED = 2260 + PlSqlLexerV1_Q = 2261 + PlSqlLexerISOLATE = 2262 + PlSqlLexerROOT = 2263 + PlSqlLexerUNITE = 2264 + PlSqlLexerALGORITHM = 2265 + PlSqlLexerCUME_DIST = 2266 + PlSqlLexerDENSE_RANK = 2267 + PlSqlLexerLISTAGG = 2268 + PlSqlLexerPERCENT_RANK = 2269 + PlSqlLexerPERCENTILE_CONT = 2270 + PlSqlLexerPERCENTILE_DISC = 2271 + PlSqlLexerRANK = 2272 + PlSqlLexerAVG = 2273 + PlSqlLexerCORR = 2274 + PlSqlLexerCOVAR_ = 2275 + PlSqlLexerDECODE = 2276 + PlSqlLexerLAG = 2277 + PlSqlLexerLAG_DIFF = 2278 + PlSqlLexerLAG_DIFF_PERCENT = 2279 + PlSqlLexerLEAD = 2280 + PlSqlLexerMAX = 2281 + PlSqlLexerMEDIAN = 2282 + PlSqlLexerMEMOPTIMIZE = 2283 + PlSqlLexerMIN = 2284 + PlSqlLexerNTILE = 2285 + PlSqlLexerNVL = 2286 + PlSqlLexerRATIO_TO_REPORT = 2287 + PlSqlLexerREGR_ = 2288 + PlSqlLexerROUND = 2289 + PlSqlLexerROW_NUMBER = 2290 + PlSqlLexerSUBSTR = 2291 + PlSqlLexerTO_CHAR = 2292 + PlSqlLexerTRIM = 2293 + PlSqlLexerSUM = 2294 + PlSqlLexerSTDDEV = 2295 + PlSqlLexerVAR_ = 2296 + PlSqlLexerVARIANCE = 2297 + PlSqlLexerLEAST = 2298 + PlSqlLexerGREATEST = 2299 + PlSqlLexerTO_DATE = 2300 + PlSqlLexerDEFAULTIF = 2301 + PlSqlLexerLLS = 2302 + PlSqlLexerENCLOSED = 2303 + PlSqlLexerTERMINATED = 2304 + PlSqlLexerOPTIONALLY = 2305 + PlSqlLexerLRTRIM = 2306 + PlSqlLexerNOTRIM = 2307 + PlSqlLexerLDRTRIM = 2308 + PlSqlLexerDATE_FORMAT = 2309 + PlSqlLexerMASK = 2310 + PlSqlLexerTRANSFORMS = 2311 + PlSqlLexerLOBFILE = 2312 + PlSqlLexerSTARTOF = 2313 + PlSqlLexerCHARACTERSET = 2314 + PlSqlLexerRECORDS = 2315 + PlSqlLexerFIXED = 2316 + PlSqlLexerDELIMITED = 2317 + PlSqlLexerXMLTAG = 2318 + PlSqlLexerPREPROCESSOR = 2319 + PlSqlLexerTERRITORY = 2320 + PlSqlLexerLITTLE = 2321 + PlSqlLexerBIG = 2322 + PlSqlLexerENDIAN = 2323 + PlSqlLexerBYTEORDERMARK = 2324 + PlSqlLexerNOCHECK = 2325 + PlSqlLexerSIZES = 2326 + PlSqlLexerARE = 2327 + PlSqlLexerBYTES = 2328 + PlSqlLexerCHARACTERS = 2329 + PlSqlLexerREADSIZE = 2330 + PlSqlLexerDISABLE_DIRECTORY_LINK_CHECK = 2331 + PlSqlLexerDATE_CACHE = 2332 + PlSqlLexerFIELD_NAMES = 2333 + PlSqlLexerFILES = 2334 + PlSqlLexerIO_OPTIONS = 2335 + PlSqlLexerDIRECTIO = 2336 + PlSqlLexerNODIRECTIO = 2337 + PlSqlLexerDNFS_ENABLE = 2338 + PlSqlLexerDNFS_DISABLE = 2339 + PlSqlLexerDNFS_READBUFFERS = 2340 + PlSqlLexerNOBADFILE = 2341 + PlSqlLexerBADFILE = 2342 + PlSqlLexerNODISCARDFILE = 2343 + PlSqlLexerDISCARDFILE = 2344 + PlSqlLexerNOLOGFILE = 2345 + PlSqlLexerFIELDS = 2346 + PlSqlLexerIGNORE_CHARS_AFTER_EOR = 2347 + PlSqlLexerCSV = 2348 + PlSqlLexerEMBEDDED = 2349 + PlSqlLexerOVERRIDE = 2350 + PlSqlLexerTHESE = 2351 + PlSqlLexerFIELD = 2352 + PlSqlLexerNONULLIF = 2353 + PlSqlLexerPOSITION = 2354 + PlSqlLexerNEWLINE_ = 2355 + PlSqlLexerDETECTED = 2356 + PlSqlLexerUNSIGNED = 2357 + PlSqlLexerZONED = 2358 + PlSqlLexerORACLE_DATE = 2359 + PlSqlLexerORACLE_NUMBER = 2360 + PlSqlLexerCOUNTED = 2361 + PlSqlLexerVARRAW = 2362 + PlSqlLexerVARCHARC = 2363 + PlSqlLexerVARRAWC = 2364 + PlSqlLexerNATIONAL_CHAR_STRING_LIT = 2365 + PlSqlLexerBIT_STRING_LIT = 2366 + PlSqlLexerHEX_STRING_LIT = 2367 + PlSqlLexerDOUBLE_PERIOD = 2368 + PlSqlLexerPERIOD = 2369 + PlSqlLexerUNSIGNED_INTEGER = 2370 + PlSqlLexerAPPROXIMATE_NUM_LIT = 2371 + PlSqlLexerCHAR_STRING = 2372 + PlSqlLexerDELIMITED_ID = 2373 + PlSqlLexerPERCENT = 2374 + PlSqlLexerAMPERSAND = 2375 + PlSqlLexerLEFT_PAREN = 2376 + PlSqlLexerRIGHT_PAREN = 2377 + PlSqlLexerDOUBLE_ASTERISK = 2378 + PlSqlLexerASTERISK = 2379 + PlSqlLexerPLUS_SIGN = 2380 + PlSqlLexerMINUS_SIGN = 2381 + PlSqlLexerCOMMA = 2382 + PlSqlLexerSOLIDUS = 2383 + PlSqlLexerAT_SIGN = 2384 + PlSqlLexerASSIGN_OP = 2385 + PlSqlLexerHASH_OP = 2386 + PlSqlLexerSQ = 2387 + PlSqlLexerBINDVAR = 2388 + PlSqlLexerNOT_EQUAL_OP = 2389 + PlSqlLexerCARRET_OPERATOR_PART = 2390 + PlSqlLexerTILDE_OPERATOR_PART = 2391 + PlSqlLexerEXCLAMATION_OPERATOR_PART = 2392 + PlSqlLexerGREATER_THAN_OP = 2393 + PlSqlLexerLESS_THAN_OP = 2394 + PlSqlLexerCOLON = 2395 + PlSqlLexerSEMICOLON = 2396 + PlSqlLexerBAR = 2397 + PlSqlLexerEQUALS_OP = 2398 + PlSqlLexerLEFT_BRACKET = 2399 + PlSqlLexerRIGHT_BRACKET = 2400 + PlSqlLexerINTRODUCER = 2401 + PlSqlLexerSINGLE_LINE_COMMENT = 2402 + PlSqlLexerMULTI_LINE_COMMENT = 2403 + PlSqlLexerREMARK_COMMENT = 2404 + PlSqlLexerPROMPT_MESSAGE = 2405 + PlSqlLexerSTART_CMD = 2406 + PlSqlLexerREGULAR_ID = 2407 + PlSqlLexerSPACES = 2408 +) + +func (l *PlSqlLexer) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 2432: + return l.REMARK_COMMENT_Sempred(localctx, predIndex) + + case 2433: + return l.PROMPT_MESSAGE_Sempred(localctx, predIndex) + + case 2434: + return l.START_CMD_Sempred(localctx, predIndex) + + default: + panic("No registered predicate for: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *PlSqlLexer) REMARK_COMMENT_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.IsNewlineAtPos(-4) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlLexer) PROMPT_MESSAGE_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.IsNewlineAtPos(-4) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlLexer) START_CMD_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.IsNewlineAtPos(-2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} diff --git a/plsql/plsql_lexer_base.go b/plsql/plsql_lexer_base.go new file mode 100644 index 0000000..bda5ee3 --- /dev/null +++ b/plsql/plsql_lexer_base.go @@ -0,0 +1,2348 @@ +package plsql + +import ( + "strings" + + "github.com/antlr4-go/antlr/v4" +) + +// PlSqlLexerBase state +type PlSqlLexerBase struct { + *antlr.BaseLexer + + lastToken antlr.Token + reservedMap map[string]bool +} + +// NextToken from the character stream. +func (l *PlSqlLexerBase) NextToken() antlr.Token { + next := l.BaseLexer.NextToken() // Get next token + if next.GetChannel() == antlr.TokenDefaultChannel { + // Keep track of the last token on default channel + l.lastToken = next + } + return next +} + +// IsRegexPossible returns true if the lexer can match a +// regex literal. +func (l *PlSqlLexerBase) IsNewlineAtPos(pos int) bool { + if l.lastToken == nil { + return true + } + la := l.GetInputStream().LA(pos) + return la == -1 || la == '\n' +} + +func (l *PlSqlLexerBase) IsIdentifier(tokenType int) bool { + if tokenType == antlr.TokenEOF { + return false + } + + switch tokenType { + case PlSqlLexerDELIMITED_ID, PlSqlLexerREGULAR_ID: + return true + case PlSqlLexerABORT, + PlSqlLexerABS, + PlSqlLexerACCESSED, + PlSqlLexerACCESS, + PlSqlLexerACCOUNT, + PlSqlLexerACOS, + PlSqlLexerACTIVATE, + PlSqlLexerACTIVE_COMPONENT, + PlSqlLexerACTIVE_FUNCTION, + PlSqlLexerACTIVE_TAG, + PlSqlLexerADD_COLUMN, + PlSqlLexerADD_GROUP, + PlSqlLexerADD_MONTHS, + PlSqlLexerADD, + PlSqlLexerADJ_DATE, + PlSqlLexerADMINISTER, + PlSqlLexerADMINISTRATOR, + PlSqlLexerADMIN, + PlSqlLexerADVISE, + PlSqlLexerADVISOR, + PlSqlLexerAFTER, + PlSqlLexerALIAS, + PlSqlLexerALLOCATE, + PlSqlLexerALLOW, + PlSqlLexerALL_ROWS, + PlSqlLexerALWAYS, + PlSqlLexerANALYZE, + PlSqlLexerANCILLARY, + PlSqlLexerAND_EQUAL, + PlSqlLexerANTIJOIN, + PlSqlLexerANYSCHEMA, + PlSqlLexerAPPENDCHILDXML, + PlSqlLexerAPPEND, + PlSqlLexerAPPEND_VALUES, + PlSqlLexerAPPLY, + PlSqlLexerARCHIVELOG, + PlSqlLexerARCHIVE, + PlSqlLexerARRAY, + PlSqlLexerASCII, + PlSqlLexerASCIISTR, + PlSqlLexerASIN, + PlSqlLexerASSEMBLY, + PlSqlLexerASSOCIATE, + PlSqlLexerASYNCHRONOUS, + PlSqlLexerASYNC, + PlSqlLexerATAN2, + PlSqlLexerATAN, + PlSqlLexerAT, + PlSqlLexerATTRIBUTE, + PlSqlLexerATTRIBUTES, + PlSqlLexerAUTHENTICATED, + PlSqlLexerAUTHENTICATION, + PlSqlLexerAUTHID, + PlSqlLexerAUTHORIZATION, + PlSqlLexerAUTOALLOCATE, + PlSqlLexerAUTOEXTEND, + PlSqlLexerAUTOMATIC, + PlSqlLexerAUTO, + PlSqlLexerAVAILABILITY, + PlSqlLexerAVG, + PlSqlLexerBACKUP, + PlSqlLexerBASICFILE, + PlSqlLexerBASIC, + PlSqlLexerBATCH, + PlSqlLexerBECOME, + PlSqlLexerBEFORE, + PlSqlLexerBEGIN, + PlSqlLexerBEGIN_OUTLINE_DATA, + PlSqlLexerBEHALF, + PlSqlLexerBFILE, + PlSqlLexerBFILENAME, + PlSqlLexerBIGFILE, + PlSqlLexerBINARY_DOUBLE_INFINITY, + PlSqlLexerBINARY_DOUBLE, + PlSqlLexerBINARY_DOUBLE_NAN, + PlSqlLexerBINARY_FLOAT_INFINITY, + PlSqlLexerBINARY_FLOAT, + PlSqlLexerBINARY_FLOAT_NAN, + PlSqlLexerBINARY, + PlSqlLexerBIND_AWARE, + PlSqlLexerBINDING, + PlSqlLexerBIN_TO_NUM, + PlSqlLexerBITAND, + PlSqlLexerBITMAP, + PlSqlLexerBITMAPS, + PlSqlLexerBITMAP_TREE, + PlSqlLexerBITS, + PlSqlLexerBLOB, + PlSqlLexerBLOCK, + PlSqlLexerBLOCK_RANGE, + PlSqlLexerBLOCKSIZE, + PlSqlLexerBLOCKS, + PlSqlLexerBODY, + PlSqlLexerBOTH, + PlSqlLexerBOUND, + PlSqlLexerBRANCH, + PlSqlLexerBREADTH, + PlSqlLexerBROADCAST, + PlSqlLexerBUFFER_CACHE, + PlSqlLexerBUFFER, + PlSqlLexerBUFFER_POOL, + PlSqlLexerBUILD, + PlSqlLexerBULK, + PlSqlLexerBYPASS_RECURSIVE_CHECK, + PlSqlLexerBYPASS_UJVC, + PlSqlLexerBYTE, + PlSqlLexerCACHE_CB, + PlSqlLexerCACHE_INSTANCES, + PlSqlLexerCACHE, + PlSqlLexerCACHE_TEMP_TABLE, + PlSqlLexerCALL, + PlSqlLexerCANCEL, + PlSqlLexerCARDINALITY, + PlSqlLexerCASCADE, + PlSqlLexerCASE, + PlSqlLexerCAST, + PlSqlLexerCATEGORY, + PlSqlLexerCEIL, + PlSqlLexerCELL_FLASH_CACHE, + PlSqlLexerCERTIFICATE, + PlSqlLexerCFILE, + PlSqlLexerCHAINED, + PlSqlLexerCHANGE_DUPKEY_ERROR_INDEX, + PlSqlLexerCHANGE, + PlSqlLexerCHARACTER, + PlSqlLexerCHAR_CS, + PlSqlLexerCHARTOROWID, + PlSqlLexerCHECK_ACL_REWRITE, + PlSqlLexerCHECKPOINT, + PlSqlLexerCHILD, + PlSqlLexerCHOOSE, + PlSqlLexerCHR, + PlSqlLexerCHUNK, + PlSqlLexerCLASS, + PlSqlLexerCLEAR, + PlSqlLexerCLOB, + PlSqlLexerCLONE, + PlSqlLexerCLOSE_CACHED_OPEN_CURSORS, + PlSqlLexerCLOSE, + PlSqlLexerCLUSTER_BY_ROWID, + PlSqlLexerCLUSTER_ID, + PlSqlLexerCLUSTERING_FACTOR, + PlSqlLexerCLUSTER_PROBABILITY, + PlSqlLexerCLUSTER_SET, + PlSqlLexerCOALESCE, + PlSqlLexerCOALESCE_SQ, + PlSqlLexerCOARSE, + PlSqlLexerCO_AUTH_IND, + PlSqlLexerCOLD, + PlSqlLexerCOLLECT, + PlSqlLexerCOLUMNAR, + PlSqlLexerCOLUMN_AUTH_INDICATOR, + PlSqlLexerCOLUMN, + PlSqlLexerCOLUMNS, + PlSqlLexerCOLUMN_STATS, + PlSqlLexerCOLUMN_VALUE, + PlSqlLexerCOMMENT, + PlSqlLexerCOMMIT, + PlSqlLexerCOMMITTED, + PlSqlLexerCOMPACT, + PlSqlLexerCOMPATIBILITY, + PlSqlLexerCOMPILE, + PlSqlLexerCOMPLETE, + PlSqlLexerCOMPLIANCE, + PlSqlLexerCOMPOSE, + PlSqlLexerCOMPOSITE_LIMIT, + PlSqlLexerCOMPOSITE, + PlSqlLexerCOMPOUND, + PlSqlLexerCOMPUTE, + PlSqlLexerCONCAT, + PlSqlLexerCONFIRM, + PlSqlLexerCONFORMING, + PlSqlLexerCONNECT_BY_CB_WHR_ONLY, + PlSqlLexerCONNECT_BY_COMBINE_SW, + PlSqlLexerCONNECT_BY_COST_BASED, + PlSqlLexerCONNECT_BY_ELIM_DUPS, + PlSqlLexerCONNECT_BY_FILTERING, + PlSqlLexerCONNECT_BY_ISCYCLE, + PlSqlLexerCONNECT_BY_ISLEAF, + PlSqlLexerCONNECT_BY_ROOT, + PlSqlLexerCONNECT_TIME, + PlSqlLexerCONSIDER, + PlSqlLexerCONSISTENT, + PlSqlLexerCONSTANT, + PlSqlLexerCONST, + PlSqlLexerCONSTRAINT, + PlSqlLexerCONSTRAINTS, + PlSqlLexerCONTAINER, + PlSqlLexerCONTENT, + PlSqlLexerCONTENTS, + PlSqlLexerCONTEXT, + PlSqlLexerCONTINUE, + PlSqlLexerCONTROLFILE, + PlSqlLexerCONVERT, + PlSqlLexerCORR_K, + PlSqlLexerCORR, + PlSqlLexerCORR_S, + PlSqlLexerCORRUPTION, + PlSqlLexerCORRUPT_XID_ALL, + PlSqlLexerCORRUPT_XID, + PlSqlLexerCOSH, + PlSqlLexerCOS, + PlSqlLexerCOST, + PlSqlLexerCOST_XML_QUERY_REWRITE, + PlSqlLexerCOUNT, + PlSqlLexerCOVAR_POP, + PlSqlLexerCOVAR_SAMP, + PlSqlLexerCPU_COSTING, + PlSqlLexerCPU_PER_CALL, + PlSqlLexerCPU_PER_SESSION, + PlSqlLexerCRASH, + PlSqlLexerCREATE_STORED_OUTLINES, + PlSqlLexerCREATION, + PlSqlLexerCROSSEDITION, + PlSqlLexerCROSS, + PlSqlLexerCSCONVERT, + PlSqlLexerCUBE_GB, + PlSqlLexerCUBE, + PlSqlLexerCUME_DISTM, + PlSqlLexerCUME_DIST, + PlSqlLexerCURRENT_DATE, + PlSqlLexerCURRENT, + PlSqlLexerCURRENT_SCHEMA, + PlSqlLexerCURRENT_TIME, + PlSqlLexerCURRENT_TIMESTAMP, + PlSqlLexerCURRENT_USER, + PlSqlLexerCURRENTV, + PlSqlLexerCURSOR, + PlSqlLexerCURSOR_SHARING_EXACT, + PlSqlLexerCURSOR_SPECIFIC_SEGMENT, + PlSqlLexerCV, + PlSqlLexerCYCLE, + PlSqlLexerDANGLING, + PlSqlLexerDATABASE, + PlSqlLexerDATAFILE, + PlSqlLexerDATAFILES, + PlSqlLexerDATA, + PlSqlLexerDATAOBJNO, + PlSqlLexerDATAOBJ_TO_PARTITION, + PlSqlLexerDATE_MODE, + PlSqlLexerDAY, + PlSqlLexerDBA, + PlSqlLexerDBA_RECYCLEBIN, + PlSqlLexerDBMS_STATS, + PlSqlLexerDB_ROLE_CHANGE, + PlSqlLexerDBTIMEZONE, + PlSqlLexerDB_VERSION, + PlSqlLexerDDL, + PlSqlLexerDEALLOCATE, + PlSqlLexerDEBUGGER, + PlSqlLexerDEBUG, + PlSqlLexerDECLARE, + PlSqlLexerDEC, + PlSqlLexerDECOMPOSE, + PlSqlLexerDECREMENT, + PlSqlLexerDECR, + PlSqlLexerDECRYPT, + PlSqlLexerDEDUPLICATE, + PlSqlLexerDEFAULTS, + PlSqlLexerDEFERRABLE, + PlSqlLexerDEFERRED, + PlSqlLexerDEFINED, + PlSqlLexerDEFINER, + PlSqlLexerDEGREE, + PlSqlLexerDELAY, + PlSqlLexerDELETEXML, + PlSqlLexerDEMAND, + PlSqlLexerDENSE_RANKM, + PlSqlLexerDENSE_RANK, + PlSqlLexerDEPENDENT, + PlSqlLexerDEPTH, + PlSqlLexerDEQUEUE, + PlSqlLexerDEREF, + PlSqlLexerDEREF_NO_REWRITE, + PlSqlLexerDETACHED, + PlSqlLexerDETERMINES, + PlSqlLexerDICTIONARY, + PlSqlLexerDIMENSION, + PlSqlLexerDIRECT_LOAD, + PlSqlLexerDIRECTORY, + PlSqlLexerDIRECT_PATH, + PlSqlLexerDISABLE, + PlSqlLexerDISABLE_PRESET, + PlSqlLexerDISABLE_RPKE, + PlSqlLexerDISALLOW, + PlSqlLexerDISASSOCIATE, + PlSqlLexerDISCONNECT, + PlSqlLexerDISKGROUP, + PlSqlLexerDISK, + PlSqlLexerDISKS, + PlSqlLexerDISMOUNT, + PlSqlLexerDISTINGUISHED, + PlSqlLexerDISTRIBUTED, + PlSqlLexerDML, + PlSqlLexerDML_UPDATE, + PlSqlLexerDOCFIDELITY, + PlSqlLexerDOCUMENT, + PlSqlLexerDOMAIN_INDEX_FILTER, + PlSqlLexerDOMAIN_INDEX_NO_SORT, + PlSqlLexerDOMAIN_INDEX_SORT, + PlSqlLexerDOUBLE, + PlSqlLexerDOWNGRADE, + PlSqlLexerDRIVING_SITE, + PlSqlLexerDROP_COLUMN, + PlSqlLexerDROP_GROUP, + PlSqlLexerDST_UPGRADE_INSERT_CONV, + PlSqlLexerDUMP, + PlSqlLexerDYNAMIC, + PlSqlLexerDYNAMIC_SAMPLING_EST_CDN, + PlSqlLexerDYNAMIC_SAMPLING, + PlSqlLexerEACH, + PlSqlLexerEDITIONING, + PlSqlLexerEDITION, + PlSqlLexerEDITIONS, + PlSqlLexerELEMENT, + PlSqlLexerELIMINATE_JOIN, + PlSqlLexerELIMINATE_OBY, + PlSqlLexerELIMINATE_OUTER_JOIN, + PlSqlLexerEMPTY_BLOB, + PlSqlLexerEMPTY_CLOB, + PlSqlLexerEMPTY, + PlSqlLexerENABLE, + PlSqlLexerENABLE_PRESET, + PlSqlLexerENCODING, + PlSqlLexerENCRYPTION, + PlSqlLexerENCRYPT, + PlSqlLexerEND_OUTLINE_DATA, + PlSqlLexerENFORCED, + PlSqlLexerENFORCE, + PlSqlLexerENQUEUE, + PlSqlLexerENTERPRISE, + PlSqlLexerENTITYESCAPING, + PlSqlLexerENTRY, + PlSqlLexerERROR_ARGUMENT, + PlSqlLexerERROR, + PlSqlLexerERROR_ON_OVERLAP_TIME, + PlSqlLexerERRORS, + PlSqlLexerESCAPE, + PlSqlLexerESTIMATE, + PlSqlLexerEVALNAME, + PlSqlLexerEVALUATION, + PlSqlLexerEVENTS, + PlSqlLexerEVERY, + PlSqlLexerEXCEPTIONS, + PlSqlLexerEXCEPT, + PlSqlLexerEXCHANGE, + PlSqlLexerEXCLUDE, + PlSqlLexerEXCLUDING, + PlSqlLexerEXECUTE, + PlSqlLexerEXEMPT, + PlSqlLexerEXISTSNODE, + PlSqlLexerEXPAND_GSET_TO_UNION, + PlSqlLexerEXPAND_TABLE, + PlSqlLexerEXPIRE, + PlSqlLexerEXPLAIN, + PlSqlLexerEXPLOSION, + PlSqlLexerEXP, + PlSqlLexerEXPORT, + PlSqlLexerEXPR_CORR_CHECK, + PlSqlLexerEXTENDS, + PlSqlLexerEXTENT, + PlSqlLexerEXTENTS, + PlSqlLexerEXTERNALLY, + PlSqlLexerEXTERNAL, + PlSqlLexerEXTRACT, + PlSqlLexerEXTRACTVALUE, + PlSqlLexerEXTRA, + PlSqlLexerFACILITY, + PlSqlLexerFACT, + PlSqlLexerFACTORIZE_JOIN, + PlSqlLexerFAILED_LOGIN_ATTEMPTS, + PlSqlLexerFAILED, + PlSqlLexerFAILGROUP, + PlSqlLexerFALSE, + PlSqlLexerFAST, + PlSqlLexerFBTSCAN, + PlSqlLexerFEATURE_ID, + PlSqlLexerFEATURE_SET, + PlSqlLexerFEATURE_VALUE, + PlSqlLexerFILE, + PlSqlLexerFILESYSTEM_LIKE_LOGGING, + PlSqlLexerFILTER, + PlSqlLexerFINAL, + PlSqlLexerFINE, + PlSqlLexerFINISH, + PlSqlLexerFIRSTM, + PlSqlLexerFIRST, + PlSqlLexerFIRST_ROWS, + PlSqlLexerFIRST_VALUE, + PlSqlLexerFLAGGER, + PlSqlLexerFLASHBACK, + PlSqlLexerFLASH_CACHE, + PlSqlLexerFLOB, + PlSqlLexerFLOOR, + PlSqlLexerFLUSH, + PlSqlLexerFOLDER, + PlSqlLexerFOLLOWING, + PlSqlLexerFOLLOWS, + PlSqlLexerFORCE, + PlSqlLexerFORCE_XML_QUERY_REWRITE, + PlSqlLexerFOREIGN, + PlSqlLexerFOREVER, + PlSqlLexerFORWARD, + PlSqlLexerFRAGMENT_NUMBER, + PlSqlLexerFREELIST, + PlSqlLexerFREELISTS, + PlSqlLexerFREEPOOLS, + PlSqlLexerFRESH, + PlSqlLexerFROM_TZ, + PlSqlLexerFULL, + PlSqlLexerFULL_OUTER_JOIN_TO_OUTER, + PlSqlLexerFUNCTION, + PlSqlLexerFUNCTIONS, + PlSqlLexerGATHER_PLAN_STATISTICS, + PlSqlLexerGBY_CONC_ROLLUP, + PlSqlLexerGBY_PUSHDOWN, + PlSqlLexerGENERATED, + PlSqlLexerGLOBALLY, + PlSqlLexerGLOBAL, + PlSqlLexerGLOBAL_NAME, + PlSqlLexerGLOBAL_TOPIC_ENABLED, + PlSqlLexerGREATEST, + PlSqlLexerGROUP_BY, + PlSqlLexerGROUP_ID, + PlSqlLexerGROUPING_ID, + PlSqlLexerGROUPING, + PlSqlLexerGROUPS, + PlSqlLexerGUARANTEED, + PlSqlLexerGUARANTEE, + PlSqlLexerGUARD, + PlSqlLexerHASH_AJ, + PlSqlLexerHASHKEYS, + PlSqlLexerHASH, + PlSqlLexerHASH_SJ, + PlSqlLexerHEADER, + PlSqlLexerHEAP, + PlSqlLexerHELP, + PlSqlLexerHEXTORAW, + PlSqlLexerHEXTOREF, + PlSqlLexerHIDDEN_KEYWORD, + PlSqlLexerHIDE, + PlSqlLexerHIERARCHY, + PlSqlLexerHIGH, + PlSqlLexerHINTSET_BEGIN, + PlSqlLexerHINTSET_END, + PlSqlLexerHOT, + PlSqlLexerHOUR, + PlSqlLexerHWM_BROKERED, + PlSqlLexerHYBRID, + PlSqlLexerIDENTIFIER, + PlSqlLexerIDENTITY, + PlSqlLexerIDGENERATORS, + PlSqlLexerIDLE_TIME, + PlSqlLexerID, + PlSqlLexerIF, + PlSqlLexerIGNORE, + PlSqlLexerIGNORE_OPTIM_EMBEDDED_HINTS, + PlSqlLexerIGNORE_ROW_ON_DUPKEY_INDEX, + PlSqlLexerIGNORE_WHERE_CLAUSE, + PlSqlLexerIMMEDIATE, + PlSqlLexerIMPACT, + PlSqlLexerIMPORT, + PlSqlLexerINCLUDE, + PlSqlLexerINCLUDE_VERSION, + PlSqlLexerINCLUDING, + PlSqlLexerINCREMENTAL, + PlSqlLexerINCREMENT, + PlSqlLexerINCR, + PlSqlLexerINDENT, + PlSqlLexerINDEX_ASC, + PlSqlLexerINDEX_COMBINE, + PlSqlLexerINDEX_DESC, + PlSqlLexerINDEXED, + PlSqlLexerINDEXES, + PlSqlLexerINDEX_FFS, + PlSqlLexerINDEX_FILTER, + PlSqlLexerINDEX_JOIN, + PlSqlLexerINDEX_ROWS, + PlSqlLexerINDEX_RRS, + PlSqlLexerINDEX_RS_ASC, + PlSqlLexerINDEX_RS_DESC, + PlSqlLexerINDEX_RS, + PlSqlLexerINDEX_SCAN, + PlSqlLexerINDEX_SKIP_SCAN, + PlSqlLexerINDEX_SS_ASC, + PlSqlLexerINDEX_SS_DESC, + PlSqlLexerINDEX_SS, + PlSqlLexerINDEX_STATS, + PlSqlLexerINDEXTYPE, + PlSqlLexerINDEXTYPES, + PlSqlLexerINDICATOR, + PlSqlLexerINFINITE, + PlSqlLexerINFORMATIONAL, + PlSqlLexerINITCAP, + PlSqlLexerINITIALIZED, + PlSqlLexerINITIALLY, + PlSqlLexerINITIAL, + PlSqlLexerINITRANS, + PlSqlLexerINLINE, + PlSqlLexerINLINE_XMLTYPE_NT, + PlSqlLexerIN_MEMORY_METADATA, + PlSqlLexerINNER, + PlSqlLexerINSERTCHILDXMLAFTER, + PlSqlLexerINSERTCHILDXMLBEFORE, + PlSqlLexerINSERTCHILDXML, + PlSqlLexerINSERTXMLAFTER, + PlSqlLexerINSERTXMLBEFORE, + PlSqlLexerINSTANCE, + PlSqlLexerINSTANCES, + PlSqlLexerINSTANTIABLE, + PlSqlLexerINSTANTLY, + PlSqlLexerINSTEAD, + PlSqlLexerINSTR2, + PlSqlLexerINSTR4, + PlSqlLexerINSTRB, + PlSqlLexerINSTRC, + PlSqlLexerINSTR, + PlSqlLexerINTERMEDIATE, + PlSqlLexerINTERNAL_CONVERT, + PlSqlLexerINTERNAL_USE, + PlSqlLexerINTERPRETED, + PlSqlLexerINTERVAL, + PlSqlLexerINT, + PlSqlLexerINVALIDATE, + PlSqlLexerINVISIBLE, + PlSqlLexerIN_XQUERY, + PlSqlLexerISOLATION_LEVEL, + PlSqlLexerISOLATION, + PlSqlLexerITERATE, + PlSqlLexerITERATION_NUMBER, + PlSqlLexerJAVA, + PlSqlLexerJOB, + PlSqlLexerJOIN, + PlSqlLexerKEEP_DUPLICATES, + PlSqlLexerKEEP, + PlSqlLexerKERBEROS, + PlSqlLexerKEY_LENGTH, + PlSqlLexerKEY, + PlSqlLexerKEYSIZE, + PlSqlLexerKEYS, + PlSqlLexerKILL, + PlSqlLexerLAG, + PlSqlLexerLAST_DAY, + PlSqlLexerLAST, + PlSqlLexerLAST_VALUE, + PlSqlLexerLATERAL, + PlSqlLexerLAYER, + PlSqlLexerLDAP_REGISTRATION_ENABLED, + PlSqlLexerLDAP_REGISTRATION, + PlSqlLexerLDAP_REG_SYNC_INTERVAL, + PlSqlLexerLEADING, + PlSqlLexerLEAD, + PlSqlLexerLEAF, + PlSqlLexerLEAST, + PlSqlLexerLEFT, + PlSqlLexerLENGTH2, + PlSqlLexerLENGTH4, + PlSqlLexerLENGTHB, + PlSqlLexerLENGTHC, + PlSqlLexerLENGTH, + PlSqlLexerLESS, + PlSqlLexerLEVEL, + PlSqlLexerLEVELS, + PlSqlLexerLIBRARY, + PlSqlLexerLIFE, + PlSqlLexerLIFETIME, + PlSqlLexerLIKE2, + PlSqlLexerLIKE4, + PlSqlLexerLIKEC, + PlSqlLexerLIKE_EXPAND, + PlSqlLexerLIMIT, + PlSqlLexerLINK, + PlSqlLexerLISTAGG, + PlSqlLexerLIST, + PlSqlLexerLN, + PlSqlLexerLNNVL, + PlSqlLexerLOAD, + PlSqlLexerLOB, + PlSqlLexerLOBNVL, + PlSqlLexerLOBS, + PlSqlLexerLOCAL_INDEXES, + PlSqlLexerLOCAL, + PlSqlLexerLOCALTIME, + PlSqlLexerLOCALTIMESTAMP, + PlSqlLexerLOCATION, + PlSqlLexerLOCATOR, + PlSqlLexerLOCKED, + PlSqlLexerLOGFILE, + PlSqlLexerLOGFILES, + PlSqlLexerLOGGING, + PlSqlLexerLOGICAL, + PlSqlLexerLOGICAL_READS_PER_CALL, + PlSqlLexerLOGICAL_READS_PER_SESSION, + PlSqlLexerLOG, + PlSqlLexerLOGOFF, + PlSqlLexerLOGON, + PlSqlLexerLOG_READ_ONLY_VIOLATIONS, + PlSqlLexerLOWER, + PlSqlLexerLOW, + PlSqlLexerLPAD, + PlSqlLexerLTRIM, + PlSqlLexerMAIN, + PlSqlLexerMAKE_REF, + PlSqlLexerMANAGED, + PlSqlLexerMANAGEMENT, + PlSqlLexerMANAGE, + PlSqlLexerMANAGER, + PlSqlLexerMANUAL, + PlSqlLexerMAPPING, + PlSqlLexerMASTER, + PlSqlLexerMATCHED, + PlSqlLexerMATERIALIZED, + PlSqlLexerMATERIALIZE, + PlSqlLexerMAXARCHLOGS, + PlSqlLexerMAXDATAFILES, + PlSqlLexerMAXEXTENTS, + PlSqlLexerMAXIMIZE, + PlSqlLexerMAXINSTANCES, + PlSqlLexerMAXLOGFILES, + PlSqlLexerMAXLOGHISTORY, + PlSqlLexerMAXLOGMEMBERS, + PlSqlLexerMAX, + PlSqlLexerMAXSIZE, + PlSqlLexerMAXTRANS, + PlSqlLexerMAXVALUE, + PlSqlLexerMEASURE, + PlSqlLexerMEASURES, + PlSqlLexerMEDIAN, + PlSqlLexerMEDIUM, + PlSqlLexerMEMBER, + PlSqlLexerMEMOPTIMIZE, + PlSqlLexerMEMORY, + PlSqlLexerMERGEACTIONS, + PlSqlLexerMERGE_AJ, + PlSqlLexerMERGE_CONST_ON, + PlSqlLexerMERGE, + PlSqlLexerMERGE_SJ, + PlSqlLexerMETHOD, + PlSqlLexerMIGRATE, + PlSqlLexerMIGRATION, + PlSqlLexerMINEXTENTS, + PlSqlLexerMINIMIZE, + PlSqlLexerMINIMUM, + PlSqlLexerMINING, + PlSqlLexerMIN, + PlSqlLexerMINUS_NULL, + PlSqlLexerMINUTE, + PlSqlLexerMINVALUE, + PlSqlLexerMIRRORCOLD, + PlSqlLexerMIRRORHOT, + PlSqlLexerMIRROR, + PlSqlLexerMLSLABEL, + PlSqlLexerMODEL_COMPILE_SUBQUERY, + PlSqlLexerMODEL_DONTVERIFY_UNIQUENESS, + PlSqlLexerMODEL_DYNAMIC_SUBQUERY, + PlSqlLexerMODEL_MIN_ANALYSIS, + PlSqlLexerMODEL, + PlSqlLexerMODEL_NO_ANALYSIS, + PlSqlLexerMODEL_PBY, + PlSqlLexerMODEL_PUSH_REF, + PlSqlLexerMODIFY_COLUMN_TYPE, + PlSqlLexerMODIFY, + PlSqlLexerMOD, + PlSqlLexerMONITORING, + PlSqlLexerMONITOR, + PlSqlLexerMONTH, + PlSqlLexerMONTHS_BETWEEN, + PlSqlLexerMOUNT, + PlSqlLexerMOUNTPATH, + PlSqlLexerMOVEMENT, + PlSqlLexerMOVE, + PlSqlLexerMULTISET, + PlSqlLexerMV_MERGE, + PlSqlLexerNAMED, + PlSqlLexerNAME, + PlSqlLexerNAMESPACE, + PlSqlLexerNAN, + PlSqlLexerNANVL, + PlSqlLexerNATIONAL, + PlSqlLexerNATIVE_FULL_OUTER_JOIN, + PlSqlLexerNATIVE, + PlSqlLexerNATURAL, + PlSqlLexerNAV, + PlSqlLexerNCHAR_CS, + PlSqlLexerNCHAR, + PlSqlLexerNCHR, + PlSqlLexerNCLOB, + PlSqlLexerNEEDED, + PlSqlLexerNESTED, + PlSqlLexerNESTED_TABLE_FAST_INSERT, + PlSqlLexerNESTED_TABLE_GET_REFS, + PlSqlLexerNESTED_TABLE_ID, + PlSqlLexerNESTED_TABLE_SET_REFS, + PlSqlLexerNESTED_TABLE_SET_SETID, + PlSqlLexerNETWORK, + PlSqlLexerNEVER, + PlSqlLexerNEW, + PlSqlLexerNEW_TIME, + PlSqlLexerNEXT_DAY, + PlSqlLexerNEXT, + PlSqlLexerNL_AJ, + PlSqlLexerNLJ_BATCHING, + PlSqlLexerNLJ_INDEX_FILTER, + PlSqlLexerNLJ_INDEX_SCAN, + PlSqlLexerNLJ_PREFETCH, + PlSqlLexerNLS_CALENDAR, + PlSqlLexerNLS_CHARACTERSET, + PlSqlLexerNLS_CHARSET_DECL_LEN, + PlSqlLexerNLS_CHARSET_ID, + PlSqlLexerNLS_CHARSET_NAME, + PlSqlLexerNLS_COMP, + PlSqlLexerNLS_CURRENCY, + PlSqlLexerNLS_DATE_FORMAT, + PlSqlLexerNLS_DATE_LANGUAGE, + PlSqlLexerNLS_INITCAP, + PlSqlLexerNLS_ISO_CURRENCY, + PlSqlLexerNL_SJ, + PlSqlLexerNLS_LANG, + PlSqlLexerNLS_LANGUAGE, + PlSqlLexerNLS_LENGTH_SEMANTICS, + PlSqlLexerNLS_LOWER, + PlSqlLexerNLS_NCHAR_CONV_EXCP, + PlSqlLexerNLS_NUMERIC_CHARACTERS, + PlSqlLexerNLS_SORT, + PlSqlLexerNLSSORT, + PlSqlLexerNLS_SPECIAL_CHARS, + PlSqlLexerNLS_TERRITORY, + PlSqlLexerNLS_UPPER, + PlSqlLexerNO_ACCESS, + PlSqlLexerNOAPPEND, + PlSqlLexerNOARCHIVELOG, + PlSqlLexerNOAUDIT, + PlSqlLexerNO_BASETABLE_MULTIMV_REWRITE, + PlSqlLexerNO_BIND_AWARE, + PlSqlLexerNO_BUFFER, + PlSqlLexerNOCACHE, + PlSqlLexerNO_CARTESIAN, + PlSqlLexerNO_CHECK_ACL_REWRITE, + PlSqlLexerNO_CLUSTER_BY_ROWID, + PlSqlLexerNO_COALESCE_SQ, + PlSqlLexerNO_CONNECT_BY_CB_WHR_ONLY, + PlSqlLexerNO_CONNECT_BY_COMBINE_SW, + PlSqlLexerNO_CONNECT_BY_COST_BASED, + PlSqlLexerNO_CONNECT_BY_ELIM_DUPS, + PlSqlLexerNO_CONNECT_BY_FILTERING, + PlSqlLexerNO_COST_XML_QUERY_REWRITE, + PlSqlLexerNO_CPU_COSTING, + PlSqlLexerNOCPU_COSTING, + PlSqlLexerNOCYCLE, + PlSqlLexerNODELAY, + PlSqlLexerNO_DOMAIN_INDEX_FILTER, + PlSqlLexerNO_DST_UPGRADE_INSERT_CONV, + PlSqlLexerNO_ELIMINATE_JOIN, + PlSqlLexerNO_ELIMINATE_OBY, + PlSqlLexerNO_ELIMINATE_OUTER_JOIN, + PlSqlLexerNOENTITYESCAPING, + PlSqlLexerNO_EXPAND_GSET_TO_UNION, + PlSqlLexerNO_EXPAND, + PlSqlLexerNO_EXPAND_TABLE, + PlSqlLexerNO_FACT, + PlSqlLexerNO_FACTORIZE_JOIN, + PlSqlLexerNO_FILTERING, + PlSqlLexerNOFORCE, + PlSqlLexerNO_FULL_OUTER_JOIN_TO_OUTER, + PlSqlLexerNO_GBY_PUSHDOWN, + PlSqlLexerNOGUARANTEE, + PlSqlLexerNO_INDEX_FFS, + PlSqlLexerNO_INDEX, + PlSqlLexerNO_INDEX_SS, + PlSqlLexerNO_LOAD, + PlSqlLexerNOLOCAL, + PlSqlLexerNOLOGGING, + PlSqlLexerNOMAPPING, + PlSqlLexerNOMAXVALUE, + PlSqlLexerNO_MERGE, + PlSqlLexerNOMINIMIZE, + PlSqlLexerNOMINVALUE, + PlSqlLexerNO_MODEL_PUSH_REF, + PlSqlLexerNO_MONITORING, + PlSqlLexerNOMONITORING, + PlSqlLexerNO_MONITOR, + PlSqlLexerNO_MULTIMV_REWRITE, + PlSqlLexerNO, + PlSqlLexerNO_NATIVE_FULL_OUTER_JOIN, + PlSqlLexerNONBLOCKING, + PlSqlLexerNONE, + PlSqlLexerNO_NLJ_BATCHING, + PlSqlLexerNO_NLJ_PREFETCH, + PlSqlLexerNONSCHEMA, + PlSqlLexerNOORDER, + PlSqlLexerNO_ORDER_ROLLUPS, + PlSqlLexerNO_OUTER_JOIN_TO_ANTI, + PlSqlLexerNO_OUTER_JOIN_TO_INNER, + PlSqlLexerNOOVERRIDE, + PlSqlLexerNO_PARALLEL_INDEX, + PlSqlLexerNOPARALLEL_INDEX, + PlSqlLexerNO_PARALLEL, + PlSqlLexerNOPARALLEL, + PlSqlLexerNO_PARTIAL_COMMIT, + PlSqlLexerNO_PLACE_DISTINCT, + PlSqlLexerNO_PLACE_GROUP_BY, + PlSqlLexerNO_PQ_MAP, + PlSqlLexerNO_PRUNE_GSETS, + PlSqlLexerNO_PULL_PRED, + PlSqlLexerNO_PUSH_PRED, + PlSqlLexerNO_PUSH_SUBQ, + PlSqlLexerNO_PX_JOIN_FILTER, + PlSqlLexerNO_QKN_BUFF, + PlSqlLexerNO_QUERY_TRANSFORMATION, + PlSqlLexerNO_REF_CASCADE, + PlSqlLexerNORELY, + PlSqlLexerNOREPAIR, + PlSqlLexerNORESETLOGS, + PlSqlLexerNO_RESULT_CACHE, + PlSqlLexerNOREVERSE, + PlSqlLexerNO_REWRITE, + PlSqlLexerNOREWRITE, + PlSqlLexerNORMAL, + PlSqlLexerNOROWDEPENDENCIES, + PlSqlLexerNOSCHEMACHECK, + PlSqlLexerNOSEGMENT, + PlSqlLexerNO_SEMIJOIN, + PlSqlLexerNO_SEMI_TO_INNER, + PlSqlLexerNO_SET_TO_JOIN, + PlSqlLexerNOSORT, + PlSqlLexerNO_SQL_TUNE, + PlSqlLexerNO_STAR_TRANSFORMATION, + PlSqlLexerNO_STATEMENT_QUEUING, + PlSqlLexerNO_STATS_GSETS, + PlSqlLexerNOSTRICT, + PlSqlLexerNO_SUBQUERY_PRUNING, + PlSqlLexerNO_SUBSTRB_PAD, + PlSqlLexerNO_SWAP_JOIN_INPUTS, + PlSqlLexerNOSWITCH, + PlSqlLexerNO_TABLE_LOOKUP_BY_NL, + PlSqlLexerNO_TEMP_TABLE, + PlSqlLexerNOTHING, + PlSqlLexerNOTIFICATION, + PlSqlLexerNO_TRANSFORM_DISTINCT_AGG, + PlSqlLexerNO_UNNEST, + PlSqlLexerNO_USE_HASH_AGGREGATION, + PlSqlLexerNO_USE_HASH_GBY_FOR_PUSHDOWN, + PlSqlLexerNO_USE_HASH, + PlSqlLexerNO_USE_INVISIBLE_INDEXES, + PlSqlLexerNO_USE_MERGE, + PlSqlLexerNO_USE_NL, + PlSqlLexerNOVALIDATE, + PlSqlLexerNO_XDB_FASTPATH_INSERT, + PlSqlLexerNO_XML_DML_REWRITE, + PlSqlLexerNO_XMLINDEX_REWRITE_IN_SELECT, + PlSqlLexerNO_XMLINDEX_REWRITE, + PlSqlLexerNO_XML_QUERY_REWRITE, + PlSqlLexerNTH_VALUE, + PlSqlLexerNTILE, + PlSqlLexerNULLIF, + PlSqlLexerNULLS, + PlSqlLexerNUMERIC, + PlSqlLexerNUM_INDEX_KEYS, + PlSqlLexerNUMTODSINTERVAL, + PlSqlLexerNUMTOYMINTERVAL, + PlSqlLexerNVARCHAR2, + PlSqlLexerNVL2, + PlSqlLexerNVL, + PlSqlLexerOBJECT2XML, + PlSqlLexerOBJECT, + PlSqlLexerOBJNO, + PlSqlLexerOBJNO_REUSE, + PlSqlLexerOCCURENCES, + PlSqlLexerOFFLINE, + PlSqlLexerOFF, + PlSqlLexerOIDINDEX, + PlSqlLexerOID, + PlSqlLexerOLAP, + PlSqlLexerOLD, + PlSqlLexerOLD_PUSH_PRED, + PlSqlLexerOLTP, + PlSqlLexerONLINE, + PlSqlLexerONLY, + PlSqlLexerOPAQUE, + PlSqlLexerOPAQUE_TRANSFORM, + PlSqlLexerOPAQUE_XCANONICAL, + PlSqlLexerOPCODE, + PlSqlLexerOPEN, + PlSqlLexerOPERATIONS, + PlSqlLexerOPERATOR, + PlSqlLexerOPT_ESTIMATE, + PlSqlLexerOPTIMAL, + PlSqlLexerOPTIMIZE, + PlSqlLexerOPTIMIZER_FEATURES_ENABLE, + PlSqlLexerOPTIMIZER_GOAL, + PlSqlLexerOPT_PARAM, + PlSqlLexerORA_BRANCH, + PlSqlLexerORADEBUG, + PlSqlLexerORA_DST_AFFECTED, + PlSqlLexerORA_DST_CONVERT, + PlSqlLexerORA_DST_ERROR, + PlSqlLexerORA_GET_ACLIDS, + PlSqlLexerORA_GET_PRIVILEGES, + PlSqlLexerORA_HASH, + PlSqlLexerORA_ROWSCN, + PlSqlLexerORA_ROWSCN_RAW, + PlSqlLexerORA_ROWVERSION, + PlSqlLexerORA_TABVERSION, + PlSqlLexerORDERED, + PlSqlLexerORDERED_PREDICATES, + PlSqlLexerORDINALITY, + PlSqlLexerOR_EXPAND, + PlSqlLexerORGANIZATION, + PlSqlLexerOR_PREDICATES, + PlSqlLexerOTHER, + PlSqlLexerOUTER_JOIN_TO_ANTI, + PlSqlLexerOUTER_JOIN_TO_INNER, + PlSqlLexerOUTER, + PlSqlLexerOUTLINE_LEAF, + PlSqlLexerOUTLINE, + PlSqlLexerOUT_OF_LINE, + PlSqlLexerOVERFLOW, + PlSqlLexerOVERFLOW_NOMOVE, + PlSqlLexerOVERLAPS, + PlSqlLexerOVER, + PlSqlLexerOWNER, + PlSqlLexerOWNERSHIP, + PlSqlLexerOWN, + PlSqlLexerPACKAGE, + PlSqlLexerPACKAGES, + PlSqlLexerPARALLEL_INDEX, + PlSqlLexerPARALLEL, + PlSqlLexerPARAMETERS, + PlSqlLexerPARAM, + PlSqlLexerPARENT, + PlSqlLexerPARITY, + PlSqlLexerPARTIALLY, + PlSqlLexerPARTITION_HASH, + PlSqlLexerPARTITION_LIST, + PlSqlLexerPARTITION, + PlSqlLexerPARTITION_RANGE, + PlSqlLexerPARTITIONS, + PlSqlLexerPARTNUMINST, + PlSqlLexerPASSING, + PlSqlLexerPASSWORD_GRACE_TIME, + PlSqlLexerPASSWORD_LIFE_TIME, + PlSqlLexerPASSWORD_LOCK_TIME, + PlSqlLexerPASSWORD, + PlSqlLexerPASSWORD_REUSE_MAX, + PlSqlLexerPASSWORD_REUSE_TIME, + PlSqlLexerPASSWORD_VERIFY_FUNCTION, + PlSqlLexerPATH, + PlSqlLexerPATHS, + PlSqlLexerPBL_HS_BEGIN, + PlSqlLexerPBL_HS_END, + PlSqlLexerPCTINCREASE, + PlSqlLexerPCTTHRESHOLD, + PlSqlLexerPCTUSED, + PlSqlLexerPCTVERSION, + PlSqlLexerPENDING, + PlSqlLexerPERCENTILE_CONT, + PlSqlLexerPERCENTILE_DISC, + PlSqlLexerPERCENT_KEYWORD, + PlSqlLexerPERCENT_RANKM, + PlSqlLexerPERCENT_RANK, + PlSqlLexerPERFORMANCE, + PlSqlLexerPERMANENT, + PlSqlLexerPERMISSION, + PlSqlLexerPFILE, + PlSqlLexerPHYSICAL, + PlSqlLexerPIKEY, + PlSqlLexerPIV_GB, + PlSqlLexerPIVOT, + PlSqlLexerPIV_SSF, + PlSqlLexerPLACE_DISTINCT, + PlSqlLexerPLACE_GROUP_BY, + PlSqlLexerPLAN, + PlSqlLexerPLSCOPE_SETTINGS, + PlSqlLexerPLSQL_CCFLAGS, + PlSqlLexerPLSQL_CODE_TYPE, + PlSqlLexerPLSQL_DEBUG, + PlSqlLexerPLSQL_OPTIMIZE_LEVEL, + PlSqlLexerPLSQL_WARNINGS, + PlSqlLexerPOINT, + PlSqlLexerPOLICY, + PlSqlLexerPOST_TRANSACTION, + PlSqlLexerPOWERMULTISET_BY_CARDINALITY, + PlSqlLexerPOWERMULTISET, + PlSqlLexerPOWER, + PlSqlLexerPQ_DISTRIBUTE, + PlSqlLexerPQ_MAP, + PlSqlLexerPQ_NOMAP, + PlSqlLexerPREBUILT, + PlSqlLexerPRECEDES, + PlSqlLexerPRECEDING, + PlSqlLexerPRECISION, + PlSqlLexerPRECOMPUTE_SUBQUERY, + PlSqlLexerPREDICATE_REORDERS, + PlSqlLexerPREDICTION_BOUNDS, + PlSqlLexerPREDICTION_COST, + PlSqlLexerPREDICTION_DETAILS, + PlSqlLexerPREDICTION, + PlSqlLexerPREDICTION_PROBABILITY, + PlSqlLexerPREDICTION_SET, + PlSqlLexerPREPARE, + PlSqlLexerPRESENT, + PlSqlLexerPRESENTNNV, + PlSqlLexerPRESENTV, + PlSqlLexerPRESERVE, + PlSqlLexerPRESERVE_OID, + PlSqlLexerPREVIOUS, + PlSqlLexerPRIMARY, + PlSqlLexerPRIVATE, + PlSqlLexerPRIVATE_SGA, + PlSqlLexerPRIVILEGE, + PlSqlLexerPRIVILEGES, + PlSqlLexerPROCEDURAL, + PlSqlLexerPROCEDURE, + PlSqlLexerPROCESS, + PlSqlLexerPROFILE, + PlSqlLexerPROGRAM, + PlSqlLexerPROJECT, + PlSqlLexerPROPAGATE, + PlSqlLexerPROTECTED, + PlSqlLexerPROTECTION, + PlSqlLexerPULL_PRED, + PlSqlLexerPURGE, + PlSqlLexerPUSH_PRED, + PlSqlLexerPUSH_SUBQ, + PlSqlLexerPX_GRANULE, + PlSqlLexerPX_JOIN_FILTER, + PlSqlLexerQB_NAME, + PlSqlLexerQUERY_BLOCK, + PlSqlLexerQUERY, + PlSqlLexerQUEUE_CURR, + PlSqlLexerQUEUE, + PlSqlLexerQUEUE_ROWP, + PlSqlLexerQUIESCE, + PlSqlLexerQUORUM, + PlSqlLexerQUOTA, + PlSqlLexerRANDOM_LOCAL, + PlSqlLexerRANDOM, + PlSqlLexerRANGE, + PlSqlLexerRANKM, + PlSqlLexerRANK, + PlSqlLexerRAPIDLY, + PlSqlLexerRATIO_TO_REPORT, + PlSqlLexerRAWTOHEX, + PlSqlLexerRAWTONHEX, + PlSqlLexerRBA, + PlSqlLexerRBO_OUTLINE, + PlSqlLexerRDBA, + PlSqlLexerREAD, + PlSqlLexerREADS, + PlSqlLexerREAL, + PlSqlLexerREBALANCE, + PlSqlLexerREBUILD, + PlSqlLexerRECORDS_PER_BLOCK, + PlSqlLexerRECOVERABLE, + PlSqlLexerRECOVER, + PlSqlLexerRECOVERY, + PlSqlLexerRECYCLEBIN, + PlSqlLexerRECYCLE, + PlSqlLexerREDACTION, + PlSqlLexerREDO, + PlSqlLexerREDUCED, + PlSqlLexerREDUNDANCY, + PlSqlLexerREF_CASCADE_CURSOR, + PlSqlLexerREFERENCED, + PlSqlLexerREFERENCE, + PlSqlLexerREFERENCES, + PlSqlLexerREFERENCING, + PlSqlLexerREF, + PlSqlLexerREFRESH, + PlSqlLexerREFTOHEX, + PlSqlLexerREGEXP_COUNT, + PlSqlLexerREGEXP_INSTR, + PlSqlLexerREGEXP_LIKE, + PlSqlLexerREGEXP_REPLACE, + PlSqlLexerREGEXP_SUBSTR, + PlSqlLexerREGISTER, + PlSqlLexerREGR_AVGX, + PlSqlLexerREGR_AVGY, + PlSqlLexerREGR_COUNT, + PlSqlLexerREGR_INTERCEPT, + PlSqlLexerREGR_R2, + PlSqlLexerREGR_SLOPE, + PlSqlLexerREGR_SXX, + PlSqlLexerREGR_SXY, + PlSqlLexerREGR_SYY, + PlSqlLexerREGULAR, + PlSqlLexerREJECT, + PlSqlLexerREKEY, + PlSqlLexerRELATIONAL, + PlSqlLexerRELY, + PlSqlLexerREMAINDER, + PlSqlLexerREMOTE_MAPPED, + PlSqlLexerREMOVE, + PlSqlLexerREPAIR, + PlSqlLexerREPEAT, + PlSqlLexerREPLACE, + PlSqlLexerREPLICATION, + PlSqlLexerREQUIRED, + PlSqlLexerRESETLOGS, + PlSqlLexerRESET, + PlSqlLexerRESIZE, + PlSqlLexerRESOLVE, + PlSqlLexerRESOLVER, + PlSqlLexerRESPECT, + PlSqlLexerRESTORE_AS_INTERVALS, + PlSqlLexerRESTORE, + PlSqlLexerRESTRICT_ALL_REF_CONS, + PlSqlLexerRESTRICTED, + PlSqlLexerRESTRICT, + PlSqlLexerRESULT_CACHE, + PlSqlLexerRESUMABLE, + PlSqlLexerRESUME, + PlSqlLexerRETENTION, + PlSqlLexerRETRY_ON_ROW_CHANGE, + PlSqlLexerRETURNING, + PlSqlLexerRETURN, + PlSqlLexerREUSE, + PlSqlLexerREVERSE, + PlSqlLexerREWRITE, + PlSqlLexerREWRITE_OR_ERROR, + PlSqlLexerRIGHT, + PlSqlLexerROLE, + PlSqlLexerROLES, + PlSqlLexerROLLBACK, + PlSqlLexerROLLING, + PlSqlLexerROLLUP, + PlSqlLexerROOT, + PlSqlLexerROUND, + PlSqlLexerROWDEPENDENCIES, + PlSqlLexerROWID, + PlSqlLexerROWIDTOCHAR, + PlSqlLexerROWIDTONCHAR, + PlSqlLexerROW_LENGTH, + PlSqlLexerROW, + PlSqlLexerROW_NUMBER, + PlSqlLexerROWNUM, + PlSqlLexerROWS, + PlSqlLexerRPAD, + PlSqlLexerRTRIM, + PlSqlLexerRULE, + PlSqlLexerRULES, + PlSqlLexerSALT, + PlSqlLexerSAMPLE, + PlSqlLexerSAVE_AS_INTERVALS, + PlSqlLexerSAVEPOINT, + PlSqlLexerSB4, + PlSqlLexerSCALE, + PlSqlLexerSCALE_ROWS, + PlSqlLexerSCAN_INSTANCES, + PlSqlLexerSCAN, + PlSqlLexerSCHEDULER, + PlSqlLexerSCHEMACHECK, + PlSqlLexerSCHEMA, + PlSqlLexerSCN_ASCENDING, + PlSqlLexerSCN, + PlSqlLexerSCOPE, + PlSqlLexerSD_ALL, + PlSqlLexerSD_INHIBIT, + PlSqlLexerSD_SHOW, + PlSqlLexerSEARCH, + PlSqlLexerSECOND, + PlSqlLexerSECUREFILE_DBA, + PlSqlLexerSECUREFILE, + PlSqlLexerSECURITY, + PlSqlLexerSEED, + PlSqlLexerSEG_BLOCK, + PlSqlLexerSEG_FILE, + PlSqlLexerSEGMENT, + PlSqlLexerSELECTIVITY, + PlSqlLexerSEMIJOIN_DRIVER, + PlSqlLexerSEMIJOIN, + PlSqlLexerSEMI_TO_INNER, + PlSqlLexerSEQUENCED, + PlSqlLexerSEQUENCE, + PlSqlLexerSEQUENTIAL, + PlSqlLexerSERIALIZABLE, + PlSqlLexerSERVERERROR, + PlSqlLexerSERVICE, + PlSqlLexerSESSION_CACHED_CURSORS, + PlSqlLexerSESSION, + PlSqlLexerSESSIONS_PER_USER, + PlSqlLexerSESSIONTIMEZONE, + PlSqlLexerSESSIONTZNAME, + PlSqlLexerSETS, + PlSqlLexerSETTINGS, + PlSqlLexerSET_TO_JOIN, + PlSqlLexerSEVERE, + PlSqlLexerSHARED, + PlSqlLexerSHARED_POOL, + PlSqlLexerSHOW, + PlSqlLexerSHRINK, + PlSqlLexerSHUTDOWN, + PlSqlLexerSIBLINGS, + PlSqlLexerSID, + PlSqlLexerSIGNAL_COMPONENT, + PlSqlLexerSIGNAL_FUNCTION, + PlSqlLexerSIGN, + PlSqlLexerSIMPLE, + PlSqlLexerSINGLE, + PlSqlLexerSINGLETASK, + PlSqlLexerSINH, + PlSqlLexerSIN, + PlSqlLexerSKIP_EXT_OPTIMIZER, + PlSqlLexerSKIP_, + PlSqlLexerSKIP_UNQ_UNUSABLE_IDX, + PlSqlLexerSKIP_UNUSABLE_INDEXES, + PlSqlLexerSMALLFILE, + PlSqlLexerSNAPSHOT, + PlSqlLexerSOME, + PlSqlLexerSORT, + PlSqlLexerSOUNDEX, + PlSqlLexerSOURCE, + PlSqlLexerSPACE_KEYWORD, + PlSqlLexerSPECIFICATION, + PlSqlLexerSPFILE, + PlSqlLexerSPLIT, + PlSqlLexerSPREADSHEET, + PlSqlLexerSQLLDR, + PlSqlLexerSQL, + PlSqlLexerSQL_TRACE, + PlSqlLexerSQL_MACRO, + PlSqlLexerSQRT, + PlSqlLexerSTALE, + PlSqlLexerSTANDALONE, + PlSqlLexerSTANDBY_MAX_DATA_DELAY, + PlSqlLexerSTANDBY, + PlSqlLexerSTAR, + PlSqlLexerSTAR_TRANSFORMATION, + PlSqlLexerSTARTUP, + PlSqlLexerSTATEMENT_ID, + PlSqlLexerSTATEMENT_QUEUING, + PlSqlLexerSTATEMENTS, + PlSqlLexerSTATIC, + PlSqlLexerSTATISTICS, + PlSqlLexerSTATS_BINOMIAL_TEST, + PlSqlLexerSTATS_CROSSTAB, + PlSqlLexerSTATS_F_TEST, + PlSqlLexerSTATS_KS_TEST, + PlSqlLexerSTATS_MODE, + PlSqlLexerSTATS_MW_TEST, + PlSqlLexerSTATS_ONE_WAY_ANOVA, + PlSqlLexerSTATS_T_TEST_INDEP, + PlSqlLexerSTATS_T_TEST_INDEPU, + PlSqlLexerSTATS_T_TEST_ONE, + PlSqlLexerSTATS_T_TEST_PAIRED, + PlSqlLexerSTATS_WSR_TEST, + PlSqlLexerSTDDEV, + PlSqlLexerSTDDEV_POP, + PlSqlLexerSTDDEV_SAMP, + PlSqlLexerSTOP, + PlSqlLexerSTORAGE, + PlSqlLexerSTORE, + PlSqlLexerSTREAMS, + PlSqlLexerSTRICT, + PlSqlLexerSTRING, + PlSqlLexerSTRIPE_COLUMNS, + PlSqlLexerSTRIPE_WIDTH, + PlSqlLexerSTRIP, + PlSqlLexerSTRUCTURE, + PlSqlLexerSUBMULTISET, + PlSqlLexerSUBPARTITION, + PlSqlLexerSUBPARTITION_REL, + PlSqlLexerSUBPARTITIONS, + PlSqlLexerSUBQUERIES, + PlSqlLexerSUBQUERY_PRUNING, + PlSqlLexerSUBSTITUTABLE, + PlSqlLexerSUBSTR2, + PlSqlLexerSUBSTR4, + PlSqlLexerSUBSTRB, + PlSqlLexerSUBSTRC, + PlSqlLexerSUBSTR, + PlSqlLexerSUCCESSFUL, + PlSqlLexerSUMMARY, + PlSqlLexerSUM, + PlSqlLexerSUPPLEMENTAL, + PlSqlLexerSUSPEND, + PlSqlLexerSWAP_JOIN_INPUTS, + PlSqlLexerSWITCH, + PlSqlLexerSWITCHOVER, + PlSqlLexerSYNCHRONOUS, + PlSqlLexerSYNC, + PlSqlLexerSYS, + PlSqlLexerSYSASM, + PlSqlLexerSYS_AUDIT, + PlSqlLexerSYSAUX, + PlSqlLexerSYS_CHECKACL, + PlSqlLexerSYS_CONNECT_BY_PATH, + PlSqlLexerSYS_CONTEXT, + PlSqlLexerSYSDATE, + PlSqlLexerSYSDBA, + PlSqlLexerSYS_DBURIGEN, + PlSqlLexerSYS_DL_CURSOR, + PlSqlLexerSYS_DM_RXFORM_CHR, + PlSqlLexerSYS_DM_RXFORM_NUM, + PlSqlLexerSYS_DOM_COMPARE, + PlSqlLexerSYS_DST_PRIM2SEC, + PlSqlLexerSYS_DST_SEC2PRIM, + PlSqlLexerSYS_ET_BFILE_TO_RAW, + PlSqlLexerSYS_ET_BLOB_TO_IMAGE, + PlSqlLexerSYS_ET_IMAGE_TO_BLOB, + PlSqlLexerSYS_ET_RAW_TO_BFILE, + PlSqlLexerSYS_EXTPDTXT, + PlSqlLexerSYS_EXTRACT_UTC, + PlSqlLexerSYS_FBT_INSDEL, + PlSqlLexerSYS_FILTER_ACLS, + PlSqlLexerSYS_FNMATCHES, + PlSqlLexerSYS_FNREPLACE, + PlSqlLexerSYS_GET_ACLIDS, + PlSqlLexerSYS_GET_PRIVILEGES, + PlSqlLexerSYS_GETTOKENID, + PlSqlLexerSYS_GETXTIVAL, + PlSqlLexerSYS_GUID, + PlSqlLexerSYS_MAKEXML, + PlSqlLexerSYS_MAKE_XMLNODEID, + PlSqlLexerSYS_MKXMLATTR, + PlSqlLexerSYS_OP_ADT2BIN, + PlSqlLexerSYS_OP_ADTCONS, + PlSqlLexerSYS_OP_ALSCRVAL, + PlSqlLexerSYS_OP_ATG, + PlSqlLexerSYS_OP_BIN2ADT, + PlSqlLexerSYS_OP_BITVEC, + PlSqlLexerSYS_OP_BL2R, + PlSqlLexerSYS_OP_BLOOM_FILTER_LIST, + PlSqlLexerSYS_OP_BLOOM_FILTER, + PlSqlLexerSYS_OP_C2C, + PlSqlLexerSYS_OP_CAST, + PlSqlLexerSYS_OP_CEG, + PlSqlLexerSYS_OP_CL2C, + PlSqlLexerSYS_OP_COMBINED_HASH, + PlSqlLexerSYS_OP_COMP, + PlSqlLexerSYS_OP_CONVERT, + PlSqlLexerSYS_OP_COUNTCHG, + PlSqlLexerSYS_OP_CSCONV, + PlSqlLexerSYS_OP_CSCONVTEST, + PlSqlLexerSYS_OP_CSR, + PlSqlLexerSYS_OP_CSX_PATCH, + PlSqlLexerSYS_OP_DECOMP, + PlSqlLexerSYS_OP_DESCEND, + PlSqlLexerSYS_OP_DISTINCT, + PlSqlLexerSYS_OP_DRA, + PlSqlLexerSYS_OP_DUMP, + PlSqlLexerSYS_OP_DV_CHECK, + PlSqlLexerSYS_OP_ENFORCE_NOT_NULL, + PlSqlLexerSYSOPER, + PlSqlLexerSYS_OP_EXTRACT, + PlSqlLexerSYS_OP_GROUPING, + PlSqlLexerSYS_OP_GUID, + PlSqlLexerSYS_OP_IIX, + PlSqlLexerSYS_OP_ITR, + PlSqlLexerSYS_OP_LBID, + PlSqlLexerSYS_OP_LOBLOC2BLOB, + PlSqlLexerSYS_OP_LOBLOC2CLOB, + PlSqlLexerSYS_OP_LOBLOC2ID, + PlSqlLexerSYS_OP_LOBLOC2NCLOB, + PlSqlLexerSYS_OP_LOBLOC2TYP, + PlSqlLexerSYS_OP_LSVI, + PlSqlLexerSYS_OP_LVL, + PlSqlLexerSYS_OP_MAKEOID, + PlSqlLexerSYS_OP_MAP_NONNULL, + PlSqlLexerSYS_OP_MSR, + PlSqlLexerSYS_OP_NICOMBINE, + PlSqlLexerSYS_OP_NIEXTRACT, + PlSqlLexerSYS_OP_NII, + PlSqlLexerSYS_OP_NIX, + PlSqlLexerSYS_OP_NOEXPAND, + PlSqlLexerSYS_OP_NTCIMG, + PlSqlLexerSYS_OP_NUMTORAW, + PlSqlLexerSYS_OP_OIDVALUE, + PlSqlLexerSYS_OP_OPNSIZE, + PlSqlLexerSYS_OP_PAR_1, + PlSqlLexerSYS_OP_PARGID_1, + PlSqlLexerSYS_OP_PARGID, + PlSqlLexerSYS_OP_PAR, + PlSqlLexerSYS_OP_PIVOT, + PlSqlLexerSYS_OP_R2O, + PlSqlLexerSYS_OP_RAWTONUM, + PlSqlLexerSYS_OP_RDTM, + PlSqlLexerSYS_OP_REF, + PlSqlLexerSYS_OP_RMTD, + PlSqlLexerSYS_OP_ROWIDTOOBJ, + PlSqlLexerSYS_OP_RPB, + PlSqlLexerSYS_OPTLOBPRBSC, + PlSqlLexerSYS_OP_TOSETID, + PlSqlLexerSYS_OP_TPR, + PlSqlLexerSYS_OP_TRTB, + PlSqlLexerSYS_OPTXICMP, + PlSqlLexerSYS_OPTXQCASTASNQ, + PlSqlLexerSYS_OP_UNDESCEND, + PlSqlLexerSYS_OP_VECAND, + PlSqlLexerSYS_OP_VECBIT, + PlSqlLexerSYS_OP_VECOR, + PlSqlLexerSYS_OP_VECXOR, + PlSqlLexerSYS_OP_VERSION, + PlSqlLexerSYS_OP_VREF, + PlSqlLexerSYS_OP_VVD, + PlSqlLexerSYS_OP_XMLCONS_FOR_CSX, + PlSqlLexerSYS_OP_XPTHATG, + PlSqlLexerSYS_OP_XPTHIDX, + PlSqlLexerSYS_OP_XPTHOP, + PlSqlLexerSYS_OP_XTXT2SQLT, + PlSqlLexerSYS_ORDERKEY_DEPTH, + PlSqlLexerSYS_ORDERKEY_MAXCHILD, + PlSqlLexerSYS_ORDERKEY_PARENT, + PlSqlLexerSYS_PARALLEL_TXN, + PlSqlLexerSYS_PATHID_IS_ATTR, + PlSqlLexerSYS_PATHID_IS_NMSPC, + PlSqlLexerSYS_PATHID_LASTNAME, + PlSqlLexerSYS_PATHID_LASTNMSPC, + PlSqlLexerSYS_PATH_REVERSE, + PlSqlLexerSYS_PXQEXTRACT, + PlSqlLexerSYS_RID_ORDER, + PlSqlLexerSYS_ROW_DELTA, + PlSqlLexerSYS_SC_2_XMLT, + PlSqlLexerSYS_SYNRCIREDO, + PlSqlLexerSYSTEM_DEFINED, + PlSqlLexerSYSTEM, + PlSqlLexerSYSTIMESTAMP, + PlSqlLexerSYS_TYPEID, + PlSqlLexerSYS_UMAKEXML, + PlSqlLexerSYS_XMLANALYZE, + PlSqlLexerSYS_XMLCONTAINS, + PlSqlLexerSYS_XMLCONV, + PlSqlLexerSYS_XMLEXNSURI, + PlSqlLexerSYS_XMLGEN, + PlSqlLexerSYS_XMLI_LOC_ISNODE, + PlSqlLexerSYS_XMLI_LOC_ISTEXT, + PlSqlLexerSYS_XMLINSTR, + PlSqlLexerSYS_XMLLOCATOR_GETSVAL, + PlSqlLexerSYS_XMLNODEID_GETCID, + PlSqlLexerSYS_XMLNODEID_GETLOCATOR, + PlSqlLexerSYS_XMLNODEID_GETOKEY, + PlSqlLexerSYS_XMLNODEID_GETPATHID, + PlSqlLexerSYS_XMLNODEID_GETPTRID, + PlSqlLexerSYS_XMLNODEID_GETRID, + PlSqlLexerSYS_XMLNODEID_GETSVAL, + PlSqlLexerSYS_XMLNODEID_GETTID, + PlSqlLexerSYS_XMLNODEID, + PlSqlLexerSYS_XMLT_2_SC, + PlSqlLexerSYS_XMLTRANSLATE, + PlSqlLexerSYS_XMLTYPE2SQL, + PlSqlLexerSYS_XQ_ASQLCNV, + PlSqlLexerSYS_XQ_ATOMCNVCHK, + PlSqlLexerSYS_XQBASEURI, + PlSqlLexerSYS_XQCASTABLEERRH, + PlSqlLexerSYS_XQCODEP2STR, + PlSqlLexerSYS_XQCODEPEQ, + PlSqlLexerSYS_XQCON2SEQ, + PlSqlLexerSYS_XQCONCAT, + PlSqlLexerSYS_XQDELETE, + PlSqlLexerSYS_XQDFLTCOLATION, + PlSqlLexerSYS_XQDOC, + PlSqlLexerSYS_XQDOCURI, + PlSqlLexerSYS_XQDURDIV, + PlSqlLexerSYS_XQED4URI, + PlSqlLexerSYS_XQENDSWITH, + PlSqlLexerSYS_XQERRH, + PlSqlLexerSYS_XQERR, + PlSqlLexerSYS_XQESHTMLURI, + PlSqlLexerSYS_XQEXLOBVAL, + PlSqlLexerSYS_XQEXSTWRP, + PlSqlLexerSYS_XQEXTRACT, + PlSqlLexerSYS_XQEXTRREF, + PlSqlLexerSYS_XQEXVAL, + PlSqlLexerSYS_XQFB2STR, + PlSqlLexerSYS_XQFNBOOL, + PlSqlLexerSYS_XQFNCMP, + PlSqlLexerSYS_XQFNDATIM, + PlSqlLexerSYS_XQFNLNAME, + PlSqlLexerSYS_XQFNNM, + PlSqlLexerSYS_XQFNNSURI, + PlSqlLexerSYS_XQFNPREDTRUTH, + PlSqlLexerSYS_XQFNQNM, + PlSqlLexerSYS_XQFNROOT, + PlSqlLexerSYS_XQFORMATNUM, + PlSqlLexerSYS_XQFTCONTAIN, + PlSqlLexerSYS_XQFUNCR, + PlSqlLexerSYS_XQGETCONTENT, + PlSqlLexerSYS_XQINDXOF, + PlSqlLexerSYS_XQINSERT, + PlSqlLexerSYS_XQINSPFX, + PlSqlLexerSYS_XQIRI2URI, + PlSqlLexerSYS_XQLANG, + PlSqlLexerSYS_XQLLNMFRMQNM, + PlSqlLexerSYS_XQMKNODEREF, + PlSqlLexerSYS_XQNILLED, + PlSqlLexerSYS_XQNODENAME, + PlSqlLexerSYS_XQNORMSPACE, + PlSqlLexerSYS_XQNORMUCODE, + PlSqlLexerSYS_XQ_NRNG, + PlSqlLexerSYS_XQNSP4PFX, + PlSqlLexerSYS_XQNSPFRMQNM, + PlSqlLexerSYS_XQPFXFRMQNM, + PlSqlLexerSYS_XQ_PKSQL2XML, + PlSqlLexerSYS_XQPOLYABS, + PlSqlLexerSYS_XQPOLYADD, + PlSqlLexerSYS_XQPOLYCEL, + PlSqlLexerSYS_XQPOLYCSTBL, + PlSqlLexerSYS_XQPOLYCST, + PlSqlLexerSYS_XQPOLYDIV, + PlSqlLexerSYS_XQPOLYFLR, + PlSqlLexerSYS_XQPOLYMOD, + PlSqlLexerSYS_XQPOLYMUL, + PlSqlLexerSYS_XQPOLYRND, + PlSqlLexerSYS_XQPOLYSQRT, + PlSqlLexerSYS_XQPOLYSUB, + PlSqlLexerSYS_XQPOLYUMUS, + PlSqlLexerSYS_XQPOLYUPLS, + PlSqlLexerSYS_XQPOLYVEQ, + PlSqlLexerSYS_XQPOLYVGE, + PlSqlLexerSYS_XQPOLYVGT, + PlSqlLexerSYS_XQPOLYVLE, + PlSqlLexerSYS_XQPOLYVLT, + PlSqlLexerSYS_XQPOLYVNE, + PlSqlLexerSYS_XQREF2VAL, + PlSqlLexerSYS_XQRENAME, + PlSqlLexerSYS_XQREPLACE, + PlSqlLexerSYS_XQRESVURI, + PlSqlLexerSYS_XQRNDHALF2EVN, + PlSqlLexerSYS_XQRSLVQNM, + PlSqlLexerSYS_XQRYENVPGET, + PlSqlLexerSYS_XQRYVARGET, + PlSqlLexerSYS_XQRYWRP, + PlSqlLexerSYS_XQSEQ2CON4XC, + PlSqlLexerSYS_XQSEQ2CON, + PlSqlLexerSYS_XQSEQDEEPEQ, + PlSqlLexerSYS_XQSEQINSB, + PlSqlLexerSYS_XQSEQRM, + PlSqlLexerSYS_XQSEQRVS, + PlSqlLexerSYS_XQSEQSUB, + PlSqlLexerSYS_XQSEQTYPMATCH, + PlSqlLexerSYS_XQSTARTSWITH, + PlSqlLexerSYS_XQSTATBURI, + PlSqlLexerSYS_XQSTR2CODEP, + PlSqlLexerSYS_XQSTRJOIN, + PlSqlLexerSYS_XQSUBSTRAFT, + PlSqlLexerSYS_XQSUBSTRBEF, + PlSqlLexerSYS_XQTOKENIZE, + PlSqlLexerSYS_XQTREATAS, + PlSqlLexerSYS_XQ_UPKXML2SQL, + PlSqlLexerSYS_XQXFORM, + PlSqlLexerTABLE, + PlSqlLexerTABLE_LOOKUP_BY_NL, + PlSqlLexerTABLES, + PlSqlLexerTABLESPACE, + PlSqlLexerTABLESPACE_NO, + PlSqlLexerTABLE_STATS, + PlSqlLexerTABNO, + PlSqlLexerTANH, + PlSqlLexerTAN, + PlSqlLexerTBLORIDXPARTNUM, + PlSqlLexerTEMPFILE, + PlSqlLexerTEMPLATE, + PlSqlLexerTEMPORARY, + PlSqlLexerTEMP_TABLE, + PlSqlLexerTEST, + PlSqlLexerTHAN, + PlSqlLexerTHE, + PlSqlLexerTHEN, + PlSqlLexerTHREAD, + PlSqlLexerTHROUGH, + PlSqlLexerTIME, + PlSqlLexerTIMING, + PlSqlLexerTIMEOUT, + PlSqlLexerTIMES, + PlSqlLexerTIMESTAMP, + PlSqlLexerTIMEZONE_ABBR, + PlSqlLexerTIMEZONE_HOUR, + PlSqlLexerTIMEZONE_MINUTE, + PlSqlLexerTIME_ZONE, + PlSqlLexerTIMEZONE_OFFSET, + PlSqlLexerTIMEZONE_REGION, + PlSqlLexerTIV_GB, + PlSqlLexerTIV_SSF, + PlSqlLexerTO_BINARY_DOUBLE, + PlSqlLexerTO_BINARY_FLOAT, + PlSqlLexerTO_BLOB, + PlSqlLexerTO_CHAR, + PlSqlLexerTO_CLOB, + PlSqlLexerTO_DATE, + PlSqlLexerTO_DSINTERVAL, + PlSqlLexerTO_LOB, + PlSqlLexerTO_MULTI_BYTE, + PlSqlLexerTO_NCHAR, + PlSqlLexerTO_NCLOB, + PlSqlLexerTO_NUMBER, + PlSqlLexerTOPLEVEL, + PlSqlLexerTO_SINGLE_BYTE, + PlSqlLexerTO_TIME, + PlSqlLexerTO_TIMESTAMP, + PlSqlLexerTO_TIMESTAMP_TZ, + PlSqlLexerTO_TIME_TZ, + PlSqlLexerTO_YMINTERVAL, + PlSqlLexerTRACE, + PlSqlLexerTRACING, + PlSqlLexerTRACKING, + PlSqlLexerTRAILING, + PlSqlLexerTRANSACTION, + PlSqlLexerTRANSFORM_DISTINCT_AGG, + PlSqlLexerTRANSITIONAL, + PlSqlLexerTRANSITION, + PlSqlLexerTRANSLATE, + PlSqlLexerTREAT, + PlSqlLexerTRIGGERS, + PlSqlLexerTRIM, + PlSqlLexerTRUE, + PlSqlLexerTRUNCATE, + PlSqlLexerTRUNC, + PlSqlLexerTRUSTED, + PlSqlLexerTUNING, + PlSqlLexerTX, + PlSqlLexerTYPE, + PlSqlLexerTYPES, + PlSqlLexerTZ_OFFSET, + PlSqlLexerUB2, + PlSqlLexerUBA, + PlSqlLexerUID, + PlSqlLexerUNARCHIVED, + PlSqlLexerUNBOUNDED, + PlSqlLexerUNBOUND, + PlSqlLexerUNDER, + PlSqlLexerUNDO, + PlSqlLexerUNDROP, + PlSqlLexerUNIFORM, + PlSqlLexerUNISTR, + PlSqlLexerUNLIMITED, + PlSqlLexerUNLOAD, + PlSqlLexerUNLOCK, + PlSqlLexerUNNEST_INNERJ_DISTINCT_VIEW, + PlSqlLexerUNNEST, + PlSqlLexerUNNEST_NOSEMIJ_NODISTINCTVIEW, + PlSqlLexerUNNEST_SEMIJ_VIEW, + PlSqlLexerUNPACKED, + PlSqlLexerUNPIVOT, + PlSqlLexerUNPROTECTED, + PlSqlLexerUNQUIESCE, + PlSqlLexerUNRECOVERABLE, + PlSqlLexerUNRESTRICTED, + PlSqlLexerUNTIL, + PlSqlLexerUNUSABLE, + PlSqlLexerUNUSED, + PlSqlLexerUPDATABLE, + PlSqlLexerUPDATED, + PlSqlLexerUPDATEXML, + PlSqlLexerUPD_INDEXES, + PlSqlLexerUPD_JOININDEX, + PlSqlLexerUPGRADE, + PlSqlLexerUPPER, + PlSqlLexerUPSERT, + PlSqlLexerUROWID, + PlSqlLexerUSAGE, + PlSqlLexerUSE_ANTI, + PlSqlLexerUSE_CONCAT, + PlSqlLexerUSE_HASH_AGGREGATION, + PlSqlLexerUSE_HASH_GBY_FOR_PUSHDOWN, + PlSqlLexerUSE_HASH, + PlSqlLexerUSE_INVISIBLE_INDEXES, + PlSqlLexerUSE_MERGE_CARTESIAN, + PlSqlLexerUSE_MERGE, + PlSqlLexerUSE, + PlSqlLexerUSE_NL, + PlSqlLexerUSE_NL_WITH_INDEX, + PlSqlLexerUSE_PRIVATE_OUTLINES, + PlSqlLexerUSER_DEFINED, + PlSqlLexerUSERENV, + PlSqlLexerUSERGROUP, + PlSqlLexerUSER, + PlSqlLexerUSER_RECYCLEBIN, + PlSqlLexerUSERS, + PlSqlLexerUSE_SEMI, + PlSqlLexerUSE_STORED_OUTLINES, + PlSqlLexerUSE_TTT_FOR_GSETS, + PlSqlLexerUSE_WEAK_NAME_RESL, + PlSqlLexerUSING, + PlSqlLexerVALIDATE, + PlSqlLexerVALIDATION, + PlSqlLexerVALUE, + PlSqlLexerVARIANCE, + PlSqlLexerVAR_POP, + PlSqlLexerVARRAY, + PlSqlLexerVARRAYS, + PlSqlLexerVAR_SAMP, + PlSqlLexerVARYING, + PlSqlLexerVECTOR_READ, + PlSqlLexerVECTOR_READ_TRACE, + PlSqlLexerVERIFY, + PlSqlLexerVERSIONING, + PlSqlLexerVERSION, + PlSqlLexerVERSIONS_ENDSCN, + PlSqlLexerVERSIONS_ENDTIME, + PlSqlLexerVERSIONS, + PlSqlLexerVERSIONS_OPERATION, + PlSqlLexerVERSIONS_STARTSCN, + PlSqlLexerVERSIONS_STARTTIME, + PlSqlLexerVERSIONS_XID, + PlSqlLexerVIRTUAL, + PlSqlLexerVISIBLE, + PlSqlLexerVOLUME, + PlSqlLexerVSIZE, + PlSqlLexerWAIT, + PlSqlLexerWALLET, + PlSqlLexerWELLFORMED, + PlSqlLexerWHENEVER, + PlSqlLexerWHEN, + PlSqlLexerWHITESPACE, + PlSqlLexerWIDTH_BUCKET, + PlSqlLexerWITHIN, + PlSqlLexerWITHOUT, + PlSqlLexerWORK, + PlSqlLexerWRAPPED, + PlSqlLexerWRITE, + PlSqlLexerXDB_FASTPATH_INSERT, + PlSqlLexerX_DYN_PRUNE, + PlSqlLexerXID, + PlSqlLexerXML2OBJECT, + PlSqlLexerXMLATTRIBUTES, + PlSqlLexerXMLCAST, + PlSqlLexerXMLCDATA, + PlSqlLexerXMLCOLATTVAL, + PlSqlLexerXMLCOMMENT, + PlSqlLexerXMLCONCAT, + PlSqlLexerXMLDIFF, + PlSqlLexerXML_DML_RWT_STMT, + PlSqlLexerXMLELEMENT, + PlSqlLexerXMLEXISTS2, + PlSqlLexerXMLEXISTS, + PlSqlLexerXMLFOREST, + PlSqlLexerXMLINDEX_REWRITE_IN_SELECT, + PlSqlLexerXMLINDEX_REWRITE, + PlSqlLexerXMLINDEX_SEL_IDX_TBL, + PlSqlLexerXMLISNODE, + PlSqlLexerXMLISVALID, + PlSqlLexerXML, + PlSqlLexerXMLNAMESPACES, + PlSqlLexerXMLPARSE, + PlSqlLexerXMLPATCH, + PlSqlLexerXMLPI, + PlSqlLexerXMLQUERY, + PlSqlLexerXMLQUERYVAL, + PlSqlLexerXMLROOT, + PlSqlLexerXMLSCHEMA, + PlSqlLexerXMLSERIALIZE, + PlSqlLexerXMLTABLE, + PlSqlLexerXMLTRANSFORMBLOB, + PlSqlLexerXMLTRANSFORM, + PlSqlLexerXMLTYPE, + PlSqlLexerXPATHTABLE, + PlSqlLexerXS_SYS_CONTEXT, + PlSqlLexerYEAR, + PlSqlLexerYES, + PlSqlLexerZONE: + return true + case PlSqlLexerACL, + PlSqlLexerACROSS, + PlSqlLexerACTION, + PlSqlLexerACTIONS, + PlSqlLexerACTIVE, + PlSqlLexerACTIVE_DATA, + PlSqlLexerACTIVITY, + PlSqlLexerADAPTIVE_PLAN, + PlSqlLexerADVANCED, + PlSqlLexerAFD_DISKSTRING, + PlSqlLexerALTERNATE, + PlSqlLexerALGORITHM, + PlSqlLexerANALYTIC, + PlSqlLexerANCESTOR, + PlSqlLexerANOMALY, + PlSqlLexerANSI_REARCH, + PlSqlLexerAPPLICATION, + PlSqlLexerAPPROX_COUNT_DISTINCT, + PlSqlLexerARCHIVAL, + PlSqlLexerARCHIVED, + PlSqlLexerASIS, + PlSqlLexerASSIGN, + PlSqlLexerAUTO_LOGIN, + PlSqlLexerAUTO_REOPTIMIZE, + PlSqlLexerAVRO, + PlSqlLexerBACKGROUND, + PlSqlLexerBACKUPS, + PlSqlLexerBATCHSIZE, + PlSqlLexerBATCH_TABLE_ACCESS_BY_ROWID, + PlSqlLexerBEGINNING, + PlSqlLexerBEQUEATH, + PlSqlLexerBITMAP_AND, + PlSqlLexerBLOCKCHAIN, + PlSqlLexerBSON, + PlSqlLexerCACHING, + PlSqlLexerCALCULATED, + PlSqlLexerCALLBACK, + PlSqlLexerCAPACITY, + PlSqlLexerCAPTION, + PlSqlLexerCDBDEFAULT, + PlSqlLexerCLASSIFICATION, + PlSqlLexerCLASSIFIER, + PlSqlLexerCLAUSE, + PlSqlLexerCLEAN, + PlSqlLexerCLEANUP, + PlSqlLexerCLIENT, + PlSqlLexerCLUSTERING, + PlSqlLexerCLUSTER_DETAILS, + PlSqlLexerCLUSTER_DISTANCE, + PlSqlLexerCOLLATE, + PlSqlLexerCOLLATION, + PlSqlLexerCOMMON, + PlSqlLexerCOMMON_DATA, + PlSqlLexerCOMPONENT, + PlSqlLexerCOMPONENTS, + PlSqlLexerCONDITION, + PlSqlLexerCONDITIONAL, + PlSqlLexerCONTAINERS, + PlSqlLexerCONTAINERS_DEFAULT, + PlSqlLexerCONTAINER_DATA, + PlSqlLexerCONTAINER_MAP, + PlSqlLexerCONVERSION, + PlSqlLexerCON_DBID_TO_ID, + PlSqlLexerCON_GUID_TO_ID, + PlSqlLexerCON_ID, + PlSqlLexerCON_NAME_TO_ID, + PlSqlLexerCON_UID_TO_ID, + PlSqlLexerCOOKIE, + PlSqlLexerCOPY, + PlSqlLexerCREATE_FILE_DEST, + PlSqlLexerCREDENTIAL, + PlSqlLexerCRITICAL, + PlSqlLexerCUBE_AJ, + PlSqlLexerCUBE_SJ, + PlSqlLexerDATAMOVEMENT, + PlSqlLexerDATAOBJ_TO_MAT_PARTITION, + PlSqlLexerDATAPUMP, + PlSqlLexerDATA_SECURITY_REWRITE_LIMIT, + PlSqlLexerDAYS, + PlSqlLexerDB_UNIQUE_NAME, + PlSqlLexerDECORRELATE, + PlSqlLexerDEFAULT_CREDENTIAL, + PlSqlLexerDEFAULT_COLLATION, + PlSqlLexerDEFINE, + PlSqlLexerDEFINITION, + PlSqlLexerDELEGATE, + PlSqlLexerDELETE_ALL, + PlSqlLexerDESCRIPTION, + PlSqlLexerDESTROY, + PlSqlLexerDIMENSIONS, + PlSqlLexerDISABLE_ALL, + PlSqlLexerDISABLE_PARALLEL_DML, + PlSqlLexerDISCARD, + PlSqlLexerDISTRIBUTE, + PlSqlLexerDUPLICATE, + PlSqlLexerDUPLICATED, + PlSqlLexerDV, + PlSqlLexerEDITIONABLE, + PlSqlLexerELIM_GROUPBY, + PlSqlLexerEM, + PlSqlLexerENABLE_ALL, + PlSqlLexerENABLE_PARALLEL_DML, + PlSqlLexerEQUIPART, + PlSqlLexerEVAL, + PlSqlLexerEVALUATE, + PlSqlLexerEXISTING, + PlSqlLexerEXPRESS, + PlSqlLexerEXTENDED, + PlSqlLexerEXTRACTCLOBXML, + PlSqlLexerFACTOR, + PlSqlLexerFAILOVER, + PlSqlLexerFAILURE, + PlSqlLexerFAMILY, + PlSqlLexerFAR, + PlSqlLexerFASTSTART, + PlSqlLexerFEATURE, + PlSqlLexerFEATURE_DETAILS, + PlSqlLexerFETCH, + PlSqlLexerFILE_NAME_CONVERT, + PlSqlLexerFILEGROUP, + PlSqlLexerFIXED_VIEW_DATA, + PlSqlLexerFLEX, + PlSqlLexerFORMAT, + PlSqlLexerFTP, + PlSqlLexerGATHER_OPTIMIZER_STATISTICS, + PlSqlLexerGET, + PlSqlLexerHALF_YEARS, + PlSqlLexerHASHING, + PlSqlLexerHIER_ORDER, + PlSqlLexerHIERARCHICAL, + PlSqlLexerHOURS, + PlSqlLexerHTTP, + PlSqlLexerH_LETTER, + PlSqlLexerIDLE, + PlSqlLexerILM, + PlSqlLexerIMMUTABLE, + PlSqlLexerINACTIVE, + PlSqlLexerINACTIVE_ACCOUNT_TIME, + PlSqlLexerINDEXING, + PlSqlLexerINHERIT, + PlSqlLexerINMEMORY, + PlSqlLexerINMEMORY_PRUNING, + PlSqlLexerINPLACE, + PlSqlLexerINTERLEAVED, + PlSqlLexerISOLATE, + PlSqlLexerIS_LEAF, + PlSqlLexerJSON, + PlSqlLexerJSONGET, + PlSqlLexerJSONPARSE, + PlSqlLexerJSON_ARRAY, + PlSqlLexerJSON_ARRAYAGG, + PlSqlLexerJSON_EQUAL, + PlSqlLexerJSON_EXISTS, + PlSqlLexerJSON_EXISTS2, + PlSqlLexerJSON_OBJECT, + PlSqlLexerJSON_OBJECTAGG, + PlSqlLexerJSON_QUERY, + PlSqlLexerJSON_SERIALIZE, + PlSqlLexerJSON_TABLE, + PlSqlLexerJSON_TEXTCONTAINS, + PlSqlLexerJSON_TEXTCONTAINS2, + PlSqlLexerJSON_VALUE, + PlSqlLexerKEYSTORE, + PlSqlLexerLABEL, + PlSqlLexerLAX, + PlSqlLexerLEAD_CDB, + PlSqlLexerLEAD_CDB_URI, + PlSqlLexerLEVEL_NAME, + PlSqlLexerLIFECYCLE, + PlSqlLexerLINEAR, + PlSqlLexerLOCKDOWN, + PlSqlLexerLOCKING, + PlSqlLexerLOGMINING, + PlSqlLexerLOST, + PlSqlLexerMANDATORY, + PlSqlLexerMAP, + PlSqlLexerMATCH, + PlSqlLexerMATCHES, + PlSqlLexerMATCH_NUMBER, + PlSqlLexerMATCH_RECOGNIZE, + PlSqlLexerMAX_SHARED_TEMP_SIZE, + PlSqlLexerMEMCOMPRESS, + PlSqlLexerMETADATA, + PlSqlLexerMEMBER_CAPTION, + PlSqlLexerMEMBER_DESCRIPTION, + PlSqlLexerMEMBER_NAME, + PlSqlLexerMEMBER_UNIQUE_NAME, + PlSqlLexerMINUTES, + PlSqlLexerMODEL_NB, + PlSqlLexerMODEL_SV, + PlSqlLexerMODIFICATION, + PlSqlLexerMODULE, + PlSqlLexerMONTHS, + PlSqlLexerMULTIDIMENSIONAL, + PlSqlLexerNEG, + PlSqlLexerNOCOPY, + PlSqlLexerNOKEEP, + PlSqlLexerNONEDITIONABLE, + PlSqlLexerNOPARTITION, + PlSqlLexerNORELOCATE, + PlSqlLexerNOREPLAY, + PlSqlLexerNO_ADAPTIVE_PLAN, + PlSqlLexerNO_ANSI_REARCH, + PlSqlLexerNO_AUTO_REOPTIMIZE, + PlSqlLexerNO_BATCH_TABLE_ACCESS_BY_ROWID, + PlSqlLexerNO_CLUSTERING, + PlSqlLexerNO_COMMON_DATA, + PlSqlLexerNO_DATA_SECURITY_REWRITE, + PlSqlLexerNO_DECORRELATE, + PlSqlLexerNO_ELIM_GROUPBY, + PlSqlLexerNO_GATHER_OPTIMIZER_STATISTICS, + PlSqlLexerNO_INMEMORY, + PlSqlLexerNO_INMEMORY_PRUNING, + PlSqlLexerNO_OBJECT_LINK, + PlSqlLexerNO_PARTIAL_JOIN, + PlSqlLexerNO_PARTIAL_ROLLUP_PUSHDOWN, + PlSqlLexerNO_PQ_CONCURRENT_UNION, + PlSqlLexerNO_PQ_REPLICATE, + PlSqlLexerNO_PQ_SKEW, + PlSqlLexerNOPROMPT, + PlSqlLexerNO_PX_FAULT_TOLERANCE, + PlSqlLexerNO_ROOT_SW_FOR_LOCAL, + PlSqlLexerNO_SQL_TRANSLATION, + PlSqlLexerNO_USE_CUBE, + PlSqlLexerNO_USE_VECTOR_AGGREGATION, + PlSqlLexerNO_VECTOR_TRANSFORM, + PlSqlLexerNO_VECTOR_TRANSFORM_DIMS, + PlSqlLexerNO_VECTOR_TRANSFORM_FACT, + PlSqlLexerNO_ZONEMAP, + PlSqlLexerOBJ_ID, + PlSqlLexerOFFSET, + PlSqlLexerOLS, + PlSqlLexerOMIT, + PlSqlLexerONE, + PlSqlLexerORACLE_DATAPUMP, + PlSqlLexerORACLE_HDFS, + PlSqlLexerORACLE_HIVE, + PlSqlLexerORACLE_LOADER, + PlSqlLexerORA_CHECK_ACL, + PlSqlLexerORA_CHECK_PRIVILEGE, + PlSqlLexerORA_CLUSTERING, + PlSqlLexerORA_INVOKING_USER, + PlSqlLexerORA_INVOKING_USERID, + PlSqlLexerORA_INVOKING_XS_USER, + PlSqlLexerORA_INVOKING_XS_USER_GUID, + PlSqlLexerORA_RAWCOMPARE, + PlSqlLexerORA_RAWCONCAT, + PlSqlLexerORA_WRITE_TIME, + PlSqlLexerPARENT_LEVEL_NAME, + PlSqlLexerPARENT_UNIQUE_NAME, + PlSqlLexerPASSWORD_ROLLOVER_TIME, + PlSqlLexerPARTIAL, + PlSqlLexerPARTIAL_JOIN, + PlSqlLexerPARTIAL_ROLLUP_PUSHDOWN, + PlSqlLexerPAST, + PlSqlLexerPATCH, + PlSqlLexerPATH_PREFIX, + PlSqlLexerPATTERN, + PlSqlLexerPER, + PlSqlLexerPERIOD, + PlSqlLexerPERIOD_KEYWORD, + PlSqlLexerPERMUTE, + PlSqlLexerPLUGGABLE, + PlSqlLexerPOOL_16K, + PlSqlLexerPOOL_2K, + PlSqlLexerPOOL_32K, + PlSqlLexerPOOL_4K, + PlSqlLexerPOOL_8K, + PlSqlLexerPQ_CONCURRENT_UNION, + PlSqlLexerPQ_DISTRIBUTE_WINDOW, + PlSqlLexerPQ_FILTER, + PlSqlLexerPQ_REPLICATE, + PlSqlLexerPQ_SKEW, + PlSqlLexerPRELOAD, + PlSqlLexerPRETTY, + PlSqlLexerPREV, + PlSqlLexerPRINTBLOBTOCLOB, + PlSqlLexerPRIORITY, + PlSqlLexerPRIVILEGED, + PlSqlLexerPROPERTY, + PlSqlLexerPROTOCOL, + PlSqlLexerPROXY, + PlSqlLexerPRUNING, + PlSqlLexerPX_FAULT_TOLERANCE, + PlSqlLexerQUARTERS, + PlSqlLexerQUOTAGROUP, + PlSqlLexerREALM, + PlSqlLexerREDEFINE, + PlSqlLexerRELOCATE, + PlSqlLexerREMOTE, + PlSqlLexerRESTART, + PlSqlLexerROLESET, + PlSqlLexerROWID_MAPPING_TABLE, + PlSqlLexerRUNNING, + PlSqlLexerSAVE, + PlSqlLexerSCRUB, + PlSqlLexerSDO_GEOM_MBR, + PlSqlLexerSECONDS, + PlSqlLexerSECRET, + PlSqlLexerSERIAL, + PlSqlLexerSERVICES, + PlSqlLexerSERVICE_NAME_CONVERT, + PlSqlLexerSHARDED, + PlSqlLexerSHARING, + PlSqlLexerSHELFLIFE, + PlSqlLexerSITE, + PlSqlLexerSOURCE_FILE_DIRECTORY, + PlSqlLexerSOURCE_FILE_NAME_CONVERT, + PlSqlLexerSQL_TRANSLATION_PROFILE, + PlSqlLexerSTANDARD, + PlSqlLexerSTANDARD_HASH, + PlSqlLexerSTANDBYS, + PlSqlLexerSTATE, + PlSqlLexerSTATEMENT, + PlSqlLexerSTREAM, + PlSqlLexerSUBSCRIBE, + PlSqlLexerSUBSET, + PlSqlLexerSUCCESS, + PlSqlLexerSYSBACKUP, + PlSqlLexerSYSDG, + PlSqlLexerSYSGUID, + PlSqlLexerSYSKM, + PlSqlLexerSYSOBJ, + PlSqlLexerSYS_CHECK_PRIVILEGE, + PlSqlLexerSYS_GET_COL_ACLIDS, + PlSqlLexerSYS_MKXTI, + PlSqlLexerSYS_OP_CYCLED_SEQ, + PlSqlLexerSYS_OP_HASH, + PlSqlLexerSYS_OP_KEY_VECTOR_CREATE, + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER, + PlSqlLexerSYS_OP_KEY_VECTOR_FILTER_LIST, + PlSqlLexerSYS_OP_KEY_VECTOR_SUCCEEDED, + PlSqlLexerSYS_OP_KEY_VECTOR_USE, + PlSqlLexerSYS_OP_PART_ID, + PlSqlLexerSYS_OP_ZONE_ID, + PlSqlLexerSYS_RAW_TO_XSID, + PlSqlLexerSYS_XSID_TO_RAW, + PlSqlLexerSYS_ZMAP_FILTER, + PlSqlLexerSYS_ZMAP_REFRESH, + PlSqlLexerTAG, + PlSqlLexerTEXT, + PlSqlLexerTIER, + PlSqlLexerTIES, + PlSqlLexerTO_ACLID, + PlSqlLexerTRANSFORM, + PlSqlLexerTRANSLATION, + PlSqlLexerTRUST, + PlSqlLexerUCS2, + PlSqlLexerUNCONDITIONAL, + PlSqlLexerUNITE, + PlSqlLexerUNMATCHED, + PlSqlLexerUNPLUG, + PlSqlLexerUNSUBSCRIBE, + PlSqlLexerUSABLE, + PlSqlLexerUSER_DATA, + PlSqlLexerUSER_TABLESPACES, + PlSqlLexerUSE_CUBE, + PlSqlLexerUSE_HIDDEN_PARTITIONS, + PlSqlLexerUSE_VECTOR_AGGREGATION, + PlSqlLexerUSING_NO_EXPAND, + PlSqlLexerUTF16BE, + PlSqlLexerUTF16LE, + PlSqlLexerUTF32, + PlSqlLexerUTF8, + PlSqlLexerV1, + PlSqlLexerV2, + PlSqlLexerVALIDATE_CONVERSION, + PlSqlLexerVALID_TIME_END, + PlSqlLexerVECTOR_TRANSFORM, + PlSqlLexerVECTOR_TRANSFORM_DIMS, + PlSqlLexerVECTOR_TRANSFORM_FACT, + PlSqlLexerVERIFIER, + PlSqlLexerVIOLATION, + PlSqlLexerVISIBILITY, + PlSqlLexerWEEK, + PlSqlLexerWEEKS, + PlSqlLexerWITH_PLSQL, + PlSqlLexerWRAPPER, + PlSqlLexerXS, + PlSqlLexerYEARS, + PlSqlLexerZONEMAP, + PlSqlLexerDEFAULTIF, + PlSqlLexerLLS, + PlSqlLexerENCLOSED, + PlSqlLexerTERMINATED, + PlSqlLexerOPTIONALLY, + PlSqlLexerLRTRIM, + PlSqlLexerNOTRIM, + PlSqlLexerLDRTRIM, + PlSqlLexerDATE_FORMAT, + PlSqlLexerMASK, + PlSqlLexerTRANSFORMS, + PlSqlLexerLOBFILE, + PlSqlLexerSTARTOF, + PlSqlLexerCHARACTERSET, + PlSqlLexerRECORDS, + PlSqlLexerFIXED, + PlSqlLexerDELIMITED, + PlSqlLexerXMLTAG, + PlSqlLexerPREPROCESSOR, + PlSqlLexerTERRITORY, + PlSqlLexerLITTLE, + PlSqlLexerBIG, + PlSqlLexerENDIAN, + PlSqlLexerBYTEORDERMARK, + PlSqlLexerNOCHECK, + PlSqlLexerSIZES, + PlSqlLexerARE, + PlSqlLexerBYTES, + PlSqlLexerCHARACTERS, + PlSqlLexerREADSIZE, + PlSqlLexerDISABLE_DIRECTORY_LINK_CHECK, + PlSqlLexerDATE_CACHE, + PlSqlLexerFIELD_NAMES, + PlSqlLexerFILES, + PlSqlLexerIO_OPTIONS, + PlSqlLexerDIRECTIO, + PlSqlLexerNODIRECTIO, + PlSqlLexerDNFS_ENABLE, + PlSqlLexerDNFS_DISABLE, + PlSqlLexerDNFS_READBUFFERS, + PlSqlLexerNOBADFILE, + PlSqlLexerBADFILE, + PlSqlLexerNODISCARDFILE, + PlSqlLexerDISCARDFILE, + PlSqlLexerNOLOGFILE, + PlSqlLexerFIELDS, + PlSqlLexerIGNORE_CHARS_AFTER_EOR, + PlSqlLexerCSV, + PlSqlLexerEMBEDDED, + PlSqlLexerOVERRIDE, + PlSqlLexerTHESE, + PlSqlLexerFIELD, + PlSqlLexerNONULLIF, + PlSqlLexerPOSITION, + PlSqlLexerNEWLINE_, + PlSqlLexerDETECTED, + PlSqlLexerUNSIGNED, + PlSqlLexerZONED, + PlSqlLexerORACLE_DATE, + PlSqlLexerORACLE_NUMBER, + PlSqlLexerCOUNTED, + PlSqlLexerVARRAW, + PlSqlLexerVARCHARC, + PlSqlLexerVARRAWC: + return true + case PlSqlLexerABSENT, + PlSqlLexerA_LETTER, + PlSqlLexerAGENT, + PlSqlLexerAGGREGATE, + PlSqlLexerAUTONOMOUS_TRANSACTION, + PlSqlLexerBACKINGFILE, + PlSqlLexerBINARY_INTEGER, + PlSqlLexerBOOLEAN, + PlSqlLexerC_LETTER, + PlSqlLexerCHAR, + PlSqlLexerCLUSTER, + PlSqlLexerCONSTRUCTOR, + PlSqlLexerCUSTOMDATUM, + PlSqlLexerCASESENSITIVE, + PlSqlLexerDECIMAL, + PlSqlLexerDELETE, + PlSqlLexerDETERMINISTIC, + PlSqlLexerDSINTERVAL_UNCONSTRAINED, + PlSqlLexerE_LETTER, + PlSqlLexerERR, + PlSqlLexerEXCEPTION, + PlSqlLexerEXCEPTION_INIT, + PlSqlLexerEXISTS, + PlSqlLexerEXIT, + PlSqlLexerFILESTORE, + PlSqlLexerFLOAT, + PlSqlLexerFORALL, + PlSqlLexerG_LETTER, + PlSqlLexerINDICES, + PlSqlLexerINOUT, + PlSqlLexerINTEGER, + PlSqlLexerJSON_TRANSFORM, + PlSqlLexerK_LETTER, + PlSqlLexerLANGUAGE, + PlSqlLexerLONG, + PlSqlLexerLOOP, + PlSqlLexerMOUNTPOINT, + PlSqlLexerM_LETTER, + PlSqlLexerMISSING, + PlSqlLexerMISMATCH, + PlSqlLexerNUMBER, + PlSqlLexerORADATA, + PlSqlLexerOSERROR, + PlSqlLexerOUT, + PlSqlLexerOVERRIDING, + PlSqlLexerP_LETTER, + PlSqlLexerPARALLEL_ENABLE, + PlSqlLexerPIPELINED, + PlSqlLexerPLS_INTEGER, + PlSqlLexerPMEM, + PlSqlLexerPOSITIVE, + PlSqlLexerPOSITIVEN, + PlSqlLexerPRAGMA, + PlSqlLexerPUBLIC, + PlSqlLexerRAISE, + PlSqlLexerRAW, + PlSqlLexerRECORD, + PlSqlLexerRENAME, + PlSqlLexerRESTRICT_REFERENCES, + PlSqlLexerRESULT, + PlSqlLexerSDO_GEOMETRY, + PlSqlLexerSELF, + PlSqlLexerSERIALLY_REUSABLE, + PlSqlLexerSET, + PlSqlLexerSHARDSPACE, + PlSqlLexerSIGNTYPE, + PlSqlLexerSIMPLE_INTEGER, + PlSqlLexerSMALLINT, + PlSqlLexerSQLDATA, + PlSqlLexerSQLERROR, + PlSqlLexerSUBTYPE, + PlSqlLexerT_LETTER, + PlSqlLexerTIMESTAMP_LTZ_UNCONSTRAINED, + PlSqlLexerTIMESTAMP_TZ_UNCONSTRAINED, + PlSqlLexerTIMESTAMP_UNCONSTRAINED, + PlSqlLexerTRIGGER, + PlSqlLexerVARCHAR, + PlSqlLexerVARCHAR2, + PlSqlLexerVARIABLE, + PlSqlLexerWARNING, + PlSqlLexerWHILE, + PlSqlLexerXMLAGG, + PlSqlLexerYMINTERVAL_UNCONSTRAINED, + PlSqlLexerREGR_, + PlSqlLexerVAR_, + PlSqlLexerCOVAR_: + return true + } + return false +} + +func (l *PlSqlLexerBase) IsReservedKeywords(s string) bool { + l.initReservedMap() + + _, exists := l.reservedMap[strings.ToUpper(s)] + return exists +} + +func (l *PlSqlLexerBase) initReservedMap() { + if l.reservedMap != nil { + return + } + l.reservedMap = make(map[string]bool) + for keyword := range ReservedWords { + l.reservedMap[keyword] = true + } +} diff --git a/plsql/plsql_parser.go b/plsql/plsql_parser.go new file mode 100644 index 0000000..f796508 --- /dev/null +++ b/plsql/plsql_parser.go @@ -0,0 +1,351591 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql // PlSqlParser +import ( + "fmt" + "strconv" + "sync" + + "github.com/antlr4-go/antlr/v4" +) + +// Suppress unused import errors +var _ = fmt.Printf +var _ = strconv.Itoa +var _ = sync.Once{} + +type PlSqlParser struct { + PlSqlParserBase +} + +var PlSqlParserParserStaticData struct { + once sync.Once + serializedATN []int32 + LiteralNames []string + SymbolicNames []string + RuleNames []string + PredictionContextCache *antlr.PredictionContextCache + atn *antlr.ATN + decisionToDFA []*antlr.DFA +} + +func plsqlparserParserInit() { + staticData := &PlSqlParserParserStaticData + staticData.LiteralNames = []string{ + "", "'ABORT'", "'ABS'", "'ABSENT'", "'ACCESS'", "'ACCESSED'", "'ACCOUNT'", + "'ACL'", "'ACOS'", "'ACROSS'", "'ACTION'", "'ACTIONS'", "'ACTIVATE'", + "'ACTIVE'", "'ACTIVE_COMPONENT'", "'ACTIVE_DATA'", "'ACTIVE_FUNCTION'", + "'ACTIVE_TAG'", "'ACTIVITY'", "'ADAPTIVE_PLAN'", "'ADD'", "'ADD_COLUMN'", + "'ADD_GROUP'", "'ADD_MONTHS'", "'ADJ_DATE'", "'ADMIN'", "'ADMINISTER'", + "'ADMINISTRATOR'", "'ADVANCED'", "'ADVISE'", "'ADVISOR'", "'AFD_DISKSTRING'", + "'AFTER'", "'AGENT'", "'AGGREGATE'", "'A'", "'ALIAS'", "'ALL'", "'ALLOCATE'", + "'ALLOW'", "'ALL_ROWS'", "'ALTER'", "'ALTERNATE'", "'ALWAYS'", "'ANALYTIC'", + "'ANALYZE'", "'ANCESTOR'", "'ANCILLARY'", "'AND'", "'AND_EQUAL'", "'ANOMALY'", + "'ANSI_REARCH'", "'ANTIJOIN'", "'ANY'", "'ANYSCHEMA'", "'APPEND'", "'APPENDCHILDXML'", + "'APPEND_VALUES'", "'APPLICATION'", "'APPLY'", "'APPROX_COUNT_DISTINCT'", + "'ARCHIVAL'", "'ARCHIVE'", "'ARCHIVED'", "'ARCHIVELOG'", "'ARRAY'", + "'AS'", "'ASC'", "'ASCII'", "'ASCIISTR'", "'ASIN'", "'ASIS'", "'ASSEMBLY'", + "'ASSIGN'", "'ASSOCIATE'", "'ASYNC'", "'ASYNCHRONOUS'", "'ATAN2'", "'ATAN'", + "'AT'", "'ATTRIBUTE'", "'ATTRIBUTES'", "'AUDIT'", "'AUTHENTICATED'", + "'AUTHENTICATION'", "'AUTHID'", "'AUTHORIZATION'", "'AUTOALLOCATE'", + "'AUTO'", "'AUTOEXTEND'", "'AUTO_LOGIN'", "'AUTOMATIC'", "'AUTONOMOUS_TRANSACTION'", + "'AUTO_REOPTIMIZE'", "'AVAILABILITY'", "'AVRO'", "'BACKGROUND'", "'BACKINGFILE'", + "'BACKUP'", "'BACKUPS'", "'BASIC'", "'BASICFILE'", "'BATCH'", "'BATCHSIZE'", + "'BATCH_TABLE_ACCESS_BY_ROWID'", "'BECOME'", "'BEFORE'", "'BEGIN'", + "'BEGINNING'", "'BEGIN_OUTLINE_DATA'", "'BEHALF'", "'BEQUEATH'", "'BETWEEN'", + "'BFILE'", "'BFILENAME'", "'BIGFILE'", "'BINARY'", "'BINARY_DOUBLE'", + "'BINARY_DOUBLE_INFINITY'", "'BINARY_DOUBLE_NAN'", "'BINARY_FLOAT'", + "'BINARY_FLOAT_INFINITY'", "'BINARY_FLOAT_NAN'", "'BINARY_INTEGER'", + "'BIND_AWARE'", "'BINDING'", "'BIN_TO_NUM'", "'BITAND'", "'BITMAP_AND'", + "'BITMAP'", "'BITMAPS'", "'BITMAP_TREE'", "'BITS'", "'BLOB'", "'BLOCK'", + "'BLOCK_RANGE'", "'BLOCKS'", "'BLOCKSIZE'", "'BODY'", "'BOOLEAN'", "'BOTH'", + "'BOUND'", "'BRANCH'", "'BREADTH'", "'BROADCAST'", "'BSON'", "'BUFFER'", + "'BUFFER_CACHE'", "'BUFFER_POOL'", "'BUILD'", "'BULK'", "'BY'", "'BYPASS_RECURSIVE_CHECK'", + "'BYPASS_UJVC'", "'BYTE'", "'CACHE'", "'CACHE_CB'", "'CACHE_INSTANCES'", + "'CACHE_TEMP_TABLE'", "'CACHING'", "'CALCULATED'", "'CALLBACK'", "'CALL'", + "'CANCEL'", "'CANONICAL'", "'CAPACITY'", "'CAPTION'", "'CARDINALITY'", + "'CASCADE'", "'CASE'", "'CAST'", "'CASE-SENSITIVE'", "'CATEGORY'", "'CDB$DEFAULT'", + "'CEIL'", "'CELL_FLASH_CACHE'", "'CERTIFICATE'", "'CFILE'", "'CHAINED'", + "'CHANGE'", "'CHANGE_DUPKEY_ERROR_INDEX'", "'CHARACTER'", "'CHAR'", + "'CHAR_CS'", "'CHARTOROWID'", "'CHECK_ACL_REWRITE'", "'CHECK'", "'CHECKPOINT'", + "'CHILD'", "'CHOOSE'", "'CHR'", "'CHUNK'", "'CLASS'", "'CLASSIFICATION'", + "'CLASSIFIER'", "'CLAUSE'", "'CLEAN'", "'CLEANUP'", "'CLEAR'", "'C'", + "'CLIENT'", "'CLOB'", "'CLONE'", "'CLOSE_CACHED_OPEN_CURSORS'", "'CLOSE'", + "'CLUSTER_BY_ROWID'", "'CLUSTER'", "'CLUSTER_DETAILS'", "'CLUSTER_DISTANCE'", + "'CLUSTER_ID'", "'CLUSTERING'", "'CLUSTERING_FACTOR'", "'CLUSTER_PROBABILITY'", + "'CLUSTER_SET'", "'COALESCE'", "'COALESCE_SQ'", "'COARSE'", "'CO_AUTH_IND'", + "'COLD'", "'COLLECT'", "'COLUMNAR'", "'COLUMN_AUTH_INDICATOR'", "'COLUMN'", + "'COLUMNS'", "'COLUMN_STATS'", "'COLUMN_VALUE'", "'COMMENT'", "'COMMIT'", + "'COMMITTED'", "'COMMON'", "'COMMON_DATA'", "'COMPACT'", "'COMPATIBILITY'", + "'COMPILE'", "'COMPLETE'", "'COMPLIANCE'", "'COMPONENT'", "'COMPONENTS'", + "'COMPOSE'", "'COMPOSITE'", "'COMPOSITE_LIMIT'", "'COMPOUND'", "'COMPRESS'", + "'COMPUTE'", "'CONCAT'", "'CON_DBID_TO_ID'", "'CONDITIONAL'", "'CONDITION'", + "'CONFIRM'", "'CONFORMING'", "'CON_GUID_TO_ID'", "'CON_ID'", "'CON_NAME_TO_ID'", + "'CONNECT_BY_CB_WHR_ONLY'", "'CONNECT_BY_COMBINE_SW'", "'CONNECT_BY_COST_BASED'", + "'CONNECT_BY_ELIM_DUPS'", "'CONNECT_BY_FILTERING'", "'CONNECT_BY_ISCYCLE'", + "'CONNECT_BY_ISLEAF'", "'CONNECT_BY_ROOT'", "'CONNECT'", "'CONNECT_TIME'", + "'CONSIDER'", "'CONSISTENT'", "'CONSTANT'", "'CONST'", "'CONSTRAINT'", + "'CONSTRAINTS'", "'CONSTRUCTOR'", "'CONTAINER'", "'CONTAINERS'", "'CONTAINERS_DEFAULT'", + "'CONTAINER_DATA'", "'CONTAINER_MAP'", "'CONTENT'", "'CONTENTS'", "'CONTEXT'", + "'CONTINUE'", "'CONTROLFILE'", "'CON_UID_TO_ID'", "'CONVERT'", "'CONVERSION'", + "'COOKIE'", "'COPY'", "'CORR_K'", "'CORR_S'", "'CORRUPTION'", "'CORRUPT_XID_ALL'", + "'CORRUPT_XID'", "'COS'", "'COSH'", "'COST'", "'COST_XML_QUERY_REWRITE'", + "'COUNT'", "'COVAR_POP'", "'COVAR_SAMP'", "'CPU_COSTING'", "'CPU_PER_CALL'", + "'CPU_PER_SESSION'", "'CRASH'", "'CREATE'", "'CREATE_FILE_DEST'", "'CREATE_STORED_OUTLINES'", + "'CREATION'", "'CREDENTIAL'", "'CRITICAL'", "'CROSS'", "'CROSSEDITION'", + "'CSCONVERT'", "'CUBE_AJ'", "'CUBE'", "'CUBE_GB'", "'CUBE_SJ'", "'CUME_DISTM'", + "'CURRENT'", "'CURRENT_DATE'", "'CURRENT_SCHEMA'", "'CURRENT_TIME'", + "'CURRENT_TIMESTAMP'", "'CURRENT_USER'", "'CURRENTV'", "'CURSOR'", "'CURSOR_SHARING_EXACT'", + "'CURSOR_SPECIFIC_SEGMENT'", "'CUSTOMDATUM'", "'CV'", "'CYCLE'", "'DANGLING'", + "'DATABASE'", "'DATA'", "'DATAFILE'", "'DATAFILES'", "'DATAMOVEMENT'", + "'DATAOBJNO'", "'DATAOBJ_TO_MAT_PARTITION'", "'DATAOBJ_TO_PARTITION'", + "'DATAPUMP'", "'DATA_SECURITY_REWRITE_LIMIT'", "'DATE'", "'DATE_MODE'", + "'DAY'", "'DAYS'", "'DBA'", "'DBA_RECYCLEBIN'", "'DBMS_STATS'", "'DB_ROLE_CHANGE'", + "'DBTIMEZONE'", "'DB_UNIQUE_NAME'", "'DB_VERSION'", "'DDL'", "'DEALLOCATE'", + "'DEBUG'", "'DEBUGGER'", "'DEC'", "'DECIMAL'", "'DECLARE'", "'DECOMPOSE'", + "'DECORRELATE'", "'DECR'", "'DECREMENT'", "'DECRYPT'", "'DEDUPLICATE'", + "'DEFAULT'", "'DEFAULTS'", "'DEFAULT_COLLATION'", "'DEFAULT_CREDENTIAL'", + "'DEFERRABLE'", "'DEFERRED'", "'DEFINED'", "'DEFINE'", "'DEFINER'", + "'DEGREE'", "'DELAY'", "'DELEGATE'", "'DELETE_ALL'", "'DELETE'", "'DELETEXML'", + "'DEMAND'", "'DENSE_RANKM'", "'DEPENDENT'", "'DEPTH'", "'DEQUEUE'", + "'DEREF'", "'DEREF_NO_REWRITE'", "'DESC'", "'DESCRIPTION'", "'DESTROY'", + "'DETACHED'", "'DETERMINES'", "'DETERMINISTIC'", "'DICTIONARY'", "'DIMENSION'", + "'DIMENSIONS'", "'DIRECT_LOAD'", "'DIRECTORY'", "'DIRECT_PATH'", "'DISABLE_ALL'", + "'DISABLE'", "'DISABLE_PARALLEL_DML'", "'DISABLE_PRESET'", "'DISABLE_RPKE'", + "'DISALLOW'", "'DISASSOCIATE'", "'DISCARD'", "'DISCONNECT'", "'DISK'", + "'DISKGROUP'", "'DISKS'", "'DISMOUNT'", "'DISTINCT'", "'DISTINGUISHED'", + "'DISTRIBUTED'", "'DISTRIBUTE'", "'DML'", "'DML_UPDATE'", "'DOCFIDELITY'", + "'DOCUMENT'", "'DOMAIN_INDEX_FILTER'", "'DOMAIN_INDEX_NO_SORT'", "'DOMAIN_INDEX_SORT'", + "'DOUBLE'", "'DOWNGRADE'", "'DRIVING_SITE'", "'DROP_COLUMN'", "'DROP'", + "'DROP_GROUP'", "'DSINTERVAL_UNCONSTRAINED'", "'DST_UPGRADE_INSERT_CONV'", + "'DUMP'", "'DUPLICATE'", "'DV'", "'DYNAMIC'", "'DYNAMIC_SAMPLING'", + "'DYNAMIC_SAMPLING_EST_CDN'", "'E'", "'EACH'", "'EDITIONABLE'", "'EDITION'", + "'EDITIONING'", "'EDITIONS'", "'ELEMENT'", "'ELIM_GROUPBY'", "'ELIMINATE_JOIN'", + "'ELIMINATE_OBY'", "'ELIMINATE_OUTER_JOIN'", "'ELSE'", "'ELSIF'", "'EM'", + "'EMPTY_BLOB'", "'EMPTY_CLOB'", "'EMPTY'", "'ENABLE_ALL'", "'ENABLE'", + "'ENABLE_PARALLEL_DML'", "'ENABLE_PRESET'", "'ENCODING'", "'ENCRYPT'", + "'ENCRYPTION'", "'END'", "'END_OUTLINE_DATA'", "'ENFORCED'", "'ENFORCE'", + "'ENQUEUE'", "'ENTERPRISE'", "'ENTITYESCAPING'", "'ENTRY'", "'EQUIPART'", + "'ERR'", "'ERROR_ARGUMENT'", "'ERROR'", "'ERROR_ON_OVERLAP_TIME'", "'ERRORS'", + "'ESCAPE'", "'ESTIMATE'", "'EVAL'", "'EVALNAME'", "'EVALUATE'", "'EVALUATION'", + "'EVENTS'", "'EVERY'", "'EXCEPT'", "'EXCEPTION'", "'EXCEPTION_INIT'", + "'EXCEPTIONS'", "'EXCHANGE'", "'EXCLUDE'", "'EXCLUDING'", "'EXCLUSIVE'", + "'EXECUTE'", "'EXEMPT'", "'EXISTING'", "'EXISTS'", "'EXISTSNODE'", "'EXIT'", + "'EXPAND_GSET_TO_UNION'", "'EXPAND_TABLE'", "'EXP'", "'EXPIRE'", "'EXPLAIN'", + "'EXPLOSION'", "'EXPORT'", "'EXPR_CORR_CHECK'", "'EXPRESS'", "'EXTENDS'", + "'EXTENT'", "'EXTENTS'", "'EXTERNAL'", "'EXTERNALLY'", "'EXTRACTCLOBXML'", + "'EXTRACT'", "'EXTRACTVALUE'", "'EXTRA'", "'FACILITY'", "'FACT'", "'FACTOR'", + "'FACTORIZE_JOIN'", "'FAILED'", "'FAILED_LOGIN_ATTEMPTS'", "'FAILGROUP'", + "'FAILOVER'", "'FAILURE'", "'FALSE'", "'FAMILY'", "'FAR'", "'FAST'", + "'FASTSTART'", "'FBTSCAN'", "'FEATURE'", "'FEATURE_DETAILS'", "'FEATURE_ID'", + "'FEATURE_SET'", "'FEATURE_VALUE'", "'FETCH'", "'FILE'", "'FILE_NAME_CONVERT'", + "'FILEGROUP'", "'FILESTORE'", "'FILESYSTEM_LIKE_LOGGING'", "'FILTER'", + "'FINAL'", "'FINE'", "'FINISH'", "'FIRST'", "'FIRSTM'", "'FIRST_ROWS'", + "'FIRST_VALUE'", "'FIXED_VIEW_DATA'", "'FLAGGER'", "'FLASHBACK'", "'FLASH_CACHE'", + "'FLOAT'", "'FLOB'", "'FLEX'", "'FLOOR'", "'FLUSH'", "'FOLDER'", "'FOLLOWING'", + "'FOLLOWS'", "'FORALL'", "'FORCE'", "'FORCE_XML_QUERY_REWRITE'", "'FOREIGN'", + "'FOREVER'", "'FOR'", "'FORMAT'", "'FORWARD'", "'FRAGMENT_NUMBER'", + "'FREELIST'", "'FREELISTS'", "'FREEPOOLS'", "'FRESH'", "'FROM'", "'FROM_TZ'", + "'FULL'", "'FULL_OUTER_JOIN_TO_OUTER'", "'FUNCTION'", "'FUNCTIONS'", + "'FTP'", "'G'", "'GATHER_OPTIMIZER_STATISTICS'", "'GATHER_PLAN_STATISTICS'", + "'GBY_CONC_ROLLUP'", "'GBY_PUSHDOWN'", "'GENERATED'", "'GET'", "'GLOBAL'", + "'GLOBALLY'", "'GLOBAL_NAME'", "'GLOBAL_TOPIC_ENABLED'", "'GOTO'", "'GRANT'", + "'GROUP_BY'", "'GROUP'", "'GROUP_ID'", "'GROUPING'", "'GROUPING_ID'", + "'GROUPS'", "'GUARANTEED'", "'GUARANTEE'", "'GUARD'", "'HALF_YEARS'", + "'HASH_AJ'", "'HASH'", "'HASHKEYS'", "'HASH_SJ'", "'HAVING'", "'HEADER'", + "'HEAP'", "'HELP'", "'HEXTORAW'", "'HEXTOREF'", "'HIDDEN'", "'HIDE'", + "'HIER_ORDER'", "'HIERARCHICAL'", "'HIERARCHIES'", "'HIERARCHY'", "'HIGH'", + "'HINTSET_BEGIN'", "'HINTSET_END'", "'HOT'", "'HOUR'", "'HOURS'", "'HTTP'", + "'HWM_BROKERED'", "'HYBRID'", "'H'", "'IDENTIFIED'", "'IDENTIFIER'", + "'IDENTITY'", "'IDGENERATORS'", "'ID'", "'IDLE_TIME'", "'IF'", "'IGNORE'", + "'IGNORE_OPTIM_EMBEDDED_HINTS'", "'IGNORE_ROW_ON_DUPKEY_INDEX'", "'IGNORE_WHERE_CLAUSE'", + "'ILM'", "'IMMEDIATE'", "'IMPACT'", "'IMPORT'", "'INACTIVE'", "'INACTIVE_ACCOUNT_TIME'", + "'INCLUDE'", "'INCLUDE_VERSION'", "'INCLUDING'", "'INCREMENTAL'", "'INCREMENT'", + "'INCR'", "'INDENT'", "'INDEX_ASC'", "'INDEX_COMBINE'", "'INDEX_DESC'", + "'INDEXED'", "'INDEXES'", "'INDEX_FFS'", "'INDEX_FILTER'", "'INDEX'", + "'INDEXING'", "'INDEX_JOIN'", "'INDEX_ROWS'", "'INDEX_RRS'", "'INDEX_RS_ASC'", + "'INDEX_RS_DESC'", "'INDEX_RS'", "'INDEX_SCAN'", "'INDEX_SKIP_SCAN'", + "'INDEX_SS_ASC'", "'INDEX_SS_DESC'", "'INDEX_SS'", "'INDEX_STATS'", + "'INDEXTYPE'", "'INDEXTYPES'", "'INDICATOR'", "'INDICES'", "'INFINITE'", + "'INFORMATIONAL'", "'INHERIT'", "'IN'", "'INITCAP'", "'INITIAL'", "'INITIALIZED'", + "'INITIALLY'", "'INITRANS'", "'INLINE'", "'INLINE_XMLTYPE_NT'", "'INMEMORY'", + "'IN_MEMORY_METADATA'", "'INMEMORY_PRUNING'", "'INNER'", "'INOUT'", + "'INPLACE'", "'INSERTCHILDXMLAFTER'", "'INSERTCHILDXMLBEFORE'", "'INSERTCHILDXML'", + "'INSERT'", "'INSERTXMLAFTER'", "'INSERTXMLBEFORE'", "'INSTANCE'", "'INSTANCES'", + "'INSTANTIABLE'", "'INSTANTLY'", "'INSTEAD'", "'INSTR2'", "'INSTR4'", + "'INSTRB'", "'INSTRC'", "'INSTR'", "'INTEGER'", "'INTERLEAVED'", "'INTERMEDIATE'", + "'INTERNAL_CONVERT'", "'INTERNAL_USE'", "'INTERPRETED'", "'INTERSECT'", + "'INTERVAL'", "'INT'", "'INTO'", "'INVALIDATE'", "'INVISIBLE'", "'IN_XQUERY'", + "'IS'", "'IS_LEAF'", "'ISOLATION'", "'ISOLATION_LEVEL'", "'ITERATE'", + "'ITERATION_NUMBER'", "'JAVA'", "'JOB'", "'JOIN'", "'JSON_ARRAYAGG'", + "'JSON_ARRAY'", "'JSON_EQUAL'", "'JSON_EXISTS2'", "'JSON_EXISTS'", "'JSONGET'", + "'JSON'", "'JSON_OBJECTAGG'", "'JSON_OBJECT'", "'JSONPARSE'", "'JSON_QUERY'", + "'JSON_SERIALIZE'", "'JSON_TABLE'", "'JSON_TEXTCONTAINS2'", "'JSON_TEXTCONTAINS'", + "'JSON_TRANSFORM'", "'JSON_VALUE'", "'K'", "'KEEP_DUPLICATES'", "'KEEP'", + "'KERBEROS'", "'KEY'", "'KEY_LENGTH'", "'KEYSIZE'", "'KEYS'", "'KEYSTORE'", + "'KILL'", "'LABEL'", "'LANGUAGE'", "'LAST_DAY'", "'LAST'", "'LAST_VALUE'", + "'LATERAL'", "'LAX'", "'LAYER'", "'LDAP_REGISTRATION_ENABLED'", "'LDAP_REGISTRATION'", + "'LDAP_REG_SYNC_INTERVAL'", "'LEAF'", "'LEAD_CDB'", "'LEAD_CDB_URI'", + "'LEADING'", "'LEFT'", "'LENGTH2'", "'LENGTH4'", "'LENGTHB'", "'LENGTHC'", + "'LENGTH'", "'LESS'", "'LEVEL'", "'LEVEL_NAME'", "'LEVELS'", "'LIBRARY'", + "'LIFECYCLE'", "'LIFE'", "'LIFETIME'", "'LIKE2'", "'LIKE4'", "'LIKEC'", + "'LIKE_EXPAND'", "'LIKE'", "'LIMIT'", "'LINEAR'", "'LINK'", "'LIST'", + "'LN'", "'LNNVL'", "'LOAD'", "'LOB'", "'LOBNVL'", "'LOBS'", "'LOCAL_INDEXES'", + "'LOCAL'", "'LOCALTIME'", "'LOCALTIMESTAMP'", "'LOCATION'", "'LOCATOR'", + "'LOCKDOWN'", "'LOCKED'", "'LOCKING'", "'LOCK'", "'LOGFILE'", "'LOGFILES'", + "'LOGGING'", "'LOGICAL'", "'LOGICAL_READS_PER_CALL'", "'LOGICAL_READS_PER_SESSION'", + "'LOG'", "'LOGMINING'", "'LOGOFF'", "'LOGON'", "'LOG_READ_ONLY_VIOLATIONS'", + "'LONG'", "'LOOP'", "'LOST'", "'LOWER'", "'LOW'", "'LPAD'", "'LTRIM'", + "'M'", "'MAIN'", "'MAKE_REF'", "'MANAGED'", "'MANAGE'", "'MANAGEMENT'", + "'MANAGER'", "'MANDATORY'", "'MANUAL'", "'MAP'", "'MAPPING'", "'MASTER'", + "'MATCHED'", "'MATCHES'", "'MATCH'", "'MATCH_NUMBER'", "'MATCH_RECOGNIZE'", + "'MATERIALIZED'", "'MATERIALIZE'", "'MAXARCHLOGS'", "'MAXDATAFILES'", + "'MAXEXTENTS'", "'MAXIMIZE'", "'MAXINSTANCES'", "'MAXLOGFILES'", "'MAXLOGHISTORY'", + "'MAXLOGMEMBERS'", "'MAX_SHARED_TEMP_SIZE'", "'MAXSIZE'", "'MAXTRANS'", + "'MAXVALUE'", "'MEASURE'", "'MEASURES'", "'MEDIUM'", "'MEMBER'", "'MEMBER_CAPTION'", + "'MEMBER_DESCRIPTION'", "'MEMBER_NAME'", "'MEMBER_UNIQUE_NAME'", "'MEMCOMPRESS'", + "'MEMORY'", "'MERGE$ACTIONS'", "'MERGE_AJ'", "'MERGE_CONST_ON'", "'MERGE'", + "'MERGE_SJ'", "'METADATA'", "'METHOD'", "'MIGRATE'", "'MIGRATION'", + "'MINEXTENTS'", "'MINIMIZE'", "'MINIMUM'", "'MINING'", "'MINUS'", "'MINUS_NULL'", + "'MINUTE'", "'MINUTES'", "'MINVALUE'", "'MIRRORCOLD'", "'MIRRORHOT'", + "'MIRROR'", "'MISSING'", "'MISMATCH'", "'MLSLABEL'", "'MODEL_COMPILE_SUBQUERY'", + "'MODEL_DONTVERIFY_UNIQUENESS'", "'MODEL_DYNAMIC_SUBQUERY'", "'MODEL_MIN_ANALYSIS'", + "'MODEL'", "'MODEL_NB'", "'MODEL_NO_ANALYSIS'", "'MODEL_PBY'", "'MODEL_PUSH_REF'", + "'MODEL_SV'", "'MODE'", "'MODIFICATION'", "'MODIFY_COLUMN_TYPE'", "'MODIFY'", + "'MOD'", "'MODULE'", "'MONITORING'", "'MONITOR'", "'MONTH'", "'MONTHS_BETWEEN'", + "'MONTHS'", "'MOUNT'", "'MOUNTPATH'", "'MOUNTPOINT'", "'MOVEMENT'", + "'MOVE'", "'MULTIDIMENSIONAL'", "'MULTISET'", "'MV_MERGE'", "'NAMED'", + "'NAME'", "'NAMESPACE'", "'NAN'", "'NANVL'", "'NATIONAL'", "'NATIVE_FULL_OUTER_JOIN'", + "'NATIVE'", "'NATURAL'", "'NATURALN'", "'NAV'", "'NCHAR_CS'", "'NCHAR'", + "'NCHR'", "'NCLOB'", "'NEEDED'", "'NEG'", "'NESTED'", "'NESTED_TABLE_FAST_INSERT'", + "'NESTED_TABLE_GET_REFS'", "'NESTED_TABLE_ID'", "'NESTED_TABLE_SET_REFS'", + "'NESTED_TABLE_SET_SETID'", "'NETWORK'", "'NEVER'", "'NEW'", "'NEW_TIME'", + "'NEXT_DAY'", "'NEXT'", "'NL_AJ'", "'NLJ_BATCHING'", "'NLJ_INDEX_FILTER'", + "'NLJ_INDEX_SCAN'", "'NLJ_PREFETCH'", "'NLS_CALENDAR'", "'NLS_CHARACTERSET'", + "'NLS_CHARSET_DECL_LEN'", "'NLS_CHARSET_ID'", "'NLS_CHARSET_NAME'", + "'NLS_COMP'", "'NLS_CURRENCY'", "'NLS_DATE_FORMAT'", "'NLS_DATE_LANGUAGE'", + "'NLS_INITCAP'", "'NLS_ISO_CURRENCY'", "'NL_SJ'", "'NLS_LANG'", "'NLS_LANGUAGE'", + "'NLS_LENGTH_SEMANTICS'", "'NLS_LOWER'", "'NLS_NCHAR_CONV_EXCP'", "'NLS_NUMERIC_CHARACTERS'", + "'NLS_SORT'", "'NLSSORT'", "'NLS_SPECIAL_CHARS'", "'NLS_TERRITORY'", + "'NLS_UPPER'", "'NO_ACCESS'", "'NO_ADAPTIVE_PLAN'", "'NO_ANSI_REARCH'", + "'NOAPPEND'", "'NOARCHIVELOG'", "'NOAUDIT'", "'NO_AUTO_REOPTIMIZE'", + "'NO_BASETABLE_MULTIMV_REWRITE'", "'NO_BATCH_TABLE_ACCESS_BY_ROWID'", + "'NO_BIND_AWARE'", "'NO_BUFFER'", "'NOCACHE'", "'NO_CARTESIAN'", "'NO_CHECK_ACL_REWRITE'", + "'NO_CLUSTER_BY_ROWID'", "'NO_CLUSTERING'", "'NO_COALESCE_SQ'", "'NO_COMMON_DATA'", + "'NOCOMPRESS'", "'NO_CONNECT_BY_CB_WHR_ONLY'", "'NO_CONNECT_BY_COMBINE_SW'", + "'NO_CONNECT_BY_COST_BASED'", "'NO_CONNECT_BY_ELIM_DUPS'", "'NO_CONNECT_BY_FILTERING'", + "'NOCOPY'", "'NO_COST_XML_QUERY_REWRITE'", "'NO_CPU_COSTING'", "'NOCPU_COSTING'", + "'NOCYCLE'", "'NO_DATA_SECURITY_REWRITE'", "'NO_DECORRELATE'", "'NODELAY'", + "'NO_DOMAIN_INDEX_FILTER'", "'NO_DST_UPGRADE_INSERT_CONV'", "'NO_ELIM_GROUPBY'", + "'NO_ELIMINATE_JOIN'", "'NO_ELIMINATE_OBY'", "'NO_ELIMINATE_OUTER_JOIN'", + "'NOENTITYESCAPING'", "'NO_EXPAND_GSET_TO_UNION'", "'NO_EXPAND'", "'NO_EXPAND_TABLE'", + "'NO_FACT'", "'NO_FACTORIZE_JOIN'", "'NO_FILTERING'", "'NOFORCE'", "'NO_FULL_OUTER_JOIN_TO_OUTER'", + "'NO_GATHER_OPTIMIZER_STATISTICS'", "'NO_GBY_PUSHDOWN'", "'NOGUARANTEE'", + "'NO_INDEX_FFS'", "'NO_INDEX'", "'NO_INDEX_SS'", "'NO_INMEMORY'", "'NO_INMEMORY_PRUNING'", + "'NOKEEP'", "'NO_LOAD'", "'NOLOCAL'", "'NOLOGGING'", "'NOMAPPING'", + "'NOMAXVALUE'", "'NO_MERGE'", "'NOMINIMIZE'", "'NOMINVALUE'", "'NO_MODEL_PUSH_REF'", + "'NO_MONITORING'", "'NOMONITORING'", "'NO_MONITOR'", "'NO_MULTIMV_REWRITE'", + "'NO_NATIVE_FULL_OUTER_JOIN'", "'NONBLOCKING'", "'NONEDITIONABLE'", + "'NONE'", "'NO_NLJ_BATCHING'", "'NO_NLJ_PREFETCH'", "'NO'", "'NONSCHEMA'", + "'NO_OBJECT_LINK'", "'NOORDER'", "'NO_ORDER_ROLLUPS'", "'NO_OUTER_JOIN_TO_ANTI'", + "'NO_OUTER_JOIN_TO_INNER'", "'NOOVERRIDE'", "'NO_PARALLEL_INDEX'", "'NOPARALLEL_INDEX'", + "'NO_PARALLEL'", "'NOPARALLEL'", "'NO_PARTIAL_COMMIT'", "'NO_PARTIAL_JOIN'", + "'NO_PARTIAL_ROLLUP_PUSHDOWN'", "'NOPARTITION'", "'NO_PLACE_DISTINCT'", + "'NO_PLACE_GROUP_BY'", "'NO_PQ_CONCURRENT_UNION'", "'NO_PQ_MAP'", "'NOPROMPT'", + "'NO_PQ_REPLICATE'", "'NO_PQ_SKEW'", "'NO_PRUNE_GSETS'", "'NO_PULL_PRED'", + "'NO_PUSH_PRED'", "'NO_PUSH_SUBQ'", "'NO_PX_FAULT_TOLERANCE'", "'NO_PX_JOIN_FILTER'", + "'NO_QKN_BUFF'", "'NO_QUERY_TRANSFORMATION'", "'NO_REF_CASCADE'", "'NORELOCATE'", + "'NORELY'", "'NOREPAIR'", "'NOREPLAY'", "'NORESETLOGS'", "'NO_RESULT_CACHE'", + "'NOREVERSE'", "'NO_REWRITE'", "'NOREWRITE'", "'NORMAL'", "'NO_ROOT_SW_FOR_LOCAL'", + "'NOROWDEPENDENCIES'", "'NOSCHEMACHECK'", "'NOSEGMENT'", "'NO_SEMIJOIN'", + "'NO_SEMI_TO_INNER'", "'NO_SET_TO_JOIN'", "'NOSORT'", "'NO_SQL_TRANSLATION'", + "'NO_SQL_TUNE'", "'NO_STAR_TRANSFORMATION'", "'NO_STATEMENT_QUEUING'", + "'NO_STATS_GSETS'", "'NOSTRICT'", "'NO_SUBQUERY_PRUNING'", "'NO_SUBSTRB_PAD'", + "'NO_SWAP_JOIN_INPUTS'", "'NOSWITCH'", "'NO_TABLE_LOOKUP_BY_NL'", "'NO_TEMP_TABLE'", + "'NOTHING'", "'NOTIFICATION'", "'NOT'", "'NO_TRANSFORM_DISTINCT_AGG'", + "'NO_UNNEST'", "'NO_USE_CUBE'", "'NO_USE_HASH_AGGREGATION'", "'NO_USE_HASH_GBY_FOR_PUSHDOWN'", + "'NO_USE_HASH'", "'NO_USE_INVISIBLE_INDEXES'", "'NO_USE_MERGE'", "'NO_USE_NL'", + "'NO_USE_VECTOR_AGGREGATION'", "'NOVALIDATE'", "'NO_VECTOR_TRANSFORM_DIMS'", + "'NO_VECTOR_TRANSFORM_FACT'", "'NO_VECTOR_TRANSFORM'", "'NOWAIT'", "'NO_XDB_FASTPATH_INSERT'", + "'NO_XML_DML_REWRITE'", "'NO_XMLINDEX_REWRITE_IN_SELECT'", "'NO_XMLINDEX_REWRITE'", + "'NO_XML_QUERY_REWRITE'", "'NO_ZONEMAP'", "'NTH_VALUE'", "'NULLIF'", + "'NULL'", "'NULLS'", "'NUMBER'", "'NUMERIC'", "'NUM_INDEX_KEYS'", "'NUMTODSINTERVAL'", + "'NUMTOYMINTERVAL'", "'NVARCHAR2'", "'NVL2'", "'OBJECT2XML'", "'OBJECT'", + "'OBJ_ID'", "'OBJNO'", "'OBJNO_REUSE'", "'OCCURENCES'", "'OFFLINE'", + "'OFF'", "'OFFSET'", "'OF'", "'OIDINDEX'", "'OID'", "'OLAP'", "'OLD'", + "'OLD_PUSH_PRED'", "'OLS'", "'OLTP'", "'OMIT'", "'ONE'", "'ONLINE'", + "'ONLY'", "'ON'", "'OPAQUE'", "'OPAQUE_TRANSFORM'", "'OPAQUE_XCANONICAL'", + "'OPCODE'", "'OPEN'", "'OPERATIONS'", "'OPERATOR'", "'OPT_ESTIMATE'", + "'OPTIMAL'", "'OPTIMIZE'", "'OPTIMIZER_FEATURES_ENABLE'", "'OPTIMIZER_GOAL'", + "'OPTION'", "'OPT_PARAM'", "'ORA_BRANCH'", "'ORA_CHECK_ACL'", "'ORA_CHECK_PRIVILEGE'", + "'ORA_CLUSTERING'", "'ORADATA'", "'ORADEBUG'", "'ORA_DST_AFFECTED'", + "'ORA_DST_CONVERT'", "'ORA_DST_ERROR'", "'ORA_GET_ACLIDS'", "'ORA_GET_PRIVILEGES'", + "'ORA_HASH'", "'ORA_INVOKING_USERID'", "'ORA_INVOKING_USER'", "'ORA_INVOKING_XS_USER_GUID'", + "'ORA_INVOKING_XS_USER'", "'ORA_RAWCOMPARE'", "'ORA_RAWCONCAT'", "'ORA_ROWSCN'", + "'ORA_ROWSCN_RAW'", "'ORA_ROWVERSION'", "'ORA_TABVERSION'", "'ORA_WRITE_TIME'", + "'ORDERED'", "'ORDERED_PREDICATES'", "'ORDER'", "'ORDINALITY'", "'OR_EXPAND'", + "'ORGANIZATION'", "'OR'", "'OR_PREDICATES'", "'OSERROR'", "'OTHER'", + "'OUTER_JOIN_TO_ANTI'", "'OUTER_JOIN_TO_INNER'", "'OUTER'", "'OUTLINE_LEAF'", + "'OUTLINE'", "'OUT_OF_LINE'", "'OUT'", "'OVERFLOW_NOMOVE'", "'OVERFLOW'", + "'OVERLAPS'", "'OVER'", "'OVERRIDING'", "'OWNER'", "'OWNERSHIP'", "'OWN'", + "'P'", "'PACKAGE'", "'PACKAGES'", "'PARALLEL_ENABLE'", "'PARALLEL_INDEX'", + "'PARALLEL'", "'PARAMETERS'", "'PARAM'", "'PARENT'", "'PARENT_LEVEL_NAME'", + "'PARENT_UNIQUE_NAME'", "'PARITY'", "'PARTIAL_JOIN'", "'PARTIALLY'", + "'PARTIAL'", "'PARTIAL_ROLLUP_PUSHDOWN'", "'PARTITION_HASH'", "'PARTITION_LIST'", + "'PARTITION'", "'PARTITION_RANGE'", "'PARTITIONS'", "'PART$NUM$INST'", + "'PASSING'", "'PASSWORD_GRACE_TIME'", "'PASSWORD_LIFE_TIME'", "'PASSWORD_LOCK_TIME'", + "'PASSWORD'", "'PASSWORD_REUSE_MAX'", "'PASSWORD_REUSE_TIME'", "'PASSWORD_ROLLOVER_TIME'", + "'PASSWORD_VERIFY_FUNCTION'", "'PAST'", "'PATCH'", "'PATH'", "'PATH_PREFIX'", + "'PATHS'", "'PATTERN'", "'PBL_HS_BEGIN'", "'PBL_HS_END'", "'PCTFREE'", + "'PCTINCREASE'", "'PCTTHRESHOLD'", "'PCTUSED'", "'PCTVERSION'", "'PENDING'", + "", "", "", "'PERCENT'", "'PERCENT_RANKM'", "", "", "", "'PERFORMANCE'", + "'PERIOD'", "'PERMANENT'", "'PERMISSION'", "'PERMUTE'", "'PER'", "'PFILE'", + "'PHYSICAL'", "'PIKEY'", "'PIPELINED'", "'PIPE'", "'PIV_GB'", "'PIVOT'", + "'PIV_SSF'", "'PLACE_DISTINCT'", "'PLACE_GROUP_BY'", "'PLAN'", "'PLSCOPE_SETTINGS'", + "'PLS_INTEGER'", "'PLSQL_CCFLAGS'", "'PLSQL_CODE_TYPE'", "'PLSQL_DEBUG'", + "'PLSQL_OPTIMIZE_LEVEL'", "'PLSQL_WARNINGS'", "'PLUGGABLE'", "'PMEM'", + "'POINT'", "'POLICY'", "'POOL_16K'", "'POOL_2K'", "'POOL_32K'", "'POOL_4K'", + "'POOL_8K'", "'POSITIVEN'", "'POSITIVE'", "'POST_TRANSACTION'", "'POWERMULTISET_BY_CARDINALITY'", + "'POWERMULTISET'", "'POWER'", "'PQ_CONCURRENT_UNION'", "'PQ_DISTRIBUTE'", + "'PQ_DISTRIBUTE_WINDOW'", "'PQ_FILTER'", "'PQ_MAP'", "'PQ_NOMAP'", "'PQ_REPLICATE'", + "'PQ_SKEW'", "'PRAGMA'", "'PREBUILT'", "'PRECEDES'", "'PRECEDING'", + "'PRECISION'", "'PRECOMPUTE_SUBQUERY'", "'PREDICATE_REORDERS'", "'PRELOAD'", + "'PREPARE'", "'PRESENTNNV'", "'PRESENT'", "'PRESENTV'", "'PRESERVE_OID'", + "'PRESERVE'", "'PRETTY'", "'PREVIOUS'", "'PREV'", "'PRIMARY'", "'PRINTBLOBTOCLOB'", + "'PRIORITY'", "'PRIOR'", "'PRIVATE'", "'PRIVATE_SGA'", "'PRIVILEGED'", + "'PRIVILEGE'", "'PRIVILEGES'", "'PROCEDURAL'", "'PROCEDURE'", "'PROCESS'", + "'PROFILE'", "'PROGRAM'", "'PROJECT'", "'PROPAGATE'", "'PROPERTY'", + "'PROTECTED'", "'PROTECTION'", "'PROTOCOL'", "'PROXY'", "'PRUNING'", + "'PUBLIC'", "'PULL_PRED'", "'PURGE'", "'PUSH_PRED'", "'PUSH_SUBQ'", + "'PX_FAULT_TOLERANCE'", "'PX_GRANULE'", "'PX_JOIN_FILTER'", "'QB_NAME'", + "'QUARTERS'", "'QUERY_BLOCK'", "'QUERY'", "'QUEUE_CURR'", "'QUEUE'", + "'QUEUE_ROWP'", "'QUIESCE'", "'QUORUM'", "'QUOTA'", "'QUOTAGROUP'", + "'RAISE'", "'RANDOM_LOCAL'", "'RANDOM'", "'RANGE'", "'RANKM'", "'RAPIDLY'", + "'RAW'", "'RAWTOHEX'", "'RAWTONHEX'", "'RBA'", "'RBO_OUTLINE'", "'RDBA'", + "'READ'", "'READS'", "'REALM'", "'REAL'", "'REBALANCE'", "'REBUILD'", + "'RECORD'", "'RECORDS_PER_BLOCK'", "'RECOVERABLE'", "'RECOVER'", "'RECOVERY'", + "'RECYCLEBIN'", "'RECYCLE'", "'REDACTION'", "'REDEFINE'", "'REDO'", + "'REDUCED'", "'REDUNDANCY'", "'REF_CASCADE_CURSOR'", "'REFERENCED'", + "'REFERENCE'", "'REFERENCES'", "'REFERENCING'", "'REF'", "'REFRESH'", + "'REFTOHEX'", "'REGEXP_COUNT'", "'REGEXP_INSTR'", "'REGEXP_LIKE'", "'REGEXP_REPLACE'", + "'REGEXP_SUBSTR'", "'REGISTER'", "'REGR_AVGX'", "'REGR_AVGY'", "'REGR_COUNT'", + "'REGR_INTERCEPT'", "'REGR_R2'", "'REGR_SLOPE'", "'REGR_SXX'", "'REGR_SXY'", + "'REGR_SYY'", "'REGULAR'", "'REJECT'", "'REKEY'", "'RELATIONAL'", "'RELIES_ON'", + "'RELOCATE'", "'RELY'", "'REMAINDER'", "'REMOTE'", "'REMOTE_MAPPED'", + "'REMOVE'", "'RENAME'", "'REPAIR'", "'REPEAT'", "'REPLACE'", "'REPLICATION'", + "'REQUIRED'", "'RESETLOGS'", "'RESET'", "'RESIZE'", "'RESOLVE'", "'RESOLVER'", + "'RESOURCE'", "'RESPECT'", "'RESTART'", "'RESTORE_AS_INTERVALS'", "'RESTORE'", + "'RESTRICT_ALL_REF_CONS'", "'RESTRICTED'", "'RESTRICT_REFERENCES'", + "'RESTRICT'", "'RESULT_CACHE'", "'RESULT'", "'RESUMABLE'", "'RESUME'", + "'RETENTION'", "'RETRY_ON_ROW_CHANGE'", "'RETURNING'", "'RETURN'", "'REUSE'", + "'REVERSE'", "'REVOKE'", "'REWRITE_OR_ERROR'", "'REWRITE'", "'RIGHT'", + "'ROLE'", "'ROLESET'", "'ROLES'", "'ROLLBACK'", "'ROLLING'", "'ROLLUP'", + "'ROWDEPENDENCIES'", "'ROWID_MAPPING_TABLE'", "'ROWID'", "'ROWIDTOCHAR'", + "'ROWIDTONCHAR'", "'ROW_LENGTH'", "'ROWNUM'", "'ROW'", "'ROWS'", "'RPAD'", + "'RTRIM'", "'RULE'", "'RULES'", "'RUNNING'", "'SALT'", "'SAMPLE'", "'SAVE_AS_INTERVALS'", + "'SAVEPOINT'", "'SAVE'", "'SB4'", "'SCALE_ROWS'", "'SCALE'", "'SCAN_INSTANCES'", + "'SCAN'", "'SCHEDULER'", "'SCHEMACHECK'", "'SCHEMA'", "'SCN_ASCENDING'", + "'SCN'", "'SCOPE'", "'SCRUB'", "'SD_ALL'", "'SD_INHIBIT'", "'SDO_GEOM_MBR'", + "'SDO_GEOMETRY'", "'SD_SHOW'", "'SEARCH'", "'SECOND'", "'SECONDS'", + "'SECRET'", "'SECUREFILE_DBA'", "'SECUREFILE'", "'SECURITY'", "'SEED'", + "'SEG_BLOCK'", "'SEG_FILE'", "'SEGMENT'", "'SELECTIVITY'", "'SELECT'", + "'SELF'", "'SEMIJOIN_DRIVER'", "'SEMIJOIN'", "'SEMI_TO_INNER'", "'SEQUENCED'", + "'SEQUENCE'", "'SEQUENTIAL'", "'SERIALIZABLE'", "'SERIALLY_REUSABLE'", + "'SERIAL'", "'SERVERERROR'", "'SERVICE_NAME_CONVERT'", "'SERVICE'", + "'SERVICES'", "'SESSION_CACHED_CURSORS'", "'SESSION'", "'SESSIONS_PER_USER'", + "'SESSIONTIMEZONE'", "'SESSIONTZNAME'", "'SET'", "'SETS'", "'SETTINGS'", + "'SET_TO_JOIN'", "'SEVERE'", "'SHARDSPACE'", "'SHARED_POOL'", "'SHARED'", + "'SHARE'", "'SHARING'", "'SHELFLIFE'", "'SHOW'", "'SHRINK'", "'SHUTDOWN'", + "'SIBLINGS'", "'SID'", "'SITE'", "'SIGNAL_COMPONENT'", "'SIGNAL_FUNCTION'", + "'SIGN'", "'SIGNTYPE'", "'SIMPLE_INTEGER'", "'SIMPLE'", "'SINGLE'", + "'SINGLETASK'", "'SINH'", "'SIN'", "'SIZE'", "'SKIP_EXT_OPTIMIZER'", + "'SKIP'", "'SKIP_UNQ_UNUSABLE_IDX'", "'SKIP_UNUSABLE_INDEXES'", "'SMALLFILE'", + "'SMALLINT'", "'SNAPSHOT'", "'SOME'", "'SORT'", "'SOUNDEX'", "'SOURCE_FILE_DIRECTORY'", + "'SOURCE_FILE_NAME_CONVERT'", "'SOURCE'", "'SPACE'", "'SPECIFICATION'", + "'SPFILE'", "'SPLIT'", "'SPREADSHEET'", "'SQLDATA'", "'SQLERROR'", "'SQLLDR'", + "'SQL'", "'SQL_MACRO'", "'SQL_TRACE'", "'SQL_TRANSLATION_PROFILE'", + "'SQRT'", "'STALE'", "'STANDALONE'", "'STANDARD'", "'STANDARD_HASH'", + "'STANDBY_MAX_DATA_DELAY'", "'STANDBYS'", "'STANDBY'", "'STAR'", "'STAR_TRANSFORMATION'", + "'START'", "'STARTUP'", "'STATEMENT_ID'", "'STATEMENT_QUEUING'", "'STATEMENTS'", + "'STATEMENT'", "'STATE'", "'STATIC'", "'STATISTICS'", "'STATS_BINOMIAL_TEST'", + "'STATS_CROSSTAB'", "'STATS_F_TEST'", "'STATS_KS_TEST'", "'STATS_MODE'", + "'STATS_MW_TEST'", "'STATS_ONE_WAY_ANOVA'", "'STATS_T_TEST_INDEP'", + "'STATS_T_TEST_INDEPU'", "'STATS_T_TEST_ONE'", "'STATS_T_TEST_PAIRED'", + "'STATS_WSR_TEST'", "'STDDEV_POP'", "'STDDEV_SAMP'", "'STOP'", "'STORAGE'", + "'STORE'", "'STREAMS'", "'STREAM'", "'STRICT'", "'STRING'", "'STRIPE_COLUMNS'", + "'STRIPE_WIDTH'", "'STRIP'", "'STRUCTURE'", "'SUBMULTISET'", "'SUBPARTITION_REL'", + "'SUBPARTITIONS'", "'SUBPARTITION'", "'SUBQUERIES'", "'SUBQUERY_PRUNING'", + "'SUBSCRIBE'", "'SUBSET'", "'SUBSTITUTABLE'", "'SUBSTR2'", "'SUBSTR4'", + "'SUBSTRB'", "'SUBSTRC'", "'SUBTYPE'", "'SUCCESSFUL'", "'SUCCESS'", + "'SUMMARY'", "'SUPPLEMENTAL'", "'SUSPEND'", "'SWAP_JOIN_INPUTS'", "'SWITCHOVER'", + "'SWITCH'", "'SYNCHRONOUS'", "'SYNC'", "'SYNONYM'", "'SYS'", "'SYSASM'", + "'SYS_AUDIT'", "'SYSAUX'", "'SYSBACKUP'", "'SYS_CHECKACL'", "'SYS_CHECK_PRIVILEGE'", + "'SYS_CONNECT_BY_PATH'", "'SYS_CONTEXT'", "'SYSDATE'", "'SYSDBA'", "'SYS_DBURIGEN'", + "'SYSDG'", "'SYS_DL_CURSOR'", "'SYS_DM_RXFORM_CHR'", "'SYS_DM_RXFORM_NUM'", + "'SYS_DOM_COMPARE'", "'SYS_DST_PRIM2SEC'", "'SYS_DST_SEC2PRIM'", "'SYS_ET_BFILE_TO_RAW'", + "'SYS_ET_BLOB_TO_IMAGE'", "'SYS_ET_IMAGE_TO_BLOB'", "'SYS_ET_RAW_TO_BFILE'", + "'SYS_EXTPDTXT'", "'SYS_EXTRACT_UTC'", "'SYS_FBT_INSDEL'", "'SYS_FILTER_ACLS'", + "'SYS_FNMATCHES'", "'SYS_FNREPLACE'", "'SYS_GET_ACLIDS'", "'SYS_GET_COL_ACLIDS'", + "'SYS_GET_PRIVILEGES'", "'SYS_GETTOKENID'", "'SYS_GETXTIVAL'", "'SYS_GUID'", + "'SYSGUID'", "'SYSKM'", "'SYS_MAKE_XMLNODEID'", "'SYS_MAKEXML'", "'SYS_MKXMLATTR'", + "'SYS_MKXTI'", "'SYSOBJ'", "'SYS_OP_ADT2BIN'", "'SYS_OP_ADTCONS'", "'SYS_OP_ALSCRVAL'", + "'SYS_OP_ATG'", "'SYS_OP_BIN2ADT'", "'SYS_OP_BITVEC'", "'SYS_OP_BL2R'", + "'SYS_OP_BLOOM_FILTER_LIST'", "'SYS_OP_BLOOM_FILTER'", "'SYS_OP_C2C'", + "'SYS_OP_CAST'", "'SYS_OP_CEG'", "'SYS_OP_CL2C'", "'SYS_OP_COMBINED_HASH'", + "'SYS_OP_COMP'", "'SYS_OP_CONVERT'", "'SYS_OP_COUNTCHG'", "'SYS_OP_CSCONV'", + "'SYS_OP_CSCONVTEST'", "'SYS_OP_CSR'", "'SYS_OP_CSX_PATCH'", "'SYS_OP_CYCLED_SEQ'", + "'SYS_OP_DECOMP'", "'SYS_OP_DESCEND'", "'SYS_OP_DISTINCT'", "'SYS_OP_DRA'", + "'SYS_OP_DUMP'", "'SYS_OP_DV_CHECK'", "'SYS_OP_ENFORCE_NOT_NULL$'", + "'SYSOPER'", "'SYS_OP_EXTRACT'", "'SYS_OP_GROUPING'", "'SYS_OP_GUID'", + "'SYS_OP_HASH'", "'SYS_OP_IIX'", "'SYS_OP_ITR'", "'SYS_OP_KEY_VECTOR_CREATE'", + "'SYS_OP_KEY_VECTOR_FILTER_LIST'", "'SYS_OP_KEY_VECTOR_FILTER'", "'SYS_OP_KEY_VECTOR_SUCCEEDED'", + "'SYS_OP_KEY_VECTOR_USE'", "'SYS_OP_LBID'", "'SYS_OP_LOBLOC2BLOB'", + "'SYS_OP_LOBLOC2CLOB'", "'SYS_OP_LOBLOC2ID'", "'SYS_OP_LOBLOC2NCLOB'", + "'SYS_OP_LOBLOC2TYP'", "'SYS_OP_LSVI'", "'SYS_OP_LVL'", "'SYS_OP_MAKEOID'", + "'SYS_OP_MAP_NONNULL'", "'SYS_OP_MSR'", "'SYS_OP_NICOMBINE'", "'SYS_OP_NIEXTRACT'", + "'SYS_OP_NII'", "'SYS_OP_NIX'", "'SYS_OP_NOEXPAND'", "'SYS_OP_NTCIMG$'", + "'SYS_OP_NUMTORAW'", "'SYS_OP_OIDVALUE'", "'SYS_OP_OPNSIZE'", "'SYS_OP_PAR_1'", + "'SYS_OP_PARGID_1'", "'SYS_OP_PARGID'", "'SYS_OP_PAR'", "'SYS_OP_PART_ID'", + "'SYS_OP_PIVOT'", "'SYS_OP_R2O'", "'SYS_OP_RAWTONUM'", "'SYS_OP_RDTM'", + "'SYS_OP_REF'", "'SYS_OP_RMTD'", "'SYS_OP_ROWIDTOOBJ'", "'SYS_OP_RPB'", + "'SYS_OPTLOBPRBSC'", "'SYS_OP_TOSETID'", "'SYS_OP_TPR'", "'SYS_OP_TRTB'", + "'SYS_OPTXICMP'", "'SYS_OPTXQCASTASNQ'", "'SYS_OP_UNDESCEND'", "'SYS_OP_VECAND'", + "'SYS_OP_VECBIT'", "'SYS_OP_VECOR'", "'SYS_OP_VECXOR'", "'SYS_OP_VERSION'", + "'SYS_OP_VREF'", "'SYS_OP_VVD'", "'SYS_OP_XMLCONS_FOR_CSX'", "'SYS_OP_XPTHATG'", + "'SYS_OP_XPTHIDX'", "'SYS_OP_XPTHOP'", "'SYS_OP_XTXT2SQLT'", "'SYS_OP_ZONE_ID'", + "'SYS_ORDERKEY_DEPTH'", "'SYS_ORDERKEY_MAXCHILD'", "'SYS_ORDERKEY_PARENT'", + "'SYS_PARALLEL_TXN'", "'SYS_PATHID_IS_ATTR'", "'SYS_PATHID_IS_NMSPC'", + "'SYS_PATHID_LASTNAME'", "'SYS_PATHID_LASTNMSPC'", "'SYS_PATH_REVERSE'", + "'SYS_PXQEXTRACT'", "'SYS_RAW_TO_XSID'", "'SYS_RID_ORDER'", "'SYS_ROW_DELTA'", + "'SYS_SC_2_XMLT'", "'SYS_SYNRCIREDO'", "'SYSTEM_DEFINED'", "'SYSTEM'", + "'SYSTIMESTAMP'", "'SYS_TYPEID'", "'SYS_UMAKEXML'", "'SYS_XMLANALYZE'", + "'SYS_XMLCONTAINS'", "'SYS_XMLCONV'", "'SYS_XMLEXNSURI'", "'SYS_XMLGEN'", + "'SYS_XMLI_LOC_ISNODE'", "'SYS_XMLI_LOC_ISTEXT'", "'SYS_XMLINSTR'", + "'SYS_XMLLOCATOR_GETSVAL'", "'SYS_XMLNODEID_GETCID'", "'SYS_XMLNODEID_GETLOCATOR'", + "'SYS_XMLNODEID_GETOKEY'", "'SYS_XMLNODEID_GETPATHID'", "'SYS_XMLNODEID_GETPTRID'", + "'SYS_XMLNODEID_GETRID'", "'SYS_XMLNODEID_GETSVAL'", "'SYS_XMLNODEID_GETTID'", + "'SYS_XMLNODEID'", "'SYS_XMLT_2_SC'", "'SYS_XMLTRANSLATE'", "'SYS_XMLTYPE2SQL'", + "'SYS_XQ_ASQLCNV'", "'SYS_XQ_ATOMCNVCHK'", "'SYS_XQBASEURI'", "'SYS_XQCASTABLEERRH'", + "'SYS_XQCODEP2STR'", "'SYS_XQCODEPEQ'", "'SYS_XQCON2SEQ'", "'SYS_XQCONCAT'", + "'SYS_XQDELETE'", "'SYS_XQDFLTCOLATION'", "'SYS_XQDOC'", "'SYS_XQDOCURI'", + "'SYS_XQDURDIV'", "'SYS_XQED4URI'", "'SYS_XQENDSWITH'", "'SYS_XQERRH'", + "'SYS_XQERR'", "'SYS_XQESHTMLURI'", "'SYS_XQEXLOBVAL'", "'SYS_XQEXSTWRP'", + "'SYS_XQEXTRACT'", "'SYS_XQEXTRREF'", "'SYS_XQEXVAL'", "'SYS_XQFB2STR'", + "'SYS_XQFNBOOL'", "'SYS_XQFNCMP'", "'SYS_XQFNDATIM'", "'SYS_XQFNLNAME'", + "'SYS_XQFNNM'", "'SYS_XQFNNSURI'", "'SYS_XQFNPREDTRUTH'", "'SYS_XQFNQNM'", + "'SYS_XQFNROOT'", "'SYS_XQFORMATNUM'", "'SYS_XQFTCONTAIN'", "'SYS_XQFUNCR'", + "'SYS_XQGETCONTENT'", "'SYS_XQINDXOF'", "'SYS_XQINSERT'", "'SYS_XQINSPFX'", + "'SYS_XQIRI2URI'", "'SYS_XQLANG'", "'SYS_XQLLNMFRMQNM'", "'SYS_XQMKNODEREF'", + "'SYS_XQNILLED'", "'SYS_XQNODENAME'", "'SYS_XQNORMSPACE'", "'SYS_XQNORMUCODE'", + "'SYS_XQ_NRNG'", "'SYS_XQNSP4PFX'", "'SYS_XQNSPFRMQNM'", "'SYS_XQPFXFRMQNM'", + "'SYS_XQ_PKSQL2XML'", "'SYS_XQPOLYABS'", "'SYS_XQPOLYADD'", "'SYS_XQPOLYCEL'", + "'SYS_XQPOLYCSTBL'", "'SYS_XQPOLYCST'", "'SYS_XQPOLYDIV'", "'SYS_XQPOLYFLR'", + "'SYS_XQPOLYMOD'", "'SYS_XQPOLYMUL'", "'SYS_XQPOLYRND'", "'SYS_XQPOLYSQRT'", + "'SYS_XQPOLYSUB'", "'SYS_XQPOLYUMUS'", "'SYS_XQPOLYUPLS'", "'SYS_XQPOLYVEQ'", + "'SYS_XQPOLYVGE'", "'SYS_XQPOLYVGT'", "'SYS_XQPOLYVLE'", "'SYS_XQPOLYVLT'", + "'SYS_XQPOLYVNE'", "'SYS_XQREF2VAL'", "'SYS_XQRENAME'", "'SYS_XQREPLACE'", + "'SYS_XQRESVURI'", "'SYS_XQRNDHALF2EVN'", "'SYS_XQRSLVQNM'", "'SYS_XQRYENVPGET'", + "'SYS_XQRYVARGET'", "'SYS_XQRYWRP'", "'SYS_XQSEQ2CON4XC'", "'SYS_XQSEQ2CON'", + "'SYS_XQSEQDEEPEQ'", "'SYS_XQSEQINSB'", "'SYS_XQSEQRM'", "'SYS_XQSEQRVS'", + "'SYS_XQSEQSUB'", "'SYS_XQSEQTYPMATCH'", "'SYS_XQSTARTSWITH'", "'SYS_XQSTATBURI'", + "'SYS_XQSTR2CODEP'", "'SYS_XQSTRJOIN'", "'SYS_XQSUBSTRAFT'", "'SYS_XQSUBSTRBEF'", + "'SYS_XQTOKENIZE'", "'SYS_XQTREATAS'", "'SYS_XQ_UPKXML2SQL'", "'SYS_XQXFORM'", + "'SYS_XSID_TO_RAW'", "'SYS_ZMAP_FILTER'", "'SYS_ZMAP_REFRESH'", "'T'", + "'TABLE_LOOKUP_BY_NL'", "'TABLESPACE_NO'", "'TABLESPACE'", "'TABLES'", + "'TABLE_STATS'", "'TABLE'", "'TABNO'", "'TAG'", "'TANH'", "'TAN'", "'TBL$OR$IDX$PART$NUM'", + "'TEMPFILE'", "'TEMPLATE'", "'TEMPORARY'", "'TEMP_TABLE'", "'TEST'", + "'TEXT'", "'THAN'", "'THEN'", "'THE'", "'THREAD'", "'THROUGH'", "'TIER'", + "'TIES'", "'TIMEOUT'", "'TIMESTAMP_LTZ_UNCONSTRAINED'", "'TIMESTAMP'", + "'TIMESTAMP_TZ_UNCONSTRAINED'", "'TIMESTAMP_UNCONSTRAINED'", "'TIMES'", + "'TIME'", "'TIMEZONE'", "'TIMEZONE_ABBR'", "'TIMEZONE_HOUR'", "'TIMEZONE_MINUTE'", + "'TIMEZONE_OFFSET'", "'TIMEZONE_REGION'", "'TIME_ZONE'", "'TIMING'", + "'TIV_GB'", "'TIV_SSF'", "'TO_ACLID'", "'TO_BINARY_DOUBLE'", "'TO_BINARY_FLOAT'", + "'TO_BLOB'", "'TO_CLOB'", "'TO_DSINTERVAL'", "'TO_LOB'", "'TO_MULTI_BYTE'", + "'TO_NCHAR'", "'TO_NCLOB'", "'TO_NUMBER'", "'TOPLEVEL'", "'TO_SINGLE_BYTE'", + "'TO_TIMESTAMP'", "'TO_TIMESTAMP_TZ'", "'TO_TIME'", "'TO_TIME_TZ'", + "'TO'", "'TO_YMINTERVAL'", "'TRACE'", "'TRACING'", "'TRACKING'", "'TRAILING'", + "'TRANSACTION'", "'TRANSFORM'", "'TRANSFORM_DISTINCT_AGG'", "'TRANSITIONAL'", + "'TRANSITION'", "'TRANSLATE'", "'TRANSLATION'", "'TREAT'", "'TRIGGERS'", + "'TRIGGER'", "'TRUE'", "'TRUNCATE'", "'TRUNC'", "'TRUSTED'", "'TRUST'", + "'TUNING'", "'TX'", "'TYPES'", "'TYPE'", "'TZ_OFFSET'", "'UB2'", "'UBA'", + "'UCS2'", "'UID'", "'UNARCHIVED'", "'UNBOUNDED'", "'UNBOUND'", "'UNCONDITIONAL'", + "'UNDER'", "'UNDO'", "'UNDROP'", "'UNIFORM'", "'UNION'", "'UNIQUE'", + "'UNISTR'", "'UNLIMITED'", "'UNLOAD'", "'UNLOCK'", "'UNMATCHED'", "'UNNEST_INNERJ_DISTINCT_VIEW'", + "'UNNEST_NOSEMIJ_NODISTINCTVIEW'", "'UNNEST_SEMIJ_VIEW'", "'UNNEST'", + "'UNPACKED'", "'UNPIVOT'", "'UNPLUG'", "'UNPROTECTED'", "'UNQUIESCE'", + "'UNRECOVERABLE'", "'UNRESTRICTED'", "'UNSUBSCRIBE'", "'UNTIL'", "'UNUSABLE'", + "'UNUSED'", "'UPDATABLE'", "'UPDATED'", "'UPDATE'", "'UPDATEXML'", "'UPD_INDEXES'", + "'UPD_JOININDEX'", "'UPGRADE'", "'UPPER'", "'UPSERT'", "'UROWID'", "'USABLE'", + "'USAGE'", "'USE_ANTI'", "'USE_CONCAT'", "'USE_CUBE'", "'USE_HASH_AGGREGATION'", + "'USE_HASH_GBY_FOR_PUSHDOWN'", "'USE_HASH'", "'USE_HIDDEN_PARTITIONS'", + "'USE_INVISIBLE_INDEXES'", "'USE_MERGE_CARTESIAN'", "'USE_MERGE'", "'USE_NL'", + "'USE_NL_WITH_INDEX'", "'USE_PRIVATE_OUTLINES'", "'USER_DATA'", "'USER_DEFINED'", + "'USERENV'", "'USERGROUP'", "'USER_RECYCLEBIN'", "'USERS'", "'USER_TABLESPACES'", + "'USER'", "'USE_SEMI'", "'USE_STORED_OUTLINES'", "'USE_TTT_FOR_GSETS'", + "'USE'", "'USE_VECTOR_AGGREGATION'", "'USE_WEAK_NAME_RESL'", "'USING_NO_EXPAND'", + "'USING'", "'UTF16BE'", "'UTF16LE'", "'UTF32'", "'UTF8'", "'V1'", "'V2'", + "'VALIDATE'", "'VALIDATE_CONVERSION'", "'VALIDATION'", "'VALID_TIME_END'", + "'VALUES'", "'VALUE'", "'VARCHAR2'", "'VARCHAR'", "'VARIABLE'", "'VAR_POP'", + "'VARRAYS'", "'VARRAY'", "'VAR_SAMP'", "'VARYING'", "'VECTOR_READ_TRACE'", + "'VECTOR_READ'", "'VECTOR_TRANSFORM_DIMS'", "'VECTOR_TRANSFORM_FACT'", + "'VECTOR_TRANSFORM'", "'VERIFIER'", "'VERIFY'", "'VERSIONING'", "'VERSIONS_ENDSCN'", + "'VERSIONS_ENDTIME'", "'VERSIONS_OPERATION'", "'VERSIONS_STARTSCN'", + "'VERSIONS_STARTTIME'", "'VERSIONS'", "'VERSIONS_XID'", "'VERSION'", + "'VIEW'", "'VIOLATION'", "'VIRTUAL'", "'VISIBILITY'", "'VISIBLE'", "'VOLUME'", + "'VSIZE'", "'WAIT'", "'WALLET'", "'WARNING'", "'WEEKS'", "'WEEK'", "'WELLFORMED'", + "'WHENEVER'", "'WHEN'", "'WHERE'", "'WHILE'", "'WHITESPACE'", "'WIDTH_BUCKET'", + "'WITHIN'", "'WITHOUT'", "'WITH_PLSQL'", "'WITH'", "'WORK'", "'WRAPPED'", + "'WRAPPER'", "'WRITE'", "'XDB_FASTPATH_INSERT'", "'XDB'", "'X_DYN_PRUNE'", + "'XID'", "'XML2OBJECT'", "'XMLAGG'", "'XMLATTRIBUTES'", "'XMLCAST'", + "'XMLCDATA'", "'XMLCOLATTVAL'", "'XMLCOMMENT'", "'XMLCONCAT'", "'XMLDIFF'", + "'XML_DML_RWT_STMT'", "'XMLELEMENT'", "'XMLEXISTS2'", "'XMLEXISTS'", + "'XMLFOREST'", "'XMLINDEX'", "'XMLINDEX_REWRITE_IN_SELECT'", "'XMLINDEX_REWRITE'", + "'XMLINDEX_SEL_IDX_TBL'", "'XMLISNODE'", "'XMLISVALID'", "'XMLNAMESPACES'", + "'XMLPARSE'", "'XMLPATCH'", "'XMLPI'", "'XMLQUERYVAL'", "'XMLQUERY'", + "'XMLROOT'", "'XMLSCHEMA'", "'XMLSERIALIZE'", "'XMLTABLE'", "'XMLTRANSFORMBLOB'", + "'XMLTRANSFORM'", "'XMLTYPE'", "'XML'", "'XPATHTABLE'", "'XS_SYS_CONTEXT'", + "'XS'", "'YEARS'", "'YEAR'", "'YES'", "'YMINTERVAL_UNCONSTRAINED'", + "'ZONEMAP'", "'ZONE'", "'PREDICTION'", "'PREDICTION_BOUNDS'", "'PREDICTION_COST'", + "'PREDICTION_DETAILS'", "'PREDICTION_PROBABILITY'", "'PREDICTION_SET'", + "'BLOCKCHAIN'", "'COLLATE'", "'COLLATION'", "'DEFINITION'", "'DUPLICATED'", + "'EXTENDED'", "'HASHING'", "'IDLE'", "'IMMUTABLE'", "'ORACLE_DATAPUMP'", + "'ORACLE_HDFS'", "'ORACLE_HIVE'", "'ORACLE_LOADER'", "'\"SHA2_512\"'", + "'SHARDED'", "'\"V1\"'", "'ISOLATE'", "'ROOT'", "'UNITE'", "'ALGORITHM'", + "'CUME_DIST'", "'DENSE_RANK'", "'LISTAGG'", "'PERCENT_RANK'", "'PERCENTILE_CONT'", + "'PERCENTILE_DISC'", "'RANK'", "'AVG'", "'CORR'", "'COVAR_'", "'DECODE'", + "'LAG'", "'LAG_DIFF'", "'LAG_DIFF_PERCENT'", "'LEAD'", "'MAX'", "'MEDIAN'", + "'MEMOPTIMIZE'", "'MIN'", "'NTILE'", "'NVL'", "'RATIO_TO_REPORT'", "'REGR_'", + "'ROUND'", "'ROW_NUMBER'", "'SUBSTR'", "'TO_CHAR'", "'TRIM'", "'SUM'", + "'STDDEV'", "'VAR_'", "'VARIANCE'", "'LEAST'", "'GREATEST'", "'TO_DATE'", + "'DEFAULTIF'", "'LLS'", "'ENCLOSED'", "'TERMINATED'", "'OPTIONALLY'", + "'LRTRIM'", "'NOTRIM'", "'LDRTRIM'", "'DATE_FORMAT'", "'MASK'", "'TRANSFORMS'", + "'LOBFILE'", "'STARTOF'", "'CHARACTERSET'", "'RECORDS'", "'FIXED'", + "'DELIMITED'", "'XMLTAG'", "'PREPROCESSOR'", "'TERRITORY'", "'LITTLE'", + "'BIG'", "'ENDIAN'", "'BYTEORDERMARK'", "'NOCHECK'", "'SIZES'", "'ARE'", + "'BYTES'", "'CHARACTERS'", "'READSIZE'", "'DISABLE_DIRECTORY_LINK_CHECK'", + "'DATE_CACHE'", "'FIELD_NAMES'", "'FILES'", "'IO_OPTIONS'", "'DIRECTIO'", + "'NODIRECTIO'", "'DNFS_ENABLE'", "'DNFS_DISABLE'", "'DNFS_READBUFFERS'", + "'NOBADFILE'", "'BADFILE'", "'NODISCARDFILE'", "'DISCARDFILE'", "'NOLOGFILE'", + "'FIELDS'", "'IGNORE_CHARS_AFTER_EOR'", "'CSV'", "'EMBEDDED'", "'OVERRIDE'", + "'THESE'", "'FIELD'", "'NONULLIF'", "'POSITION'", "'NEWLINE'", "'DETECTED'", + "'UNSIGNED'", "'ZONED'", "'ORACLE_DATE'", "'ORACLE_NUMBER'", "'COUNTED'", + "'VARRAW'", "'VARCHARC'", "'VARRAWC'", "", "", "", "'..'", "'.'", "", + "", "", "", "'%'", "'&'", "'('", "')'", "'**'", "'*'", "'+'", "'-'", + "','", "'/'", "'@'", "':='", "'#'", "'''", "", "", "'^'", "'~'", "'!'", + "'>'", "'<'", "':'", "';'", "'|'", "'='", "'['", "']'", "'_'", + } + staticData.SymbolicNames = []string{ + "", "ABORT", "ABS", "ABSENT", "ACCESS", "ACCESSED", "ACCOUNT", "ACL", + "ACOS", "ACROSS", "ACTION", "ACTIONS", "ACTIVATE", "ACTIVE", "ACTIVE_COMPONENT", + "ACTIVE_DATA", "ACTIVE_FUNCTION", "ACTIVE_TAG", "ACTIVITY", "ADAPTIVE_PLAN", + "ADD", "ADD_COLUMN", "ADD_GROUP", "ADD_MONTHS", "ADJ_DATE", "ADMIN", + "ADMINISTER", "ADMINISTRATOR", "ADVANCED", "ADVISE", "ADVISOR", "AFD_DISKSTRING", + "AFTER", "AGENT", "AGGREGATE", "A_LETTER", "ALIAS", "ALL", "ALLOCATE", + "ALLOW", "ALL_ROWS", "ALTER", "ALTERNATE", "ALWAYS", "ANALYTIC", "ANALYZE", + "ANCESTOR", "ANCILLARY", "AND", "AND_EQUAL", "ANOMALY", "ANSI_REARCH", + "ANTIJOIN", "ANY", "ANYSCHEMA", "APPEND", "APPENDCHILDXML", "APPEND_VALUES", + "APPLICATION", "APPLY", "APPROX_COUNT_DISTINCT", "ARCHIVAL", "ARCHIVE", + "ARCHIVED", "ARCHIVELOG", "ARRAY", "AS", "ASC", "ASCII", "ASCIISTR", + "ASIN", "ASIS", "ASSEMBLY", "ASSIGN", "ASSOCIATE", "ASYNC", "ASYNCHRONOUS", + "ATAN2", "ATAN", "AT", "ATTRIBUTE", "ATTRIBUTES", "AUDIT", "AUTHENTICATED", + "AUTHENTICATION", "AUTHID", "AUTHORIZATION", "AUTOALLOCATE", "AUTO", + "AUTOEXTEND", "AUTO_LOGIN", "AUTOMATIC", "AUTONOMOUS_TRANSACTION", "AUTO_REOPTIMIZE", + "AVAILABILITY", "AVRO", "BACKGROUND", "BACKINGFILE", "BACKUP", "BACKUPS", + "BASIC", "BASICFILE", "BATCH", "BATCHSIZE", "BATCH_TABLE_ACCESS_BY_ROWID", + "BECOME", "BEFORE", "BEGIN", "BEGINNING", "BEGIN_OUTLINE_DATA", "BEHALF", + "BEQUEATH", "BETWEEN", "BFILE", "BFILENAME", "BIGFILE", "BINARY", "BINARY_DOUBLE", + "BINARY_DOUBLE_INFINITY", "BINARY_DOUBLE_NAN", "BINARY_FLOAT", "BINARY_FLOAT_INFINITY", + "BINARY_FLOAT_NAN", "BINARY_INTEGER", "BIND_AWARE", "BINDING", "BIN_TO_NUM", + "BITAND", "BITMAP_AND", "BITMAP", "BITMAPS", "BITMAP_TREE", "BITS", + "BLOB", "BLOCK", "BLOCK_RANGE", "BLOCKS", "BLOCKSIZE", "BODY", "BOOLEAN", + "BOTH", "BOUND", "BRANCH", "BREADTH", "BROADCAST", "BSON", "BUFFER", + "BUFFER_CACHE", "BUFFER_POOL", "BUILD", "BULK", "BY", "BYPASS_RECURSIVE_CHECK", + "BYPASS_UJVC", "BYTE", "CACHE", "CACHE_CB", "CACHE_INSTANCES", "CACHE_TEMP_TABLE", + "CACHING", "CALCULATED", "CALLBACK", "CALL", "CANCEL", "CANONICAL", + "CAPACITY", "CAPTION", "CARDINALITY", "CASCADE", "CASE", "CAST", "CASESENSITIVE", + "CATEGORY", "CDBDEFAULT", "CEIL", "CELL_FLASH_CACHE", "CERTIFICATE", + "CFILE", "CHAINED", "CHANGE", "CHANGE_DUPKEY_ERROR_INDEX", "CHARACTER", + "CHAR", "CHAR_CS", "CHARTOROWID", "CHECK_ACL_REWRITE", "CHECK", "CHECKPOINT", + "CHILD", "CHOOSE", "CHR", "CHUNK", "CLASS", "CLASSIFICATION", "CLASSIFIER", + "CLAUSE", "CLEAN", "CLEANUP", "CLEAR", "C_LETTER", "CLIENT", "CLOB", + "CLONE", "CLOSE_CACHED_OPEN_CURSORS", "CLOSE", "CLUSTER_BY_ROWID", "CLUSTER", + "CLUSTER_DETAILS", "CLUSTER_DISTANCE", "CLUSTER_ID", "CLUSTERING", "CLUSTERING_FACTOR", + "CLUSTER_PROBABILITY", "CLUSTER_SET", "COALESCE", "COALESCE_SQ", "COARSE", + "CO_AUTH_IND", "COLD", "COLLECT", "COLUMNAR", "COLUMN_AUTH_INDICATOR", + "COLUMN", "COLUMNS", "COLUMN_STATS", "COLUMN_VALUE", "COMMENT", "COMMIT", + "COMMITTED", "COMMON", "COMMON_DATA", "COMPACT", "COMPATIBILITY", "COMPILE", + "COMPLETE", "COMPLIANCE", "COMPONENT", "COMPONENTS", "COMPOSE", "COMPOSITE", + "COMPOSITE_LIMIT", "COMPOUND", "COMPRESS", "COMPUTE", "CONCAT", "CON_DBID_TO_ID", + "CONDITIONAL", "CONDITION", "CONFIRM", "CONFORMING", "CON_GUID_TO_ID", + "CON_ID", "CON_NAME_TO_ID", "CONNECT_BY_CB_WHR_ONLY", "CONNECT_BY_COMBINE_SW", + "CONNECT_BY_COST_BASED", "CONNECT_BY_ELIM_DUPS", "CONNECT_BY_FILTERING", + "CONNECT_BY_ISCYCLE", "CONNECT_BY_ISLEAF", "CONNECT_BY_ROOT", "CONNECT", + "CONNECT_TIME", "CONSIDER", "CONSISTENT", "CONSTANT", "CONST", "CONSTRAINT", + "CONSTRAINTS", "CONSTRUCTOR", "CONTAINER", "CONTAINERS", "CONTAINERS_DEFAULT", + "CONTAINER_DATA", "CONTAINER_MAP", "CONTENT", "CONTENTS", "CONTEXT", + "CONTINUE", "CONTROLFILE", "CON_UID_TO_ID", "CONVERT", "CONVERSION", + "COOKIE", "COPY", "CORR_K", "CORR_S", "CORRUPTION", "CORRUPT_XID_ALL", + "CORRUPT_XID", "COS", "COSH", "COST", "COST_XML_QUERY_REWRITE", "COUNT", + "COVAR_POP", "COVAR_SAMP", "CPU_COSTING", "CPU_PER_CALL", "CPU_PER_SESSION", + "CRASH", "CREATE", "CREATE_FILE_DEST", "CREATE_STORED_OUTLINES", "CREATION", + "CREDENTIAL", "CRITICAL", "CROSS", "CROSSEDITION", "CSCONVERT", "CUBE_AJ", + "CUBE", "CUBE_GB", "CUBE_SJ", "CUME_DISTM", "CURRENT", "CURRENT_DATE", + "CURRENT_SCHEMA", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER", + "CURRENTV", "CURSOR", "CURSOR_SHARING_EXACT", "CURSOR_SPECIFIC_SEGMENT", + "CUSTOMDATUM", "CV", "CYCLE", "DANGLING", "DATABASE", "DATA", "DATAFILE", + "DATAFILES", "DATAMOVEMENT", "DATAOBJNO", "DATAOBJ_TO_MAT_PARTITION", + "DATAOBJ_TO_PARTITION", "DATAPUMP", "DATA_SECURITY_REWRITE_LIMIT", "DATE", + "DATE_MODE", "DAY", "DAYS", "DBA", "DBA_RECYCLEBIN", "DBMS_STATS", "DB_ROLE_CHANGE", + "DBTIMEZONE", "DB_UNIQUE_NAME", "DB_VERSION", "DDL", "DEALLOCATE", "DEBUG", + "DEBUGGER", "DEC", "DECIMAL", "DECLARE", "DECOMPOSE", "DECORRELATE", + "DECR", "DECREMENT", "DECRYPT", "DEDUPLICATE", "DEFAULT", "DEFAULTS", + "DEFAULT_COLLATION", "DEFAULT_CREDENTIAL", "DEFERRABLE", "DEFERRED", + "DEFINED", "DEFINE", "DEFINER", "DEGREE", "DELAY", "DELEGATE", "DELETE_ALL", + "DELETE", "DELETEXML", "DEMAND", "DENSE_RANKM", "DEPENDENT", "DEPTH", + "DEQUEUE", "DEREF", "DEREF_NO_REWRITE", "DESC", "DESCRIPTION", "DESTROY", + "DETACHED", "DETERMINES", "DETERMINISTIC", "DICTIONARY", "DIMENSION", + "DIMENSIONS", "DIRECT_LOAD", "DIRECTORY", "DIRECT_PATH", "DISABLE_ALL", + "DISABLE", "DISABLE_PARALLEL_DML", "DISABLE_PRESET", "DISABLE_RPKE", + "DISALLOW", "DISASSOCIATE", "DISCARD", "DISCONNECT", "DISK", "DISKGROUP", + "DISKS", "DISMOUNT", "DISTINCT", "DISTINGUISHED", "DISTRIBUTED", "DISTRIBUTE", + "DML", "DML_UPDATE", "DOCFIDELITY", "DOCUMENT", "DOMAIN_INDEX_FILTER", + "DOMAIN_INDEX_NO_SORT", "DOMAIN_INDEX_SORT", "DOUBLE", "DOWNGRADE", + "DRIVING_SITE", "DROP_COLUMN", "DROP", "DROP_GROUP", "DSINTERVAL_UNCONSTRAINED", + "DST_UPGRADE_INSERT_CONV", "DUMP", "DUPLICATE", "DV", "DYNAMIC", "DYNAMIC_SAMPLING", + "DYNAMIC_SAMPLING_EST_CDN", "E_LETTER", "EACH", "EDITIONABLE", "EDITION", + "EDITIONING", "EDITIONS", "ELEMENT", "ELIM_GROUPBY", "ELIMINATE_JOIN", + "ELIMINATE_OBY", "ELIMINATE_OUTER_JOIN", "ELSE", "ELSIF", "EM", "EMPTY_BLOB", + "EMPTY_CLOB", "EMPTY", "ENABLE_ALL", "ENABLE", "ENABLE_PARALLEL_DML", + "ENABLE_PRESET", "ENCODING", "ENCRYPT", "ENCRYPTION", "END", "END_OUTLINE_DATA", + "ENFORCED", "ENFORCE", "ENQUEUE", "ENTERPRISE", "ENTITYESCAPING", "ENTRY", + "EQUIPART", "ERR", "ERROR_ARGUMENT", "ERROR", "ERROR_ON_OVERLAP_TIME", + "ERRORS", "ESCAPE", "ESTIMATE", "EVAL", "EVALNAME", "EVALUATE", "EVALUATION", + "EVENTS", "EVERY", "EXCEPT", "EXCEPTION", "EXCEPTION_INIT", "EXCEPTIONS", + "EXCHANGE", "EXCLUDE", "EXCLUDING", "EXCLUSIVE", "EXECUTE", "EXEMPT", + "EXISTING", "EXISTS", "EXISTSNODE", "EXIT", "EXPAND_GSET_TO_UNION", + "EXPAND_TABLE", "EXP", "EXPIRE", "EXPLAIN", "EXPLOSION", "EXPORT", "EXPR_CORR_CHECK", + "EXPRESS", "EXTENDS", "EXTENT", "EXTENTS", "EXTERNAL", "EXTERNALLY", + "EXTRACTCLOBXML", "EXTRACT", "EXTRACTVALUE", "EXTRA", "FACILITY", "FACT", + "FACTOR", "FACTORIZE_JOIN", "FAILED", "FAILED_LOGIN_ATTEMPTS", "FAILGROUP", + "FAILOVER", "FAILURE", "FALSE", "FAMILY", "FAR", "FAST", "FASTSTART", + "FBTSCAN", "FEATURE", "FEATURE_DETAILS", "FEATURE_ID", "FEATURE_SET", + "FEATURE_VALUE", "FETCH", "FILE", "FILE_NAME_CONVERT", "FILEGROUP", + "FILESTORE", "FILESYSTEM_LIKE_LOGGING", "FILTER", "FINAL", "FINE", "FINISH", + "FIRST", "FIRSTM", "FIRST_ROWS", "FIRST_VALUE", "FIXED_VIEW_DATA", "FLAGGER", + "FLASHBACK", "FLASH_CACHE", "FLOAT", "FLOB", "FLEX", "FLOOR", "FLUSH", + "FOLDER", "FOLLOWING", "FOLLOWS", "FORALL", "FORCE", "FORCE_XML_QUERY_REWRITE", + "FOREIGN", "FOREVER", "FOR", "FORMAT", "FORWARD", "FRAGMENT_NUMBER", + "FREELIST", "FREELISTS", "FREEPOOLS", "FRESH", "FROM", "FROM_TZ", "FULL", + "FULL_OUTER_JOIN_TO_OUTER", "FUNCTION", "FUNCTIONS", "FTP", "G_LETTER", + "GATHER_OPTIMIZER_STATISTICS", "GATHER_PLAN_STATISTICS", "GBY_CONC_ROLLUP", + "GBY_PUSHDOWN", "GENERATED", "GET", "GLOBAL", "GLOBALLY", "GLOBAL_NAME", + "GLOBAL_TOPIC_ENABLED", "GOTO", "GRANT", "GROUP_BY", "GROUP", "GROUP_ID", + "GROUPING", "GROUPING_ID", "GROUPS", "GUARANTEED", "GUARANTEE", "GUARD", + "HALF_YEARS", "HASH_AJ", "HASH", "HASHKEYS", "HASH_SJ", "HAVING", "HEADER", + "HEAP", "HELP", "HEXTORAW", "HEXTOREF", "HIDDEN_KEYWORD", "HIDE", "HIER_ORDER", + "HIERARCHICAL", "HIERARCHIES", "HIERARCHY", "HIGH", "HINTSET_BEGIN", + "HINTSET_END", "HOT", "HOUR", "HOURS", "HTTP", "HWM_BROKERED", "HYBRID", + "H_LETTER", "IDENTIFIED", "IDENTIFIER", "IDENTITY", "IDGENERATORS", + "ID", "IDLE_TIME", "IF", "IGNORE", "IGNORE_OPTIM_EMBEDDED_HINTS", "IGNORE_ROW_ON_DUPKEY_INDEX", + "IGNORE_WHERE_CLAUSE", "ILM", "IMMEDIATE", "IMPACT", "IMPORT", "INACTIVE", + "INACTIVE_ACCOUNT_TIME", "INCLUDE", "INCLUDE_VERSION", "INCLUDING", + "INCREMENTAL", "INCREMENT", "INCR", "INDENT", "INDEX_ASC", "INDEX_COMBINE", + "INDEX_DESC", "INDEXED", "INDEXES", "INDEX_FFS", "INDEX_FILTER", "INDEX", + "INDEXING", "INDEX_JOIN", "INDEX_ROWS", "INDEX_RRS", "INDEX_RS_ASC", + "INDEX_RS_DESC", "INDEX_RS", "INDEX_SCAN", "INDEX_SKIP_SCAN", "INDEX_SS_ASC", + "INDEX_SS_DESC", "INDEX_SS", "INDEX_STATS", "INDEXTYPE", "INDEXTYPES", + "INDICATOR", "INDICES", "INFINITE", "INFORMATIONAL", "INHERIT", "IN", + "INITCAP", "INITIAL", "INITIALIZED", "INITIALLY", "INITRANS", "INLINE", + "INLINE_XMLTYPE_NT", "INMEMORY", "IN_MEMORY_METADATA", "INMEMORY_PRUNING", + "INNER", "INOUT", "INPLACE", "INSERTCHILDXMLAFTER", "INSERTCHILDXMLBEFORE", + "INSERTCHILDXML", "INSERT", "INSERTXMLAFTER", "INSERTXMLBEFORE", "INSTANCE", + "INSTANCES", "INSTANTIABLE", "INSTANTLY", "INSTEAD", "INSTR2", "INSTR4", + "INSTRB", "INSTRC", "INSTR", "INTEGER", "INTERLEAVED", "INTERMEDIATE", + "INTERNAL_CONVERT", "INTERNAL_USE", "INTERPRETED", "INTERSECT", "INTERVAL", + "INT", "INTO", "INVALIDATE", "INVISIBLE", "IN_XQUERY", "IS", "IS_LEAF", + "ISOLATION", "ISOLATION_LEVEL", "ITERATE", "ITERATION_NUMBER", "JAVA", + "JOB", "JOIN", "JSON_ARRAYAGG", "JSON_ARRAY", "JSON_EQUAL", "JSON_EXISTS2", + "JSON_EXISTS", "JSONGET", "JSON", "JSON_OBJECTAGG", "JSON_OBJECT", "JSONPARSE", + "JSON_QUERY", "JSON_SERIALIZE", "JSON_TABLE", "JSON_TEXTCONTAINS2", + "JSON_TEXTCONTAINS", "JSON_TRANSFORM", "JSON_VALUE", "K_LETTER", "KEEP_DUPLICATES", + "KEEP", "KERBEROS", "KEY", "KEY_LENGTH", "KEYSIZE", "KEYS", "KEYSTORE", + "KILL", "LABEL", "LANGUAGE", "LAST_DAY", "LAST", "LAST_VALUE", "LATERAL", + "LAX", "LAYER", "LDAP_REGISTRATION_ENABLED", "LDAP_REGISTRATION", "LDAP_REG_SYNC_INTERVAL", + "LEAF", "LEAD_CDB", "LEAD_CDB_URI", "LEADING", "LEFT", "LENGTH2", "LENGTH4", + "LENGTHB", "LENGTHC", "LENGTH", "LESS", "LEVEL", "LEVEL_NAME", "LEVELS", + "LIBRARY", "LIFECYCLE", "LIFE", "LIFETIME", "LIKE2", "LIKE4", "LIKEC", + "LIKE_EXPAND", "LIKE", "LIMIT", "LINEAR", "LINK", "LIST", "LN", "LNNVL", + "LOAD", "LOB", "LOBNVL", "LOBS", "LOCAL_INDEXES", "LOCAL", "LOCALTIME", + "LOCALTIMESTAMP", "LOCATION", "LOCATOR", "LOCKDOWN", "LOCKED", "LOCKING", + "LOCK", "LOGFILE", "LOGFILES", "LOGGING", "LOGICAL", "LOGICAL_READS_PER_CALL", + "LOGICAL_READS_PER_SESSION", "LOG", "LOGMINING", "LOGOFF", "LOGON", + "LOG_READ_ONLY_VIOLATIONS", "LONG", "LOOP", "LOST", "LOWER", "LOW", + "LPAD", "LTRIM", "M_LETTER", "MAIN", "MAKE_REF", "MANAGED", "MANAGE", + "MANAGEMENT", "MANAGER", "MANDATORY", "MANUAL", "MAP", "MAPPING", "MASTER", + "MATCHED", "MATCHES", "MATCH", "MATCH_NUMBER", "MATCH_RECOGNIZE", "MATERIALIZED", + "MATERIALIZE", "MAXARCHLOGS", "MAXDATAFILES", "MAXEXTENTS", "MAXIMIZE", + "MAXINSTANCES", "MAXLOGFILES", "MAXLOGHISTORY", "MAXLOGMEMBERS", "MAX_SHARED_TEMP_SIZE", + "MAXSIZE", "MAXTRANS", "MAXVALUE", "MEASURE", "MEASURES", "MEDIUM", + "MEMBER", "MEMBER_CAPTION", "MEMBER_DESCRIPTION", "MEMBER_NAME", "MEMBER_UNIQUE_NAME", + "MEMCOMPRESS", "MEMORY", "MERGEACTIONS", "MERGE_AJ", "MERGE_CONST_ON", + "MERGE", "MERGE_SJ", "METADATA", "METHOD", "MIGRATE", "MIGRATION", "MINEXTENTS", + "MINIMIZE", "MINIMUM", "MINING", "MINUS", "MINUS_NULL", "MINUTE", "MINUTES", + "MINVALUE", "MIRRORCOLD", "MIRRORHOT", "MIRROR", "MISSING", "MISMATCH", + "MLSLABEL", "MODEL_COMPILE_SUBQUERY", "MODEL_DONTVERIFY_UNIQUENESS", + "MODEL_DYNAMIC_SUBQUERY", "MODEL_MIN_ANALYSIS", "MODEL", "MODEL_NB", + "MODEL_NO_ANALYSIS", "MODEL_PBY", "MODEL_PUSH_REF", "MODEL_SV", "MODE", + "MODIFICATION", "MODIFY_COLUMN_TYPE", "MODIFY", "MOD", "MODULE", "MONITORING", + "MONITOR", "MONTH", "MONTHS_BETWEEN", "MONTHS", "MOUNT", "MOUNTPATH", + "MOUNTPOINT", "MOVEMENT", "MOVE", "MULTIDIMENSIONAL", "MULTISET", "MV_MERGE", + "NAMED", "NAME", "NAMESPACE", "NAN", "NANVL", "NATIONAL", "NATIVE_FULL_OUTER_JOIN", + "NATIVE", "NATURAL", "NATURALN", "NAV", "NCHAR_CS", "NCHAR", "NCHR", + "NCLOB", "NEEDED", "NEG", "NESTED", "NESTED_TABLE_FAST_INSERT", "NESTED_TABLE_GET_REFS", + "NESTED_TABLE_ID", "NESTED_TABLE_SET_REFS", "NESTED_TABLE_SET_SETID", + "NETWORK", "NEVER", "NEW", "NEW_TIME", "NEXT_DAY", "NEXT", "NL_AJ", + "NLJ_BATCHING", "NLJ_INDEX_FILTER", "NLJ_INDEX_SCAN", "NLJ_PREFETCH", + "NLS_CALENDAR", "NLS_CHARACTERSET", "NLS_CHARSET_DECL_LEN", "NLS_CHARSET_ID", + "NLS_CHARSET_NAME", "NLS_COMP", "NLS_CURRENCY", "NLS_DATE_FORMAT", "NLS_DATE_LANGUAGE", + "NLS_INITCAP", "NLS_ISO_CURRENCY", "NL_SJ", "NLS_LANG", "NLS_LANGUAGE", + "NLS_LENGTH_SEMANTICS", "NLS_LOWER", "NLS_NCHAR_CONV_EXCP", "NLS_NUMERIC_CHARACTERS", + "NLS_SORT", "NLSSORT", "NLS_SPECIAL_CHARS", "NLS_TERRITORY", "NLS_UPPER", + "NO_ACCESS", "NO_ADAPTIVE_PLAN", "NO_ANSI_REARCH", "NOAPPEND", "NOARCHIVELOG", + "NOAUDIT", "NO_AUTO_REOPTIMIZE", "NO_BASETABLE_MULTIMV_REWRITE", "NO_BATCH_TABLE_ACCESS_BY_ROWID", + "NO_BIND_AWARE", "NO_BUFFER", "NOCACHE", "NO_CARTESIAN", "NO_CHECK_ACL_REWRITE", + "NO_CLUSTER_BY_ROWID", "NO_CLUSTERING", "NO_COALESCE_SQ", "NO_COMMON_DATA", + "NOCOMPRESS", "NO_CONNECT_BY_CB_WHR_ONLY", "NO_CONNECT_BY_COMBINE_SW", + "NO_CONNECT_BY_COST_BASED", "NO_CONNECT_BY_ELIM_DUPS", "NO_CONNECT_BY_FILTERING", + "NOCOPY", "NO_COST_XML_QUERY_REWRITE", "NO_CPU_COSTING", "NOCPU_COSTING", + "NOCYCLE", "NO_DATA_SECURITY_REWRITE", "NO_DECORRELATE", "NODELAY", + "NO_DOMAIN_INDEX_FILTER", "NO_DST_UPGRADE_INSERT_CONV", "NO_ELIM_GROUPBY", + "NO_ELIMINATE_JOIN", "NO_ELIMINATE_OBY", "NO_ELIMINATE_OUTER_JOIN", + "NOENTITYESCAPING", "NO_EXPAND_GSET_TO_UNION", "NO_EXPAND", "NO_EXPAND_TABLE", + "NO_FACT", "NO_FACTORIZE_JOIN", "NO_FILTERING", "NOFORCE", "NO_FULL_OUTER_JOIN_TO_OUTER", + "NO_GATHER_OPTIMIZER_STATISTICS", "NO_GBY_PUSHDOWN", "NOGUARANTEE", + "NO_INDEX_FFS", "NO_INDEX", "NO_INDEX_SS", "NO_INMEMORY", "NO_INMEMORY_PRUNING", + "NOKEEP", "NO_LOAD", "NOLOCAL", "NOLOGGING", "NOMAPPING", "NOMAXVALUE", + "NO_MERGE", "NOMINIMIZE", "NOMINVALUE", "NO_MODEL_PUSH_REF", "NO_MONITORING", + "NOMONITORING", "NO_MONITOR", "NO_MULTIMV_REWRITE", "NO_NATIVE_FULL_OUTER_JOIN", + "NONBLOCKING", "NONEDITIONABLE", "NONE", "NO_NLJ_BATCHING", "NO_NLJ_PREFETCH", + "NO", "NONSCHEMA", "NO_OBJECT_LINK", "NOORDER", "NO_ORDER_ROLLUPS", + "NO_OUTER_JOIN_TO_ANTI", "NO_OUTER_JOIN_TO_INNER", "NOOVERRIDE", "NO_PARALLEL_INDEX", + "NOPARALLEL_INDEX", "NO_PARALLEL", "NOPARALLEL", "NO_PARTIAL_COMMIT", + "NO_PARTIAL_JOIN", "NO_PARTIAL_ROLLUP_PUSHDOWN", "NOPARTITION", "NO_PLACE_DISTINCT", + "NO_PLACE_GROUP_BY", "NO_PQ_CONCURRENT_UNION", "NO_PQ_MAP", "NOPROMPT", + "NO_PQ_REPLICATE", "NO_PQ_SKEW", "NO_PRUNE_GSETS", "NO_PULL_PRED", "NO_PUSH_PRED", + "NO_PUSH_SUBQ", "NO_PX_FAULT_TOLERANCE", "NO_PX_JOIN_FILTER", "NO_QKN_BUFF", + "NO_QUERY_TRANSFORMATION", "NO_REF_CASCADE", "NORELOCATE", "NORELY", + "NOREPAIR", "NOREPLAY", "NORESETLOGS", "NO_RESULT_CACHE", "NOREVERSE", + "NO_REWRITE", "NOREWRITE", "NORMAL", "NO_ROOT_SW_FOR_LOCAL", "NOROWDEPENDENCIES", + "NOSCHEMACHECK", "NOSEGMENT", "NO_SEMIJOIN", "NO_SEMI_TO_INNER", "NO_SET_TO_JOIN", + "NOSORT", "NO_SQL_TRANSLATION", "NO_SQL_TUNE", "NO_STAR_TRANSFORMATION", + "NO_STATEMENT_QUEUING", "NO_STATS_GSETS", "NOSTRICT", "NO_SUBQUERY_PRUNING", + "NO_SUBSTRB_PAD", "NO_SWAP_JOIN_INPUTS", "NOSWITCH", "NO_TABLE_LOOKUP_BY_NL", + "NO_TEMP_TABLE", "NOTHING", "NOTIFICATION", "NOT", "NO_TRANSFORM_DISTINCT_AGG", + "NO_UNNEST", "NO_USE_CUBE", "NO_USE_HASH_AGGREGATION", "NO_USE_HASH_GBY_FOR_PUSHDOWN", + "NO_USE_HASH", "NO_USE_INVISIBLE_INDEXES", "NO_USE_MERGE", "NO_USE_NL", + "NO_USE_VECTOR_AGGREGATION", "NOVALIDATE", "NO_VECTOR_TRANSFORM_DIMS", + "NO_VECTOR_TRANSFORM_FACT", "NO_VECTOR_TRANSFORM", "NOWAIT", "NO_XDB_FASTPATH_INSERT", + "NO_XML_DML_REWRITE", "NO_XMLINDEX_REWRITE_IN_SELECT", "NO_XMLINDEX_REWRITE", + "NO_XML_QUERY_REWRITE", "NO_ZONEMAP", "NTH_VALUE", "NULLIF", "NULL_", + "NULLS", "NUMBER", "NUMERIC", "NUM_INDEX_KEYS", "NUMTODSINTERVAL", "NUMTOYMINTERVAL", + "NVARCHAR2", "NVL2", "OBJECT2XML", "OBJECT", "OBJ_ID", "OBJNO", "OBJNO_REUSE", + "OCCURENCES", "OFFLINE", "OFF", "OFFSET", "OF", "OIDINDEX", "OID", "OLAP", + "OLD", "OLD_PUSH_PRED", "OLS", "OLTP", "OMIT", "ONE", "ONLINE", "ONLY", + "ON", "OPAQUE", "OPAQUE_TRANSFORM", "OPAQUE_XCANONICAL", "OPCODE", "OPEN", + "OPERATIONS", "OPERATOR", "OPT_ESTIMATE", "OPTIMAL", "OPTIMIZE", "OPTIMIZER_FEATURES_ENABLE", + "OPTIMIZER_GOAL", "OPTION", "OPT_PARAM", "ORA_BRANCH", "ORA_CHECK_ACL", + "ORA_CHECK_PRIVILEGE", "ORA_CLUSTERING", "ORADATA", "ORADEBUG", "ORA_DST_AFFECTED", + "ORA_DST_CONVERT", "ORA_DST_ERROR", "ORA_GET_ACLIDS", "ORA_GET_PRIVILEGES", + "ORA_HASH", "ORA_INVOKING_USERID", "ORA_INVOKING_USER", "ORA_INVOKING_XS_USER_GUID", + "ORA_INVOKING_XS_USER", "ORA_RAWCOMPARE", "ORA_RAWCONCAT", "ORA_ROWSCN", + "ORA_ROWSCN_RAW", "ORA_ROWVERSION", "ORA_TABVERSION", "ORA_WRITE_TIME", + "ORDERED", "ORDERED_PREDICATES", "ORDER", "ORDINALITY", "OR_EXPAND", + "ORGANIZATION", "OR", "OR_PREDICATES", "OSERROR", "OTHER", "OUTER_JOIN_TO_ANTI", + "OUTER_JOIN_TO_INNER", "OUTER", "OUTLINE_LEAF", "OUTLINE", "OUT_OF_LINE", + "OUT", "OVERFLOW_NOMOVE", "OVERFLOW", "OVERLAPS", "OVER", "OVERRIDING", + "OWNER", "OWNERSHIP", "OWN", "P_LETTER", "PACKAGE", "PACKAGES", "PARALLEL_ENABLE", + "PARALLEL_INDEX", "PARALLEL", "PARAMETERS", "PARAM", "PARENT", "PARENT_LEVEL_NAME", + "PARENT_UNIQUE_NAME", "PARITY", "PARTIAL_JOIN", "PARTIALLY", "PARTIAL", + "PARTIAL_ROLLUP_PUSHDOWN", "PARTITION_HASH", "PARTITION_LIST", "PARTITION", + "PARTITION_RANGE", "PARTITIONS", "PARTNUMINST", "PASSING", "PASSWORD_GRACE_TIME", + "PASSWORD_LIFE_TIME", "PASSWORD_LOCK_TIME", "PASSWORD", "PASSWORD_REUSE_MAX", + "PASSWORD_REUSE_TIME", "PASSWORD_ROLLOVER_TIME", "PASSWORD_VERIFY_FUNCTION", + "PAST", "PATCH", "PATH", "PATH_PREFIX", "PATHS", "PATTERN", "PBL_HS_BEGIN", + "PBL_HS_END", "PCTFREE", "PCTINCREASE", "PCTTHRESHOLD", "PCTUSED", "PCTVERSION", + "PENDING", "PERCENT_FOUND", "PERCENT_ISOPEN", "PERCENT_NOTFOUND", "PERCENT_KEYWORD", + "PERCENT_RANKM", "PERCENT_ROWCOUNT", "PERCENT_ROWTYPE", "PERCENT_TYPE", + "PERFORMANCE", "PERIOD_KEYWORD", "PERMANENT", "PERMISSION", "PERMUTE", + "PER", "PFILE", "PHYSICAL", "PIKEY", "PIPELINED", "PIPE", "PIV_GB", + "PIVOT", "PIV_SSF", "PLACE_DISTINCT", "PLACE_GROUP_BY", "PLAN", "PLSCOPE_SETTINGS", + "PLS_INTEGER", "PLSQL_CCFLAGS", "PLSQL_CODE_TYPE", "PLSQL_DEBUG", "PLSQL_OPTIMIZE_LEVEL", + "PLSQL_WARNINGS", "PLUGGABLE", "PMEM", "POINT", "POLICY", "POOL_16K", + "POOL_2K", "POOL_32K", "POOL_4K", "POOL_8K", "POSITIVEN", "POSITIVE", + "POST_TRANSACTION", "POWERMULTISET_BY_CARDINALITY", "POWERMULTISET", + "POWER", "PQ_CONCURRENT_UNION", "PQ_DISTRIBUTE", "PQ_DISTRIBUTE_WINDOW", + "PQ_FILTER", "PQ_MAP", "PQ_NOMAP", "PQ_REPLICATE", "PQ_SKEW", "PRAGMA", + "PREBUILT", "PRECEDES", "PRECEDING", "PRECISION", "PRECOMPUTE_SUBQUERY", + "PREDICATE_REORDERS", "PRELOAD", "PREPARE", "PRESENTNNV", "PRESENT", + "PRESENTV", "PRESERVE_OID", "PRESERVE", "PRETTY", "PREVIOUS", "PREV", + "PRIMARY", "PRINTBLOBTOCLOB", "PRIORITY", "PRIOR", "PRIVATE", "PRIVATE_SGA", + "PRIVILEGED", "PRIVILEGE", "PRIVILEGES", "PROCEDURAL", "PROCEDURE", + "PROCESS", "PROFILE", "PROGRAM", "PROJECT", "PROPAGATE", "PROPERTY", + "PROTECTED", "PROTECTION", "PROTOCOL", "PROXY", "PRUNING", "PUBLIC", + "PULL_PRED", "PURGE", "PUSH_PRED", "PUSH_SUBQ", "PX_FAULT_TOLERANCE", + "PX_GRANULE", "PX_JOIN_FILTER", "QB_NAME", "QUARTERS", "QUERY_BLOCK", + "QUERY", "QUEUE_CURR", "QUEUE", "QUEUE_ROWP", "QUIESCE", "QUORUM", "QUOTA", + "QUOTAGROUP", "RAISE", "RANDOM_LOCAL", "RANDOM", "RANGE", "RANKM", "RAPIDLY", + "RAW", "RAWTOHEX", "RAWTONHEX", "RBA", "RBO_OUTLINE", "RDBA", "READ", + "READS", "REALM", "REAL", "REBALANCE", "REBUILD", "RECORD", "RECORDS_PER_BLOCK", + "RECOVERABLE", "RECOVER", "RECOVERY", "RECYCLEBIN", "RECYCLE", "REDACTION", + "REDEFINE", "REDO", "REDUCED", "REDUNDANCY", "REF_CASCADE_CURSOR", "REFERENCED", + "REFERENCE", "REFERENCES", "REFERENCING", "REF", "REFRESH", "REFTOHEX", + "REGEXP_COUNT", "REGEXP_INSTR", "REGEXP_LIKE", "REGEXP_REPLACE", "REGEXP_SUBSTR", + "REGISTER", "REGR_AVGX", "REGR_AVGY", "REGR_COUNT", "REGR_INTERCEPT", + "REGR_R2", "REGR_SLOPE", "REGR_SXX", "REGR_SXY", "REGR_SYY", "REGULAR", + "REJECT", "REKEY", "RELATIONAL", "RELIES_ON", "RELOCATE", "RELY", "REMAINDER", + "REMOTE", "REMOTE_MAPPED", "REMOVE", "RENAME", "REPAIR", "REPEAT", "REPLACE", + "REPLICATION", "REQUIRED", "RESETLOGS", "RESET", "RESIZE", "RESOLVE", + "RESOLVER", "RESOURCE", "RESPECT", "RESTART", "RESTORE_AS_INTERVALS", + "RESTORE", "RESTRICT_ALL_REF_CONS", "RESTRICTED", "RESTRICT_REFERENCES", + "RESTRICT", "RESULT_CACHE", "RESULT", "RESUMABLE", "RESUME", "RETENTION", + "RETRY_ON_ROW_CHANGE", "RETURNING", "RETURN", "REUSE", "REVERSE", "REVOKE", + "REWRITE_OR_ERROR", "REWRITE", "RIGHT", "ROLE", "ROLESET", "ROLES", + "ROLLBACK", "ROLLING", "ROLLUP", "ROWDEPENDENCIES", "ROWID_MAPPING_TABLE", + "ROWID", "ROWIDTOCHAR", "ROWIDTONCHAR", "ROW_LENGTH", "ROWNUM", "ROW", + "ROWS", "RPAD", "RTRIM", "RULE", "RULES", "RUNNING", "SALT", "SAMPLE", + "SAVE_AS_INTERVALS", "SAVEPOINT", "SAVE", "SB4", "SCALE_ROWS", "SCALE", + "SCAN_INSTANCES", "SCAN", "SCHEDULER", "SCHEMACHECK", "SCHEMA", "SCN_ASCENDING", + "SCN", "SCOPE", "SCRUB", "SD_ALL", "SD_INHIBIT", "SDO_GEOM_MBR", "SDO_GEOMETRY", + "SD_SHOW", "SEARCH", "SECOND", "SECONDS", "SECRET", "SECUREFILE_DBA", + "SECUREFILE", "SECURITY", "SEED", "SEG_BLOCK", "SEG_FILE", "SEGMENT", + "SELECTIVITY", "SELECT", "SELF", "SEMIJOIN_DRIVER", "SEMIJOIN", "SEMI_TO_INNER", + "SEQUENCED", "SEQUENCE", "SEQUENTIAL", "SERIALIZABLE", "SERIALLY_REUSABLE", + "SERIAL", "SERVERERROR", "SERVICE_NAME_CONVERT", "SERVICE", "SERVICES", + "SESSION_CACHED_CURSORS", "SESSION", "SESSIONS_PER_USER", "SESSIONTIMEZONE", + "SESSIONTZNAME", "SET", "SETS", "SETTINGS", "SET_TO_JOIN", "SEVERE", + "SHARDSPACE", "SHARED_POOL", "SHARED", "SHARE", "SHARING", "SHELFLIFE", + "SHOW", "SHRINK", "SHUTDOWN", "SIBLINGS", "SID", "SITE", "SIGNAL_COMPONENT", + "SIGNAL_FUNCTION", "SIGN", "SIGNTYPE", "SIMPLE_INTEGER", "SIMPLE", "SINGLE", + "SINGLETASK", "SINH", "SIN", "SIZE", "SKIP_EXT_OPTIMIZER", "SKIP_", + "SKIP_UNQ_UNUSABLE_IDX", "SKIP_UNUSABLE_INDEXES", "SMALLFILE", "SMALLINT", + "SNAPSHOT", "SOME", "SORT", "SOUNDEX", "SOURCE_FILE_DIRECTORY", "SOURCE_FILE_NAME_CONVERT", + "SOURCE", "SPACE_KEYWORD", "SPECIFICATION", "SPFILE", "SPLIT", "SPREADSHEET", + "SQLDATA", "SQLERROR", "SQLLDR", "SQL", "SQL_MACRO", "SQL_TRACE", "SQL_TRANSLATION_PROFILE", + "SQRT", "STALE", "STANDALONE", "STANDARD", "STANDARD_HASH", "STANDBY_MAX_DATA_DELAY", + "STANDBYS", "STANDBY", "STAR", "STAR_TRANSFORMATION", "START", "STARTUP", + "STATEMENT_ID", "STATEMENT_QUEUING", "STATEMENTS", "STATEMENT", "STATE", + "STATIC", "STATISTICS", "STATS_BINOMIAL_TEST", "STATS_CROSSTAB", "STATS_F_TEST", + "STATS_KS_TEST", "STATS_MODE", "STATS_MW_TEST", "STATS_ONE_WAY_ANOVA", + "STATS_T_TEST_INDEP", "STATS_T_TEST_INDEPU", "STATS_T_TEST_ONE", "STATS_T_TEST_PAIRED", + "STATS_WSR_TEST", "STDDEV_POP", "STDDEV_SAMP", "STOP", "STORAGE", "STORE", + "STREAMS", "STREAM", "STRICT", "STRING", "STRIPE_COLUMNS", "STRIPE_WIDTH", + "STRIP", "STRUCTURE", "SUBMULTISET", "SUBPARTITION_REL", "SUBPARTITIONS", + "SUBPARTITION", "SUBQUERIES", "SUBQUERY_PRUNING", "SUBSCRIBE", "SUBSET", + "SUBSTITUTABLE", "SUBSTR2", "SUBSTR4", "SUBSTRB", "SUBSTRC", "SUBTYPE", + "SUCCESSFUL", "SUCCESS", "SUMMARY", "SUPPLEMENTAL", "SUSPEND", "SWAP_JOIN_INPUTS", + "SWITCHOVER", "SWITCH", "SYNCHRONOUS", "SYNC", "SYNONYM", "SYS", "SYSASM", + "SYS_AUDIT", "SYSAUX", "SYSBACKUP", "SYS_CHECKACL", "SYS_CHECK_PRIVILEGE", + "SYS_CONNECT_BY_PATH", "SYS_CONTEXT", "SYSDATE", "SYSDBA", "SYS_DBURIGEN", + "SYSDG", "SYS_DL_CURSOR", "SYS_DM_RXFORM_CHR", "SYS_DM_RXFORM_NUM", + "SYS_DOM_COMPARE", "SYS_DST_PRIM2SEC", "SYS_DST_SEC2PRIM", "SYS_ET_BFILE_TO_RAW", + "SYS_ET_BLOB_TO_IMAGE", "SYS_ET_IMAGE_TO_BLOB", "SYS_ET_RAW_TO_BFILE", + "SYS_EXTPDTXT", "SYS_EXTRACT_UTC", "SYS_FBT_INSDEL", "SYS_FILTER_ACLS", + "SYS_FNMATCHES", "SYS_FNREPLACE", "SYS_GET_ACLIDS", "SYS_GET_COL_ACLIDS", + "SYS_GET_PRIVILEGES", "SYS_GETTOKENID", "SYS_GETXTIVAL", "SYS_GUID", + "SYSGUID", "SYSKM", "SYS_MAKE_XMLNODEID", "SYS_MAKEXML", "SYS_MKXMLATTR", + "SYS_MKXTI", "SYSOBJ", "SYS_OP_ADT2BIN", "SYS_OP_ADTCONS", "SYS_OP_ALSCRVAL", + "SYS_OP_ATG", "SYS_OP_BIN2ADT", "SYS_OP_BITVEC", "SYS_OP_BL2R", "SYS_OP_BLOOM_FILTER_LIST", + "SYS_OP_BLOOM_FILTER", "SYS_OP_C2C", "SYS_OP_CAST", "SYS_OP_CEG", "SYS_OP_CL2C", + "SYS_OP_COMBINED_HASH", "SYS_OP_COMP", "SYS_OP_CONVERT", "SYS_OP_COUNTCHG", + "SYS_OP_CSCONV", "SYS_OP_CSCONVTEST", "SYS_OP_CSR", "SYS_OP_CSX_PATCH", + "SYS_OP_CYCLED_SEQ", "SYS_OP_DECOMP", "SYS_OP_DESCEND", "SYS_OP_DISTINCT", + "SYS_OP_DRA", "SYS_OP_DUMP", "SYS_OP_DV_CHECK", "SYS_OP_ENFORCE_NOT_NULL", + "SYSOPER", "SYS_OP_EXTRACT", "SYS_OP_GROUPING", "SYS_OP_GUID", "SYS_OP_HASH", + "SYS_OP_IIX", "SYS_OP_ITR", "SYS_OP_KEY_VECTOR_CREATE", "SYS_OP_KEY_VECTOR_FILTER_LIST", + "SYS_OP_KEY_VECTOR_FILTER", "SYS_OP_KEY_VECTOR_SUCCEEDED", "SYS_OP_KEY_VECTOR_USE", + "SYS_OP_LBID", "SYS_OP_LOBLOC2BLOB", "SYS_OP_LOBLOC2CLOB", "SYS_OP_LOBLOC2ID", + "SYS_OP_LOBLOC2NCLOB", "SYS_OP_LOBLOC2TYP", "SYS_OP_LSVI", "SYS_OP_LVL", + "SYS_OP_MAKEOID", "SYS_OP_MAP_NONNULL", "SYS_OP_MSR", "SYS_OP_NICOMBINE", + "SYS_OP_NIEXTRACT", "SYS_OP_NII", "SYS_OP_NIX", "SYS_OP_NOEXPAND", "SYS_OP_NTCIMG", + "SYS_OP_NUMTORAW", "SYS_OP_OIDVALUE", "SYS_OP_OPNSIZE", "SYS_OP_PAR_1", + "SYS_OP_PARGID_1", "SYS_OP_PARGID", "SYS_OP_PAR", "SYS_OP_PART_ID", + "SYS_OP_PIVOT", "SYS_OP_R2O", "SYS_OP_RAWTONUM", "SYS_OP_RDTM", "SYS_OP_REF", + "SYS_OP_RMTD", "SYS_OP_ROWIDTOOBJ", "SYS_OP_RPB", "SYS_OPTLOBPRBSC", + "SYS_OP_TOSETID", "SYS_OP_TPR", "SYS_OP_TRTB", "SYS_OPTXICMP", "SYS_OPTXQCASTASNQ", + "SYS_OP_UNDESCEND", "SYS_OP_VECAND", "SYS_OP_VECBIT", "SYS_OP_VECOR", + "SYS_OP_VECXOR", "SYS_OP_VERSION", "SYS_OP_VREF", "SYS_OP_VVD", "SYS_OP_XMLCONS_FOR_CSX", + "SYS_OP_XPTHATG", "SYS_OP_XPTHIDX", "SYS_OP_XPTHOP", "SYS_OP_XTXT2SQLT", + "SYS_OP_ZONE_ID", "SYS_ORDERKEY_DEPTH", "SYS_ORDERKEY_MAXCHILD", "SYS_ORDERKEY_PARENT", + "SYS_PARALLEL_TXN", "SYS_PATHID_IS_ATTR", "SYS_PATHID_IS_NMSPC", "SYS_PATHID_LASTNAME", + "SYS_PATHID_LASTNMSPC", "SYS_PATH_REVERSE", "SYS_PXQEXTRACT", "SYS_RAW_TO_XSID", + "SYS_RID_ORDER", "SYS_ROW_DELTA", "SYS_SC_2_XMLT", "SYS_SYNRCIREDO", + "SYSTEM_DEFINED", "SYSTEM", "SYSTIMESTAMP", "SYS_TYPEID", "SYS_UMAKEXML", + "SYS_XMLANALYZE", "SYS_XMLCONTAINS", "SYS_XMLCONV", "SYS_XMLEXNSURI", + "SYS_XMLGEN", "SYS_XMLI_LOC_ISNODE", "SYS_XMLI_LOC_ISTEXT", "SYS_XMLINSTR", + "SYS_XMLLOCATOR_GETSVAL", "SYS_XMLNODEID_GETCID", "SYS_XMLNODEID_GETLOCATOR", + "SYS_XMLNODEID_GETOKEY", "SYS_XMLNODEID_GETPATHID", "SYS_XMLNODEID_GETPTRID", + "SYS_XMLNODEID_GETRID", "SYS_XMLNODEID_GETSVAL", "SYS_XMLNODEID_GETTID", + "SYS_XMLNODEID", "SYS_XMLT_2_SC", "SYS_XMLTRANSLATE", "SYS_XMLTYPE2SQL", + "SYS_XQ_ASQLCNV", "SYS_XQ_ATOMCNVCHK", "SYS_XQBASEURI", "SYS_XQCASTABLEERRH", + "SYS_XQCODEP2STR", "SYS_XQCODEPEQ", "SYS_XQCON2SEQ", "SYS_XQCONCAT", + "SYS_XQDELETE", "SYS_XQDFLTCOLATION", "SYS_XQDOC", "SYS_XQDOCURI", "SYS_XQDURDIV", + "SYS_XQED4URI", "SYS_XQENDSWITH", "SYS_XQERRH", "SYS_XQERR", "SYS_XQESHTMLURI", + "SYS_XQEXLOBVAL", "SYS_XQEXSTWRP", "SYS_XQEXTRACT", "SYS_XQEXTRREF", + "SYS_XQEXVAL", "SYS_XQFB2STR", "SYS_XQFNBOOL", "SYS_XQFNCMP", "SYS_XQFNDATIM", + "SYS_XQFNLNAME", "SYS_XQFNNM", "SYS_XQFNNSURI", "SYS_XQFNPREDTRUTH", + "SYS_XQFNQNM", "SYS_XQFNROOT", "SYS_XQFORMATNUM", "SYS_XQFTCONTAIN", + "SYS_XQFUNCR", "SYS_XQGETCONTENT", "SYS_XQINDXOF", "SYS_XQINSERT", "SYS_XQINSPFX", + "SYS_XQIRI2URI", "SYS_XQLANG", "SYS_XQLLNMFRMQNM", "SYS_XQMKNODEREF", + "SYS_XQNILLED", "SYS_XQNODENAME", "SYS_XQNORMSPACE", "SYS_XQNORMUCODE", + "SYS_XQ_NRNG", "SYS_XQNSP4PFX", "SYS_XQNSPFRMQNM", "SYS_XQPFXFRMQNM", + "SYS_XQ_PKSQL2XML", "SYS_XQPOLYABS", "SYS_XQPOLYADD", "SYS_XQPOLYCEL", + "SYS_XQPOLYCSTBL", "SYS_XQPOLYCST", "SYS_XQPOLYDIV", "SYS_XQPOLYFLR", + "SYS_XQPOLYMOD", "SYS_XQPOLYMUL", "SYS_XQPOLYRND", "SYS_XQPOLYSQRT", + "SYS_XQPOLYSUB", "SYS_XQPOLYUMUS", "SYS_XQPOLYUPLS", "SYS_XQPOLYVEQ", + "SYS_XQPOLYVGE", "SYS_XQPOLYVGT", "SYS_XQPOLYVLE", "SYS_XQPOLYVLT", + "SYS_XQPOLYVNE", "SYS_XQREF2VAL", "SYS_XQRENAME", "SYS_XQREPLACE", "SYS_XQRESVURI", + "SYS_XQRNDHALF2EVN", "SYS_XQRSLVQNM", "SYS_XQRYENVPGET", "SYS_XQRYVARGET", + "SYS_XQRYWRP", "SYS_XQSEQ2CON4XC", "SYS_XQSEQ2CON", "SYS_XQSEQDEEPEQ", + "SYS_XQSEQINSB", "SYS_XQSEQRM", "SYS_XQSEQRVS", "SYS_XQSEQSUB", "SYS_XQSEQTYPMATCH", + "SYS_XQSTARTSWITH", "SYS_XQSTATBURI", "SYS_XQSTR2CODEP", "SYS_XQSTRJOIN", + "SYS_XQSUBSTRAFT", "SYS_XQSUBSTRBEF", "SYS_XQTOKENIZE", "SYS_XQTREATAS", + "SYS_XQ_UPKXML2SQL", "SYS_XQXFORM", "SYS_XSID_TO_RAW", "SYS_ZMAP_FILTER", + "SYS_ZMAP_REFRESH", "T_LETTER", "TABLE_LOOKUP_BY_NL", "TABLESPACE_NO", + "TABLESPACE", "TABLES", "TABLE_STATS", "TABLE", "TABNO", "TAG", "TANH", + "TAN", "TBLORIDXPARTNUM", "TEMPFILE", "TEMPLATE", "TEMPORARY", "TEMP_TABLE", + "TEST", "TEXT", "THAN", "THEN", "THE", "THREAD", "THROUGH", "TIER", + "TIES", "TIMEOUT", "TIMESTAMP_LTZ_UNCONSTRAINED", "TIMESTAMP", "TIMESTAMP_TZ_UNCONSTRAINED", + "TIMESTAMP_UNCONSTRAINED", "TIMES", "TIME", "TIMEZONE", "TIMEZONE_ABBR", + "TIMEZONE_HOUR", "TIMEZONE_MINUTE", "TIMEZONE_OFFSET", "TIMEZONE_REGION", + "TIME_ZONE", "TIMING", "TIV_GB", "TIV_SSF", "TO_ACLID", "TO_BINARY_DOUBLE", + "TO_BINARY_FLOAT", "TO_BLOB", "TO_CLOB", "TO_DSINTERVAL", "TO_LOB", + "TO_MULTI_BYTE", "TO_NCHAR", "TO_NCLOB", "TO_NUMBER", "TOPLEVEL", "TO_SINGLE_BYTE", + "TO_TIMESTAMP", "TO_TIMESTAMP_TZ", "TO_TIME", "TO_TIME_TZ", "TO", "TO_YMINTERVAL", + "TRACE", "TRACING", "TRACKING", "TRAILING", "TRANSACTION", "TRANSFORM", + "TRANSFORM_DISTINCT_AGG", "TRANSITIONAL", "TRANSITION", "TRANSLATE", + "TRANSLATION", "TREAT", "TRIGGERS", "TRIGGER", "TRUE", "TRUNCATE", "TRUNC", + "TRUSTED", "TRUST", "TUNING", "TX", "TYPES", "TYPE", "TZ_OFFSET", "UB2", + "UBA", "UCS2", "UID", "UNARCHIVED", "UNBOUNDED", "UNBOUND", "UNCONDITIONAL", + "UNDER", "UNDO", "UNDROP", "UNIFORM", "UNION", "UNIQUE", "UNISTR", "UNLIMITED", + "UNLOAD", "UNLOCK", "UNMATCHED", "UNNEST_INNERJ_DISTINCT_VIEW", "UNNEST_NOSEMIJ_NODISTINCTVIEW", + "UNNEST_SEMIJ_VIEW", "UNNEST", "UNPACKED", "UNPIVOT", "UNPLUG", "UNPROTECTED", + "UNQUIESCE", "UNRECOVERABLE", "UNRESTRICTED", "UNSUBSCRIBE", "UNTIL", + "UNUSABLE", "UNUSED", "UPDATABLE", "UPDATED", "UPDATE", "UPDATEXML", + "UPD_INDEXES", "UPD_JOININDEX", "UPGRADE", "UPPER", "UPSERT", "UROWID", + "USABLE", "USAGE", "USE_ANTI", "USE_CONCAT", "USE_CUBE", "USE_HASH_AGGREGATION", + "USE_HASH_GBY_FOR_PUSHDOWN", "USE_HASH", "USE_HIDDEN_PARTITIONS", "USE_INVISIBLE_INDEXES", + "USE_MERGE_CARTESIAN", "USE_MERGE", "USE_NL", "USE_NL_WITH_INDEX", "USE_PRIVATE_OUTLINES", + "USER_DATA", "USER_DEFINED", "USERENV", "USERGROUP", "USER_RECYCLEBIN", + "USERS", "USER_TABLESPACES", "USER", "USE_SEMI", "USE_STORED_OUTLINES", + "USE_TTT_FOR_GSETS", "USE", "USE_VECTOR_AGGREGATION", "USE_WEAK_NAME_RESL", + "USING_NO_EXPAND", "USING", "UTF16BE", "UTF16LE", "UTF32", "UTF8", "V1", + "V2", "VALIDATE", "VALIDATE_CONVERSION", "VALIDATION", "VALID_TIME_END", + "VALUES", "VALUE", "VARCHAR2", "VARCHAR", "VARIABLE", "VAR_POP", "VARRAYS", + "VARRAY", "VAR_SAMP", "VARYING", "VECTOR_READ_TRACE", "VECTOR_READ", + "VECTOR_TRANSFORM_DIMS", "VECTOR_TRANSFORM_FACT", "VECTOR_TRANSFORM", + "VERIFIER", "VERIFY", "VERSIONING", "VERSIONS_ENDSCN", "VERSIONS_ENDTIME", + "VERSIONS_OPERATION", "VERSIONS_STARTSCN", "VERSIONS_STARTTIME", "VERSIONS", + "VERSIONS_XID", "VERSION", "VIEW", "VIOLATION", "VIRTUAL", "VISIBILITY", + "VISIBLE", "VOLUME", "VSIZE", "WAIT", "WALLET", "WARNING", "WEEKS", + "WEEK", "WELLFORMED", "WHENEVER", "WHEN", "WHERE", "WHILE", "WHITESPACE", + "WIDTH_BUCKET", "WITHIN", "WITHOUT", "WITH_PLSQL", "WITH", "WORK", "WRAPPED", + "WRAPPER", "WRITE", "XDB_FASTPATH_INSERT", "XDB", "X_DYN_PRUNE", "XID", + "XML2OBJECT", "XMLAGG", "XMLATTRIBUTES", "XMLCAST", "XMLCDATA", "XMLCOLATTVAL", + "XMLCOMMENT", "XMLCONCAT", "XMLDIFF", "XML_DML_RWT_STMT", "XMLELEMENT", + "XMLEXISTS2", "XMLEXISTS", "XMLFOREST", "XMLINDEX", "XMLINDEX_REWRITE_IN_SELECT", + "XMLINDEX_REWRITE", "XMLINDEX_SEL_IDX_TBL", "XMLISNODE", "XMLISVALID", + "XMLNAMESPACES", "XMLPARSE", "XMLPATCH", "XMLPI", "XMLQUERYVAL", "XMLQUERY", + "XMLROOT", "XMLSCHEMA", "XMLSERIALIZE", "XMLTABLE", "XMLTRANSFORMBLOB", + "XMLTRANSFORM", "XMLTYPE", "XML", "XPATHTABLE", "XS_SYS_CONTEXT", "XS", + "YEARS", "YEAR", "YES", "YMINTERVAL_UNCONSTRAINED", "ZONEMAP", "ZONE", + "PREDICTION", "PREDICTION_BOUNDS", "PREDICTION_COST", "PREDICTION_DETAILS", + "PREDICTION_PROBABILITY", "PREDICTION_SET", "BLOCKCHAIN", "COLLATE", + "COLLATION", "DEFINITION", "DUPLICATED", "EXTENDED", "HASHING", "IDLE", + "IMMUTABLE", "ORACLE_DATAPUMP", "ORACLE_HDFS", "ORACLE_HIVE", "ORACLE_LOADER", + "SHA2_512_Q", "SHARDED", "V1_Q", "ISOLATE", "ROOT", "UNITE", "ALGORITHM", + "CUME_DIST", "DENSE_RANK", "LISTAGG", "PERCENT_RANK", "PERCENTILE_CONT", + "PERCENTILE_DISC", "RANK", "AVG", "CORR", "COVAR_", "DECODE", "LAG", + "LAG_DIFF", "LAG_DIFF_PERCENT", "LEAD", "MAX", "MEDIAN", "MEMOPTIMIZE", + "MIN", "NTILE", "NVL", "RATIO_TO_REPORT", "REGR_", "ROUND", "ROW_NUMBER", + "SUBSTR", "TO_CHAR", "TRIM", "SUM", "STDDEV", "VAR_", "VARIANCE", "LEAST", + "GREATEST", "TO_DATE", "DEFAULTIF", "LLS", "ENCLOSED", "TERMINATED", + "OPTIONALLY", "LRTRIM", "NOTRIM", "LDRTRIM", "DATE_FORMAT", "MASK", + "TRANSFORMS", "LOBFILE", "STARTOF", "CHARACTERSET", "RECORDS", "FIXED", + "DELIMITED", "XMLTAG", "PREPROCESSOR", "TERRITORY", "LITTLE", "BIG", + "ENDIAN", "BYTEORDERMARK", "NOCHECK", "SIZES", "ARE", "BYTES", "CHARACTERS", + "READSIZE", "DISABLE_DIRECTORY_LINK_CHECK", "DATE_CACHE", "FIELD_NAMES", + "FILES", "IO_OPTIONS", "DIRECTIO", "NODIRECTIO", "DNFS_ENABLE", "DNFS_DISABLE", + "DNFS_READBUFFERS", "NOBADFILE", "BADFILE", "NODISCARDFILE", "DISCARDFILE", + "NOLOGFILE", "FIELDS", "IGNORE_CHARS_AFTER_EOR", "CSV", "EMBEDDED", + "OVERRIDE", "THESE", "FIELD", "NONULLIF", "POSITION", "NEWLINE_", "DETECTED", + "UNSIGNED", "ZONED", "ORACLE_DATE", "ORACLE_NUMBER", "COUNTED", "VARRAW", + "VARCHARC", "VARRAWC", "NATIONAL_CHAR_STRING_LIT", "BIT_STRING_LIT", + "HEX_STRING_LIT", "DOUBLE_PERIOD", "PERIOD", "UNSIGNED_INTEGER", "APPROXIMATE_NUM_LIT", + "CHAR_STRING", "DELIMITED_ID", "PERCENT", "AMPERSAND", "LEFT_PAREN", + "RIGHT_PAREN", "DOUBLE_ASTERISK", "ASTERISK", "PLUS_SIGN", "MINUS_SIGN", + "COMMA", "SOLIDUS", "AT_SIGN", "ASSIGN_OP", "HASH_OP", "SQ", "BINDVAR", + "NOT_EQUAL_OP", "CARRET_OPERATOR_PART", "TILDE_OPERATOR_PART", "EXCLAMATION_OPERATOR_PART", + "GREATER_THAN_OP", "LESS_THAN_OP", "COLON", "SEMICOLON", "BAR", "EQUALS_OP", + "LEFT_BRACKET", "RIGHT_BRACKET", "INTRODUCER", "SINGLE_LINE_COMMENT", + "MULTI_LINE_COMMENT", "REMARK_COMMENT", "PROMPT_MESSAGE", "START_CMD", + "REGULAR_ID", "SPACES", + } + staticData.RuleNames = []string{ + "sql_script", "unit_statement", "alter_diskgroup", "add_disk_clause", + "drop_disk_clause", "resize_disk_clause", "replace_disk_clause", "wait_nowait", + "rename_disk_clause", "disk_online_clause", "disk_offline_clause", "timeout_clause", + "rebalance_diskgroup_clause", "phase", "check_diskgroup_clause", "diskgroup_template_clauses", + "qualified_template_clause", "redundancy_clause", "striping_clause", + "force_noforce", "diskgroup_directory_clauses", "dir_name", "diskgroup_alias_clauses", + "diskgroup_volume_clauses", "add_volume_clause", "modify_volume_clause", + "diskgroup_attributes", "modify_diskgroup_file", "disk_region_clause", + "drop_diskgroup_file_clause", "convert_redundancy_clause", "usergroup_clauses", + "user_clauses", "file_permissions_clause", "file_owner_clause", "scrub_clause", + "quotagroup_clauses", "property_name", "property_value", "filegroup_clauses", + "add_filegroup_clause", "modify_filegroup_clause", "move_to_filegroup_clause", + "drop_filegroup_clause", "quorum_regular", "undrop_disk_clause", "diskgroup_availability", + "enable_disable_volume", "drop_function", "alter_flashback_archive", + "alter_hierarchy", "alter_function", "alter_java", "match_string", "create_function_body", + "sql_macro_body", "parallel_enable_clause", "partition_by_clause", "result_cache_clause", + "relies_on_part", "streaming_clause", "alter_outline", "outline_options", + "alter_lockdown_profile", "lockdown_feature", "lockdown_options", "lockdown_statements", + "statement_clauses", "clause_options", "option_values", "string_list", + "disable_enable", "drop_lockdown_profile", "drop_package", "alter_package", + "create_package", "create_package_body", "package_obj_spec", "procedure_spec", + "function_spec", "package_obj_body", "alter_pmem_filestore", "drop_pmem_filestore", + "drop_procedure", "alter_procedure", "function_body", "procedure_body", + "create_procedure_body", "alter_resource_cost", "drop_outline", "alter_rollback_segment", + "drop_restore_point", "drop_rollback_segment", "drop_role", "create_pmem_filestore", + "pmem_filestore_options", "file_path", "create_rollback_segment", "drop_trigger", + "alter_trigger", "create_trigger", "trigger_follows_clause", "trigger_when_clause", + "simple_dml_trigger", "for_each_row", "compound_dml_trigger", "non_dml_trigger", + "trigger_body", "routine_clause", "compound_trigger_block", "timing_point_section", + "non_dml_event", "dml_event_clause", "dml_event_element", "dml_event_nested_clause", + "referencing_clause", "referencing_element", "drop_type", "alter_type", + "compile_type_clause", "replace_type_clause", "alter_method_spec", "alter_method_element", + "alter_attribute_definition", "attribute_definition", "alter_collection_clauses", + "dependent_handling_clause", "dependent_exceptions_part", "create_type", + "type_definition", "object_type_def", "object_as_part", "object_under_part", + "nested_table_type_def", "sqlj_object_type", "type_body", "type_body_elements", + "map_order_func_declaration", "subprog_decl_in_type", "proc_decl_in_type", + "func_decl_in_type", "constructor_declaration", "modifier_clause", "object_member_spec", + "sqlj_object_type_attr", "element_spec", "element_spec_options", "subprogram_spec", + "overriding_subprogram_spec", "overriding_function_spec", "type_procedure_spec", + "type_function_spec", "constructor_spec", "map_order_function_spec", + "pragma_clause", "pragma_elements", "type_elements_parameter", "drop_sequence", + "alter_sequence", "alter_session", "alter_session_set_clause", "create_sequence", + "sequence_spec", "sequence_start_clause", "create_analytic_view", "classification_clause", + "caption_clause", "description_clause", "classification_item", "language", + "cav_using_clause", "dim_by_clause", "dim_key", "dim_ref", "hier_ref", + "measures_clause", "av_measure", "base_meas_clause", "meas_aggregate_clause", + "calc_meas_clause", "default_measure_clause", "default_aggregate_clause", + "cache_clause", "cache_specification", "levels_clause", "level_specification", + "level_group_type", "fact_columns_clause", "qry_transform_clause", "create_attribute_dimension", + "ad_using_clause", "source_clause", "join_path_clause", "join_condition", + "join_condition_item", "attributes_clause", "ad_attributes_clause", + "ad_level_clause", "key_clause", "alternate_key_clause", "dim_order_clause", + "all_clause", "create_audit_policy", "privilege_audit_clause", "action_audit_clause", + "standard_actions", "actions_clause", "object_action", "system_action", + "component_actions", "component_action", "role_audit_clause", "create_controlfile", + "controlfile_options", "logfile_clause", "character_set_clause", "file_specification", + "create_diskgroup", "qualified_disk_clause", "create_edition", "create_flashback_archive", + "flashback_archive_quota", "flashback_archive_retention", "create_hierarchy", + "hier_using_clause", "level_hier_clause", "hier_attrs_clause", "hier_attr_clause", + "hier_attr_name", "create_index", "cluster_index_clause", "cluster_name", + "table_index_clause", "bitmap_join_index_clause", "index_expr_option", + "index_expr", "index_properties", "domain_index_clause", "local_domain_index_clause", + "xmlindex_clause", "local_xmlindex_clause", "global_partitioned_index", + "index_partitioning_clause", "local_partitioned_index", "on_range_partitioned_table", + "on_list_partitioned_table", "partitioned_table", "on_hash_partitioned_table", + "on_hash_partitioned_clause", "on_comp_partitioned_table", "on_comp_partitioned_clause", + "index_subpartition_clause", "index_subpartition_subclause", "odci_parameters", + "indextype", "alter_index", "alter_index_ops_set1", "alter_index_ops_set2", + "visible_or_invisible", "monitoring_nomonitoring", "rebuild_clause", + "alter_index_partitioning", "modify_index_default_attrs", "add_hash_index_partition", + "coalesce_index_partition", "modify_index_partition", "modify_index_partitions_ops", + "rename_index_partition", "drop_index_partition", "split_index_partition", + "index_partition_description", "modify_index_subpartition", "partition_name_old", + "new_partition_name", "new_index_name", "alter_inmemory_join_group", + "create_user", "alter_user", "drop_user", "alter_identified_by", "identified_by", + "identified_other_clause", "user_tablespace_clause", "quota_clause", + "profile_clause", "role_clause", "user_default_role_clause", "password_expire_clause", + "user_lock_clause", "user_editions_clause", "alter_user_editions_clause", + "proxy_clause", "container_names", "set_container_data", "add_rem_container_data", + "container_data_clause", "administer_key_management", "keystore_management_clauses", + "create_keystore", "open_keystore", "force_keystore", "close_keystore", + "backup_keystore", "alter_keystore_password", "merge_into_new_keystore", + "merge_into_existing_keystore", "isolate_keystore", "unite_keystore", + "key_management_clauses", "set_key", "create_key", "mkid", "mk", "use_key", + "set_key_tag", "export_keys", "import_keys", "migrate_keys", "reverse_migrate_keys", + "move_keys", "identified_by_store", "using_algorithm_clause", "using_tag_clause", + "secret_management_clauses", "add_update_secret", "delete_secret", "add_update_secret_seps", + "delete_secret_seps", "zero_downtime_software_patching_clauses", "with_backup_clause", + "identified_by_password_clause", "keystore_password", "path", "secret", + "analyze", "partition_extention_clause", "validation_clauses", "compute_clauses", + "for_clause", "online_or_offline", "into_clause1", "partition_key_value", + "subpartition_key_value", "associate_statistics", "column_association", + "function_association", "indextype_name", "using_statistics_type", "statistics_type_name", + "default_cost_clause", "cpu_cost", "io_cost", "network_cost", "default_selectivity_clause", + "default_selectivity", "storage_table_clause", "unified_auditing", "policy_name", + "audit_traditional", "audit_direct_path", "audit_container_clause", + "audit_operation_clause", "auditing_by_clause", "audit_user", "audit_schema_object_clause", + "sql_operation", "auditing_on_clause", "model_name", "object_name", + "profile_name", "sql_statement_shortcut", "drop_index", "disassociate_statistics", + "drop_indextype", "drop_inmemory_join_group", "flashback_table", "restore_point", + "purge_statement", "noaudit_statement", "rename_object", "grant_statement", + "container_clause", "revoke_statement", "revoke_system_privilege", "revokee_clause", + "revoke_object_privileges", "on_object_clause", "revoke_roles_from_programs", + "program_unit", "create_dimension", "create_directory", "directory_name", + "directory_path", "create_inmemory_join_group", "drop_hierarchy", "alter_library", + "drop_java", "drop_library", "create_java", "create_library", "plsql_library_source", + "credential_name", "library_editionable", "library_debug", "compiler_parameters_clause", + "parameter_value", "library_name", "alter_dimension", "level_clause", + "hierarchy_clause", "dimension_join_clause", "attribute_clause", "extended_attribute_clause", + "column_one_or_more_sub_clause", "alter_view", "alter_view_editionable", + "create_view", "editioning_clause", "view_options", "view_alias_constraint", + "object_view_clause", "inline_constraint", "inline_ref_constraint", + "out_of_line_ref_constraint", "out_of_line_constraint", "constraint_state", + "xmltype_view_clause", "xml_schema_spec", "xml_schema_url", "element", + "alter_tablespace", "datafile_tempfile_clauses", "tablespace_logging_clauses", + "tablespace_group_clause", "tablespace_group_name", "tablespace_state_clauses", + "flashback_mode_clause", "new_tablespace_name", "create_tablespace", + "permanent_tablespace_clause", "tablespace_encryption_spec", "logging_clause", + "extent_management_clause", "segment_management_clause", "temporary_tablespace_clause", + "undo_tablespace_clause", "tablespace_retention_clause", "create_tablespace_set", + "permanent_tablespace_attrs", "tablespace_encryption_clause", "default_tablespace_params", + "default_table_compression", "low_high", "default_index_compression", + "inmmemory_clause", "datafile_specification", "tempfile_specification", + "datafile_tempfile_spec", "redo_log_file_spec", "autoextend_clause", + "maxsize_clause", "build_clause", "partial_index_clause", "parallel_clause", + "alter_materialized_view", "alter_mv_option1", "alter_mv_refresh", "rollback_segment", + "modify_mv_column_clause", "alter_materialized_view_log", "add_mv_log_column_clause", + "move_mv_log_clause", "mv_log_augmentation", "datetime_expr", "interval_expr", + "synchronous_or_asynchronous", "including_or_excluding", "create_materialized_view_log", + "new_values_clause", "mv_log_purge_clause", "create_materialized_zonemap", + "alter_materialized_zonemap", "drop_materialized_zonemap", "zonemap_refresh_clause", + "zonemap_attributes", "zonemap_name", "operator_name", "operator_function_name", + "create_zonemap_on_table", "create_zonemap_as_subquery", "alter_operator", + "drop_operator", "create_operator", "binding_clause", "add_binding_clause", + "implementation_clause", "primary_operator_list", "primary_operator_item", + "operator_context_clause", "using_function_clause", "drop_binding_clause", + "create_materialized_view", "scoped_table_ref_constraint", "mv_column_alias", + "create_mv_refresh", "drop_materialized_view", "create_context", "oracle_namespace", + "create_cluster", "create_profile", "resource_parameters", "password_parameters", + "create_lockdown_profile", "static_base_profile", "dynamic_base_profile", + "create_outline", "create_restore_point", "create_role", "create_table", + "xmltype_table", "xmltype_virtual_columns", "xmltype_column_properties", + "xmltype_storage", "xmlschema_spec", "object_table", "object_type", + "oid_index_clause", "oid_clause", "object_properties", "object_table_substitution", + "relational_table", "immutable_table_clauses", "immutable_table_no_drop_clause", + "immutable_table_no_delete_clause", "blockchain_table_clauses", "blockchain_drop_table_clause", + "blockchain_row_retention_clause", "blockchain_hash_and_data_format_clause", + "collation_name", "table_properties", "read_only_clause", "indexing_clause", + "attribute_clustering_clause", "clustering_join", "clustering_join_item", + "equijoin_condition", "cluster_clause", "clustering_columns", "clustering_column_group", + "yes_no", "zonemap_clause", "logical_replication_clause", "table_name", + "relational_property", "table_partitioning_clauses", "range_partitions", + "list_partitions", "hash_partitions", "individual_hash_partitions", + "hash_partitions_by_quantity", "hash_partition_quantity", "composite_range_partitions", + "composite_list_partitions", "composite_hash_partitions", "reference_partitioning", + "reference_partition_desc", "system_partitioning", "range_partition_desc", + "list_partition_desc", "subpartition_template", "hash_subpartition_quantity", + "subpartition_by_range", "subpartition_by_list", "subpartition_by_hash", + "subpartition_name", "range_subpartition_desc", "list_subpartition_desc", + "individual_hash_subparts", "hash_subparts_by_quantity", "range_values_clause", + "list_values_clause", "table_partition_description", "partitioning_storage_clause", + "lob_partitioning_storage", "datatype_null_enable", "size_clause", "table_compression", + "inmemory_table_clause", "inmemory_attributes", "inmemory_memcompress", + "inmemory_priority", "inmemory_distribute", "inmemory_duplicate", "inmemory_column_clause", + "physical_attributes_clause", "storage_clause", "deferred_segment_creation", + "segment_attributes_clause", "physical_properties", "ilm_clause", "ilm_policy_clause", + "ilm_compression_policy", "ilm_tiering_policy", "ilm_after_on", "segment_group", + "ilm_inmemory_policy", "ilm_time_period", "heap_org_table_clause", "external_table_clause", + "access_driver_type", "external_table_data_props", "opaque_format_spec", + "record_format_info", "et_string", "et_record_spec_options", "et_record_spec_option", + "et_output_files", "et_output_file", "directory_spec", "file_spec", + "field_definitions", "field_options", "field_option", "field_list", + "field_item", "field_name", "pos_spec", "pos_start", "pos_increment", + "pos_end", "pos_length", "datatype_spec", "init_spec", "lls_clause", + "delim_spec", "trim_spec", "field_date_format", "column_transforms", + "transform", "source_field", "lobfile_item", "lobfile_attr_list", "concat_item", + "row_movement_clause", "flashback_archive_clause", "log_grp", "supplemental_table_logging", + "supplemental_log_grp_clause", "supplemental_id_key_clause", "allocate_extent_clause", + "deallocate_unused_clause", "shrink_clause", "records_per_block_clause", + "upgrade_table_clause", "truncate_table", "drop_table", "drop_tablespace", + "drop_tablespace_set", "including_contents_clause", "drop_view", "comment_on_column", + "enable_or_disable", "allow_or_disallow", "alter_synonym", "create_synonym", + "drop_synonym", "create_spfile", "spfile_name", "pfile_name", "comment_on_table", + "comment_on_materialized", "alter_analytic_view", "alter_add_cache_clause", + "levels_item", "measure_list", "alter_drop_cache_clause", "alter_attribute_dimension", + "alter_audit_policy", "alter_cluster", "drop_analytic_view", "drop_attribute_dimension", + "drop_audit_policy", "drop_flashback_archive", "drop_cluster", "drop_context", + "drop_directory", "drop_diskgroup", "drop_edition", "truncate_cluster", + "cache_or_nocache", "database_name", "alter_database", "database_clause", + "startup_clauses", "resetlogs_or_noresetlogs", "upgrade_or_downgrade", + "recovery_clauses", "begin_or_end", "general_recovery", "full_database_recovery", + "partial_database_recovery", "partial_database_recovery_10g", "managed_standby_recovery", + "db_name", "database_file_clauses", "create_datafile_clause", "alter_datafile_clause", + "alter_tempfile_clause", "move_datafile_clause", "logfile_clauses", + "add_logfile_clauses", "group_redo_logfile", "drop_logfile_clauses", + "switch_logfile_clause", "supplemental_db_logging", "add_or_drop", "supplemental_plsql_clause", + "logfile_descriptor", "controlfile_clauses", "trace_file_clause", "standby_database_clauses", + "activate_standby_db_clause", "maximize_standby_db_clause", "register_logfile_clause", + "commit_switchover_clause", "start_standby_clause", "stop_standby_clause", + "convert_database_clause", "default_settings_clause", "set_time_zone_clause", + "instance_clauses", "security_clause", "domain", "database", "edition_name", + "filenumber", "filename", "prepare_clause", "drop_mirror_clause", "lost_write_protection", + "cdb_fleet_clauses", "lead_cdb_clause", "lead_cdb_uri_clause", "property_clauses", + "replay_upgrade_clauses", "alter_database_link", "password_value", "link_authentication", + "create_database", "database_logging_clauses", "database_logging_sub_clause", + "tablespace_clauses", "enable_pluggable_database", "file_name_convert", + "filename_convert_sub_clause", "tablespace_datafile_clauses", "undo_mode_clause", + "default_tablespace", "default_temp_tablespace", "undo_tablespace", + "drop_database", "create_database_link", "dblink", "drop_database_link", + "alter_tablespace_set", "alter_tablespace_attrs", "alter_tablespace_encryption", + "ts_file_name_convert", "alter_role", "role_identified_clause", "alter_table", + "memoptimize_read_write_clause", "alter_table_properties", "alter_table_partitioning", + "add_table_partition", "drop_table_partition", "merge_table_partition", + "modify_table_partition", "split_table_partition", "truncate_table_partition", + "exchange_table_partition", "coalesce_table_partition", "alter_interval_partition", + "partition_extended_names", "subpartition_extended_names", "alter_table_properties_1", + "alter_iot_clauses", "alter_mapping_table_clause", "alter_overflow_clause", + "add_overflow_clause", "update_index_clauses", "update_global_index_clause", + "update_all_indexes_clause", "update_all_indexes_index_clause", "update_index_partition", + "update_index_subpartition", "enable_disable_clause", "using_index_clause", + "index_attributes", "sort_or_nosort", "exceptions_clause", "move_table_clause", + "index_org_table_clause", "mapping_table_clause", "key_compression", + "index_org_overflow_clause", "column_clauses", "modify_collection_retrieval", + "collection_item", "rename_column_clause", "old_column_name", "new_column_name", + "add_modify_drop_column_clauses", "drop_column_clause", "modify_column_clauses", + "modify_col_visibility", "modify_col_properties", "modify_col_substitutable", + "add_column_clause", "alter_varray_col_properties", "varray_col_properties", + "varray_storage_clause", "lob_segname", "lob_item", "lob_storage_parameters", + "lob_storage_clause", "modify_lob_storage_clause", "modify_lob_parameters", + "lob_parameters", "lob_deduplicate_clause", "lob_compression_clause", + "lob_retention_clause", "encryption_spec", "tablespace", "varray_item", + "column_properties", "lob_partition_storage", "period_definition", "start_time_column", + "end_time_column", "column_definition", "column_collation_name", "identity_clause", + "identity_options_parentheses", "identity_options", "virtual_column_definition", + "autogenerated_sequence_definition", "evaluation_edition_clause", "out_of_line_part_storage", + "nested_table_col_properties", "nested_item", "substitutable_column_clause", + "partition_name", "supplemental_logging_props", "column_or_attribute", + "object_type_col_properties", "constraint_clauses", "old_constraint_name", + "new_constraint_name", "drop_constraint_clause", "drop_primary_key_or_unique_or_generic_clause", + "add_constraint", "add_constraint_clause", "check_constraint", "drop_constraint", + "enable_constraint", "disable_constraint", "foreign_key_clause", "references_clause", + "on_delete_clause", "unique_key_clause", "primary_key_clause", "anonymous_block", + "invoker_rights_clause", "call_spec", "java_spec", "c_spec", "c_agent_in_clause", + "c_parameters_clause", "parameter", "default_value_part", "seq_of_declare_specs", + "declare_spec", "variable_declaration", "subtype_declaration", "cursor_declaration", + "parameter_spec", "exception_declaration", "pragma_declaration", "record_type_def", + "field_spec", "ref_cursor_type_def", "type_declaration", "table_type_def", + "table_indexed_by_part", "varray_type_def", "seq_of_statements", "label_declaration", + "statement", "swallow_to_semi", "assignment_statement", "continue_statement", + "exit_statement", "goto_statement", "if_statement", "elsif_part", "else_part", + "loop_statement", "cursor_loop_param", "forall_statement", "bounds_clause", + "between_bound", "lower_bound", "upper_bound", "null_statement", "raise_statement", + "return_statement", "call_statement", "pipe_row_statement", "body", + "exception_handler", "trigger_block", "block", "sql_statement", "execute_immediate", + "dynamic_returning_clause", "data_manipulation_language_statements", + "cursor_manipulation_statements", "close_statement", "open_statement", + "fetch_statement", "open_for_statement", "transaction_control_statements", + "set_transaction_command", "set_constraint_command", "commit_statement", + "write_clause", "rollback_statement", "savepoint_statement", "explain_statement", + "select_only_statement", "select_statement", "subquery_factoring_clause", + "factoring_element", "search_clause", "cycle_clause", "subquery", "subquery_basic_elements", + "subquery_operation_part", "query_block", "selected_list", "from_clause", + "select_list_elements", "table_wild", "table_ref_list", "table_ref", + "table_ref_aux", "table_ref_aux_internal", "join_clause", "join_on_part", + "join_using_part", "outer_join_type", "query_partition_clause", "flashback_query_clause", + "pivot_clause", "pivot_element", "pivot_for_clause", "pivot_in_clause", + "pivot_in_clause_element", "pivot_in_clause_elements", "unpivot_clause", + "unpivot_in_clause", "unpivot_in_elements", "hierarchical_query_clause", + "start_part", "group_by_clause", "group_by_elements", "rollup_cube_clause", + "grouping_sets_clause", "grouping_sets_elements", "having_clause", "model_clause", + "cell_reference_options", "return_rows_clause", "reference_model", "main_model", + "model_column_clauses", "model_column_partition_part", "model_column_list", + "model_column", "model_rules_clause", "model_rules_part", "model_rules_element", + "cell_assignment", "model_iterate_clause", "until_part", "order_by_clause", + "order_by_elements", "offset_clause", "fetch_clause", "for_update_clause", + "for_update_of_part", "for_update_options", "update_statement", "update_set_clause", + "column_based_update_set_clause", "delete_statement", "insert_statement", + "single_table_insert", "multi_table_insert", "multi_table_element", + "conditional_insert_clause", "conditional_insert_when_part", "conditional_insert_else_part", + "insert_into_clause", "values_clause", "merge_statement", "merge_update_clause", + "merge_element", "merge_update_delete_part", "merge_insert_clause", + "selected_tableview", "lock_table_statement", "wait_nowait_part", "lock_table_element", + "lock_mode", "general_table_ref", "static_returning_clause", "error_logging_clause", + "error_logging_into_part", "error_logging_reject_part", "dml_table_expression_clause", + "table_collection_expression", "subquery_restriction_clause", "sample_clause", + "seed_part", "condition", "json_condition", "expressions", "expression", + "cursor_expression", "logical_expression", "unary_logical_expression", + "logical_operation", "multiset_expression", "relational_expression", + "compound_expression", "relational_operator", "in_elements", "between_elements", + "concatenation", "interval_expression", "model_expression", "model_expression_element", + "single_column_for_loop", "multi_column_for_loop", "unary_expression", + "case_statement", "simple_case_statement", "simple_case_when_part", + "searched_case_statement", "searched_case_when_part", "case_else_part", + "atom", "quantified_expression", "string_function", "standard_function", + "json_function", "json_object_content", "json_object_entry", "json_table_clause", + "json_array_element", "json_on_null_clause", "json_return_clause", "json_transform_op", + "json_column_clause", "json_column_definition", "json_query_returning_clause", + "json_query_return_type", "json_query_wrapper_clause", "json_query_on_error_clause", + "json_query_on_empty_clause", "json_value_return_clause", "json_value_return_type", + "json_value_on_mismatch_clause", "literal", "numeric_function_wrapper", + "numeric_function", "listagg_overflow_clause", "other_function", "over_clause_keyword", + "within_or_over_clause_keyword", "standard_prediction_function_keyword", + "over_clause", "windowing_clause", "windowing_type", "windowing_elements", + "using_clause", "using_element", "collect_order_by_part", "within_or_over_part", + "cost_matrix_clause", "xml_passing_clause", "xml_attributes_clause", + "xml_namespaces_clause", "xml_table_column", "xml_general_default_part", + "xml_multiuse_expression_element", "xmlroot_param_version_part", "xmlroot_param_standalone_part", + "xmlserialize_param_enconding_part", "xmlserialize_param_version_part", + "xmlserialize_param_ident_part", "sql_plus_command", "whenever_command", + "set_command", "timing_command", "partition_extension_clause", "column_alias", + "table_alias", "where_clause", "quantitative_where_stmt", "into_clause", + "xml_column_name", "cost_class_name", "attribute_name", "savepoint_name", + "rollback_segment_name", "table_var_name", "schema_name", "routine_name", + "package_name", "implementation_type_name", "parameter_name", "reference_model_name", + "main_model_name", "container_tableview_name", "aggregate_function_name", + "query_name", "grantee_name", "role_name", "constraint_name", "label_name", + "type_name", "sequence_name", "exception_name", "function_name", "procedure_name", + "trigger_name", "variable_name", "index_name", "cursor_name", "record_name", + "collection_name", "link_name", "column_name", "tableview_name", "xmltable", + "char_set_name", "synonym_name", "schema_object_name", "dir_object_name", + "user_object_name", "grant_object_name", "column_list", "paren_column_list", + "keep_clause", "function_argument", "function_argument_analytic", "function_argument_modeling", + "respect_or_ignore_nulls", "argument", "type_spec", "datatype", "precision_part", + "native_datatype_element", "bind_variable", "general_element", "general_element_part", + "table_element", "object_privilege", "system_privilege", "constant", + "constant_without_variable", "numeric", "numeric_negative", "quoted_string", + "char_str", "identifier", "id_expression", "outer_join_sign", "regular_id", + "non_reserved_keywords_in_12c", "non_reserved_keywords_pre12c", "string_function_name", + "numeric_function_name", + } + staticData.PredictionContextCache = antlr.NewPredictionContextCache() + staticData.serializedATN = []int32{ + 4, 1, 2408, 20333, 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, 2, 1125, 7, 1125, 2, 1126, 7, 1126, 2, 1127, 7, + 1127, 2, 1128, 7, 1128, 2, 1129, 7, 1129, 2, 1130, 7, 1130, 2, 1131, 7, + 1131, 2, 1132, 7, 1132, 2, 1133, 7, 1133, 2, 1134, 7, 1134, 2, 1135, 7, + 1135, 2, 1136, 7, 1136, 2, 1137, 7, 1137, 2, 1138, 7, 1138, 2, 1139, 7, + 1139, 2, 1140, 7, 1140, 2, 1141, 7, 1141, 2, 1142, 7, 1142, 2, 1143, 7, + 1143, 2, 1144, 7, 1144, 2, 1145, 7, 1145, 2, 1146, 7, 1146, 2, 1147, 7, + 1147, 2, 1148, 7, 1148, 2, 1149, 7, 1149, 2, 1150, 7, 1150, 2, 1151, 7, + 1151, 2, 1152, 7, 1152, 2, 1153, 7, 1153, 2, 1154, 7, 1154, 2, 1155, 7, + 1155, 2, 1156, 7, 1156, 2, 1157, 7, 1157, 2, 1158, 7, 1158, 2, 1159, 7, + 1159, 2, 1160, 7, 1160, 2, 1161, 7, 1161, 2, 1162, 7, 1162, 2, 1163, 7, + 1163, 2, 1164, 7, 1164, 2, 1165, 7, 1165, 2, 1166, 7, 1166, 2, 1167, 7, + 1167, 2, 1168, 7, 1168, 2, 1169, 7, 1169, 2, 1170, 7, 1170, 2, 1171, 7, + 1171, 2, 1172, 7, 1172, 2, 1173, 7, 1173, 2, 1174, 7, 1174, 2, 1175, 7, + 1175, 2, 1176, 7, 1176, 2, 1177, 7, 1177, 2, 1178, 7, 1178, 2, 1179, 7, + 1179, 2, 1180, 7, 1180, 2, 1181, 7, 1181, 2, 1182, 7, 1182, 2, 1183, 7, + 1183, 2, 1184, 7, 1184, 2, 1185, 7, 1185, 2, 1186, 7, 1186, 2, 1187, 7, + 1187, 2, 1188, 7, 1188, 2, 1189, 7, 1189, 2, 1190, 7, 1190, 2, 1191, 7, + 1191, 2, 1192, 7, 1192, 2, 1193, 7, 1193, 2, 1194, 7, 1194, 2, 1195, 7, + 1195, 1, 0, 1, 0, 3, 0, 2395, 8, 0, 1, 0, 3, 0, 2398, 8, 0, 1, 0, 5, 0, + 2401, 8, 0, 10, 0, 12, 0, 2404, 9, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 3, 1, 2547, 8, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, + 2, 2554, 8, 2, 11, 2, 12, 2, 2555, 1, 2, 3, 2, 2559, 8, 2, 1, 2, 3, 2, + 2562, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, + 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2584, + 8, 2, 3, 2, 2586, 8, 2, 1, 2, 1, 2, 1, 2, 5, 2, 2591, 8, 2, 10, 2, 12, + 2, 2594, 9, 2, 1, 2, 3, 2, 2597, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2602, 8, + 2, 3, 2, 2604, 8, 2, 1, 3, 1, 3, 1, 3, 3, 3, 2609, 8, 3, 1, 3, 3, 3, 2612, + 8, 3, 1, 3, 1, 3, 3, 3, 2616, 8, 3, 1, 3, 1, 3, 1, 3, 1, 3, 5, 3, 2622, + 8, 3, 10, 3, 12, 3, 2625, 9, 3, 4, 3, 2627, 8, 3, 11, 3, 12, 3, 2628, 1, + 4, 1, 4, 3, 4, 2633, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2638, 8, 4, 1, 4, 1, + 4, 1, 4, 3, 4, 2643, 8, 4, 5, 4, 2645, 8, 4, 10, 4, 12, 4, 2648, 9, 4, + 1, 4, 1, 4, 1, 4, 3, 4, 2653, 8, 4, 1, 4, 1, 4, 1, 4, 3, 4, 2658, 8, 4, + 1, 4, 1, 4, 1, 4, 3, 4, 2663, 8, 4, 5, 4, 2665, 8, 4, 10, 4, 12, 4, 2668, + 9, 4, 3, 4, 2670, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 2676, 8, 5, 1, 6, + 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 3, 6, 2684, 8, 6, 1, 6, 1, 6, 1, 6, 1, 6, + 1, 6, 3, 6, 2691, 8, 6, 5, 6, 2693, 8, 6, 10, 6, 12, 6, 2696, 9, 6, 1, + 6, 1, 6, 3, 6, 2700, 8, 6, 1, 6, 3, 6, 2703, 8, 6, 1, 7, 1, 7, 1, 8, 1, + 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 5, 8, 2717, 8, 8, 10, + 8, 12, 8, 2720, 9, 8, 1, 8, 1, 8, 3, 8, 2724, 8, 8, 1, 9, 1, 9, 3, 9, 2728, + 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 2734, 8, 9, 10, 9, 12, 9, 2737, 9, + 9, 1, 9, 1, 9, 1, 9, 3, 9, 2742, 8, 9, 1, 9, 1, 9, 1, 9, 1, 9, 5, 9, 2748, + 8, 9, 10, 9, 12, 9, 2751, 9, 9, 4, 9, 2753, 8, 9, 11, 9, 12, 9, 2754, 1, + 9, 3, 9, 2758, 8, 9, 1, 9, 1, 9, 3, 9, 2762, 8, 9, 1, 9, 3, 9, 2765, 8, + 9, 1, 10, 1, 10, 3, 10, 2769, 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, + 2775, 8, 10, 10, 10, 12, 10, 2778, 9, 10, 1, 10, 1, 10, 1, 10, 3, 10, 2783, + 8, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 2789, 8, 10, 10, 10, 12, 10, + 2792, 9, 10, 3, 10, 2794, 8, 10, 1, 10, 3, 10, 2797, 8, 10, 1, 11, 1, 11, + 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 4, 12, 2807, 8, 12, 11, 12, 12, + 12, 2808, 3, 12, 2811, 8, 12, 1, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2817, + 8, 12, 1, 12, 1, 12, 1, 12, 3, 12, 2822, 8, 12, 3, 12, 2824, 8, 12, 1, + 13, 1, 13, 1, 14, 1, 14, 3, 14, 2830, 8, 14, 1, 14, 3, 14, 2833, 8, 14, + 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, 15, 2843, 8, + 15, 10, 15, 12, 15, 2846, 9, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 5, + 15, 2853, 8, 15, 10, 15, 12, 15, 2856, 9, 15, 3, 15, 2858, 8, 15, 1, 16, + 1, 16, 1, 16, 3, 16, 2863, 8, 16, 1, 16, 3, 16, 2866, 8, 16, 1, 16, 1, + 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, + 1, 20, 5, 20, 2881, 8, 20, 10, 20, 12, 20, 2884, 9, 20, 1, 20, 1, 20, 1, + 20, 1, 20, 3, 20, 2890, 8, 20, 1, 20, 1, 20, 1, 20, 3, 20, 2895, 8, 20, + 5, 20, 2897, 8, 20, 10, 20, 12, 20, 2900, 9, 20, 1, 20, 1, 20, 1, 20, 1, + 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 2912, 8, 20, 10, 20, + 12, 20, 2915, 9, 20, 3, 20, 2917, 8, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2930, 8, 22, 10, 22, + 12, 22, 2933, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 2940, 8, + 22, 10, 22, 12, 22, 2943, 9, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, + 22, 1, 22, 1, 22, 1, 22, 5, 22, 2954, 8, 22, 10, 22, 12, 22, 2957, 9, 22, + 3, 22, 2959, 8, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, + 23, 1, 23, 1, 23, 1, 23, 3, 23, 2972, 8, 23, 1, 24, 1, 24, 1, 24, 1, 24, + 1, 24, 1, 24, 3, 24, 2980, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24, 3, 24, 2986, + 8, 24, 1, 24, 1, 24, 3, 24, 2990, 8, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, + 25, 3, 25, 2997, 8, 25, 1, 25, 1, 25, 3, 25, 3001, 8, 25, 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, 5, 27, 3023, 8, 27, + 10, 27, 12, 27, 3026, 9, 27, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, + 1, 29, 5, 29, 3035, 8, 29, 10, 29, 12, 29, 3038, 9, 29, 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, + 5, 31, 3053, 8, 31, 10, 31, 12, 31, 3056, 9, 31, 1, 31, 1, 31, 1, 31, 1, + 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 3066, 8, 31, 10, 31, 12, 31, 3069, + 9, 31, 1, 31, 1, 31, 1, 31, 3, 31, 3074, 8, 31, 1, 32, 1, 32, 1, 32, 1, + 32, 1, 32, 5, 32, 3081, 8, 32, 10, 32, 12, 32, 3084, 9, 32, 1, 32, 1, 32, + 1, 32, 1, 32, 1, 32, 5, 32, 3091, 8, 32, 10, 32, 12, 32, 3094, 9, 32, 1, + 32, 3, 32, 3097, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, + 1, 32, 1, 32, 5, 32, 3108, 8, 32, 10, 32, 12, 32, 3111, 9, 32, 3, 32, 3113, + 8, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3122, 8, + 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 3130, 8, 33, 5, 33, + 3132, 8, 33, 10, 33, 12, 33, 3135, 9, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, + 33, 5, 33, 3142, 8, 33, 10, 33, 12, 33, 3145, 9, 33, 1, 34, 1, 34, 1, 34, + 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 3156, 8, 34, 10, 34, 12, + 34, 3159, 9, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 5, 34, 3166, 8, 34, + 10, 34, 12, 34, 3169, 9, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 3, 35, + 3176, 8, 35, 1, 35, 3, 35, 3179, 8, 35, 1, 35, 1, 35, 3, 35, 3183, 8, 35, + 1, 35, 3, 35, 3186, 8, 35, 1, 35, 3, 35, 3189, 8, 35, 1, 35, 3, 35, 3192, + 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 3, 36, 3202, + 8, 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, 3, 36, 3221, 8, 36, + 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 3, 39, 3231, 8, + 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 3239, 8, 40, 1, 40, + 1, 40, 1, 40, 3, 40, 3244, 8, 40, 1, 40, 1, 40, 1, 40, 1, 40, 3, 40, 3250, + 8, 40, 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, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 3, 43, + 3271, 8, 43, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 3, 46, 3280, + 8, 46, 1, 46, 3, 46, 3283, 8, 46, 1, 46, 1, 46, 3, 46, 3287, 8, 46, 3, + 46, 3289, 8, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 5, 47, 3296, 8, 47, + 10, 47, 12, 47, 3299, 9, 47, 1, 47, 3, 47, 3302, 8, 47, 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, 3, 49, 3319, 8, 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, 3, 49, 3333, 8, 49, 3, 49, + 3335, 8, 49, 1, 49, 3, 49, 3338, 8, 49, 1, 49, 1, 49, 3, 49, 3342, 8, 49, + 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 3, 50, 3349, 8, 50, 1, 50, 1, 50, 1, + 50, 1, 50, 1, 50, 3, 50, 3356, 8, 50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, + 3, 51, 3363, 8, 51, 1, 51, 5, 51, 3366, 8, 51, 10, 51, 12, 51, 3369, 9, + 51, 1, 51, 1, 51, 3, 51, 3373, 8, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, + 1, 52, 1, 52, 1, 52, 3, 52, 3383, 8, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, + 52, 1, 52, 3, 52, 3391, 8, 52, 1, 52, 1, 52, 3, 52, 3395, 8, 52, 1, 52, + 1, 52, 4, 52, 3399, 8, 52, 11, 52, 12, 52, 3400, 1, 52, 1, 52, 3, 52, 3405, + 8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 3410, 8, 52, 1, 53, 1, 53, 1, 54, 1, + 54, 1, 54, 3, 54, 3417, 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, + 5, 54, 3425, 8, 54, 10, 54, 12, 54, 3428, 9, 54, 1, 54, 1, 54, 3, 54, 3432, + 8, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 3440, 8, 54, 10, + 54, 12, 54, 3443, 9, 54, 1, 54, 3, 54, 3446, 8, 54, 1, 54, 1, 54, 3, 54, + 3450, 8, 54, 1, 54, 3, 54, 3453, 8, 54, 1, 54, 1, 54, 3, 54, 3457, 8, 54, + 1, 54, 1, 54, 1, 54, 1, 54, 3, 54, 3463, 8, 54, 1, 54, 1, 54, 1, 55, 1, + 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1, 56, 3, 56, 3477, + 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 3486, 8, + 57, 1, 57, 3, 57, 3489, 8, 57, 1, 57, 1, 57, 1, 58, 1, 58, 3, 58, 3495, + 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 5, 59, 3502, 8, 59, 10, 59, 12, + 59, 3505, 9, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, + 1, 61, 1, 61, 3, 61, 3517, 8, 61, 1, 61, 1, 61, 4, 61, 3521, 8, 61, 11, + 61, 12, 61, 3522, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, + 1, 62, 1, 62, 3, 62, 3535, 8, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, + 63, 1, 63, 3, 63, 3544, 8, 63, 1, 63, 1, 63, 1, 63, 3, 63, 3549, 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, 3, 64, 3565, 8, 64, 3, 64, 3567, 8, 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, 3, 65, 3583, 8, 65, 3, 65, 3585, 8, 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, 3, 66, 3606, 8, 66, 3, 66, + 3608, 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, 3, 67, + 3628, 8, 67, 3, 67, 3630, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, + 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 4, 68, 3643, 8, 68, 11, 68, 12, + 68, 3644, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 3654, + 8, 68, 3, 68, 3656, 8, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, + 69, 1, 69, 1, 69, 3, 69, 3667, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 3672, + 8, 70, 10, 70, 12, 70, 3675, 9, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, + 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 3687, 8, 73, 1, 73, 1, 73, 1, + 73, 3, 73, 3692, 8, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, + 1, 74, 3, 74, 3702, 8, 74, 1, 74, 3, 74, 3705, 8, 74, 1, 74, 5, 74, 3708, + 8, 74, 10, 74, 12, 74, 3711, 9, 74, 1, 74, 1, 74, 3, 74, 3715, 8, 74, 1, + 74, 1, 74, 1, 75, 1, 75, 1, 75, 3, 75, 3722, 8, 75, 1, 75, 1, 75, 1, 75, + 1, 75, 3, 75, 3728, 8, 75, 1, 75, 1, 75, 3, 75, 3732, 8, 75, 1, 75, 1, + 75, 5, 75, 3736, 8, 75, 10, 75, 12, 75, 3739, 9, 75, 1, 75, 1, 75, 3, 75, + 3743, 8, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 3, 76, 3750, 8, 76, 1, + 76, 1, 76, 1, 76, 1, 76, 1, 76, 3, 76, 3757, 8, 76, 1, 76, 1, 76, 1, 76, + 5, 76, 3762, 8, 76, 10, 76, 12, 76, 3765, 9, 76, 1, 76, 1, 76, 3, 76, 3769, + 8, 76, 1, 76, 1, 76, 3, 76, 3773, 8, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, + 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 3, 77, 3785, 8, 77, 1, 78, 1, 78, + 1, 78, 1, 78, 1, 78, 1, 78, 5, 78, 3793, 8, 78, 10, 78, 12, 78, 3796, 9, + 78, 1, 78, 1, 78, 3, 78, 3800, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, + 1, 79, 1, 79, 1, 79, 5, 79, 3810, 8, 79, 10, 79, 12, 79, 3813, 9, 79, 1, + 79, 1, 79, 3, 79, 3817, 8, 79, 1, 79, 1, 79, 1, 79, 3, 79, 3822, 8, 79, + 1, 79, 3, 79, 3825, 8, 79, 1, 79, 3, 79, 3828, 8, 79, 1, 79, 1, 79, 1, + 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 3, 80, 3841, + 8, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, + 81, 3, 81, 3853, 8, 81, 1, 81, 1, 81, 3, 81, 3857, 8, 81, 1, 81, 3, 81, + 3860, 8, 81, 1, 81, 3, 81, 3863, 8, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, + 82, 3, 82, 3870, 8, 82, 1, 82, 1, 82, 3, 82, 3874, 8, 82, 1, 82, 3, 82, + 3877, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, + 84, 1, 84, 3, 84, 3889, 8, 84, 1, 84, 5, 84, 3892, 8, 84, 10, 84, 12, 84, + 3895, 9, 84, 1, 84, 1, 84, 3, 84, 3899, 8, 84, 1, 84, 1, 84, 1, 85, 1, + 85, 1, 85, 1, 85, 1, 85, 1, 85, 5, 85, 3909, 8, 85, 10, 85, 12, 85, 3912, + 9, 85, 1, 85, 1, 85, 3, 85, 3916, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, + 85, 1, 85, 5, 85, 3924, 8, 85, 10, 85, 12, 85, 3927, 9, 85, 1, 85, 3, 85, + 3930, 8, 85, 1, 85, 3, 85, 3933, 8, 85, 1, 85, 1, 85, 3, 85, 3937, 8, 85, + 1, 85, 3, 85, 3940, 8, 85, 1, 85, 1, 85, 3, 85, 3944, 8, 85, 1, 85, 1, + 85, 1, 85, 3, 85, 3949, 8, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, + 1, 86, 1, 86, 5, 86, 3959, 8, 86, 10, 86, 12, 86, 3962, 9, 86, 1, 86, 1, + 86, 3, 86, 3966, 8, 86, 1, 86, 1, 86, 3, 86, 3970, 8, 86, 1, 86, 3, 86, + 3973, 8, 86, 1, 86, 1, 86, 1, 86, 3, 86, 3978, 8, 86, 1, 86, 1, 86, 1, + 87, 1, 87, 1, 87, 3, 87, 3985, 8, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, + 1, 87, 5, 87, 3993, 8, 87, 10, 87, 12, 87, 3996, 9, 87, 1, 87, 1, 87, 3, + 87, 4000, 8, 87, 1, 87, 3, 87, 4003, 8, 87, 1, 87, 1, 87, 3, 87, 4007, + 8, 87, 1, 87, 3, 87, 4010, 8, 87, 1, 87, 1, 87, 1, 87, 3, 87, 4015, 8, + 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 4, 88, 4024, 8, 88, + 11, 88, 12, 88, 4025, 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, 3, 90, 4042, 8, 90, 3, + 90, 4044, 8, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, + 3, 91, 4054, 8, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, + 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 4, 94, 4071, 8, 94, + 11, 94, 12, 94, 4072, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 3, 95, 4080, 8, + 95, 1, 95, 1, 95, 1, 95, 3, 95, 4085, 8, 95, 1, 96, 1, 96, 1, 97, 1, 97, + 3, 97, 4091, 8, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 5, 97, 4099, + 8, 97, 10, 97, 12, 97, 4102, 9, 97, 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, 3, 99, 4118, + 8, 99, 1, 99, 5, 99, 4121, 8, 99, 10, 99, 12, 99, 4124, 9, 99, 1, 99, 1, + 99, 3, 99, 4128, 8, 99, 3, 99, 4130, 8, 99, 1, 99, 1, 99, 1, 100, 1, 100, + 1, 100, 3, 100, 4137, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, + 100, 4144, 8, 100, 1, 100, 3, 100, 4147, 8, 100, 1, 100, 3, 100, 4150, + 8, 100, 1, 100, 3, 100, 4153, 8, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, + 101, 1, 101, 1, 101, 5, 101, 4162, 8, 101, 10, 101, 12, 101, 4165, 9, 101, + 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, + 3, 103, 4176, 8, 103, 1, 103, 1, 103, 3, 103, 4180, 8, 103, 1, 103, 3, + 103, 4183, 8, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, + 3, 105, 4192, 8, 105, 1, 106, 1, 106, 1, 106, 1, 106, 5, 106, 4198, 8, + 106, 10, 106, 12, 106, 4201, 9, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, + 106, 3, 106, 4208, 8, 106, 1, 106, 3, 106, 4211, 8, 106, 1, 107, 1, 107, + 1, 107, 1, 107, 1, 107, 3, 107, 4218, 8, 107, 1, 108, 1, 108, 3, 108, 4222, + 8, 108, 1, 109, 1, 109, 1, 109, 3, 109, 4227, 8, 109, 1, 109, 4, 109, 4230, + 8, 109, 11, 109, 12, 109, 4231, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, + 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 3, 110, 4273, 8, + 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, + 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 3, + 111, 4301, 8, 111, 1, 112, 1, 112, 1, 112, 5, 112, 4306, 8, 112, 10, 112, + 12, 112, 4309, 9, 112, 1, 112, 1, 112, 3, 112, 4313, 8, 112, 1, 112, 1, + 112, 1, 113, 1, 113, 1, 113, 3, 113, 4320, 8, 113, 1, 114, 1, 114, 1, 114, + 1, 114, 1, 114, 1, 115, 1, 115, 4, 115, 4329, 8, 115, 11, 115, 12, 115, + 4330, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 3, 117, 4339, 8, + 117, 1, 117, 1, 117, 3, 117, 4343, 8, 117, 1, 117, 1, 117, 1, 118, 1, 118, + 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 4356, 8, + 118, 1, 118, 3, 118, 4359, 8, 118, 1, 118, 1, 118, 1, 119, 1, 119, 3, 119, + 4365, 8, 119, 1, 119, 3, 119, 4368, 8, 119, 1, 119, 5, 119, 4371, 8, 119, + 10, 119, 12, 119, 4374, 9, 119, 1, 119, 1, 119, 3, 119, 4378, 8, 119, 1, + 120, 1, 120, 3, 120, 4382, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, + 1, 120, 5, 120, 4390, 8, 120, 10, 120, 12, 120, 4393, 9, 120, 1, 120, 1, + 120, 1, 121, 1, 121, 1, 121, 5, 121, 4400, 8, 121, 10, 121, 12, 121, 4403, + 9, 121, 1, 122, 1, 122, 1, 122, 3, 122, 4408, 8, 122, 1, 123, 1, 123, 1, + 123, 1, 123, 1, 123, 1, 123, 1, 123, 5, 123, 4417, 8, 123, 10, 123, 12, + 123, 4420, 9, 123, 1, 123, 1, 123, 3, 123, 4424, 8, 123, 1, 124, 1, 124, + 3, 124, 4428, 8, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 3, + 125, 4436, 8, 125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 126, 3, 126, + 4444, 8, 126, 1, 126, 1, 126, 1, 126, 3, 126, 4449, 8, 126, 1, 126, 3, + 126, 4452, 8, 126, 3, 126, 4454, 8, 126, 1, 127, 3, 127, 4457, 8, 127, + 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 3, 128, 4466, 8, + 128, 1, 128, 1, 128, 1, 128, 3, 128, 4471, 8, 128, 1, 128, 1, 128, 1, 129, + 1, 129, 1, 129, 3, 129, 4478, 8, 129, 1, 129, 3, 129, 4481, 8, 129, 1, + 129, 3, 129, 4484, 8, 129, 1, 130, 3, 130, 4487, 8, 130, 1, 130, 1, 130, + 3, 130, 4491, 8, 130, 1, 130, 3, 130, 4494, 8, 130, 1, 130, 1, 130, 1, + 130, 1, 130, 5, 130, 4500, 8, 130, 10, 130, 12, 130, 4503, 9, 130, 1, 130, + 1, 130, 3, 130, 4507, 8, 130, 1, 130, 5, 130, 4510, 8, 130, 10, 130, 12, + 130, 4513, 9, 130, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 4519, 8, 131, + 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, + 4529, 8, 133, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, 134, 1, + 134, 1, 135, 1, 135, 1, 135, 1, 135, 4, 135, 4543, 8, 135, 11, 135, 12, + 135, 4544, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 3, 136, 4552, 8, 136, + 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1, 138, 1, 138, 1, 138, 3, 138, + 4562, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 1, 139, 5, 139, 4570, + 8, 139, 10, 139, 12, 139, 4573, 9, 139, 1, 139, 1, 139, 1, 139, 1, 139, + 3, 139, 4579, 8, 139, 1, 139, 3, 139, 4582, 8, 139, 1, 139, 1, 139, 1, + 139, 3, 139, 4587, 8, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, + 5, 140, 4595, 8, 140, 10, 140, 12, 140, 4598, 9, 140, 1, 140, 1, 140, 3, + 140, 4602, 8, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4609, + 8, 140, 1, 140, 3, 140, 4612, 8, 140, 1, 140, 1, 140, 1, 140, 3, 140, 4617, + 8, 140, 1, 141, 3, 141, 4620, 8, 141, 1, 141, 3, 141, 4623, 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, 5, 141, 4638, 8, 141, 10, 141, 12, 141, 4641, + 9, 141, 1, 141, 1, 141, 3, 141, 4645, 8, 141, 1, 141, 1, 141, 1, 141, 1, + 141, 1, 141, 1, 141, 1, 141, 3, 141, 4654, 8, 141, 1, 141, 3, 141, 4657, + 8, 141, 1, 141, 1, 141, 1, 141, 3, 141, 4662, 8, 141, 1, 142, 3, 142, 4665, + 8, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 3, 143, 4672, 8, 143, 1, + 143, 3, 143, 4675, 8, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 3, 145, + 4682, 8, 145, 1, 145, 4, 145, 4685, 8, 145, 11, 145, 12, 145, 4686, 1, + 145, 1, 145, 3, 145, 4691, 8, 145, 1, 146, 1, 146, 1, 146, 3, 146, 4696, + 8, 146, 1, 147, 1, 147, 1, 147, 3, 147, 4701, 8, 147, 1, 148, 1, 148, 1, + 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 5, 149, 4713, + 8, 149, 10, 149, 12, 149, 4716, 9, 149, 1, 149, 1, 149, 3, 149, 4720, 8, + 149, 1, 149, 1, 149, 1, 149, 1, 149, 1, 149, 3, 149, 4727, 8, 149, 1, 149, + 3, 149, 4730, 8, 149, 1, 149, 1, 149, 3, 149, 4734, 8, 149, 1, 149, 3, + 149, 4737, 8, 149, 1, 149, 3, 149, 4740, 8, 149, 1, 149, 3, 149, 4743, + 8, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 5, 150, 4751, 8, + 150, 10, 150, 12, 150, 4754, 9, 150, 1, 150, 1, 150, 1, 150, 3, 150, 4759, + 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 4767, 8, + 151, 10, 151, 12, 151, 4770, 9, 151, 1, 151, 1, 151, 3, 151, 4774, 8, 151, + 1, 151, 1, 151, 1, 151, 1, 151, 1, 151, 3, 151, 4781, 8, 151, 1, 151, 1, + 151, 1, 151, 1, 151, 3, 151, 4787, 8, 151, 1, 151, 1, 151, 3, 151, 4791, + 8, 151, 1, 152, 3, 152, 4794, 8, 152, 1, 152, 3, 152, 4797, 8, 152, 1, + 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 1, 152, 1, 152, 5, 152, 4812, 8, 152, 10, 152, 12, 152, 4815, + 9, 152, 1, 152, 1, 152, 3, 152, 4819, 8, 152, 1, 152, 1, 152, 1, 152, 1, + 152, 1, 152, 1, 152, 3, 152, 4827, 8, 152, 1, 153, 1, 153, 1, 153, 1, 153, + 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 5, 154, 4839, 8, 154, 10, + 154, 12, 154, 4842, 9, 154, 1, 154, 1, 154, 1, 155, 1, 155, 3, 155, 4848, + 8, 155, 1, 156, 1, 156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, + 1, 158, 1, 158, 1, 158, 1, 158, 4, 158, 4862, 8, 158, 11, 158, 12, 158, + 4863, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, + 159, 1, 159, 1, 159, 3, 159, 4886, 8, 159, 1, 159, 1, 159, 1, 159, 1, 159, + 1, 159, 3, 159, 4893, 8, 159, 3, 159, 4895, 8, 159, 1, 159, 1, 159, 3, + 159, 4899, 8, 159, 1, 160, 1, 160, 1, 160, 1, 160, 4, 160, 4905, 8, 160, + 11, 160, 12, 160, 4906, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, + 1, 160, 1, 160, 1, 160, 3, 160, 4918, 8, 160, 1, 160, 1, 160, 1, 160, 1, + 160, 1, 160, 1, 160, 1, 160, 1, 160, 1, 160, 3, 160, 4929, 8, 160, 3, 160, + 4931, 8, 160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 5, 161, 4938, 8, + 161, 10, 161, 12, 161, 4941, 9, 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, 162, 1, + 162, 1, 162, 1, 162, 1, 162, 1, 162, 3, 162, 4961, 8, 162, 1, 163, 1, 163, + 1, 163, 1, 163, 1, 164, 1, 164, 1, 164, 3, 164, 4970, 8, 164, 1, 164, 3, + 164, 4973, 8, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 3, 164, + 4981, 8, 164, 1, 164, 5, 164, 4984, 8, 164, 10, 164, 12, 164, 4987, 9, + 164, 1, 164, 3, 164, 4990, 8, 164, 1, 164, 3, 164, 4993, 8, 164, 1, 164, + 3, 164, 4996, 8, 164, 1, 164, 3, 164, 4999, 8, 164, 1, 164, 3, 164, 5002, + 8, 164, 1, 164, 3, 164, 5005, 8, 164, 1, 164, 3, 164, 5008, 8, 164, 1, + 164, 3, 164, 5011, 8, 164, 1, 165, 1, 165, 3, 165, 5015, 8, 165, 1, 165, + 3, 165, 5018, 8, 165, 1, 165, 3, 165, 5021, 8, 165, 1, 165, 5, 165, 5024, + 8, 165, 10, 165, 12, 165, 5027, 9, 165, 1, 165, 3, 165, 5030, 8, 165, 1, + 165, 3, 165, 5033, 8, 165, 1, 165, 4, 165, 5036, 8, 165, 11, 165, 12, 165, + 5037, 3, 165, 5040, 8, 165, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, + 167, 1, 168, 1, 168, 1, 168, 1, 168, 3, 168, 5052, 8, 168, 1, 168, 1, 168, + 3, 168, 5056, 8, 168, 1, 169, 1, 169, 3, 169, 5060, 8, 169, 1, 170, 1, + 170, 1, 170, 1, 170, 3, 170, 5066, 8, 170, 1, 170, 1, 170, 3, 170, 5070, + 8, 170, 1, 170, 3, 170, 5073, 8, 170, 1, 170, 3, 170, 5076, 8, 170, 1, + 171, 1, 171, 1, 171, 1, 171, 1, 171, 1, 171, 5, 171, 5084, 8, 171, 10, + 171, 12, 171, 5087, 9, 171, 1, 171, 1, 171, 1, 172, 1, 172, 5, 172, 5093, + 8, 172, 10, 172, 12, 172, 5096, 9, 172, 1, 172, 1, 172, 1, 172, 1, 172, + 1, 172, 3, 172, 5103, 8, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, + 172, 5110, 8, 172, 1, 172, 5, 172, 5113, 8, 172, 10, 172, 12, 172, 5116, + 9, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 5123, 8, 172, 1, + 172, 3, 172, 5126, 8, 172, 1, 172, 1, 172, 3, 172, 5130, 8, 172, 1, 172, + 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 3, 172, 5140, 8, + 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 5, 172, 5147, 8, 172, 10, + 172, 12, 172, 5150, 9, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1, 173, 3, + 173, 5157, 8, 173, 1, 173, 1, 173, 3, 173, 5161, 8, 173, 1, 173, 3, 173, + 5164, 8, 173, 1, 174, 1, 174, 1, 174, 3, 174, 5169, 8, 174, 1, 174, 1, + 174, 3, 174, 5173, 8, 174, 1, 174, 3, 174, 5176, 8, 174, 1, 174, 3, 174, + 5179, 8, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 5, 175, 5186, 8, + 175, 10, 175, 12, 175, 5189, 9, 175, 1, 175, 1, 175, 1, 176, 1, 176, 1, + 176, 3, 176, 5196, 8, 176, 1, 177, 1, 177, 1, 177, 3, 177, 5201, 8, 177, + 1, 178, 1, 178, 1, 178, 1, 178, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, + 1, 180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, + 1, 182, 1, 182, 1, 182, 1, 182, 5, 182, 5225, 8, 182, 10, 182, 12, 182, + 5228, 9, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 1, 183, 5, + 183, 5237, 8, 183, 10, 183, 12, 183, 5240, 9, 183, 1, 183, 1, 183, 1, 183, + 1, 183, 5, 183, 5246, 8, 183, 10, 183, 12, 183, 5249, 9, 183, 3, 183, 5251, + 8, 183, 1, 184, 1, 184, 1, 184, 1, 184, 1, 184, 5, 184, 5258, 8, 184, 10, + 184, 12, 184, 5261, 9, 184, 1, 184, 1, 184, 1, 184, 1, 185, 1, 185, 1, + 185, 1, 185, 3, 185, 5270, 8, 185, 1, 185, 1, 185, 1, 185, 3, 185, 5275, + 8, 185, 1, 185, 1, 185, 1, 185, 1, 186, 1, 186, 1, 186, 1, 186, 1, 186, + 1, 186, 3, 186, 5286, 8, 186, 1, 186, 3, 186, 5289, 8, 186, 3, 186, 5291, + 8, 186, 1, 187, 1, 187, 1, 187, 1, 187, 3, 187, 5297, 8, 187, 1, 187, 1, + 187, 1, 187, 3, 187, 5302, 8, 187, 1, 187, 5, 187, 5305, 8, 187, 10, 187, + 12, 187, 5308, 9, 187, 3, 187, 5310, 8, 187, 1, 188, 1, 188, 1, 188, 1, + 188, 3, 188, 5316, 8, 188, 1, 189, 1, 189, 1, 189, 3, 189, 5321, 8, 189, + 1, 189, 3, 189, 5324, 8, 189, 1, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, + 189, 5331, 8, 189, 1, 189, 1, 189, 1, 189, 1, 189, 3, 189, 5337, 8, 189, + 1, 189, 5, 189, 5340, 8, 189, 10, 189, 12, 189, 5343, 9, 189, 1, 189, 1, + 189, 1, 189, 3, 189, 5348, 8, 189, 1, 189, 1, 189, 1, 189, 4, 189, 5353, + 8, 189, 11, 189, 12, 189, 5354, 1, 189, 3, 189, 5358, 8, 189, 1, 190, 1, + 190, 1, 190, 1, 190, 5, 190, 5364, 8, 190, 10, 190, 12, 190, 5367, 9, 190, + 1, 190, 5, 190, 5370, 8, 190, 10, 190, 12, 190, 5373, 9, 190, 1, 191, 1, + 191, 1, 191, 3, 191, 5378, 8, 191, 1, 191, 1, 191, 3, 191, 5382, 8, 191, + 1, 191, 3, 191, 5385, 8, 191, 1, 191, 3, 191, 5388, 8, 191, 1, 192, 1, + 192, 1, 192, 1, 192, 1, 192, 1, 192, 1, 193, 1, 193, 1, 193, 5, 193, 5399, + 8, 193, 10, 193, 12, 193, 5402, 9, 193, 1, 194, 1, 194, 1, 194, 3, 194, + 5407, 8, 194, 1, 194, 1, 194, 1, 194, 1, 194, 1, 194, 3, 194, 5414, 8, + 194, 1, 194, 1, 194, 1, 195, 1, 195, 1, 195, 1, 195, 1, 195, 5, 195, 5423, + 8, 195, 10, 195, 12, 195, 5426, 9, 195, 1, 195, 1, 195, 1, 196, 1, 196, + 1, 196, 3, 196, 5433, 8, 196, 1, 196, 1, 196, 3, 196, 5437, 8, 196, 1, + 196, 3, 196, 5440, 8, 196, 1, 196, 5, 196, 5443, 8, 196, 10, 196, 12, 196, + 5446, 9, 196, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, 197, 3, + 197, 5455, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 5460, 8, 197, 1, 197, + 5, 197, 5463, 8, 197, 10, 197, 12, 197, 5466, 9, 197, 1, 197, 1, 197, 3, + 197, 5470, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 5475, 8, 197, 1, 197, + 1, 197, 1, 197, 3, 197, 5480, 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 5485, + 8, 197, 1, 197, 1, 197, 1, 197, 3, 197, 5490, 8, 197, 1, 197, 1, 197, 1, + 197, 3, 197, 5495, 8, 197, 1, 197, 5, 197, 5498, 8, 197, 10, 197, 12, 197, + 5501, 9, 197, 3, 197, 5503, 8, 197, 1, 197, 1, 197, 1, 197, 1, 197, 1, + 197, 5, 197, 5510, 8, 197, 10, 197, 12, 197, 5513, 9, 197, 1, 197, 1, 197, + 3, 197, 5517, 8, 197, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 1, 198, 5, + 198, 5525, 8, 198, 10, 198, 12, 198, 5528, 9, 198, 1, 198, 1, 198, 3, 198, + 5532, 8, 198, 1, 199, 1, 199, 1, 199, 1, 200, 1, 200, 3, 200, 5539, 8, + 200, 1, 200, 1, 200, 3, 200, 5543, 8, 200, 1, 201, 1, 201, 1, 201, 1, 201, + 1, 201, 1, 201, 1, 201, 3, 201, 5552, 8, 201, 1, 201, 1, 201, 1, 201, 1, + 201, 1, 201, 3, 201, 5559, 8, 201, 1, 201, 1, 201, 3, 201, 5563, 8, 201, + 1, 202, 1, 202, 1, 202, 1, 202, 1, 202, 3, 202, 5570, 8, 202, 1, 202, 3, + 202, 5573, 8, 202, 1, 202, 3, 202, 5576, 8, 202, 1, 202, 1, 202, 1, 202, + 1, 202, 1, 202, 1, 202, 3, 202, 5584, 8, 202, 1, 202, 1, 202, 3, 202, 5588, + 8, 202, 1, 202, 3, 202, 5591, 8, 202, 1, 203, 1, 203, 1, 203, 1, 203, 5, + 203, 5597, 8, 203, 10, 203, 12, 203, 5600, 9, 203, 1, 204, 1, 204, 4, 204, + 5604, 8, 204, 11, 204, 12, 204, 5605, 1, 205, 1, 205, 1, 205, 1, 205, 5, + 205, 5612, 8, 205, 10, 205, 12, 205, 5615, 9, 205, 1, 206, 1, 206, 3, 206, + 5619, 8, 206, 1, 206, 1, 206, 1, 206, 1, 206, 1, 206, 3, 206, 5626, 8, + 206, 1, 206, 1, 206, 1, 206, 3, 206, 5631, 8, 206, 1, 206, 3, 206, 5634, + 8, 206, 1, 206, 1, 206, 3, 206, 5638, 8, 206, 3, 206, 5640, 8, 206, 1, + 207, 1, 207, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 1, 208, 3, + 208, 5651, 8, 208, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, + 5, 209, 5660, 8, 209, 10, 209, 12, 209, 5663, 9, 209, 1, 209, 1, 209, 1, + 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 1, 209, 5, 209, 5674, 8, 209, + 10, 209, 12, 209, 5677, 9, 209, 1, 209, 1, 209, 3, 209, 5681, 8, 209, 1, + 210, 1, 210, 1, 211, 1, 211, 1, 211, 1, 211, 5, 211, 5689, 8, 211, 10, + 211, 12, 211, 5692, 9, 211, 1, 212, 1, 212, 1, 212, 3, 212, 5697, 8, 212, + 1, 212, 3, 212, 5700, 8, 212, 1, 212, 1, 212, 1, 212, 3, 212, 5705, 8, + 212, 1, 212, 1, 212, 1, 212, 1, 212, 1, 212, 5, 212, 5712, 8, 212, 10, + 212, 12, 212, 5715, 9, 212, 3, 212, 5717, 8, 212, 1, 212, 5, 212, 5720, + 8, 212, 10, 212, 12, 212, 5723, 9, 212, 1, 212, 3, 212, 5726, 8, 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, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, 213, 1, + 213, 1, 213, 1, 213, 1, 213, 3, 213, 5750, 8, 213, 3, 213, 5752, 8, 213, + 1, 214, 1, 214, 3, 214, 5756, 8, 214, 1, 214, 3, 214, 5759, 8, 214, 1, + 214, 1, 214, 1, 214, 3, 214, 5764, 8, 214, 1, 214, 3, 214, 5767, 8, 214, + 1, 214, 5, 214, 5770, 8, 214, 10, 214, 12, 214, 5773, 9, 214, 1, 215, 1, + 215, 1, 215, 1, 215, 1, 216, 1, 216, 3, 216, 5781, 8, 216, 1, 217, 1, 217, + 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 1, 217, 3, 217, 5792, 8, + 217, 1, 217, 3, 217, 5795, 8, 217, 1, 217, 3, 217, 5798, 8, 217, 1, 217, + 3, 217, 5801, 8, 217, 1, 217, 1, 217, 3, 217, 5805, 8, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 5, 217, 5811, 8, 217, 10, 217, 12, 217, 5814, 9, 217, + 4, 217, 5816, 8, 217, 11, 217, 12, 217, 5817, 1, 217, 1, 217, 1, 217, 1, + 217, 1, 217, 1, 217, 1, 217, 1, 217, 5, 217, 5828, 8, 217, 10, 217, 12, + 217, 5831, 9, 217, 3, 217, 5833, 8, 217, 1, 218, 1, 218, 1, 218, 3, 218, + 5838, 8, 218, 1, 218, 1, 218, 3, 218, 5842, 8, 218, 1, 218, 3, 218, 5845, + 8, 218, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 1, 219, 3, 219, + 5854, 8, 219, 1, 220, 1, 220, 1, 220, 1, 220, 3, 220, 5860, 8, 220, 1, + 220, 1, 220, 1, 220, 1, 220, 3, 220, 5866, 8, 220, 1, 220, 3, 220, 5869, + 8, 220, 1, 220, 1, 220, 3, 220, 5873, 8, 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, 3, 223, 5888, 8, 223, 1, 223, 3, 223, 5891, 8, 223, 1, 223, 3, 223, + 5894, 8, 223, 1, 223, 1, 223, 1, 223, 1, 223, 3, 223, 5900, 8, 223, 1, + 223, 1, 223, 1, 223, 1, 223, 3, 223, 5906, 8, 223, 1, 223, 5, 223, 5909, + 8, 223, 10, 223, 12, 223, 5912, 9, 223, 1, 223, 1, 223, 1, 223, 3, 223, + 5917, 8, 223, 1, 224, 1, 224, 1, 224, 1, 224, 3, 224, 5923, 8, 224, 1, + 224, 1, 224, 1, 225, 1, 225, 1, 225, 1, 225, 3, 225, 5931, 8, 225, 4, 225, + 5933, 8, 225, 11, 225, 12, 225, 5934, 1, 225, 1, 225, 1, 226, 1, 226, 1, + 226, 1, 226, 1, 226, 1, 226, 1, 227, 1, 227, 5, 227, 5947, 8, 227, 10, + 227, 12, 227, 5950, 9, 227, 1, 228, 1, 228, 1, 229, 1, 229, 3, 229, 5956, + 8, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 1, 229, 3, 229, 5964, 8, + 229, 1, 229, 3, 229, 5967, 8, 229, 1, 229, 1, 229, 1, 230, 1, 230, 1, 230, + 3, 230, 5974, 8, 230, 1, 231, 1, 231, 1, 231, 3, 231, 5979, 8, 231, 1, + 231, 1, 231, 1, 232, 1, 232, 3, 232, 5985, 8, 232, 1, 232, 1, 232, 1, 232, + 1, 232, 5, 232, 5991, 8, 232, 10, 232, 12, 232, 5994, 9, 232, 1, 232, 1, + 232, 3, 232, 5998, 8, 232, 1, 233, 1, 233, 1, 233, 1, 233, 3, 233, 6004, + 8, 233, 1, 233, 1, 233, 3, 233, 6008, 8, 233, 1, 233, 1, 233, 1, 233, 3, + 233, 6013, 8, 233, 1, 233, 1, 233, 3, 233, 6017, 8, 233, 5, 233, 6019, + 8, 233, 10, 233, 12, 233, 6022, 9, 233, 1, 233, 1, 233, 1, 233, 1, 233, + 1, 233, 1, 233, 1, 233, 1, 233, 5, 233, 6032, 8, 233, 10, 233, 12, 233, + 6035, 9, 233, 1, 233, 1, 233, 3, 233, 6039, 8, 233, 1, 233, 3, 233, 6042, + 8, 233, 1, 234, 1, 234, 3, 234, 6046, 8, 234, 1, 235, 1, 235, 3, 235, 6050, + 8, 235, 1, 236, 1, 236, 1, 236, 4, 236, 6055, 8, 236, 11, 236, 12, 236, + 6056, 1, 236, 1, 236, 1, 236, 1, 236, 3, 236, 6063, 8, 236, 3, 236, 6065, + 8, 236, 1, 237, 1, 237, 3, 237, 6069, 8, 237, 1, 237, 3, 237, 6072, 8, + 237, 1, 237, 1, 237, 1, 237, 1, 237, 1, 237, 3, 237, 6079, 8, 237, 1, 238, + 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 3, 238, + 6090, 8, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, 238, 1, + 238, 3, 238, 6100, 8, 238, 5, 238, 6102, 8, 238, 10, 238, 12, 238, 6105, + 9, 238, 1, 238, 1, 238, 3, 238, 6109, 8, 238, 1, 239, 1, 239, 3, 239, 6113, + 8, 239, 1, 239, 1, 239, 3, 239, 6117, 8, 239, 1, 239, 3, 239, 6120, 8, + 239, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 1, 240, 5, 240, 6129, + 8, 240, 10, 240, 12, 240, 6132, 9, 240, 1, 240, 1, 240, 3, 240, 6136, 8, + 240, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, + 241, 6146, 8, 241, 10, 241, 12, 241, 6149, 9, 241, 1, 241, 1, 241, 1, 241, + 1, 241, 1, 241, 5, 241, 6156, 8, 241, 10, 241, 12, 241, 6159, 9, 241, 1, + 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 1, 241, 5, 241, 6168, 8, 241, + 10, 241, 12, 241, 6171, 9, 241, 1, 241, 1, 241, 1, 241, 3, 241, 6176, 8, + 241, 3, 241, 6178, 8, 241, 3, 241, 6180, 8, 241, 1, 242, 1, 242, 3, 242, + 6184, 8, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 1, 242, 5, + 242, 6193, 8, 242, 10, 242, 12, 242, 6196, 9, 242, 1, 242, 1, 242, 3, 242, + 6200, 8, 242, 1, 243, 1, 243, 1, 243, 1, 243, 1, 243, 3, 243, 6207, 8, + 243, 1, 244, 1, 244, 1, 244, 1, 244, 5, 244, 6213, 8, 244, 10, 244, 12, + 244, 6216, 9, 244, 1, 244, 1, 244, 1, 245, 1, 245, 1, 245, 1, 245, 5, 245, + 6224, 8, 245, 10, 245, 12, 245, 6227, 9, 245, 1, 245, 1, 245, 1, 246, 1, + 246, 3, 246, 6233, 8, 246, 1, 246, 1, 246, 5, 246, 6237, 8, 246, 10, 246, + 12, 246, 6240, 9, 246, 1, 246, 3, 246, 6243, 8, 246, 1, 247, 1, 247, 1, + 247, 1, 247, 1, 247, 1, 247, 5, 247, 6251, 8, 247, 10, 247, 12, 247, 6254, + 9, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 1, 247, 5, 247, 6262, 8, + 247, 10, 247, 12, 247, 6265, 9, 247, 1, 247, 1, 247, 3, 247, 6269, 8, 247, + 1, 248, 1, 248, 3, 248, 6273, 8, 248, 1, 248, 1, 248, 3, 248, 6277, 8, + 248, 1, 248, 3, 248, 6280, 8, 248, 1, 248, 3, 248, 6283, 8, 248, 1, 249, + 1, 249, 1, 249, 1, 249, 1, 249, 1, 249, 5, 249, 6291, 8, 249, 10, 249, + 12, 249, 6294, 9, 249, 1, 249, 1, 249, 3, 249, 6298, 8, 249, 1, 249, 1, + 249, 1, 249, 1, 249, 5, 249, 6304, 8, 249, 10, 249, 12, 249, 6307, 9, 249, + 1, 249, 1, 249, 1, 250, 1, 250, 3, 250, 6313, 8, 250, 1, 250, 1, 250, 5, + 250, 6317, 8, 250, 10, 250, 12, 250, 6320, 9, 250, 1, 250, 1, 250, 3, 250, + 6324, 8, 250, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 1, 251, 5, 251, 6332, + 8, 251, 10, 251, 12, 251, 6335, 9, 251, 1, 251, 1, 251, 1, 251, 1, 251, + 1, 251, 1, 251, 5, 251, 6343, 8, 251, 10, 251, 12, 251, 6346, 9, 251, 1, + 251, 1, 251, 3, 251, 6350, 8, 251, 1, 252, 1, 252, 3, 252, 6354, 8, 252, + 1, 252, 1, 252, 3, 252, 6358, 8, 252, 1, 252, 3, 252, 6361, 8, 252, 1, + 252, 3, 252, 6364, 8, 252, 1, 253, 1, 253, 1, 254, 1, 254, 1, 254, 3, 254, + 6371, 8, 254, 1, 254, 1, 254, 1, 255, 1, 255, 1, 255, 1, 255, 1, 255, 3, + 255, 6380, 8, 255, 1, 255, 1, 255, 1, 256, 1, 256, 1, 256, 1, 256, 1, 256, + 1, 256, 4, 256, 6390, 8, 256, 11, 256, 12, 256, 6391, 1, 257, 1, 257, 1, + 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, 257, 1, + 257, 3, 257, 6415, 8, 257, 1, 258, 1, 258, 1, 259, 1, 259, 1, 260, 1, 260, + 1, 260, 1, 260, 1, 260, 1, 260, 1, 260, 3, 260, 6428, 8, 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, 5, 260, 6442, 8, 260, 10, 260, 12, 260, 6445, 9, 260, 1, 261, + 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 1, 261, 3, 261, 6455, 8, + 261, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6463, 8, 262, + 1, 262, 1, 262, 1, 262, 1, 262, 3, 262, 6469, 8, 262, 1, 262, 3, 262, 6472, + 8, 262, 1, 263, 1, 263, 1, 263, 3, 263, 6477, 8, 263, 1, 263, 1, 263, 3, + 263, 6481, 8, 263, 1, 263, 3, 263, 6484, 8, 263, 1, 263, 3, 263, 6487, + 8, 263, 1, 264, 1, 264, 1, 264, 3, 264, 6492, 8, 264, 1, 265, 1, 265, 1, + 265, 1, 265, 4, 265, 6498, 8, 265, 11, 265, 12, 265, 6499, 1, 265, 1, 265, + 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 1, 265, 3, 265, + 6512, 8, 265, 1, 266, 1, 266, 1, 266, 1, 266, 1, 266, 3, 266, 6519, 8, + 266, 1, 267, 1, 267, 1, 267, 1, 267, 1, 267, 3, 267, 6526, 8, 267, 1, 267, + 1, 267, 1, 267, 1, 268, 1, 268, 1, 268, 1, 268, 1, 269, 1, 269, 1, 269, + 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 5, 269, 6543, 8, 269, 10, 269, + 12, 269, 6546, 9, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, 1, 269, + 1, 269, 1, 269, 3, 269, 6556, 8, 269, 1, 269, 3, 269, 6559, 8, 269, 1, + 270, 1, 270, 1, 270, 1, 270, 4, 270, 6565, 8, 270, 11, 270, 12, 270, 6566, + 1, 270, 1, 270, 1, 270, 1, 270, 1, 270, 3, 270, 6574, 8, 270, 1, 270, 3, + 270, 6577, 8, 270, 3, 270, 6579, 8, 270, 1, 271, 1, 271, 1, 271, 1, 271, + 1, 271, 1, 271, 3, 271, 6587, 8, 271, 1, 272, 1, 272, 1, 273, 1, 273, 1, + 274, 1, 274, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, + 275, 6602, 8, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 1, 275, 3, 275, + 6610, 8, 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, 4, 276, 6630, 8, 276, 11, 276, 12, 276, 6631, 1, 276, 1, 276, + 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, + 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 4, 277, 6650, 8, 277, 11, 277, + 12, 277, 6651, 1, 277, 1, 277, 1, 277, 1, 277, 1, 277, 5, 277, 6659, 8, + 277, 10, 277, 12, 277, 6662, 9, 277, 1, 277, 1, 277, 1, 277, 3, 277, 6667, + 8, 277, 1, 278, 1, 278, 1, 278, 1, 278, 3, 278, 6673, 8, 278, 1, 279, 1, + 279, 1, 279, 3, 279, 6678, 8, 279, 1, 280, 1, 280, 1, 280, 1, 280, 1, 281, + 1, 281, 1, 281, 1, 281, 3, 281, 6688, 8, 281, 1, 282, 1, 282, 1, 282, 1, + 282, 1, 283, 1, 283, 1, 283, 3, 283, 6697, 8, 283, 1, 283, 1, 283, 1, 283, + 1, 284, 1, 284, 1, 284, 1, 285, 1, 285, 1, 285, 5, 285, 6708, 8, 285, 10, + 285, 12, 285, 6711, 9, 285, 1, 285, 1, 285, 1, 285, 1, 285, 1, 285, 5, + 285, 6718, 8, 285, 10, 285, 12, 285, 6721, 9, 285, 5, 285, 6723, 8, 285, + 10, 285, 12, 285, 6726, 9, 285, 3, 285, 6728, 8, 285, 1, 286, 1, 286, 1, + 286, 1, 286, 3, 286, 6734, 8, 286, 1, 287, 1, 287, 1, 287, 1, 288, 1, 288, + 1, 288, 1, 289, 1, 289, 1, 289, 1, 290, 1, 290, 1, 290, 1, 290, 1, 290, + 5, 290, 6750, 8, 290, 10, 290, 12, 290, 6753, 9, 290, 3, 290, 6755, 8, + 290, 1, 290, 3, 290, 6758, 8, 290, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, + 1, 291, 3, 291, 6766, 8, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, + 291, 1, 291, 1, 291, 1, 291, 1, 291, 1, 291, 3, 291, 6779, 8, 291, 3, 291, + 6781, 8, 291, 1, 291, 1, 291, 3, 291, 6785, 8, 291, 1, 291, 1, 291, 1, + 291, 1, 291, 1, 291, 1, 291, 3, 291, 6793, 8, 291, 3, 291, 6795, 8, 291, + 3, 291, 6797, 8, 291, 3, 291, 6799, 8, 291, 1, 292, 1, 292, 1, 292, 1, + 292, 5, 292, 6805, 8, 292, 10, 292, 12, 292, 6808, 9, 292, 1, 292, 1, 292, + 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 1, 293, 3, 293, 6818, 8, 293, 1, + 294, 1, 294, 1, 294, 1, 294, 1, 294, 1, 295, 1, 295, 1, 295, 1, 295, 3, + 295, 6829, 8, 295, 3, 295, 6831, 8, 295, 1, 296, 1, 296, 1, 296, 1, 296, + 1, 296, 1, 296, 1, 296, 3, 296, 6840, 8, 296, 1, 296, 1, 296, 1, 297, 1, + 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 1, 297, 3, 297, 6853, + 8, 297, 1, 298, 1, 298, 1, 298, 1, 298, 3, 298, 6859, 8, 298, 1, 298, 1, + 298, 1, 298, 1, 298, 1, 298, 3, 298, 6866, 8, 298, 1, 298, 1, 298, 1, 298, + 1, 298, 1, 299, 1, 299, 1, 299, 1, 299, 3, 299, 6876, 8, 299, 1, 299, 1, + 299, 3, 299, 6880, 8, 299, 1, 300, 1, 300, 1, 300, 1, 301, 1, 301, 1, 301, + 1, 301, 3, 301, 6889, 8, 301, 1, 301, 3, 301, 6892, 8, 301, 1, 302, 1, + 302, 1, 302, 1, 302, 3, 302, 6898, 8, 302, 1, 302, 3, 302, 6901, 8, 302, + 1, 302, 1, 302, 1, 302, 3, 302, 6906, 8, 302, 1, 303, 1, 303, 1, 303, 1, + 303, 3, 303, 6912, 8, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, 1, 303, + 3, 303, 6920, 8, 303, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, 6926, 8, + 304, 1, 304, 1, 304, 1, 304, 1, 304, 3, 304, 6932, 8, 304, 1, 304, 1, 304, + 1, 304, 1, 304, 1, 304, 1, 304, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, + 6944, 8, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 1, 305, 3, 305, 6952, + 8, 305, 1, 306, 3, 306, 6955, 8, 306, 1, 306, 1, 306, 1, 306, 1, 306, 1, + 306, 1, 306, 1, 306, 1, 306, 1, 306, 3, 306, 6966, 8, 306, 1, 306, 1, 306, + 3, 306, 6970, 8, 306, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, 307, 1, + 307, 1, 307, 1, 307, 3, 307, 6981, 8, 307, 1, 307, 1, 307, 3, 307, 6985, + 8, 307, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, 1, 308, + 1, 308, 3, 308, 6996, 8, 308, 1, 309, 1, 309, 3, 309, 7000, 8, 309, 1, + 309, 1, 309, 1, 309, 1, 309, 3, 309, 7006, 8, 309, 1, 309, 3, 309, 7009, + 8, 309, 1, 309, 3, 309, 7012, 8, 309, 1, 309, 3, 309, 7015, 8, 309, 1, + 309, 3, 309, 7018, 8, 309, 1, 309, 1, 309, 3, 309, 7022, 8, 309, 1, 309, + 3, 309, 7025, 8, 309, 1, 310, 1, 310, 3, 310, 7029, 8, 310, 1, 310, 1, + 310, 1, 310, 1, 310, 3, 310, 7035, 8, 310, 1, 310, 3, 310, 7038, 8, 310, + 1, 310, 3, 310, 7041, 8, 310, 1, 310, 3, 310, 7044, 8, 310, 1, 310, 3, + 310, 7047, 8, 310, 1, 310, 1, 310, 3, 310, 7051, 8, 310, 1, 310, 3, 310, + 7054, 8, 310, 1, 311, 1, 311, 1, 312, 1, 312, 1, 313, 1, 313, 3, 313, 7062, + 8, 313, 1, 313, 1, 313, 1, 313, 3, 313, 7067, 8, 313, 1, 313, 3, 313, 7070, + 8, 313, 1, 313, 1, 313, 3, 313, 7074, 8, 313, 1, 314, 1, 314, 1, 314, 1, + 314, 1, 314, 1, 314, 3, 314, 7082, 8, 314, 1, 314, 1, 314, 3, 314, 7086, + 8, 314, 1, 315, 1, 315, 3, 315, 7090, 8, 315, 1, 315, 1, 315, 1, 315, 1, + 315, 1, 315, 1, 315, 1, 315, 3, 315, 7099, 8, 315, 1, 315, 1, 315, 1, 315, + 1, 315, 1, 315, 1, 315, 1, 315, 5, 315, 7108, 8, 315, 10, 315, 12, 315, + 7111, 9, 315, 1, 315, 1, 315, 1, 315, 1, 315, 3, 315, 7117, 8, 315, 3, + 315, 7119, 8, 315, 1, 316, 1, 316, 3, 316, 7123, 8, 316, 1, 316, 1, 316, + 1, 316, 1, 316, 1, 316, 1, 316, 1, 316, 3, 316, 7132, 8, 316, 1, 316, 1, + 316, 3, 316, 7136, 8, 316, 1, 317, 1, 317, 3, 317, 7140, 8, 317, 1, 317, + 1, 317, 1, 317, 1, 317, 1, 317, 3, 317, 7147, 8, 317, 1, 317, 1, 317, 1, + 317, 1, 317, 3, 317, 7153, 8, 317, 1, 318, 1, 318, 3, 318, 7157, 8, 318, + 1, 318, 1, 318, 1, 318, 1, 318, 1, 318, 3, 318, 7164, 8, 318, 1, 318, 1, + 318, 1, 318, 1, 318, 1, 318, 1, 319, 1, 319, 3, 319, 7173, 8, 319, 1, 319, + 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, + 3, 319, 7185, 8, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, 319, 1, + 319, 1, 319, 1, 319, 1, 319, 5, 319, 7197, 8, 319, 10, 319, 12, 319, 7200, + 9, 319, 1, 319, 3, 319, 7203, 8, 319, 3, 319, 7205, 8, 319, 1, 319, 3, + 319, 7208, 8, 319, 1, 320, 1, 320, 1, 320, 1, 320, 1, 320, 3, 320, 7215, + 8, 320, 1, 321, 1, 321, 1, 321, 1, 321, 1, 322, 1, 322, 1, 322, 1, 322, + 1, 323, 1, 323, 1, 323, 1, 323, 3, 323, 7229, 8, 323, 1, 324, 1, 324, 1, + 324, 1, 324, 1, 324, 1, 324, 1, 324, 3, 324, 7238, 8, 324, 1, 324, 3, 324, + 7241, 8, 324, 1, 324, 3, 324, 7244, 8, 324, 1, 324, 3, 324, 7247, 8, 324, + 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 1, 325, 3, 325, 7255, 8, 325, 1, + 325, 1, 325, 3, 325, 7259, 8, 325, 1, 326, 1, 326, 1, 326, 1, 326, 1, 326, + 1, 326, 1, 326, 3, 326, 7268, 8, 326, 1, 326, 1, 326, 3, 326, 7272, 8, + 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, 3, 327, 7287, 8, 327, 1, 327, 1, 327, + 1, 327, 1, 327, 1, 328, 1, 328, 3, 328, 7295, 8, 328, 1, 328, 1, 328, 1, + 328, 1, 328, 1, 328, 1, 328, 1, 329, 1, 329, 1, 329, 1, 329, 3, 329, 7307, + 8, 329, 1, 330, 1, 330, 1, 330, 1, 330, 1, 331, 1, 331, 1, 332, 1, 332, + 1, 333, 1, 333, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 7324, 8, + 334, 1, 334, 3, 334, 7327, 8, 334, 1, 334, 1, 334, 1, 334, 3, 334, 7332, + 8, 334, 1, 334, 1, 334, 1, 334, 1, 334, 1, 334, 3, 334, 7339, 8, 334, 1, + 334, 1, 334, 3, 334, 7343, 8, 334, 1, 334, 3, 334, 7346, 8, 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, 5, 335, 7360, 8, 335, 10, 335, 12, 335, 7363, 9, 335, 1, + 335, 1, 335, 3, 335, 7367, 8, 335, 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, + 1, 335, 1, 335, 1, 335, 1, 335, 1, 335, 5, 335, 7379, 8, 335, 10, 335, + 12, 335, 7382, 9, 335, 1, 335, 1, 335, 3, 335, 7386, 8, 335, 3, 335, 7388, + 8, 335, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, + 7397, 8, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 1, 336, 3, 336, 7405, + 8, 336, 1, 336, 3, 336, 7408, 8, 336, 1, 336, 3, 336, 7411, 8, 336, 1, + 336, 3, 336, 7414, 8, 336, 1, 336, 3, 336, 7417, 8, 336, 3, 336, 7419, + 8, 336, 1, 337, 1, 337, 3, 337, 7423, 8, 337, 1, 337, 1, 337, 3, 337, 7427, + 8, 337, 1, 338, 1, 338, 1, 338, 5, 338, 7432, 8, 338, 10, 338, 12, 338, + 7435, 9, 338, 1, 338, 1, 338, 3, 338, 7439, 8, 338, 1, 338, 1, 338, 1, + 338, 3, 338, 7444, 8, 338, 1, 338, 5, 338, 7447, 8, 338, 10, 338, 12, 338, + 7450, 9, 338, 1, 338, 3, 338, 7453, 8, 338, 1, 338, 3, 338, 7456, 8, 338, + 1, 338, 1, 338, 1, 338, 3, 338, 7461, 8, 338, 1, 338, 1, 338, 1, 338, 1, + 338, 4, 338, 7467, 8, 338, 11, 338, 12, 338, 7468, 1, 338, 5, 338, 7472, + 8, 338, 10, 338, 12, 338, 7475, 9, 338, 3, 338, 7477, 8, 338, 1, 339, 1, + 339, 1, 340, 1, 340, 3, 340, 7483, 8, 340, 1, 341, 1, 341, 1, 341, 3, 341, + 7488, 8, 341, 1, 342, 1, 342, 1, 342, 3, 342, 7493, 8, 342, 1, 343, 1, + 343, 1, 343, 1, 343, 1, 343, 3, 343, 7500, 8, 343, 1, 343, 3, 343, 7503, + 8, 343, 1, 343, 1, 343, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, 1, 344, + 1, 344, 1, 344, 1, 344, 5, 344, 7516, 8, 344, 10, 344, 12, 344, 7519, 9, + 344, 1, 344, 1, 344, 1, 345, 1, 345, 1, 345, 1, 345, 5, 345, 7527, 8, 345, + 10, 345, 12, 345, 7530, 9, 345, 1, 345, 1, 345, 1, 345, 1, 345, 5, 345, + 7536, 8, 345, 10, 345, 12, 345, 7539, 9, 345, 1, 345, 1, 345, 1, 345, 1, + 345, 5, 345, 7545, 8, 345, 10, 345, 12, 345, 7548, 9, 345, 1, 345, 1, 345, + 1, 345, 1, 345, 5, 345, 7554, 8, 345, 10, 345, 12, 345, 7557, 9, 345, 1, + 345, 1, 345, 1, 345, 1, 345, 5, 345, 7563, 8, 345, 10, 345, 12, 345, 7566, + 9, 345, 3, 345, 7568, 8, 345, 1, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7574, + 8, 345, 1, 345, 1, 345, 1, 345, 3, 345, 7579, 8, 345, 3, 345, 7581, 8, + 345, 1, 346, 1, 346, 1, 347, 1, 347, 1, 347, 3, 347, 7588, 8, 347, 1, 348, + 1, 348, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, 1, 349, + 1, 349, 1, 349, 1, 350, 1, 350, 1, 351, 1, 351, 1, 352, 1, 352, 1, 353, + 1, 353, 1, 353, 1, 353, 1, 354, 1, 354, 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, 5, 356, 7628, 8, 356, 10, 356, 12, 356, 7631, 9, 356, 3, 356, 7633, + 8, 356, 1, 356, 1, 356, 3, 356, 7637, 8, 356, 1, 356, 3, 356, 7640, 8, + 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 1, 356, 5, 356, 7649, + 8, 356, 10, 356, 12, 356, 7652, 9, 356, 1, 356, 1, 356, 1, 356, 1, 356, + 5, 356, 7658, 8, 356, 10, 356, 12, 356, 7661, 9, 356, 3, 356, 7663, 8, + 356, 3, 356, 7665, 8, 356, 1, 356, 1, 356, 1, 357, 1, 357, 1, 358, 1, 358, + 1, 358, 1, 358, 1, 358, 1, 358, 3, 358, 7677, 8, 358, 1, 358, 1, 358, 1, + 358, 3, 358, 7682, 8, 358, 1, 358, 1, 358, 3, 358, 7686, 8, 358, 1, 358, + 1, 358, 3, 358, 7690, 8, 358, 1, 358, 3, 358, 7693, 8, 358, 1, 358, 3, + 358, 7696, 8, 358, 1, 358, 1, 358, 1, 359, 1, 359, 1, 359, 1, 359, 1, 360, + 1, 360, 1, 360, 1, 360, 1, 360, 1, 361, 1, 361, 1, 361, 3, 361, 7712, 8, + 361, 3, 361, 7714, 8, 361, 1, 361, 1, 361, 1, 361, 1, 361, 3, 361, 7720, + 8, 361, 3, 361, 7722, 8, 361, 5, 361, 7724, 8, 361, 10, 361, 12, 361, 7727, + 9, 361, 1, 361, 1, 361, 1, 361, 3, 361, 7732, 8, 361, 1, 361, 1, 361, 1, + 361, 1, 361, 3, 361, 7738, 8, 361, 5, 361, 7740, 8, 361, 10, 361, 12, 361, + 7743, 9, 361, 3, 361, 7745, 8, 361, 1, 362, 1, 362, 1, 362, 1, 362, 5, + 362, 7751, 8, 362, 10, 362, 12, 362, 7754, 9, 362, 1, 363, 1, 363, 1, 364, + 1, 364, 1, 364, 5, 364, 7761, 8, 364, 10, 364, 12, 364, 7764, 9, 364, 1, + 364, 3, 364, 7767, 8, 364, 1, 364, 1, 364, 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, 3, 366, 7786, 8, 366, 1, 367, 1, 367, 1, 367, 3, 367, 7791, + 8, 367, 1, 367, 1, 367, 1, 368, 1, 368, 1, 368, 3, 368, 7798, 8, 368, 1, + 368, 1, 368, 1, 369, 1, 369, 1, 369, 3, 369, 7805, 8, 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, 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, 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, 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, 370, 1, 370, 1, 370, 1, 370, 1, 370, 1, 370, 3, 370, 7879, 8, + 370, 1, 371, 1, 371, 1, 371, 1, 371, 1, 371, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 3, 372, 7893, 8, 372, 1, 372, 1, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7902, 8, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 5, 372, 7908, 8, 372, 10, 372, 12, 372, 7911, 9, 372, 1, 372, + 1, 372, 1, 372, 1, 372, 3, 372, 7917, 8, 372, 1, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 3, 372, 7924, 8, 372, 1, 372, 5, 372, 7927, 8, 372, 10, 372, + 12, 372, 7930, 9, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7936, 8, + 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7943, 8, 372, 1, 372, + 5, 372, 7946, 8, 372, 10, 372, 12, 372, 7949, 9, 372, 1, 372, 1, 372, 1, + 372, 1, 372, 3, 372, 7955, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 3, 372, 7962, 8, 372, 1, 372, 5, 372, 7965, 8, 372, 10, 372, 12, 372, 7968, + 9, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 7974, 8, 372, 1, 372, 1, + 372, 1, 372, 1, 372, 1, 372, 3, 372, 7981, 8, 372, 1, 372, 5, 372, 7984, + 8, 372, 10, 372, 12, 372, 7987, 9, 372, 1, 372, 1, 372, 1, 372, 1, 372, + 3, 372, 7993, 8, 372, 1, 372, 1, 372, 1, 372, 1, 372, 1, 372, 3, 372, 8000, + 8, 372, 1, 372, 5, 372, 8003, 8, 372, 10, 372, 12, 372, 8006, 9, 372, 3, + 372, 8008, 8, 372, 1, 372, 3, 372, 8011, 8, 372, 1, 373, 1, 373, 1, 373, + 1, 373, 1, 373, 3, 373, 8018, 8, 373, 1, 373, 1, 373, 3, 373, 8022, 8, + 373, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 1, 374, 3, 374, 8031, + 8, 374, 1, 374, 1, 374, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 5, 375, + 8040, 8, 375, 10, 375, 12, 375, 8043, 9, 375, 1, 375, 1, 375, 1, 375, 1, + 375, 1, 375, 1, 375, 3, 375, 8051, 8, 375, 1, 375, 1, 375, 3, 375, 8055, + 8, 375, 1, 375, 1, 375, 1, 375, 1, 375, 1, 375, 3, 375, 8062, 8, 375, 3, + 375, 8064, 8, 375, 1, 376, 1, 376, 1, 376, 5, 376, 8069, 8, 376, 10, 376, + 12, 376, 8072, 9, 376, 1, 377, 1, 377, 1, 377, 1, 377, 1, 377, 3, 377, + 8079, 8, 377, 1, 377, 1, 377, 1, 377, 3, 377, 8084, 8, 377, 1, 377, 1, + 377, 3, 377, 8088, 8, 377, 1, 378, 1, 378, 1, 378, 3, 378, 8093, 8, 378, + 1, 378, 1, 378, 1, 378, 1, 378, 1, 378, 3, 378, 8100, 8, 378, 3, 378, 8102, + 8, 378, 1, 378, 1, 378, 3, 378, 8106, 8, 378, 1, 378, 3, 378, 8109, 8, + 378, 1, 378, 3, 378, 8112, 8, 378, 1, 379, 1, 379, 1, 379, 1, 379, 1, 379, + 1, 379, 1, 380, 1, 380, 3, 380, 8122, 8, 380, 1, 380, 1, 380, 1, 380, 1, + 380, 3, 380, 8128, 8, 380, 3, 380, 8130, 8, 380, 4, 380, 8132, 8, 380, + 11, 380, 12, 380, 8133, 1, 380, 1, 380, 3, 380, 8138, 8, 380, 1, 380, 1, + 380, 1, 380, 3, 380, 8143, 8, 380, 1, 380, 1, 380, 1, 380, 3, 380, 8148, + 8, 380, 5, 380, 8150, 8, 380, 10, 380, 12, 380, 8153, 9, 380, 1, 380, 1, + 380, 1, 380, 3, 380, 8158, 8, 380, 1, 380, 1, 380, 1, 380, 3, 380, 8163, + 8, 380, 1, 380, 1, 380, 1, 380, 3, 380, 8168, 8, 380, 1, 380, 3, 380, 8171, + 8, 380, 1, 380, 1, 380, 1, 381, 1, 381, 1, 381, 1, 381, 1, 382, 1, 382, + 1, 382, 3, 382, 8182, 8, 382, 1, 382, 3, 382, 8185, 8, 382, 1, 382, 3, + 382, 8188, 8, 382, 1, 383, 1, 383, 1, 383, 1, 383, 3, 383, 8194, 8, 383, + 1, 383, 1, 383, 1, 383, 1, 384, 1, 384, 3, 384, 8201, 8, 384, 1, 384, 1, + 384, 1, 384, 3, 384, 8206, 8, 384, 5, 384, 8208, 8, 384, 10, 384, 12, 384, + 8211, 9, 384, 1, 385, 1, 385, 1, 385, 3, 385, 8216, 8, 385, 3, 385, 8218, + 8, 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 8224, 8, 385, 3, 385, 8226, + 8, 385, 5, 385, 8228, 8, 385, 10, 385, 12, 385, 8231, 9, 385, 1, 385, 1, + 385, 1, 385, 1, 385, 1, 385, 1, 385, 3, 385, 8239, 8, 385, 1, 386, 1, 386, + 1, 386, 1, 386, 3, 386, 8245, 8, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, + 386, 5, 386, 8252, 8, 386, 10, 386, 12, 386, 8255, 9, 386, 1, 386, 1, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 8266, 8, + 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 8274, 8, 386, + 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 1, 386, 3, 386, 8283, 8, + 386, 1, 386, 3, 386, 8286, 8, 386, 1, 387, 1, 387, 1, 387, 5, 387, 8291, + 8, 387, 10, 387, 12, 387, 8294, 9, 387, 1, 387, 3, 387, 8297, 8, 387, 1, + 387, 1, 387, 1, 387, 1, 387, 5, 387, 8303, 8, 387, 10, 387, 12, 387, 8306, + 9, 387, 1, 388, 1, 388, 1, 388, 1, 388, 3, 388, 8312, 8, 388, 1, 388, 1, + 388, 1, 389, 1, 389, 1, 389, 1, 389, 4, 389, 8320, 8, 389, 11, 389, 12, + 389, 8321, 1, 389, 1, 389, 1, 389, 4, 389, 8327, 8, 389, 11, 389, 12, 389, + 8328, 1, 390, 1, 390, 1, 390, 3, 390, 8334, 8, 390, 1, 390, 1, 390, 1, + 390, 1, 390, 1, 390, 3, 390, 8341, 8, 390, 1, 390, 1, 390, 1, 390, 1, 390, + 1, 391, 1, 391, 1, 392, 1, 392, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 3, 393, 8358, 8, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, + 393, 3, 393, 8365, 8, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, 393, + 1, 393, 1, 393, 3, 393, 8375, 8, 393, 1, 393, 1, 393, 1, 393, 1, 393, 1, + 393, 4, 393, 8382, 8, 393, 11, 393, 12, 393, 8383, 1, 393, 1, 393, 1, 394, + 1, 394, 1, 394, 1, 394, 1, 394, 3, 394, 8393, 8, 394, 1, 394, 1, 394, 1, + 395, 1, 395, 1, 395, 1, 395, 1, 395, 3, 395, 8402, 8, 395, 1, 395, 5, 395, + 8405, 8, 395, 10, 395, 12, 395, 8408, 9, 395, 1, 395, 1, 395, 3, 395, 8412, + 8, 395, 1, 395, 3, 395, 8415, 8, 395, 1, 395, 1, 395, 1, 396, 1, 396, 1, + 396, 1, 396, 1, 396, 1, 396, 3, 396, 8425, 8, 396, 1, 396, 1, 396, 1, 397, + 1, 397, 1, 397, 1, 397, 1, 398, 1, 398, 1, 398, 3, 398, 8436, 8, 398, 1, + 398, 1, 398, 3, 398, 8440, 8, 398, 1, 398, 3, 398, 8443, 8, 398, 1, 398, + 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 8451, 8, 398, 1, 398, 1, + 398, 1, 398, 1, 398, 3, 398, 8457, 8, 398, 3, 398, 8459, 8, 398, 1, 398, + 1, 398, 1, 398, 3, 398, 8464, 8, 398, 1, 398, 3, 398, 8467, 8, 398, 1, + 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 8474, 8, 398, 1, 398, 1, 398, + 3, 398, 8478, 8, 398, 1, 398, 4, 398, 8481, 8, 398, 11, 398, 12, 398, 8482, + 1, 398, 3, 398, 8486, 8, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, + 398, 1, 398, 1, 398, 1, 398, 1, 398, 1, 398, 3, 398, 8499, 8, 398, 1, 398, + 1, 398, 3, 398, 8503, 8, 398, 1, 399, 1, 399, 1, 399, 3, 399, 8508, 8, + 399, 1, 399, 3, 399, 8511, 8, 399, 1, 399, 1, 399, 1, 399, 1, 400, 1, 400, + 1, 400, 1, 400, 1, 400, 3, 400, 8521, 8, 400, 1, 400, 1, 400, 3, 400, 8525, + 8, 400, 1, 400, 1, 400, 3, 400, 8529, 8, 400, 1, 401, 1, 401, 1, 401, 3, + 401, 8534, 8, 401, 1, 401, 1, 401, 1, 402, 1, 402, 1, 402, 1, 403, 1, 403, + 1, 403, 1, 404, 1, 404, 1, 404, 1, 404, 1, 405, 1, 405, 3, 405, 8550, 8, + 405, 1, 406, 1, 406, 1, 406, 3, 406, 8555, 8, 406, 1, 406, 1, 406, 1, 407, + 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 3, 407, 8567, 8, + 407, 4, 407, 8569, 8, 407, 11, 407, 12, 407, 8570, 1, 407, 1, 407, 1, 407, + 1, 407, 3, 407, 8577, 8, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, + 407, 1, 407, 1, 407, 1, 407, 1, 407, 1, 407, 5, 407, 8590, 8, 407, 10, + 407, 12, 407, 8593, 9, 407, 3, 407, 8595, 8, 407, 3, 407, 8597, 8, 407, + 3, 407, 8599, 8, 407, 4, 407, 8601, 8, 407, 11, 407, 12, 407, 8602, 1, + 407, 3, 407, 8606, 8, 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, 408, 1, 408, 1, 408, + 1, 408, 5, 408, 8624, 8, 408, 10, 408, 12, 408, 8627, 9, 408, 1, 408, 1, + 408, 3, 408, 8631, 8, 408, 1, 408, 1, 408, 1, 408, 3, 408, 8636, 8, 408, + 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 1, 409, 4, 409, 8645, 8, + 409, 11, 409, 12, 409, 8646, 1, 409, 3, 409, 8650, 8, 409, 1, 409, 1, 409, + 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 1, 410, 4, 410, 8660, 8, 410, 11, + 410, 12, 410, 8661, 1, 411, 1, 411, 1, 411, 1, 411, 1, 411, 4, 411, 8669, + 8, 411, 11, 411, 12, 411, 8670, 1, 412, 1, 412, 1, 412, 1, 412, 1, 412, + 1, 412, 1, 412, 4, 412, 8680, 8, 412, 11, 412, 12, 412, 8681, 1, 413, 1, + 413, 1, 413, 1, 413, 1, 413, 5, 413, 8689, 8, 413, 10, 413, 12, 413, 8692, + 9, 413, 1, 413, 1, 413, 3, 413, 8696, 8, 413, 1, 414, 1, 414, 1, 414, 1, + 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, + 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 1, 414, 5, 414, 8718, + 8, 414, 10, 414, 12, 414, 8721, 9, 414, 1, 414, 1, 414, 3, 414, 8725, 8, + 414, 1, 414, 1, 414, 1, 414, 1, 414, 3, 414, 8731, 8, 414, 3, 414, 8733, + 8, 414, 1, 414, 1, 414, 1, 415, 1, 415, 1, 415, 1, 416, 1, 416, 1, 416, + 3, 416, 8743, 8, 416, 1, 416, 3, 416, 8746, 8, 416, 1, 416, 3, 416, 8749, + 8, 416, 1, 416, 3, 416, 8752, 8, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, + 416, 8758, 8, 416, 1, 416, 1, 416, 1, 416, 1, 416, 1, 416, 3, 416, 8765, + 8, 416, 1, 416, 1, 416, 3, 416, 8769, 8, 416, 3, 416, 8771, 8, 416, 1, + 416, 3, 416, 8774, 8, 416, 1, 416, 1, 416, 1, 416, 3, 416, 8779, 8, 416, + 1, 416, 1, 416, 3, 416, 8783, 8, 416, 1, 416, 1, 416, 1, 416, 3, 416, 8788, + 8, 416, 1, 416, 3, 416, 8791, 8, 416, 1, 417, 1, 417, 1, 417, 3, 417, 8796, + 8, 417, 1, 417, 3, 417, 8799, 8, 417, 1, 418, 1, 418, 1, 418, 3, 418, 8804, + 8, 418, 1, 419, 1, 419, 3, 419, 8808, 8, 419, 1, 419, 1, 419, 5, 419, 8812, + 8, 419, 10, 419, 12, 419, 8815, 9, 419, 1, 419, 3, 419, 8818, 8, 419, 4, + 419, 8820, 8, 419, 11, 419, 12, 419, 8821, 1, 419, 1, 419, 1, 420, 1, 420, + 1, 420, 1, 420, 3, 420, 8830, 8, 420, 1, 420, 1, 420, 1, 420, 1, 420, 1, + 420, 1, 420, 1, 420, 1, 420, 1, 420, 5, 420, 8841, 8, 420, 10, 420, 12, + 420, 8844, 9, 420, 1, 420, 3, 420, 8847, 8, 420, 1, 420, 1, 420, 1, 420, + 1, 420, 3, 420, 8853, 8, 420, 1, 420, 3, 420, 8856, 8, 420, 1, 420, 1, + 420, 3, 420, 8860, 8, 420, 1, 420, 1, 420, 1, 420, 3, 420, 8865, 8, 420, + 4, 420, 8867, 8, 420, 11, 420, 12, 420, 8868, 1, 420, 1, 420, 5, 420, 8873, + 8, 420, 10, 420, 12, 420, 8876, 9, 420, 1, 421, 1, 421, 3, 421, 8880, 8, + 421, 1, 421, 3, 421, 8883, 8, 421, 1, 421, 1, 421, 1, 421, 1, 421, 1, 421, + 1, 421, 3, 421, 8891, 8, 421, 1, 421, 3, 421, 8894, 8, 421, 1, 422, 1, + 422, 1, 422, 1, 422, 1, 422, 1, 422, 1, 422, 3, 422, 8903, 8, 422, 1, 422, + 1, 422, 3, 422, 8907, 8, 422, 3, 422, 8909, 8, 422, 1, 423, 1, 423, 1, + 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, + 423, 1, 423, 1, 423, 1, 423, 1, 423, 1, 423, 3, 423, 8928, 8, 423, 1, 423, + 1, 423, 1, 423, 1, 423, 3, 423, 8934, 8, 423, 1, 423, 4, 423, 8937, 8, + 423, 11, 423, 12, 423, 8938, 1, 423, 1, 423, 1, 423, 3, 423, 8944, 8, 423, + 3, 423, 8946, 8, 423, 1, 424, 1, 424, 3, 424, 8950, 8, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 5, 424, 8957, 8, 424, 10, 424, 12, 424, 8960, + 9, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, + 5, 424, 8970, 8, 424, 10, 424, 12, 424, 8973, 9, 424, 1, 424, 1, 424, 1, + 424, 1, 424, 1, 424, 1, 424, 1, 424, 1, 424, 3, 424, 8983, 8, 424, 1, 424, + 3, 424, 8986, 8, 424, 1, 425, 3, 425, 8989, 8, 425, 1, 425, 1, 425, 1, + 425, 1, 425, 1, 425, 1, 425, 1, 425, 4, 425, 8998, 8, 425, 11, 425, 12, + 425, 8999, 1, 426, 1, 426, 1, 426, 3, 426, 9005, 8, 426, 1, 426, 1, 426, + 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 1, 426, 5, 426, 9015, 8, 426, 10, + 426, 12, 426, 9018, 9, 426, 1, 426, 1, 426, 3, 426, 9022, 8, 426, 1, 427, + 1, 427, 3, 427, 9026, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, + 427, 3, 427, 9034, 8, 427, 1, 427, 1, 427, 1, 427, 1, 427, 1, 427, 3, 427, + 9041, 8, 427, 1, 427, 1, 427, 1, 427, 3, 427, 9046, 8, 427, 1, 427, 1, + 427, 1, 427, 3, 427, 9051, 8, 427, 1, 428, 1, 428, 1, 429, 1, 429, 1, 430, + 1, 430, 1, 430, 1, 430, 1, 430, 3, 430, 9062, 8, 430, 1, 430, 3, 430, 9065, + 8, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, + 1, 430, 1, 430, 3, 430, 9077, 8, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, + 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 1, 430, 3, + 430, 9092, 8, 430, 1, 430, 1, 430, 1, 431, 1, 431, 1, 431, 3, 431, 9099, + 8, 431, 1, 431, 1, 431, 1, 431, 1, 431, 3, 431, 9105, 8, 431, 1, 431, 1, + 431, 3, 431, 9109, 8, 431, 1, 431, 1, 431, 1, 431, 1, 431, 3, 431, 9115, + 8, 431, 1, 431, 1, 431, 3, 431, 9119, 8, 431, 1, 431, 1, 431, 1, 431, 1, + 431, 1, 431, 5, 431, 9126, 8, 431, 10, 431, 12, 431, 9129, 9, 431, 1, 431, + 1, 431, 1, 431, 1, 431, 5, 431, 9135, 8, 431, 10, 431, 12, 431, 9138, 9, + 431, 1, 431, 1, 431, 3, 431, 9142, 8, 431, 1, 432, 1, 432, 3, 432, 9146, + 8, 432, 1, 432, 1, 432, 3, 432, 9150, 8, 432, 1, 433, 1, 433, 1, 433, 1, + 433, 3, 433, 9156, 8, 433, 1, 434, 1, 434, 1, 435, 1, 435, 1, 435, 3, 435, + 9163, 8, 435, 1, 435, 1, 435, 1, 435, 1, 435, 3, 435, 9169, 8, 435, 1, + 436, 1, 436, 1, 436, 1, 437, 1, 437, 1, 438, 1, 438, 3, 438, 9178, 8, 438, + 1, 438, 1, 438, 1, 438, 3, 438, 9183, 8, 438, 1, 438, 1, 438, 1, 439, 1, + 439, 1, 439, 3, 439, 9190, 8, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, + 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, 1, 439, + 1, 439, 5, 439, 9207, 8, 439, 10, 439, 12, 439, 9210, 9, 439, 1, 440, 1, + 440, 1, 440, 1, 441, 1, 441, 1, 442, 1, 442, 1, 442, 1, 442, 1, 442, 1, + 442, 1, 442, 3, 442, 9224, 8, 442, 3, 442, 9226, 8, 442, 1, 443, 1, 443, + 1, 443, 1, 443, 1, 443, 1, 444, 1, 444, 1, 444, 1, 444, 3, 444, 9237, 8, + 444, 1, 444, 3, 444, 9240, 8, 444, 1, 444, 3, 444, 9243, 8, 444, 1, 445, + 1, 445, 1, 445, 1, 445, 3, 445, 9249, 8, 445, 1, 445, 3, 445, 9252, 8, + 445, 1, 445, 3, 445, 9255, 8, 445, 1, 446, 1, 446, 1, 446, 1, 447, 1, 447, + 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 3, 447, 9267, 8, 447, 1, 447, 1, + 447, 1, 447, 1, 447, 1, 447, 1, 447, 1, 447, 5, 447, 9276, 8, 447, 10, + 447, 12, 447, 9279, 9, 447, 3, 447, 9281, 8, 447, 1, 447, 4, 447, 9284, + 8, 447, 11, 447, 12, 447, 9285, 1, 447, 1, 447, 3, 447, 9290, 8, 447, 1, + 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 3, 448, 9298, 8, 448, 1, 448, + 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, 1, 448, + 1, 448, 3, 448, 9311, 8, 448, 1, 449, 1, 449, 3, 449, 9315, 8, 449, 1, + 449, 1, 449, 3, 449, 9319, 8, 449, 1, 450, 1, 450, 3, 450, 9323, 8, 450, + 1, 450, 3, 450, 9326, 8, 450, 1, 450, 3, 450, 9329, 8, 450, 1, 450, 3, + 450, 9332, 8, 450, 1, 450, 3, 450, 9335, 8, 450, 1, 451, 1, 451, 1, 451, + 1, 451, 1, 451, 1, 451, 1, 451, 1, 451, 3, 451, 9345, 8, 451, 1, 451, 3, + 451, 9348, 8, 451, 1, 452, 1, 452, 1, 453, 1, 453, 1, 453, 1, 453, 1, 453, + 3, 453, 9357, 8, 453, 1, 454, 1, 454, 3, 454, 9361, 8, 454, 1, 454, 1, + 454, 1, 454, 1, 454, 5, 454, 9367, 8, 454, 10, 454, 12, 454, 9370, 9, 454, + 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 1, 454, 5, 454, + 9380, 8, 454, 10, 454, 12, 454, 9383, 9, 454, 3, 454, 9385, 8, 454, 3, + 454, 9387, 8, 454, 1, 454, 1, 454, 3, 454, 9391, 8, 454, 1, 455, 1, 455, + 3, 455, 9395, 8, 455, 1, 455, 1, 455, 1, 456, 1, 456, 3, 456, 9401, 8, + 456, 1, 456, 1, 456, 1, 457, 3, 457, 9406, 8, 457, 1, 457, 1, 457, 3, 457, + 9410, 8, 457, 1, 457, 3, 457, 9413, 8, 457, 1, 457, 3, 457, 9416, 8, 457, + 1, 458, 1, 458, 1, 458, 1, 458, 1, 458, 5, 458, 9423, 8, 458, 10, 458, + 12, 458, 9426, 9, 458, 1, 458, 1, 458, 3, 458, 9430, 8, 458, 1, 458, 1, + 458, 3, 458, 9434, 8, 458, 1, 458, 1, 458, 3, 458, 9438, 8, 458, 1, 458, + 3, 458, 9441, 8, 458, 1, 459, 1, 459, 1, 459, 1, 459, 1, 459, 3, 459, 9448, + 8, 459, 1, 459, 3, 459, 9451, 8, 459, 3, 459, 9453, 8, 459, 1, 460, 1, + 460, 1, 460, 3, 460, 9458, 8, 460, 1, 461, 1, 461, 1, 461, 1, 462, 1, 462, + 1, 462, 1, 463, 1, 463, 1, 463, 3, 463, 9469, 8, 463, 3, 463, 9471, 8, + 463, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, + 464, 1, 464, 5, 464, 9483, 8, 464, 10, 464, 12, 464, 9486, 9, 464, 1, 464, + 1, 464, 1, 464, 5, 464, 9491, 8, 464, 10, 464, 12, 464, 9494, 9, 464, 1, + 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 3, 464, 9502, 8, 464, 1, 464, + 3, 464, 9505, 8, 464, 1, 464, 1, 464, 1, 464, 3, 464, 9510, 8, 464, 1, + 464, 3, 464, 9513, 8, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, 1, 464, + 1, 464, 3, 464, 9522, 8, 464, 1, 464, 1, 464, 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, 3, 466, 9544, 8, 466, 1, 466, + 1, 466, 1, 466, 1, 466, 3, 466, 9550, 8, 466, 1, 466, 1, 466, 1, 466, 4, + 466, 9555, 8, 466, 11, 466, 12, 466, 9556, 1, 467, 1, 467, 1, 468, 1, 468, + 1, 468, 1, 468, 1, 468, 1, 468, 3, 468, 9567, 8, 468, 1, 468, 1, 468, 1, + 469, 1, 469, 1, 469, 1, 469, 1, 469, 3, 469, 9576, 8, 469, 1, 469, 1, 469, + 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 1, 469, 3, 469, + 9588, 8, 469, 1, 469, 3, 469, 9591, 8, 469, 1, 469, 3, 469, 9594, 8, 469, + 1, 469, 1, 469, 1, 470, 1, 470, 1, 470, 1, 470, 1, 470, 1, 471, 1, 471, + 1, 471, 3, 471, 9606, 8, 471, 1, 472, 1, 472, 1, 472, 1, 472, 1, 472, 1, + 472, 1, 472, 3, 472, 9615, 8, 472, 1, 472, 1, 472, 1, 472, 1, 472, 5, 472, + 9621, 8, 472, 10, 472, 12, 472, 9624, 9, 472, 1, 472, 1, 472, 3, 472, 9628, + 8, 472, 1, 472, 1, 472, 1, 472, 1, 472, 5, 472, 9634, 8, 472, 10, 472, + 12, 472, 9637, 9, 472, 1, 472, 1, 472, 3, 472, 9641, 8, 472, 1, 472, 3, + 472, 9644, 8, 472, 1, 473, 1, 473, 1, 474, 1, 474, 1, 475, 1, 475, 1, 476, + 1, 476, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, + 1, 477, 1, 477, 1, 477, 4, 477, 9665, 8, 477, 11, 477, 12, 477, 9666, 3, + 477, 9669, 8, 477, 1, 477, 3, 477, 9672, 8, 477, 1, 477, 1, 477, 3, 477, + 9676, 8, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, 477, 1, + 477, 3, 477, 9686, 8, 477, 5, 477, 9688, 8, 477, 10, 477, 12, 477, 9691, + 9, 477, 1, 477, 1, 477, 3, 477, 9695, 8, 477, 1, 477, 4, 477, 9698, 8, + 477, 11, 477, 12, 477, 9699, 1, 477, 1, 477, 3, 477, 9704, 8, 477, 3, 477, + 9706, 8, 477, 1, 477, 3, 477, 9709, 8, 477, 5, 477, 9711, 8, 477, 10, 477, + 12, 477, 9714, 9, 477, 1, 478, 1, 478, 1, 478, 1, 478, 1, 479, 1, 479, + 1, 479, 3, 479, 9723, 8, 479, 1, 480, 1, 480, 1, 480, 1, 480, 1, 480, 1, + 480, 1, 480, 1, 480, 3, 480, 9733, 8, 480, 1, 480, 3, 480, 9736, 8, 480, + 1, 480, 3, 480, 9739, 8, 480, 1, 480, 1, 480, 3, 480, 9743, 8, 480, 1, + 480, 1, 480, 3, 480, 9747, 8, 480, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, + 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 1, 481, 3, 481, 9760, 8, 481, 1, + 482, 1, 482, 1, 482, 1, 482, 1, 482, 1, 483, 1, 483, 3, 483, 9769, 8, 483, + 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, 1, 483, + 3, 483, 9780, 8, 483, 3, 483, 9782, 8, 483, 1, 484, 1, 484, 1, 484, 1, + 484, 1, 484, 1, 484, 1, 484, 1, 484, 1, 484, 4, 484, 9793, 8, 484, 11, + 484, 12, 484, 9794, 1, 485, 1, 485, 1, 485, 3, 485, 9800, 8, 485, 1, 486, + 1, 486, 1, 486, 3, 486, 9805, 8, 486, 1, 487, 1, 487, 1, 487, 5, 487, 9810, + 8, 487, 10, 487, 12, 487, 9813, 9, 487, 1, 488, 1, 488, 1, 488, 1, 488, + 1, 488, 1, 488, 1, 489, 1, 489, 1, 489, 1, 490, 1, 490, 1, 490, 1, 490, + 1, 490, 1, 490, 3, 490, 9830, 8, 490, 1, 491, 1, 491, 1, 491, 1, 491, 3, + 491, 9836, 8, 491, 1, 492, 1, 492, 1, 492, 3, 492, 9841, 8, 492, 1, 492, + 1, 492, 1, 492, 1, 492, 1, 492, 1, 492, 5, 492, 9849, 8, 492, 10, 492, + 12, 492, 9852, 9, 492, 1, 492, 1, 492, 1, 492, 3, 492, 9857, 8, 492, 1, + 493, 1, 493, 1, 493, 1, 493, 5, 493, 9863, 8, 493, 10, 493, 12, 493, 9866, + 9, 493, 1, 493, 1, 493, 1, 493, 3, 493, 9871, 8, 493, 1, 493, 1, 493, 3, + 493, 9875, 8, 493, 1, 493, 3, 493, 9878, 8, 493, 1, 493, 1, 493, 1, 494, + 1, 494, 1, 494, 1, 494, 1, 495, 1, 495, 1, 495, 1, 495, 3, 495, 9890, 8, + 495, 1, 496, 1, 496, 1, 496, 5, 496, 9895, 8, 496, 10, 496, 12, 496, 9898, + 9, 496, 1, 497, 1, 497, 1, 497, 1, 497, 1, 497, 5, 497, 9905, 8, 497, 10, + 497, 12, 497, 9908, 9, 497, 1, 497, 1, 497, 1, 498, 1, 498, 1, 498, 1, + 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 1, 498, 3, 498, 9922, 8, 498, + 1, 498, 1, 498, 1, 498, 3, 498, 9927, 8, 498, 1, 499, 1, 499, 1, 499, 1, + 500, 1, 500, 1, 500, 1, 500, 1, 500, 1, 500, 5, 500, 9938, 8, 500, 10, + 500, 12, 500, 9941, 9, 500, 1, 500, 1, 500, 3, 500, 9945, 8, 500, 1, 501, + 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 3, 501, 9953, 8, 501, 1, 501, 1, + 501, 1, 501, 3, 501, 9958, 8, 501, 1, 501, 1, 501, 1, 501, 3, 501, 9963, + 8, 501, 5, 501, 9965, 8, 501, 10, 501, 12, 501, 9968, 9, 501, 1, 501, 1, + 501, 3, 501, 9972, 8, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, + 3, 501, 9980, 8, 501, 1, 501, 3, 501, 9983, 8, 501, 1, 501, 3, 501, 9986, + 8, 501, 1, 501, 3, 501, 9989, 8, 501, 1, 501, 3, 501, 9992, 8, 501, 3, + 501, 9994, 8, 501, 1, 501, 1, 501, 1, 501, 1, 501, 1, 501, 4, 501, 10001, + 8, 501, 11, 501, 12, 501, 10002, 5, 501, 10005, 8, 501, 10, 501, 12, 501, + 10008, 9, 501, 1, 501, 1, 501, 1, 501, 3, 501, 10013, 8, 501, 1, 501, 3, + 501, 10016, 8, 501, 1, 501, 1, 501, 3, 501, 10020, 8, 501, 1, 501, 1, 501, + 1, 501, 3, 501, 10025, 8, 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, 3, 502, + 10040, 8, 502, 1, 502, 1, 502, 1, 503, 1, 503, 3, 503, 10046, 8, 503, 1, + 503, 1, 503, 3, 503, 10050, 8, 503, 1, 504, 1, 504, 1, 504, 1, 504, 1, + 504, 1, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10061, 8, 504, 1, 504, 1, + 504, 1, 504, 1, 504, 3, 504, 10067, 8, 504, 1, 504, 1, 504, 1, 504, 3, + 504, 10072, 8, 504, 1, 504, 1, 504, 1, 504, 3, 504, 10077, 8, 504, 1, 504, + 1, 504, 1, 504, 3, 504, 10082, 8, 504, 1, 504, 1, 504, 1, 504, 4, 504, + 10087, 8, 504, 11, 504, 12, 504, 10088, 3, 504, 10091, 8, 504, 1, 505, + 1, 505, 1, 505, 1, 505, 1, 505, 1, 505, 3, 505, 10099, 8, 505, 1, 505, + 1, 505, 1, 506, 1, 506, 1, 506, 3, 506, 10106, 8, 506, 1, 506, 1, 506, + 1, 506, 1, 506, 1, 506, 1, 506, 3, 506, 10114, 8, 506, 1, 506, 1, 506, + 1, 506, 1, 506, 1, 506, 3, 506, 10121, 8, 506, 1, 506, 1, 506, 1, 507, + 1, 507, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, + 10134, 8, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, 10140, 8, 508, 5, + 508, 10142, 8, 508, 10, 508, 12, 508, 10145, 9, 508, 1, 508, 1, 508, 1, + 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, 10156, 8, + 508, 1, 508, 1, 508, 1, 508, 1, 508, 1, 508, 3, 508, 10163, 8, 508, 5, + 508, 10165, 8, 508, 10, 508, 12, 508, 10168, 9, 508, 1, 508, 3, 508, 10171, + 8, 508, 1, 508, 3, 508, 10174, 8, 508, 1, 508, 3, 508, 10177, 8, 508, 1, + 508, 1, 508, 1, 509, 1, 509, 3, 509, 10183, 8, 509, 1, 509, 1, 509, 1, + 509, 1, 509, 1, 509, 4, 509, 10190, 8, 509, 11, 509, 12, 509, 10191, 1, + 509, 3, 509, 10195, 8, 509, 1, 510, 1, 510, 1, 510, 1, 510, 1, 510, 1, + 510, 3, 510, 10203, 8, 510, 3, 510, 10205, 8, 510, 1, 511, 1, 511, 1, 511, + 1, 511, 3, 511, 10211, 8, 511, 1, 511, 1, 511, 1, 511, 1, 511, 3, 511, + 10217, 8, 511, 1, 511, 1, 511, 1, 511, 3, 511, 10222, 8, 511, 3, 511, 10224, + 8, 511, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 1, 512, 3, 512, 10232, + 8, 512, 1, 513, 1, 513, 1, 513, 1, 514, 1, 514, 1, 514, 1, 515, 1, 515, + 1, 515, 3, 515, 10243, 8, 515, 1, 515, 3, 515, 10246, 8, 515, 1, 515, 1, + 515, 3, 515, 10250, 8, 515, 1, 515, 1, 515, 3, 515, 10254, 8, 515, 1, 515, + 3, 515, 10257, 8, 515, 1, 515, 1, 515, 1, 515, 3, 515, 10262, 8, 515, 1, + 515, 1, 515, 3, 515, 10266, 8, 515, 1, 516, 1, 516, 3, 516, 10270, 8, 516, + 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 1, 516, 3, 516, 10279, + 8, 516, 1, 516, 1, 516, 1, 516, 1, 516, 3, 516, 10285, 8, 516, 1, 516, + 1, 516, 1, 516, 1, 516, 3, 516, 10291, 8, 516, 1, 517, 1, 517, 1, 517, + 1, 517, 3, 517, 10297, 8, 517, 1, 517, 3, 517, 10300, 8, 517, 1, 518, 1, + 518, 1, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10308, 8, 518, 1, 518, 1, + 518, 3, 518, 10312, 8, 518, 1, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10318, + 8, 518, 1, 518, 1, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10325, 8, 518, + 1, 518, 1, 518, 3, 518, 10329, 8, 518, 3, 518, 10331, 8, 518, 1, 518, 1, + 518, 1, 518, 3, 518, 10336, 8, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10341, + 8, 518, 1, 518, 1, 518, 1, 518, 3, 518, 10346, 8, 518, 1, 518, 1, 518, + 3, 518, 10350, 8, 518, 1, 518, 1, 518, 1, 519, 1, 519, 1, 519, 1, 519, + 1, 519, 1, 519, 3, 519, 10360, 8, 519, 1, 519, 1, 519, 3, 519, 10364, 8, + 519, 1, 519, 3, 519, 10367, 8, 519, 1, 519, 3, 519, 10370, 8, 519, 1, 519, + 1, 519, 1, 519, 1, 519, 3, 519, 10376, 8, 519, 1, 519, 3, 519, 10379, 8, + 519, 1, 519, 3, 519, 10382, 8, 519, 1, 519, 3, 519, 10385, 8, 519, 1, 519, + 1, 519, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, + 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 1, 520, 5, 520, 10404, + 8, 520, 10, 520, 12, 520, 10407, 9, 520, 1, 520, 1, 520, 1, 521, 1, 521, + 3, 521, 10413, 8, 521, 1, 521, 1, 521, 3, 521, 10417, 8, 521, 1, 521, 3, + 521, 10420, 8, 521, 1, 522, 1, 522, 1, 522, 1, 522, 1, 522, 3, 522, 10427, + 8, 522, 1, 522, 1, 522, 1, 522, 3, 522, 10432, 8, 522, 1, 522, 1, 522, + 1, 522, 1, 522, 1, 522, 3, 522, 10439, 8, 522, 1, 522, 1, 522, 1, 522, + 1, 522, 3, 522, 10445, 8, 522, 3, 522, 10447, 8, 522, 1, 522, 1, 522, 1, + 522, 1, 522, 3, 522, 10453, 8, 522, 1, 523, 1, 523, 3, 523, 10457, 8, 523, + 1, 523, 1, 523, 1, 523, 1, 523, 1, 523, 3, 523, 10464, 8, 523, 1, 523, + 1, 523, 1, 523, 3, 523, 10469, 8, 523, 1, 524, 1, 524, 1, 524, 1, 524, + 3, 524, 10475, 8, 524, 1, 524, 1, 524, 3, 524, 10479, 8, 524, 1, 524, 1, + 524, 1, 524, 1, 524, 5, 524, 10485, 8, 524, 10, 524, 12, 524, 10488, 9, + 524, 1, 524, 1, 524, 3, 524, 10492, 8, 524, 1, 524, 1, 524, 1, 524, 1, + 524, 3, 524, 10498, 8, 524, 1, 524, 3, 524, 10501, 8, 524, 1, 524, 3, 524, + 10504, 8, 524, 1, 524, 3, 524, 10507, 8, 524, 1, 524, 1, 524, 1, 525, 1, + 525, 1, 526, 1, 526, 3, 526, 10515, 8, 526, 1, 526, 1, 526, 1, 526, 1, + 526, 4, 526, 10521, 8, 526, 11, 526, 12, 526, 10522, 1, 526, 1, 526, 1, + 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 1, 527, 3, 527, 10534, 8, + 527, 1, 528, 1, 528, 3, 528, 10538, 8, 528, 1, 528, 1, 528, 3, 528, 10542, + 8, 528, 1, 528, 1, 528, 1, 528, 5, 528, 10547, 8, 528, 10, 528, 12, 528, + 10550, 9, 528, 1, 528, 3, 528, 10553, 8, 528, 1, 528, 1, 528, 1, 528, 3, + 528, 10558, 8, 528, 1, 529, 3, 529, 10561, 8, 529, 1, 529, 1, 529, 1, 529, + 1, 529, 1, 529, 1, 530, 1, 530, 1, 530, 1, 530, 5, 530, 10572, 8, 530, + 10, 530, 12, 530, 10575, 9, 530, 1, 530, 1, 530, 3, 530, 10579, 8, 530, + 1, 530, 1, 530, 3, 530, 10583, 8, 530, 1, 530, 1, 530, 1, 530, 3, 530, + 10588, 8, 530, 1, 530, 1, 530, 1, 530, 1, 530, 3, 530, 10594, 8, 530, 1, + 530, 1, 530, 1, 530, 1, 530, 3, 530, 10600, 8, 530, 1, 530, 3, 530, 10603, + 8, 530, 1, 530, 1, 530, 1, 531, 3, 531, 10608, 8, 531, 1, 531, 3, 531, + 10611, 8, 531, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, 1, 532, + 3, 532, 10620, 8, 532, 1, 533, 1, 533, 1, 533, 3, 533, 10625, 8, 533, 1, + 533, 1, 533, 1, 533, 1, 533, 1, 533, 1, 533, 3, 533, 10633, 8, 533, 3, + 533, 10635, 8, 533, 1, 534, 1, 534, 1, 534, 1, 534, 1, 535, 1, 535, 1, + 535, 1, 535, 1, 535, 1, 535, 1, 535, 3, 535, 10648, 8, 535, 1, 536, 1, + 536, 1, 536, 3, 536, 10653, 8, 536, 1, 536, 1, 536, 1, 536, 1, 536, 1, + 536, 1, 536, 3, 536, 10661, 8, 536, 3, 536, 10663, 8, 536, 1, 537, 1, 537, + 1, 537, 1, 537, 1, 537, 1, 537, 1, 538, 1, 538, 1, 539, 3, 539, 10674, + 8, 539, 1, 539, 3, 539, 10677, 8, 539, 1, 539, 3, 539, 10680, 8, 539, 1, + 539, 3, 539, 10683, 8, 539, 1, 539, 3, 539, 10686, 8, 539, 1, 539, 3, 539, + 10689, 8, 539, 1, 539, 3, 539, 10692, 8, 539, 1, 539, 3, 539, 10695, 8, + 539, 1, 539, 3, 539, 10698, 8, 539, 1, 539, 5, 539, 10701, 8, 539, 10, + 539, 12, 539, 10704, 9, 539, 1, 539, 3, 539, 10707, 8, 539, 1, 539, 3, + 539, 10710, 8, 539, 1, 539, 3, 539, 10713, 8, 539, 1, 539, 3, 539, 10716, + 8, 539, 1, 539, 1, 539, 3, 539, 10720, 8, 539, 1, 539, 1, 539, 1, 539, + 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 1, 539, 3, 539, 10731, 8, 539, + 1, 539, 3, 539, 10734, 8, 539, 1, 540, 1, 540, 1, 540, 1, 541, 1, 541, + 1, 541, 1, 542, 1, 542, 3, 542, 10744, 8, 542, 1, 542, 1, 542, 3, 542, + 10748, 8, 542, 1, 542, 1, 542, 3, 542, 10752, 8, 542, 1, 542, 3, 542, 10755, + 8, 542, 1, 542, 1, 542, 1, 542, 3, 542, 10760, 8, 542, 1, 542, 3, 542, + 10763, 8, 542, 1, 543, 1, 543, 1, 543, 3, 543, 10768, 8, 543, 1, 543, 1, + 543, 1, 543, 1, 543, 5, 543, 10774, 8, 543, 10, 543, 12, 543, 10777, 9, + 543, 1, 544, 1, 544, 1, 544, 1, 544, 3, 544, 10783, 8, 544, 1, 544, 1, + 544, 1, 544, 1, 544, 1, 544, 1, 544, 1, 545, 1, 545, 1, 546, 1, 546, 3, + 546, 10795, 8, 546, 1, 546, 1, 546, 1, 546, 1, 547, 1, 547, 1, 547, 1, + 547, 1, 547, 5, 547, 10805, 8, 547, 10, 547, 12, 547, 10808, 9, 547, 1, + 547, 1, 547, 3, 547, 10812, 8, 547, 1, 548, 1, 548, 1, 548, 1, 548, 5, + 548, 10818, 8, 548, 10, 548, 12, 548, 10821, 9, 548, 1, 548, 1, 548, 1, + 549, 1, 549, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 1, 550, 3, + 550, 10834, 8, 550, 1, 550, 1, 550, 1, 550, 3, 550, 10839, 8, 550, 1, 551, + 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 1, 551, 3, 551, + 10850, 8, 551, 1, 551, 3, 551, 10853, 8, 551, 3, 551, 10855, 8, 551, 1, + 552, 1, 552, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 1, 553, 3, 553, 10865, + 8, 553, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, 1, 554, + 3, 554, 10875, 8, 554, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, + 1, 555, 5, 555, 10884, 8, 555, 10, 555, 12, 555, 10887, 9, 555, 1, 555, + 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, + 1, 555, 5, 555, 10900, 8, 555, 10, 555, 12, 555, 10903, 9, 555, 1, 555, + 1, 555, 3, 555, 10907, 8, 555, 3, 555, 10909, 8, 555, 1, 555, 1, 555, 1, + 555, 3, 555, 10914, 8, 555, 1, 555, 1, 555, 1, 555, 1, 555, 1, 555, 3, + 555, 10921, 8, 555, 1, 555, 1, 555, 1, 555, 5, 555, 10926, 8, 555, 10, + 555, 12, 555, 10929, 9, 555, 1, 555, 1, 555, 1, 556, 1, 556, 1, 556, 1, + 556, 1, 556, 1, 556, 1, 556, 1, 556, 1, 556, 3, 556, 10942, 8, 556, 1, + 556, 1, 556, 1, 556, 1, 556, 1, 556, 3, 556, 10949, 8, 556, 1, 556, 1, + 556, 1, 556, 5, 556, 10954, 8, 556, 10, 556, 12, 556, 10957, 9, 556, 1, + 556, 1, 556, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 1, 557, 5, + 557, 10968, 8, 557, 10, 557, 12, 557, 10971, 9, 557, 1, 557, 1, 557, 1, + 557, 3, 557, 10976, 8, 557, 1, 558, 1, 558, 1, 558, 3, 558, 10981, 8, 558, + 1, 558, 3, 558, 10984, 8, 558, 1, 558, 1, 558, 1, 558, 3, 558, 10989, 8, + 558, 1, 558, 3, 558, 10992, 8, 558, 5, 558, 10994, 8, 558, 10, 558, 12, + 558, 10997, 9, 558, 1, 558, 1, 558, 1, 559, 1, 559, 1, 559, 1, 559, 1, + 559, 1, 559, 1, 559, 1, 559, 5, 559, 11009, 8, 559, 10, 559, 12, 559, 11012, + 9, 559, 1, 559, 1, 559, 3, 559, 11016, 8, 559, 1, 559, 1, 559, 3, 559, + 11020, 8, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, 1, 559, + 5, 559, 11029, 8, 559, 10, 559, 12, 559, 11032, 9, 559, 1, 559, 1, 559, + 3, 559, 11036, 8, 559, 1, 560, 1, 560, 1, 561, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 561, 5, 561, 11047, 8, 561, 10, 561, 12, 561, 11050, + 9, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, 1, 561, + 1, 561, 1, 561, 1, 561, 5, 561, 11063, 8, 561, 10, 561, 12, 561, 11066, + 9, 561, 1, 561, 1, 561, 3, 561, 11070, 8, 561, 3, 561, 11072, 8, 561, 1, + 561, 1, 561, 1, 561, 3, 561, 11077, 8, 561, 1, 561, 1, 561, 1, 561, 1, + 561, 5, 561, 11083, 8, 561, 10, 561, 12, 561, 11086, 9, 561, 1, 561, 1, + 561, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, 562, 1, + 562, 3, 562, 11099, 8, 562, 1, 562, 1, 562, 1, 562, 1, 562, 5, 562, 11105, + 8, 562, 10, 562, 12, 562, 11108, 9, 562, 1, 562, 1, 562, 1, 563, 1, 563, + 1, 563, 1, 563, 1, 563, 1, 563, 4, 563, 11118, 8, 563, 11, 563, 12, 563, + 11119, 1, 563, 1, 563, 1, 563, 1, 563, 3, 563, 11126, 8, 563, 1, 563, 1, + 563, 3, 563, 11130, 8, 563, 1, 564, 1, 564, 1, 564, 1, 564, 1, 564, 1, + 564, 1, 564, 1, 564, 1, 564, 1, 564, 5, 564, 11142, 8, 564, 10, 564, 12, + 564, 11145, 9, 564, 1, 564, 1, 564, 3, 564, 11149, 8, 564, 1, 565, 1, 565, + 3, 565, 11153, 8, 565, 1, 565, 1, 565, 1, 566, 1, 566, 1, 566, 1, 566, + 1, 566, 1, 566, 1, 566, 1, 566, 5, 566, 11165, 8, 566, 10, 566, 12, 566, + 11168, 9, 566, 3, 566, 11170, 8, 566, 1, 567, 1, 567, 3, 567, 11174, 8, + 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 1, 567, 5, 567, 11182, 8, + 567, 10, 567, 12, 567, 11185, 9, 567, 1, 567, 1, 567, 1, 567, 5, 567, 11190, + 8, 567, 10, 567, 12, 567, 11193, 9, 567, 1, 567, 1, 567, 1, 567, 5, 567, + 11198, 8, 567, 10, 567, 12, 567, 11201, 9, 567, 3, 567, 11203, 8, 567, + 1, 567, 1, 567, 1, 567, 3, 567, 11208, 8, 567, 3, 567, 11210, 8, 567, 1, + 568, 1, 568, 3, 568, 11214, 8, 568, 1, 568, 1, 568, 1, 568, 1, 568, 1, + 568, 1, 568, 5, 568, 11222, 8, 568, 10, 568, 12, 568, 11225, 9, 568, 1, + 568, 1, 568, 1, 568, 5, 568, 11230, 8, 568, 10, 568, 12, 568, 11233, 9, + 568, 1, 568, 1, 568, 1, 568, 5, 568, 11238, 8, 568, 10, 568, 12, 568, 11241, + 9, 568, 3, 568, 11243, 8, 568, 1, 568, 1, 568, 1, 568, 3, 568, 11248, 8, + 568, 3, 568, 11250, 8, 568, 1, 569, 1, 569, 1, 569, 1, 569, 1, 569, 1, + 569, 5, 569, 11258, 8, 569, 10, 569, 12, 569, 11261, 9, 569, 1, 569, 1, + 569, 1, 569, 5, 569, 11266, 8, 569, 10, 569, 12, 569, 11269, 9, 569, 1, + 569, 1, 569, 1, 569, 5, 569, 11274, 8, 569, 10, 569, 12, 569, 11277, 9, + 569, 3, 569, 11279, 8, 569, 1, 569, 1, 569, 1, 569, 3, 569, 11284, 8, 569, + 1, 570, 1, 570, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, 1, 571, + 5, 571, 11295, 8, 571, 10, 571, 12, 571, 11298, 9, 571, 1, 571, 1, 571, + 3, 571, 11302, 8, 571, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, 1, 572, + 1, 572, 3, 572, 11311, 8, 572, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, + 1, 573, 1, 573, 5, 573, 11320, 8, 573, 10, 573, 12, 573, 11323, 9, 573, + 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, 1, 573, + 5, 573, 11334, 8, 573, 10, 573, 12, 573, 11337, 9, 573, 1, 573, 1, 573, + 3, 573, 11341, 8, 573, 1, 573, 3, 573, 11344, 8, 573, 1, 574, 1, 574, 1, + 575, 1, 575, 3, 575, 11350, 8, 575, 1, 575, 1, 575, 3, 575, 11354, 8, 575, + 1, 576, 1, 576, 3, 576, 11358, 8, 576, 1, 576, 1, 576, 3, 576, 11362, 8, + 576, 1, 577, 1, 577, 3, 577, 11366, 8, 577, 1, 577, 3, 577, 11369, 8, 577, + 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 1, 578, 5, 578, + 11379, 8, 578, 10, 578, 12, 578, 11382, 9, 578, 1, 578, 1, 578, 3, 578, + 11386, 8, 578, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, 1, 579, + 5, 579, 11395, 8, 579, 10, 579, 12, 579, 11398, 9, 579, 1, 579, 1, 579, + 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 5, 580, 11407, 8, 580, 10, 580, + 12, 580, 11410, 9, 580, 1, 580, 1, 580, 1, 580, 1, 580, 1, 580, 5, 580, + 11417, 8, 580, 10, 580, 12, 580, 11420, 9, 580, 1, 580, 3, 580, 11423, + 8, 580, 1, 580, 1, 580, 1, 581, 3, 581, 11428, 8, 581, 1, 581, 3, 581, + 11431, 8, 581, 1, 581, 1, 581, 3, 581, 11435, 8, 581, 1, 581, 1, 581, 3, + 581, 11439, 8, 581, 3, 581, 11441, 8, 581, 1, 581, 1, 581, 1, 581, 5, 581, + 11446, 8, 581, 10, 581, 12, 581, 11449, 9, 581, 1, 582, 1, 582, 1, 582, + 1, 582, 1, 582, 3, 582, 11456, 8, 582, 1, 582, 1, 582, 1, 582, 1, 582, + 1, 582, 1, 582, 1, 582, 1, 582, 3, 582, 11466, 8, 582, 1, 582, 1, 582, + 1, 582, 4, 582, 11471, 8, 582, 11, 582, 12, 582, 11472, 1, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 3, 583, 11482, 8, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 1, 583, 3, 583, 11490, 8, 583, 1, 583, + 1, 583, 1, 583, 1, 583, 1, 583, 3, 583, 11497, 8, 583, 1, 584, 1, 584, + 1, 584, 3, 584, 11502, 8, 584, 1, 584, 1, 584, 3, 584, 11506, 8, 584, 1, + 584, 1, 584, 1, 584, 3, 584, 11511, 8, 584, 1, 584, 1, 584, 1, 584, 3, + 584, 11516, 8, 584, 1, 584, 3, 584, 11519, 8, 584, 1, 584, 3, 584, 11522, + 8, 584, 1, 584, 3, 584, 11525, 8, 584, 3, 584, 11527, 8, 584, 1, 584, 1, + 584, 3, 584, 11531, 8, 584, 1, 584, 3, 584, 11534, 8, 584, 1, 585, 1, 585, + 3, 585, 11538, 8, 585, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, 1, 586, + 3, 586, 11546, 8, 586, 3, 586, 11548, 8, 586, 3, 586, 11550, 8, 586, 1, + 586, 3, 586, 11553, 8, 586, 1, 587, 4, 587, 11556, 8, 587, 11, 587, 12, + 587, 11557, 1, 587, 1, 587, 3, 587, 11562, 8, 587, 1, 587, 1, 587, 3, 587, + 11566, 8, 587, 1, 587, 5, 587, 11569, 8, 587, 10, 587, 12, 587, 11572, + 9, 587, 3, 587, 11574, 8, 587, 1, 588, 1, 588, 3, 588, 11578, 8, 588, 1, + 588, 3, 588, 11581, 8, 588, 1, 588, 3, 588, 11584, 8, 588, 1, 588, 1, 588, + 3, 588, 11588, 8, 588, 1, 588, 3, 588, 11591, 8, 588, 1, 588, 1, 588, 3, + 588, 11595, 8, 588, 1, 588, 3, 588, 11598, 8, 588, 1, 589, 1, 589, 1, 589, + 1, 589, 1, 589, 3, 589, 11605, 8, 589, 3, 589, 11607, 8, 589, 1, 589, 1, + 589, 3, 589, 11611, 8, 589, 1, 590, 1, 590, 1, 590, 1, 591, 1, 591, 1, + 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 11623, 8, 591, 3, 591, 11625, + 8, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 1, 591, 3, 591, 11633, + 8, 591, 3, 591, 11635, 8, 591, 1, 592, 1, 592, 3, 592, 11639, 8, 592, 1, + 592, 1, 592, 3, 592, 11643, 8, 592, 1, 593, 1, 593, 3, 593, 11647, 8, 593, + 1, 593, 1, 593, 3, 593, 11651, 8, 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, 4, 594, 11669, 8, 594, 11, 594, 12, 594, 11670, + 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, 3, 595, 11693, 8, 595, 1, 595, 1, 595, 1, 595, 1, 595, + 1, 595, 1, 595, 1, 595, 4, 595, 11702, 8, 595, 11, 595, 12, 595, 11703, + 1, 595, 1, 595, 1, 596, 1, 596, 1, 596, 1, 596, 1, 597, 1, 597, 1, 597, + 1, 597, 3, 597, 11716, 8, 597, 1, 597, 3, 597, 11719, 8, 597, 1, 597, 1, + 597, 4, 597, 11723, 8, 597, 11, 597, 12, 597, 11724, 1, 598, 3, 598, 11728, + 8, 598, 1, 598, 1, 598, 3, 598, 11732, 8, 598, 1, 598, 3, 598, 11735, 8, + 598, 1, 598, 3, 598, 11738, 8, 598, 1, 598, 3, 598, 11741, 8, 598, 1, 598, + 1, 598, 1, 598, 3, 598, 11746, 8, 598, 1, 598, 1, 598, 1, 598, 3, 598, + 11751, 8, 598, 1, 598, 1, 598, 1, 598, 3, 598, 11756, 8, 598, 1, 598, 1, + 598, 1, 598, 1, 598, 1, 598, 1, 598, 3, 598, 11764, 8, 598, 3, 598, 11766, + 8, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 1, 598, 5, 598, 11774, + 8, 598, 10, 598, 12, 598, 11777, 9, 598, 1, 598, 1, 598, 3, 598, 11781, + 8, 598, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, 1, 599, + 1, 599, 1, 599, 3, 599, 11793, 8, 599, 1, 600, 1, 600, 1, 600, 3, 600, + 11798, 8, 600, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 601, 1, 601, 3, 601, 11810, 8, 601, 1, 601, 1, 601, 1, 601, + 1, 601, 1, 601, 1, 601, 1, 601, 3, 601, 11819, 8, 601, 1, 602, 1, 602, + 1, 602, 1, 602, 3, 602, 11825, 8, 602, 1, 602, 1, 602, 3, 602, 11829, 8, + 602, 1, 602, 1, 602, 1, 602, 3, 602, 11834, 8, 602, 1, 602, 3, 602, 11837, + 8, 602, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 1, 603, 3, 603, 11845, + 8, 603, 1, 603, 1, 603, 3, 603, 11849, 8, 603, 1, 604, 1, 604, 1, 605, + 1, 605, 1, 605, 3, 605, 11856, 8, 605, 1, 605, 1, 605, 1, 605, 1, 605, + 1, 605, 3, 605, 11863, 8, 605, 1, 605, 3, 605, 11866, 8, 605, 1, 605, 1, + 605, 1, 606, 1, 606, 1, 606, 1, 607, 3, 607, 11874, 8, 607, 1, 607, 3, + 607, 11877, 8, 607, 1, 607, 3, 607, 11880, 8, 607, 1, 608, 1, 608, 1, 608, + 3, 608, 11885, 8, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, 1, 608, + 3, 608, 11893, 8, 608, 3, 608, 11895, 8, 608, 1, 608, 3, 608, 11898, 8, + 608, 1, 609, 1, 609, 1, 610, 1, 610, 1, 610, 3, 610, 11905, 8, 610, 1, + 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, + 610, 1, 610, 1, 610, 3, 610, 11919, 8, 610, 3, 610, 11921, 8, 610, 1, 610, + 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, 1, 610, + 5, 610, 11933, 8, 610, 10, 610, 12, 610, 11936, 9, 610, 1, 610, 1, 610, + 3, 610, 11940, 8, 610, 1, 611, 3, 611, 11943, 8, 611, 1, 611, 3, 611, 11946, + 8, 611, 1, 611, 3, 611, 11949, 8, 611, 1, 612, 1, 612, 1, 612, 1, 612, + 1, 612, 1, 612, 3, 612, 11957, 8, 612, 1, 612, 1, 612, 3, 612, 11961, 8, + 612, 1, 612, 1, 612, 3, 612, 11965, 8, 612, 1, 612, 3, 612, 11968, 8, 612, + 1, 613, 1, 613, 1, 614, 4, 614, 11973, 8, 614, 11, 614, 12, 614, 11974, + 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 3, 615, 11983, 8, 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, + 3, 615, 12012, 8, 615, 1, 615, 1, 615, 1, 615, 3, 615, 12017, 8, 615, 1, + 615, 3, 615, 12020, 8, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, 615, 1, + 615, 1, 615, 3, 615, 12029, 8, 615, 1, 616, 4, 616, 12032, 8, 616, 11, + 616, 12, 616, 12033, 1, 617, 1, 617, 1, 617, 1, 617, 1, 617, 3, 617, 12041, + 8, 617, 1, 617, 3, 617, 12044, 8, 617, 1, 617, 1, 617, 1, 617, 1, 617, + 1, 617, 3, 617, 12051, 8, 617, 1, 617, 3, 617, 12054, 8, 617, 1, 617, 1, + 617, 1, 617, 1, 617, 1, 617, 3, 617, 12061, 8, 617, 1, 617, 3, 617, 12064, + 8, 617, 3, 617, 12066, 8, 617, 1, 618, 1, 618, 1, 619, 1, 619, 1, 620, + 1, 620, 3, 620, 12074, 8, 620, 1, 620, 3, 620, 12077, 8, 620, 1, 621, 4, + 621, 12080, 8, 621, 11, 621, 12, 621, 12081, 1, 622, 1, 622, 1, 622, 1, + 622, 3, 622, 12088, 8, 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, + 622, 1, 622, 1, 622, 1, 622, 1, 622, 4, 622, 12109, 8, 622, 11, 622, 12, + 622, 12110, 1, 622, 3, 622, 12114, 8, 622, 1, 623, 1, 623, 1, 623, 1, 623, + 5, 623, 12120, 8, 623, 10, 623, 12, 623, 12123, 9, 623, 1, 623, 1, 623, + 1, 624, 1, 624, 3, 624, 12129, 8, 624, 1, 624, 3, 624, 12132, 8, 624, 1, + 624, 3, 624, 12135, 8, 624, 1, 624, 3, 624, 12138, 8, 624, 1, 625, 1, 625, + 1, 626, 3, 626, 12143, 8, 626, 1, 626, 1, 626, 1, 626, 1, 626, 1, 626, + 3, 626, 12150, 8, 626, 1, 626, 1, 626, 1, 626, 3, 626, 12155, 8, 626, 3, + 626, 12157, 8, 626, 1, 626, 1, 626, 1, 627, 1, 627, 1, 628, 1, 628, 1, + 629, 1, 629, 1, 630, 1, 630, 1, 631, 3, 631, 12170, 8, 631, 1, 631, 1, + 631, 3, 631, 12174, 8, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12179, 8, 631, + 1, 631, 3, 631, 12182, 8, 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, + 3, 631, 12189, 8, 631, 1, 631, 3, 631, 12192, 8, 631, 1, 631, 3, 631, 12195, + 8, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12200, 8, 631, 1, 631, 1, 631, + 3, 631, 12204, 8, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12209, 8, 631, 1, + 631, 3, 631, 12212, 8, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12217, 8, 631, + 1, 631, 1, 631, 1, 631, 3, 631, 12222, 8, 631, 1, 631, 3, 631, 12225, 8, + 631, 1, 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12232, 8, 631, 1, + 631, 1, 631, 1, 631, 1, 631, 3, 631, 12238, 8, 631, 1, 631, 3, 631, 12241, + 8, 631, 1, 631, 3, 631, 12244, 8, 631, 1, 631, 3, 631, 12247, 8, 631, 1, + 631, 1, 631, 1, 631, 1, 631, 1, 631, 3, 631, 12254, 8, 631, 1, 631, 1, + 631, 1, 631, 3, 631, 12259, 8, 631, 1, 632, 1, 632, 1, 632, 1, 633, 1, + 633, 1, 633, 1, 633, 3, 633, 12268, 8, 633, 1, 633, 3, 633, 12271, 8, 633, + 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 3, 634, 12278, 8, 634, 1, 634, + 1, 634, 1, 634, 1, 634, 3, 634, 12284, 8, 634, 1, 634, 3, 634, 12287, 8, + 634, 1, 634, 1, 634, 1, 634, 1, 634, 1, 634, 3, 634, 12294, 8, 634, 3, + 634, 12296, 8, 634, 3, 634, 12298, 8, 634, 1, 635, 1, 635, 1, 636, 1, 636, + 3, 636, 12304, 8, 636, 1, 636, 1, 636, 1, 636, 1, 637, 1, 637, 1, 637, + 1, 637, 1, 637, 1, 637, 5, 637, 12315, 8, 637, 10, 637, 12, 637, 12318, + 9, 637, 1, 637, 1, 637, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, + 1, 638, 1, 638, 1, 638, 1, 638, 5, 638, 12332, 8, 638, 10, 638, 12, 638, + 12335, 9, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, + 5, 638, 12344, 8, 638, 10, 638, 12, 638, 12347, 9, 638, 1, 638, 1, 638, + 3, 638, 12351, 8, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, 1, 638, + 3, 638, 12359, 8, 638, 1, 639, 1, 639, 1, 640, 1, 640, 1, 640, 1, 640, + 3, 640, 12367, 8, 640, 1, 641, 1, 641, 1, 641, 1, 641, 1, 641, 3, 641, + 12374, 8, 641, 1, 641, 3, 641, 12377, 8, 641, 1, 641, 1, 641, 1, 641, 1, + 641, 3, 641, 12383, 8, 641, 1, 641, 3, 641, 12386, 8, 641, 5, 641, 12388, + 8, 641, 10, 641, 12, 641, 12391, 9, 641, 1, 641, 1, 641, 1, 641, 1, 641, + 1, 641, 1, 641, 3, 641, 12399, 8, 641, 1, 642, 1, 642, 1, 642, 3, 642, + 12404, 8, 642, 1, 643, 3, 643, 12407, 8, 643, 1, 643, 1, 643, 1, 643, 1, + 644, 1, 644, 1, 644, 3, 644, 12415, 8, 644, 1, 644, 1, 644, 1, 644, 3, + 644, 12420, 8, 644, 1, 645, 1, 645, 1, 646, 1, 646, 1, 646, 1, 646, 1, + 646, 3, 646, 12429, 8, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 3, + 646, 12436, 8, 646, 5, 646, 12438, 8, 646, 10, 646, 12, 646, 12441, 9, + 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 3, 646, 12449, 8, + 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 1, 646, 3, 646, 12457, 8, + 646, 5, 646, 12459, 8, 646, 10, 646, 12, 646, 12462, 9, 646, 3, 646, 12464, + 8, 646, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 1, 647, 3, 647, 12472, + 8, 647, 1, 647, 1, 647, 1, 647, 1, 647, 3, 647, 12478, 8, 647, 5, 647, + 12480, 8, 647, 10, 647, 12, 647, 12483, 9, 647, 1, 647, 1, 647, 3, 647, + 12487, 8, 647, 1, 648, 1, 648, 1, 648, 3, 648, 12492, 8, 648, 1, 648, 1, + 648, 1, 648, 1, 648, 1, 648, 1, 648, 3, 648, 12500, 8, 648, 4, 648, 12502, + 8, 648, 11, 648, 12, 648, 12503, 1, 648, 1, 648, 1, 648, 1, 649, 1, 649, + 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 1, 649, 4, 649, 12518, + 8, 649, 11, 649, 12, 649, 12519, 1, 649, 3, 649, 12523, 8, 649, 1, 650, + 1, 650, 1, 650, 1, 650, 3, 650, 12529, 8, 650, 1, 651, 1, 651, 1, 651, + 3, 651, 12534, 8, 651, 1, 651, 3, 651, 12537, 8, 651, 1, 652, 3, 652, 12540, + 8, 652, 1, 652, 1, 652, 1, 653, 1, 653, 3, 653, 12546, 8, 653, 1, 653, + 1, 653, 1, 653, 1, 653, 1, 653, 1, 654, 1, 654, 1, 654, 1, 654, 3, 654, + 12557, 8, 654, 1, 654, 1, 654, 1, 655, 1, 655, 1, 655, 1, 655, 1, 655, + 3, 655, 12566, 8, 655, 1, 655, 3, 655, 12569, 8, 655, 1, 655, 1, 655, 1, + 656, 1, 656, 1, 656, 1, 656, 1, 656, 3, 656, 12578, 8, 656, 3, 656, 12580, + 8, 656, 1, 656, 3, 656, 12583, 8, 656, 1, 657, 1, 657, 1, 657, 1, 657, + 1, 657, 3, 657, 12590, 8, 657, 1, 658, 1, 658, 1, 658, 1, 658, 3, 658, + 12596, 8, 658, 1, 658, 1, 658, 3, 658, 12600, 8, 658, 1, 659, 1, 659, 1, + 659, 1, 659, 1, 659, 3, 659, 12607, 8, 659, 1, 659, 1, 659, 1, 660, 1, + 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 660, 1, 661, 1, 661, 1, 662, 1, + 662, 1, 663, 1, 663, 3, 663, 12624, 8, 663, 1, 663, 1, 663, 1, 663, 1, + 663, 3, 663, 12630, 8, 663, 1, 663, 1, 663, 1, 663, 1, 664, 1, 664, 1, + 664, 3, 664, 12638, 8, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, 664, 1, + 664, 1, 664, 3, 664, 12647, 8, 664, 1, 664, 1, 664, 1, 664, 3, 664, 12652, + 8, 664, 1, 664, 1, 664, 1, 664, 3, 664, 12657, 8, 664, 1, 664, 1, 664, + 1, 664, 1, 664, 3, 664, 12663, 8, 664, 1, 664, 1, 664, 1, 664, 1, 664, + 1, 664, 3, 664, 12670, 8, 664, 1, 664, 1, 664, 1, 664, 3, 664, 12675, 8, + 664, 3, 664, 12677, 8, 664, 1, 665, 1, 665, 3, 665, 12681, 8, 665, 1, 665, + 1, 665, 1, 665, 1, 665, 3, 665, 12687, 8, 665, 1, 665, 1, 665, 3, 665, + 12691, 8, 665, 1, 666, 1, 666, 1, 666, 1, 666, 3, 666, 12697, 8, 666, 1, + 666, 1, 666, 1, 666, 1, 666, 3, 666, 12703, 8, 666, 1, 666, 1, 666, 3, + 666, 12707, 8, 666, 1, 666, 3, 666, 12710, 8, 666, 1, 667, 1, 667, 1, 668, + 1, 668, 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, 3, 671, 12737, 8, 671, 1, 671, 1, 671, + 1, 671, 1, 671, 1, 671, 1, 671, 1, 671, 3, 671, 12746, 8, 671, 1, 672, + 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 3, 672, 12755, 8, 672, + 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 1, 672, 5, 672, 12763, 8, 672, + 10, 672, 12, 672, 12766, 9, 672, 1, 672, 1, 672, 1, 673, 1, 673, 1, 673, + 3, 673, 12773, 8, 673, 1, 673, 1, 673, 1, 673, 3, 673, 12778, 8, 673, 1, + 673, 1, 673, 1, 674, 1, 674, 1, 674, 5, 674, 12785, 8, 674, 10, 674, 12, + 674, 12788, 9, 674, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, + 675, 3, 675, 12797, 8, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, 675, 1, + 675, 5, 675, 12805, 8, 675, 10, 675, 12, 675, 12808, 9, 675, 1, 675, 1, + 675, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 3, 676, 12818, 8, + 676, 1, 676, 1, 676, 1, 676, 1, 676, 1, 676, 3, 676, 12825, 8, 676, 1, + 677, 1, 677, 1, 677, 1, 677, 1, 677, 3, 677, 12832, 8, 677, 1, 677, 3, + 677, 12835, 8, 677, 1, 677, 3, 677, 12838, 8, 677, 1, 677, 3, 677, 12841, + 8, 677, 1, 677, 1, 677, 3, 677, 12845, 8, 677, 3, 677, 12847, 8, 677, 1, + 677, 3, 677, 12850, 8, 677, 1, 677, 3, 677, 12853, 8, 677, 1, 677, 3, 677, + 12856, 8, 677, 1, 677, 3, 677, 12859, 8, 677, 1, 677, 1, 677, 3, 677, 12863, + 8, 677, 3, 677, 12865, 8, 677, 1, 677, 1, 677, 1, 677, 1, 677, 1, 677, + 1, 677, 3, 677, 12873, 8, 677, 3, 677, 12875, 8, 677, 1, 678, 1, 678, 1, + 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 1, 678, 4, 678, 12886, 8, + 678, 11, 678, 12, 678, 12887, 1, 678, 3, 678, 12891, 8, 678, 1, 678, 1, + 678, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 1, 679, 3, 679, 12901, 8, + 679, 1, 679, 1, 679, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 1, 680, 3, + 680, 12911, 8, 680, 1, 680, 1, 680, 1, 681, 1, 681, 1, 681, 1, 681, 1, + 681, 1, 682, 1, 682, 1, 682, 1, 682, 1, 682, 1, 683, 1, 683, 1, 683, 1, + 683, 1, 683, 1, 683, 1, 683, 3, 683, 12932, 8, 683, 3, 683, 12934, 8, 683, + 1, 684, 1, 684, 1, 684, 1, 684, 1, 685, 1, 685, 1, 685, 1, 685, 1, 686, + 1, 686, 1, 686, 1, 686, 3, 686, 12948, 8, 686, 1, 686, 1, 686, 3, 686, + 12952, 8, 686, 1, 686, 3, 686, 12955, 8, 686, 1, 687, 1, 687, 1, 687, 1, + 687, 3, 687, 12961, 8, 687, 1, 688, 1, 688, 1, 688, 1, 688, 1, 688, 3, + 688, 12968, 8, 688, 1, 689, 1, 689, 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, 3, 691, 12991, 8, 691, 1, + 691, 1, 691, 1, 692, 3, 692, 12996, 8, 692, 1, 692, 1, 692, 3, 692, 13000, + 8, 692, 1, 693, 1, 693, 1, 693, 3, 693, 13005, 8, 693, 1, 693, 1, 693, + 1, 693, 3, 693, 13010, 8, 693, 1, 693, 3, 693, 13013, 8, 693, 1, 693, 3, + 693, 13016, 8, 693, 1, 693, 1, 693, 1, 693, 3, 693, 13021, 8, 693, 1, 694, + 1, 694, 1, 695, 1, 695, 1, 696, 1, 696, 1, 696, 1, 696, 1, 696, 3, 696, + 13032, 8, 696, 1, 697, 1, 697, 1, 698, 1, 698, 3, 698, 13038, 8, 698, 1, + 698, 1, 698, 3, 698, 13042, 8, 698, 1, 698, 1, 698, 1, 698, 1, 698, 3, + 698, 13048, 8, 698, 1, 698, 1, 698, 1, 698, 1, 698, 1, 698, 4, 698, 13055, + 8, 698, 11, 698, 12, 698, 13056, 3, 698, 13059, 8, 698, 1, 698, 1, 698, + 3, 698, 13063, 8, 698, 1, 698, 3, 698, 13066, 8, 698, 1, 699, 3, 699, 13069, + 8, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, + 3, 699, 13079, 8, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, 1, 699, + 4, 699, 13087, 8, 699, 11, 699, 12, 699, 13088, 3, 699, 13091, 8, 699, + 1, 700, 1, 700, 1, 700, 1, 700, 5, 700, 13097, 8, 700, 10, 700, 12, 700, + 13100, 9, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 1, 700, 5, 700, + 13108, 8, 700, 10, 700, 12, 700, 13111, 9, 700, 1, 700, 3, 700, 13114, + 8, 700, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 1, 701, 5, 701, 13122, + 8, 701, 10, 701, 12, 701, 13125, 9, 701, 1, 701, 1, 701, 1, 701, 1, 701, + 1, 701, 1, 701, 5, 701, 13133, 8, 701, 10, 701, 12, 701, 13136, 9, 701, + 3, 701, 13138, 8, 701, 1, 701, 1, 701, 1, 701, 3, 701, 13143, 8, 701, 1, + 701, 1, 701, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, 702, 1, + 702, 1, 702, 1, 702, 3, 702, 13157, 8, 702, 1, 702, 1, 702, 1, 702, 1, + 702, 1, 702, 1, 702, 1, 702, 4, 702, 13166, 8, 702, 11, 702, 12, 702, 13167, + 1, 702, 1, 702, 3, 702, 13172, 8, 702, 1, 702, 1, 702, 1, 702, 1, 702, + 1, 702, 1, 702, 3, 702, 13180, 8, 702, 3, 702, 13182, 8, 702, 1, 703, 1, + 703, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 5, 704, 13191, 8, 704, 10, + 704, 12, 704, 13194, 9, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, 704, 1, + 704, 1, 704, 3, 704, 13203, 8, 704, 1, 705, 1, 705, 1, 705, 1, 705, 3, + 705, 13209, 8, 705, 1, 705, 1, 705, 1, 705, 3, 705, 13214, 8, 705, 5, 705, + 13216, 8, 705, 10, 705, 12, 705, 13219, 9, 705, 1, 705, 1, 705, 3, 705, + 13223, 8, 705, 1, 706, 1, 706, 1, 706, 3, 706, 13228, 8, 706, 1, 706, 1, + 706, 1, 706, 3, 706, 13233, 8, 706, 5, 706, 13235, 8, 706, 10, 706, 12, + 706, 13238, 9, 706, 1, 706, 1, 706, 1, 706, 1, 706, 3, 706, 13244, 8, 706, + 1, 706, 1, 706, 1, 706, 1, 706, 1, 706, 3, 706, 13251, 8, 706, 1, 707, + 1, 707, 1, 707, 3, 707, 13256, 8, 707, 1, 707, 1, 707, 1, 707, 3, 707, + 13261, 8, 707, 5, 707, 13263, 8, 707, 10, 707, 12, 707, 13266, 9, 707, + 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 1, 707, 3, 707, + 13276, 8, 707, 1, 708, 1, 708, 1, 708, 1, 708, 3, 708, 13282, 8, 708, 1, + 708, 1, 708, 1, 708, 3, 708, 13287, 8, 708, 5, 708, 13289, 8, 708, 10, + 708, 12, 708, 13292, 9, 708, 1, 708, 1, 708, 3, 708, 13296, 8, 708, 1, + 708, 3, 708, 13299, 8, 708, 1, 708, 3, 708, 13302, 8, 708, 1, 709, 1, 709, + 3, 709, 13306, 8, 709, 1, 709, 3, 709, 13309, 8, 709, 1, 709, 3, 709, 13312, + 8, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, 1, 709, + 1, 709, 1, 709, 3, 709, 13324, 8, 709, 1, 709, 1, 709, 1, 709, 1, 709, + 1, 709, 5, 709, 13331, 8, 709, 10, 709, 12, 709, 13334, 9, 709, 1, 709, + 1, 709, 1, 709, 1, 709, 1, 709, 3, 709, 13341, 8, 709, 1, 709, 1, 709, + 1, 709, 1, 709, 5, 709, 13347, 8, 709, 10, 709, 12, 709, 13350, 9, 709, + 1, 709, 1, 709, 3, 709, 13354, 8, 709, 1, 709, 1, 709, 1, 709, 1, 709, + 3, 709, 13360, 8, 709, 1, 710, 1, 710, 3, 710, 13364, 8, 710, 1, 710, 1, + 710, 1, 710, 1, 710, 1, 710, 3, 710, 13371, 8, 710, 1, 710, 4, 710, 13374, + 8, 710, 11, 710, 12, 710, 13375, 1, 710, 1, 710, 1, 710, 3, 710, 13381, + 8, 710, 1, 710, 1, 710, 1, 710, 3, 710, 13386, 8, 710, 5, 710, 13388, 8, + 710, 10, 710, 12, 710, 13391, 9, 710, 1, 710, 1, 710, 1, 710, 1, 710, 5, + 710, 13397, 8, 710, 10, 710, 12, 710, 13400, 9, 710, 3, 710, 13402, 8, + 710, 1, 711, 1, 711, 3, 711, 13406, 8, 711, 1, 711, 1, 711, 1, 712, 1, + 712, 3, 712, 13412, 8, 712, 1, 712, 1, 712, 1, 712, 1, 712, 5, 712, 13418, + 8, 712, 10, 712, 12, 712, 13421, 9, 712, 1, 712, 1, 712, 1, 712, 1, 712, + 5, 712, 13427, 8, 712, 10, 712, 12, 712, 13430, 9, 712, 3, 712, 13432, + 8, 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, 3, 714, 13447, 8, 714, 1, 715, + 1, 715, 1, 716, 1, 716, 1, 716, 1, 716, 1, 716, 1, 717, 1, 717, 1, 717, + 1, 717, 1, 717, 1, 717, 5, 717, 13462, 8, 717, 10, 717, 12, 717, 13465, + 9, 717, 1, 717, 1, 717, 1, 717, 3, 717, 13470, 8, 717, 1, 718, 1, 718, + 3, 718, 13474, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, + 13481, 8, 718, 1, 718, 1, 718, 1, 718, 1, 718, 1, 718, 3, 718, 13488, 8, + 718, 1, 718, 3, 718, 13491, 8, 718, 3, 718, 13493, 8, 718, 1, 719, 1, 719, + 1, 719, 1, 719, 3, 719, 13499, 8, 719, 3, 719, 13501, 8, 719, 1, 719, 3, + 719, 13504, 8, 719, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, 720, 1, + 720, 3, 720, 13513, 8, 720, 1, 720, 3, 720, 13516, 8, 720, 1, 721, 1, 721, + 3, 721, 13520, 8, 721, 1, 721, 1, 721, 1, 721, 1, 721, 3, 721, 13526, 8, + 721, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 722, 1, 723, 1, + 723, 1, 723, 3, 723, 13538, 8, 723, 1, 723, 1, 723, 1, 723, 1, 724, 1, + 724, 1, 724, 1, 724, 1, 724, 3, 724, 13548, 8, 724, 1, 724, 1, 724, 3, + 724, 13552, 8, 724, 1, 724, 3, 724, 13555, 8, 724, 1, 724, 3, 724, 13558, + 8, 724, 1, 724, 1, 724, 1, 724, 3, 724, 13563, 8, 724, 1, 724, 1, 724, + 3, 724, 13567, 8, 724, 1, 724, 1, 724, 3, 724, 13571, 8, 724, 1, 724, 3, + 724, 13574, 8, 724, 1, 725, 1, 725, 1, 725, 1, 725, 1, 725, 3, 725, 13581, + 8, 725, 1, 725, 3, 725, 13584, 8, 725, 1, 725, 1, 725, 1, 725, 1, 725, + 1, 725, 3, 725, 13591, 8, 725, 1, 725, 1, 725, 1, 725, 1, 725, 3, 725, + 13597, 8, 725, 1, 726, 1, 726, 1, 726, 1, 726, 1, 726, 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, 728, 1, 728, 1, 728, 1, 728, + 1, 728, 3, 728, 13625, 8, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, + 1, 728, 4, 728, 13633, 8, 728, 11, 728, 12, 728, 13634, 1, 728, 1, 728, + 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 3, 728, 13645, 8, 728, + 3, 728, 13647, 8, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, 1, 728, + 3, 728, 13655, 8, 728, 1, 729, 1, 729, 1, 729, 1, 729, 1, 729, 1, 730, + 1, 730, 1, 730, 1, 730, 1, 731, 1, 731, 1, 731, 1, 732, 1, 732, 1, 733, + 1, 733, 1, 734, 1, 734, 1, 735, 1, 735, 1, 736, 1, 736, 1, 737, 1, 737, + 1, 737, 1, 737, 1, 737, 1, 737, 1, 737, 3, 737, 13686, 8, 737, 1, 737, + 1, 737, 1, 737, 3, 737, 13691, 8, 737, 1, 738, 1, 738, 1, 738, 1, 738, + 1, 738, 1, 739, 1, 739, 1, 739, 1, 739, 1, 739, 1, 740, 1, 740, 3, 740, + 13705, 8, 740, 1, 741, 1, 741, 1, 741, 1, 741, 1, 741, 1, 742, 1, 742, + 1, 742, 1, 742, 1, 742, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, 1, 743, + 1, 744, 1, 744, 1, 744, 1, 744, 1, 745, 1, 745, 3, 745, 13729, 8, 745, + 1, 745, 3, 745, 13732, 8, 745, 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, + 1, 745, 1, 745, 1, 745, 1, 745, 1, 745, 3, 745, 13744, 8, 745, 1, 745, + 3, 745, 13747, 8, 745, 1, 746, 1, 746, 3, 746, 13751, 8, 746, 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, 3, 748, 13773, 8, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, + 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 3, 748, 13786, 8, 748, 1, + 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 1, 748, 5, 748, 13795, 8, + 748, 10, 748, 12, 748, 13798, 9, 748, 1, 748, 4, 748, 13801, 8, 748, 11, + 748, 12, 748, 13802, 1, 749, 1, 749, 1, 749, 1, 749, 5, 749, 13809, 8, + 749, 10, 749, 12, 749, 13812, 9, 749, 1, 749, 1, 749, 1, 749, 1, 749, 1, + 749, 1, 749, 3, 749, 13820, 8, 749, 1, 750, 1, 750, 3, 750, 13824, 8, 750, + 1, 750, 1, 750, 1, 751, 1, 751, 1, 751, 1, 751, 3, 751, 13832, 8, 751, + 1, 751, 1, 751, 1, 751, 1, 751, 5, 751, 13838, 8, 751, 10, 751, 12, 751, + 13841, 9, 751, 1, 751, 1, 751, 1, 751, 3, 751, 13846, 8, 751, 1, 752, 1, + 752, 1, 752, 1, 752, 1, 752, 3, 752, 13853, 8, 752, 1, 752, 1, 752, 3, + 752, 13857, 8, 752, 1, 752, 1, 752, 3, 752, 13861, 8, 752, 3, 752, 13863, + 8, 752, 1, 752, 3, 752, 13866, 8, 752, 1, 753, 1, 753, 1, 753, 1, 753, + 1, 753, 1, 753, 5, 753, 13874, 8, 753, 10, 753, 12, 753, 13877, 9, 753, + 1, 753, 1, 753, 1, 753, 3, 753, 13882, 8, 753, 1, 754, 1, 754, 1, 754, + 3, 754, 13887, 8, 754, 1, 755, 1, 755, 1, 755, 1, 755, 4, 755, 13893, 8, + 755, 11, 755, 12, 755, 13894, 1, 756, 1, 756, 1, 756, 1, 756, 1, 757, 1, + 757, 1, 757, 1, 757, 1, 757, 3, 757, 13906, 8, 757, 1, 757, 3, 757, 13909, + 8, 757, 1, 758, 3, 758, 13912, 8, 758, 1, 758, 1, 758, 1, 758, 1, 758, + 1, 758, 1, 758, 1, 758, 1, 758, 3, 758, 13922, 8, 758, 1, 758, 1, 758, + 1, 758, 1, 758, 1, 758, 5, 758, 13929, 8, 758, 10, 758, 12, 758, 13932, + 9, 758, 3, 758, 13934, 8, 758, 1, 758, 3, 758, 13937, 8, 758, 1, 759, 3, + 759, 13940, 8, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, 759, 1, + 759, 5, 759, 13949, 8, 759, 10, 759, 12, 759, 13952, 9, 759, 3, 759, 13954, + 8, 759, 1, 760, 1, 760, 1, 760, 1, 760, 3, 760, 13960, 8, 760, 1, 760, + 3, 760, 13963, 8, 760, 1, 761, 1, 761, 3, 761, 13967, 8, 761, 1, 761, 3, + 761, 13970, 8, 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, 761, 1, + 761, 1, 761, 1, 761, 1, 761, 1, 761, 3, 761, 13983, 8, 761, 3, 761, 13985, + 8, 761, 1, 761, 5, 761, 13988, 8, 761, 10, 761, 12, 761, 13991, 9, 761, + 1, 761, 1, 761, 3, 761, 13995, 8, 761, 1, 762, 1, 762, 1, 762, 5, 762, + 14000, 8, 762, 10, 762, 12, 762, 14003, 9, 762, 1, 762, 1, 762, 3, 762, + 14007, 8, 762, 1, 763, 1, 763, 3, 763, 14011, 8, 763, 1, 763, 1, 763, 1, + 763, 1, 763, 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, 3, 765, 14034, 8, 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, 3, + 765, 14050, 8, 765, 1, 766, 1, 766, 1, 766, 3, 766, 14055, 8, 766, 1, 766, + 1, 766, 3, 766, 14059, 8, 766, 1, 766, 1, 766, 3, 766, 14063, 8, 766, 1, + 766, 1, 766, 3, 766, 14067, 8, 766, 1, 766, 3, 766, 14070, 8, 766, 1, 766, + 1, 766, 1, 766, 3, 766, 14075, 8, 766, 3, 766, 14077, 8, 766, 1, 767, 1, + 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 1, 767, 5, + 767, 14089, 8, 767, 10, 767, 12, 767, 14092, 9, 767, 1, 767, 1, 767, 3, + 767, 14096, 8, 767, 1, 768, 1, 768, 1, 768, 1, 768, 1, 768, 3, 768, 14103, + 8, 768, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, 1, 769, + 1, 769, 3, 769, 14114, 8, 769, 1, 769, 1, 769, 1, 769, 1, 769, 3, 769, + 14120, 8, 769, 3, 769, 14122, 8, 769, 3, 769, 14124, 8, 769, 1, 770, 1, + 770, 1, 770, 1, 770, 5, 770, 14130, 8, 770, 10, 770, 12, 770, 14133, 9, + 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 3, 770, 14141, 8, + 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 1, 770, 3, 770, 14149, 8, + 770, 4, 770, 14151, 8, 770, 11, 770, 12, 770, 14152, 3, 770, 14155, 8, + 770, 1, 770, 1, 770, 1, 771, 3, 771, 14160, 8, 771, 1, 771, 1, 771, 1, + 771, 1, 771, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, 772, 1, + 772, 1, 772, 1, 772, 1, 772, 3, 772, 14177, 8, 772, 1, 773, 1, 773, 1, + 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 1, 773, 3, 773, 14188, 8, + 773, 1, 774, 1, 774, 1, 774, 1, 774, 1, 774, 3, 774, 14195, 8, 774, 1, + 774, 1, 774, 3, 774, 14199, 8, 774, 1, 774, 3, 774, 14202, 8, 774, 1, 774, + 3, 774, 14205, 8, 774, 3, 774, 14207, 8, 774, 1, 775, 1, 775, 1, 775, 3, + 775, 14212, 8, 775, 1, 775, 1, 775, 3, 775, 14216, 8, 775, 3, 775, 14218, + 8, 775, 1, 776, 1, 776, 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, 3, 777, + 14236, 8, 777, 1, 777, 1, 777, 3, 777, 14240, 8, 777, 1, 777, 3, 777, 14243, + 8, 777, 1, 777, 1, 777, 1, 777, 3, 777, 14248, 8, 777, 3, 777, 14250, 8, + 777, 1, 777, 3, 777, 14253, 8, 777, 1, 777, 1, 777, 3, 777, 14257, 8, 777, + 3, 777, 14259, 8, 777, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, 1, 778, + 1, 778, 1, 778, 5, 778, 14269, 8, 778, 10, 778, 12, 778, 14272, 9, 778, + 1, 778, 1, 778, 1, 778, 5, 778, 14277, 8, 778, 10, 778, 12, 778, 14280, + 9, 778, 3, 778, 14282, 8, 778, 1, 778, 1, 778, 1, 779, 1, 779, 1, 779, + 3, 779, 14289, 8, 779, 1, 779, 1, 779, 3, 779, 14293, 8, 779, 1, 779, 3, + 779, 14296, 8, 779, 1, 779, 3, 779, 14299, 8, 779, 1, 779, 3, 779, 14302, + 8, 779, 1, 779, 1, 779, 3, 779, 14306, 8, 779, 3, 779, 14308, 8, 779, 1, + 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 1, 780, 3, 780, 14318, + 8, 780, 1, 780, 1, 780, 3, 780, 14322, 8, 780, 1, 781, 1, 781, 1, 781, + 3, 781, 14327, 8, 781, 1, 781, 1, 781, 1, 781, 3, 781, 14332, 8, 781, 1, + 782, 1, 782, 1, 782, 1, 782, 1, 782, 3, 782, 14339, 8, 782, 1, 782, 1, + 782, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 1, 783, 5, 783, 14349, 8, + 783, 10, 783, 12, 783, 14352, 9, 783, 1, 783, 1, 783, 1, 783, 1, 783, 3, + 783, 14358, 8, 783, 1, 783, 1, 783, 1, 783, 5, 783, 14363, 8, 783, 10, + 783, 12, 783, 14366, 9, 783, 1, 783, 3, 783, 14369, 8, 783, 3, 783, 14371, + 8, 783, 1, 784, 1, 784, 1, 784, 1, 784, 3, 784, 14377, 8, 784, 1, 784, + 1, 784, 1, 784, 1, 784, 5, 784, 14383, 8, 784, 10, 784, 12, 784, 14386, + 9, 784, 1, 784, 1, 784, 1, 784, 1, 784, 3, 784, 14392, 8, 784, 1, 784, + 1, 784, 1, 784, 5, 784, 14397, 8, 784, 10, 784, 12, 784, 14400, 9, 784, + 1, 784, 3, 784, 14403, 8, 784, 3, 784, 14405, 8, 784, 1, 785, 1, 785, 1, + 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, + 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 1, 785, 4, 785, 14425, 8, + 785, 11, 785, 12, 785, 14426, 1, 785, 3, 785, 14430, 8, 785, 1, 786, 1, + 786, 1, 786, 1, 786, 3, 786, 14436, 8, 786, 1, 787, 1, 787, 1, 787, 1, + 787, 3, 787, 14442, 8, 787, 1, 788, 1, 788, 1, 788, 1, 788, 1, 788, 1, + 788, 4, 788, 14450, 8, 788, 11, 788, 12, 788, 14451, 3, 788, 14454, 8, + 788, 1, 789, 1, 789, 1, 789, 3, 789, 14459, 8, 789, 1, 789, 1, 789, 1, + 789, 3, 789, 14464, 8, 789, 1, 789, 1, 789, 1, 789, 3, 789, 14469, 8, 789, + 5, 789, 14471, 8, 789, 10, 789, 12, 789, 14474, 9, 789, 1, 789, 3, 789, + 14477, 8, 789, 1, 790, 1, 790, 3, 790, 14481, 8, 790, 1, 791, 1, 791, 1, + 791, 1, 791, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 1, 792, 3, 792, 14493, + 8, 792, 1, 793, 1, 793, 1, 793, 1, 793, 3, 793, 14499, 8, 793, 1, 793, + 1, 793, 1, 793, 5, 793, 14504, 8, 793, 10, 793, 12, 793, 14507, 9, 793, + 1, 794, 1, 794, 3, 794, 14511, 8, 794, 1, 794, 1, 794, 5, 794, 14515, 8, + 794, 10, 794, 12, 794, 14518, 9, 794, 1, 795, 1, 795, 3, 795, 14522, 8, + 795, 1, 795, 1, 795, 3, 795, 14526, 8, 795, 1, 795, 1, 795, 5, 795, 14530, + 8, 795, 10, 795, 12, 795, 14533, 9, 795, 1, 796, 1, 796, 3, 796, 14537, + 8, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, 5, 796, 14544, 8, 796, + 10, 796, 12, 796, 14547, 9, 796, 1, 796, 1, 796, 1, 796, 1, 796, 1, 796, + 1, 796, 3, 796, 14555, 8, 796, 1, 796, 3, 796, 14558, 8, 796, 1, 796, 3, + 796, 14561, 8, 796, 1, 796, 3, 796, 14564, 8, 796, 1, 796, 1, 796, 3, 796, + 14568, 8, 796, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, 1, 797, + 1, 797, 3, 797, 14578, 8, 797, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, + 1, 798, 3, 798, 14586, 8, 798, 1, 798, 1, 798, 1, 798, 1, 798, 1, 798, + 1, 798, 4, 798, 14594, 8, 798, 11, 798, 12, 798, 14595, 1, 799, 1, 799, + 1, 800, 1, 800, 1, 800, 1, 800, 1, 801, 1, 801, 3, 801, 14606, 8, 801, + 1, 801, 3, 801, 14609, 8, 801, 1, 801, 3, 801, 14612, 8, 801, 1, 801, 3, + 801, 14615, 8, 801, 1, 801, 1, 801, 5, 801, 14619, 8, 801, 10, 801, 12, + 801, 14622, 9, 801, 1, 801, 3, 801, 14625, 8, 801, 1, 802, 1, 802, 1, 802, + 1, 802, 4, 802, 14631, 8, 802, 11, 802, 12, 802, 14632, 1, 802, 3, 802, + 14636, 8, 802, 1, 802, 3, 802, 14639, 8, 802, 1, 803, 1, 803, 1, 803, 3, + 803, 14644, 8, 803, 1, 804, 1, 804, 1, 804, 3, 804, 14649, 8, 804, 1, 805, + 1, 805, 3, 805, 14653, 8, 805, 1, 805, 1, 805, 3, 805, 14657, 8, 805, 1, + 806, 1, 806, 1, 806, 1, 806, 3, 806, 14663, 8, 806, 1, 807, 1, 807, 1, + 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 807, 1, 808, 1, 808, 1, 809, 1, + 809, 1, 809, 1, 809, 1, 809, 1, 809, 1, 810, 1, 810, 1, 811, 1, 811, 1, + 812, 1, 812, 1, 812, 1, 812, 4, 812, 14689, 8, 812, 11, 812, 12, 812, 14690, + 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 5, 813, + 14701, 8, 813, 10, 813, 12, 813, 14704, 9, 813, 1, 813, 1, 813, 3, 813, + 14708, 8, 813, 1, 813, 1, 813, 1, 813, 5, 813, 14713, 8, 813, 10, 813, + 12, 813, 14716, 9, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, + 1, 813, 5, 813, 14725, 8, 813, 10, 813, 12, 813, 14728, 9, 813, 1, 813, + 1, 813, 3, 813, 14732, 8, 813, 1, 813, 1, 813, 1, 813, 5, 813, 14737, 8, + 813, 10, 813, 12, 813, 14740, 9, 813, 1, 813, 1, 813, 3, 813, 14744, 8, + 813, 1, 813, 1, 813, 1, 813, 1, 813, 1, 813, 3, 813, 14751, 8, 813, 1, + 813, 1, 813, 3, 813, 14755, 8, 813, 1, 814, 1, 814, 1, 814, 1, 814, 1, + 814, 5, 814, 14762, 8, 814, 10, 814, 12, 814, 14765, 9, 814, 1, 814, 1, + 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, 814, 1, + 814, 1, 814, 3, 814, 14779, 8, 814, 1, 815, 1, 815, 1, 815, 1, 816, 1, + 816, 3, 816, 14786, 8, 816, 1, 816, 1, 816, 3, 816, 14790, 8, 816, 1, 816, + 1, 816, 1, 816, 3, 816, 14795, 8, 816, 1, 816, 3, 816, 14798, 8, 816, 1, + 816, 1, 816, 1, 816, 3, 816, 14803, 8, 816, 1, 816, 5, 816, 14806, 8, 816, + 10, 816, 12, 816, 14809, 9, 816, 1, 816, 3, 816, 14812, 8, 816, 1, 817, + 1, 817, 1, 817, 3, 817, 14817, 8, 817, 1, 817, 1, 817, 1, 817, 1, 817, + 1, 817, 3, 817, 14824, 8, 817, 1, 818, 1, 818, 1, 818, 1, 818, 3, 818, + 14830, 8, 818, 1, 818, 1, 818, 1, 818, 3, 818, 14835, 8, 818, 5, 818, 14837, + 8, 818, 10, 818, 12, 818, 14840, 9, 818, 1, 818, 1, 818, 1, 818, 1, 818, + 3, 818, 14846, 8, 818, 3, 818, 14848, 8, 818, 1, 818, 3, 818, 14851, 8, + 818, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 819, 1, 820, 1, + 820, 1, 820, 3, 820, 14863, 8, 820, 1, 820, 1, 820, 3, 820, 14867, 8, 820, + 1, 821, 1, 821, 1, 821, 3, 821, 14872, 8, 821, 1, 821, 1, 821, 3, 821, + 14876, 8, 821, 1, 821, 1, 821, 1, 821, 1, 821, 1, 821, 3, 821, 14883, 8, + 821, 1, 822, 1, 822, 1, 823, 1, 823, 3, 823, 14889, 8, 823, 1, 824, 1, + 824, 1, 824, 1, 824, 3, 824, 14895, 8, 824, 1, 824, 3, 824, 14898, 8, 824, + 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 5, 825, 14905, 8, 825, 10, 825, + 12, 825, 14908, 9, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, + 5, 825, 14916, 8, 825, 10, 825, 12, 825, 14919, 9, 825, 1, 825, 4, 825, + 14922, 8, 825, 11, 825, 12, 825, 14923, 1, 825, 1, 825, 1, 825, 1, 825, + 1, 825, 1, 825, 1, 825, 1, 825, 1, 825, 5, 825, 14935, 8, 825, 10, 825, + 12, 825, 14938, 9, 825, 1, 825, 4, 825, 14941, 8, 825, 11, 825, 12, 825, + 14942, 3, 825, 14945, 8, 825, 1, 826, 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, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, 827, 1, + 827, 1, 827, 3, 827, 14972, 8, 827, 1, 827, 3, 827, 14975, 8, 827, 1, 827, + 1, 827, 1, 827, 4, 827, 14980, 8, 827, 11, 827, 12, 827, 14981, 1, 828, + 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, + 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, 1, 828, + 1, 828, 3, 828, 15004, 8, 828, 1, 828, 3, 828, 15007, 8, 828, 4, 828, 15009, + 8, 828, 11, 828, 12, 828, 15010, 1, 829, 1, 829, 1, 830, 1, 830, 1, 830, + 3, 830, 15018, 8, 830, 3, 830, 15020, 8, 830, 1, 831, 1, 831, 1, 831, 1, + 831, 1, 831, 1, 831, 3, 831, 15028, 8, 831, 1, 832, 1, 832, 3, 832, 15032, + 8, 832, 1, 832, 1, 832, 1, 832, 3, 832, 15037, 8, 832, 1, 832, 3, 832, + 15040, 8, 832, 1, 832, 3, 832, 15043, 8, 832, 1, 832, 3, 832, 15046, 8, + 832, 1, 833, 1, 833, 1, 834, 1, 834, 1, 834, 3, 834, 15053, 8, 834, 1, + 834, 1, 834, 1, 834, 3, 834, 15058, 8, 834, 1, 834, 1, 834, 1, 835, 1, + 835, 1, 835, 1, 835, 3, 835, 15066, 8, 835, 1, 835, 1, 835, 1, 835, 1, + 835, 5, 835, 15072, 8, 835, 10, 835, 12, 835, 15075, 9, 835, 1, 835, 1, + 835, 3, 835, 15079, 8, 835, 1, 835, 4, 835, 15082, 8, 835, 11, 835, 12, + 835, 15083, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, + 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 4, 836, 15100, 8, + 836, 11, 836, 12, 836, 15101, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, + 836, 1, 836, 1, 836, 1, 836, 1, 836, 1, 836, 4, 836, 15115, 8, 836, 11, + 836, 12, 836, 15116, 3, 836, 15119, 8, 836, 1, 837, 1, 837, 1, 837, 1, + 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 1, 837, 3, 837, 15131, 8, + 837, 1, 838, 1, 838, 1, 839, 1, 839, 1, 840, 1, 840, 1, 840, 3, 840, 15140, + 8, 840, 1, 840, 1, 840, 3, 840, 15144, 8, 840, 3, 840, 15146, 8, 840, 1, + 840, 3, 840, 15149, 8, 840, 1, 840, 3, 840, 15152, 8, 840, 1, 840, 1, 840, + 1, 840, 3, 840, 15157, 8, 840, 1, 840, 1, 840, 3, 840, 15161, 8, 840, 1, + 840, 1, 840, 3, 840, 15165, 8, 840, 1, 840, 4, 840, 15168, 8, 840, 11, + 840, 12, 840, 15169, 1, 840, 3, 840, 15173, 8, 840, 1, 841, 1, 841, 1, + 842, 1, 842, 1, 842, 1, 842, 1, 842, 1, 842, 3, 842, 15183, 8, 842, 3, + 842, 15185, 8, 842, 1, 842, 1, 842, 1, 842, 3, 842, 15190, 8, 842, 1, 843, + 4, 843, 15193, 8, 843, 11, 843, 12, 843, 15194, 1, 843, 1, 843, 4, 843, + 15199, 8, 843, 11, 843, 12, 843, 15200, 1, 843, 1, 843, 3, 843, 15205, + 8, 843, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 15212, 8, 844, + 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, + 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 1, 844, 3, 844, 15230, + 8, 844, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 15237, 8, 845, + 1, 845, 3, 845, 15240, 8, 845, 1, 845, 3, 845, 15243, 8, 845, 1, 845, 3, + 845, 15246, 8, 845, 1, 845, 3, 845, 15249, 8, 845, 1, 845, 1, 845, 1, 845, + 1, 845, 1, 845, 1, 845, 3, 845, 15257, 8, 845, 3, 845, 15259, 8, 845, 1, + 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 1, 845, 3, 845, 15268, 8, + 845, 3, 845, 15270, 8, 845, 1, 845, 5, 845, 15273, 8, 845, 10, 845, 12, + 845, 15276, 9, 845, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 1, 846, 3, + 846, 15284, 8, 846, 3, 846, 15286, 8, 846, 1, 846, 1, 846, 1, 846, 1, 846, + 1, 846, 5, 846, 15293, 8, 846, 10, 846, 12, 846, 15296, 9, 846, 1, 846, + 3, 846, 15299, 8, 846, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, 1, 847, + 3, 847, 15307, 8, 847, 1, 848, 1, 848, 1, 848, 1, 849, 1, 849, 1, 849, + 1, 849, 3, 849, 15316, 8, 849, 1, 849, 3, 849, 15319, 8, 849, 1, 849, 3, + 849, 15322, 8, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, 849, 1, + 849, 1, 849, 1, 849, 1, 849, 4, 849, 15334, 8, 849, 11, 849, 12, 849, 15335, + 1, 849, 1, 849, 3, 849, 15340, 8, 849, 1, 849, 1, 849, 3, 849, 15344, 8, + 849, 1, 849, 3, 849, 15347, 8, 849, 1, 850, 1, 850, 1, 851, 3, 851, 15352, + 8, 851, 1, 851, 1, 851, 1, 851, 3, 851, 15357, 8, 851, 1, 851, 1, 851, + 1, 851, 1, 851, 1, 851, 3, 851, 15364, 8, 851, 1, 851, 1, 851, 1, 851, + 1, 851, 3, 851, 15370, 8, 851, 1, 852, 1, 852, 3, 852, 15374, 8, 852, 1, + 853, 1, 853, 1, 853, 1, 853, 3, 853, 15380, 8, 853, 1, 854, 1, 854, 1, + 855, 1, 855, 1, 855, 1, 855, 1, 856, 1, 856, 1, 856, 5, 856, 15391, 8, + 856, 10, 856, 12, 856, 15394, 9, 856, 1, 856, 3, 856, 15397, 8, 856, 1, + 856, 1, 856, 1, 856, 5, 856, 15402, 8, 856, 10, 856, 12, 856, 15405, 9, + 856, 1, 856, 3, 856, 15408, 8, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, + 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, 856, 5, 856, 15420, 8, 856, 10, + 856, 12, 856, 15423, 9, 856, 1, 856, 1, 856, 3, 856, 15427, 8, 856, 1, + 856, 1, 856, 3, 856, 15431, 8, 856, 1, 856, 1, 856, 1, 856, 1, 856, 1, + 856, 1, 856, 1, 856, 4, 856, 15440, 8, 856, 11, 856, 12, 856, 15441, 3, + 856, 15444, 8, 856, 1, 857, 1, 857, 1, 858, 1, 858, 1, 859, 1, 859, 1, + 859, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 1, 860, 5, 860, 15460, + 8, 860, 10, 860, 12, 860, 15463, 9, 860, 1, 860, 1, 860, 3, 860, 15467, + 8, 860, 1, 860, 3, 860, 15470, 8, 860, 1, 860, 3, 860, 15473, 8, 860, 1, + 860, 1, 860, 1, 860, 3, 860, 15478, 8, 860, 3, 860, 15480, 8, 860, 1, 861, + 1, 861, 1, 861, 3, 861, 15485, 8, 861, 1, 861, 1, 861, 1, 861, 1, 861, + 3, 861, 15491, 8, 861, 1, 861, 4, 861, 15494, 8, 861, 11, 861, 12, 861, + 15495, 1, 862, 1, 862, 1, 862, 1, 862, 3, 862, 15502, 8, 862, 1, 863, 1, + 863, 1, 863, 1, 863, 1, 863, 3, 863, 15509, 8, 863, 1, 864, 1, 864, 1, + 864, 1, 864, 1, 865, 1, 865, 1, 865, 1, 865, 1, 866, 1, 866, 1, 866, 1, + 866, 1, 867, 1, 867, 1, 867, 1, 867, 1, 867, 3, 867, 15528, 8, 867, 1, + 868, 1, 868, 1, 868, 3, 868, 15533, 8, 868, 1, 868, 1, 868, 1, 868, 1, + 868, 1, 868, 3, 868, 15540, 8, 868, 3, 868, 15542, 8, 868, 1, 869, 1, 869, + 1, 869, 1, 869, 1, 869, 3, 869, 15549, 8, 869, 1, 870, 1, 870, 1, 870, + 3, 870, 15554, 8, 870, 1, 871, 1, 871, 1, 871, 1, 871, 3, 871, 15560, 8, + 871, 1, 872, 1, 872, 3, 872, 15564, 8, 872, 1, 872, 1, 872, 1, 872, 1, + 872, 4, 872, 15570, 8, 872, 11, 872, 12, 872, 15571, 3, 872, 15574, 8, + 872, 1, 872, 1, 872, 1, 872, 1, 873, 1, 873, 1, 873, 1, 874, 1, 874, 1, + 874, 3, 874, 15585, 8, 874, 1, 875, 1, 875, 1, 875, 1, 875, 1, 876, 1, + 876, 1, 876, 3, 876, 15594, 8, 876, 1, 876, 1, 876, 1, 876, 3, 876, 15599, + 8, 876, 1, 876, 1, 876, 3, 876, 15603, 8, 876, 1, 876, 3, 876, 15606, 8, + 876, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 877, 1, 878, 1, 878, 1, + 878, 1, 878, 1, 878, 1, 878, 3, 878, 15620, 8, 878, 1, 878, 1, 878, 1, + 879, 1, 879, 5, 879, 15626, 8, 879, 10, 879, 12, 879, 15629, 9, 879, 1, + 879, 3, 879, 15632, 8, 879, 1, 879, 3, 879, 15635, 8, 879, 1, 880, 1, 880, + 1, 880, 1, 881, 4, 881, 15641, 8, 881, 11, 881, 12, 881, 15642, 1, 882, + 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, 1, 882, + 3, 882, 15655, 8, 882, 1, 883, 1, 883, 3, 883, 15659, 8, 883, 1, 883, 1, + 883, 1, 883, 3, 883, 15664, 8, 883, 1, 883, 3, 883, 15667, 8, 883, 1, 883, + 1, 883, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, 1, 884, + 1, 884, 3, 884, 15680, 8, 884, 1, 884, 1, 884, 3, 884, 15684, 8, 884, 1, + 884, 1, 884, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 1, 885, 5, 885, 15694, + 8, 885, 10, 885, 12, 885, 15697, 9, 885, 1, 885, 1, 885, 3, 885, 15701, + 8, 885, 1, 885, 1, 885, 3, 885, 15705, 8, 885, 1, 885, 1, 885, 3, 885, + 15709, 8, 885, 1, 885, 1, 885, 1, 886, 1, 886, 3, 886, 15715, 8, 886, 1, + 886, 3, 886, 15718, 8, 886, 1, 886, 3, 886, 15721, 8, 886, 1, 887, 1, 887, + 1, 887, 1, 887, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, + 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, + 1, 888, 1, 888, 1, 888, 1, 888, 1, 888, 3, 888, 15748, 8, 888, 1, 888, + 1, 888, 4, 888, 15752, 8, 888, 11, 888, 12, 888, 15753, 1, 888, 1, 888, + 3, 888, 15758, 8, 888, 1, 888, 1, 888, 1, 889, 1, 889, 1, 889, 1, 889, + 1, 889, 5, 889, 15767, 8, 889, 10, 889, 12, 889, 15770, 9, 889, 1, 889, + 1, 889, 1, 890, 1, 890, 3, 890, 15776, 8, 890, 1, 890, 1, 890, 3, 890, + 15780, 8, 890, 1, 890, 3, 890, 15783, 8, 890, 1, 891, 1, 891, 1, 891, 1, + 891, 3, 891, 15789, 8, 891, 1, 892, 1, 892, 1, 892, 1, 892, 1, 892, 1, + 892, 1, 892, 3, 892, 15798, 8, 892, 1, 892, 1, 892, 1, 893, 1, 893, 1, + 893, 1, 893, 3, 893, 15806, 8, 893, 1, 893, 1, 893, 3, 893, 15810, 8, 893, + 1, 894, 1, 894, 3, 894, 15814, 8, 894, 1, 894, 1, 894, 1, 894, 1, 895, + 1, 895, 1, 895, 3, 895, 15822, 8, 895, 1, 895, 1, 895, 1, 895, 1, 895, + 1, 895, 1, 895, 1, 895, 3, 895, 15831, 8, 895, 1, 896, 1, 896, 1, 896, + 1, 896, 4, 896, 15837, 8, 896, 11, 896, 12, 896, 15838, 1, 897, 1, 897, + 1, 897, 1, 897, 1, 897, 1, 897, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, 1, 898, + 1, 898, 1, 898, 3, 898, 15863, 8, 898, 1, 899, 4, 899, 15866, 8, 899, 11, + 899, 12, 899, 15867, 1, 900, 1, 900, 3, 900, 15872, 8, 900, 1, 900, 1, + 900, 1, 900, 1, 901, 1, 901, 3, 901, 15879, 8, 901, 1, 901, 1, 901, 3, + 901, 15883, 8, 901, 1, 902, 1, 902, 3, 902, 15887, 8, 902, 1, 902, 1, 902, + 3, 902, 15891, 8, 902, 1, 903, 1, 903, 1, 903, 1, 904, 1, 904, 1, 904, + 1, 904, 1, 904, 5, 904, 15901, 8, 904, 10, 904, 12, 904, 15904, 9, 904, + 1, 904, 3, 904, 15907, 8, 904, 1, 904, 1, 904, 1, 904, 1, 905, 1, 905, + 1, 905, 1, 905, 1, 905, 1, 906, 1, 906, 1, 906, 1, 907, 3, 907, 15921, + 8, 907, 1, 907, 1, 907, 1, 907, 1, 907, 3, 907, 15927, 8, 907, 1, 907, + 1, 907, 1, 907, 1, 907, 1, 907, 3, 907, 15934, 8, 907, 1, 908, 1, 908, + 1, 908, 3, 908, 15939, 8, 908, 1, 908, 1, 908, 1, 908, 1, 908, 1, 908, + 1, 908, 1, 908, 1, 908, 1, 908, 3, 908, 15950, 8, 908, 1, 908, 3, 908, + 15953, 8, 908, 1, 908, 1, 908, 1, 908, 1, 908, 3, 908, 15959, 8, 908, 3, + 908, 15961, 8, 908, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, 909, 1, + 909, 3, 909, 15970, 8, 909, 1, 910, 1, 910, 1, 910, 1, 910, 1, 910, 1, + 910, 1, 910, 1, 910, 3, 910, 15980, 8, 910, 1, 910, 1, 910, 1, 910, 3, + 910, 15985, 8, 910, 1, 911, 1, 911, 1, 911, 1, 911, 1, 911, 1, 912, 1, + 912, 1, 913, 1, 913, 1, 914, 1, 914, 1, 915, 1, 915, 3, 915, 16000, 8, + 915, 1, 916, 1, 916, 3, 916, 16004, 8, 916, 1, 917, 3, 917, 16007, 8, 917, + 1, 917, 1, 917, 3, 917, 16011, 8, 917, 1, 917, 1, 917, 3, 917, 16015, 8, + 917, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 918, 1, 919, 1, 919, 1, + 919, 1, 919, 4, 919, 16027, 8, 919, 11, 919, 12, 919, 16028, 3, 919, 16031, + 8, 919, 1, 919, 1, 919, 3, 919, 16035, 8, 919, 1, 920, 1, 920, 1, 920, + 1, 920, 5, 920, 16041, 8, 920, 10, 920, 12, 920, 16044, 9, 920, 1, 920, + 1, 920, 1, 920, 1, 921, 1, 921, 5, 921, 16051, 8, 921, 10, 921, 12, 921, + 16054, 9, 921, 3, 921, 16056, 8, 921, 1, 921, 1, 921, 1, 922, 3, 922, 16061, + 8, 922, 1, 922, 4, 922, 16064, 8, 922, 11, 922, 12, 922, 16065, 1, 922, + 1, 922, 1, 923, 1, 923, 1, 923, 1, 923, 3, 923, 16074, 8, 923, 1, 924, + 1, 924, 1, 924, 1, 924, 1, 924, 3, 924, 16081, 8, 924, 1, 924, 1, 924, + 3, 924, 16085, 8, 924, 1, 924, 3, 924, 16088, 8, 924, 1, 925, 1, 925, 1, + 925, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 1, 926, 3, 926, 16100, + 8, 926, 1, 927, 1, 927, 1, 927, 1, 927, 3, 927, 16106, 8, 927, 1, 928, + 1, 928, 1, 928, 1, 929, 1, 929, 1, 929, 1, 929, 3, 929, 16115, 8, 929, + 1, 929, 3, 929, 16118, 8, 929, 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, + 1, 930, 5, 930, 16126, 8, 930, 10, 930, 12, 930, 16129, 9, 930, 1, 930, + 1, 930, 1, 930, 1, 930, 1, 930, 1, 930, 5, 930, 16137, 8, 930, 10, 930, + 12, 930, 16140, 9, 930, 1, 930, 1, 930, 1, 930, 3, 930, 16145, 8, 930, + 3, 930, 16147, 8, 930, 3, 930, 16149, 8, 930, 1, 931, 1, 931, 1, 931, 1, + 931, 1, 931, 3, 931, 16156, 8, 931, 1, 931, 3, 931, 16159, 8, 931, 1, 932, + 1, 932, 1, 932, 1, 932, 1, 932, 3, 932, 16166, 8, 932, 1, 933, 1, 933, + 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 1, 933, 3, 933, 16177, + 8, 933, 1, 933, 1, 933, 1, 933, 1, 933, 3, 933, 16183, 8, 933, 1, 933, + 1, 933, 3, 933, 16187, 8, 933, 1, 934, 1, 934, 1, 934, 1, 934, 1, 934, + 1, 934, 5, 934, 16195, 8, 934, 10, 934, 12, 934, 16198, 9, 934, 3, 934, + 16200, 8, 934, 1, 934, 1, 934, 1, 935, 1, 935, 3, 935, 16206, 8, 935, 1, + 935, 1, 935, 1, 935, 3, 935, 16211, 8, 935, 1, 935, 1, 935, 1, 935, 1, + 935, 3, 935, 16217, 8, 935, 1, 935, 1, 935, 1, 935, 3, 935, 16222, 8, 935, + 3, 935, 16224, 8, 935, 1, 936, 1, 936, 3, 936, 16228, 8, 936, 1, 936, 3, + 936, 16231, 8, 936, 1, 937, 1, 937, 3, 937, 16235, 8, 937, 1, 937, 1, 937, + 3, 937, 16239, 8, 937, 1, 937, 1, 937, 1, 937, 3, 937, 16244, 8, 937, 1, + 938, 1, 938, 1, 938, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 1, 939, 3, + 939, 16255, 8, 939, 1, 939, 1, 939, 3, 939, 16259, 8, 939, 1, 939, 1, 939, + 1, 939, 1, 939, 1, 939, 1, 939, 3, 939, 16267, 8, 939, 1, 940, 1, 940, + 1, 941, 1, 941, 1, 941, 1, 941, 1, 941, 5, 941, 16276, 8, 941, 10, 941, + 12, 941, 16279, 9, 941, 1, 942, 1, 942, 1, 942, 1, 942, 5, 942, 16285, + 8, 942, 10, 942, 12, 942, 16288, 9, 942, 1, 943, 1, 943, 3, 943, 16292, + 8, 943, 1, 943, 1, 943, 1, 943, 1, 943, 3, 943, 16298, 8, 943, 1, 943, + 1, 943, 3, 943, 16302, 8, 943, 1, 943, 3, 943, 16305, 8, 943, 1, 944, 1, + 944, 1, 944, 1, 944, 1, 944, 1, 944, 3, 944, 16313, 8, 944, 1, 944, 3, + 944, 16316, 8, 944, 1, 944, 1, 944, 3, 944, 16320, 8, 944, 1, 944, 1, 944, + 3, 944, 16324, 8, 944, 1, 944, 1, 944, 1, 944, 3, 944, 16329, 8, 944, 1, + 944, 3, 944, 16332, 8, 944, 1, 944, 1, 944, 3, 944, 16336, 8, 944, 1, 944, + 1, 944, 3, 944, 16340, 8, 944, 5, 944, 16342, 8, 944, 10, 944, 12, 944, + 16345, 9, 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, 946, 1, 946, 5, 946, 16361, + 8, 946, 10, 946, 12, 946, 16364, 9, 946, 1, 947, 1, 947, 1, 947, 1, 947, + 1, 947, 3, 947, 16371, 8, 947, 1, 948, 1, 948, 3, 948, 16375, 8, 948, 1, + 948, 1, 948, 3, 948, 16379, 8, 948, 1, 948, 1, 948, 1, 949, 3, 949, 16384, + 8, 949, 1, 949, 1, 949, 3, 949, 16388, 8, 949, 1, 949, 1, 949, 3, 949, + 16392, 8, 949, 1, 949, 1, 949, 3, 949, 16396, 8, 949, 1, 949, 3, 949, 16399, + 8, 949, 1, 949, 3, 949, 16402, 8, 949, 1, 949, 3, 949, 16405, 8, 949, 1, + 949, 3, 949, 16408, 8, 949, 1, 949, 3, 949, 16411, 8, 949, 1, 950, 1, 950, + 1, 950, 1, 950, 5, 950, 16417, 8, 950, 10, 950, 12, 950, 16420, 9, 950, + 3, 950, 16422, 8, 950, 1, 951, 1, 951, 1, 951, 1, 952, 1, 952, 1, 952, + 3, 952, 16430, 8, 952, 3, 952, 16432, 8, 952, 1, 953, 1, 953, 1, 953, 1, + 953, 1, 954, 1, 954, 1, 954, 5, 954, 16441, 8, 954, 10, 954, 12, 954, 16444, + 9, 954, 1, 955, 1, 955, 5, 955, 16448, 8, 955, 10, 955, 12, 955, 16451, + 9, 955, 1, 955, 1, 955, 3, 955, 16455, 8, 955, 1, 956, 1, 956, 5, 956, + 16459, 8, 956, 10, 956, 12, 956, 16462, 9, 956, 1, 956, 1, 956, 3, 956, + 16466, 8, 956, 1, 957, 1, 957, 1, 957, 3, 957, 16471, 8, 957, 1, 957, 1, + 957, 1, 957, 5, 957, 16476, 8, 957, 10, 957, 12, 957, 16479, 9, 957, 1, + 957, 1, 957, 1, 957, 3, 957, 16484, 8, 957, 1, 957, 1, 957, 1, 957, 1, + 957, 1, 957, 3, 957, 16491, 8, 957, 1, 958, 3, 958, 16494, 8, 958, 1, 958, + 3, 958, 16497, 8, 958, 1, 958, 1, 958, 3, 958, 16501, 8, 958, 1, 958, 1, + 958, 1, 958, 3, 958, 16506, 8, 958, 1, 958, 1, 958, 5, 958, 16510, 8, 958, + 10, 958, 12, 958, 16513, 9, 958, 1, 959, 1, 959, 1, 959, 1, 960, 1, 960, + 1, 960, 1, 961, 1, 961, 3, 961, 16523, 8, 961, 1, 962, 1, 962, 1, 962, + 1, 962, 1, 962, 3, 962, 16530, 8, 962, 1, 962, 1, 962, 3, 962, 16534, 8, + 962, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 1, 963, 3, + 963, 16544, 8, 963, 1, 964, 1, 964, 3, 964, 16548, 8, 964, 1, 964, 1, 964, + 1, 964, 1, 964, 5, 964, 16554, 8, 964, 10, 964, 12, 964, 16557, 9, 964, + 1, 964, 1, 964, 1, 964, 1, 964, 1, 965, 1, 965, 1, 965, 1, 965, 1, 965, + 3, 965, 16568, 8, 965, 1, 966, 1, 966, 1, 966, 3, 966, 16573, 8, 966, 1, + 967, 1, 967, 1, 967, 1, 967, 1, 967, 1, 967, 5, 967, 16581, 8, 967, 10, + 967, 12, 967, 16584, 9, 967, 1, 967, 1, 967, 1, 967, 5, 967, 16589, 8, + 967, 10, 967, 12, 967, 16592, 9, 967, 3, 967, 16594, 8, 967, 1, 967, 1, + 967, 1, 968, 1, 968, 3, 968, 16600, 8, 968, 1, 969, 1, 969, 1, 969, 3, + 969, 16605, 8, 969, 1, 969, 3, 969, 16608, 8, 969, 1, 970, 1, 970, 1, 970, + 3, 970, 16613, 8, 970, 1, 970, 1, 970, 1, 970, 3, 970, 16618, 8, 970, 1, + 970, 1, 970, 1, 970, 1, 970, 1, 971, 1, 971, 1, 971, 1, 971, 1, 971, 5, + 971, 16629, 8, 971, 10, 971, 12, 971, 16632, 9, 971, 1, 971, 1, 971, 1, + 972, 1, 972, 3, 972, 16638, 8, 972, 1, 972, 1, 972, 1, 972, 1, 972, 1, + 972, 1, 972, 5, 972, 16646, 8, 972, 10, 972, 12, 972, 16649, 9, 972, 1, + 972, 1, 972, 3, 972, 16653, 8, 972, 3, 972, 16655, 8, 972, 1, 973, 1, 973, + 1, 973, 3, 973, 16660, 8, 973, 1, 973, 1, 973, 3, 973, 16664, 8, 973, 1, + 973, 1, 973, 1, 973, 1, 973, 3, 973, 16670, 8, 973, 1, 973, 1, 973, 3, + 973, 16674, 8, 973, 1, 974, 1, 974, 1, 974, 1, 974, 1, 975, 1, 975, 1, + 975, 1, 975, 1, 975, 5, 975, 16685, 8, 975, 10, 975, 12, 975, 16688, 9, + 975, 1, 975, 3, 975, 16691, 8, 975, 1, 975, 1, 975, 1, 975, 1, 975, 1, + 975, 1, 975, 5, 975, 16699, 8, 975, 10, 975, 12, 975, 16702, 9, 975, 3, + 975, 16704, 8, 975, 3, 975, 16706, 8, 975, 1, 976, 1, 976, 1, 976, 3, 976, + 16711, 8, 976, 1, 977, 1, 977, 1, 977, 1, 977, 1, 977, 5, 977, 16718, 8, + 977, 10, 977, 12, 977, 16721, 9, 977, 1, 977, 1, 977, 1, 978, 1, 978, 1, + 978, 1, 978, 1, 978, 1, 978, 5, 978, 16731, 8, 978, 10, 978, 12, 978, 16734, + 9, 978, 1, 978, 1, 978, 1, 979, 1, 979, 1, 979, 3, 979, 16741, 8, 979, + 1, 979, 1, 979, 3, 979, 16745, 8, 979, 1, 980, 1, 980, 1, 980, 1, 981, + 1, 981, 5, 981, 16752, 8, 981, 10, 981, 12, 981, 16755, 9, 981, 1, 981, + 3, 981, 16758, 8, 981, 1, 981, 5, 981, 16761, 8, 981, 10, 981, 12, 981, + 16764, 9, 981, 1, 981, 1, 981, 1, 982, 1, 982, 1, 982, 1, 982, 1, 982, + 1, 982, 3, 982, 16774, 8, 982, 3, 982, 16776, 8, 982, 1, 983, 1, 983, 1, + 983, 1, 983, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, 984, 1, + 984, 5, 984, 16790, 8, 984, 10, 984, 12, 984, 16793, 9, 984, 1, 985, 1, + 985, 3, 985, 16797, 8, 985, 1, 985, 1, 985, 5, 985, 16801, 8, 985, 10, + 985, 12, 985, 16804, 9, 985, 1, 985, 1, 985, 1, 986, 3, 986, 16809, 8, + 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 986, 1, 987, 1, 987, 1, + 987, 1, 987, 1, 988, 1, 988, 1, 988, 1, 988, 5, 988, 16825, 8, 988, 10, + 988, 12, 988, 16828, 9, 988, 1, 988, 1, 988, 1, 989, 1, 989, 3, 989, 16834, + 8, 989, 1, 989, 3, 989, 16837, 8, 989, 1, 990, 3, 990, 16840, 8, 990, 1, + 990, 1, 990, 1, 990, 1, 990, 5, 990, 16846, 8, 990, 10, 990, 12, 990, 16849, + 9, 990, 3, 990, 16851, 8, 990, 1, 990, 1, 990, 1, 991, 1, 991, 1, 991, + 1, 991, 3, 991, 16859, 8, 991, 3, 991, 16861, 8, 991, 1, 991, 1, 991, 3, + 991, 16865, 8, 991, 1, 991, 3, 991, 16868, 8, 991, 1, 992, 1, 992, 1, 992, + 3, 992, 16873, 8, 992, 3, 992, 16875, 8, 992, 1, 992, 1, 992, 3, 992, 16879, + 8, 992, 1, 992, 1, 992, 1, 992, 1, 993, 1, 993, 1, 994, 1, 994, 1, 994, + 1, 994, 1, 994, 3, 994, 16891, 8, 994, 1, 995, 1, 995, 1, 995, 1, 995, + 1, 995, 1, 996, 1, 996, 3, 996, 16900, 8, 996, 1, 996, 1, 996, 1, 996, + 1, 996, 5, 996, 16906, 8, 996, 10, 996, 12, 996, 16909, 9, 996, 1, 997, + 1, 997, 3, 997, 16913, 8, 997, 1, 997, 1, 997, 3, 997, 16917, 8, 997, 1, + 998, 1, 998, 1, 998, 1, 998, 1, 999, 1, 999, 1, 999, 1, 999, 3, 999, 16927, + 8, 999, 3, 999, 16929, 8, 999, 1, 999, 1, 999, 1, 999, 1, 999, 3, 999, + 16935, 8, 999, 1, 1000, 1, 1000, 1, 1000, 3, 1000, 16940, 8, 1000, 1, 1000, + 3, 1000, 16943, 8, 1000, 1, 1001, 1, 1001, 1, 1001, 1, 1002, 1, 1002, 1, + 1002, 1, 1002, 1, 1002, 3, 1002, 16953, 8, 1002, 1, 1003, 1, 1003, 1, 1003, + 1, 1003, 3, 1003, 16959, 8, 1003, 1, 1003, 3, 1003, 16962, 8, 1003, 1, + 1003, 3, 1003, 16965, 8, 1003, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 5, 1004, + 16971, 8, 1004, 10, 1004, 12, 1004, 16974, 9, 1004, 1, 1004, 1, 1004, 1, + 1004, 1, 1004, 1, 1004, 1, 1004, 1, 1004, 3, 1004, 16983, 8, 1004, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, + 1, 1005, 1, 1005, 1, 1005, 1, 1005, 1, 1005, 3, 1005, 16999, 8, 1005, 1, + 1006, 1, 1006, 3, 1006, 17003, 8, 1006, 1, 1006, 1, 1006, 3, 1006, 17007, + 8, 1006, 1, 1006, 3, 1006, 17010, 8, 1006, 1, 1006, 3, 1006, 17013, 8, + 1006, 1, 1007, 1, 1007, 1, 1007, 3, 1007, 17018, 8, 1007, 1, 1008, 1, 1008, + 1, 1008, 3, 1008, 17023, 8, 1008, 1, 1008, 3, 1008, 17026, 8, 1008, 1, + 1008, 3, 1008, 17029, 8, 1008, 1, 1009, 1, 1009, 4, 1009, 17033, 8, 1009, + 11, 1009, 12, 1009, 17034, 1, 1009, 3, 1009, 17038, 8, 1009, 1, 1009, 1, + 1009, 1, 1010, 1, 1010, 3, 1010, 17044, 8, 1010, 1, 1010, 3, 1010, 17047, + 8, 1010, 1, 1011, 3, 1011, 17050, 8, 1011, 1, 1011, 4, 1011, 17053, 8, + 1011, 11, 1011, 12, 1011, 17054, 1, 1011, 3, 1011, 17058, 8, 1011, 1, 1012, + 1, 1012, 1, 1012, 1, 1012, 4, 1012, 17064, 8, 1012, 11, 1012, 12, 1012, + 17065, 1, 1013, 1, 1013, 4, 1013, 17070, 8, 1013, 11, 1013, 12, 1013, 17071, + 1, 1014, 1, 1014, 1, 1014, 3, 1014, 17077, 8, 1014, 1, 1015, 1, 1015, 1, + 1015, 1, 1015, 1, 1015, 1, 1015, 3, 1015, 17085, 8, 1015, 1, 1016, 1, 1016, + 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, 1, 1016, + 1, 1016, 3, 1016, 17098, 8, 1016, 1, 1016, 1, 1016, 3, 1016, 17102, 8, + 1016, 3, 1016, 17104, 8, 1016, 1, 1016, 3, 1016, 17107, 8, 1016, 1, 1017, + 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 1, 1017, 5, 1017, + 17117, 8, 1017, 10, 1017, 12, 1017, 17120, 9, 1017, 1, 1017, 3, 1017, 17123, + 8, 1017, 1, 1017, 3, 1017, 17126, 8, 1017, 1, 1018, 1, 1018, 1, 1018, 1, + 1018, 1, 1019, 1, 1019, 1, 1019, 1, 1020, 1, 1020, 1, 1020, 1, 1020, 1, + 1020, 1, 1020, 3, 1020, 17141, 8, 1020, 1, 1020, 1, 1020, 3, 1020, 17145, + 8, 1020, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 1, 1021, 3, 1021, 17152, 8, + 1021, 1, 1021, 3, 1021, 17155, 8, 1021, 1, 1022, 1, 1022, 1, 1022, 1, 1022, + 1, 1022, 5, 1022, 17162, 8, 1022, 10, 1022, 12, 1022, 17165, 9, 1022, 1, + 1022, 1, 1022, 1, 1022, 1, 1022, 3, 1022, 17171, 8, 1022, 1, 1023, 1, 1023, + 1, 1023, 3, 1023, 17176, 8, 1023, 1, 1024, 1, 1024, 3, 1024, 17180, 8, + 1024, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 3, 1025, 17188, + 8, 1025, 1, 1025, 1, 1025, 1, 1025, 1, 1025, 3, 1025, 17194, 8, 1025, 1, + 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 1, 1026, 3, 1026, 17202, 8, 1026, + 1, 1026, 3, 1026, 17205, 8, 1026, 1, 1027, 1, 1027, 1, 1027, 1, 1027, 1, + 1028, 1, 1028, 1, 1028, 3, 1028, 17214, 8, 1028, 1, 1028, 3, 1028, 17217, + 8, 1028, 1, 1028, 3, 1028, 17220, 8, 1028, 1, 1029, 1, 1029, 1, 1029, 1, + 1030, 1, 1030, 1, 1030, 1, 1030, 3, 1030, 17229, 8, 1030, 1, 1031, 1, 1031, + 1, 1031, 1, 1031, 3, 1031, 17235, 8, 1031, 1, 1031, 1, 1031, 1, 1031, 1, + 1031, 3, 1031, 17241, 8, 1031, 1, 1031, 1, 1031, 1, 1031, 3, 1031, 17246, + 8, 1031, 3, 1031, 17248, 8, 1031, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 1, + 1032, 1, 1032, 1, 1032, 1, 1032, 1, 1032, 3, 1032, 17259, 8, 1032, 3, 1032, + 17261, 8, 1032, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, 1033, 1, + 1033, 3, 1033, 17270, 8, 1033, 3, 1033, 17272, 8, 1033, 1, 1034, 1, 1034, + 3, 1034, 17276, 8, 1034, 1, 1034, 1, 1034, 1, 1034, 1, 1034, 3, 1034, 17282, + 8, 1034, 1, 1034, 1, 1034, 3, 1034, 17286, 8, 1034, 1, 1035, 1, 1035, 1, + 1035, 1, 1035, 1, 1035, 1, 1036, 1, 1036, 3, 1036, 17295, 8, 1036, 1, 1037, + 1, 1037, 1, 1037, 3, 1037, 17300, 8, 1037, 1, 1037, 1, 1037, 1, 1037, 3, + 1037, 17305, 8, 1037, 1, 1037, 3, 1037, 17308, 8, 1037, 1, 1037, 1, 1037, + 1, 1037, 3, 1037, 17313, 8, 1037, 1, 1037, 1, 1037, 1, 1037, 1, 1037, 1, + 1037, 3, 1037, 17320, 8, 1037, 1, 1038, 1, 1038, 1, 1038, 5, 1038, 17325, + 8, 1038, 10, 1038, 12, 1038, 17328, 9, 1038, 1, 1039, 1, 1039, 3, 1039, + 17332, 8, 1039, 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, 1041, 1, 1041, 5, + 1041, 17348, 8, 1041, 10, 1041, 12, 1041, 17351, 9, 1041, 1, 1042, 3, 1042, + 17354, 8, 1042, 1, 1042, 1, 1042, 1, 1042, 3, 1042, 17359, 8, 1042, 1, + 1042, 5, 1042, 17362, 8, 1042, 10, 1042, 12, 1042, 17365, 9, 1042, 1, 1043, + 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, 1, 1043, + 3, 1043, 17376, 8, 1043, 1, 1043, 1, 1043, 3, 1043, 17380, 8, 1043, 1, + 1043, 1, 1043, 1, 1043, 5, 1043, 17385, 8, 1043, 10, 1043, 12, 1043, 17388, + 9, 1043, 1, 1043, 1, 1043, 3, 1043, 17392, 8, 1043, 1, 1044, 1, 1044, 1, + 1044, 3, 1044, 17397, 8, 1044, 1, 1044, 3, 1044, 17400, 8, 1044, 1, 1045, + 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 1, 1045, 5, 1045, 17409, 8, + 1045, 10, 1045, 12, 1045, 17412, 9, 1045, 1, 1046, 1, 1046, 3, 1046, 17416, + 8, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, 1, 1046, + 1, 1046, 3, 1046, 17426, 8, 1046, 3, 1046, 17428, 8, 1046, 3, 1046, 17430, + 8, 1046, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, 1, 1047, + 1, 1047, 3, 1047, 17440, 8, 1047, 1, 1047, 1, 1047, 3, 1047, 17444, 8, + 1047, 3, 1047, 17446, 8, 1047, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, + 1, 1048, 1, 1048, 1, 1048, 5, 1048, 17456, 8, 1048, 10, 1048, 12, 1048, + 17459, 9, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 1, 1048, 3, 1048, 17466, + 8, 1048, 1, 1049, 1, 1049, 1, 1049, 1, 1049, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 3, 1050, 17479, 8, 1050, 1, 1050, 3, + 1050, 17482, 8, 1050, 1, 1050, 1, 1050, 1, 1050, 3, 1050, 17487, 8, 1050, + 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, 1, 1050, + 1, 1050, 1, 1050, 5, 1050, 17499, 8, 1050, 10, 1050, 12, 1050, 17502, 9, + 1050, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 17509, 8, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 17517, 8, + 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 17524, 8, 1051, + 1, 1051, 1, 1051, 1, 1051, 1, 1051, 1, 1051, 3, 1051, 17531, 8, 1051, 1, + 1052, 1, 1052, 1, 1052, 1, 1052, 1, 1052, 3, 1052, 17538, 8, 1052, 1, 1053, + 1, 1053, 3, 1053, 17542, 8, 1053, 1, 1053, 1, 1053, 1, 1053, 3, 1053, 17547, + 8, 1053, 5, 1053, 17549, 8, 1053, 10, 1053, 12, 1053, 17552, 9, 1053, 1, + 1053, 1, 1053, 1, 1053, 5, 1053, 17557, 8, 1053, 10, 1053, 12, 1053, 17560, + 9, 1053, 1, 1053, 3, 1053, 17563, 8, 1053, 1, 1054, 1, 1054, 1, 1054, 1, + 1054, 1, 1054, 3, 1054, 17570, 8, 1054, 1, 1054, 1, 1054, 1, 1054, 3, 1054, + 17575, 8, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, 1054, 1, + 1054, 3, 1054, 17584, 8, 1054, 1, 1055, 1, 1055, 1, 1055, 1, 1055, 1, 1055, + 1, 1055, 1, 1055, 3, 1055, 17593, 8, 1055, 1, 1055, 3, 1055, 17596, 8, + 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, 1056, 1, 1056, 1, 1056, 1, + 1056, 1, 1056, 1, 1056, 3, 1056, 17616, 8, 1056, 1, 1057, 1, 1057, 3, 1057, + 17620, 8, 1057, 1, 1058, 3, 1058, 17623, 8, 1058, 1, 1058, 1, 1058, 1, + 1058, 4, 1058, 17628, 8, 1058, 11, 1058, 12, 1058, 17629, 1, 1058, 3, 1058, + 17633, 8, 1058, 1, 1058, 1, 1058, 3, 1058, 17637, 8, 1058, 1, 1058, 3, + 1058, 17640, 8, 1058, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 1, 1059, 3, 1059, + 17647, 8, 1059, 1, 1060, 3, 1060, 17650, 8, 1060, 1, 1060, 1, 1060, 4, + 1060, 17654, 8, 1060, 11, 1060, 12, 1060, 17655, 1, 1060, 3, 1060, 17659, + 8, 1060, 1, 1060, 1, 1060, 3, 1060, 17663, 8, 1060, 1, 1060, 3, 1060, 17666, + 8, 1060, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 1, 1061, 3, 1061, 17673, 8, + 1061, 1, 1062, 1, 1062, 1, 1062, 3, 1062, 17678, 8, 1062, 1, 1063, 1, 1063, + 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, 1, 1063, + 5, 1063, 17690, 8, 1063, 10, 1063, 12, 1063, 17693, 9, 1063, 1, 1063, 1, + 1063, 1, 1063, 1, 1063, 3, 1063, 17699, 8, 1063, 1, 1064, 1, 1064, 1, 1064, + 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 1, 1064, 3, 1064, 17710, 8, + 1064, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 3, + 1065, 17719, 8, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 3, 1065, 17728, 8, 1065, 1, 1065, 1, 1065, 3, 1065, 17732, 8, + 1065, 1, 1065, 1, 1065, 3, 1065, 17736, 8, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 3, 1065, 17762, 8, 1065, 1, + 1065, 3, 1065, 17765, 8, 1065, 1, 1065, 3, 1065, 17768, 8, 1065, 1, 1065, + 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 3, 1065, + 17778, 8, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 3, + 1065, 17786, 8, 1065, 1, 1065, 1, 1065, 1, 1065, 1, 1065, 3, 1065, 17792, + 8, 1065, 3, 1065, 17794, 8, 1065, 1, 1065, 1, 1065, 3, 1065, 17798, 8, + 1065, 1, 1066, 1, 1066, 1, 1066, 1, 1066, 3, 1066, 17804, 8, 1066, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 5, 1067, 17811, 8, 1067, 10, 1067, + 12, 1067, 17814, 9, 1067, 1, 1067, 3, 1067, 17817, 8, 1067, 1, 1067, 3, + 1067, 17820, 8, 1067, 1, 1067, 3, 1067, 17823, 8, 1067, 1, 1067, 1, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, 17832, 8, 1067, 1, + 1067, 3, 1067, 17835, 8, 1067, 1, 1067, 3, 1067, 17838, 8, 1067, 1, 1067, + 3, 1067, 17841, 8, 1067, 1, 1067, 3, 1067, 17844, 8, 1067, 1, 1067, 1, + 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, + 1067, 3, 1067, 17856, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 1, 1067, 3, 1067, 17864, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, + 1067, 3, 1067, 17871, 8, 1067, 1, 1067, 3, 1067, 17874, 8, 1067, 1, 1067, + 1, 1067, 3, 1067, 17878, 8, 1067, 3, 1067, 17880, 8, 1067, 1, 1067, 3, + 1067, 17883, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, 17888, 8, 1067, + 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, + 17897, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, 17902, 8, 1067, 1, + 1067, 3, 1067, 17905, 8, 1067, 1, 1067, 3, 1067, 17908, 8, 1067, 1, 1067, + 3, 1067, 17911, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, + 1067, 1, 1067, 3, 1067, 17920, 8, 1067, 1, 1067, 3, 1067, 17923, 8, 1067, + 1, 1067, 3, 1067, 17926, 8, 1067, 1, 1067, 3, 1067, 17929, 8, 1067, 1, + 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, 17935, 8, 1067, 1, 1067, 1, 1067, + 3, 1067, 17939, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, + 1067, 1, 1067, 1, 1067, 5, 1067, 17949, 8, 1067, 10, 1067, 12, 1067, 17952, + 9, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, + 3, 1067, 17961, 8, 1067, 1, 1067, 1, 1067, 3, 1067, 17965, 8, 1067, 1, + 1067, 3, 1067, 17968, 8, 1067, 1, 1067, 1, 1067, 1, 1067, 1, 1067, 3, 1067, + 17974, 8, 1067, 1, 1067, 1, 1067, 3, 1067, 17978, 8, 1067, 1, 1067, 1, + 1067, 1, 1067, 1, 1067, 3, 1067, 17984, 8, 1067, 1, 1067, 1, 1067, 3, 1067, + 17988, 8, 1067, 1, 1067, 3, 1067, 17991, 8, 1067, 1, 1067, 3, 1067, 17994, + 8, 1067, 3, 1067, 17996, 8, 1067, 1, 1068, 1, 1068, 1, 1068, 5, 1068, 18001, + 8, 1068, 10, 1068, 12, 1068, 18004, 9, 1068, 1, 1068, 3, 1068, 18007, 8, + 1068, 1, 1068, 3, 1068, 18010, 8, 1068, 1, 1068, 3, 1068, 18013, 8, 1068, + 1, 1068, 3, 1068, 18016, 8, 1068, 1, 1068, 1, 1068, 1, 1068, 3, 1068, 18021, + 8, 1068, 1, 1069, 3, 1069, 18024, 8, 1069, 1, 1069, 1, 1069, 3, 1069, 18028, + 8, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, 1, 1069, + 3, 1069, 18037, 8, 1069, 1, 1069, 3, 1069, 18040, 8, 1069, 1, 1070, 1, + 1070, 1, 1070, 1, 1070, 1, 1070, 3, 1070, 18047, 8, 1070, 1, 1070, 1, 1070, + 3, 1070, 18051, 8, 1070, 1, 1070, 1, 1070, 1, 1070, 3, 1070, 18056, 8, + 1070, 1, 1070, 1, 1070, 1, 1070, 3, 1070, 18061, 8, 1070, 1, 1070, 3, 1070, + 18064, 8, 1070, 1, 1070, 1, 1070, 1, 1071, 1, 1071, 1, 1071, 1, 1071, 1, + 1071, 3, 1071, 18073, 8, 1071, 1, 1071, 1, 1071, 3, 1071, 18077, 8, 1071, + 1, 1072, 1, 1072, 1, 1072, 1, 1072, 1, 1073, 1, 1073, 1, 1073, 1, 1073, + 1, 1073, 3, 1073, 18088, 8, 1073, 1, 1073, 3, 1073, 18091, 8, 1073, 1, + 1073, 1, 1073, 3, 1073, 18095, 8, 1073, 1, 1074, 1, 1074, 1, 1074, 3, 1074, + 18100, 8, 1074, 1, 1074, 1, 1074, 3, 1074, 18104, 8, 1074, 1, 1074, 1, + 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18113, 8, 1074, + 1, 1074, 3, 1074, 18116, 8, 1074, 1, 1074, 1, 1074, 3, 1074, 18120, 8, + 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 3, + 1074, 18129, 8, 1074, 1, 1074, 3, 1074, 18132, 8, 1074, 1, 1074, 1, 1074, + 3, 1074, 18136, 8, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18141, 8, + 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 3, + 1074, 18150, 8, 1074, 1, 1074, 3, 1074, 18153, 8, 1074, 1, 1074, 1, 1074, + 3, 1074, 18157, 8, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, 1074, 1, + 1074, 3, 1074, 18165, 8, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18170, + 8, 1074, 1, 1074, 1, 1074, 1, 1074, 3, 1074, 18175, 8, 1074, 1, 1074, 3, + 1074, 18178, 8, 1074, 1, 1074, 1, 1074, 3, 1074, 18182, 8, 1074, 3, 1074, + 18184, 8, 1074, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 1, 1075, 5, 1075, 18191, + 8, 1075, 10, 1075, 12, 1075, 18194, 9, 1075, 1, 1075, 1, 1075, 1, 1076, + 1, 1076, 3, 1076, 18200, 8, 1076, 1, 1076, 3, 1076, 18203, 8, 1076, 1, + 1076, 1, 1076, 1, 1076, 1, 1076, 1, 1076, 3, 1076, 18210, 8, 1076, 3, 1076, + 18212, 8, 1076, 1, 1076, 3, 1076, 18215, 8, 1076, 1, 1076, 3, 1076, 18218, + 8, 1076, 1, 1076, 1, 1076, 3, 1076, 18222, 8, 1076, 1, 1076, 3, 1076, 18225, + 8, 1076, 1, 1076, 1, 1076, 1, 1076, 3, 1076, 18230, 8, 1076, 1, 1076, 1, + 1076, 1, 1076, 1, 1076, 1, 1076, 3, 1076, 18237, 8, 1076, 1, 1076, 1, 1076, + 1, 1076, 1, 1076, 3, 1076, 18243, 8, 1076, 1, 1076, 1, 1076, 1, 1076, 1, + 1076, 1, 1076, 1, 1076, 3, 1076, 18251, 8, 1076, 1, 1077, 1, 1077, 3, 1077, + 18255, 8, 1077, 1, 1077, 3, 1077, 18258, 8, 1077, 1, 1077, 3, 1077, 18261, + 8, 1077, 1, 1078, 1, 1078, 1, 1078, 1, 1078, 3, 1078, 18267, 8, 1078, 1, + 1078, 3, 1078, 18270, 8, 1078, 1, 1078, 1, 1078, 3, 1078, 18274, 8, 1078, + 1, 1079, 1, 1079, 3, 1079, 18278, 8, 1079, 1, 1079, 1, 1079, 1, 1079, 3, + 1079, 18283, 8, 1079, 1, 1079, 3, 1079, 18286, 8, 1079, 1, 1079, 3, 1079, + 18289, 8, 1079, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1080, 1, + 1080, 3, 1080, 18298, 8, 1080, 1, 1080, 1, 1080, 1, 1080, 1, 1081, 1, 1081, + 1, 1081, 1, 1081, 1, 1081, 1, 1081, 1, 1081, 3, 1081, 18310, 8, 1081, 1, + 1081, 1, 1081, 1, 1081, 1, 1082, 1, 1082, 3, 1082, 18317, 8, 1082, 1, 1082, + 3, 1082, 18320, 8, 1082, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 3, 1083, 18326, + 8, 1083, 1, 1083, 3, 1083, 18329, 8, 1083, 1, 1083, 3, 1083, 18332, 8, + 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 3, + 1083, 18341, 8, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 3, 1083, 18347, + 8, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 1, 1083, 3, 1083, 18354, 8, + 1083, 3, 1083, 18356, 8, 1083, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, + 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 1, 1084, 3, 1084, 18369, 8, + 1084, 1, 1085, 1, 1085, 1, 1085, 1, 1085, 3, 1085, 18375, 8, 1085, 1, 1086, + 1, 1086, 1, 1086, 3, 1086, 18380, 8, 1086, 1, 1087, 1, 1087, 1, 1087, 3, + 1087, 18385, 8, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, + 1, 1087, 3, 1087, 18394, 8, 1087, 1, 1087, 3, 1087, 18397, 8, 1087, 3, + 1087, 18399, 8, 1087, 1, 1087, 1, 1087, 3, 1087, 18403, 8, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 18410, 8, 1087, 1, 1087, 1, + 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 18417, 8, 1087, 1, 1087, 1, 1087, + 1, 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 18425, 8, 1087, 1, 1087, 1, + 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, 1087, 1, + 1087, 1, 1087, 1, 1087, 1, 1087, 3, 1087, 18440, 8, 1087, 1, 1088, 1, 1088, + 1, 1088, 1, 1088, 3, 1088, 18446, 8, 1088, 1, 1088, 1, 1088, 3, 1088, 18450, + 8, 1088, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18455, 8, 1089, 1, 1089, 1, + 1089, 1, 1089, 3, 1089, 18460, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 3, 1089, 18466, 8, 1089, 1, 1089, 3, 1089, 18469, 8, 1089, 1, 1089, 1, + 1089, 3, 1089, 18473, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18483, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18493, 8, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18499, 8, 1089, 3, 1089, 18501, + 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 3, 1089, 18511, 8, 1089, 3, 1089, 18513, 8, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18520, 8, 1089, 1, 1089, 1, 1089, + 3, 1089, 18524, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 4, + 1089, 18531, 8, 1089, 11, 1089, 12, 1089, 18532, 1, 1089, 1, 1089, 1, 1089, + 3, 1089, 18538, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18543, 8, + 1089, 1, 1089, 3, 1089, 18546, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18555, 8, 1089, 1, 1089, 3, 1089, 18558, + 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 3, 1089, 18567, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18581, + 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, + 18589, 8, 1089, 1, 1089, 3, 1089, 18592, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, + 1089, 3, 1089, 18605, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, + 18611, 8, 1089, 3, 1089, 18613, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, + 1089, 18626, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 3, 1089, 18635, 8, 1089, 1, 1089, 1, 1089, 5, 1089, 18639, 8, + 1089, 10, 1089, 12, 1089, 18642, 9, 1089, 1, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18651, 8, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18659, 8, 1089, 1, 1089, 3, + 1089, 18662, 8, 1089, 1, 1089, 3, 1089, 18665, 8, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 3, 1089, 18679, 8, 1089, 3, 1089, 18681, 8, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18689, 8, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18694, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 5, 1089, 18701, 8, 1089, 10, 1089, 12, 1089, 18704, + 9, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18709, 8, 1089, 1, 1089, 1, + 1089, 1, 1089, 3, 1089, 18714, 8, 1089, 1, 1089, 3, 1089, 18717, 8, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18722, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 3, 1089, 18727, 8, 1089, 5, 1089, 18729, 8, 1089, 10, 1089, 12, 1089, + 18732, 9, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18737, 8, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18743, 8, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18752, 8, 1089, 1, + 1089, 1, 1089, 1, 1089, 3, 1089, 18757, 8, 1089, 1, 1089, 1, 1089, 1, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18765, 8, 1089, 1, 1089, 1, 1089, 3, + 1089, 18769, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18774, 8, 1089, + 1, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18780, 8, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18787, 8, 1089, 1, 1089, 1, 1089, + 1, 1089, 3, 1089, 18792, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 1, 1089, 1, + 1089, 3, 1089, 18799, 8, 1089, 1, 1089, 1, 1089, 3, 1089, 18803, 8, 1089, + 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18808, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18816, 8, 1089, 1, 1089, 3, 1089, + 18819, 8, 1089, 1, 1089, 3, 1089, 18822, 8, 1089, 1, 1089, 3, 1089, 18825, + 8, 1089, 1, 1089, 1, 1089, 3, 1089, 18829, 8, 1089, 1, 1089, 1, 1089, 1, + 1089, 3, 1089, 18834, 8, 1089, 1, 1089, 1, 1089, 1, 1089, 3, 1089, 18839, + 8, 1089, 1, 1090, 1, 1090, 1, 1091, 1, 1091, 1, 1092, 1, 1092, 1, 1093, + 1, 1093, 1, 1093, 3, 1093, 18850, 8, 1093, 1, 1093, 1, 1093, 3, 1093, 18854, + 8, 1093, 3, 1093, 18856, 8, 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 1, + 1093, 1, 1093, 1, 1093, 1, 1093, 1, 1093, 3, 1093, 18867, 8, 1093, 3, 1093, + 18869, 8, 1093, 1, 1093, 1, 1093, 1, 1094, 1, 1094, 1, 1094, 1, 1094, 1, + 1094, 1, 1094, 1, 1094, 3, 1094, 18880, 8, 1094, 1, 1095, 1, 1095, 1, 1096, + 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 1, 1096, 3, 1096, 18891, 8, + 1096, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 1, 1097, 5, 1097, 18898, 8, 1097, + 10, 1097, 12, 1097, 18901, 9, 1097, 3, 1097, 18903, 8, 1097, 1, 1098, 1, + 1098, 3, 1098, 18907, 8, 1098, 1, 1098, 3, 1098, 18910, 8, 1098, 1, 1098, + 1, 1098, 1, 1099, 1, 1099, 1, 1099, 1, 1099, 1, 1100, 1, 1100, 1, 1100, + 1, 1100, 1, 1100, 1, 1100, 1, 1100, 3, 1100, 18925, 8, 1100, 1, 1101, 1, + 1101, 1, 1101, 3, 1101, 18930, 8, 1101, 1, 1101, 1, 1101, 1, 1101, 1, 1101, + 5, 1101, 18936, 8, 1101, 10, 1101, 12, 1101, 18939, 9, 1101, 1, 1101, 1, + 1101, 1, 1101, 1, 1101, 3, 1101, 18945, 8, 1101, 1, 1101, 1, 1101, 3, 1101, + 18949, 8, 1101, 1, 1102, 1, 1102, 1, 1102, 3, 1102, 18954, 8, 1102, 1, + 1102, 1, 1102, 3, 1102, 18958, 8, 1102, 1, 1102, 1, 1102, 1, 1102, 3, 1102, + 18963, 8, 1102, 5, 1102, 18965, 8, 1102, 10, 1102, 12, 1102, 18968, 9, + 1102, 1, 1103, 1, 1103, 1, 1103, 3, 1103, 18973, 8, 1103, 1, 1103, 3, 1103, + 18976, 8, 1103, 1, 1103, 1, 1103, 1, 1103, 5, 1103, 18981, 8, 1103, 10, + 1103, 12, 1103, 18984, 9, 1103, 1, 1103, 1, 1103, 1, 1104, 1, 1104, 1, + 1104, 1, 1104, 1, 1104, 3, 1104, 18993, 8, 1104, 1, 1104, 1, 1104, 1, 1104, + 1, 1104, 5, 1104, 18999, 8, 1104, 10, 1104, 12, 1104, 19002, 9, 1104, 1, + 1104, 3, 1104, 19005, 8, 1104, 1, 1104, 1, 1104, 1, 1105, 1, 1105, 1, 1105, + 1, 1105, 1, 1105, 1, 1105, 3, 1105, 19015, 8, 1105, 1, 1105, 3, 1105, 19018, + 8, 1105, 3, 1105, 19020, 8, 1105, 1, 1106, 1, 1106, 1, 1106, 1, 1107, 1, + 1107, 1, 1107, 1, 1107, 1, 1107, 3, 1107, 19030, 8, 1107, 3, 1107, 19032, + 8, 1107, 1, 1108, 1, 1108, 1, 1108, 1, 1108, 3, 1108, 19038, 8, 1108, 1, + 1109, 1, 1109, 1, 1109, 1, 1109, 3, 1109, 19044, 8, 1109, 3, 1109, 19046, + 8, 1109, 1, 1110, 1, 1110, 1, 1110, 1, 1111, 1, 1111, 1, 1111, 1, 1112, + 1, 1112, 1, 1112, 1, 1112, 1, 1112, 1, 1112, 3, 1112, 19060, 8, 1112, 3, + 1112, 19062, 8, 1112, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, 1, 1113, + 1, 1113, 1, 1113, 1, 1113, 3, 1113, 19073, 8, 1113, 1, 1114, 1, 1114, 1, + 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 1, 1114, 3, 1114, 19083, 8, 1114, + 1, 1114, 3, 1114, 19086, 8, 1114, 1, 1114, 1, 1114, 3, 1114, 19090, 8, + 1114, 3, 1114, 19092, 8, 1114, 1, 1115, 1, 1115, 1, 1115, 1, 1115, 1, 1115, + 1, 1115, 1, 1115, 3, 1115, 19101, 8, 1115, 1, 1116, 1, 1116, 1, 1116, 5, + 1116, 19106, 8, 1116, 10, 1116, 12, 1116, 19109, 9, 1116, 1, 1116, 1, 1116, + 3, 1116, 19113, 8, 1116, 1, 1117, 1, 1117, 3, 1117, 19117, 8, 1117, 1, + 1117, 1, 1117, 3, 1117, 19121, 8, 1117, 1, 1117, 1, 1117, 1, 1118, 3, 1118, + 19126, 8, 1118, 1, 1118, 1, 1118, 3, 1118, 19130, 8, 1118, 1, 1118, 3, + 1118, 19133, 8, 1118, 1, 1119, 1, 1119, 3, 1119, 19137, 8, 1119, 1, 1120, + 1, 1120, 1, 1120, 1, 1120, 1, 1120, 1, 1120, 3, 1120, 19145, 8, 1120, 1, + 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 1, 1121, 5, 1121, 19154, + 8, 1121, 10, 1121, 12, 1121, 19157, 9, 1121, 1, 1121, 1, 1121, 1, 1122, + 1, 1122, 3, 1122, 19163, 8, 1122, 1, 1122, 1, 1122, 1, 1122, 3, 1122, 19168, + 8, 1122, 1, 1122, 1, 1122, 1, 1122, 3, 1122, 19173, 8, 1122, 5, 1122, 19175, + 8, 1122, 10, 1122, 12, 1122, 19178, 9, 1122, 1, 1123, 1, 1123, 3, 1123, + 19182, 8, 1123, 1, 1124, 1, 1124, 1, 1125, 1, 1125, 1, 1126, 1, 1126, 1, + 1127, 1, 1127, 1, 1128, 1, 1128, 1, 1129, 1, 1129, 1, 1130, 1, 1130, 1, + 1130, 5, 1130, 19199, 8, 1130, 10, 1130, 12, 1130, 19202, 9, 1130, 1, 1130, + 1, 1130, 3, 1130, 19206, 8, 1130, 1, 1131, 1, 1131, 1, 1132, 1, 1132, 1, + 1132, 3, 1132, 19213, 8, 1132, 1, 1133, 1, 1133, 1, 1134, 1, 1134, 1, 1135, + 1, 1135, 1, 1136, 1, 1136, 1, 1136, 3, 1136, 19224, 8, 1136, 1, 1137, 1, + 1137, 1, 1137, 5, 1137, 19229, 8, 1137, 10, 1137, 12, 1137, 19232, 9, 1137, + 1, 1138, 1, 1138, 1, 1139, 1, 1139, 3, 1139, 19238, 8, 1139, 1, 1140, 1, + 1140, 1, 1140, 3, 1140, 19243, 8, 1140, 1, 1141, 1, 1141, 1, 1141, 5, 1141, + 19248, 8, 1141, 10, 1141, 12, 1141, 19251, 9, 1141, 1, 1141, 1, 1141, 3, + 1141, 19255, 8, 1141, 1, 1142, 1, 1142, 1, 1143, 1, 1143, 1, 1143, 5, 1143, + 19262, 8, 1143, 10, 1143, 12, 1143, 19265, 9, 1143, 1, 1144, 1, 1144, 1, + 1144, 5, 1144, 19270, 8, 1144, 10, 1144, 12, 1144, 19273, 9, 1144, 1, 1145, + 1, 1145, 1, 1145, 5, 1145, 19278, 8, 1145, 10, 1145, 12, 1145, 19281, 9, + 1145, 1, 1146, 1, 1146, 1, 1146, 3, 1146, 19286, 8, 1146, 1, 1147, 1, 1147, + 1, 1147, 3, 1147, 19291, 8, 1147, 1, 1148, 1, 1148, 1, 1148, 3, 1148, 19296, + 8, 1148, 1, 1149, 1, 1149, 3, 1149, 19300, 8, 1149, 1, 1149, 1, 1149, 1, + 1149, 3, 1149, 19305, 8, 1149, 1, 1149, 3, 1149, 19308, 8, 1149, 1, 1150, + 1, 1150, 1, 1150, 3, 1150, 19313, 8, 1150, 1, 1151, 1, 1151, 3, 1151, 19317, + 8, 1151, 1, 1152, 1, 1152, 3, 1152, 19321, 8, 1152, 1, 1153, 1, 1153, 1, + 1153, 3, 1153, 19326, 8, 1153, 1, 1154, 1, 1154, 1, 1155, 1, 1155, 1, 1155, + 5, 1155, 19333, 8, 1155, 10, 1155, 12, 1155, 19336, 9, 1155, 1, 1156, 1, + 1156, 1, 1156, 3, 1156, 19341, 8, 1156, 1, 1156, 1, 1156, 1, 1156, 1, 1156, + 5, 1156, 19347, 8, 1156, 10, 1156, 12, 1156, 19350, 9, 1156, 1, 1156, 3, + 1156, 19353, 8, 1156, 1, 1156, 1, 1156, 3, 1156, 19357, 8, 1156, 3, 1156, + 19359, 8, 1156, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 1, 1157, 3, 1157, 19366, + 8, 1157, 1, 1157, 1, 1157, 3, 1157, 19370, 8, 1157, 1, 1157, 1, 1157, 1, + 1157, 1, 1157, 5, 1157, 19376, 8, 1157, 10, 1157, 12, 1157, 19379, 9, 1157, + 3, 1157, 19381, 8, 1157, 1, 1157, 1, 1157, 1, 1157, 3, 1157, 19386, 8, + 1157, 1, 1158, 1, 1158, 1, 1158, 5, 1158, 19391, 8, 1158, 10, 1158, 12, + 1158, 19394, 9, 1158, 1, 1159, 1, 1159, 1, 1160, 1, 1160, 1, 1161, 1, 1161, + 1, 1162, 1, 1162, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 5, 1163, + 19409, 8, 1163, 10, 1163, 12, 1163, 19412, 9, 1163, 1, 1163, 1, 1163, 1, + 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, 1163, 1, + 1163, 1, 1163, 1, 1163, 1, 1163, 3, 1163, 19428, 8, 1163, 1, 1164, 1, 1164, + 1, 1164, 5, 1164, 19433, 8, 1164, 10, 1164, 12, 1164, 19436, 9, 1164, 1, + 1165, 1, 1165, 1, 1165, 1, 1165, 1, 1166, 1, 1166, 1, 1166, 1, 1166, 1, + 1166, 1, 1166, 1, 1166, 3, 1166, 19449, 8, 1166, 1, 1167, 1, 1167, 1, 1167, + 1, 1167, 5, 1167, 19455, 8, 1167, 10, 1167, 12, 1167, 19458, 9, 1167, 3, + 1167, 19460, 8, 1167, 1, 1167, 1, 1167, 3, 1167, 19464, 8, 1167, 1, 1168, + 1, 1168, 1, 1168, 3, 1168, 19469, 8, 1168, 1, 1168, 1, 1168, 1, 1168, 3, + 1168, 19474, 8, 1168, 5, 1168, 19476, 8, 1168, 10, 1168, 12, 1168, 19479, + 9, 1168, 3, 1168, 19481, 8, 1168, 1, 1168, 1, 1168, 3, 1168, 19485, 8, + 1168, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 3, 1169, 19492, 8, 1169, + 1, 1169, 1, 1169, 1, 1169, 3, 1169, 19497, 8, 1169, 3, 1169, 19499, 8, + 1169, 3, 1169, 19501, 8, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, 1, 1169, + 1, 1169, 1, 1169, 1, 1169, 3, 1169, 19511, 8, 1169, 1, 1169, 1, 1169, 1, + 1169, 3, 1169, 19516, 8, 1169, 5, 1169, 19518, 8, 1169, 10, 1169, 12, 1169, + 19521, 9, 1169, 3, 1169, 19523, 8, 1169, 1, 1169, 1, 1169, 3, 1169, 19527, + 8, 1169, 1, 1170, 1, 1170, 1, 1170, 1, 1171, 1, 1171, 1, 1171, 1, 1171, + 3, 1171, 19536, 8, 1171, 1, 1171, 1, 1171, 1, 1172, 1, 1172, 3, 1172, 19542, + 8, 1172, 1, 1172, 1, 1172, 3, 1172, 19546, 8, 1172, 3, 1172, 19548, 8, + 1172, 1, 1173, 1, 1173, 3, 1173, 19552, 8, 1173, 1, 1173, 1, 1173, 3, 1173, + 19556, 8, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 3, 1173, 19563, + 8, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 3, 1173, + 19571, 8, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 1, 1173, 3, + 1173, 19579, 8, 1173, 3, 1173, 19581, 8, 1173, 1, 1174, 1, 1174, 1, 1174, + 3, 1174, 19586, 8, 1174, 1, 1174, 1, 1174, 1, 1174, 3, 1174, 19591, 8, + 1174, 3, 1174, 19593, 8, 1174, 1, 1174, 3, 1174, 19596, 8, 1174, 1, 1174, + 1, 1174, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 3, 1175, 19620, 8, 1175, 1, + 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 3, 1175, 19627, 8, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, + 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 1, 1175, 3, 1175, 19660, 8, + 1175, 1, 1176, 1, 1176, 1, 1176, 3, 1176, 19665, 8, 1176, 1, 1176, 3, 1176, + 19668, 8, 1176, 1, 1176, 1, 1176, 1, 1176, 3, 1176, 19673, 8, 1176, 3, + 1176, 19675, 8, 1176, 1, 1176, 1, 1176, 3, 1176, 19679, 8, 1176, 1, 1177, + 1, 1177, 1, 1177, 5, 1177, 19684, 8, 1177, 10, 1177, 12, 1177, 19687, 9, + 1177, 1, 1178, 1, 1178, 3, 1178, 19691, 8, 1178, 1, 1178, 1, 1178, 1, 1178, + 3, 1178, 19696, 8, 1178, 1, 1178, 3, 1178, 19699, 8, 1178, 1, 1179, 1, + 1179, 3, 1179, 19703, 8, 1179, 1, 1179, 1, 1179, 1, 1179, 5, 1179, 19708, + 8, 1179, 10, 1179, 12, 1179, 19711, 9, 1179, 1, 1180, 1, 1180, 3, 1180, + 19715, 8, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, + 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, + 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, + 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 1, 1180, 3, 1180, 19745, 8, 1180, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19752, 8, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19767, 8, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19783, 8, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 3, 1181, 19802, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 3, 1181, 19819, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 3, 1181, 19826, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 3, 1181, 19834, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, + 1181, 19847, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 3, 1181, 19856, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 3, 1181, 19865, 8, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19874, 8, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19884, + 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, + 19892, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 3, 1181, 19902, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19912, 8, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 3, 1181, 19924, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 3, 1181, 19940, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19958, 8, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 3, 1181, 19971, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 3, 1181, 19986, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 19997, 8, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20007, + 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 3, 1181, 20018, 8, 1181, 1, 1181, 1, 1181, 1, 1181, 1, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20028, 8, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20045, 8, + 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20051, 8, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, 1, 1181, + 1, 1181, 1, 1181, 1, 1181, 3, 1181, 20073, 8, 1181, 1, 1182, 1, 1182, 1, + 1182, 3, 1182, 20078, 8, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 3, 1182, + 20084, 8, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 3, 1182, 20090, 8, + 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 3, 1182, 20096, 8, 1182, 1, 1182, + 1, 1182, 1, 1182, 3, 1182, 20101, 8, 1182, 3, 1182, 20103, 8, 1182, 1, + 1182, 3, 1182, 20106, 8, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, + 1, 1182, 1, 1182, 1, 1182, 3, 1182, 20116, 8, 1182, 1, 1182, 3, 1182, 20119, + 8, 1182, 3, 1182, 20121, 8, 1182, 3, 1182, 20123, 8, 1182, 1, 1182, 1, + 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, 1182, 1, + 1182, 1, 1182, 1, 1182, 3, 1182, 20137, 8, 1182, 1, 1183, 1, 1183, 1, 1183, + 3, 1183, 20142, 8, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20148, + 8, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20154, 8, 1183, 1, + 1183, 1, 1183, 1, 1183, 1, 1183, 3, 1183, 20160, 8, 1183, 1, 1183, 1, 1183, + 1, 1183, 3, 1183, 20165, 8, 1183, 3, 1183, 20167, 8, 1183, 1, 1183, 3, + 1183, 20170, 8, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, + 1, 1183, 1, 1183, 3, 1183, 20180, 8, 1183, 1, 1183, 3, 1183, 20183, 8, + 1183, 3, 1183, 20185, 8, 1183, 3, 1183, 20187, 8, 1183, 1, 1183, 1, 1183, + 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, 1, 1183, + 1, 1183, 1, 1183, 3, 1183, 20201, 8, 1183, 1, 1184, 1, 1184, 1, 1185, 1, + 1185, 1, 1185, 1, 1186, 1, 1186, 1, 1186, 3, 1186, 20211, 8, 1186, 1, 1187, + 1, 1187, 1, 1188, 1, 1188, 3, 1188, 20217, 8, 1188, 1, 1188, 1, 1188, 1, + 1189, 1, 1189, 3, 1189, 20223, 8, 1189, 1, 1190, 1, 1190, 1, 1190, 1, 1190, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, + 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 1, 1191, 3, 1191, 20323, 8, + 1191, 1, 1192, 1, 1192, 1, 1193, 1, 1193, 1, 1194, 1, 1194, 1, 1195, 1, + 1195, 1, 1195, 0, 3, 2082, 2090, 2100, 1196, 0, 2, 4, 6, 8, 10, 12, 14, + 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, + 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, + 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, + 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, + 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, + 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, + 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, + 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, + 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, + 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, + 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, + 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, + 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, + 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, + 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, + 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500, 502, 504, 506, 508, + 510, 512, 514, 516, 518, 520, 522, 524, 526, 528, 530, 532, 534, 536, 538, + 540, 542, 544, 546, 548, 550, 552, 554, 556, 558, 560, 562, 564, 566, 568, + 570, 572, 574, 576, 578, 580, 582, 584, 586, 588, 590, 592, 594, 596, 598, + 600, 602, 604, 606, 608, 610, 612, 614, 616, 618, 620, 622, 624, 626, 628, + 630, 632, 634, 636, 638, 640, 642, 644, 646, 648, 650, 652, 654, 656, 658, + 660, 662, 664, 666, 668, 670, 672, 674, 676, 678, 680, 682, 684, 686, 688, + 690, 692, 694, 696, 698, 700, 702, 704, 706, 708, 710, 712, 714, 716, 718, + 720, 722, 724, 726, 728, 730, 732, 734, 736, 738, 740, 742, 744, 746, 748, + 750, 752, 754, 756, 758, 760, 762, 764, 766, 768, 770, 772, 774, 776, 778, + 780, 782, 784, 786, 788, 790, 792, 794, 796, 798, 800, 802, 804, 806, 808, + 810, 812, 814, 816, 818, 820, 822, 824, 826, 828, 830, 832, 834, 836, 838, + 840, 842, 844, 846, 848, 850, 852, 854, 856, 858, 860, 862, 864, 866, 868, + 870, 872, 874, 876, 878, 880, 882, 884, 886, 888, 890, 892, 894, 896, 898, + 900, 902, 904, 906, 908, 910, 912, 914, 916, 918, 920, 922, 924, 926, 928, + 930, 932, 934, 936, 938, 940, 942, 944, 946, 948, 950, 952, 954, 956, 958, + 960, 962, 964, 966, 968, 970, 972, 974, 976, 978, 980, 982, 984, 986, 988, + 990, 992, 994, 996, 998, 1000, 1002, 1004, 1006, 1008, 1010, 1012, 1014, + 1016, 1018, 1020, 1022, 1024, 1026, 1028, 1030, 1032, 1034, 1036, 1038, + 1040, 1042, 1044, 1046, 1048, 1050, 1052, 1054, 1056, 1058, 1060, 1062, + 1064, 1066, 1068, 1070, 1072, 1074, 1076, 1078, 1080, 1082, 1084, 1086, + 1088, 1090, 1092, 1094, 1096, 1098, 1100, 1102, 1104, 1106, 1108, 1110, + 1112, 1114, 1116, 1118, 1120, 1122, 1124, 1126, 1128, 1130, 1132, 1134, + 1136, 1138, 1140, 1142, 1144, 1146, 1148, 1150, 1152, 1154, 1156, 1158, + 1160, 1162, 1164, 1166, 1168, 1170, 1172, 1174, 1176, 1178, 1180, 1182, + 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198, 1200, 1202, 1204, 1206, + 1208, 1210, 1212, 1214, 1216, 1218, 1220, 1222, 1224, 1226, 1228, 1230, + 1232, 1234, 1236, 1238, 1240, 1242, 1244, 1246, 1248, 1250, 1252, 1254, + 1256, 1258, 1260, 1262, 1264, 1266, 1268, 1270, 1272, 1274, 1276, 1278, + 1280, 1282, 1284, 1286, 1288, 1290, 1292, 1294, 1296, 1298, 1300, 1302, + 1304, 1306, 1308, 1310, 1312, 1314, 1316, 1318, 1320, 1322, 1324, 1326, + 1328, 1330, 1332, 1334, 1336, 1338, 1340, 1342, 1344, 1346, 1348, 1350, + 1352, 1354, 1356, 1358, 1360, 1362, 1364, 1366, 1368, 1370, 1372, 1374, + 1376, 1378, 1380, 1382, 1384, 1386, 1388, 1390, 1392, 1394, 1396, 1398, + 1400, 1402, 1404, 1406, 1408, 1410, 1412, 1414, 1416, 1418, 1420, 1422, + 1424, 1426, 1428, 1430, 1432, 1434, 1436, 1438, 1440, 1442, 1444, 1446, + 1448, 1450, 1452, 1454, 1456, 1458, 1460, 1462, 1464, 1466, 1468, 1470, + 1472, 1474, 1476, 1478, 1480, 1482, 1484, 1486, 1488, 1490, 1492, 1494, + 1496, 1498, 1500, 1502, 1504, 1506, 1508, 1510, 1512, 1514, 1516, 1518, + 1520, 1522, 1524, 1526, 1528, 1530, 1532, 1534, 1536, 1538, 1540, 1542, + 1544, 1546, 1548, 1550, 1552, 1554, 1556, 1558, 1560, 1562, 1564, 1566, + 1568, 1570, 1572, 1574, 1576, 1578, 1580, 1582, 1584, 1586, 1588, 1590, + 1592, 1594, 1596, 1598, 1600, 1602, 1604, 1606, 1608, 1610, 1612, 1614, + 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630, 1632, 1634, 1636, 1638, + 1640, 1642, 1644, 1646, 1648, 1650, 1652, 1654, 1656, 1658, 1660, 1662, + 1664, 1666, 1668, 1670, 1672, 1674, 1676, 1678, 1680, 1682, 1684, 1686, + 1688, 1690, 1692, 1694, 1696, 1698, 1700, 1702, 1704, 1706, 1708, 1710, + 1712, 1714, 1716, 1718, 1720, 1722, 1724, 1726, 1728, 1730, 1732, 1734, + 1736, 1738, 1740, 1742, 1744, 1746, 1748, 1750, 1752, 1754, 1756, 1758, + 1760, 1762, 1764, 1766, 1768, 1770, 1772, 1774, 1776, 1778, 1780, 1782, + 1784, 1786, 1788, 1790, 1792, 1794, 1796, 1798, 1800, 1802, 1804, 1806, + 1808, 1810, 1812, 1814, 1816, 1818, 1820, 1822, 1824, 1826, 1828, 1830, + 1832, 1834, 1836, 1838, 1840, 1842, 1844, 1846, 1848, 1850, 1852, 1854, + 1856, 1858, 1860, 1862, 1864, 1866, 1868, 1870, 1872, 1874, 1876, 1878, + 1880, 1882, 1884, 1886, 1888, 1890, 1892, 1894, 1896, 1898, 1900, 1902, + 1904, 1906, 1908, 1910, 1912, 1914, 1916, 1918, 1920, 1922, 1924, 1926, + 1928, 1930, 1932, 1934, 1936, 1938, 1940, 1942, 1944, 1946, 1948, 1950, + 1952, 1954, 1956, 1958, 1960, 1962, 1964, 1966, 1968, 1970, 1972, 1974, + 1976, 1978, 1980, 1982, 1984, 1986, 1988, 1990, 1992, 1994, 1996, 1998, + 2000, 2002, 2004, 2006, 2008, 2010, 2012, 2014, 2016, 2018, 2020, 2022, + 2024, 2026, 2028, 2030, 2032, 2034, 2036, 2038, 2040, 2042, 2044, 2046, + 2048, 2050, 2052, 2054, 2056, 2058, 2060, 2062, 2064, 2066, 2068, 2070, + 2072, 2074, 2076, 2078, 2080, 2082, 2084, 2086, 2088, 2090, 2092, 2094, + 2096, 2098, 2100, 2102, 2104, 2106, 2108, 2110, 2112, 2114, 2116, 2118, + 2120, 2122, 2124, 2126, 2128, 2130, 2132, 2134, 2136, 2138, 2140, 2142, + 2144, 2146, 2148, 2150, 2152, 2154, 2156, 2158, 2160, 2162, 2164, 2166, + 2168, 2170, 2172, 2174, 2176, 2178, 2180, 2182, 2184, 2186, 2188, 2190, + 2192, 2194, 2196, 2198, 2200, 2202, 2204, 2206, 2208, 2210, 2212, 2214, + 2216, 2218, 2220, 2222, 2224, 2226, 2228, 2230, 2232, 2234, 2236, 2238, + 2240, 2242, 2244, 2246, 2248, 2250, 2252, 2254, 2256, 2258, 2260, 2262, + 2264, 2266, 2268, 2270, 2272, 2274, 2276, 2278, 2280, 2282, 2284, 2286, + 2288, 2290, 2292, 2294, 2296, 2298, 2300, 2302, 2304, 2306, 2308, 2310, + 2312, 2314, 2316, 2318, 2320, 2322, 2324, 2326, 2328, 2330, 2332, 2334, + 2336, 2338, 2340, 2342, 2344, 2346, 2348, 2350, 2352, 2354, 2356, 2358, + 2360, 2362, 2364, 2366, 2368, 2370, 2372, 2374, 2376, 2378, 2380, 2382, + 2384, 2386, 2388, 2390, 0, 285, 2, 0, 1136, 1136, 2173, 2173, 2, 0, 627, + 627, 831, 831, 2, 0, 2186, 2186, 2188, 2188, 2, 0, 1091, 1091, 1461, 1461, + 2, 0, 20, 20, 909, 909, 5, 0, 421, 421, 618, 618, 892, 892, 1249, 1249, + 2081, 2081, 2, 0, 216, 216, 541, 541, 2, 0, 560, 560, 1027, 1027, 2, 0, + 749, 749, 831, 831, 2, 0, 20, 20, 425, 425, 3, 0, 593, 593, 1222, 1222, + 1235, 1235, 2, 0, 1174, 1174, 2192, 2192, 2, 0, 593, 593, 1235, 1235, 4, + 0, 88, 88, 618, 618, 828, 828, 2281, 2281, 3, 0, 206, 206, 329, 329, 2171, + 2171, 2, 0, 1393, 1393, 1449, 1449, 2, 0, 1098, 1098, 1477, 1477, 2, 0, + 398, 398, 453, 453, 2, 0, 192, 192, 1608, 1608, 2, 0, 2373, 2373, 2379, + 2379, 2, 0, 66, 66, 723, 723, 2, 0, 34, 34, 1300, 1300, 3, 0, 603, 603, + 796, 796, 1399, 1399, 2, 0, 206, 206, 1215, 1215, 2, 0, 1359, 1359, 1377, + 1377, 3, 0, 37, 37, 229, 229, 804, 804, 2, 0, 861, 861, 889, 889, 3, 0, + 138, 138, 1239, 1239, 1610, 1610, 4, 0, 262, 262, 299, 299, 818, 818, 1360, + 1360, 2, 0, 137, 137, 1595, 1595, 2, 0, 32, 32, 106, 106, 3, 0, 376, 376, + 697, 697, 2091, 2091, 3, 0, 950, 950, 1167, 1167, 1246, 1246, 2, 0, 560, + 560, 2136, 2136, 2, 0, 138, 138, 1610, 1610, 3, 0, 20, 20, 425, 425, 909, + 909, 3, 0, 325, 325, 1194, 1194, 1614, 1614, 2, 0, 840, 840, 1215, 1215, + 2, 0, 865, 865, 1638, 1638, 3, 0, 540, 540, 702, 702, 1234, 1234, 3, 0, + 227, 227, 1119, 1119, 1497, 1497, 3, 0, 350, 350, 414, 414, 1388, 1388, + 2, 0, 13, 13, 37, 37, 2, 0, 877, 877, 1054, 1054, 2, 0, 1090, 1090, 1455, + 1455, 2, 0, 1624, 1624, 2001, 2001, 10, 0, 342, 342, 601, 601, 623, 623, + 888, 888, 916, 916, 1386, 1386, 1538, 1538, 1624, 1624, 2176, 2176, 2234, + 2234, 2, 0, 2281, 2281, 2284, 2284, 2, 0, 67, 67, 385, 385, 2, 0, 543, + 543, 762, 762, 3, 0, 700, 700, 1564, 1564, 1636, 1636, 14, 0, 41, 41, 82, + 82, 226, 226, 376, 376, 489, 489, 549, 549, 591, 591, 659, 659, 697, 697, + 812, 812, 1408, 1408, 1460, 1460, 1548, 1548, 2091, 2091, 3, 0, 41, 41, + 301, 301, 425, 425, 3, 0, 489, 489, 1408, 1408, 2192, 2192, 4, 0, 337, + 337, 394, 394, 1169, 1169, 2233, 2233, 3, 0, 84, 84, 578, 578, 624, 624, + 2, 0, 1093, 1093, 1466, 1466, 5, 0, 435, 435, 579, 579, 831, 831, 1238, + 1238, 1970, 1970, 3, 0, 341, 341, 914, 914, 2235, 2235, 6, 0, 381, 381, + 614, 614, 724, 724, 782, 782, 866, 869, 1247, 1248, 2, 0, 129, 129, 2068, + 2068, 2, 0, 2087, 2087, 2099, 2099, 2, 0, 721, 721, 2170, 2170, 2, 0, 912, + 912, 1048, 1048, 2, 0, 20, 20, 1459, 1459, 2, 0, 508, 508, 587, 587, 2, + 0, 363, 363, 1984, 1984, 2, 0, 812, 812, 2072, 2072, 2, 0, 20, 20, 2091, + 2091, 2, 0, 1160, 1160, 1173, 1173, 2, 0, 1842, 1842, 2121, 2121, 2, 0, + 151, 151, 481, 481, 2, 0, 4, 4, 1564, 1564, 2, 0, 37, 37, 315, 315, 2, + 0, 1528, 1528, 1997, 1997, 2, 0, 659, 659, 1976, 1976, 2, 0, 25, 25, 374, + 374, 2, 0, 1471, 1471, 1608, 1608, 3, 0, 576, 576, 1239, 1239, 1365, 1365, + 3, 0, 192, 192, 1471, 1471, 1608, 1608, 2, 0, 233, 233, 1469, 1469, 3, + 0, 113, 113, 133, 133, 201, 201, 2, 0, 437, 437, 1053, 1053, 2, 0, 168, + 168, 1479, 1479, 2, 0, 320, 320, 371, 371, 2, 0, 272, 272, 274, 274, 2, + 0, 629, 629, 632, 632, 2, 0, 368, 368, 640, 640, 2, 0, 1132, 1132, 2136, + 2136, 2, 0, 802, 802, 1974, 1974, 2, 0, 331, 331, 1982, 1982, 3, 0, 640, + 640, 1098, 1098, 1984, 1984, 2, 0, 1161, 1161, 1175, 1175, 2, 0, 115, 115, + 1600, 1600, 3, 0, 538, 538, 815, 815, 1040, 1040, 2, 0, 88, 88, 839, 839, + 2, 0, 599, 599, 1031, 1031, 2, 0, 618, 618, 828, 828, 2, 0, 574, 574, 1252, + 1252, 2, 0, 227, 227, 378, 378, 2, 0, 461, 461, 2048, 2048, 2, 0, 76, 76, + 1687, 1687, 2, 0, 487, 487, 647, 647, 2, 0, 155, 155, 993, 993, 3, 0, 233, + 233, 525, 525, 560, 560, 3, 0, 234, 234, 525, 525, 560, 560, 2, 0, 804, + 804, 842, 842, 2, 0, 1100, 1100, 1500, 1500, 6, 0, 240, 240, 262, 262, + 298, 299, 633, 633, 817, 818, 1565, 1565, 3, 0, 363, 363, 2070, 2070, 2370, + 2370, 4, 0, 518, 518, 644, 644, 1261, 1263, 1265, 1266, 2, 0, 586, 586, + 1359, 1359, 2, 0, 376, 376, 1351, 1351, 2, 0, 101, 101, 1541, 1541, 2, + 0, 425, 425, 1351, 1351, 2, 0, 711, 711, 794, 794, 2, 0, 1057, 1057, 2236, + 2236, 6, 0, 435, 435, 579, 579, 749, 749, 831, 831, 1238, 1238, 1970, 1970, + 2, 0, 62, 62, 1388, 1388, 2, 0, 165, 165, 1388, 1388, 5, 0, 306, 306, 618, + 618, 828, 828, 864, 864, 1054, 1054, 2, 0, 2070, 2070, 2370, 2370, 3, 0, + 363, 363, 751, 751, 1420, 1420, 3, 0, 363, 363, 751, 751, 1054, 1054, 3, + 0, 376, 376, 398, 398, 453, 453, 2, 0, 222, 222, 1507, 1507, 2, 0, 4, 4, + 907, 907, 2, 0, 593, 593, 1546, 1546, 4, 0, 341, 342, 914, 914, 916, 916, + 2234, 2235, 1, 0, 2255, 2258, 2, 0, 2144, 2144, 2316, 2316, 2, 0, 2367, + 2367, 2372, 2373, 2, 0, 760, 760, 2320, 2320, 1, 0, 2321, 2322, 2, 0, 186, + 186, 2325, 2325, 1, 0, 2328, 2329, 2, 0, 1597, 1597, 2332, 2332, 1, 0, + 2336, 2337, 1, 0, 2338, 2339, 2, 0, 1144, 1144, 2353, 2353, 1, 0, 2380, + 2381, 2, 0, 2381, 2381, 2395, 2395, 2, 0, 355, 355, 2358, 2358, 2, 0, 2143, + 2143, 2362, 2364, 2, 0, 1144, 1144, 2301, 2301, 3, 0, 830, 830, 1510, 1510, + 2306, 2308, 2, 0, 339, 339, 1997, 1997, 2, 0, 882, 882, 1044, 1044, 2, + 0, 425, 425, 751, 751, 2, 0, 48, 48, 751, 751, 2, 0, 39, 39, 402, 402, + 3, 0, 233, 233, 437, 437, 1053, 1053, 2, 0, 425, 425, 1488, 1488, 2, 0, + 202, 202, 1628, 1628, 2, 0, 422, 422, 2095, 2095, 2, 0, 107, 107, 459, + 459, 2, 0, 816, 816, 1298, 1298, 3, 0, 94, 94, 1291, 1291, 1373, 1373, + 2, 0, 227, 227, 1346, 1346, 2, 0, 1, 1, 1654, 1654, 2, 0, 1298, 1298, 1602, + 1602, 3, 0, 37, 37, 1054, 1054, 1628, 1628, 3, 0, 618, 618, 892, 892, 2081, + 2081, 4, 0, 398, 398, 453, 453, 1459, 1459, 1683, 1683, 2, 0, 522, 522, + 2045, 2045, 2, 0, 1459, 1459, 1568, 1568, 2, 0, 1690, 1690, 1842, 1842, + 2, 0, 851, 851, 854, 854, 1, 0, 855, 857, 2, 0, 37, 37, 770, 770, 2, 0, + 457, 457, 1451, 1451, 3, 0, 361, 361, 457, 457, 1451, 1451, 2, 0, 1408, + 1408, 2192, 2192, 2, 0, 1256, 1256, 1258, 1258, 1, 0, 1667, 1668, 2, 0, + 363, 363, 560, 560, 2, 0, 720, 720, 2091, 2091, 2, 0, 1106, 1106, 1604, + 1604, 2, 0, 808, 808, 2141, 2141, 2, 0, 570, 570, 1281, 1281, 2, 0, 362, + 362, 750, 750, 3, 0, 618, 618, 828, 828, 864, 864, 2, 0, 315, 315, 1145, + 1145, 2, 0, 586, 586, 804, 804, 4, 0, 680, 680, 692, 692, 1006, 1006, 1229, + 1229, 2, 0, 363, 363, 2385, 2385, 1, 1, 2396, 2396, 1, 0, 2396, 2396, 1, + 0, 1486, 1487, 1, 0, 267, 268, 2, 0, 102, 102, 640, 640, 2, 0, 143, 143, + 381, 381, 3, 0, 37, 37, 410, 410, 2068, 2068, 2, 0, 307, 307, 933, 933, + 3, 0, 574, 574, 774, 774, 1493, 1493, 3, 0, 1528, 1528, 1602, 1602, 1997, + 1997, 2, 0, 486, 486, 645, 645, 2, 0, 311, 311, 1499, 1499, 2, 0, 635, + 635, 751, 751, 2, 0, 37, 37, 2090, 2090, 2, 0, 91, 91, 1555, 1555, 1, 0, + 1507, 1508, 2, 0, 543, 543, 953, 953, 2, 0, 37, 37, 543, 543, 2, 0, 1976, + 1976, 1990, 1990, 2, 0, 765, 765, 1659, 1659, 2, 0, 865, 865, 1665, 1665, + 2, 0, 788, 790, 792, 792, 1, 0, 2393, 2394, 2, 0, 470, 470, 2046, 2046, + 2, 0, 2379, 2379, 2383, 2383, 4, 0, 341, 341, 914, 914, 1537, 1537, 2235, + 2235, 2, 0, 360, 360, 649, 649, 4, 0, 37, 37, 53, 53, 492, 492, 1603, 1603, + 3, 0, 140, 140, 773, 773, 2034, 2034, 2, 0, 3, 3, 1145, 1145, 2, 0, 154, + 154, 182, 182, 2, 0, 65, 65, 1155, 1155, 2, 0, 723, 723, 2141, 2141, 2, + 0, 470, 470, 1145, 1145, 2, 0, 451, 451, 1145, 1145, 2, 0, 470, 470, 635, + 635, 3, 0, 470, 470, 635, 635, 1463, 1463, 4, 0, 470, 470, 635, 635, 1145, + 1145, 1459, 1459, 3, 0, 301, 301, 470, 470, 635, 635, 3, 0, 470, 470, 635, + 635, 1145, 1145, 2, 0, 246, 246, 2062, 2062, 2, 0, 37, 37, 410, 410, 2, + 0, 170, 170, 2200, 2200, 2, 0, 410, 410, 2068, 2068, 2, 0, 1283, 1285, + 1288, 1288, 2, 0, 164, 164, 232, 232, 2, 0, 546, 546, 763, 763, 3, 0, 2013, + 2014, 2022, 2022, 2025, 2026, 2, 0, 2017, 2017, 2030, 2030, 2, 0, 183, + 183, 936, 936, 2, 0, 2202, 2202, 2210, 2210, 2, 0, 465, 465, 1020, 1020, + 2, 0, 476, 476, 926, 926, 2, 0, 275, 275, 417, 417, 2, 0, 613, 613, 1579, + 1579, 6, 0, 2273, 2275, 2277, 2282, 2284, 2285, 2287, 2288, 2290, 2290, + 2294, 2297, 2, 0, 2266, 2267, 2269, 2272, 1, 0, 2240, 2245, 2, 0, 1399, + 1399, 1508, 1508, 2, 0, 557, 557, 1341, 1341, 2, 0, 1101, 1101, 1525, 1525, + 2, 0, 468, 468, 472, 472, 2, 0, 1221, 1221, 1615, 1615, 2, 0, 227, 227, + 1497, 1497, 3, 0, 227, 227, 1054, 1054, 1497, 1497, 2, 0, 1256, 1256, 1668, + 1668, 3, 0, 37, 37, 53, 53, 1603, 1603, 2, 0, 635, 635, 1472, 1472, 1, + 0, 1289, 1290, 2, 0, 341, 341, 2235, 2235, 2, 0, 914, 914, 1537, 1537, + 2, 0, 41, 41, 425, 425, 2, 0, 301, 301, 425, 425, 2, 0, 41, 41, 301, 301, + 3, 0, 41, 41, 425, 425, 489, 489, 2, 0, 53, 53, 507, 507, 2, 0, 192, 192, + 1368, 1368, 4, 0, 41, 41, 226, 226, 425, 425, 1548, 1548, 4, 0, 41, 41, + 425, 425, 1548, 1548, 2091, 2091, 3, 0, 376, 376, 425, 425, 697, 697, 6, + 0, 41, 41, 376, 376, 425, 425, 697, 697, 1548, 1548, 2091, 2091, 2, 0, + 425, 425, 2091, 2091, 3, 0, 41, 41, 425, 425, 591, 591, 3, 0, 41, 41, 425, + 425, 1548, 1548, 3, 0, 41, 41, 301, 301, 1477, 1477, 3, 0, 41, 41, 425, + 425, 2125, 2125, 10, 0, 41, 41, 98, 98, 226, 226, 376, 376, 425, 425, 697, + 697, 812, 812, 1408, 1408, 1548, 1548, 2091, 2091, 5, 0, 41, 41, 301, 301, + 425, 425, 835, 835, 2070, 2070, 4, 0, 41, 41, 425, 425, 489, 489, 2063, + 2063, 3, 0, 425, 425, 875, 875, 2063, 2063, 2, 0, 45, 45, 82, 82, 2, 0, + 391, 391, 2035, 2035, 6, 0, 341, 341, 622, 622, 887, 887, 914, 914, 1537, + 1537, 2235, 2235, 1, 0, 2370, 2371, 2, 0, 2365, 2365, 2372, 2372, 254, + 0, 7, 7, 9, 11, 13, 13, 15, 15, 18, 19, 28, 28, 31, 31, 42, 42, 44, 44, + 46, 46, 50, 51, 58, 58, 60, 61, 63, 63, 71, 71, 73, 73, 90, 90, 93, 93, + 95, 96, 99, 99, 103, 104, 108, 108, 111, 111, 128, 128, 145, 145, 159, + 161, 165, 166, 173, 173, 193, 197, 200, 200, 207, 208, 210, 210, 229, 230, + 236, 237, 245, 247, 250, 252, 271, 274, 280, 280, 282, 284, 302, 302, 305, + 306, 310, 310, 313, 313, 333, 333, 335, 335, 337, 338, 342, 342, 348, 348, + 358, 358, 365, 366, 370, 370, 374, 375, 386, 387, 393, 393, 397, 397, 399, + 399, 404, 404, 413, 413, 430, 431, 437, 437, 442, 442, 448, 448, 452, 452, + 454, 454, 467, 467, 475, 475, 477, 477, 491, 491, 503, 503, 509, 509, 515, + 515, 520, 521, 523, 524, 526, 526, 528, 529, 533, 533, 535, 536, 547, 547, + 553, 553, 565, 565, 578, 578, 580, 580, 585, 585, 601, 601, 614, 615, 623, + 624, 627, 627, 639, 639, 643, 644, 660, 660, 679, 679, 688, 688, 690, 690, + 693, 693, 711, 711, 724, 724, 732, 746, 748, 748, 757, 757, 759, 759, 765, + 765, 771, 772, 782, 782, 785, 785, 794, 794, 809, 809, 811, 811, 820, 820, + 826, 826, 838, 838, 840, 840, 844, 847, 858, 858, 866, 870, 877, 877, 888, + 888, 901, 901, 905, 905, 907, 907, 911, 911, 916, 916, 922, 922, 941, 941, + 983, 984, 988, 988, 990, 990, 997, 997, 999, 999, 1006, 1006, 1011, 1012, + 1016, 1016, 1029, 1029, 1035, 1037, 1053, 1053, 1059, 1059, 1070, 1072, + 1075, 1075, 1077, 1079, 1084, 1084, 1089, 1089, 1092, 1092, 1099, 1099, + 1107, 1107, 1124, 1124, 1131, 1131, 1133, 1135, 1142, 1142, 1156, 1156, + 1162, 1162, 1169, 1169, 1171, 1172, 1191, 1193, 1202, 1207, 1212, 1212, + 1247, 1248, 1250, 1250, 1252, 1253, 1267, 1267, 1269, 1270, 1272, 1272, + 1274, 1274, 1292, 1292, 1295, 1296, 1315, 1315, 1319, 1323, 1330, 1330, + 1332, 1333, 1336, 1337, 1345, 1345, 1352, 1352, 1354, 1354, 1356, 1357, + 1361, 1361, 1371, 1371, 1374, 1376, 1382, 1382, 1386, 1386, 1395, 1395, + 1410, 1410, 1422, 1422, 1454, 1454, 1457, 1457, 1473, 1473, 1495, 1495, + 1501, 1501, 1513, 1513, 1518, 1518, 1530, 1530, 1533, 1533, 1538, 1539, + 1558, 1558, 1560, 1560, 1562, 1562, 1577, 1578, 1584, 1584, 1606, 1607, + 1620, 1620, 1624, 1625, 1627, 1627, 1636, 1637, 1658, 1658, 1671, 1672, + 1680, 1680, 1690, 1690, 1694, 1694, 1696, 1696, 1702, 1702, 1720, 1720, + 1725, 1726, 1730, 1731, 1753, 1753, 1765, 1765, 1768, 1772, 1797, 1797, + 1825, 1825, 1836, 1836, 1967, 1969, 1978, 1978, 1987, 1987, 1993, 1994, + 2012, 2012, 2036, 2036, 2041, 2041, 2049, 2049, 2057, 2057, 2062, 2062, + 2073, 2073, 2080, 2080, 2085, 2085, 2099, 2099, 2103, 2103, 2107, 2107, + 2114, 2114, 2120, 2120, 2126, 2126, 2128, 2128, 2130, 2135, 2137, 2137, + 2139, 2139, 2152, 2155, 2167, 2167, 2169, 2169, 2176, 2177, 2187, 2187, + 2191, 2191, 2233, 2234, 2238, 2238, 2246, 2258, 2260, 2260, 2262, 2262, + 2264, 2265, 2283, 2283, 2301, 2364, 2369, 2369, 340, 0, 1, 2, 4, 6, 8, + 8, 12, 12, 14, 14, 16, 17, 20, 27, 29, 30, 32, 32, 36, 36, 38, 40, 43, + 43, 45, 45, 47, 47, 49, 49, 52, 52, 54, 57, 59, 59, 62, 62, 64, 65, 68, + 70, 72, 72, 74, 81, 83, 89, 91, 91, 94, 94, 98, 98, 100, 102, 105, 107, + 109, 110, 113, 122, 124, 127, 129, 138, 140, 144, 146, 150, 152, 158, 162, + 163, 167, 170, 172, 172, 174, 181, 183, 185, 187, 192, 198, 198, 201, 205, + 209, 209, 211, 228, 231, 235, 238, 241, 243, 244, 248, 249, 253, 260, 262, + 268, 270, 270, 275, 279, 281, 281, 285, 300, 303, 304, 307, 309, 311, 312, + 314, 324, 326, 332, 334, 334, 336, 336, 340, 341, 343, 347, 349, 354, 357, + 357, 359, 362, 364, 364, 367, 369, 371, 373, 377, 384, 388, 389, 391, 392, + 394, 396, 398, 398, 400, 403, 405, 409, 411, 412, 414, 424, 426, 426, 428, + 429, 432, 434, 436, 436, 438, 441, 443, 445, 449, 451, 453, 453, 455, 458, + 460, 466, 469, 474, 476, 476, 478, 481, 484, 487, 489, 490, 493, 493, 495, + 502, 504, 508, 510, 514, 516, 519, 522, 522, 525, 525, 527, 527, 530, 532, + 534, 534, 538, 546, 548, 550, 552, 552, 554, 558, 560, 563, 566, 571, 573, + 577, 581, 584, 586, 589, 592, 592, 594, 600, 602, 605, 607, 613, 617, 622, + 625, 626, 629, 638, 640, 642, 645, 658, 661, 675, 677, 678, 681, 687, 689, + 689, 691, 691, 694, 696, 698, 709, 712, 715, 717, 718, 720, 722, 725, 731, + 750, 756, 758, 758, 761, 764, 766, 770, 773, 781, 783, 784, 786, 791, 793, + 793, 795, 808, 810, 810, 813, 819, 821, 823, 827, 830, 832, 837, 839, 839, + 841, 843, 848, 857, 859, 865, 871, 876, 878, 884, 886, 887, 889, 892, 895, + 900, 902, 904, 908, 910, 912, 915, 917, 918, 920, 921, 923, 933, 935, 940, + 942, 982, 985, 987, 989, 989, 991, 996, 998, 998, 1001, 1005, 1007, 1010, + 1013, 1015, 1017, 1028, 1030, 1034, 1038, 1052, 1054, 1058, 1060, 1069, + 1073, 1074, 1076, 1076, 1080, 1083, 1085, 1088, 1090, 1091, 1093, 1098, + 1100, 1106, 1108, 1120, 1122, 1123, 1125, 1130, 1132, 1132, 1137, 1141, + 1143, 1144, 1146, 1146, 1148, 1155, 1157, 1161, 1164, 1168, 1170, 1170, + 1173, 1174, 1176, 1187, 1189, 1190, 1195, 1201, 1208, 1211, 1213, 1214, + 1216, 1218, 1220, 1220, 1222, 1228, 1230, 1233, 1235, 1237, 1239, 1240, + 1242, 1246, 1249, 1249, 1251, 1251, 1254, 1266, 1268, 1268, 1271, 1271, + 1273, 1273, 1275, 1276, 1278, 1282, 1286, 1287, 1291, 1291, 1293, 1294, + 1297, 1299, 1302, 1308, 1310, 1314, 1317, 1318, 1326, 1329, 1331, 1331, + 1334, 1335, 1339, 1344, 1346, 1351, 1353, 1353, 1355, 1355, 1359, 1360, + 1362, 1370, 1372, 1373, 1378, 1381, 1383, 1385, 1387, 1394, 1397, 1401, + 1403, 1409, 1411, 1413, 1415, 1421, 1423, 1452, 1455, 1456, 1458, 1459, + 1461, 1470, 1472, 1472, 1474, 1477, 1479, 1480, 1482, 1489, 1491, 1494, + 1496, 1500, 1502, 1512, 1514, 1517, 1519, 1529, 1531, 1532, 1535, 1537, + 1540, 1547, 1550, 1556, 1559, 1559, 1561, 1561, 1563, 1567, 1569, 1572, + 1574, 1575, 1579, 1583, 1585, 1587, 1590, 1594, 1596, 1600, 1602, 1605, + 1608, 1613, 1616, 1619, 1621, 1623, 1626, 1626, 1628, 1630, 1632, 1635, + 1638, 1657, 1659, 1670, 1673, 1677, 1679, 1679, 1681, 1688, 1690, 1693, + 1695, 1695, 1697, 1701, 1703, 1719, 1721, 1724, 1727, 1729, 1732, 1752, + 1754, 1764, 1766, 1767, 1773, 1796, 1798, 1824, 1826, 1835, 1837, 1966, + 1971, 1977, 1979, 1986, 1988, 1992, 1995, 1995, 1997, 1997, 2000, 2001, + 2003, 2011, 2013, 2028, 2030, 2035, 2037, 2040, 2042, 2043, 2045, 2048, + 2050, 2056, 2058, 2061, 2063, 2066, 2069, 2072, 2074, 2079, 2081, 2084, + 2086, 2090, 2092, 2098, 2100, 2102, 2104, 2106, 2108, 2113, 2115, 2119, + 2121, 2125, 2127, 2127, 2129, 2129, 2136, 2136, 2138, 2138, 2141, 2141, + 2145, 2151, 2156, 2165, 2168, 2168, 2170, 2174, 2178, 2180, 2183, 2186, + 2189, 2190, 2192, 2193, 2195, 2197, 2199, 2210, 2212, 2232, 2235, 2236, + 2239, 2245, 2263, 2263, 2266, 2274, 2277, 2277, 2280, 2287, 2289, 2295, + 2297, 2300, 3, 0, 190, 190, 2276, 2276, 2291, 2293, 5, 0, 294, 294, 2273, + 2273, 2286, 2286, 2289, 2289, 2294, 2294, 23331, 0, 2402, 1, 0, 0, 0, 2, + 2546, 1, 0, 0, 0, 4, 2548, 1, 0, 0, 0, 6, 2605, 1, 0, 0, 0, 8, 2630, 1, + 0, 0, 0, 10, 2671, 1, 0, 0, 0, 12, 2677, 1, 0, 0, 0, 14, 2704, 1, 0, 0, + 0, 16, 2706, 1, 0, 0, 0, 18, 2725, 1, 0, 0, 0, 20, 2766, 1, 0, 0, 0, 22, + 2798, 1, 0, 0, 0, 24, 2803, 1, 0, 0, 0, 26, 2825, 1, 0, 0, 0, 28, 2827, + 1, 0, 0, 0, 30, 2857, 1, 0, 0, 0, 32, 2859, 1, 0, 0, 0, 34, 2869, 1, 0, + 0, 0, 36, 2871, 1, 0, 0, 0, 38, 2873, 1, 0, 0, 0, 40, 2916, 1, 0, 0, 0, + 42, 2918, 1, 0, 0, 0, 44, 2958, 1, 0, 0, 0, 46, 2971, 1, 0, 0, 0, 48, 2973, + 1, 0, 0, 0, 50, 2991, 1, 0, 0, 0, 52, 3002, 1, 0, 0, 0, 54, 3008, 1, 0, + 0, 0, 56, 3027, 1, 0, 0, 0, 58, 3029, 1, 0, 0, 0, 60, 3039, 1, 0, 0, 0, + 62, 3073, 1, 0, 0, 0, 64, 3112, 1, 0, 0, 0, 66, 3114, 1, 0, 0, 0, 68, 3146, + 1, 0, 0, 0, 70, 3170, 1, 0, 0, 0, 72, 3220, 1, 0, 0, 0, 74, 3222, 1, 0, + 0, 0, 76, 3224, 1, 0, 0, 0, 78, 3230, 1, 0, 0, 0, 80, 3232, 1, 0, 0, 0, + 82, 3251, 1, 0, 0, 0, 84, 3259, 1, 0, 0, 0, 86, 3266, 1, 0, 0, 0, 88, 3272, + 1, 0, 0, 0, 90, 3274, 1, 0, 0, 0, 92, 3288, 1, 0, 0, 0, 94, 3290, 1, 0, + 0, 0, 96, 3303, 1, 0, 0, 0, 98, 3308, 1, 0, 0, 0, 100, 3343, 1, 0, 0, 0, + 102, 3357, 1, 0, 0, 0, 104, 3376, 1, 0, 0, 0, 106, 3411, 1, 0, 0, 0, 108, + 3413, 1, 0, 0, 0, 110, 3466, 1, 0, 0, 0, 112, 3474, 1, 0, 0, 0, 114, 3478, + 1, 0, 0, 0, 116, 3492, 1, 0, 0, 0, 118, 3496, 1, 0, 0, 0, 120, 3508, 1, + 0, 0, 0, 122, 3513, 1, 0, 0, 0, 124, 3534, 1, 0, 0, 0, 126, 3536, 1, 0, + 0, 0, 128, 3550, 1, 0, 0, 0, 130, 3568, 1, 0, 0, 0, 132, 3586, 1, 0, 0, + 0, 134, 3609, 1, 0, 0, 0, 136, 3631, 1, 0, 0, 0, 138, 3666, 1, 0, 0, 0, + 140, 3668, 1, 0, 0, 0, 142, 3676, 1, 0, 0, 0, 144, 3678, 1, 0, 0, 0, 146, + 3683, 1, 0, 0, 0, 148, 3696, 1, 0, 0, 0, 150, 3718, 1, 0, 0, 0, 152, 3746, + 1, 0, 0, 0, 154, 3784, 1, 0, 0, 0, 156, 3786, 1, 0, 0, 0, 158, 3803, 1, + 0, 0, 0, 160, 3840, 1, 0, 0, 0, 162, 3842, 1, 0, 0, 0, 164, 3864, 1, 0, + 0, 0, 166, 3878, 1, 0, 0, 0, 168, 3883, 1, 0, 0, 0, 170, 3902, 1, 0, 0, + 0, 172, 3952, 1, 0, 0, 0, 174, 3981, 1, 0, 0, 0, 176, 4018, 1, 0, 0, 0, + 178, 4027, 1, 0, 0, 0, 180, 4031, 1, 0, 0, 0, 182, 4045, 1, 0, 0, 0, 184, + 4055, 1, 0, 0, 0, 186, 4060, 1, 0, 0, 0, 188, 4065, 1, 0, 0, 0, 190, 4084, + 1, 0, 0, 0, 192, 4086, 1, 0, 0, 0, 194, 4088, 1, 0, 0, 0, 196, 4103, 1, + 0, 0, 0, 198, 4108, 1, 0, 0, 0, 200, 4133, 1, 0, 0, 0, 202, 4157, 1, 0, + 0, 0, 204, 4166, 1, 0, 0, 0, 206, 4175, 1, 0, 0, 0, 208, 4184, 1, 0, 0, + 0, 210, 4188, 1, 0, 0, 0, 212, 4193, 1, 0, 0, 0, 214, 4217, 1, 0, 0, 0, + 216, 4219, 1, 0, 0, 0, 218, 4223, 1, 0, 0, 0, 220, 4272, 1, 0, 0, 0, 222, + 4300, 1, 0, 0, 0, 224, 4302, 1, 0, 0, 0, 226, 4316, 1, 0, 0, 0, 228, 4321, + 1, 0, 0, 0, 230, 4326, 1, 0, 0, 0, 232, 4332, 1, 0, 0, 0, 234, 4335, 1, + 0, 0, 0, 236, 4346, 1, 0, 0, 0, 238, 4362, 1, 0, 0, 0, 240, 4379, 1, 0, + 0, 0, 242, 4396, 1, 0, 0, 0, 244, 4404, 1, 0, 0, 0, 246, 4409, 1, 0, 0, + 0, 248, 4425, 1, 0, 0, 0, 250, 4429, 1, 0, 0, 0, 252, 4453, 1, 0, 0, 0, + 254, 4456, 1, 0, 0, 0, 256, 4462, 1, 0, 0, 0, 258, 4474, 1, 0, 0, 0, 260, + 4486, 1, 0, 0, 0, 262, 4514, 1, 0, 0, 0, 264, 4520, 1, 0, 0, 0, 266, 4523, + 1, 0, 0, 0, 268, 4530, 1, 0, 0, 0, 270, 4538, 1, 0, 0, 0, 272, 4551, 1, + 0, 0, 0, 274, 4553, 1, 0, 0, 0, 276, 4557, 1, 0, 0, 0, 278, 4563, 1, 0, + 0, 0, 280, 4588, 1, 0, 0, 0, 282, 4619, 1, 0, 0, 0, 284, 4664, 1, 0, 0, + 0, 286, 4674, 1, 0, 0, 0, 288, 4676, 1, 0, 0, 0, 290, 4681, 1, 0, 0, 0, + 292, 4695, 1, 0, 0, 0, 294, 4697, 1, 0, 0, 0, 296, 4702, 1, 0, 0, 0, 298, + 4706, 1, 0, 0, 0, 300, 4744, 1, 0, 0, 0, 302, 4760, 1, 0, 0, 0, 304, 4793, + 1, 0, 0, 0, 306, 4828, 1, 0, 0, 0, 308, 4832, 1, 0, 0, 0, 310, 4847, 1, + 0, 0, 0, 312, 4849, 1, 0, 0, 0, 314, 4852, 1, 0, 0, 0, 316, 4857, 1, 0, + 0, 0, 318, 4867, 1, 0, 0, 0, 320, 4930, 1, 0, 0, 0, 322, 4932, 1, 0, 0, + 0, 324, 4960, 1, 0, 0, 0, 326, 4962, 1, 0, 0, 0, 328, 4966, 1, 0, 0, 0, + 330, 5039, 1, 0, 0, 0, 332, 5041, 1, 0, 0, 0, 334, 5044, 1, 0, 0, 0, 336, + 5047, 1, 0, 0, 0, 338, 5059, 1, 0, 0, 0, 340, 5061, 1, 0, 0, 0, 342, 5077, + 1, 0, 0, 0, 344, 5090, 1, 0, 0, 0, 346, 5156, 1, 0, 0, 0, 348, 5168, 1, + 0, 0, 0, 350, 5180, 1, 0, 0, 0, 352, 5192, 1, 0, 0, 0, 354, 5197, 1, 0, + 0, 0, 356, 5202, 1, 0, 0, 0, 358, 5206, 1, 0, 0, 0, 360, 5211, 1, 0, 0, + 0, 362, 5215, 1, 0, 0, 0, 364, 5220, 1, 0, 0, 0, 366, 5229, 1, 0, 0, 0, + 368, 5252, 1, 0, 0, 0, 370, 5265, 1, 0, 0, 0, 372, 5290, 1, 0, 0, 0, 374, + 5292, 1, 0, 0, 0, 376, 5311, 1, 0, 0, 0, 378, 5317, 1, 0, 0, 0, 380, 5359, + 1, 0, 0, 0, 382, 5377, 1, 0, 0, 0, 384, 5389, 1, 0, 0, 0, 386, 5395, 1, + 0, 0, 0, 388, 5406, 1, 0, 0, 0, 390, 5417, 1, 0, 0, 0, 392, 5432, 1, 0, + 0, 0, 394, 5447, 1, 0, 0, 0, 396, 5518, 1, 0, 0, 0, 398, 5533, 1, 0, 0, + 0, 400, 5536, 1, 0, 0, 0, 402, 5544, 1, 0, 0, 0, 404, 5564, 1, 0, 0, 0, + 406, 5592, 1, 0, 0, 0, 408, 5603, 1, 0, 0, 0, 410, 5607, 1, 0, 0, 0, 412, + 5639, 1, 0, 0, 0, 414, 5641, 1, 0, 0, 0, 416, 5650, 1, 0, 0, 0, 418, 5652, + 1, 0, 0, 0, 420, 5682, 1, 0, 0, 0, 422, 5684, 1, 0, 0, 0, 424, 5693, 1, + 0, 0, 0, 426, 5751, 1, 0, 0, 0, 428, 5753, 1, 0, 0, 0, 430, 5774, 1, 0, + 0, 0, 432, 5780, 1, 0, 0, 0, 434, 5782, 1, 0, 0, 0, 436, 5834, 1, 0, 0, + 0, 438, 5846, 1, 0, 0, 0, 440, 5855, 1, 0, 0, 0, 442, 5876, 1, 0, 0, 0, + 444, 5880, 1, 0, 0, 0, 446, 5884, 1, 0, 0, 0, 448, 5918, 1, 0, 0, 0, 450, + 5926, 1, 0, 0, 0, 452, 5938, 1, 0, 0, 0, 454, 5944, 1, 0, 0, 0, 456, 5951, + 1, 0, 0, 0, 458, 5953, 1, 0, 0, 0, 460, 5970, 1, 0, 0, 0, 462, 5978, 1, + 0, 0, 0, 464, 5982, 1, 0, 0, 0, 466, 5999, 1, 0, 0, 0, 468, 6043, 1, 0, + 0, 0, 470, 6049, 1, 0, 0, 0, 472, 6064, 1, 0, 0, 0, 474, 6066, 1, 0, 0, + 0, 476, 6080, 1, 0, 0, 0, 478, 6112, 1, 0, 0, 0, 480, 6121, 1, 0, 0, 0, + 482, 6137, 1, 0, 0, 0, 484, 6181, 1, 0, 0, 0, 486, 6201, 1, 0, 0, 0, 488, + 6208, 1, 0, 0, 0, 490, 6219, 1, 0, 0, 0, 492, 6230, 1, 0, 0, 0, 494, 6268, + 1, 0, 0, 0, 496, 6270, 1, 0, 0, 0, 498, 6297, 1, 0, 0, 0, 500, 6310, 1, + 0, 0, 0, 502, 6349, 1, 0, 0, 0, 504, 6351, 1, 0, 0, 0, 506, 6365, 1, 0, + 0, 0, 508, 6370, 1, 0, 0, 0, 510, 6374, 1, 0, 0, 0, 512, 6389, 1, 0, 0, + 0, 514, 6414, 1, 0, 0, 0, 516, 6416, 1, 0, 0, 0, 518, 6418, 1, 0, 0, 0, + 520, 6420, 1, 0, 0, 0, 522, 6454, 1, 0, 0, 0, 524, 6456, 1, 0, 0, 0, 526, + 6473, 1, 0, 0, 0, 528, 6488, 1, 0, 0, 0, 530, 6493, 1, 0, 0, 0, 532, 6518, + 1, 0, 0, 0, 534, 6520, 1, 0, 0, 0, 536, 6530, 1, 0, 0, 0, 538, 6534, 1, + 0, 0, 0, 540, 6560, 1, 0, 0, 0, 542, 6580, 1, 0, 0, 0, 544, 6588, 1, 0, + 0, 0, 546, 6590, 1, 0, 0, 0, 548, 6592, 1, 0, 0, 0, 550, 6594, 1, 0, 0, + 0, 552, 6617, 1, 0, 0, 0, 554, 6666, 1, 0, 0, 0, 556, 6668, 1, 0, 0, 0, + 558, 6674, 1, 0, 0, 0, 560, 6679, 1, 0, 0, 0, 562, 6683, 1, 0, 0, 0, 564, + 6689, 1, 0, 0, 0, 566, 6693, 1, 0, 0, 0, 568, 6701, 1, 0, 0, 0, 570, 6727, + 1, 0, 0, 0, 572, 6729, 1, 0, 0, 0, 574, 6735, 1, 0, 0, 0, 576, 6738, 1, + 0, 0, 0, 578, 6741, 1, 0, 0, 0, 580, 6744, 1, 0, 0, 0, 582, 6798, 1, 0, + 0, 0, 584, 6800, 1, 0, 0, 0, 586, 6811, 1, 0, 0, 0, 588, 6819, 1, 0, 0, + 0, 590, 6830, 1, 0, 0, 0, 592, 6832, 1, 0, 0, 0, 594, 6852, 1, 0, 0, 0, + 596, 6854, 1, 0, 0, 0, 598, 6871, 1, 0, 0, 0, 600, 6881, 1, 0, 0, 0, 602, + 6884, 1, 0, 0, 0, 604, 6893, 1, 0, 0, 0, 606, 6907, 1, 0, 0, 0, 608, 6921, + 1, 0, 0, 0, 610, 6939, 1, 0, 0, 0, 612, 6954, 1, 0, 0, 0, 614, 6971, 1, + 0, 0, 0, 616, 6995, 1, 0, 0, 0, 618, 6997, 1, 0, 0, 0, 620, 7026, 1, 0, + 0, 0, 622, 7055, 1, 0, 0, 0, 624, 7057, 1, 0, 0, 0, 626, 7059, 1, 0, 0, + 0, 628, 7075, 1, 0, 0, 0, 630, 7087, 1, 0, 0, 0, 632, 7120, 1, 0, 0, 0, + 634, 7137, 1, 0, 0, 0, 636, 7154, 1, 0, 0, 0, 638, 7170, 1, 0, 0, 0, 640, + 7209, 1, 0, 0, 0, 642, 7216, 1, 0, 0, 0, 644, 7220, 1, 0, 0, 0, 646, 7228, + 1, 0, 0, 0, 648, 7230, 1, 0, 0, 0, 650, 7248, 1, 0, 0, 0, 652, 7260, 1, + 0, 0, 0, 654, 7277, 1, 0, 0, 0, 656, 7292, 1, 0, 0, 0, 658, 7302, 1, 0, + 0, 0, 660, 7308, 1, 0, 0, 0, 662, 7312, 1, 0, 0, 0, 664, 7314, 1, 0, 0, + 0, 666, 7316, 1, 0, 0, 0, 668, 7331, 1, 0, 0, 0, 670, 7387, 1, 0, 0, 0, + 672, 7418, 1, 0, 0, 0, 674, 7420, 1, 0, 0, 0, 676, 7428, 1, 0, 0, 0, 678, + 7478, 1, 0, 0, 0, 680, 7480, 1, 0, 0, 0, 682, 7487, 1, 0, 0, 0, 684, 7492, + 1, 0, 0, 0, 686, 7494, 1, 0, 0, 0, 688, 7506, 1, 0, 0, 0, 690, 7567, 1, + 0, 0, 0, 692, 7582, 1, 0, 0, 0, 694, 7584, 1, 0, 0, 0, 696, 7589, 1, 0, + 0, 0, 698, 7591, 1, 0, 0, 0, 700, 7601, 1, 0, 0, 0, 702, 7603, 1, 0, 0, + 0, 704, 7605, 1, 0, 0, 0, 706, 7607, 1, 0, 0, 0, 708, 7611, 1, 0, 0, 0, + 710, 7613, 1, 0, 0, 0, 712, 7619, 1, 0, 0, 0, 714, 7668, 1, 0, 0, 0, 716, + 7670, 1, 0, 0, 0, 718, 7699, 1, 0, 0, 0, 720, 7703, 1, 0, 0, 0, 722, 7744, + 1, 0, 0, 0, 724, 7746, 1, 0, 0, 0, 726, 7755, 1, 0, 0, 0, 728, 7766, 1, + 0, 0, 0, 730, 7770, 1, 0, 0, 0, 732, 7772, 1, 0, 0, 0, 734, 7790, 1, 0, + 0, 0, 736, 7797, 1, 0, 0, 0, 738, 7804, 1, 0, 0, 0, 740, 7878, 1, 0, 0, + 0, 742, 7880, 1, 0, 0, 0, 744, 7885, 1, 0, 0, 0, 746, 8012, 1, 0, 0, 0, + 748, 8023, 1, 0, 0, 0, 750, 8034, 1, 0, 0, 0, 752, 8065, 1, 0, 0, 0, 754, + 8073, 1, 0, 0, 0, 756, 8089, 1, 0, 0, 0, 758, 8113, 1, 0, 0, 0, 760, 8119, + 1, 0, 0, 0, 762, 8174, 1, 0, 0, 0, 764, 8178, 1, 0, 0, 0, 766, 8193, 1, + 0, 0, 0, 768, 8200, 1, 0, 0, 0, 770, 8217, 1, 0, 0, 0, 772, 8240, 1, 0, + 0, 0, 774, 8296, 1, 0, 0, 0, 776, 8307, 1, 0, 0, 0, 778, 8315, 1, 0, 0, + 0, 780, 8330, 1, 0, 0, 0, 782, 8346, 1, 0, 0, 0, 784, 8348, 1, 0, 0, 0, + 786, 8350, 1, 0, 0, 0, 788, 8387, 1, 0, 0, 0, 790, 8396, 1, 0, 0, 0, 792, + 8418, 1, 0, 0, 0, 794, 8428, 1, 0, 0, 0, 796, 8432, 1, 0, 0, 0, 798, 8504, + 1, 0, 0, 0, 800, 8515, 1, 0, 0, 0, 802, 8533, 1, 0, 0, 0, 804, 8537, 1, + 0, 0, 0, 806, 8540, 1, 0, 0, 0, 808, 8543, 1, 0, 0, 0, 810, 8549, 1, 0, + 0, 0, 812, 8554, 1, 0, 0, 0, 814, 8558, 1, 0, 0, 0, 816, 8607, 1, 0, 0, + 0, 818, 8637, 1, 0, 0, 0, 820, 8659, 1, 0, 0, 0, 822, 8668, 1, 0, 0, 0, + 824, 8672, 1, 0, 0, 0, 826, 8695, 1, 0, 0, 0, 828, 8697, 1, 0, 0, 0, 830, + 8736, 1, 0, 0, 0, 832, 8739, 1, 0, 0, 0, 834, 8798, 1, 0, 0, 0, 836, 8803, + 1, 0, 0, 0, 838, 8805, 1, 0, 0, 0, 840, 8825, 1, 0, 0, 0, 842, 8879, 1, + 0, 0, 0, 844, 8908, 1, 0, 0, 0, 846, 8945, 1, 0, 0, 0, 848, 8949, 1, 0, + 0, 0, 850, 8997, 1, 0, 0, 0, 852, 9001, 1, 0, 0, 0, 854, 9025, 1, 0, 0, + 0, 856, 9052, 1, 0, 0, 0, 858, 9054, 1, 0, 0, 0, 860, 9056, 1, 0, 0, 0, + 862, 9141, 1, 0, 0, 0, 864, 9149, 1, 0, 0, 0, 866, 9151, 1, 0, 0, 0, 868, + 9157, 1, 0, 0, 0, 870, 9168, 1, 0, 0, 0, 872, 9170, 1, 0, 0, 0, 874, 9173, + 1, 0, 0, 0, 876, 9175, 1, 0, 0, 0, 878, 9186, 1, 0, 0, 0, 880, 9211, 1, + 0, 0, 0, 882, 9214, 1, 0, 0, 0, 884, 9216, 1, 0, 0, 0, 886, 9227, 1, 0, + 0, 0, 888, 9232, 1, 0, 0, 0, 890, 9244, 1, 0, 0, 0, 892, 9256, 1, 0, 0, + 0, 894, 9259, 1, 0, 0, 0, 896, 9310, 1, 0, 0, 0, 898, 9312, 1, 0, 0, 0, + 900, 9320, 1, 0, 0, 0, 902, 9336, 1, 0, 0, 0, 904, 9349, 1, 0, 0, 0, 906, + 9351, 1, 0, 0, 0, 908, 9390, 1, 0, 0, 0, 910, 9392, 1, 0, 0, 0, 912, 9398, + 1, 0, 0, 0, 914, 9405, 1, 0, 0, 0, 916, 9429, 1, 0, 0, 0, 918, 9442, 1, + 0, 0, 0, 920, 9454, 1, 0, 0, 0, 922, 9459, 1, 0, 0, 0, 924, 9462, 1, 0, + 0, 0, 926, 9470, 1, 0, 0, 0, 928, 9472, 1, 0, 0, 0, 930, 9525, 1, 0, 0, + 0, 932, 9527, 1, 0, 0, 0, 934, 9558, 1, 0, 0, 0, 936, 9560, 1, 0, 0, 0, + 938, 9570, 1, 0, 0, 0, 940, 9597, 1, 0, 0, 0, 942, 9602, 1, 0, 0, 0, 944, + 9607, 1, 0, 0, 0, 946, 9645, 1, 0, 0, 0, 948, 9647, 1, 0, 0, 0, 950, 9649, + 1, 0, 0, 0, 952, 9651, 1, 0, 0, 0, 954, 9653, 1, 0, 0, 0, 956, 9715, 1, + 0, 0, 0, 958, 9719, 1, 0, 0, 0, 960, 9724, 1, 0, 0, 0, 962, 9748, 1, 0, + 0, 0, 964, 9761, 1, 0, 0, 0, 966, 9766, 1, 0, 0, 0, 968, 9792, 1, 0, 0, + 0, 970, 9796, 1, 0, 0, 0, 972, 9801, 1, 0, 0, 0, 974, 9806, 1, 0, 0, 0, + 976, 9814, 1, 0, 0, 0, 978, 9820, 1, 0, 0, 0, 980, 9823, 1, 0, 0, 0, 982, + 9831, 1, 0, 0, 0, 984, 9837, 1, 0, 0, 0, 986, 9858, 1, 0, 0, 0, 988, 9881, + 1, 0, 0, 0, 990, 9889, 1, 0, 0, 0, 992, 9891, 1, 0, 0, 0, 994, 9899, 1, + 0, 0, 0, 996, 9911, 1, 0, 0, 0, 998, 9928, 1, 0, 0, 0, 1000, 9931, 1, 0, + 0, 0, 1002, 9946, 1, 0, 0, 0, 1004, 10030, 1, 0, 0, 0, 1006, 10045, 1, + 0, 0, 0, 1008, 10090, 1, 0, 0, 0, 1010, 10092, 1, 0, 0, 0, 1012, 10102, + 1, 0, 0, 0, 1014, 10124, 1, 0, 0, 0, 1016, 10126, 1, 0, 0, 0, 1018, 10180, + 1, 0, 0, 0, 1020, 10204, 1, 0, 0, 0, 1022, 10223, 1, 0, 0, 0, 1024, 10225, + 1, 0, 0, 0, 1026, 10233, 1, 0, 0, 0, 1028, 10236, 1, 0, 0, 0, 1030, 10239, + 1, 0, 0, 0, 1032, 10267, 1, 0, 0, 0, 1034, 10292, 1, 0, 0, 0, 1036, 10301, + 1, 0, 0, 0, 1038, 10353, 1, 0, 0, 0, 1040, 10388, 1, 0, 0, 0, 1042, 10410, + 1, 0, 0, 0, 1044, 10452, 1, 0, 0, 0, 1046, 10456, 1, 0, 0, 0, 1048, 10470, + 1, 0, 0, 0, 1050, 10510, 1, 0, 0, 0, 1052, 10512, 1, 0, 0, 0, 1054, 10526, + 1, 0, 0, 0, 1056, 10557, 1, 0, 0, 0, 1058, 10560, 1, 0, 0, 0, 1060, 10578, + 1, 0, 0, 0, 1062, 10607, 1, 0, 0, 0, 1064, 10612, 1, 0, 0, 0, 1066, 10621, + 1, 0, 0, 0, 1068, 10636, 1, 0, 0, 0, 1070, 10640, 1, 0, 0, 0, 1072, 10649, + 1, 0, 0, 0, 1074, 10664, 1, 0, 0, 0, 1076, 10670, 1, 0, 0, 0, 1078, 10673, + 1, 0, 0, 0, 1080, 10735, 1, 0, 0, 0, 1082, 10738, 1, 0, 0, 0, 1084, 10741, + 1, 0, 0, 0, 1086, 10767, 1, 0, 0, 0, 1088, 10778, 1, 0, 0, 0, 1090, 10790, + 1, 0, 0, 0, 1092, 10792, 1, 0, 0, 0, 1094, 10811, 1, 0, 0, 0, 1096, 10813, + 1, 0, 0, 0, 1098, 10824, 1, 0, 0, 0, 1100, 10838, 1, 0, 0, 0, 1102, 10854, + 1, 0, 0, 0, 1104, 10856, 1, 0, 0, 0, 1106, 10864, 1, 0, 0, 0, 1108, 10874, + 1, 0, 0, 0, 1110, 10876, 1, 0, 0, 0, 1112, 10932, 1, 0, 0, 0, 1114, 10960, + 1, 0, 0, 0, 1116, 10977, 1, 0, 0, 0, 1118, 11000, 1, 0, 0, 0, 1120, 11037, + 1, 0, 0, 0, 1122, 11039, 1, 0, 0, 0, 1124, 11089, 1, 0, 0, 0, 1126, 11111, + 1, 0, 0, 0, 1128, 11131, 1, 0, 0, 0, 1130, 11150, 1, 0, 0, 0, 1132, 11156, + 1, 0, 0, 0, 1134, 11171, 1, 0, 0, 0, 1136, 11211, 1, 0, 0, 0, 1138, 11251, + 1, 0, 0, 0, 1140, 11285, 1, 0, 0, 0, 1142, 11287, 1, 0, 0, 0, 1144, 11303, + 1, 0, 0, 0, 1146, 11312, 1, 0, 0, 0, 1148, 11345, 1, 0, 0, 0, 1150, 11347, + 1, 0, 0, 0, 1152, 11355, 1, 0, 0, 0, 1154, 11363, 1, 0, 0, 0, 1156, 11370, + 1, 0, 0, 0, 1158, 11387, 1, 0, 0, 0, 1160, 11401, 1, 0, 0, 0, 1162, 11427, + 1, 0, 0, 0, 1164, 11470, 1, 0, 0, 0, 1166, 11474, 1, 0, 0, 0, 1168, 11498, + 1, 0, 0, 0, 1170, 11535, 1, 0, 0, 0, 1172, 11552, 1, 0, 0, 0, 1174, 11573, + 1, 0, 0, 0, 1176, 11597, 1, 0, 0, 0, 1178, 11610, 1, 0, 0, 0, 1180, 11612, + 1, 0, 0, 0, 1182, 11615, 1, 0, 0, 0, 1184, 11642, 1, 0, 0, 0, 1186, 11650, + 1, 0, 0, 0, 1188, 11668, 1, 0, 0, 0, 1190, 11672, 1, 0, 0, 0, 1192, 11707, + 1, 0, 0, 0, 1194, 11722, 1, 0, 0, 0, 1196, 11780, 1, 0, 0, 0, 1198, 11782, + 1, 0, 0, 0, 1200, 11797, 1, 0, 0, 0, 1202, 11818, 1, 0, 0, 0, 1204, 11820, + 1, 0, 0, 0, 1206, 11848, 1, 0, 0, 0, 1208, 11850, 1, 0, 0, 0, 1210, 11862, + 1, 0, 0, 0, 1212, 11869, 1, 0, 0, 0, 1214, 11873, 1, 0, 0, 0, 1216, 11881, + 1, 0, 0, 0, 1218, 11899, 1, 0, 0, 0, 1220, 11904, 1, 0, 0, 0, 1222, 11942, + 1, 0, 0, 0, 1224, 11950, 1, 0, 0, 0, 1226, 11969, 1, 0, 0, 0, 1228, 11972, + 1, 0, 0, 0, 1230, 12028, 1, 0, 0, 0, 1232, 12031, 1, 0, 0, 0, 1234, 12065, + 1, 0, 0, 0, 1236, 12067, 1, 0, 0, 0, 1238, 12069, 1, 0, 0, 0, 1240, 12071, + 1, 0, 0, 0, 1242, 12079, 1, 0, 0, 0, 1244, 12113, 1, 0, 0, 0, 1246, 12115, + 1, 0, 0, 0, 1248, 12126, 1, 0, 0, 0, 1250, 12139, 1, 0, 0, 0, 1252, 12142, + 1, 0, 0, 0, 1254, 12160, 1, 0, 0, 0, 1256, 12162, 1, 0, 0, 0, 1258, 12164, + 1, 0, 0, 0, 1260, 12166, 1, 0, 0, 0, 1262, 12258, 1, 0, 0, 0, 1264, 12260, + 1, 0, 0, 0, 1266, 12263, 1, 0, 0, 0, 1268, 12297, 1, 0, 0, 0, 1270, 12299, + 1, 0, 0, 0, 1272, 12301, 1, 0, 0, 0, 1274, 12308, 1, 0, 0, 0, 1276, 12321, + 1, 0, 0, 0, 1278, 12360, 1, 0, 0, 0, 1280, 12366, 1, 0, 0, 0, 1282, 12398, + 1, 0, 0, 0, 1284, 12403, 1, 0, 0, 0, 1286, 12406, 1, 0, 0, 0, 1288, 12419, + 1, 0, 0, 0, 1290, 12421, 1, 0, 0, 0, 1292, 12463, 1, 0, 0, 0, 1294, 12465, + 1, 0, 0, 0, 1296, 12488, 1, 0, 0, 0, 1298, 12508, 1, 0, 0, 0, 1300, 12524, + 1, 0, 0, 0, 1302, 12530, 1, 0, 0, 0, 1304, 12539, 1, 0, 0, 0, 1306, 12543, + 1, 0, 0, 0, 1308, 12552, 1, 0, 0, 0, 1310, 12560, 1, 0, 0, 0, 1312, 12572, + 1, 0, 0, 0, 1314, 12584, 1, 0, 0, 0, 1316, 12591, 1, 0, 0, 0, 1318, 12601, + 1, 0, 0, 0, 1320, 12610, 1, 0, 0, 0, 1322, 12617, 1, 0, 0, 0, 1324, 12619, + 1, 0, 0, 0, 1326, 12621, 1, 0, 0, 0, 1328, 12676, 1, 0, 0, 0, 1330, 12678, + 1, 0, 0, 0, 1332, 12692, 1, 0, 0, 0, 1334, 12711, 1, 0, 0, 0, 1336, 12713, + 1, 0, 0, 0, 1338, 12715, 1, 0, 0, 0, 1340, 12722, 1, 0, 0, 0, 1342, 12730, + 1, 0, 0, 0, 1344, 12747, 1, 0, 0, 0, 1346, 12777, 1, 0, 0, 0, 1348, 12781, + 1, 0, 0, 0, 1350, 12789, 1, 0, 0, 0, 1352, 12811, 1, 0, 0, 0, 1354, 12826, + 1, 0, 0, 0, 1356, 12876, 1, 0, 0, 0, 1358, 12894, 1, 0, 0, 0, 1360, 12904, + 1, 0, 0, 0, 1362, 12914, 1, 0, 0, 0, 1364, 12919, 1, 0, 0, 0, 1366, 12924, + 1, 0, 0, 0, 1368, 12935, 1, 0, 0, 0, 1370, 12939, 1, 0, 0, 0, 1372, 12943, + 1, 0, 0, 0, 1374, 12956, 1, 0, 0, 0, 1376, 12962, 1, 0, 0, 0, 1378, 12969, + 1, 0, 0, 0, 1380, 12971, 1, 0, 0, 0, 1382, 12973, 1, 0, 0, 0, 1384, 12995, + 1, 0, 0, 0, 1386, 13020, 1, 0, 0, 0, 1388, 13022, 1, 0, 0, 0, 1390, 13024, + 1, 0, 0, 0, 1392, 13031, 1, 0, 0, 0, 1394, 13033, 1, 0, 0, 0, 1396, 13035, + 1, 0, 0, 0, 1398, 13068, 1, 0, 0, 0, 1400, 13113, 1, 0, 0, 0, 1402, 13115, + 1, 0, 0, 0, 1404, 13146, 1, 0, 0, 0, 1406, 13183, 1, 0, 0, 0, 1408, 13202, + 1, 0, 0, 0, 1410, 13204, 1, 0, 0, 0, 1412, 13224, 1, 0, 0, 0, 1414, 13252, + 1, 0, 0, 0, 1416, 13277, 1, 0, 0, 0, 1418, 13359, 1, 0, 0, 0, 1420, 13361, + 1, 0, 0, 0, 1422, 13405, 1, 0, 0, 0, 1424, 13409, 1, 0, 0, 0, 1426, 13433, + 1, 0, 0, 0, 1428, 13440, 1, 0, 0, 0, 1430, 13448, 1, 0, 0, 0, 1432, 13450, + 1, 0, 0, 0, 1434, 13469, 1, 0, 0, 0, 1436, 13492, 1, 0, 0, 0, 1438, 13494, + 1, 0, 0, 0, 1440, 13512, 1, 0, 0, 0, 1442, 13517, 1, 0, 0, 0, 1444, 13527, + 1, 0, 0, 0, 1446, 13534, 1, 0, 0, 0, 1448, 13542, 1, 0, 0, 0, 1450, 13575, + 1, 0, 0, 0, 1452, 13598, 1, 0, 0, 0, 1454, 13603, 1, 0, 0, 0, 1456, 13654, + 1, 0, 0, 0, 1458, 13656, 1, 0, 0, 0, 1460, 13661, 1, 0, 0, 0, 1462, 13665, + 1, 0, 0, 0, 1464, 13668, 1, 0, 0, 0, 1466, 13670, 1, 0, 0, 0, 1468, 13672, + 1, 0, 0, 0, 1470, 13674, 1, 0, 0, 0, 1472, 13676, 1, 0, 0, 0, 1474, 13678, + 1, 0, 0, 0, 1476, 13692, 1, 0, 0, 0, 1478, 13697, 1, 0, 0, 0, 1480, 13704, + 1, 0, 0, 0, 1482, 13706, 1, 0, 0, 0, 1484, 13711, 1, 0, 0, 0, 1486, 13716, + 1, 0, 0, 0, 1488, 13722, 1, 0, 0, 0, 1490, 13726, 1, 0, 0, 0, 1492, 13750, + 1, 0, 0, 0, 1494, 13752, 1, 0, 0, 0, 1496, 13759, 1, 0, 0, 0, 1498, 13819, + 1, 0, 0, 0, 1500, 13823, 1, 0, 0, 0, 1502, 13845, 1, 0, 0, 0, 1504, 13847, + 1, 0, 0, 0, 1506, 13867, 1, 0, 0, 0, 1508, 13883, 1, 0, 0, 0, 1510, 13888, + 1, 0, 0, 0, 1512, 13896, 1, 0, 0, 0, 1514, 13900, 1, 0, 0, 0, 1516, 13911, + 1, 0, 0, 0, 1518, 13939, 1, 0, 0, 0, 1520, 13955, 1, 0, 0, 0, 1522, 13964, + 1, 0, 0, 0, 1524, 13996, 1, 0, 0, 0, 1526, 14008, 1, 0, 0, 0, 1528, 14016, + 1, 0, 0, 0, 1530, 14049, 1, 0, 0, 0, 1532, 14051, 1, 0, 0, 0, 1534, 14078, + 1, 0, 0, 0, 1536, 14097, 1, 0, 0, 0, 1538, 14123, 1, 0, 0, 0, 1540, 14125, + 1, 0, 0, 0, 1542, 14159, 1, 0, 0, 0, 1544, 14176, 1, 0, 0, 0, 1546, 14187, + 1, 0, 0, 0, 1548, 14189, 1, 0, 0, 0, 1550, 14208, 1, 0, 0, 0, 1552, 14219, + 1, 0, 0, 0, 1554, 14228, 1, 0, 0, 0, 1556, 14260, 1, 0, 0, 0, 1558, 14285, + 1, 0, 0, 0, 1560, 14309, 1, 0, 0, 0, 1562, 14323, 1, 0, 0, 0, 1564, 14333, + 1, 0, 0, 0, 1566, 14342, 1, 0, 0, 0, 1568, 14372, 1, 0, 0, 0, 1570, 14424, + 1, 0, 0, 0, 1572, 14435, 1, 0, 0, 0, 1574, 14437, 1, 0, 0, 0, 1576, 14453, + 1, 0, 0, 0, 1578, 14455, 1, 0, 0, 0, 1580, 14480, 1, 0, 0, 0, 1582, 14482, + 1, 0, 0, 0, 1584, 14486, 1, 0, 0, 0, 1586, 14494, 1, 0, 0, 0, 1588, 14508, + 1, 0, 0, 0, 1590, 14519, 1, 0, 0, 0, 1592, 14534, 1, 0, 0, 0, 1594, 14569, + 1, 0, 0, 0, 1596, 14593, 1, 0, 0, 0, 1598, 14597, 1, 0, 0, 0, 1600, 14599, + 1, 0, 0, 0, 1602, 14603, 1, 0, 0, 0, 1604, 14638, 1, 0, 0, 0, 1606, 14643, + 1, 0, 0, 0, 1608, 14648, 1, 0, 0, 0, 1610, 14652, 1, 0, 0, 0, 1612, 14662, + 1, 0, 0, 0, 1614, 14664, 1, 0, 0, 0, 1616, 14672, 1, 0, 0, 0, 1618, 14674, + 1, 0, 0, 0, 1620, 14680, 1, 0, 0, 0, 1622, 14682, 1, 0, 0, 0, 1624, 14688, + 1, 0, 0, 0, 1626, 14754, 1, 0, 0, 0, 1628, 14756, 1, 0, 0, 0, 1630, 14780, + 1, 0, 0, 0, 1632, 14783, 1, 0, 0, 0, 1634, 14813, 1, 0, 0, 0, 1636, 14825, + 1, 0, 0, 0, 1638, 14852, 1, 0, 0, 0, 1640, 14859, 1, 0, 0, 0, 1642, 14868, + 1, 0, 0, 0, 1644, 14884, 1, 0, 0, 0, 1646, 14888, 1, 0, 0, 0, 1648, 14897, + 1, 0, 0, 0, 1650, 14899, 1, 0, 0, 0, 1652, 14946, 1, 0, 0, 0, 1654, 14979, + 1, 0, 0, 0, 1656, 15008, 1, 0, 0, 0, 1658, 15012, 1, 0, 0, 0, 1660, 15019, + 1, 0, 0, 0, 1662, 15021, 1, 0, 0, 0, 1664, 15031, 1, 0, 0, 0, 1666, 15047, + 1, 0, 0, 0, 1668, 15052, 1, 0, 0, 0, 1670, 15081, 1, 0, 0, 0, 1672, 15085, + 1, 0, 0, 0, 1674, 15120, 1, 0, 0, 0, 1676, 15132, 1, 0, 0, 0, 1678, 15134, + 1, 0, 0, 0, 1680, 15136, 1, 0, 0, 0, 1682, 15174, 1, 0, 0, 0, 1684, 15176, + 1, 0, 0, 0, 1686, 15204, 1, 0, 0, 0, 1688, 15229, 1, 0, 0, 0, 1690, 15231, + 1, 0, 0, 0, 1692, 15277, 1, 0, 0, 0, 1694, 15300, 1, 0, 0, 0, 1696, 15308, + 1, 0, 0, 0, 1698, 15311, 1, 0, 0, 0, 1700, 15348, 1, 0, 0, 0, 1702, 15369, + 1, 0, 0, 0, 1704, 15373, 1, 0, 0, 0, 1706, 15375, 1, 0, 0, 0, 1708, 15381, + 1, 0, 0, 0, 1710, 15383, 1, 0, 0, 0, 1712, 15443, 1, 0, 0, 0, 1714, 15445, + 1, 0, 0, 0, 1716, 15447, 1, 0, 0, 0, 1718, 15449, 1, 0, 0, 0, 1720, 15479, + 1, 0, 0, 0, 1722, 15481, 1, 0, 0, 0, 1724, 15501, 1, 0, 0, 0, 1726, 15503, + 1, 0, 0, 0, 1728, 15510, 1, 0, 0, 0, 1730, 15514, 1, 0, 0, 0, 1732, 15518, + 1, 0, 0, 0, 1734, 15522, 1, 0, 0, 0, 1736, 15529, 1, 0, 0, 0, 1738, 15543, + 1, 0, 0, 0, 1740, 15550, 1, 0, 0, 0, 1742, 15555, 1, 0, 0, 0, 1744, 15563, + 1, 0, 0, 0, 1746, 15578, 1, 0, 0, 0, 1748, 15581, 1, 0, 0, 0, 1750, 15586, + 1, 0, 0, 0, 1752, 15590, 1, 0, 0, 0, 1754, 15607, 1, 0, 0, 0, 1756, 15613, + 1, 0, 0, 0, 1758, 15623, 1, 0, 0, 0, 1760, 15636, 1, 0, 0, 0, 1762, 15640, + 1, 0, 0, 0, 1764, 15654, 1, 0, 0, 0, 1766, 15656, 1, 0, 0, 0, 1768, 15670, + 1, 0, 0, 0, 1770, 15687, 1, 0, 0, 0, 1772, 15712, 1, 0, 0, 0, 1774, 15722, + 1, 0, 0, 0, 1776, 15726, 1, 0, 0, 0, 1778, 15761, 1, 0, 0, 0, 1780, 15773, + 1, 0, 0, 0, 1782, 15784, 1, 0, 0, 0, 1784, 15790, 1, 0, 0, 0, 1786, 15801, + 1, 0, 0, 0, 1788, 15813, 1, 0, 0, 0, 1790, 15821, 1, 0, 0, 0, 1792, 15836, + 1, 0, 0, 0, 1794, 15840, 1, 0, 0, 0, 1796, 15862, 1, 0, 0, 0, 1798, 15865, + 1, 0, 0, 0, 1800, 15871, 1, 0, 0, 0, 1802, 15876, 1, 0, 0, 0, 1804, 15884, + 1, 0, 0, 0, 1806, 15892, 1, 0, 0, 0, 1808, 15895, 1, 0, 0, 0, 1810, 15911, + 1, 0, 0, 0, 1812, 15916, 1, 0, 0, 0, 1814, 15920, 1, 0, 0, 0, 1816, 15960, + 1, 0, 0, 0, 1818, 15962, 1, 0, 0, 0, 1820, 15984, 1, 0, 0, 0, 1822, 15986, + 1, 0, 0, 0, 1824, 15991, 1, 0, 0, 0, 1826, 15993, 1, 0, 0, 0, 1828, 15995, + 1, 0, 0, 0, 1830, 15997, 1, 0, 0, 0, 1832, 16001, 1, 0, 0, 0, 1834, 16006, + 1, 0, 0, 0, 1836, 16016, 1, 0, 0, 0, 1838, 16022, 1, 0, 0, 0, 1840, 16036, + 1, 0, 0, 0, 1842, 16055, 1, 0, 0, 0, 1844, 16060, 1, 0, 0, 0, 1846, 16073, + 1, 0, 0, 0, 1848, 16075, 1, 0, 0, 0, 1850, 16089, 1, 0, 0, 0, 1852, 16099, + 1, 0, 0, 0, 1854, 16105, 1, 0, 0, 0, 1856, 16107, 1, 0, 0, 0, 1858, 16110, + 1, 0, 0, 0, 1860, 16119, 1, 0, 0, 0, 1862, 16150, 1, 0, 0, 0, 1864, 16165, + 1, 0, 0, 0, 1866, 16167, 1, 0, 0, 0, 1868, 16188, 1, 0, 0, 0, 1870, 16203, + 1, 0, 0, 0, 1872, 16225, 1, 0, 0, 0, 1874, 16232, 1, 0, 0, 0, 1876, 16245, + 1, 0, 0, 0, 1878, 16248, 1, 0, 0, 0, 1880, 16268, 1, 0, 0, 0, 1882, 16270, + 1, 0, 0, 0, 1884, 16280, 1, 0, 0, 0, 1886, 16289, 1, 0, 0, 0, 1888, 16306, + 1, 0, 0, 0, 1890, 16349, 1, 0, 0, 0, 1892, 16358, 1, 0, 0, 0, 1894, 16370, + 1, 0, 0, 0, 1896, 16378, 1, 0, 0, 0, 1898, 16383, 1, 0, 0, 0, 1900, 16421, + 1, 0, 0, 0, 1902, 16423, 1, 0, 0, 0, 1904, 16431, 1, 0, 0, 0, 1906, 16433, + 1, 0, 0, 0, 1908, 16437, 1, 0, 0, 0, 1910, 16445, 1, 0, 0, 0, 1912, 16456, + 1, 0, 0, 0, 1914, 16490, 1, 0, 0, 0, 1916, 16493, 1, 0, 0, 0, 1918, 16514, + 1, 0, 0, 0, 1920, 16517, 1, 0, 0, 0, 1922, 16520, 1, 0, 0, 0, 1924, 16524, + 1, 0, 0, 0, 1926, 16543, 1, 0, 0, 0, 1928, 16545, 1, 0, 0, 0, 1930, 16562, + 1, 0, 0, 0, 1932, 16569, 1, 0, 0, 0, 1934, 16574, 1, 0, 0, 0, 1936, 16597, + 1, 0, 0, 0, 1938, 16607, 1, 0, 0, 0, 1940, 16609, 1, 0, 0, 0, 1942, 16623, + 1, 0, 0, 0, 1944, 16637, 1, 0, 0, 0, 1946, 16673, 1, 0, 0, 0, 1948, 16675, + 1, 0, 0, 0, 1950, 16705, 1, 0, 0, 0, 1952, 16710, 1, 0, 0, 0, 1954, 16712, + 1, 0, 0, 0, 1956, 16724, 1, 0, 0, 0, 1958, 16744, 1, 0, 0, 0, 1960, 16746, + 1, 0, 0, 0, 1962, 16749, 1, 0, 0, 0, 1964, 16775, 1, 0, 0, 0, 1966, 16777, + 1, 0, 0, 0, 1968, 16781, 1, 0, 0, 0, 1970, 16796, 1, 0, 0, 0, 1972, 16808, + 1, 0, 0, 0, 1974, 16816, 1, 0, 0, 0, 1976, 16820, 1, 0, 0, 0, 1978, 16833, + 1, 0, 0, 0, 1980, 16839, 1, 0, 0, 0, 1982, 16854, 1, 0, 0, 0, 1984, 16874, + 1, 0, 0, 0, 1986, 16883, 1, 0, 0, 0, 1988, 16885, 1, 0, 0, 0, 1990, 16892, + 1, 0, 0, 0, 1992, 16897, 1, 0, 0, 0, 1994, 16910, 1, 0, 0, 0, 1996, 16918, + 1, 0, 0, 0, 1998, 16922, 1, 0, 0, 0, 2000, 16936, 1, 0, 0, 0, 2002, 16944, + 1, 0, 0, 0, 2004, 16952, 1, 0, 0, 0, 2006, 16954, 1, 0, 0, 0, 2008, 16966, + 1, 0, 0, 0, 2010, 16998, 1, 0, 0, 0, 2012, 17000, 1, 0, 0, 0, 2014, 17014, + 1, 0, 0, 0, 2016, 17019, 1, 0, 0, 0, 2018, 17037, 1, 0, 0, 0, 2020, 17041, + 1, 0, 0, 0, 2022, 17049, 1, 0, 0, 0, 2024, 17059, 1, 0, 0, 0, 2026, 17067, + 1, 0, 0, 0, 2028, 17073, 1, 0, 0, 0, 2030, 17078, 1, 0, 0, 0, 2032, 17086, + 1, 0, 0, 0, 2034, 17108, 1, 0, 0, 0, 2036, 17127, 1, 0, 0, 0, 2038, 17131, + 1, 0, 0, 0, 2040, 17134, 1, 0, 0, 0, 2042, 17151, 1, 0, 0, 0, 2044, 17156, + 1, 0, 0, 0, 2046, 17175, 1, 0, 0, 0, 2048, 17177, 1, 0, 0, 0, 2050, 17193, + 1, 0, 0, 0, 2052, 17201, 1, 0, 0, 0, 2054, 17206, 1, 0, 0, 0, 2056, 17210, + 1, 0, 0, 0, 2058, 17221, 1, 0, 0, 0, 2060, 17224, 1, 0, 0, 0, 2062, 17247, + 1, 0, 0, 0, 2064, 17249, 1, 0, 0, 0, 2066, 17262, 1, 0, 0, 0, 2068, 17273, + 1, 0, 0, 0, 2070, 17287, 1, 0, 0, 0, 2072, 17294, 1, 0, 0, 0, 2074, 17319, + 1, 0, 0, 0, 2076, 17321, 1, 0, 0, 0, 2078, 17331, 1, 0, 0, 0, 2080, 17333, + 1, 0, 0, 0, 2082, 17338, 1, 0, 0, 0, 2084, 17353, 1, 0, 0, 0, 2086, 17391, + 1, 0, 0, 0, 2088, 17393, 1, 0, 0, 0, 2090, 17401, 1, 0, 0, 0, 2092, 17413, + 1, 0, 0, 0, 2094, 17445, 1, 0, 0, 0, 2096, 17465, 1, 0, 0, 0, 2098, 17467, + 1, 0, 0, 0, 2100, 17471, 1, 0, 0, 0, 2102, 17530, 1, 0, 0, 0, 2104, 17532, + 1, 0, 0, 0, 2106, 17562, 1, 0, 0, 0, 2108, 17564, 1, 0, 0, 0, 2110, 17585, + 1, 0, 0, 0, 2112, 17615, 1, 0, 0, 0, 2114, 17619, 1, 0, 0, 0, 2116, 17622, + 1, 0, 0, 0, 2118, 17641, 1, 0, 0, 0, 2120, 17649, 1, 0, 0, 0, 2122, 17667, + 1, 0, 0, 0, 2124, 17674, 1, 0, 0, 0, 2126, 17698, 1, 0, 0, 0, 2128, 17700, + 1, 0, 0, 0, 2130, 17797, 1, 0, 0, 0, 2132, 17803, 1, 0, 0, 0, 2134, 17995, + 1, 0, 0, 0, 2136, 18006, 1, 0, 0, 0, 2138, 18039, 1, 0, 0, 0, 2140, 18041, + 1, 0, 0, 0, 2142, 18072, 1, 0, 0, 0, 2144, 18078, 1, 0, 0, 0, 2146, 18082, + 1, 0, 0, 0, 2148, 18183, 1, 0, 0, 0, 2150, 18185, 1, 0, 0, 0, 2152, 18250, + 1, 0, 0, 0, 2154, 18254, 1, 0, 0, 0, 2156, 18273, 1, 0, 0, 0, 2158, 18288, + 1, 0, 0, 0, 2160, 18297, 1, 0, 0, 0, 2162, 18309, 1, 0, 0, 0, 2164, 18314, + 1, 0, 0, 0, 2166, 18355, 1, 0, 0, 0, 2168, 18357, 1, 0, 0, 0, 2170, 18374, + 1, 0, 0, 0, 2172, 18376, 1, 0, 0, 0, 2174, 18439, 1, 0, 0, 0, 2176, 18441, + 1, 0, 0, 0, 2178, 18838, 1, 0, 0, 0, 2180, 18840, 1, 0, 0, 0, 2182, 18842, + 1, 0, 0, 0, 2184, 18844, 1, 0, 0, 0, 2186, 18846, 1, 0, 0, 0, 2188, 18872, + 1, 0, 0, 0, 2190, 18881, 1, 0, 0, 0, 2192, 18890, 1, 0, 0, 0, 2194, 18892, + 1, 0, 0, 0, 2196, 18909, 1, 0, 0, 0, 2198, 18913, 1, 0, 0, 0, 2200, 18924, + 1, 0, 0, 0, 2202, 18926, 1, 0, 0, 0, 2204, 18950, 1, 0, 0, 0, 2206, 18969, + 1, 0, 0, 0, 2208, 18987, 1, 0, 0, 0, 2210, 19008, 1, 0, 0, 0, 2212, 19021, + 1, 0, 0, 0, 2214, 19024, 1, 0, 0, 0, 2216, 19033, 1, 0, 0, 0, 2218, 19039, + 1, 0, 0, 0, 2220, 19047, 1, 0, 0, 0, 2222, 19050, 1, 0, 0, 0, 2224, 19061, + 1, 0, 0, 0, 2226, 19072, 1, 0, 0, 0, 2228, 19074, 1, 0, 0, 0, 2230, 19093, + 1, 0, 0, 0, 2232, 19102, 1, 0, 0, 0, 2234, 19114, 1, 0, 0, 0, 2236, 19132, + 1, 0, 0, 0, 2238, 19136, 1, 0, 0, 0, 2240, 19138, 1, 0, 0, 0, 2242, 19146, + 1, 0, 0, 0, 2244, 19162, 1, 0, 0, 0, 2246, 19181, 1, 0, 0, 0, 2248, 19183, + 1, 0, 0, 0, 2250, 19185, 1, 0, 0, 0, 2252, 19187, 1, 0, 0, 0, 2254, 19189, + 1, 0, 0, 0, 2256, 19191, 1, 0, 0, 0, 2258, 19193, 1, 0, 0, 0, 2260, 19195, + 1, 0, 0, 0, 2262, 19207, 1, 0, 0, 0, 2264, 19209, 1, 0, 0, 0, 2266, 19214, + 1, 0, 0, 0, 2268, 19216, 1, 0, 0, 0, 2270, 19218, 1, 0, 0, 0, 2272, 19220, + 1, 0, 0, 0, 2274, 19225, 1, 0, 0, 0, 2276, 19233, 1, 0, 0, 0, 2278, 19235, + 1, 0, 0, 0, 2280, 19242, 1, 0, 0, 0, 2282, 19244, 1, 0, 0, 0, 2284, 19256, + 1, 0, 0, 0, 2286, 19258, 1, 0, 0, 0, 2288, 19266, 1, 0, 0, 0, 2290, 19274, + 1, 0, 0, 0, 2292, 19282, 1, 0, 0, 0, 2294, 19287, 1, 0, 0, 0, 2296, 19292, + 1, 0, 0, 0, 2298, 19307, 1, 0, 0, 0, 2300, 19309, 1, 0, 0, 0, 2302, 19316, + 1, 0, 0, 0, 2304, 19320, 1, 0, 0, 0, 2306, 19322, 1, 0, 0, 0, 2308, 19327, + 1, 0, 0, 0, 2310, 19329, 1, 0, 0, 0, 2312, 19358, 1, 0, 0, 0, 2314, 19360, + 1, 0, 0, 0, 2316, 19387, 1, 0, 0, 0, 2318, 19395, 1, 0, 0, 0, 2320, 19397, + 1, 0, 0, 0, 2322, 19399, 1, 0, 0, 0, 2324, 19401, 1, 0, 0, 0, 2326, 19427, + 1, 0, 0, 0, 2328, 19429, 1, 0, 0, 0, 2330, 19437, 1, 0, 0, 0, 2332, 19441, + 1, 0, 0, 0, 2334, 19450, 1, 0, 0, 0, 2336, 19465, 1, 0, 0, 0, 2338, 19486, + 1, 0, 0, 0, 2340, 19528, 1, 0, 0, 0, 2342, 19535, 1, 0, 0, 0, 2344, 19547, + 1, 0, 0, 0, 2346, 19580, 1, 0, 0, 0, 2348, 19582, 1, 0, 0, 0, 2350, 19659, + 1, 0, 0, 0, 2352, 19664, 1, 0, 0, 0, 2354, 19680, 1, 0, 0, 0, 2356, 19690, + 1, 0, 0, 0, 2358, 19702, 1, 0, 0, 0, 2360, 19744, 1, 0, 0, 0, 2362, 20072, + 1, 0, 0, 0, 2364, 20136, 1, 0, 0, 0, 2366, 20200, 1, 0, 0, 0, 2368, 20202, + 1, 0, 0, 0, 2370, 20204, 1, 0, 0, 0, 2372, 20210, 1, 0, 0, 0, 2374, 20212, + 1, 0, 0, 0, 2376, 20216, 1, 0, 0, 0, 2378, 20222, 1, 0, 0, 0, 2380, 20224, + 1, 0, 0, 0, 2382, 20322, 1, 0, 0, 0, 2384, 20324, 1, 0, 0, 0, 2386, 20326, + 1, 0, 0, 0, 2388, 20328, 1, 0, 0, 0, 2390, 20330, 1, 0, 0, 0, 2392, 2395, + 3, 2226, 1113, 0, 2393, 2395, 3, 2, 1, 0, 2394, 2392, 1, 0, 0, 0, 2394, + 2393, 1, 0, 0, 0, 2395, 2397, 1, 0, 0, 0, 2396, 2398, 5, 2396, 0, 0, 2397, + 2396, 1, 0, 0, 0, 2397, 2398, 1, 0, 0, 0, 2398, 2401, 1, 0, 0, 0, 2399, + 2401, 5, 2396, 0, 0, 2400, 2394, 1, 0, 0, 0, 2400, 2399, 1, 0, 0, 0, 2401, + 2404, 1, 0, 0, 0, 2402, 2400, 1, 0, 0, 0, 2402, 2403, 1, 0, 0, 0, 2403, + 2405, 1, 0, 0, 0, 2404, 2402, 1, 0, 0, 0, 2405, 2406, 5, 0, 0, 1, 2406, + 1, 1, 0, 0, 0, 2407, 2547, 3, 1342, 671, 0, 2408, 2547, 3, 1352, 676, 0, + 2409, 2547, 3, 1354, 677, 0, 2410, 2547, 3, 1356, 678, 0, 2411, 2547, 3, + 1382, 691, 0, 2412, 2547, 3, 1490, 745, 0, 2413, 2547, 3, 814, 407, 0, + 2414, 2547, 3, 4, 2, 0, 2415, 2547, 3, 98, 49, 0, 2416, 2547, 3, 102, 51, + 0, 2417, 2547, 3, 100, 50, 0, 2418, 2547, 3, 510, 255, 0, 2419, 2547, 3, + 550, 275, 0, 2420, 2547, 3, 104, 52, 0, 2421, 2547, 3, 790, 395, 0, 2422, + 2547, 3, 126, 63, 0, 2423, 2547, 3, 928, 464, 0, 2424, 2547, 3, 938, 469, + 0, 2425, 2547, 3, 962, 481, 0, 2426, 2547, 3, 980, 490, 0, 2427, 2547, + 3, 122, 61, 0, 2428, 2547, 3, 148, 74, 0, 2429, 2547, 3, 162, 81, 0, 2430, + 2547, 3, 168, 84, 0, 2431, 2547, 3, 176, 88, 0, 2432, 2547, 3, 1536, 768, + 0, 2433, 2547, 3, 180, 90, 0, 2434, 2547, 3, 316, 158, 0, 2435, 2547, 3, + 318, 159, 0, 2436, 2547, 3, 1326, 663, 0, 2437, 2547, 3, 1540, 770, 0, + 2438, 2547, 3, 860, 430, 0, 2439, 2547, 3, 1528, 764, 0, 2440, 2547, 3, + 198, 99, 0, 2441, 2547, 3, 236, 118, 0, 2442, 2547, 3, 554, 277, 0, 2443, + 2547, 3, 828, 414, 0, 2444, 2547, 3, 328, 164, 0, 2445, 2547, 3, 378, 189, + 0, 2446, 2547, 3, 404, 202, 0, 2447, 2547, 3, 1016, 508, 0, 2448, 2547, + 3, 1012, 506, 0, 2449, 2547, 3, 424, 212, 0, 2450, 2547, 3, 1496, 748, + 0, 2451, 2547, 3, 1522, 761, 0, 2452, 2547, 3, 778, 389, 0, 2453, 2547, + 3, 780, 390, 0, 2454, 2547, 3, 434, 217, 0, 2455, 2547, 3, 438, 219, 0, + 2456, 2547, 3, 440, 220, 0, 2457, 2547, 3, 108, 54, 0, 2458, 2547, 3, 446, + 223, 0, 2459, 2547, 3, 458, 229, 0, 2460, 2547, 3, 786, 393, 0, 2461, 2547, + 3, 796, 398, 0, 2462, 2547, 3, 798, 399, 0, 2463, 2547, 3, 1024, 512, 0, + 2464, 2547, 3, 1002, 501, 0, 2465, 2547, 3, 954, 477, 0, 2466, 2547, 3, + 960, 480, 0, 2467, 2547, 3, 984, 492, 0, 2468, 2547, 3, 1030, 515, 0, 2469, + 2547, 3, 150, 75, 0, 2470, 2547, 3, 152, 76, 0, 2471, 2547, 3, 188, 94, + 0, 2472, 2547, 3, 174, 87, 0, 2473, 2547, 3, 1018, 509, 0, 2474, 2547, + 3, 1032, 516, 0, 2475, 2547, 3, 1034, 517, 0, 2476, 2547, 3, 194, 97, 0, + 2477, 2547, 3, 322, 161, 0, 2478, 2547, 3, 1332, 666, 0, 2479, 2547, 3, + 1328, 664, 0, 2480, 2547, 3, 1036, 518, 0, 2481, 2547, 3, 876, 438, 0, + 2482, 2547, 3, 894, 447, 0, 2483, 2547, 3, 200, 100, 0, 2484, 2547, 3, + 256, 128, 0, 2485, 2547, 3, 552, 276, 0, 2486, 2547, 3, 832, 416, 0, 2487, + 2547, 3, 1358, 679, 0, 2488, 2547, 3, 1360, 680, 0, 2489, 2547, 3, 1362, + 681, 0, 2490, 2547, 3, 1366, 683, 0, 2491, 2547, 3, 1368, 684, 0, 2492, + 2547, 3, 1520, 760, 0, 2493, 2547, 3, 1526, 763, 0, 2494, 2547, 3, 1370, + 685, 0, 2495, 2547, 3, 1372, 686, 0, 2496, 2547, 3, 1374, 687, 0, 2497, + 2547, 3, 1364, 682, 0, 2498, 2547, 3, 96, 48, 0, 2499, 2547, 3, 788, 394, + 0, 2500, 2547, 3, 742, 371, 0, 2501, 2547, 3, 746, 373, 0, 2502, 2547, + 3, 748, 374, 0, 2503, 2547, 3, 792, 396, 0, 2504, 2547, 3, 794, 397, 0, + 2505, 2547, 3, 144, 72, 0, 2506, 2547, 3, 1010, 505, 0, 2507, 2547, 3, + 964, 482, 0, 2508, 2547, 3, 982, 491, 0, 2509, 2547, 3, 178, 89, 0, 2510, + 2547, 3, 146, 73, 0, 2511, 2547, 3, 164, 82, 0, 2512, 2547, 3, 166, 83, + 0, 2513, 2547, 3, 182, 91, 0, 2514, 2547, 3, 186, 93, 0, 2515, 2547, 3, + 184, 92, 0, 2516, 2547, 3, 314, 157, 0, 2517, 2547, 3, 1330, 665, 0, 2518, + 2547, 3, 1310, 655, 0, 2519, 2547, 3, 1312, 656, 0, 2520, 2547, 3, 1314, + 657, 0, 2521, 2547, 3, 196, 98, 0, 2522, 2547, 3, 234, 117, 0, 2523, 2547, + 3, 556, 278, 0, 2524, 2547, 3, 1318, 659, 0, 2525, 2547, 3, 592, 296, 0, + 2526, 2547, 3, 668, 334, 0, 2527, 2547, 3, 1744, 872, 0, 2528, 2547, 3, + 686, 343, 0, 2529, 2547, 3, 716, 358, 0, 2530, 2547, 3, 1320, 660, 0, 2531, + 2547, 3, 1340, 670, 0, 2532, 2547, 3, 1338, 669, 0, 2533, 2547, 3, 1852, + 926, 0, 2534, 2547, 3, 744, 372, 0, 2535, 2547, 3, 750, 375, 0, 2536, 2547, + 3, 760, 380, 0, 2537, 2547, 3, 756, 378, 0, 2538, 2547, 3, 754, 377, 0, + 2539, 2547, 3, 758, 379, 0, 2540, 2547, 3, 764, 382, 0, 2541, 2547, 3, + 1864, 932, 0, 2542, 2547, 3, 1376, 688, 0, 2543, 2547, 3, 1308, 654, 0, + 2544, 2547, 3, 712, 356, 0, 2545, 2547, 3, 1834, 917, 0, 2546, 2407, 1, + 0, 0, 0, 2546, 2408, 1, 0, 0, 0, 2546, 2409, 1, 0, 0, 0, 2546, 2410, 1, + 0, 0, 0, 2546, 2411, 1, 0, 0, 0, 2546, 2412, 1, 0, 0, 0, 2546, 2413, 1, + 0, 0, 0, 2546, 2414, 1, 0, 0, 0, 2546, 2415, 1, 0, 0, 0, 2546, 2416, 1, + 0, 0, 0, 2546, 2417, 1, 0, 0, 0, 2546, 2418, 1, 0, 0, 0, 2546, 2419, 1, + 0, 0, 0, 2546, 2420, 1, 0, 0, 0, 2546, 2421, 1, 0, 0, 0, 2546, 2422, 1, + 0, 0, 0, 2546, 2423, 1, 0, 0, 0, 2546, 2424, 1, 0, 0, 0, 2546, 2425, 1, + 0, 0, 0, 2546, 2426, 1, 0, 0, 0, 2546, 2427, 1, 0, 0, 0, 2546, 2428, 1, + 0, 0, 0, 2546, 2429, 1, 0, 0, 0, 2546, 2430, 1, 0, 0, 0, 2546, 2431, 1, + 0, 0, 0, 2546, 2432, 1, 0, 0, 0, 2546, 2433, 1, 0, 0, 0, 2546, 2434, 1, + 0, 0, 0, 2546, 2435, 1, 0, 0, 0, 2546, 2436, 1, 0, 0, 0, 2546, 2437, 1, + 0, 0, 0, 2546, 2438, 1, 0, 0, 0, 2546, 2439, 1, 0, 0, 0, 2546, 2440, 1, + 0, 0, 0, 2546, 2441, 1, 0, 0, 0, 2546, 2442, 1, 0, 0, 0, 2546, 2443, 1, + 0, 0, 0, 2546, 2444, 1, 0, 0, 0, 2546, 2445, 1, 0, 0, 0, 2546, 2446, 1, + 0, 0, 0, 2546, 2447, 1, 0, 0, 0, 2546, 2448, 1, 0, 0, 0, 2546, 2449, 1, + 0, 0, 0, 2546, 2450, 1, 0, 0, 0, 2546, 2451, 1, 0, 0, 0, 2546, 2452, 1, + 0, 0, 0, 2546, 2453, 1, 0, 0, 0, 2546, 2454, 1, 0, 0, 0, 2546, 2455, 1, + 0, 0, 0, 2546, 2456, 1, 0, 0, 0, 2546, 2457, 1, 0, 0, 0, 2546, 2458, 1, + 0, 0, 0, 2546, 2459, 1, 0, 0, 0, 2546, 2460, 1, 0, 0, 0, 2546, 2461, 1, + 0, 0, 0, 2546, 2462, 1, 0, 0, 0, 2546, 2463, 1, 0, 0, 0, 2546, 2464, 1, + 0, 0, 0, 2546, 2465, 1, 0, 0, 0, 2546, 2466, 1, 0, 0, 0, 2546, 2467, 1, + 0, 0, 0, 2546, 2468, 1, 0, 0, 0, 2546, 2469, 1, 0, 0, 0, 2546, 2470, 1, + 0, 0, 0, 2546, 2471, 1, 0, 0, 0, 2546, 2472, 1, 0, 0, 0, 2546, 2473, 1, + 0, 0, 0, 2546, 2474, 1, 0, 0, 0, 2546, 2475, 1, 0, 0, 0, 2546, 2476, 1, + 0, 0, 0, 2546, 2477, 1, 0, 0, 0, 2546, 2478, 1, 0, 0, 0, 2546, 2479, 1, + 0, 0, 0, 2546, 2480, 1, 0, 0, 0, 2546, 2481, 1, 0, 0, 0, 2546, 2482, 1, + 0, 0, 0, 2546, 2483, 1, 0, 0, 0, 2546, 2484, 1, 0, 0, 0, 2546, 2485, 1, + 0, 0, 0, 2546, 2486, 1, 0, 0, 0, 2546, 2487, 1, 0, 0, 0, 2546, 2488, 1, + 0, 0, 0, 2546, 2489, 1, 0, 0, 0, 2546, 2490, 1, 0, 0, 0, 2546, 2491, 1, + 0, 0, 0, 2546, 2492, 1, 0, 0, 0, 2546, 2493, 1, 0, 0, 0, 2546, 2494, 1, + 0, 0, 0, 2546, 2495, 1, 0, 0, 0, 2546, 2496, 1, 0, 0, 0, 2546, 2497, 1, + 0, 0, 0, 2546, 2498, 1, 0, 0, 0, 2546, 2499, 1, 0, 0, 0, 2546, 2500, 1, + 0, 0, 0, 2546, 2501, 1, 0, 0, 0, 2546, 2502, 1, 0, 0, 0, 2546, 2503, 1, + 0, 0, 0, 2546, 2504, 1, 0, 0, 0, 2546, 2505, 1, 0, 0, 0, 2546, 2506, 1, + 0, 0, 0, 2546, 2507, 1, 0, 0, 0, 2546, 2508, 1, 0, 0, 0, 2546, 2509, 1, + 0, 0, 0, 2546, 2510, 1, 0, 0, 0, 2546, 2511, 1, 0, 0, 0, 2546, 2512, 1, + 0, 0, 0, 2546, 2513, 1, 0, 0, 0, 2546, 2514, 1, 0, 0, 0, 2546, 2515, 1, + 0, 0, 0, 2546, 2516, 1, 0, 0, 0, 2546, 2517, 1, 0, 0, 0, 2546, 2518, 1, + 0, 0, 0, 2546, 2519, 1, 0, 0, 0, 2546, 2520, 1, 0, 0, 0, 2546, 2521, 1, + 0, 0, 0, 2546, 2522, 1, 0, 0, 0, 2546, 2523, 1, 0, 0, 0, 2546, 2524, 1, + 0, 0, 0, 2546, 2525, 1, 0, 0, 0, 2546, 2526, 1, 0, 0, 0, 2546, 2527, 1, + 0, 0, 0, 2546, 2528, 1, 0, 0, 0, 2546, 2529, 1, 0, 0, 0, 2546, 2530, 1, + 0, 0, 0, 2546, 2531, 1, 0, 0, 0, 2546, 2532, 1, 0, 0, 0, 2546, 2533, 1, + 0, 0, 0, 2546, 2534, 1, 0, 0, 0, 2546, 2535, 1, 0, 0, 0, 2546, 2536, 1, + 0, 0, 0, 2546, 2537, 1, 0, 0, 0, 2546, 2538, 1, 0, 0, 0, 2546, 2539, 1, + 0, 0, 0, 2546, 2540, 1, 0, 0, 0, 2546, 2541, 1, 0, 0, 0, 2546, 2542, 1, + 0, 0, 0, 2546, 2543, 1, 0, 0, 0, 2546, 2544, 1, 0, 0, 0, 2546, 2545, 1, + 0, 0, 0, 2547, 3, 1, 0, 0, 0, 2548, 2549, 5, 41, 0, 0, 2549, 2603, 5, 407, + 0, 0, 2550, 2585, 3, 2378, 1189, 0, 2551, 2554, 3, 6, 3, 0, 2552, 2554, + 3, 8, 4, 0, 2553, 2551, 1, 0, 0, 0, 2553, 2552, 1, 0, 0, 0, 2554, 2555, + 1, 0, 0, 0, 2555, 2553, 1, 0, 0, 0, 2555, 2556, 1, 0, 0, 0, 2556, 2559, + 1, 0, 0, 0, 2557, 2559, 3, 10, 5, 0, 2558, 2553, 1, 0, 0, 0, 2558, 2557, + 1, 0, 0, 0, 2559, 2561, 1, 0, 0, 0, 2560, 2562, 3, 24, 12, 0, 2561, 2560, + 1, 0, 0, 0, 2561, 2562, 1, 0, 0, 0, 2562, 2586, 1, 0, 0, 0, 2563, 2584, + 3, 12, 6, 0, 2564, 2584, 3, 16, 8, 0, 2565, 2584, 3, 18, 9, 0, 2566, 2584, + 3, 20, 10, 0, 2567, 2584, 3, 24, 12, 0, 2568, 2584, 3, 28, 14, 0, 2569, + 2584, 3, 30, 15, 0, 2570, 2584, 3, 40, 20, 0, 2571, 2584, 3, 44, 22, 0, + 2572, 2584, 3, 46, 23, 0, 2573, 2584, 3, 52, 26, 0, 2574, 2584, 3, 58, + 29, 0, 2575, 2584, 3, 60, 30, 0, 2576, 2584, 3, 62, 31, 0, 2577, 2584, + 3, 64, 32, 0, 2578, 2584, 3, 66, 33, 0, 2579, 2584, 3, 68, 34, 0, 2580, + 2584, 3, 70, 35, 0, 2581, 2584, 3, 72, 36, 0, 2582, 2584, 3, 78, 39, 0, + 2583, 2563, 1, 0, 0, 0, 2583, 2564, 1, 0, 0, 0, 2583, 2565, 1, 0, 0, 0, + 2583, 2566, 1, 0, 0, 0, 2583, 2567, 1, 0, 0, 0, 2583, 2568, 1, 0, 0, 0, + 2583, 2569, 1, 0, 0, 0, 2583, 2570, 1, 0, 0, 0, 2583, 2571, 1, 0, 0, 0, + 2583, 2572, 1, 0, 0, 0, 2583, 2573, 1, 0, 0, 0, 2583, 2574, 1, 0, 0, 0, + 2583, 2575, 1, 0, 0, 0, 2583, 2576, 1, 0, 0, 0, 2583, 2577, 1, 0, 0, 0, + 2583, 2578, 1, 0, 0, 0, 2583, 2579, 1, 0, 0, 0, 2583, 2580, 1, 0, 0, 0, + 2583, 2581, 1, 0, 0, 0, 2583, 2582, 1, 0, 0, 0, 2584, 2586, 1, 0, 0, 0, + 2585, 2558, 1, 0, 0, 0, 2585, 2583, 1, 0, 0, 0, 2586, 2604, 1, 0, 0, 0, + 2587, 2592, 3, 2378, 1189, 0, 2588, 2589, 5, 2382, 0, 0, 2589, 2591, 3, + 2378, 1189, 0, 2590, 2588, 1, 0, 0, 0, 2591, 2594, 1, 0, 0, 0, 2592, 2590, + 1, 0, 0, 0, 2592, 2593, 1, 0, 0, 0, 2593, 2597, 1, 0, 0, 0, 2594, 2592, + 1, 0, 0, 0, 2595, 2597, 5, 37, 0, 0, 2596, 2587, 1, 0, 0, 0, 2596, 2595, + 1, 0, 0, 0, 2597, 2601, 1, 0, 0, 0, 2598, 2602, 3, 90, 45, 0, 2599, 2602, + 3, 92, 46, 0, 2600, 2602, 3, 94, 47, 0, 2601, 2598, 1, 0, 0, 0, 2601, 2599, + 1, 0, 0, 0, 2601, 2600, 1, 0, 0, 0, 2602, 2604, 1, 0, 0, 0, 2603, 2550, + 1, 0, 0, 0, 2603, 2596, 1, 0, 0, 0, 2604, 5, 1, 0, 0, 0, 2605, 2626, 5, + 20, 0, 0, 2606, 2607, 5, 1584, 0, 0, 2607, 2609, 3, 2378, 1189, 0, 2608, + 2606, 1, 0, 0, 0, 2608, 2609, 1, 0, 0, 0, 2609, 2611, 1, 0, 0, 0, 2610, + 2612, 3, 88, 44, 0, 2611, 2610, 1, 0, 0, 0, 2611, 2612, 1, 0, 0, 0, 2612, + 2615, 1, 0, 0, 0, 2613, 2614, 5, 519, 0, 0, 2614, 2616, 3, 2378, 1189, + 0, 2615, 2613, 1, 0, 0, 0, 2615, 2616, 1, 0, 0, 0, 2616, 2617, 1, 0, 0, + 0, 2617, 2618, 5, 406, 0, 0, 2618, 2623, 3, 436, 218, 0, 2619, 2620, 5, + 2382, 0, 0, 2620, 2622, 3, 436, 218, 0, 2621, 2619, 1, 0, 0, 0, 2622, 2625, + 1, 0, 0, 0, 2623, 2621, 1, 0, 0, 0, 2623, 2624, 1, 0, 0, 0, 2624, 2627, + 1, 0, 0, 0, 2625, 2623, 1, 0, 0, 0, 2626, 2608, 1, 0, 0, 0, 2627, 2628, + 1, 0, 0, 0, 2628, 2626, 1, 0, 0, 0, 2628, 2629, 1, 0, 0, 0, 2629, 7, 1, + 0, 0, 0, 2630, 2669, 5, 425, 0, 0, 2631, 2633, 3, 88, 44, 0, 2632, 2631, + 1, 0, 0, 0, 2632, 2633, 1, 0, 0, 0, 2633, 2634, 1, 0, 0, 0, 2634, 2635, + 5, 406, 0, 0, 2635, 2637, 3, 2378, 1189, 0, 2636, 2638, 3, 38, 19, 0, 2637, + 2636, 1, 0, 0, 0, 2637, 2638, 1, 0, 0, 0, 2638, 2646, 1, 0, 0, 0, 2639, + 2640, 5, 2382, 0, 0, 2640, 2642, 3, 2378, 1189, 0, 2641, 2643, 3, 38, 19, + 0, 2642, 2641, 1, 0, 0, 0, 2642, 2643, 1, 0, 0, 0, 2643, 2645, 1, 0, 0, + 0, 2644, 2639, 1, 0, 0, 0, 2645, 2648, 1, 0, 0, 0, 2646, 2644, 1, 0, 0, + 0, 2646, 2647, 1, 0, 0, 0, 2647, 2670, 1, 0, 0, 0, 2648, 2646, 1, 0, 0, + 0, 2649, 2650, 5, 408, 0, 0, 2650, 2652, 5, 680, 0, 0, 2651, 2653, 3, 88, + 44, 0, 2652, 2651, 1, 0, 0, 0, 2652, 2653, 1, 0, 0, 0, 2653, 2654, 1, 0, + 0, 0, 2654, 2655, 5, 519, 0, 0, 2655, 2657, 3, 2378, 1189, 0, 2656, 2658, + 3, 38, 19, 0, 2657, 2656, 1, 0, 0, 0, 2657, 2658, 1, 0, 0, 0, 2658, 2666, + 1, 0, 0, 0, 2659, 2660, 5, 2382, 0, 0, 2660, 2662, 3, 2378, 1189, 0, 2661, + 2663, 3, 38, 19, 0, 2662, 2661, 1, 0, 0, 0, 2662, 2663, 1, 0, 0, 0, 2663, + 2665, 1, 0, 0, 0, 2664, 2659, 1, 0, 0, 0, 2665, 2668, 1, 0, 0, 0, 2666, + 2664, 1, 0, 0, 0, 2666, 2667, 1, 0, 0, 0, 2667, 2670, 1, 0, 0, 0, 2668, + 2666, 1, 0, 0, 0, 2669, 2632, 1, 0, 0, 0, 2669, 2649, 1, 0, 0, 0, 2670, + 9, 1, 0, 0, 0, 2671, 2672, 5, 1468, 0, 0, 2672, 2675, 5, 37, 0, 0, 2673, + 2674, 5, 1595, 0, 0, 2674, 2676, 3, 1170, 585, 0, 2675, 2673, 1, 0, 0, + 0, 2675, 2676, 1, 0, 0, 0, 2676, 11, 1, 0, 0, 0, 2677, 2678, 5, 1463, 0, + 0, 2678, 2679, 5, 406, 0, 0, 2679, 2680, 3, 2378, 1189, 0, 2680, 2681, + 5, 2188, 0, 0, 2681, 2683, 5, 2372, 0, 0, 2682, 2684, 3, 38, 19, 0, 2683, + 2682, 1, 0, 0, 0, 2683, 2684, 1, 0, 0, 0, 2684, 2694, 1, 0, 0, 0, 2685, + 2686, 5, 2382, 0, 0, 2686, 2687, 3, 2378, 1189, 0, 2687, 2688, 5, 2188, + 0, 0, 2688, 2690, 5, 2372, 0, 0, 2689, 2691, 3, 38, 19, 0, 2690, 2689, + 1, 0, 0, 0, 2690, 2691, 1, 0, 0, 0, 2691, 2693, 1, 0, 0, 0, 2692, 2685, + 1, 0, 0, 0, 2693, 2696, 1, 0, 0, 0, 2694, 2692, 1, 0, 0, 0, 2694, 2695, + 1, 0, 0, 0, 2695, 2699, 1, 0, 0, 0, 2696, 2694, 1, 0, 0, 0, 2697, 2698, + 5, 1329, 0, 0, 2698, 2700, 3, 2368, 1184, 0, 2699, 2697, 1, 0, 0, 0, 2699, + 2700, 1, 0, 0, 0, 2700, 2702, 1, 0, 0, 0, 2701, 2703, 3, 14, 7, 0, 2702, + 2701, 1, 0, 0, 0, 2702, 2703, 1, 0, 0, 0, 2703, 13, 1, 0, 0, 0, 2704, 2705, + 7, 0, 0, 0, 2705, 15, 1, 0, 0, 0, 2706, 2723, 5, 1460, 0, 0, 2707, 2708, + 5, 406, 0, 0, 2708, 2709, 3, 2378, 1189, 0, 2709, 2710, 5, 2029, 0, 0, + 2710, 2718, 3, 2378, 1189, 0, 2711, 2712, 5, 2382, 0, 0, 2712, 2713, 3, + 2378, 1189, 0, 2713, 2714, 5, 2029, 0, 0, 2714, 2715, 3, 2378, 1189, 0, + 2715, 2717, 1, 0, 0, 0, 2716, 2711, 1, 0, 0, 0, 2717, 2720, 1, 0, 0, 0, + 2718, 2716, 1, 0, 0, 0, 2718, 2719, 1, 0, 0, 0, 2719, 2724, 1, 0, 0, 0, + 2720, 2718, 1, 0, 0, 0, 2721, 2722, 5, 408, 0, 0, 2722, 2724, 5, 37, 0, + 0, 2723, 2707, 1, 0, 0, 0, 2723, 2721, 1, 0, 0, 0, 2724, 17, 1, 0, 0, 0, + 2725, 2757, 5, 1173, 0, 0, 2726, 2728, 3, 88, 44, 0, 2727, 2726, 1, 0, + 0, 0, 2727, 2728, 1, 0, 0, 0, 2728, 2729, 1, 0, 0, 0, 2729, 2730, 5, 406, + 0, 0, 2730, 2735, 3, 2378, 1189, 0, 2731, 2732, 5, 2382, 0, 0, 2732, 2734, + 3, 2378, 1189, 0, 2733, 2731, 1, 0, 0, 0, 2734, 2737, 1, 0, 0, 0, 2735, + 2733, 1, 0, 0, 0, 2735, 2736, 1, 0, 0, 0, 2736, 2753, 1, 0, 0, 0, 2737, + 2735, 1, 0, 0, 0, 2738, 2739, 5, 408, 0, 0, 2739, 2741, 5, 680, 0, 0, 2740, + 2742, 3, 88, 44, 0, 2741, 2740, 1, 0, 0, 0, 2741, 2742, 1, 0, 0, 0, 2742, + 2743, 1, 0, 0, 0, 2743, 2744, 5, 519, 0, 0, 2744, 2749, 3, 2378, 1189, + 0, 2745, 2746, 5, 2382, 0, 0, 2746, 2748, 3, 2378, 1189, 0, 2747, 2745, + 1, 0, 0, 0, 2748, 2751, 1, 0, 0, 0, 2749, 2747, 1, 0, 0, 0, 2749, 2750, + 1, 0, 0, 0, 2750, 2753, 1, 0, 0, 0, 2751, 2749, 1, 0, 0, 0, 2752, 2727, + 1, 0, 0, 0, 2752, 2738, 1, 0, 0, 0, 2753, 2754, 1, 0, 0, 0, 2754, 2752, + 1, 0, 0, 0, 2754, 2755, 1, 0, 0, 0, 2755, 2758, 1, 0, 0, 0, 2756, 2758, + 5, 37, 0, 0, 2757, 2752, 1, 0, 0, 0, 2757, 2756, 1, 0, 0, 0, 2758, 2761, + 1, 0, 0, 0, 2759, 2760, 5, 1329, 0, 0, 2760, 2762, 3, 2368, 1184, 0, 2761, + 2759, 1, 0, 0, 0, 2761, 2762, 1, 0, 0, 0, 2762, 2764, 1, 0, 0, 0, 2763, + 2765, 3, 14, 7, 0, 2764, 2763, 1, 0, 0, 0, 2764, 2765, 1, 0, 0, 0, 2765, + 19, 1, 0, 0, 0, 2766, 2793, 5, 1160, 0, 0, 2767, 2769, 3, 88, 44, 0, 2768, + 2767, 1, 0, 0, 0, 2768, 2769, 1, 0, 0, 0, 2769, 2770, 1, 0, 0, 0, 2770, + 2771, 5, 406, 0, 0, 2771, 2776, 3, 2378, 1189, 0, 2772, 2773, 5, 2382, + 0, 0, 2773, 2775, 3, 2378, 1189, 0, 2774, 2772, 1, 0, 0, 0, 2775, 2778, + 1, 0, 0, 0, 2776, 2774, 1, 0, 0, 0, 2776, 2777, 1, 0, 0, 0, 2777, 2794, + 1, 0, 0, 0, 2778, 2776, 1, 0, 0, 0, 2779, 2780, 5, 408, 0, 0, 2780, 2782, + 5, 680, 0, 0, 2781, 2783, 3, 88, 44, 0, 2782, 2781, 1, 0, 0, 0, 2782, 2783, + 1, 0, 0, 0, 2783, 2784, 1, 0, 0, 0, 2784, 2785, 5, 519, 0, 0, 2785, 2790, + 3, 2378, 1189, 0, 2786, 2787, 5, 2382, 0, 0, 2787, 2789, 3, 2378, 1189, + 0, 2788, 2786, 1, 0, 0, 0, 2789, 2792, 1, 0, 0, 0, 2790, 2788, 1, 0, 0, + 0, 2790, 2791, 1, 0, 0, 0, 2791, 2794, 1, 0, 0, 0, 2792, 2790, 1, 0, 0, + 0, 2793, 2768, 1, 0, 0, 0, 2793, 2779, 1, 0, 0, 0, 2794, 2796, 1, 0, 0, + 0, 2795, 2797, 3, 22, 11, 0, 2796, 2795, 1, 0, 0, 0, 2796, 2797, 1, 0, + 0, 0, 2797, 21, 1, 0, 0, 0, 2798, 2799, 5, 425, 0, 0, 2799, 2800, 5, 32, + 0, 0, 2800, 2801, 3, 2368, 1184, 0, 2801, 2802, 7, 1, 0, 0, 2802, 23, 1, + 0, 0, 0, 2803, 2823, 5, 1412, 0, 0, 2804, 2806, 7, 2, 0, 0, 2805, 2807, + 3, 26, 13, 0, 2806, 2805, 1, 0, 0, 0, 2807, 2808, 1, 0, 0, 0, 2808, 2806, + 1, 0, 0, 0, 2808, 2809, 1, 0, 0, 0, 2809, 2811, 1, 0, 0, 0, 2810, 2804, + 1, 0, 0, 0, 2810, 2811, 1, 0, 0, 0, 2811, 2812, 1, 0, 0, 0, 2812, 2813, + 5, 1329, 0, 0, 2813, 2814, 3, 2368, 1184, 0, 2814, 2816, 1, 0, 0, 0, 2815, + 2817, 7, 0, 0, 0, 2816, 2815, 1, 0, 0, 0, 2816, 2817, 1, 0, 0, 0, 2817, + 2824, 1, 0, 0, 0, 2818, 2819, 5, 909, 0, 0, 2819, 2821, 5, 1329, 0, 0, + 2820, 2822, 3, 2368, 1184, 0, 2821, 2820, 1, 0, 0, 0, 2821, 2822, 1, 0, + 0, 0, 2822, 2824, 1, 0, 0, 0, 2823, 2810, 1, 0, 0, 0, 2823, 2818, 1, 0, + 0, 0, 2824, 25, 1, 0, 0, 0, 2825, 2826, 3, 2378, 1189, 0, 2826, 27, 1, + 0, 0, 0, 2827, 2829, 5, 186, 0, 0, 2828, 2830, 5, 37, 0, 0, 2829, 2828, + 1, 0, 0, 0, 2829, 2830, 1, 0, 0, 0, 2830, 2832, 1, 0, 0, 0, 2831, 2833, + 7, 3, 0, 0, 2832, 2831, 1, 0, 0, 0, 2832, 2833, 1, 0, 0, 0, 2833, 29, 1, + 0, 0, 0, 2834, 2835, 7, 4, 0, 0, 2835, 2836, 5, 1983, 0, 0, 2836, 2837, + 3, 2378, 1189, 0, 2837, 2844, 3, 32, 16, 0, 2838, 2839, 5, 2382, 0, 0, + 2839, 2840, 3, 2378, 1189, 0, 2840, 2841, 3, 32, 16, 0, 2841, 2843, 1, + 0, 0, 0, 2842, 2838, 1, 0, 0, 0, 2843, 2846, 1, 0, 0, 0, 2844, 2842, 1, + 0, 0, 0, 2844, 2845, 1, 0, 0, 0, 2845, 2858, 1, 0, 0, 0, 2846, 2844, 1, + 0, 0, 0, 2847, 2848, 5, 425, 0, 0, 2848, 2849, 5, 1983, 0, 0, 2849, 2854, + 3, 2378, 1189, 0, 2850, 2851, 5, 2382, 0, 0, 2851, 2853, 3, 2378, 1189, + 0, 2852, 2850, 1, 0, 0, 0, 2853, 2856, 1, 0, 0, 0, 2854, 2852, 1, 0, 0, + 0, 2854, 2855, 1, 0, 0, 0, 2855, 2858, 1, 0, 0, 0, 2856, 2854, 1, 0, 0, + 0, 2857, 2834, 1, 0, 0, 0, 2857, 2847, 1, 0, 0, 0, 2858, 31, 1, 0, 0, 0, + 2859, 2860, 5, 81, 0, 0, 2860, 2862, 5, 2376, 0, 0, 2861, 2863, 3, 34, + 17, 0, 2862, 2861, 1, 0, 0, 0, 2862, 2863, 1, 0, 0, 0, 2863, 2865, 1, 0, + 0, 0, 2864, 2866, 3, 36, 18, 0, 2865, 2864, 1, 0, 0, 0, 2865, 2866, 1, + 0, 0, 0, 2866, 2867, 1, 0, 0, 0, 2867, 2868, 5, 2377, 0, 0, 2868, 33, 1, + 0, 0, 0, 2869, 2870, 7, 5, 0, 0, 2870, 35, 1, 0, 0, 0, 2871, 2872, 7, 6, + 0, 0, 2872, 37, 1, 0, 0, 0, 2873, 2874, 7, 7, 0, 0, 2874, 39, 1, 0, 0, + 0, 2875, 2876, 5, 20, 0, 0, 2876, 2877, 5, 395, 0, 0, 2877, 2882, 3, 1472, + 736, 0, 2878, 2879, 5, 2382, 0, 0, 2879, 2881, 3, 1472, 736, 0, 2880, 2878, + 1, 0, 0, 0, 2881, 2884, 1, 0, 0, 0, 2882, 2880, 1, 0, 0, 0, 2882, 2883, + 1, 0, 0, 0, 2883, 2917, 1, 0, 0, 0, 2884, 2882, 1, 0, 0, 0, 2885, 2886, + 5, 425, 0, 0, 2886, 2887, 5, 395, 0, 0, 2887, 2889, 3, 1472, 736, 0, 2888, + 2890, 3, 38, 19, 0, 2889, 2888, 1, 0, 0, 0, 2889, 2890, 1, 0, 0, 0, 2890, + 2898, 1, 0, 0, 0, 2891, 2892, 5, 2382, 0, 0, 2892, 2894, 3, 1472, 736, + 0, 2893, 2895, 3, 38, 19, 0, 2894, 2893, 1, 0, 0, 0, 2894, 2895, 1, 0, + 0, 0, 2895, 2897, 1, 0, 0, 0, 2896, 2891, 1, 0, 0, 0, 2897, 2900, 1, 0, + 0, 0, 2898, 2896, 1, 0, 0, 0, 2898, 2899, 1, 0, 0, 0, 2899, 2917, 1, 0, + 0, 0, 2900, 2898, 1, 0, 0, 0, 2901, 2902, 5, 1460, 0, 0, 2902, 2903, 5, + 395, 0, 0, 2903, 2904, 3, 42, 21, 0, 2904, 2905, 5, 2029, 0, 0, 2905, 2913, + 3, 42, 21, 0, 2906, 2907, 5, 2382, 0, 0, 2907, 2908, 3, 42, 21, 0, 2908, + 2909, 5, 2029, 0, 0, 2909, 2910, 3, 42, 21, 0, 2910, 2912, 1, 0, 0, 0, + 2911, 2906, 1, 0, 0, 0, 2912, 2915, 1, 0, 0, 0, 2913, 2911, 1, 0, 0, 0, + 2913, 2914, 1, 0, 0, 0, 2914, 2917, 1, 0, 0, 0, 2915, 2913, 1, 0, 0, 0, + 2916, 2875, 1, 0, 0, 0, 2916, 2885, 1, 0, 0, 0, 2916, 2901, 1, 0, 0, 0, + 2917, 41, 1, 0, 0, 0, 2918, 2919, 5, 2372, 0, 0, 2919, 43, 1, 0, 0, 0, + 2920, 2921, 5, 20, 0, 0, 2921, 2922, 5, 36, 0, 0, 2922, 2923, 5, 2372, + 0, 0, 2923, 2924, 5, 564, 0, 0, 2924, 2931, 5, 2372, 0, 0, 2925, 2926, + 5, 2382, 0, 0, 2926, 2927, 5, 2372, 0, 0, 2927, 2928, 5, 564, 0, 0, 2928, + 2930, 5, 2372, 0, 0, 2929, 2925, 1, 0, 0, 0, 2930, 2933, 1, 0, 0, 0, 2931, + 2929, 1, 0, 0, 0, 2931, 2932, 1, 0, 0, 0, 2932, 2959, 1, 0, 0, 0, 2933, + 2931, 1, 0, 0, 0, 2934, 2935, 5, 425, 0, 0, 2935, 2936, 5, 36, 0, 0, 2936, + 2941, 5, 2372, 0, 0, 2937, 2938, 5, 2382, 0, 0, 2938, 2940, 5, 2372, 0, + 0, 2939, 2937, 1, 0, 0, 0, 2940, 2943, 1, 0, 0, 0, 2941, 2939, 1, 0, 0, + 0, 2941, 2942, 1, 0, 0, 0, 2942, 2959, 1, 0, 0, 0, 2943, 2941, 1, 0, 0, + 0, 2944, 2945, 5, 1460, 0, 0, 2945, 2946, 5, 36, 0, 0, 2946, 2947, 5, 2372, + 0, 0, 2947, 2948, 5, 2029, 0, 0, 2948, 2955, 5, 2372, 0, 0, 2949, 2950, + 5, 2382, 0, 0, 2950, 2951, 5, 2372, 0, 0, 2951, 2952, 5, 2029, 0, 0, 2952, + 2954, 5, 2372, 0, 0, 2953, 2949, 1, 0, 0, 0, 2954, 2957, 1, 0, 0, 0, 2955, + 2953, 1, 0, 0, 0, 2955, 2956, 1, 0, 0, 0, 2956, 2959, 1, 0, 0, 0, 2957, + 2955, 1, 0, 0, 0, 2958, 2920, 1, 0, 0, 0, 2958, 2934, 1, 0, 0, 0, 2958, + 2944, 1, 0, 0, 0, 2959, 45, 1, 0, 0, 0, 2960, 2972, 3, 48, 24, 0, 2961, + 2972, 3, 50, 25, 0, 2962, 2963, 5, 1468, 0, 0, 2963, 2964, 5, 2171, 0, + 0, 2964, 2965, 3, 2378, 1189, 0, 2965, 2966, 5, 1595, 0, 0, 2966, 2967, + 3, 1170, 585, 0, 2967, 2972, 1, 0, 0, 0, 2968, 2969, 5, 425, 0, 0, 2969, + 2970, 5, 2171, 0, 0, 2970, 2972, 3, 2378, 1189, 0, 2971, 2960, 1, 0, 0, + 0, 2971, 2961, 1, 0, 0, 0, 2971, 2962, 1, 0, 0, 0, 2971, 2968, 1, 0, 0, + 0, 2972, 47, 1, 0, 0, 0, 2973, 2974, 5, 20, 0, 0, 2974, 2975, 5, 2171, + 0, 0, 2975, 2976, 3, 2378, 1189, 0, 2976, 2977, 5, 1595, 0, 0, 2977, 2979, + 3, 1170, 585, 0, 2978, 2980, 3, 34, 17, 0, 2979, 2978, 1, 0, 0, 0, 2979, + 2980, 1, 0, 0, 0, 2980, 2985, 1, 0, 0, 0, 2981, 2982, 5, 1662, 0, 0, 2982, + 2983, 3, 2368, 1184, 0, 2983, 2984, 7, 8, 0, 0, 2984, 2986, 1, 0, 0, 0, + 2985, 2981, 1, 0, 0, 0, 2985, 2986, 1, 0, 0, 0, 2986, 2989, 1, 0, 0, 0, + 2987, 2988, 5, 1661, 0, 0, 2988, 2990, 3, 2368, 1184, 0, 2989, 2987, 1, + 0, 0, 0, 2989, 2990, 1, 0, 0, 0, 2990, 49, 1, 0, 0, 0, 2991, 2992, 5, 909, + 0, 0, 2992, 2993, 5, 2171, 0, 0, 2993, 2996, 3, 2378, 1189, 0, 2994, 2995, + 5, 918, 0, 0, 2995, 2997, 5, 2372, 0, 0, 2996, 2994, 1, 0, 0, 0, 2996, + 2997, 1, 0, 0, 0, 2997, 3000, 1, 0, 0, 0, 2998, 2999, 5, 2100, 0, 0, 2999, + 3001, 5, 2372, 0, 0, 3000, 2998, 1, 0, 0, 0, 3000, 3001, 1, 0, 0, 0, 3001, + 51, 1, 0, 0, 0, 3002, 3003, 5, 1568, 0, 0, 3003, 3004, 5, 80, 0, 0, 3004, + 3005, 5, 2372, 0, 0, 3005, 3006, 5, 2398, 0, 0, 3006, 3007, 5, 2372, 0, + 0, 3007, 53, 1, 0, 0, 0, 3008, 3009, 5, 909, 0, 0, 3009, 3010, 5, 534, + 0, 0, 3010, 3011, 5, 2372, 0, 0, 3011, 3012, 5, 80, 0, 0, 3012, 3013, 5, + 2376, 0, 0, 3013, 3014, 3, 56, 28, 0, 3014, 3024, 5, 2377, 0, 0, 3015, + 3016, 5, 2382, 0, 0, 3016, 3017, 5, 2372, 0, 0, 3017, 3018, 5, 80, 0, 0, + 3018, 3019, 5, 2376, 0, 0, 3019, 3020, 3, 56, 28, 0, 3020, 3021, 5, 2377, + 0, 0, 3021, 3023, 1, 0, 0, 0, 3022, 3015, 1, 0, 0, 0, 3023, 3026, 1, 0, + 0, 0, 3024, 3022, 1, 0, 0, 0, 3024, 3025, 1, 0, 0, 0, 3025, 55, 1, 0, 0, + 0, 3026, 3024, 1, 0, 0, 0, 3027, 3028, 1, 0, 0, 0, 3028, 57, 1, 0, 0, 0, + 3029, 3030, 5, 425, 0, 0, 3030, 3031, 5, 534, 0, 0, 3031, 3036, 3, 1472, + 736, 0, 3032, 3033, 5, 2382, 0, 0, 3033, 3035, 3, 1472, 736, 0, 3034, 3032, + 1, 0, 0, 0, 3035, 3038, 1, 0, 0, 0, 3036, 3034, 1, 0, 0, 0, 3036, 3037, + 1, 0, 0, 0, 3037, 59, 1, 0, 0, 0, 3038, 3036, 1, 0, 0, 0, 3039, 3040, 5, + 281, 0, 0, 3040, 3041, 5, 1425, 0, 0, 3041, 3042, 5, 2029, 0, 0, 3042, + 3043, 5, 553, 0, 0, 3043, 61, 1, 0, 0, 0, 3044, 3045, 5, 20, 0, 0, 3045, + 3046, 5, 2117, 0, 0, 3046, 3047, 5, 2372, 0, 0, 3047, 3048, 5, 2188, 0, + 0, 3048, 3049, 5, 865, 0, 0, 3049, 3054, 5, 2372, 0, 0, 3050, 3051, 5, + 2382, 0, 0, 3051, 3053, 5, 2372, 0, 0, 3052, 3050, 1, 0, 0, 0, 3053, 3056, + 1, 0, 0, 0, 3054, 3052, 1, 0, 0, 0, 3054, 3055, 1, 0, 0, 0, 3055, 3074, + 1, 0, 0, 0, 3056, 3054, 1, 0, 0, 0, 3057, 3058, 5, 909, 0, 0, 3058, 3059, + 5, 2117, 0, 0, 3059, 3060, 5, 2372, 0, 0, 3060, 3061, 7, 9, 0, 0, 3061, + 3062, 5, 865, 0, 0, 3062, 3067, 5, 2372, 0, 0, 3063, 3064, 5, 2382, 0, + 0, 3064, 3066, 5, 2372, 0, 0, 3065, 3063, 1, 0, 0, 0, 3066, 3069, 1, 0, + 0, 0, 3067, 3065, 1, 0, 0, 0, 3067, 3068, 1, 0, 0, 0, 3068, 3074, 1, 0, + 0, 0, 3069, 3067, 1, 0, 0, 0, 3070, 3071, 5, 425, 0, 0, 3071, 3072, 5, + 2117, 0, 0, 3072, 3074, 5, 2372, 0, 0, 3073, 3044, 1, 0, 0, 0, 3073, 3057, + 1, 0, 0, 0, 3073, 3070, 1, 0, 0, 0, 3074, 63, 1, 0, 0, 0, 3075, 3076, 5, + 20, 0, 0, 3076, 3077, 5, 2121, 0, 0, 3077, 3082, 5, 2372, 0, 0, 3078, 3079, + 5, 2382, 0, 0, 3079, 3081, 5, 2372, 0, 0, 3080, 3078, 1, 0, 0, 0, 3081, + 3084, 1, 0, 0, 0, 3082, 3080, 1, 0, 0, 0, 3082, 3083, 1, 0, 0, 0, 3083, + 3113, 1, 0, 0, 0, 3084, 3082, 1, 0, 0, 0, 3085, 3086, 5, 425, 0, 0, 3086, + 3087, 5, 2121, 0, 0, 3087, 3092, 5, 2372, 0, 0, 3088, 3089, 5, 2382, 0, + 0, 3089, 3091, 5, 2372, 0, 0, 3090, 3088, 1, 0, 0, 0, 3091, 3094, 1, 0, + 0, 0, 3092, 3090, 1, 0, 0, 0, 3092, 3093, 1, 0, 0, 0, 3093, 3096, 1, 0, + 0, 0, 3094, 3092, 1, 0, 0, 0, 3095, 3097, 5, 168, 0, 0, 3096, 3095, 1, + 0, 0, 0, 3096, 3097, 1, 0, 0, 0, 3097, 3113, 1, 0, 0, 0, 3098, 3099, 5, + 1463, 0, 0, 3099, 3100, 5, 2121, 0, 0, 3100, 3101, 5, 2372, 0, 0, 3101, + 3102, 5, 2188, 0, 0, 3102, 3109, 5, 2372, 0, 0, 3103, 3104, 5, 2382, 0, + 0, 3104, 3105, 5, 2372, 0, 0, 3105, 3106, 5, 2188, 0, 0, 3106, 3108, 5, + 2372, 0, 0, 3107, 3103, 1, 0, 0, 0, 3108, 3111, 1, 0, 0, 0, 3109, 3107, + 1, 0, 0, 0, 3109, 3110, 1, 0, 0, 0, 3110, 3113, 1, 0, 0, 0, 3111, 3109, + 1, 0, 0, 0, 3112, 3075, 1, 0, 0, 0, 3112, 3085, 1, 0, 0, 0, 3112, 3098, + 1, 0, 0, 0, 3113, 65, 1, 0, 0, 0, 3114, 3115, 5, 1568, 0, 0, 3115, 3116, + 5, 1294, 0, 0, 3116, 3117, 7, 10, 0, 0, 3117, 3121, 5, 2398, 0, 0, 3118, + 3122, 5, 1054, 0, 0, 3119, 3120, 5, 1408, 0, 0, 3120, 3122, 7, 11, 0, 0, + 3121, 3118, 1, 0, 0, 0, 3121, 3119, 1, 0, 0, 0, 3122, 3133, 1, 0, 0, 0, + 3123, 3124, 5, 2382, 0, 0, 3124, 3125, 7, 10, 0, 0, 3125, 3129, 5, 2398, + 0, 0, 3126, 3130, 5, 1054, 0, 0, 3127, 3128, 5, 1408, 0, 0, 3128, 3130, + 7, 11, 0, 0, 3129, 3126, 1, 0, 0, 0, 3129, 3127, 1, 0, 0, 0, 3130, 3132, + 1, 0, 0, 0, 3131, 3123, 1, 0, 0, 0, 3132, 3135, 1, 0, 0, 0, 3133, 3131, + 1, 0, 0, 0, 3133, 3134, 1, 0, 0, 0, 3134, 3136, 1, 0, 0, 0, 3135, 3133, + 1, 0, 0, 0, 3136, 3137, 5, 564, 0, 0, 3137, 3138, 5, 534, 0, 0, 3138, 3143, + 5, 2372, 0, 0, 3139, 3140, 5, 2382, 0, 0, 3140, 3142, 5, 2372, 0, 0, 3141, + 3139, 1, 0, 0, 0, 3142, 3145, 1, 0, 0, 0, 3143, 3141, 1, 0, 0, 0, 3143, + 3144, 1, 0, 0, 0, 3144, 67, 1, 0, 0, 0, 3145, 3143, 1, 0, 0, 0, 3146, 3147, + 5, 1568, 0, 0, 3147, 3148, 5, 1236, 0, 0, 3148, 3149, 7, 12, 0, 0, 3149, + 3150, 5, 2398, 0, 0, 3150, 3157, 5, 2372, 0, 0, 3151, 3152, 5, 2382, 0, + 0, 3152, 3153, 7, 12, 0, 0, 3153, 3154, 5, 2398, 0, 0, 3154, 3156, 5, 2372, + 0, 0, 3155, 3151, 1, 0, 0, 0, 3156, 3159, 1, 0, 0, 0, 3157, 3155, 1, 0, + 0, 0, 3157, 3158, 1, 0, 0, 0, 3158, 3160, 1, 0, 0, 0, 3159, 3157, 1, 0, + 0, 0, 3160, 3161, 5, 564, 0, 0, 3161, 3162, 5, 534, 0, 0, 3162, 3167, 5, + 2372, 0, 0, 3163, 3164, 5, 2382, 0, 0, 3164, 3166, 5, 2372, 0, 0, 3165, + 3163, 1, 0, 0, 0, 3166, 3169, 1, 0, 0, 0, 3167, 3165, 1, 0, 0, 0, 3167, + 3168, 1, 0, 0, 0, 3168, 69, 1, 0, 0, 0, 3169, 3167, 1, 0, 0, 0, 3170, 3175, + 5, 1530, 0, 0, 3171, 3172, 5, 534, 0, 0, 3172, 3176, 5, 2372, 0, 0, 3173, + 3174, 5, 406, 0, 0, 3174, 3176, 3, 2378, 1189, 0, 3175, 3171, 1, 0, 0, + 0, 3175, 3173, 1, 0, 0, 0, 3175, 3176, 1, 0, 0, 0, 3176, 3178, 1, 0, 0, + 0, 3177, 3179, 7, 3, 0, 0, 3178, 3177, 1, 0, 0, 0, 3178, 3179, 1, 0, 0, + 0, 3179, 3182, 1, 0, 0, 0, 3180, 3181, 5, 1329, 0, 0, 3181, 3183, 7, 13, + 0, 0, 3182, 3180, 1, 0, 0, 0, 3182, 3183, 1, 0, 0, 0, 3183, 3185, 1, 0, + 0, 0, 3184, 3186, 3, 14, 7, 0, 3185, 3184, 1, 0, 0, 0, 3185, 3186, 1, 0, + 0, 0, 3186, 3188, 1, 0, 0, 0, 3187, 3189, 3, 38, 19, 0, 3188, 3187, 1, + 0, 0, 0, 3188, 3189, 1, 0, 0, 0, 3189, 3191, 1, 0, 0, 0, 3190, 3192, 5, + 1654, 0, 0, 3191, 3190, 1, 0, 0, 0, 3191, 3192, 1, 0, 0, 0, 3192, 71, 1, + 0, 0, 0, 3193, 3194, 5, 20, 0, 0, 3194, 3195, 5, 1395, 0, 0, 3195, 3201, + 3, 2378, 1189, 0, 3196, 3197, 5, 1568, 0, 0, 3197, 3198, 3, 74, 37, 0, + 3198, 3199, 5, 2398, 0, 0, 3199, 3200, 3, 76, 38, 0, 3200, 3202, 1, 0, + 0, 0, 3201, 3196, 1, 0, 0, 0, 3201, 3202, 1, 0, 0, 0, 3202, 3221, 1, 0, + 0, 0, 3203, 3204, 5, 909, 0, 0, 3204, 3205, 5, 1395, 0, 0, 3205, 3206, + 3, 2378, 1189, 0, 3206, 3207, 5, 1568, 0, 0, 3207, 3208, 3, 74, 37, 0, + 3208, 3209, 5, 2398, 0, 0, 3209, 3210, 3, 76, 38, 0, 3210, 3221, 1, 0, + 0, 0, 3211, 3212, 5, 921, 0, 0, 3212, 3213, 5, 1395, 0, 0, 3213, 3214, + 3, 2378, 1189, 0, 3214, 3215, 5, 2029, 0, 0, 3215, 3216, 3, 2378, 1189, + 0, 3216, 3221, 1, 0, 0, 0, 3217, 3218, 5, 425, 0, 0, 3218, 3219, 5, 1395, + 0, 0, 3219, 3221, 3, 2378, 1189, 0, 3220, 3193, 1, 0, 0, 0, 3220, 3203, + 1, 0, 0, 0, 3220, 3211, 1, 0, 0, 0, 3220, 3217, 1, 0, 0, 0, 3221, 73, 1, + 0, 0, 0, 3222, 3223, 3, 2378, 1189, 0, 3223, 75, 1, 0, 0, 0, 3224, 3225, + 3, 2378, 1189, 0, 3225, 77, 1, 0, 0, 0, 3226, 3231, 3, 80, 40, 0, 3227, + 3231, 3, 82, 41, 0, 3228, 3231, 3, 84, 42, 0, 3229, 3231, 3, 86, 43, 0, + 3230, 3226, 1, 0, 0, 0, 3230, 3227, 1, 0, 0, 0, 3230, 3228, 1, 0, 0, 0, + 3230, 3229, 1, 0, 0, 0, 3231, 79, 1, 0, 0, 0, 3232, 3233, 5, 20, 0, 0, + 3233, 3234, 5, 536, 0, 0, 3234, 3238, 3, 2378, 1189, 0, 3235, 3236, 7, + 14, 0, 0, 3236, 3239, 3, 2378, 1189, 0, 3237, 3239, 5, 1983, 0, 0, 3238, + 3235, 1, 0, 0, 0, 3238, 3237, 1, 0, 0, 0, 3239, 3243, 1, 0, 0, 0, 3240, + 3241, 5, 572, 0, 0, 3241, 3242, 5, 1983, 0, 0, 3242, 3244, 3, 2378, 1189, + 0, 3243, 3240, 1, 0, 0, 0, 3243, 3244, 1, 0, 0, 0, 3244, 3249, 1, 0, 0, + 0, 3245, 3246, 5, 1568, 0, 0, 3246, 3247, 5, 2372, 0, 0, 3247, 3248, 5, + 2398, 0, 0, 3248, 3250, 5, 2372, 0, 0, 3249, 3245, 1, 0, 0, 0, 3249, 3250, + 1, 0, 0, 0, 3250, 81, 1, 0, 0, 0, 3251, 3252, 5, 909, 0, 0, 3252, 3253, + 5, 536, 0, 0, 3253, 3254, 3, 2378, 1189, 0, 3254, 3255, 5, 1568, 0, 0, + 3255, 3256, 5, 2372, 0, 0, 3256, 3257, 5, 2398, 0, 0, 3257, 3258, 5, 2372, + 0, 0, 3258, 83, 1, 0, 0, 0, 3259, 3260, 5, 921, 0, 0, 3260, 3261, 5, 534, + 0, 0, 3261, 3262, 5, 2372, 0, 0, 3262, 3263, 5, 2029, 0, 0, 3263, 3264, + 5, 536, 0, 0, 3264, 3265, 3, 2378, 1189, 0, 3265, 85, 1, 0, 0, 0, 3266, + 3267, 5, 425, 0, 0, 3267, 3268, 5, 536, 0, 0, 3268, 3270, 3, 2378, 1189, + 0, 3269, 3271, 5, 168, 0, 0, 3270, 3269, 1, 0, 0, 0, 3270, 3271, 1, 0, + 0, 0, 3271, 87, 1, 0, 0, 0, 3272, 3273, 7, 15, 0, 0, 3273, 89, 1, 0, 0, + 0, 3274, 3275, 5, 2065, 0, 0, 3275, 3276, 5, 408, 0, 0, 3276, 91, 1, 0, + 0, 0, 3277, 3279, 5, 917, 0, 0, 3278, 3280, 7, 16, 0, 0, 3279, 3278, 1, + 0, 0, 0, 3279, 3280, 1, 0, 0, 0, 3280, 3282, 1, 0, 0, 0, 3281, 3283, 7, + 7, 0, 0, 3282, 3281, 1, 0, 0, 0, 3282, 3283, 1, 0, 0, 0, 3283, 3289, 1, + 0, 0, 0, 3284, 3286, 5, 409, 0, 0, 3285, 3287, 7, 7, 0, 0, 3286, 3285, + 1, 0, 0, 0, 3286, 3287, 1, 0, 0, 0, 3287, 3289, 1, 0, 0, 0, 3288, 3277, + 1, 0, 0, 0, 3288, 3284, 1, 0, 0, 0, 3289, 93, 1, 0, 0, 0, 3290, 3291, 7, + 17, 0, 0, 3291, 3301, 5, 2171, 0, 0, 3292, 3297, 3, 2378, 1189, 0, 3293, + 3294, 5, 2382, 0, 0, 3294, 3296, 3, 2378, 1189, 0, 3295, 3293, 1, 0, 0, + 0, 3296, 3299, 1, 0, 0, 0, 3297, 3295, 1, 0, 0, 0, 3297, 3298, 1, 0, 0, + 0, 3298, 3302, 1, 0, 0, 0, 3299, 3297, 1, 0, 0, 0, 3300, 3302, 5, 37, 0, + 0, 3301, 3292, 1, 0, 0, 0, 3301, 3300, 1, 0, 0, 0, 3302, 95, 1, 0, 0, 0, + 3303, 3304, 5, 425, 0, 0, 3304, 3305, 5, 576, 0, 0, 3305, 3306, 3, 2292, + 1146, 0, 3306, 3307, 5, 2396, 0, 0, 3307, 97, 1, 0, 0, 0, 3308, 3309, 5, + 41, 0, 0, 3309, 3310, 5, 549, 0, 0, 3310, 3311, 5, 62, 0, 0, 3311, 3341, + 3, 2378, 1189, 0, 3312, 3313, 5, 1568, 0, 0, 3313, 3342, 5, 363, 0, 0, + 3314, 3315, 7, 4, 0, 0, 3315, 3316, 5, 1973, 0, 0, 3316, 3318, 3, 2378, + 1189, 0, 3317, 3319, 3, 442, 221, 0, 3318, 3317, 1, 0, 0, 0, 3318, 3319, + 1, 0, 0, 0, 3319, 3342, 1, 0, 0, 0, 3320, 3321, 5, 1459, 0, 0, 3321, 3322, + 5, 1973, 0, 0, 3322, 3342, 3, 2378, 1189, 0, 3323, 3324, 5, 909, 0, 0, + 3324, 3342, 3, 444, 222, 0, 3325, 3334, 5, 1379, 0, 0, 3326, 3335, 5, 37, + 0, 0, 3327, 3332, 5, 106, 0, 0, 3328, 3329, 5, 1528, 0, 0, 3329, 3333, + 3, 2078, 1039, 0, 3330, 3331, 5, 1997, 0, 0, 3331, 3333, 3, 2078, 1039, + 0, 3332, 3328, 1, 0, 0, 0, 3332, 3330, 1, 0, 0, 0, 3333, 3335, 1, 0, 0, + 0, 3334, 3326, 1, 0, 0, 0, 3334, 3327, 1, 0, 0, 0, 3335, 3342, 1, 0, 0, + 0, 3336, 3338, 5, 1057, 0, 0, 3337, 3336, 1, 0, 0, 0, 3337, 3338, 1, 0, + 0, 0, 3338, 3339, 1, 0, 0, 0, 3339, 3340, 5, 1185, 0, 0, 3340, 3342, 5, + 330, 0, 0, 3341, 3312, 1, 0, 0, 0, 3341, 3314, 1, 0, 0, 0, 3341, 3320, + 1, 0, 0, 0, 3341, 3323, 1, 0, 0, 0, 3341, 3325, 1, 0, 0, 0, 3341, 3337, + 1, 0, 0, 0, 3342, 99, 1, 0, 0, 0, 3343, 3344, 5, 41, 0, 0, 3344, 3348, + 5, 617, 0, 0, 3345, 3346, 3, 2258, 1129, 0, 3346, 3347, 5, 2369, 0, 0, + 3347, 3349, 1, 0, 0, 0, 3348, 3345, 1, 0, 0, 0, 3348, 3349, 1, 0, 0, 0, + 3349, 3350, 1, 0, 0, 0, 3350, 3355, 3, 2378, 1189, 0, 3351, 3352, 5, 1460, + 0, 0, 3352, 3353, 5, 2029, 0, 0, 3353, 3356, 3, 2378, 1189, 0, 3354, 3356, + 5, 233, 0, 0, 3355, 3351, 1, 0, 0, 0, 3355, 3354, 1, 0, 0, 0, 3356, 101, + 1, 0, 0, 0, 3357, 3358, 5, 41, 0, 0, 3358, 3359, 5, 576, 0, 0, 3359, 3360, + 3, 2292, 1146, 0, 3360, 3362, 5, 233, 0, 0, 3361, 3363, 5, 352, 0, 0, 3362, + 3361, 1, 0, 0, 0, 3362, 3363, 1, 0, 0, 0, 3363, 3367, 1, 0, 0, 0, 3364, + 3366, 3, 808, 404, 0, 3365, 3364, 1, 0, 0, 0, 3366, 3369, 1, 0, 0, 0, 3367, + 3365, 1, 0, 0, 0, 3367, 3368, 1, 0, 0, 0, 3368, 3372, 1, 0, 0, 0, 3369, + 3367, 1, 0, 0, 0, 3370, 3371, 5, 1488, 0, 0, 3371, 3373, 5, 1570, 0, 0, + 3372, 3370, 1, 0, 0, 0, 3372, 3373, 1, 0, 0, 0, 3373, 3374, 1, 0, 0, 0, + 3374, 3375, 5, 2396, 0, 0, 3375, 103, 1, 0, 0, 0, 3376, 3377, 5, 41, 0, + 0, 3377, 3378, 5, 729, 0, 0, 3378, 3382, 7, 18, 0, 0, 3379, 3380, 3, 2258, + 1129, 0, 3380, 3381, 5, 2369, 0, 0, 3381, 3383, 1, 0, 0, 0, 3382, 3379, + 1, 0, 0, 0, 3382, 3383, 1, 0, 0, 0, 3383, 3384, 1, 0, 0, 0, 3384, 3404, + 3, 2378, 1189, 0, 3385, 3386, 5, 1470, 0, 0, 3386, 3398, 5, 2376, 0, 0, + 3387, 3388, 5, 2376, 0, 0, 3388, 3390, 3, 106, 53, 0, 3389, 3391, 5, 2382, + 0, 0, 3390, 3389, 1, 0, 0, 0, 3390, 3391, 1, 0, 0, 0, 3391, 3394, 1, 0, + 0, 0, 3392, 3395, 3, 2258, 1129, 0, 3393, 3395, 5, 2381, 0, 0, 3394, 3392, + 1, 0, 0, 0, 3394, 3393, 1, 0, 0, 0, 3395, 3396, 1, 0, 0, 0, 3396, 3397, + 5, 2377, 0, 0, 3397, 3399, 1, 0, 0, 0, 3398, 3387, 1, 0, 0, 0, 3399, 3400, + 1, 0, 0, 0, 3400, 3398, 1, 0, 0, 0, 3400, 3401, 1, 0, 0, 0, 3401, 3402, + 1, 0, 0, 0, 3402, 3403, 5, 2377, 0, 0, 3403, 3405, 1, 0, 0, 0, 3404, 3385, + 1, 0, 0, 0, 3404, 3405, 1, 0, 0, 0, 3405, 3409, 1, 0, 0, 0, 3406, 3410, + 5, 233, 0, 0, 3407, 3410, 5, 1469, 0, 0, 3408, 3410, 3, 1746, 873, 0, 3409, + 3406, 1, 0, 0, 0, 3409, 3407, 1, 0, 0, 0, 3409, 3408, 1, 0, 0, 0, 3410, + 105, 1, 0, 0, 0, 3411, 3412, 7, 19, 0, 0, 3412, 107, 1, 0, 0, 0, 3413, + 3416, 5, 301, 0, 0, 3414, 3415, 5, 1219, 0, 0, 3415, 3417, 5, 1463, 0, + 0, 3416, 3414, 1, 0, 0, 0, 3416, 3417, 1, 0, 0, 0, 3417, 3418, 1, 0, 0, + 0, 3418, 3419, 5, 576, 0, 0, 3419, 3431, 3, 2292, 1146, 0, 3420, 3421, + 5, 2376, 0, 0, 3421, 3426, 3, 1758, 879, 0, 3422, 3423, 5, 2382, 0, 0, + 3423, 3425, 3, 1758, 879, 0, 3424, 3422, 1, 0, 0, 0, 3425, 3428, 1, 0, + 0, 0, 3426, 3424, 1, 0, 0, 0, 3426, 3427, 1, 0, 0, 0, 3427, 3429, 1, 0, + 0, 0, 3428, 3426, 1, 0, 0, 0, 3429, 3430, 5, 2377, 0, 0, 3430, 3432, 1, + 0, 0, 0, 3431, 3420, 1, 0, 0, 0, 3431, 3432, 1, 0, 0, 0, 3432, 3433, 1, + 0, 0, 0, 3433, 3434, 5, 1487, 0, 0, 3434, 3441, 3, 2344, 1172, 0, 3435, + 3440, 3, 1746, 873, 0, 3436, 3440, 3, 112, 56, 0, 3437, 3440, 3, 116, 58, + 0, 3438, 3440, 5, 390, 0, 0, 3439, 3435, 1, 0, 0, 0, 3439, 3436, 1, 0, + 0, 0, 3439, 3437, 1, 0, 0, 0, 3439, 3438, 1, 0, 0, 0, 3440, 3443, 1, 0, + 0, 0, 3441, 3439, 1, 0, 0, 0, 3441, 3442, 1, 0, 0, 0, 3442, 3462, 1, 0, + 0, 0, 3443, 3441, 1, 0, 0, 0, 3444, 3446, 5, 1300, 0, 0, 3445, 3444, 1, + 0, 0, 0, 3445, 3446, 1, 0, 0, 0, 3446, 3447, 1, 0, 0, 0, 3447, 3456, 7, + 20, 0, 0, 3448, 3450, 5, 356, 0, 0, 3449, 3448, 1, 0, 0, 0, 3449, 3450, + 1, 0, 0, 0, 3450, 3452, 1, 0, 0, 0, 3451, 3453, 3, 1762, 881, 0, 3452, + 3451, 1, 0, 0, 0, 3452, 3453, 1, 0, 0, 0, 3453, 3454, 1, 0, 0, 0, 3454, + 3457, 3, 1838, 919, 0, 3455, 3457, 3, 1748, 874, 0, 3456, 3449, 1, 0, 0, + 0, 3456, 3455, 1, 0, 0, 0, 3457, 3463, 1, 0, 0, 0, 3458, 3459, 7, 21, 0, + 0, 3459, 3460, 5, 2129, 0, 0, 3460, 3463, 3, 2264, 1132, 0, 3461, 3463, + 3, 110, 55, 0, 3462, 3445, 1, 0, 0, 0, 3462, 3458, 1, 0, 0, 0, 3462, 3461, + 1, 0, 0, 0, 3463, 3464, 1, 0, 0, 0, 3464, 3465, 5, 2396, 0, 0, 3465, 109, + 1, 0, 0, 0, 3466, 3467, 5, 1618, 0, 0, 3467, 3468, 5, 723, 0, 0, 3468, + 3469, 5, 107, 0, 0, 3469, 3470, 5, 1487, 0, 0, 3470, 3471, 3, 2372, 1186, + 0, 3471, 3472, 5, 2396, 0, 0, 3472, 3473, 5, 459, 0, 0, 3473, 111, 1, 0, + 0, 0, 3474, 3476, 5, 1241, 0, 0, 3475, 3477, 3, 114, 57, 0, 3476, 3475, + 1, 0, 0, 0, 3476, 3477, 1, 0, 0, 0, 3477, 113, 1, 0, 0, 0, 3478, 3479, + 5, 2376, 0, 0, 3479, 3480, 5, 1256, 0, 0, 3480, 3481, 3, 2078, 1039, 0, + 3481, 3485, 5, 151, 0, 0, 3482, 3486, 5, 53, 0, 0, 3483, 3484, 7, 22, 0, + 0, 3484, 3486, 3, 2330, 1165, 0, 3485, 3482, 1, 0, 0, 0, 3485, 3483, 1, + 0, 0, 0, 3486, 3488, 1, 0, 0, 0, 3487, 3489, 3, 120, 60, 0, 3488, 3487, + 1, 0, 0, 0, 3488, 3489, 1, 0, 0, 0, 3489, 3490, 1, 0, 0, 0, 3490, 3491, + 5, 2377, 0, 0, 3491, 115, 1, 0, 0, 0, 3492, 3494, 5, 1480, 0, 0, 3493, + 3495, 3, 118, 59, 0, 3494, 3493, 1, 0, 0, 0, 3494, 3495, 1, 0, 0, 0, 3495, + 117, 1, 0, 0, 0, 3496, 3497, 5, 1453, 0, 0, 3497, 3498, 5, 2376, 0, 0, + 3498, 3503, 3, 2312, 1156, 0, 3499, 3500, 5, 2382, 0, 0, 3500, 3502, 3, + 2312, 1156, 0, 3501, 3499, 1, 0, 0, 0, 3502, 3505, 1, 0, 0, 0, 3503, 3501, + 1, 0, 0, 0, 3503, 3504, 1, 0, 0, 0, 3504, 3506, 1, 0, 0, 0, 3505, 3503, + 1, 0, 0, 0, 3506, 3507, 5, 2377, 0, 0, 3507, 119, 1, 0, 0, 0, 3508, 3509, + 7, 23, 0, 0, 3509, 3510, 3, 2078, 1039, 0, 3510, 3511, 5, 151, 0, 0, 3511, + 3512, 3, 2330, 1165, 0, 3512, 121, 1, 0, 0, 0, 3513, 3514, 5, 41, 0, 0, + 3514, 3516, 5, 1227, 0, 0, 3515, 3517, 7, 24, 0, 0, 3516, 3515, 1, 0, 0, + 0, 3516, 3517, 1, 0, 0, 0, 3517, 3518, 1, 0, 0, 0, 3518, 3520, 3, 2378, + 1189, 0, 3519, 3521, 3, 124, 62, 0, 3520, 3519, 1, 0, 0, 0, 3521, 3522, + 1, 0, 0, 0, 3522, 3520, 1, 0, 0, 0, 3522, 3523, 1, 0, 0, 0, 3523, 123, + 1, 0, 0, 0, 3524, 3535, 5, 1413, 0, 0, 3525, 3526, 5, 1460, 0, 0, 3526, + 3527, 5, 2029, 0, 0, 3527, 3535, 3, 2378, 1189, 0, 3528, 3529, 5, 179, + 0, 0, 3529, 3530, 5, 172, 0, 0, 3530, 3531, 5, 2029, 0, 0, 3531, 3535, + 3, 2378, 1189, 0, 3532, 3535, 5, 453, 0, 0, 3533, 3535, 5, 398, 0, 0, 3534, + 3524, 1, 0, 0, 0, 3534, 3525, 1, 0, 0, 0, 3534, 3528, 1, 0, 0, 0, 3534, + 3532, 1, 0, 0, 0, 3534, 3533, 1, 0, 0, 0, 3535, 125, 1, 0, 0, 0, 3536, + 3537, 5, 41, 0, 0, 3537, 3538, 5, 809, 0, 0, 3538, 3539, 5, 1367, 0, 0, + 3539, 3543, 3, 2378, 1189, 0, 3540, 3544, 3, 128, 64, 0, 3541, 3544, 3, + 130, 65, 0, 3542, 3544, 3, 132, 66, 0, 3543, 3540, 1, 0, 0, 0, 3543, 3541, + 1, 0, 0, 0, 3543, 3542, 1, 0, 0, 0, 3544, 3548, 1, 0, 0, 0, 3545, 3546, + 5, 2119, 0, 0, 3546, 3547, 5, 2398, 0, 0, 3547, 3549, 7, 25, 0, 0, 3548, + 3545, 1, 0, 0, 0, 3548, 3549, 1, 0, 0, 0, 3549, 127, 1, 0, 0, 0, 3550, + 3551, 3, 142, 71, 0, 3551, 3566, 5, 528, 0, 0, 3552, 3553, 5, 2398, 0, + 0, 3553, 3554, 5, 2376, 0, 0, 3554, 3555, 3, 140, 70, 0, 3555, 3556, 5, + 2377, 0, 0, 3556, 3567, 1, 0, 0, 0, 3557, 3564, 5, 37, 0, 0, 3558, 3559, + 5, 481, 0, 0, 3559, 3560, 5, 2398, 0, 0, 3560, 3561, 5, 2376, 0, 0, 3561, + 3562, 3, 140, 70, 0, 3562, 3563, 5, 2377, 0, 0, 3563, 3565, 1, 0, 0, 0, + 3564, 3558, 1, 0, 0, 0, 3564, 3565, 1, 0, 0, 0, 3565, 3567, 1, 0, 0, 0, + 3566, 3552, 1, 0, 0, 0, 3566, 3557, 1, 0, 0, 0, 3567, 129, 1, 0, 0, 0, + 3568, 3569, 3, 142, 71, 0, 3569, 3584, 5, 1188, 0, 0, 3570, 3571, 5, 2398, + 0, 0, 3571, 3572, 5, 2376, 0, 0, 3572, 3573, 3, 140, 70, 0, 3573, 3574, + 5, 2377, 0, 0, 3574, 3585, 1, 0, 0, 0, 3575, 3582, 5, 37, 0, 0, 3576, 3577, + 5, 481, 0, 0, 3577, 3578, 5, 2398, 0, 0, 3578, 3579, 5, 2376, 0, 0, 3579, + 3580, 3, 140, 70, 0, 3580, 3581, 5, 2377, 0, 0, 3581, 3583, 1, 0, 0, 0, + 3582, 3576, 1, 0, 0, 0, 3582, 3583, 1, 0, 0, 0, 3583, 3585, 1, 0, 0, 0, + 3584, 3570, 1, 0, 0, 0, 3584, 3575, 1, 0, 0, 0, 3585, 131, 1, 0, 0, 0, + 3586, 3587, 3, 142, 71, 0, 3587, 3607, 5, 1636, 0, 0, 3588, 3589, 5, 2398, + 0, 0, 3589, 3590, 5, 2376, 0, 0, 3590, 3591, 3, 140, 70, 0, 3591, 3592, + 5, 2377, 0, 0, 3592, 3608, 1, 0, 0, 0, 3593, 3594, 5, 2398, 0, 0, 3594, + 3595, 5, 2376, 0, 0, 3595, 3596, 5, 2372, 0, 0, 3596, 3597, 5, 2377, 0, + 0, 3597, 3608, 3, 134, 67, 0, 3598, 3605, 5, 37, 0, 0, 3599, 3600, 5, 481, + 0, 0, 3600, 3601, 5, 2398, 0, 0, 3601, 3602, 5, 2376, 0, 0, 3602, 3603, + 3, 140, 70, 0, 3603, 3604, 5, 2377, 0, 0, 3604, 3606, 1, 0, 0, 0, 3605, + 3599, 1, 0, 0, 0, 3605, 3606, 1, 0, 0, 0, 3606, 3608, 1, 0, 0, 0, 3607, + 3588, 1, 0, 0, 0, 3607, 3593, 1, 0, 0, 0, 3607, 3598, 1, 0, 0, 0, 3608, + 133, 1, 0, 0, 0, 3609, 3629, 5, 195, 0, 0, 3610, 3611, 5, 2398, 0, 0, 3611, + 3612, 5, 2376, 0, 0, 3612, 3613, 3, 140, 70, 0, 3613, 3614, 5, 2377, 0, + 0, 3614, 3630, 1, 0, 0, 0, 3615, 3616, 5, 2398, 0, 0, 3616, 3617, 5, 2376, + 0, 0, 3617, 3618, 5, 2372, 0, 0, 3618, 3619, 5, 2377, 0, 0, 3619, 3630, + 3, 136, 68, 0, 3620, 3627, 5, 37, 0, 0, 3621, 3622, 5, 481, 0, 0, 3622, + 3623, 5, 2398, 0, 0, 3623, 3624, 5, 2376, 0, 0, 3624, 3625, 3, 140, 70, + 0, 3625, 3626, 5, 2377, 0, 0, 3626, 3628, 1, 0, 0, 0, 3627, 3621, 1, 0, + 0, 0, 3627, 3628, 1, 0, 0, 0, 3628, 3630, 1, 0, 0, 0, 3629, 3610, 1, 0, + 0, 0, 3629, 3615, 1, 0, 0, 0, 3629, 3620, 1, 0, 0, 0, 3630, 135, 1, 0, + 0, 0, 3631, 3655, 5, 1188, 0, 0, 3632, 3633, 5, 2398, 0, 0, 3633, 3634, + 5, 2376, 0, 0, 3634, 3635, 3, 140, 70, 0, 3635, 3636, 5, 2377, 0, 0, 3636, + 3656, 1, 0, 0, 0, 3637, 3638, 5, 2398, 0, 0, 3638, 3639, 5, 2376, 0, 0, + 3639, 3640, 5, 2372, 0, 0, 3640, 3642, 5, 2377, 0, 0, 3641, 3643, 3, 138, + 69, 0, 3642, 3641, 1, 0, 0, 0, 3643, 3644, 1, 0, 0, 0, 3644, 3642, 1, 0, + 0, 0, 3644, 3645, 1, 0, 0, 0, 3645, 3656, 1, 0, 0, 0, 3646, 3653, 5, 37, + 0, 0, 3647, 3648, 5, 481, 0, 0, 3648, 3649, 5, 2398, 0, 0, 3649, 3650, + 5, 2376, 0, 0, 3650, 3651, 3, 140, 70, 0, 3651, 3652, 5, 2377, 0, 0, 3652, + 3654, 1, 0, 0, 0, 3653, 3647, 1, 0, 0, 0, 3653, 3654, 1, 0, 0, 0, 3654, + 3656, 1, 0, 0, 0, 3655, 3632, 1, 0, 0, 0, 3655, 3637, 1, 0, 0, 0, 3655, + 3646, 1, 0, 0, 0, 3656, 137, 1, 0, 0, 0, 3657, 3658, 5, 2141, 0, 0, 3658, + 3659, 5, 2398, 0, 0, 3659, 3660, 5, 2376, 0, 0, 3660, 3661, 3, 140, 70, + 0, 3661, 3662, 5, 2377, 0, 0, 3662, 3667, 1, 0, 0, 0, 3663, 3664, 7, 26, + 0, 0, 3664, 3665, 5, 2398, 0, 0, 3665, 3667, 5, 2372, 0, 0, 3666, 3657, + 1, 0, 0, 0, 3666, 3663, 1, 0, 0, 0, 3667, 139, 1, 0, 0, 0, 3668, 3673, + 5, 2372, 0, 0, 3669, 3670, 5, 2382, 0, 0, 3670, 3672, 5, 2372, 0, 0, 3671, + 3669, 1, 0, 0, 0, 3672, 3675, 1, 0, 0, 0, 3673, 3671, 1, 0, 0, 0, 3673, + 3674, 1, 0, 0, 0, 3674, 141, 1, 0, 0, 0, 3675, 3673, 1, 0, 0, 0, 3676, + 3677, 7, 17, 0, 0, 3677, 143, 1, 0, 0, 0, 3678, 3679, 5, 425, 0, 0, 3679, + 3680, 5, 809, 0, 0, 3680, 3681, 5, 1367, 0, 0, 3681, 3682, 3, 2378, 1189, + 0, 3682, 145, 1, 0, 0, 0, 3683, 3684, 5, 425, 0, 0, 3684, 3686, 5, 1239, + 0, 0, 3685, 3687, 5, 138, 0, 0, 3686, 3685, 1, 0, 0, 0, 3686, 3687, 1, + 0, 0, 0, 3687, 3691, 1, 0, 0, 0, 3688, 3689, 3, 2320, 1160, 0, 3689, 3690, + 5, 2369, 0, 0, 3690, 3692, 1, 0, 0, 0, 3691, 3688, 1, 0, 0, 0, 3691, 3692, + 1, 0, 0, 0, 3692, 3693, 1, 0, 0, 0, 3693, 3694, 3, 2262, 1131, 0, 3694, + 3695, 5, 2396, 0, 0, 3695, 147, 1, 0, 0, 0, 3696, 3697, 5, 41, 0, 0, 3697, + 3698, 5, 1239, 0, 0, 3698, 3699, 3, 2262, 1131, 0, 3699, 3701, 5, 233, + 0, 0, 3700, 3702, 5, 352, 0, 0, 3701, 3700, 1, 0, 0, 0, 3701, 3702, 1, + 0, 0, 0, 3702, 3704, 1, 0, 0, 0, 3703, 3705, 7, 27, 0, 0, 3704, 3703, 1, + 0, 0, 0, 3704, 3705, 1, 0, 0, 0, 3705, 3709, 1, 0, 0, 0, 3706, 3708, 3, + 808, 404, 0, 3707, 3706, 1, 0, 0, 0, 3708, 3711, 1, 0, 0, 0, 3709, 3707, + 1, 0, 0, 0, 3709, 3710, 1, 0, 0, 0, 3710, 3714, 1, 0, 0, 0, 3711, 3709, + 1, 0, 0, 0, 3712, 3713, 5, 1488, 0, 0, 3713, 3715, 5, 1570, 0, 0, 3714, + 3712, 1, 0, 0, 0, 3714, 3715, 1, 0, 0, 0, 3715, 3716, 1, 0, 0, 0, 3716, + 3717, 5, 2396, 0, 0, 3717, 149, 1, 0, 0, 0, 3718, 3721, 5, 301, 0, 0, 3719, + 3720, 5, 1219, 0, 0, 3720, 3722, 5, 1463, 0, 0, 3721, 3719, 1, 0, 0, 0, + 3721, 3722, 1, 0, 0, 0, 3722, 3723, 1, 0, 0, 0, 3723, 3727, 5, 1239, 0, + 0, 3724, 3725, 3, 2320, 1160, 0, 3725, 3726, 5, 2369, 0, 0, 3726, 3728, + 1, 0, 0, 0, 3727, 3724, 1, 0, 0, 0, 3727, 3728, 1, 0, 0, 0, 3728, 3729, + 1, 0, 0, 0, 3729, 3731, 3, 2262, 1131, 0, 3730, 3732, 3, 1746, 873, 0, + 3731, 3730, 1, 0, 0, 0, 3731, 3732, 1, 0, 0, 0, 3732, 3733, 1, 0, 0, 0, + 3733, 3737, 7, 20, 0, 0, 3734, 3736, 3, 154, 77, 0, 3735, 3734, 1, 0, 0, + 0, 3736, 3739, 1, 0, 0, 0, 3737, 3735, 1, 0, 0, 0, 3737, 3738, 1, 0, 0, + 0, 3738, 3740, 1, 0, 0, 0, 3739, 3737, 1, 0, 0, 0, 3740, 3742, 5, 459, + 0, 0, 3741, 3743, 3, 2262, 1131, 0, 3742, 3741, 1, 0, 0, 0, 3742, 3743, + 1, 0, 0, 0, 3743, 3744, 1, 0, 0, 0, 3744, 3745, 5, 2396, 0, 0, 3745, 151, + 1, 0, 0, 0, 3746, 3749, 5, 301, 0, 0, 3747, 3748, 5, 1219, 0, 0, 3748, + 3750, 5, 1463, 0, 0, 3749, 3747, 1, 0, 0, 0, 3749, 3750, 1, 0, 0, 0, 3750, + 3751, 1, 0, 0, 0, 3751, 3752, 5, 1239, 0, 0, 3752, 3756, 5, 138, 0, 0, + 3753, 3754, 3, 2320, 1160, 0, 3754, 3755, 5, 2369, 0, 0, 3755, 3757, 1, + 0, 0, 0, 3756, 3753, 1, 0, 0, 0, 3756, 3757, 1, 0, 0, 0, 3757, 3758, 1, + 0, 0, 0, 3758, 3759, 3, 2262, 1131, 0, 3759, 3763, 7, 20, 0, 0, 3760, 3762, + 3, 160, 80, 0, 3761, 3760, 1, 0, 0, 0, 3762, 3765, 1, 0, 0, 0, 3763, 3761, + 1, 0, 0, 0, 3763, 3764, 1, 0, 0, 0, 3764, 3768, 1, 0, 0, 0, 3765, 3763, + 1, 0, 0, 0, 3766, 3767, 5, 107, 0, 0, 3767, 3769, 3, 1792, 896, 0, 3768, + 3766, 1, 0, 0, 0, 3768, 3769, 1, 0, 0, 0, 3769, 3770, 1, 0, 0, 0, 3770, + 3772, 5, 459, 0, 0, 3771, 3773, 3, 2262, 1131, 0, 3772, 3771, 1, 0, 0, + 0, 3772, 3773, 1, 0, 0, 0, 3773, 3774, 1, 0, 0, 0, 3774, 3775, 5, 2396, + 0, 0, 3775, 153, 1, 0, 0, 0, 3776, 3785, 3, 1776, 888, 0, 3777, 3785, 3, + 1774, 887, 0, 3778, 3785, 3, 1766, 883, 0, 3779, 3785, 3, 1768, 884, 0, + 3780, 3785, 3, 1770, 885, 0, 3781, 3785, 3, 1784, 892, 0, 3782, 3785, 3, + 156, 78, 0, 3783, 3785, 3, 158, 79, 0, 3784, 3776, 1, 0, 0, 0, 3784, 3777, + 1, 0, 0, 0, 3784, 3778, 1, 0, 0, 0, 3784, 3779, 1, 0, 0, 0, 3784, 3780, + 1, 0, 0, 0, 3784, 3781, 1, 0, 0, 0, 3784, 3782, 1, 0, 0, 0, 3784, 3783, + 1, 0, 0, 0, 3785, 155, 1, 0, 0, 0, 3786, 3787, 5, 1365, 0, 0, 3787, 3799, + 3, 2376, 1188, 0, 3788, 3789, 5, 2376, 0, 0, 3789, 3794, 3, 1758, 879, + 0, 3790, 3791, 5, 2382, 0, 0, 3791, 3793, 3, 1758, 879, 0, 3792, 3790, + 1, 0, 0, 0, 3793, 3796, 1, 0, 0, 0, 3794, 3792, 1, 0, 0, 0, 3794, 3795, + 1, 0, 0, 0, 3795, 3797, 1, 0, 0, 0, 3796, 3794, 1, 0, 0, 0, 3797, 3798, + 5, 2377, 0, 0, 3798, 3800, 1, 0, 0, 0, 3799, 3788, 1, 0, 0, 0, 3799, 3800, + 1, 0, 0, 0, 3800, 3801, 1, 0, 0, 0, 3801, 3802, 5, 2396, 0, 0, 3802, 157, + 1, 0, 0, 0, 3803, 3804, 5, 576, 0, 0, 3804, 3816, 3, 2376, 1188, 0, 3805, + 3806, 5, 2376, 0, 0, 3806, 3811, 3, 1758, 879, 0, 3807, 3808, 5, 2382, + 0, 0, 3808, 3810, 3, 1758, 879, 0, 3809, 3807, 1, 0, 0, 0, 3810, 3813, + 1, 0, 0, 0, 3811, 3809, 1, 0, 0, 0, 3811, 3812, 1, 0, 0, 0, 3812, 3814, + 1, 0, 0, 0, 3813, 3811, 1, 0, 0, 0, 3814, 3815, 5, 2377, 0, 0, 3815, 3817, + 1, 0, 0, 0, 3816, 3805, 1, 0, 0, 0, 3816, 3817, 1, 0, 0, 0, 3817, 3818, + 1, 0, 0, 0, 3818, 3819, 5, 1487, 0, 0, 3819, 3821, 3, 2344, 1172, 0, 3820, + 3822, 5, 1300, 0, 0, 3821, 3820, 1, 0, 0, 0, 3821, 3822, 1, 0, 0, 0, 3822, + 3824, 1, 0, 0, 0, 3823, 3825, 5, 390, 0, 0, 3824, 3823, 1, 0, 0, 0, 3824, + 3825, 1, 0, 0, 0, 3825, 3827, 1, 0, 0, 0, 3826, 3828, 5, 1480, 0, 0, 3827, + 3826, 1, 0, 0, 0, 3827, 3828, 1, 0, 0, 0, 3828, 3829, 1, 0, 0, 0, 3829, + 3830, 5, 2396, 0, 0, 3830, 159, 1, 0, 0, 0, 3831, 3841, 3, 1774, 887, 0, + 3832, 3841, 3, 1768, 884, 0, 3833, 3841, 3, 1770, 885, 0, 3834, 3841, 3, + 1766, 883, 0, 3835, 3841, 3, 1784, 892, 0, 3836, 3841, 3, 172, 86, 0, 3837, + 3841, 3, 170, 85, 0, 3838, 3841, 3, 156, 78, 0, 3839, 3841, 3, 158, 79, + 0, 3840, 3831, 1, 0, 0, 0, 3840, 3832, 1, 0, 0, 0, 3840, 3833, 1, 0, 0, + 0, 3840, 3834, 1, 0, 0, 0, 3840, 3835, 1, 0, 0, 0, 3840, 3836, 1, 0, 0, + 0, 3840, 3837, 1, 0, 0, 0, 3840, 3838, 1, 0, 0, 0, 3840, 3839, 1, 0, 0, + 0, 3841, 161, 1, 0, 0, 0, 3842, 3843, 5, 41, 0, 0, 3843, 3844, 5, 1316, + 0, 0, 3844, 3845, 5, 537, 0, 0, 3845, 3862, 3, 2378, 1189, 0, 3846, 3847, + 5, 1468, 0, 0, 3847, 3863, 3, 1170, 585, 0, 3848, 3863, 3, 918, 459, 0, + 3849, 3852, 5, 917, 0, 0, 3850, 3851, 5, 919, 0, 0, 3851, 3853, 3, 192, + 96, 0, 3852, 3850, 1, 0, 0, 0, 3852, 3853, 1, 0, 0, 0, 3853, 3856, 1, 0, + 0, 0, 3854, 3855, 5, 97, 0, 0, 3855, 3857, 3, 1472, 736, 0, 3856, 3854, + 1, 0, 0, 0, 3856, 3857, 1, 0, 0, 0, 3857, 3859, 1, 0, 0, 0, 3858, 3860, + 5, 560, 0, 0, 3859, 3858, 1, 0, 0, 0, 3859, 3860, 1, 0, 0, 0, 3860, 3863, + 1, 0, 0, 0, 3861, 3863, 5, 409, 0, 0, 3862, 3846, 1, 0, 0, 0, 3862, 3848, + 1, 0, 0, 0, 3862, 3849, 1, 0, 0, 0, 3862, 3861, 1, 0, 0, 0, 3863, 163, + 1, 0, 0, 0, 3864, 3865, 5, 425, 0, 0, 3865, 3866, 5, 1316, 0, 0, 3866, + 3867, 5, 537, 0, 0, 3867, 3876, 3, 2378, 1189, 0, 3868, 3870, 5, 560, 0, + 0, 3869, 3868, 1, 0, 0, 0, 3869, 3870, 1, 0, 0, 0, 3870, 3871, 1, 0, 0, + 0, 3871, 3874, 5, 647, 0, 0, 3872, 3874, 5, 487, 0, 0, 3873, 3869, 1, 0, + 0, 0, 3873, 3872, 1, 0, 0, 0, 3874, 3875, 1, 0, 0, 0, 3875, 3877, 5, 276, + 0, 0, 3876, 3873, 1, 0, 0, 0, 3876, 3877, 1, 0, 0, 0, 3877, 165, 1, 0, + 0, 0, 3878, 3879, 5, 425, 0, 0, 3879, 3880, 5, 1365, 0, 0, 3880, 3881, + 3, 2294, 1147, 0, 3881, 3882, 5, 2396, 0, 0, 3882, 167, 1, 0, 0, 0, 3883, + 3884, 5, 41, 0, 0, 3884, 3885, 5, 1365, 0, 0, 3885, 3886, 3, 2294, 1147, + 0, 3886, 3888, 5, 233, 0, 0, 3887, 3889, 5, 352, 0, 0, 3888, 3887, 1, 0, + 0, 0, 3888, 3889, 1, 0, 0, 0, 3889, 3893, 1, 0, 0, 0, 3890, 3892, 3, 808, + 404, 0, 3891, 3890, 1, 0, 0, 0, 3892, 3895, 1, 0, 0, 0, 3893, 3891, 1, + 0, 0, 0, 3893, 3894, 1, 0, 0, 0, 3894, 3898, 1, 0, 0, 0, 3895, 3893, 1, + 0, 0, 0, 3896, 3897, 5, 1488, 0, 0, 3897, 3899, 5, 1570, 0, 0, 3898, 3896, + 1, 0, 0, 0, 3898, 3899, 1, 0, 0, 0, 3899, 3900, 1, 0, 0, 0, 3900, 3901, + 5, 2396, 0, 0, 3901, 169, 1, 0, 0, 0, 3902, 3903, 5, 576, 0, 0, 3903, 3915, + 3, 2376, 1188, 0, 3904, 3905, 5, 2376, 0, 0, 3905, 3910, 3, 1758, 879, + 0, 3906, 3907, 5, 2382, 0, 0, 3907, 3909, 3, 1758, 879, 0, 3908, 3906, + 1, 0, 0, 0, 3909, 3912, 1, 0, 0, 0, 3910, 3908, 1, 0, 0, 0, 3910, 3911, + 1, 0, 0, 0, 3911, 3913, 1, 0, 0, 0, 3912, 3910, 1, 0, 0, 0, 3913, 3914, + 5, 2377, 0, 0, 3914, 3916, 1, 0, 0, 0, 3915, 3904, 1, 0, 0, 0, 3915, 3916, + 1, 0, 0, 0, 3916, 3917, 1, 0, 0, 0, 3917, 3918, 5, 1487, 0, 0, 3918, 3925, + 3, 2344, 1172, 0, 3919, 3924, 3, 1746, 873, 0, 3920, 3924, 3, 112, 56, + 0, 3921, 3924, 3, 116, 58, 0, 3922, 3924, 5, 390, 0, 0, 3923, 3919, 1, + 0, 0, 0, 3923, 3920, 1, 0, 0, 0, 3923, 3921, 1, 0, 0, 0, 3923, 3922, 1, + 0, 0, 0, 3924, 3927, 1, 0, 0, 0, 3925, 3923, 1, 0, 0, 0, 3925, 3926, 1, + 0, 0, 0, 3926, 3948, 1, 0, 0, 0, 3927, 3925, 1, 0, 0, 0, 3928, 3930, 5, + 1300, 0, 0, 3929, 3928, 1, 0, 0, 0, 3929, 3930, 1, 0, 0, 0, 3930, 3932, + 1, 0, 0, 0, 3931, 3933, 5, 390, 0, 0, 3932, 3931, 1, 0, 0, 0, 3932, 3933, + 1, 0, 0, 0, 3933, 3934, 1, 0, 0, 0, 3934, 3943, 7, 20, 0, 0, 3935, 3937, + 5, 356, 0, 0, 3936, 3935, 1, 0, 0, 0, 3936, 3937, 1, 0, 0, 0, 3937, 3939, + 1, 0, 0, 0, 3938, 3940, 3, 1762, 881, 0, 3939, 3938, 1, 0, 0, 0, 3939, + 3940, 1, 0, 0, 0, 3940, 3941, 1, 0, 0, 0, 3941, 3944, 3, 1838, 919, 0, + 3942, 3944, 3, 1748, 874, 0, 3943, 3936, 1, 0, 0, 0, 3943, 3942, 1, 0, + 0, 0, 3944, 3949, 1, 0, 0, 0, 3945, 3946, 7, 21, 0, 0, 3946, 3947, 5, 2129, + 0, 0, 3947, 3949, 3, 2264, 1132, 0, 3948, 3929, 1, 0, 0, 0, 3948, 3945, + 1, 0, 0, 0, 3949, 3950, 1, 0, 0, 0, 3950, 3951, 5, 2396, 0, 0, 3951, 171, + 1, 0, 0, 0, 3952, 3953, 5, 1365, 0, 0, 3953, 3965, 3, 2376, 1188, 0, 3954, + 3955, 5, 2376, 0, 0, 3955, 3960, 3, 1758, 879, 0, 3956, 3957, 5, 2382, + 0, 0, 3957, 3959, 3, 1758, 879, 0, 3958, 3956, 1, 0, 0, 0, 3959, 3962, + 1, 0, 0, 0, 3960, 3958, 1, 0, 0, 0, 3960, 3961, 1, 0, 0, 0, 3961, 3963, + 1, 0, 0, 0, 3962, 3960, 1, 0, 0, 0, 3963, 3964, 5, 2377, 0, 0, 3964, 3966, + 1, 0, 0, 0, 3965, 3954, 1, 0, 0, 0, 3965, 3966, 1, 0, 0, 0, 3966, 3967, + 1, 0, 0, 0, 3967, 3977, 7, 20, 0, 0, 3968, 3970, 5, 356, 0, 0, 3969, 3968, + 1, 0, 0, 0, 3969, 3970, 1, 0, 0, 0, 3970, 3972, 1, 0, 0, 0, 3971, 3973, + 3, 1762, 881, 0, 3972, 3971, 1, 0, 0, 0, 3972, 3973, 1, 0, 0, 0, 3973, + 3974, 1, 0, 0, 0, 3974, 3978, 3, 1838, 919, 0, 3975, 3978, 3, 1748, 874, + 0, 3976, 3978, 5, 507, 0, 0, 3977, 3969, 1, 0, 0, 0, 3977, 3975, 1, 0, + 0, 0, 3977, 3976, 1, 0, 0, 0, 3978, 3979, 1, 0, 0, 0, 3979, 3980, 5, 2396, + 0, 0, 3980, 173, 1, 0, 0, 0, 3981, 3984, 5, 301, 0, 0, 3982, 3983, 5, 1219, + 0, 0, 3983, 3985, 5, 1463, 0, 0, 3984, 3982, 1, 0, 0, 0, 3984, 3985, 1, + 0, 0, 0, 3985, 3986, 1, 0, 0, 0, 3986, 3987, 5, 1365, 0, 0, 3987, 3999, + 3, 2294, 1147, 0, 3988, 3989, 5, 2376, 0, 0, 3989, 3994, 3, 1758, 879, + 0, 3990, 3991, 5, 2382, 0, 0, 3991, 3993, 3, 1758, 879, 0, 3992, 3990, + 1, 0, 0, 0, 3993, 3996, 1, 0, 0, 0, 3994, 3992, 1, 0, 0, 0, 3994, 3995, + 1, 0, 0, 0, 3995, 3997, 1, 0, 0, 0, 3996, 3994, 1, 0, 0, 0, 3997, 3998, + 5, 2377, 0, 0, 3998, 4000, 1, 0, 0, 0, 3999, 3988, 1, 0, 0, 0, 3999, 4000, + 1, 0, 0, 0, 4000, 4002, 1, 0, 0, 0, 4001, 4003, 3, 1746, 873, 0, 4002, + 4001, 1, 0, 0, 0, 4002, 4003, 1, 0, 0, 0, 4003, 4004, 1, 0, 0, 0, 4004, + 4014, 7, 20, 0, 0, 4005, 4007, 5, 356, 0, 0, 4006, 4005, 1, 0, 0, 0, 4006, + 4007, 1, 0, 0, 0, 4007, 4009, 1, 0, 0, 0, 4008, 4010, 3, 1762, 881, 0, + 4009, 4008, 1, 0, 0, 0, 4009, 4010, 1, 0, 0, 0, 4010, 4011, 1, 0, 0, 0, + 4011, 4015, 3, 1838, 919, 0, 4012, 4015, 3, 1748, 874, 0, 4013, 4015, 5, + 507, 0, 0, 4014, 4006, 1, 0, 0, 0, 4014, 4012, 1, 0, 0, 0, 4014, 4013, + 1, 0, 0, 0, 4015, 4016, 1, 0, 0, 0, 4016, 4017, 5, 2396, 0, 0, 4017, 175, + 1, 0, 0, 0, 4018, 4019, 5, 41, 0, 0, 4019, 4020, 5, 1471, 0, 0, 4020, 4023, + 5, 292, 0, 0, 4021, 4022, 7, 28, 0, 0, 4022, 4024, 5, 2370, 0, 0, 4023, + 4021, 1, 0, 0, 0, 4024, 4025, 1, 0, 0, 0, 4025, 4023, 1, 0, 0, 0, 4025, + 4026, 1, 0, 0, 0, 4026, 177, 1, 0, 0, 0, 4027, 4028, 5, 425, 0, 0, 4028, + 4029, 5, 1227, 0, 0, 4029, 4030, 3, 2378, 1189, 0, 4030, 179, 1, 0, 0, + 0, 4031, 4032, 5, 41, 0, 0, 4032, 4033, 5, 1497, 0, 0, 4033, 4034, 5, 1546, + 0, 0, 4034, 4043, 3, 2254, 1127, 0, 4035, 4044, 5, 1173, 0, 0, 4036, 4044, + 5, 1160, 0, 0, 4037, 4044, 3, 1190, 595, 0, 4038, 4041, 5, 1580, 0, 0, + 4039, 4040, 5, 2029, 0, 0, 4040, 4042, 3, 1170, 585, 0, 4041, 4039, 1, + 0, 0, 0, 4041, 4042, 1, 0, 0, 0, 4042, 4044, 1, 0, 0, 0, 4043, 4035, 1, + 0, 0, 0, 4043, 4036, 1, 0, 0, 0, 4043, 4037, 1, 0, 0, 0, 4043, 4038, 1, + 0, 0, 0, 4044, 181, 1, 0, 0, 0, 4045, 4046, 5, 425, 0, 0, 4046, 4047, 5, + 1475, 0, 0, 4047, 4048, 5, 1317, 0, 0, 4048, 4053, 3, 2378, 1189, 0, 4049, + 4050, 5, 564, 0, 0, 4050, 4051, 5, 1315, 0, 0, 4051, 4052, 5, 329, 0, 0, + 4052, 4054, 3, 2378, 1189, 0, 4053, 4049, 1, 0, 0, 0, 4053, 4054, 1, 0, + 0, 0, 4054, 183, 1, 0, 0, 0, 4055, 4056, 5, 425, 0, 0, 4056, 4057, 5, 1497, + 0, 0, 4057, 4058, 5, 1546, 0, 0, 4058, 4059, 3, 2254, 1127, 0, 4059, 185, + 1, 0, 0, 0, 4060, 4061, 5, 425, 0, 0, 4061, 4062, 5, 1494, 0, 0, 4062, + 4063, 3, 2280, 1140, 0, 4063, 4064, 5, 2396, 0, 0, 4064, 187, 1, 0, 0, + 0, 4065, 4066, 5, 301, 0, 0, 4066, 4067, 5, 1316, 0, 0, 4067, 4068, 5, + 537, 0, 0, 4068, 4070, 3, 2378, 1189, 0, 4069, 4071, 3, 190, 95, 0, 4070, + 4069, 1, 0, 0, 0, 4071, 4072, 1, 0, 0, 0, 4072, 4070, 1, 0, 0, 0, 4072, + 4073, 1, 0, 0, 0, 4073, 189, 1, 0, 0, 0, 4074, 4075, 5, 919, 0, 0, 4075, + 4085, 3, 192, 96, 0, 4076, 4077, 5, 97, 0, 0, 4077, 4079, 3, 1472, 736, + 0, 4078, 4080, 5, 1488, 0, 0, 4079, 4078, 1, 0, 0, 0, 4079, 4080, 1, 0, + 0, 0, 4080, 4085, 1, 0, 0, 0, 4081, 4082, 7, 29, 0, 0, 4082, 4085, 3, 1170, + 585, 0, 4083, 4085, 3, 918, 459, 0, 4084, 4074, 1, 0, 0, 0, 4084, 4076, + 1, 0, 0, 0, 4084, 4081, 1, 0, 0, 0, 4084, 4083, 1, 0, 0, 0, 4085, 191, + 1, 0, 0, 0, 4086, 4087, 5, 2372, 0, 0, 4087, 193, 1, 0, 0, 0, 4088, 4090, + 5, 301, 0, 0, 4089, 4091, 5, 1377, 0, 0, 4090, 4089, 1, 0, 0, 0, 4090, + 4091, 1, 0, 0, 0, 4091, 4092, 1, 0, 0, 0, 4092, 4093, 5, 1497, 0, 0, 4093, + 4094, 5, 1546, 0, 0, 4094, 4100, 3, 2254, 1127, 0, 4095, 4096, 5, 1973, + 0, 0, 4096, 4099, 3, 1666, 833, 0, 4097, 4099, 3, 1190, 595, 0, 4098, 4095, + 1, 0, 0, 0, 4098, 4097, 1, 0, 0, 0, 4099, 4102, 1, 0, 0, 0, 4100, 4098, + 1, 0, 0, 0, 4100, 4101, 1, 0, 0, 0, 4101, 195, 1, 0, 0, 0, 4102, 4100, + 1, 0, 0, 0, 4103, 4104, 5, 425, 0, 0, 4104, 4105, 5, 2044, 0, 0, 4105, + 4106, 3, 2296, 1148, 0, 4106, 4107, 5, 2396, 0, 0, 4107, 197, 1, 0, 0, + 0, 4108, 4109, 5, 41, 0, 0, 4109, 4110, 5, 2044, 0, 0, 4110, 4129, 3, 2296, + 1148, 0, 4111, 4130, 7, 17, 0, 0, 4112, 4113, 5, 1460, 0, 0, 4113, 4114, + 5, 2029, 0, 0, 4114, 4130, 3, 2296, 1148, 0, 4115, 4117, 5, 233, 0, 0, + 4116, 4118, 5, 352, 0, 0, 4117, 4116, 1, 0, 0, 0, 4117, 4118, 1, 0, 0, + 0, 4118, 4122, 1, 0, 0, 0, 4119, 4121, 3, 808, 404, 0, 4120, 4119, 1, 0, + 0, 0, 4121, 4124, 1, 0, 0, 0, 4122, 4120, 1, 0, 0, 0, 4122, 4123, 1, 0, + 0, 0, 4123, 4127, 1, 0, 0, 0, 4124, 4122, 1, 0, 0, 0, 4125, 4126, 5, 1488, + 0, 0, 4126, 4128, 5, 1570, 0, 0, 4127, 4125, 1, 0, 0, 0, 4127, 4128, 1, + 0, 0, 0, 4128, 4130, 1, 0, 0, 0, 4129, 4111, 1, 0, 0, 0, 4129, 4112, 1, + 0, 0, 0, 4129, 4115, 1, 0, 0, 0, 4130, 4131, 1, 0, 0, 0, 4131, 4132, 5, + 2396, 0, 0, 4132, 199, 1, 0, 0, 0, 4133, 4136, 5, 301, 0, 0, 4134, 4135, + 5, 1219, 0, 0, 4135, 4137, 5, 1463, 0, 0, 4136, 4134, 1, 0, 0, 0, 4136, + 4137, 1, 0, 0, 0, 4137, 4138, 1, 0, 0, 0, 4138, 4139, 5, 2044, 0, 0, 4139, + 4143, 3, 2296, 1148, 0, 4140, 4144, 3, 206, 103, 0, 4141, 4144, 3, 210, + 105, 0, 4142, 4144, 3, 212, 106, 0, 4143, 4140, 1, 0, 0, 0, 4143, 4141, + 1, 0, 0, 0, 4143, 4142, 1, 0, 0, 0, 4144, 4146, 1, 0, 0, 0, 4145, 4147, + 3, 202, 101, 0, 4146, 4145, 1, 0, 0, 0, 4146, 4147, 1, 0, 0, 0, 4147, 4149, + 1, 0, 0, 0, 4148, 4150, 7, 17, 0, 0, 4149, 4148, 1, 0, 0, 0, 4149, 4150, + 1, 0, 0, 0, 4150, 4152, 1, 0, 0, 0, 4151, 4153, 3, 204, 102, 0, 4152, 4151, + 1, 0, 0, 0, 4152, 4153, 1, 0, 0, 0, 4153, 4154, 1, 0, 0, 0, 4154, 4155, + 3, 214, 107, 0, 4155, 4156, 5, 2396, 0, 0, 4156, 201, 1, 0, 0, 0, 4157, + 4158, 5, 558, 0, 0, 4158, 4163, 3, 2296, 1148, 0, 4159, 4160, 5, 2382, + 0, 0, 4160, 4162, 3, 2296, 1148, 0, 4161, 4159, 1, 0, 0, 0, 4162, 4165, + 1, 0, 0, 0, 4163, 4161, 1, 0, 0, 0, 4163, 4164, 1, 0, 0, 0, 4164, 203, + 1, 0, 0, 0, 4165, 4163, 1, 0, 0, 0, 4166, 4167, 5, 2180, 0, 0, 4167, 4168, + 5, 2376, 0, 0, 4168, 4169, 3, 2072, 1036, 0, 4169, 4170, 5, 2377, 0, 0, + 4170, 205, 1, 0, 0, 0, 4171, 4176, 5, 106, 0, 0, 4172, 4176, 5, 32, 0, + 0, 4173, 4174, 5, 704, 0, 0, 4174, 4176, 5, 1163, 0, 0, 4175, 4171, 1, + 0, 0, 0, 4175, 4172, 1, 0, 0, 0, 4175, 4173, 1, 0, 0, 0, 4176, 4177, 1, + 0, 0, 0, 4177, 4179, 3, 224, 112, 0, 4178, 4180, 3, 230, 115, 0, 4179, + 4178, 1, 0, 0, 0, 4179, 4180, 1, 0, 0, 0, 4180, 4182, 1, 0, 0, 0, 4181, + 4183, 3, 208, 104, 0, 4182, 4181, 1, 0, 0, 0, 4182, 4183, 1, 0, 0, 0, 4183, + 207, 1, 0, 0, 0, 4184, 4185, 5, 564, 0, 0, 4185, 4186, 5, 436, 0, 0, 4186, + 4187, 5, 1507, 0, 0, 4187, 209, 1, 0, 0, 0, 4188, 4189, 5, 564, 0, 0, 4189, + 4191, 3, 224, 112, 0, 4190, 4192, 3, 230, 115, 0, 4191, 4190, 1, 0, 0, + 0, 4191, 4192, 1, 0, 0, 0, 4192, 211, 1, 0, 0, 0, 4193, 4194, 7, 30, 0, + 0, 4194, 4199, 3, 222, 111, 0, 4195, 4196, 5, 1219, 0, 0, 4196, 4198, 3, + 222, 111, 0, 4197, 4195, 1, 0, 0, 0, 4198, 4201, 1, 0, 0, 0, 4199, 4197, + 1, 0, 0, 0, 4199, 4200, 1, 0, 0, 0, 4200, 4202, 1, 0, 0, 0, 4201, 4199, + 1, 0, 0, 0, 4202, 4210, 5, 1175, 0, 0, 4203, 4211, 5, 329, 0, 0, 4204, + 4205, 3, 2258, 1129, 0, 4205, 4206, 5, 2369, 0, 0, 4206, 4208, 1, 0, 0, + 0, 4207, 4204, 1, 0, 0, 0, 4207, 4208, 1, 0, 0, 0, 4208, 4209, 1, 0, 0, + 0, 4209, 4211, 5, 1526, 0, 0, 4210, 4203, 1, 0, 0, 0, 4210, 4207, 1, 0, + 0, 0, 4211, 213, 1, 0, 0, 0, 4212, 4213, 5, 241, 0, 0, 4213, 4218, 5, 2044, + 0, 0, 4214, 4215, 5, 162, 0, 0, 4215, 4218, 3, 2376, 1188, 0, 4216, 4218, + 3, 1842, 921, 0, 4217, 4212, 1, 0, 0, 0, 4217, 4214, 1, 0, 0, 0, 4217, + 4216, 1, 0, 0, 0, 4218, 215, 1, 0, 0, 0, 4219, 4221, 3, 2260, 1130, 0, + 4220, 4222, 3, 2334, 1167, 0, 4221, 4220, 1, 0, 0, 0, 4221, 4222, 1, 0, + 0, 0, 4222, 217, 1, 0, 0, 0, 4223, 4224, 5, 241, 0, 0, 4224, 4226, 5, 2044, + 0, 0, 4225, 4227, 3, 1762, 881, 0, 4226, 4225, 1, 0, 0, 0, 4226, 4227, + 1, 0, 0, 0, 4227, 4229, 1, 0, 0, 0, 4228, 4230, 3, 220, 110, 0, 4229, 4228, + 1, 0, 0, 0, 4230, 4231, 1, 0, 0, 0, 4231, 4229, 1, 0, 0, 0, 4231, 4232, + 1, 0, 0, 0, 4232, 4233, 1, 0, 0, 0, 4233, 4234, 5, 459, 0, 0, 4234, 4235, + 3, 2296, 1148, 0, 4235, 219, 1, 0, 0, 0, 4236, 4237, 5, 106, 0, 0, 4237, + 4238, 5, 1636, 0, 0, 4238, 4239, 5, 723, 0, 0, 4239, 4240, 3, 1842, 921, + 0, 4240, 4241, 5, 106, 0, 0, 4241, 4242, 5, 1636, 0, 0, 4242, 4243, 5, + 2396, 0, 0, 4243, 4273, 1, 0, 0, 0, 4244, 4245, 5, 106, 0, 0, 4245, 4246, + 5, 436, 0, 0, 4246, 4247, 5, 1507, 0, 0, 4247, 4248, 5, 723, 0, 0, 4248, + 4249, 3, 1842, 921, 0, 4249, 4250, 5, 106, 0, 0, 4250, 4251, 5, 436, 0, + 0, 4251, 4252, 5, 1507, 0, 0, 4252, 4253, 5, 2396, 0, 0, 4253, 4273, 1, + 0, 0, 0, 4254, 4255, 5, 32, 0, 0, 4255, 4256, 5, 1636, 0, 0, 4256, 4257, + 5, 723, 0, 0, 4257, 4258, 3, 1842, 921, 0, 4258, 4259, 5, 32, 0, 0, 4259, + 4260, 5, 1636, 0, 0, 4260, 4261, 5, 2396, 0, 0, 4261, 4273, 1, 0, 0, 0, + 4262, 4263, 5, 32, 0, 0, 4263, 4264, 5, 436, 0, 0, 4264, 4265, 5, 1507, + 0, 0, 4265, 4266, 5, 723, 0, 0, 4266, 4267, 3, 1842, 921, 0, 4267, 4268, + 5, 32, 0, 0, 4268, 4269, 5, 436, 0, 0, 4269, 4270, 5, 1507, 0, 0, 4270, + 4271, 5, 2396, 0, 0, 4271, 4273, 1, 0, 0, 0, 4272, 4236, 1, 0, 0, 0, 4272, + 4244, 1, 0, 0, 0, 4272, 4254, 1, 0, 0, 0, 4272, 4262, 1, 0, 0, 0, 4273, + 221, 1, 0, 0, 0, 4274, 4301, 5, 41, 0, 0, 4275, 4301, 5, 45, 0, 0, 4276, + 4277, 5, 74, 0, 0, 4277, 4301, 5, 1639, 0, 0, 4278, 4301, 5, 82, 0, 0, + 4279, 4301, 5, 226, 0, 0, 4280, 4301, 5, 301, 0, 0, 4281, 4282, 5, 403, + 0, 0, 4282, 4301, 5, 1639, 0, 0, 4283, 4301, 5, 425, 0, 0, 4284, 4301, + 5, 591, 0, 0, 4285, 4301, 5, 987, 0, 0, 4286, 4301, 5, 1460, 0, 0, 4287, + 4301, 5, 1490, 0, 0, 4288, 4301, 5, 2046, 0, 0, 4289, 4301, 5, 350, 0, + 0, 4290, 4301, 5, 1632, 0, 0, 4291, 4301, 5, 1581, 0, 0, 4292, 4301, 5, + 346, 0, 0, 4293, 4301, 5, 822, 0, 0, 4294, 4301, 5, 821, 0, 0, 4295, 4301, + 5, 1559, 0, 0, 4296, 4301, 5, 1683, 0, 0, 4297, 4301, 5, 329, 0, 0, 4298, + 4301, 5, 1526, 0, 0, 4299, 4301, 5, 558, 0, 0, 4300, 4274, 1, 0, 0, 0, + 4300, 4275, 1, 0, 0, 0, 4300, 4276, 1, 0, 0, 0, 4300, 4278, 1, 0, 0, 0, + 4300, 4279, 1, 0, 0, 0, 4300, 4280, 1, 0, 0, 0, 4300, 4281, 1, 0, 0, 0, + 4300, 4283, 1, 0, 0, 0, 4300, 4284, 1, 0, 0, 0, 4300, 4285, 1, 0, 0, 0, + 4300, 4286, 1, 0, 0, 0, 4300, 4287, 1, 0, 0, 0, 4300, 4288, 1, 0, 0, 0, + 4300, 4289, 1, 0, 0, 0, 4300, 4290, 1, 0, 0, 0, 4300, 4291, 1, 0, 0, 0, + 4300, 4292, 1, 0, 0, 0, 4300, 4293, 1, 0, 0, 0, 4300, 4294, 1, 0, 0, 0, + 4300, 4295, 1, 0, 0, 0, 4300, 4296, 1, 0, 0, 0, 4300, 4297, 1, 0, 0, 0, + 4300, 4298, 1, 0, 0, 0, 4300, 4299, 1, 0, 0, 0, 4301, 223, 1, 0, 0, 0, + 4302, 4307, 3, 226, 113, 0, 4303, 4304, 5, 1219, 0, 0, 4304, 4306, 3, 226, + 113, 0, 4305, 4303, 1, 0, 0, 0, 4306, 4309, 1, 0, 0, 0, 4307, 4305, 1, + 0, 0, 0, 4307, 4308, 1, 0, 0, 0, 4308, 4310, 1, 0, 0, 0, 4309, 4307, 1, + 0, 0, 0, 4310, 4312, 5, 1175, 0, 0, 4311, 4313, 3, 228, 114, 0, 4312, 4311, + 1, 0, 0, 0, 4312, 4313, 1, 0, 0, 0, 4313, 4314, 1, 0, 0, 0, 4314, 4315, + 3, 2312, 1156, 0, 4315, 225, 1, 0, 0, 0, 4316, 4319, 7, 31, 0, 0, 4317, + 4318, 5, 1163, 0, 0, 4318, 4320, 3, 2328, 1164, 0, 4319, 4317, 1, 0, 0, + 0, 4319, 4320, 1, 0, 0, 0, 4320, 227, 1, 0, 0, 0, 4321, 4322, 5, 942, 0, + 0, 4322, 4323, 5, 1976, 0, 0, 4323, 4324, 3, 2312, 1156, 0, 4324, 4325, + 5, 1163, 0, 0, 4325, 229, 1, 0, 0, 0, 4326, 4328, 5, 1430, 0, 0, 4327, + 4329, 3, 232, 116, 0, 4328, 4327, 1, 0, 0, 0, 4329, 4330, 1, 0, 0, 0, 4330, + 4328, 1, 0, 0, 0, 4330, 4331, 1, 0, 0, 0, 4331, 231, 1, 0, 0, 0, 4332, + 4333, 7, 32, 0, 0, 4333, 4334, 3, 2236, 1118, 0, 4334, 233, 1, 0, 0, 0, + 4335, 4336, 5, 425, 0, 0, 4336, 4338, 5, 2053, 0, 0, 4337, 4339, 5, 138, + 0, 0, 4338, 4337, 1, 0, 0, 0, 4338, 4339, 1, 0, 0, 0, 4339, 4340, 1, 0, + 0, 0, 4340, 4342, 3, 2286, 1143, 0, 4341, 4343, 7, 33, 0, 0, 4342, 4341, + 1, 0, 0, 0, 4342, 4343, 1, 0, 0, 0, 4343, 4344, 1, 0, 0, 0, 4344, 4345, + 5, 2396, 0, 0, 4345, 235, 1, 0, 0, 0, 4346, 4347, 5, 41, 0, 0, 4347, 4348, + 5, 2053, 0, 0, 4348, 4355, 3, 2286, 1143, 0, 4349, 4356, 3, 238, 119, 0, + 4350, 4356, 3, 240, 120, 0, 4351, 4356, 3, 242, 121, 0, 4352, 4356, 3, + 250, 125, 0, 4353, 4356, 3, 284, 142, 0, 4354, 4356, 3, 296, 148, 0, 4355, + 4349, 1, 0, 0, 0, 4355, 4350, 1, 0, 0, 0, 4355, 4351, 1, 0, 0, 0, 4355, + 4352, 1, 0, 0, 0, 4355, 4353, 1, 0, 0, 0, 4355, 4354, 1, 0, 0, 0, 4356, + 4358, 1, 0, 0, 0, 4357, 4359, 3, 252, 126, 0, 4358, 4357, 1, 0, 0, 0, 4358, + 4359, 1, 0, 0, 0, 4359, 4360, 1, 0, 0, 0, 4360, 4361, 5, 2396, 0, 0, 4361, + 237, 1, 0, 0, 0, 4362, 4364, 5, 233, 0, 0, 4363, 4365, 5, 352, 0, 0, 4364, + 4363, 1, 0, 0, 0, 4364, 4365, 1, 0, 0, 0, 4365, 4367, 1, 0, 0, 0, 4366, + 4368, 7, 34, 0, 0, 4367, 4366, 1, 0, 0, 0, 4367, 4368, 1, 0, 0, 0, 4368, + 4372, 1, 0, 0, 0, 4369, 4371, 3, 808, 404, 0, 4370, 4369, 1, 0, 0, 0, 4371, + 4374, 1, 0, 0, 0, 4372, 4370, 1, 0, 0, 0, 4372, 4373, 1, 0, 0, 0, 4373, + 4377, 1, 0, 0, 0, 4374, 4372, 1, 0, 0, 0, 4375, 4376, 5, 1488, 0, 0, 4376, + 4378, 5, 1570, 0, 0, 4377, 4375, 1, 0, 0, 0, 4377, 4378, 1, 0, 0, 0, 4378, + 239, 1, 0, 0, 0, 4379, 4381, 5, 1463, 0, 0, 4380, 4382, 3, 1746, 873, 0, + 4381, 4380, 1, 0, 0, 0, 4381, 4382, 1, 0, 0, 0, 4382, 4383, 1, 0, 0, 0, + 4383, 4384, 5, 66, 0, 0, 4384, 4385, 5, 1155, 0, 0, 4385, 4386, 5, 2376, + 0, 0, 4386, 4391, 3, 286, 143, 0, 4387, 4388, 5, 2382, 0, 0, 4388, 4390, + 3, 286, 143, 0, 4389, 4387, 1, 0, 0, 0, 4390, 4393, 1, 0, 0, 0, 4391, 4389, + 1, 0, 0, 0, 4391, 4392, 1, 0, 0, 0, 4392, 4394, 1, 0, 0, 0, 4393, 4391, + 1, 0, 0, 0, 4394, 4395, 5, 2377, 0, 0, 4395, 241, 1, 0, 0, 0, 4396, 4401, + 3, 244, 122, 0, 4397, 4398, 5, 2382, 0, 0, 4398, 4400, 3, 244, 122, 0, + 4399, 4397, 1, 0, 0, 0, 4400, 4403, 1, 0, 0, 0, 4401, 4399, 1, 0, 0, 0, + 4401, 4402, 1, 0, 0, 0, 4402, 243, 1, 0, 0, 0, 4403, 4401, 1, 0, 0, 0, + 4404, 4407, 7, 9, 0, 0, 4405, 4408, 3, 306, 153, 0, 4406, 4408, 3, 294, + 147, 0, 4407, 4405, 1, 0, 0, 0, 4407, 4406, 1, 0, 0, 0, 4408, 245, 1, 0, + 0, 0, 4409, 4410, 7, 35, 0, 0, 4410, 4423, 5, 80, 0, 0, 4411, 4424, 3, + 248, 124, 0, 4412, 4413, 5, 2376, 0, 0, 4413, 4418, 3, 248, 124, 0, 4414, + 4415, 5, 2382, 0, 0, 4415, 4417, 3, 248, 124, 0, 4416, 4414, 1, 0, 0, 0, + 4417, 4420, 1, 0, 0, 0, 4418, 4416, 1, 0, 0, 0, 4418, 4419, 1, 0, 0, 0, + 4419, 4421, 1, 0, 0, 0, 4420, 4418, 1, 0, 0, 0, 4421, 4422, 5, 2377, 0, + 0, 4422, 4424, 1, 0, 0, 0, 4423, 4411, 1, 0, 0, 0, 4423, 4412, 1, 0, 0, + 0, 4424, 247, 1, 0, 0, 0, 4425, 4427, 3, 2250, 1125, 0, 4426, 4428, 3, + 2344, 1172, 0, 4427, 4426, 1, 0, 0, 0, 4427, 4428, 1, 0, 0, 0, 4428, 249, + 1, 0, 0, 0, 4429, 4435, 5, 909, 0, 0, 4430, 4431, 5, 793, 0, 0, 4431, 4436, + 3, 2078, 1039, 0, 4432, 4433, 5, 441, 0, 0, 4433, 4434, 5, 2053, 0, 0, + 4434, 4436, 3, 2344, 1172, 0, 4435, 4430, 1, 0, 0, 0, 4435, 4432, 1, 0, + 0, 0, 4436, 251, 1, 0, 0, 0, 4437, 4454, 5, 720, 0, 0, 4438, 4448, 5, 168, + 0, 0, 4439, 4440, 5, 281, 0, 0, 4440, 4441, 5, 2029, 0, 0, 4441, 4449, + 5, 1673, 0, 0, 4442, 4444, 5, 1121, 0, 0, 4443, 4442, 1, 0, 0, 0, 4443, + 4444, 1, 0, 0, 0, 4444, 4445, 1, 0, 0, 0, 4445, 4446, 5, 647, 0, 0, 4446, + 4447, 5, 1976, 0, 0, 4447, 4449, 5, 330, 0, 0, 4448, 4439, 1, 0, 0, 0, + 4448, 4443, 1, 0, 0, 0, 4448, 4449, 1, 0, 0, 0, 4449, 4451, 1, 0, 0, 0, + 4450, 4452, 3, 254, 127, 0, 4451, 4450, 1, 0, 0, 0, 4451, 4452, 1, 0, 0, + 0, 4452, 4454, 1, 0, 0, 0, 4453, 4437, 1, 0, 0, 0, 4453, 4438, 1, 0, 0, + 0, 4454, 253, 1, 0, 0, 0, 4455, 4457, 5, 560, 0, 0, 4456, 4455, 1, 0, 0, + 0, 4456, 4457, 1, 0, 0, 0, 4457, 4458, 1, 0, 0, 0, 4458, 4459, 5, 484, + 0, 0, 4459, 4460, 5, 719, 0, 0, 4460, 4461, 3, 2312, 1156, 0, 4461, 255, + 1, 0, 0, 0, 4462, 4465, 5, 301, 0, 0, 4463, 4464, 5, 1219, 0, 0, 4464, + 4466, 5, 1463, 0, 0, 4465, 4463, 1, 0, 0, 0, 4465, 4466, 1, 0, 0, 0, 4466, + 4467, 1, 0, 0, 0, 4467, 4470, 5, 2053, 0, 0, 4468, 4471, 3, 258, 129, 0, + 4469, 4471, 3, 270, 135, 0, 4470, 4468, 1, 0, 0, 0, 4470, 4469, 1, 0, 0, + 0, 4471, 4472, 1, 0, 0, 0, 4472, 4473, 5, 2396, 0, 0, 4473, 257, 1, 0, + 0, 0, 4474, 4477, 3, 2286, 1143, 0, 4475, 4476, 5, 1165, 0, 0, 4476, 4478, + 5, 2372, 0, 0, 4477, 4475, 1, 0, 0, 0, 4477, 4478, 1, 0, 0, 0, 4478, 4480, + 1, 0, 0, 0, 4479, 4481, 5, 560, 0, 0, 4480, 4479, 1, 0, 0, 0, 4480, 4481, + 1, 0, 0, 0, 4481, 4483, 1, 0, 0, 0, 4482, 4484, 3, 260, 130, 0, 4483, 4482, + 1, 0, 0, 0, 4483, 4484, 1, 0, 0, 0, 4484, 259, 1, 0, 0, 0, 4485, 4487, + 3, 1746, 873, 0, 4486, 4485, 1, 0, 0, 0, 4486, 4487, 1, 0, 0, 0, 4487, + 4490, 1, 0, 0, 0, 4488, 4491, 3, 262, 131, 0, 4489, 4491, 3, 264, 132, + 0, 4490, 4488, 1, 0, 0, 0, 4490, 4489, 1, 0, 0, 0, 4491, 4493, 1, 0, 0, + 0, 4492, 4494, 3, 268, 134, 0, 4493, 4492, 1, 0, 0, 0, 4493, 4494, 1, 0, + 0, 0, 4494, 4506, 1, 0, 0, 0, 4495, 4496, 5, 2376, 0, 0, 4496, 4501, 3, + 286, 143, 0, 4497, 4498, 5, 2382, 0, 0, 4498, 4500, 3, 286, 143, 0, 4499, + 4497, 1, 0, 0, 0, 4500, 4503, 1, 0, 0, 0, 4501, 4499, 1, 0, 0, 0, 4501, + 4502, 1, 0, 0, 0, 4502, 4504, 1, 0, 0, 0, 4503, 4501, 1, 0, 0, 0, 4504, + 4505, 5, 2377, 0, 0, 4505, 4507, 1, 0, 0, 0, 4506, 4495, 1, 0, 0, 0, 4506, + 4507, 1, 0, 0, 0, 4507, 4511, 1, 0, 0, 0, 4508, 4510, 3, 284, 142, 0, 4509, + 4508, 1, 0, 0, 0, 4510, 4513, 1, 0, 0, 0, 4511, 4509, 1, 0, 0, 0, 4511, + 4512, 1, 0, 0, 0, 4512, 261, 1, 0, 0, 0, 4513, 4511, 1, 0, 0, 0, 4514, + 4518, 7, 20, 0, 0, 4515, 4519, 5, 1155, 0, 0, 4516, 4519, 3, 1790, 895, + 0, 4517, 4519, 3, 266, 133, 0, 4518, 4515, 1, 0, 0, 0, 4518, 4516, 1, 0, + 0, 0, 4518, 4517, 1, 0, 0, 0, 4519, 263, 1, 0, 0, 0, 4520, 4521, 5, 2063, + 0, 0, 4521, 4522, 3, 2344, 1172, 0, 4522, 265, 1, 0, 0, 0, 4523, 4524, + 5, 1976, 0, 0, 4524, 4525, 5, 1163, 0, 0, 4525, 4528, 3, 2344, 1172, 0, + 4526, 4527, 5, 1121, 0, 0, 4527, 4529, 5, 1145, 0, 0, 4528, 4526, 1, 0, + 0, 0, 4528, 4529, 1, 0, 0, 0, 4529, 267, 1, 0, 0, 0, 4530, 4531, 5, 507, + 0, 0, 4531, 4532, 5, 926, 0, 0, 4532, 4533, 3, 2078, 1039, 0, 4533, 4534, + 5, 760, 0, 0, 4534, 4535, 5, 729, 0, 0, 4535, 4536, 5, 2129, 0, 0, 4536, + 4537, 7, 36, 0, 0, 4537, 269, 1, 0, 0, 0, 4538, 4539, 5, 138, 0, 0, 4539, + 4540, 3, 2286, 1143, 0, 4540, 4542, 7, 20, 0, 0, 4541, 4543, 3, 272, 136, + 0, 4542, 4541, 1, 0, 0, 0, 4543, 4544, 1, 0, 0, 0, 4544, 4542, 1, 0, 0, + 0, 4544, 4545, 1, 0, 0, 0, 4545, 4546, 1, 0, 0, 0, 4546, 4547, 5, 459, + 0, 0, 4547, 271, 1, 0, 0, 0, 4548, 4552, 3, 274, 137, 0, 4549, 4552, 3, + 276, 138, 0, 4550, 4552, 3, 296, 148, 0, 4551, 4548, 1, 0, 0, 0, 4551, + 4549, 1, 0, 0, 0, 4551, 4550, 1, 0, 0, 0, 4552, 273, 1, 0, 0, 0, 4553, + 4554, 7, 37, 0, 0, 4554, 4555, 5, 865, 0, 0, 4555, 4556, 3, 280, 140, 0, + 4556, 275, 1, 0, 0, 0, 4557, 4561, 7, 38, 0, 0, 4558, 4562, 3, 278, 139, + 0, 4559, 4562, 3, 280, 140, 0, 4560, 4562, 3, 282, 141, 0, 4561, 4558, + 1, 0, 0, 0, 4561, 4559, 1, 0, 0, 0, 4561, 4560, 1, 0, 0, 0, 4562, 277, + 1, 0, 0, 0, 4563, 4564, 5, 1365, 0, 0, 4564, 4565, 3, 2294, 1147, 0, 4565, + 4566, 5, 2376, 0, 0, 4566, 4571, 3, 312, 156, 0, 4567, 4568, 5, 2382, 0, + 0, 4568, 4570, 3, 312, 156, 0, 4569, 4567, 1, 0, 0, 0, 4570, 4573, 1, 0, + 0, 0, 4571, 4569, 1, 0, 0, 0, 4571, 4572, 1, 0, 0, 0, 4572, 4574, 1, 0, + 0, 0, 4573, 4571, 1, 0, 0, 0, 4574, 4575, 5, 2377, 0, 0, 4575, 4586, 7, + 20, 0, 0, 4576, 4587, 3, 1748, 874, 0, 4577, 4579, 5, 356, 0, 0, 4578, + 4577, 1, 0, 0, 0, 4578, 4579, 1, 0, 0, 0, 4579, 4581, 1, 0, 0, 0, 4580, + 4582, 3, 1762, 881, 0, 4581, 4580, 1, 0, 0, 0, 4581, 4582, 1, 0, 0, 0, + 4582, 4583, 1, 0, 0, 0, 4583, 4584, 3, 1838, 919, 0, 4584, 4585, 5, 2396, + 0, 0, 4585, 4587, 1, 0, 0, 0, 4586, 4576, 1, 0, 0, 0, 4586, 4578, 1, 0, + 0, 0, 4587, 279, 1, 0, 0, 0, 4588, 4589, 5, 576, 0, 0, 4589, 4601, 3, 2292, + 1146, 0, 4590, 4591, 5, 2376, 0, 0, 4591, 4596, 3, 312, 156, 0, 4592, 4593, + 5, 2382, 0, 0, 4593, 4595, 3, 312, 156, 0, 4594, 4592, 1, 0, 0, 0, 4595, + 4598, 1, 0, 0, 0, 4596, 4594, 1, 0, 0, 0, 4596, 4597, 1, 0, 0, 0, 4597, + 4599, 1, 0, 0, 0, 4598, 4596, 1, 0, 0, 0, 4599, 4600, 5, 2377, 0, 0, 4600, + 4602, 1, 0, 0, 0, 4601, 4590, 1, 0, 0, 0, 4601, 4602, 1, 0, 0, 0, 4602, + 4603, 1, 0, 0, 0, 4603, 4604, 5, 1487, 0, 0, 4604, 4605, 3, 2344, 1172, + 0, 4605, 4616, 7, 20, 0, 0, 4606, 4617, 3, 1748, 874, 0, 4607, 4609, 5, + 356, 0, 0, 4608, 4607, 1, 0, 0, 0, 4608, 4609, 1, 0, 0, 0, 4609, 4611, + 1, 0, 0, 0, 4610, 4612, 3, 1762, 881, 0, 4611, 4610, 1, 0, 0, 0, 4611, + 4612, 1, 0, 0, 0, 4612, 4613, 1, 0, 0, 0, 4613, 4614, 3, 1838, 919, 0, + 4614, 4615, 5, 2396, 0, 0, 4615, 4617, 1, 0, 0, 0, 4616, 4606, 1, 0, 0, + 0, 4616, 4608, 1, 0, 0, 0, 4617, 281, 1, 0, 0, 0, 4618, 4620, 5, 540, 0, + 0, 4619, 4618, 1, 0, 0, 0, 4619, 4620, 1, 0, 0, 0, 4620, 4622, 1, 0, 0, + 0, 4621, 4623, 5, 702, 0, 0, 4622, 4621, 1, 0, 0, 0, 4622, 4623, 1, 0, + 0, 0, 4623, 4624, 1, 0, 0, 0, 4624, 4625, 5, 269, 0, 0, 4625, 4626, 5, + 576, 0, 0, 4626, 4644, 3, 2344, 1172, 0, 4627, 4628, 5, 2376, 0, 0, 4628, + 4629, 5, 1549, 0, 0, 4629, 4630, 5, 680, 0, 0, 4630, 4631, 5, 1229, 0, + 0, 4631, 4632, 3, 2344, 1172, 0, 4632, 4633, 5, 2382, 0, 0, 4633, 4634, + 1, 0, 0, 0, 4634, 4639, 3, 312, 156, 0, 4635, 4636, 5, 2382, 0, 0, 4636, + 4638, 3, 312, 156, 0, 4637, 4635, 1, 0, 0, 0, 4638, 4641, 1, 0, 0, 0, 4639, + 4637, 1, 0, 0, 0, 4639, 4640, 1, 0, 0, 0, 4640, 4642, 1, 0, 0, 0, 4641, + 4639, 1, 0, 0, 0, 4642, 4643, 5, 2377, 0, 0, 4643, 4645, 1, 0, 0, 0, 4644, + 4627, 1, 0, 0, 0, 4644, 4645, 1, 0, 0, 0, 4645, 4646, 1, 0, 0, 0, 4646, + 4647, 5, 1487, 0, 0, 4647, 4648, 5, 1549, 0, 0, 4648, 4649, 5, 66, 0, 0, + 4649, 4650, 5, 1481, 0, 0, 4650, 4661, 7, 20, 0, 0, 4651, 4662, 3, 1748, + 874, 0, 4652, 4654, 5, 356, 0, 0, 4653, 4652, 1, 0, 0, 0, 4653, 4654, 1, + 0, 0, 0, 4654, 4656, 1, 0, 0, 0, 4655, 4657, 3, 1762, 881, 0, 4656, 4655, + 1, 0, 0, 0, 4656, 4657, 1, 0, 0, 0, 4657, 4658, 1, 0, 0, 0, 4658, 4659, + 3, 1838, 919, 0, 4659, 4660, 5, 2396, 0, 0, 4660, 4662, 1, 0, 0, 0, 4661, + 4651, 1, 0, 0, 0, 4661, 4653, 1, 0, 0, 0, 4662, 283, 1, 0, 0, 0, 4663, + 4665, 5, 1121, 0, 0, 4664, 4663, 1, 0, 0, 0, 4664, 4665, 1, 0, 0, 0, 4665, + 4666, 1, 0, 0, 0, 4666, 4667, 7, 39, 0, 0, 4667, 285, 1, 0, 0, 0, 4668, + 4669, 3, 2376, 1188, 0, 4669, 4671, 3, 2344, 1172, 0, 4670, 4672, 3, 288, + 144, 0, 4671, 4670, 1, 0, 0, 0, 4671, 4672, 1, 0, 0, 0, 4672, 4675, 1, + 0, 0, 0, 4673, 4675, 3, 290, 145, 0, 4674, 4668, 1, 0, 0, 0, 4674, 4673, + 1, 0, 0, 0, 4675, 287, 1, 0, 0, 0, 4676, 4677, 5, 507, 0, 0, 4677, 4678, + 5, 926, 0, 0, 4678, 4679, 3, 2078, 1039, 0, 4679, 289, 1, 0, 0, 0, 4680, + 4682, 3, 284, 142, 0, 4681, 4680, 1, 0, 0, 0, 4681, 4682, 1, 0, 0, 0, 4682, + 4684, 1, 0, 0, 0, 4683, 4685, 3, 292, 146, 0, 4684, 4683, 1, 0, 0, 0, 4685, + 4686, 1, 0, 0, 0, 4686, 4684, 1, 0, 0, 0, 4686, 4687, 1, 0, 0, 0, 4687, + 4690, 1, 0, 0, 0, 4688, 4689, 5, 2382, 0, 0, 4689, 4691, 3, 308, 154, 0, + 4690, 4688, 1, 0, 0, 0, 4690, 4691, 1, 0, 0, 0, 4691, 291, 1, 0, 0, 0, + 4692, 4696, 3, 294, 147, 0, 4693, 4696, 3, 304, 152, 0, 4694, 4696, 3, + 306, 153, 0, 4695, 4692, 1, 0, 0, 0, 4695, 4693, 1, 0, 0, 0, 4695, 4694, + 1, 0, 0, 0, 4696, 293, 1, 0, 0, 0, 4697, 4700, 7, 38, 0, 0, 4698, 4701, + 3, 300, 150, 0, 4699, 4701, 3, 302, 151, 0, 4700, 4698, 1, 0, 0, 0, 4700, + 4699, 1, 0, 0, 0, 4701, 295, 1, 0, 0, 0, 4702, 4703, 5, 1234, 0, 0, 4703, + 4704, 5, 865, 0, 0, 4704, 4705, 3, 298, 149, 0, 4705, 297, 1, 0, 0, 0, + 4706, 4707, 5, 576, 0, 0, 4707, 4719, 3, 2292, 1146, 0, 4708, 4709, 5, + 2376, 0, 0, 4709, 4714, 3, 312, 156, 0, 4710, 4711, 5, 2382, 0, 0, 4711, + 4713, 3, 312, 156, 0, 4712, 4710, 1, 0, 0, 0, 4713, 4716, 1, 0, 0, 0, 4714, + 4712, 1, 0, 0, 0, 4714, 4715, 1, 0, 0, 0, 4715, 4717, 1, 0, 0, 0, 4716, + 4714, 1, 0, 0, 0, 4717, 4718, 5, 2377, 0, 0, 4718, 4720, 1, 0, 0, 0, 4719, + 4708, 1, 0, 0, 0, 4719, 4720, 1, 0, 0, 0, 4720, 4721, 1, 0, 0, 0, 4721, + 4726, 5, 1487, 0, 0, 4722, 4727, 3, 2344, 1172, 0, 4723, 4724, 5, 1549, + 0, 0, 4724, 4725, 5, 66, 0, 0, 4725, 4727, 5, 1481, 0, 0, 4726, 4722, 1, + 0, 0, 0, 4726, 4723, 1, 0, 0, 0, 4727, 4739, 1, 0, 0, 0, 4728, 4730, 5, + 1300, 0, 0, 4729, 4728, 1, 0, 0, 0, 4729, 4730, 1, 0, 0, 0, 4730, 4731, + 1, 0, 0, 0, 4731, 4733, 7, 20, 0, 0, 4732, 4734, 5, 356, 0, 0, 4733, 4732, + 1, 0, 0, 0, 4733, 4734, 1, 0, 0, 0, 4734, 4736, 1, 0, 0, 0, 4735, 4737, + 3, 1762, 881, 0, 4736, 4735, 1, 0, 0, 0, 4736, 4737, 1, 0, 0, 0, 4737, + 4738, 1, 0, 0, 0, 4738, 4740, 3, 1838, 919, 0, 4739, 4729, 1, 0, 0, 0, + 4739, 4740, 1, 0, 0, 0, 4740, 4742, 1, 0, 0, 0, 4741, 4743, 5, 2396, 0, + 0, 4742, 4741, 1, 0, 0, 0, 4742, 4743, 1, 0, 0, 0, 4743, 299, 1, 0, 0, + 0, 4744, 4745, 5, 1365, 0, 0, 4745, 4746, 3, 2294, 1147, 0, 4746, 4747, + 5, 2376, 0, 0, 4747, 4752, 3, 312, 156, 0, 4748, 4749, 5, 2382, 0, 0, 4749, + 4751, 3, 312, 156, 0, 4750, 4748, 1, 0, 0, 0, 4751, 4754, 1, 0, 0, 0, 4752, + 4750, 1, 0, 0, 0, 4752, 4753, 1, 0, 0, 0, 4753, 4755, 1, 0, 0, 0, 4754, + 4752, 1, 0, 0, 0, 4755, 4758, 5, 2377, 0, 0, 4756, 4757, 7, 20, 0, 0, 4757, + 4759, 3, 1748, 874, 0, 4758, 4756, 1, 0, 0, 0, 4758, 4759, 1, 0, 0, 0, + 4759, 301, 1, 0, 0, 0, 4760, 4761, 5, 576, 0, 0, 4761, 4773, 3, 2292, 1146, + 0, 4762, 4763, 5, 2376, 0, 0, 4763, 4768, 3, 312, 156, 0, 4764, 4765, 5, + 2382, 0, 0, 4765, 4767, 3, 312, 156, 0, 4766, 4764, 1, 0, 0, 0, 4767, 4770, + 1, 0, 0, 0, 4768, 4766, 1, 0, 0, 0, 4768, 4769, 1, 0, 0, 0, 4769, 4771, + 1, 0, 0, 0, 4770, 4768, 1, 0, 0, 0, 4771, 4772, 5, 2377, 0, 0, 4772, 4774, + 1, 0, 0, 0, 4773, 4762, 1, 0, 0, 0, 4773, 4774, 1, 0, 0, 0, 4774, 4775, + 1, 0, 0, 0, 4775, 4780, 5, 1487, 0, 0, 4776, 4781, 3, 2344, 1172, 0, 4777, + 4778, 5, 1549, 0, 0, 4778, 4779, 5, 66, 0, 0, 4779, 4781, 5, 1481, 0, 0, + 4780, 4776, 1, 0, 0, 0, 4780, 4777, 1, 0, 0, 0, 4781, 4790, 1, 0, 0, 0, + 4782, 4783, 7, 20, 0, 0, 4783, 4791, 3, 1748, 874, 0, 4784, 4786, 5, 507, + 0, 0, 4785, 4787, 5, 2144, 0, 0, 4786, 4785, 1, 0, 0, 0, 4786, 4787, 1, + 0, 0, 0, 4787, 4788, 1, 0, 0, 0, 4788, 4789, 5, 926, 0, 0, 4789, 4791, + 3, 2078, 1039, 0, 4790, 4782, 1, 0, 0, 0, 4790, 4784, 1, 0, 0, 0, 4790, + 4791, 1, 0, 0, 0, 4791, 303, 1, 0, 0, 0, 4792, 4794, 5, 540, 0, 0, 4793, + 4792, 1, 0, 0, 0, 4793, 4794, 1, 0, 0, 0, 4794, 4796, 1, 0, 0, 0, 4795, + 4797, 5, 702, 0, 0, 4796, 4795, 1, 0, 0, 0, 4796, 4797, 1, 0, 0, 0, 4797, + 4798, 1, 0, 0, 0, 4798, 4799, 5, 269, 0, 0, 4799, 4800, 5, 576, 0, 0, 4800, + 4818, 3, 2344, 1172, 0, 4801, 4802, 5, 2376, 0, 0, 4802, 4803, 5, 1549, + 0, 0, 4803, 4804, 5, 680, 0, 0, 4804, 4805, 5, 1229, 0, 0, 4805, 4806, + 3, 2344, 1172, 0, 4806, 4807, 5, 2382, 0, 0, 4807, 4808, 1, 0, 0, 0, 4808, + 4813, 3, 312, 156, 0, 4809, 4810, 5, 2382, 0, 0, 4810, 4812, 3, 312, 156, + 0, 4811, 4809, 1, 0, 0, 0, 4812, 4815, 1, 0, 0, 0, 4813, 4811, 1, 0, 0, + 0, 4813, 4814, 1, 0, 0, 0, 4814, 4816, 1, 0, 0, 0, 4815, 4813, 1, 0, 0, + 0, 4816, 4817, 5, 2377, 0, 0, 4817, 4819, 1, 0, 0, 0, 4818, 4801, 1, 0, + 0, 0, 4818, 4819, 1, 0, 0, 0, 4819, 4820, 1, 0, 0, 0, 4820, 4821, 5, 1487, + 0, 0, 4821, 4822, 5, 1549, 0, 0, 4822, 4823, 5, 66, 0, 0, 4823, 4826, 5, + 1481, 0, 0, 4824, 4825, 7, 20, 0, 0, 4825, 4827, 3, 1748, 874, 0, 4826, + 4824, 1, 0, 0, 0, 4826, 4827, 1, 0, 0, 0, 4827, 305, 1, 0, 0, 0, 4828, + 4829, 7, 37, 0, 0, 4829, 4830, 5, 865, 0, 0, 4830, 4831, 3, 302, 151, 0, + 4831, 307, 1, 0, 0, 0, 4832, 4833, 5, 1338, 0, 0, 4833, 4834, 5, 1478, + 0, 0, 4834, 4835, 5, 2376, 0, 0, 4835, 4840, 3, 310, 155, 0, 4836, 4837, + 5, 2382, 0, 0, 4837, 4839, 3, 310, 155, 0, 4838, 4836, 1, 0, 0, 0, 4839, + 4842, 1, 0, 0, 0, 4840, 4838, 1, 0, 0, 0, 4840, 4841, 1, 0, 0, 0, 4841, + 4843, 1, 0, 0, 0, 4842, 4840, 1, 0, 0, 0, 4843, 4844, 5, 2377, 0, 0, 4844, + 309, 1, 0, 0, 0, 4845, 4848, 3, 2376, 1188, 0, 4846, 4848, 5, 363, 0, 0, + 4847, 4845, 1, 0, 0, 0, 4847, 4846, 1, 0, 0, 0, 4848, 311, 1, 0, 0, 0, + 4849, 4850, 3, 2266, 1133, 0, 4850, 4851, 3, 2344, 1172, 0, 4851, 313, + 1, 0, 0, 0, 4852, 4853, 5, 425, 0, 0, 4853, 4854, 5, 1554, 0, 0, 4854, + 4855, 3, 2288, 1144, 0, 4855, 4856, 5, 2396, 0, 0, 4856, 315, 1, 0, 0, + 0, 4857, 4858, 5, 41, 0, 0, 4858, 4859, 5, 1554, 0, 0, 4859, 4861, 3, 2288, + 1144, 0, 4860, 4862, 3, 324, 162, 0, 4861, 4860, 1, 0, 0, 0, 4862, 4863, + 1, 0, 0, 0, 4863, 4861, 1, 0, 0, 0, 4863, 4864, 1, 0, 0, 0, 4864, 4865, + 1, 0, 0, 0, 4865, 4866, 5, 2396, 0, 0, 4866, 317, 1, 0, 0, 0, 4867, 4868, + 5, 41, 0, 0, 4868, 4898, 5, 1564, 0, 0, 4869, 4870, 5, 29, 0, 0, 4870, + 4899, 7, 40, 0, 0, 4871, 4872, 5, 204, 0, 0, 4872, 4873, 5, 329, 0, 0, + 4873, 4874, 5, 795, 0, 0, 4874, 4899, 3, 2266, 1133, 0, 4875, 4876, 3, + 1322, 661, 0, 4876, 4877, 5, 227, 0, 0, 4877, 4878, 5, 680, 0, 0, 4878, + 4879, 5, 1365, 0, 0, 4879, 4899, 1, 0, 0, 0, 4880, 4881, 3, 1322, 661, + 0, 4881, 4882, 5, 600, 0, 0, 4882, 4899, 1, 0, 0, 0, 4883, 4886, 3, 1322, + 661, 0, 4884, 4886, 5, 560, 0, 0, 4885, 4883, 1, 0, 0, 0, 4885, 4884, 1, + 0, 0, 0, 4886, 4887, 1, 0, 0, 0, 4887, 4888, 5, 1243, 0, 0, 4888, 4894, + 7, 41, 0, 0, 4889, 4892, 5, 1243, 0, 0, 4890, 4893, 3, 2170, 1085, 0, 4891, + 4893, 3, 2266, 1133, 0, 4892, 4890, 1, 0, 0, 0, 4892, 4891, 1, 0, 0, 0, + 4893, 4895, 1, 0, 0, 0, 4894, 4889, 1, 0, 0, 0, 4894, 4895, 1, 0, 0, 0, + 4895, 4899, 1, 0, 0, 0, 4896, 4897, 5, 1568, 0, 0, 4897, 4899, 3, 320, + 160, 0, 4898, 4869, 1, 0, 0, 0, 4898, 4871, 1, 0, 0, 0, 4898, 4875, 1, + 0, 0, 0, 4898, 4880, 1, 0, 0, 0, 4898, 4885, 1, 0, 0, 0, 4898, 4896, 1, + 0, 0, 0, 4899, 319, 1, 0, 0, 0, 4900, 4901, 3, 2266, 1133, 0, 4901, 4902, + 5, 2398, 0, 0, 4902, 4903, 3, 810, 405, 0, 4903, 4905, 1, 0, 0, 0, 4904, + 4900, 1, 0, 0, 0, 4905, 4906, 1, 0, 0, 0, 4906, 4904, 1, 0, 0, 0, 4906, + 4907, 1, 0, 0, 0, 4907, 4931, 1, 0, 0, 0, 4908, 4909, 5, 438, 0, 0, 4909, + 4910, 5, 2398, 0, 0, 4910, 4931, 3, 2378, 1189, 0, 4911, 4912, 5, 270, + 0, 0, 4912, 4913, 5, 2398, 0, 0, 4913, 4917, 3, 2378, 1189, 0, 4914, 4915, + 5, 1561, 0, 0, 4915, 4916, 5, 2398, 0, 0, 4916, 4918, 3, 2378, 1189, 0, + 4917, 4914, 1, 0, 0, 0, 4917, 4918, 1, 0, 0, 0, 4918, 4931, 1, 0, 0, 0, + 4919, 4920, 5, 1507, 0, 0, 4920, 4921, 5, 61, 0, 0, 4921, 4922, 5, 2169, + 0, 0, 4922, 4923, 5, 2398, 0, 0, 4923, 4931, 7, 42, 0, 0, 4924, 4925, 5, + 365, 0, 0, 4925, 4928, 5, 2398, 0, 0, 4926, 4929, 3, 2378, 1189, 0, 4927, + 4929, 5, 1054, 0, 0, 4928, 4926, 1, 0, 0, 0, 4928, 4927, 1, 0, 0, 0, 4929, + 4931, 1, 0, 0, 0, 4930, 4904, 1, 0, 0, 0, 4930, 4908, 1, 0, 0, 0, 4930, + 4911, 1, 0, 0, 0, 4930, 4919, 1, 0, 0, 0, 4930, 4924, 1, 0, 0, 0, 4931, + 321, 1, 0, 0, 0, 4932, 4933, 5, 301, 0, 0, 4933, 4934, 5, 1554, 0, 0, 4934, + 4939, 3, 2288, 1144, 0, 4935, 4938, 3, 326, 163, 0, 4936, 4938, 3, 324, + 162, 0, 4937, 4935, 1, 0, 0, 0, 4937, 4936, 1, 0, 0, 0, 4938, 4941, 1, + 0, 0, 0, 4939, 4937, 1, 0, 0, 0, 4939, 4940, 1, 0, 0, 0, 4940, 4942, 1, + 0, 0, 0, 4941, 4939, 1, 0, 0, 0, 4942, 4943, 5, 2396, 0, 0, 4943, 323, + 1, 0, 0, 0, 4944, 4945, 5, 649, 0, 0, 4945, 4946, 5, 151, 0, 0, 4946, 4961, + 5, 2370, 0, 0, 4947, 4948, 5, 861, 0, 0, 4948, 4961, 5, 2370, 0, 0, 4949, + 4961, 5, 1042, 0, 0, 4950, 4951, 5, 889, 0, 0, 4951, 4961, 5, 2370, 0, + 0, 4952, 4961, 5, 1045, 0, 0, 4953, 4961, 5, 327, 0, 0, 4954, 4961, 5, + 1010, 0, 0, 4955, 4956, 5, 155, 0, 0, 4956, 4961, 5, 2370, 0, 0, 4957, + 4961, 5, 993, 0, 0, 4958, 4961, 5, 1215, 0, 0, 4959, 4961, 5, 1060, 0, + 0, 4960, 4944, 1, 0, 0, 0, 4960, 4947, 1, 0, 0, 0, 4960, 4949, 1, 0, 0, + 0, 4960, 4950, 1, 0, 0, 0, 4960, 4952, 1, 0, 0, 0, 4960, 4953, 1, 0, 0, + 0, 4960, 4954, 1, 0, 0, 0, 4960, 4955, 1, 0, 0, 0, 4960, 4957, 1, 0, 0, + 0, 4960, 4958, 1, 0, 0, 0, 4960, 4959, 1, 0, 0, 0, 4961, 325, 1, 0, 0, + 0, 4962, 4963, 5, 1631, 0, 0, 4963, 4964, 5, 2188, 0, 0, 4964, 4965, 5, + 2370, 0, 0, 4965, 327, 1, 0, 0, 0, 4966, 4969, 5, 301, 0, 0, 4967, 4968, + 5, 1219, 0, 0, 4968, 4970, 5, 1463, 0, 0, 4969, 4967, 1, 0, 0, 0, 4969, + 4970, 1, 0, 0, 0, 4970, 4972, 1, 0, 0, 0, 4971, 4973, 7, 7, 0, 0, 4972, + 4971, 1, 0, 0, 0, 4972, 4973, 1, 0, 0, 0, 4973, 4974, 1, 0, 0, 0, 4974, + 4975, 5, 44, 0, 0, 4975, 4976, 5, 2166, 0, 0, 4976, 4980, 3, 2378, 1189, + 0, 4977, 4978, 5, 1577, 0, 0, 4978, 4979, 5, 2398, 0, 0, 4979, 4981, 7, + 43, 0, 0, 4980, 4977, 1, 0, 0, 0, 4980, 4981, 1, 0, 0, 0, 4981, 4985, 1, + 0, 0, 0, 4982, 4984, 3, 330, 165, 0, 4983, 4982, 1, 0, 0, 0, 4984, 4987, + 1, 0, 0, 0, 4985, 4983, 1, 0, 0, 0, 4985, 4986, 1, 0, 0, 0, 4986, 4989, + 1, 0, 0, 0, 4987, 4985, 1, 0, 0, 0, 4988, 4990, 3, 340, 170, 0, 4989, 4988, + 1, 0, 0, 0, 4989, 4990, 1, 0, 0, 0, 4990, 4992, 1, 0, 0, 0, 4991, 4993, + 3, 342, 171, 0, 4992, 4991, 1, 0, 0, 0, 4992, 4993, 1, 0, 0, 0, 4993, 4995, + 1, 0, 0, 0, 4994, 4996, 3, 350, 175, 0, 4995, 4994, 1, 0, 0, 0, 4995, 4996, + 1, 0, 0, 0, 4996, 4998, 1, 0, 0, 0, 4997, 4999, 3, 360, 180, 0, 4998, 4997, + 1, 0, 0, 0, 4998, 4999, 1, 0, 0, 0, 4999, 5001, 1, 0, 0, 0, 5000, 5002, + 3, 362, 181, 0, 5001, 5000, 1, 0, 0, 0, 5001, 5002, 1, 0, 0, 0, 5002, 5004, + 1, 0, 0, 0, 5003, 5005, 3, 364, 182, 0, 5004, 5003, 1, 0, 0, 0, 5004, 5005, + 1, 0, 0, 0, 5005, 5007, 1, 0, 0, 0, 5006, 5008, 3, 374, 187, 0, 5007, 5006, + 1, 0, 0, 0, 5007, 5008, 1, 0, 0, 0, 5008, 5010, 1, 0, 0, 0, 5009, 5011, + 3, 376, 188, 0, 5010, 5009, 1, 0, 0, 0, 5010, 5011, 1, 0, 0, 0, 5011, 329, + 1, 0, 0, 0, 5012, 5014, 3, 332, 166, 0, 5013, 5015, 3, 334, 167, 0, 5014, + 5013, 1, 0, 0, 0, 5014, 5015, 1, 0, 0, 0, 5015, 5021, 1, 0, 0, 0, 5016, + 5018, 3, 332, 166, 0, 5017, 5016, 1, 0, 0, 0, 5017, 5018, 1, 0, 0, 0, 5018, + 5019, 1, 0, 0, 0, 5019, 5021, 3, 334, 167, 0, 5020, 5012, 1, 0, 0, 0, 5020, + 5017, 1, 0, 0, 0, 5021, 5025, 1, 0, 0, 0, 5022, 5024, 3, 336, 168, 0, 5023, + 5022, 1, 0, 0, 0, 5024, 5027, 1, 0, 0, 0, 5025, 5023, 1, 0, 0, 0, 5025, + 5026, 1, 0, 0, 0, 5026, 5040, 1, 0, 0, 0, 5027, 5025, 1, 0, 0, 0, 5028, + 5030, 3, 332, 166, 0, 5029, 5028, 1, 0, 0, 0, 5029, 5030, 1, 0, 0, 0, 5030, + 5032, 1, 0, 0, 0, 5031, 5033, 3, 334, 167, 0, 5032, 5031, 1, 0, 0, 0, 5032, + 5033, 1, 0, 0, 0, 5033, 5035, 1, 0, 0, 0, 5034, 5036, 3, 336, 168, 0, 5035, + 5034, 1, 0, 0, 0, 5036, 5037, 1, 0, 0, 0, 5037, 5035, 1, 0, 0, 0, 5037, + 5038, 1, 0, 0, 0, 5038, 5040, 1, 0, 0, 0, 5039, 5020, 1, 0, 0, 0, 5039, + 5029, 1, 0, 0, 0, 5040, 331, 1, 0, 0, 0, 5041, 5042, 5, 166, 0, 0, 5042, + 5043, 3, 2372, 1186, 0, 5043, 333, 1, 0, 0, 0, 5044, 5045, 5, 386, 0, 0, + 5045, 5046, 3, 2372, 1186, 0, 5046, 335, 1, 0, 0, 0, 5047, 5048, 5, 193, + 0, 0, 5048, 5051, 3, 2378, 1189, 0, 5049, 5050, 5, 2141, 0, 0, 5050, 5052, + 3, 2372, 1186, 0, 5051, 5049, 1, 0, 0, 0, 5051, 5052, 1, 0, 0, 0, 5052, + 5055, 1, 0, 0, 0, 5053, 5054, 5, 760, 0, 0, 5054, 5056, 3, 338, 169, 0, + 5055, 5053, 1, 0, 0, 0, 5055, 5056, 1, 0, 0, 0, 5056, 337, 1, 0, 0, 0, + 5057, 5060, 5, 1145, 0, 0, 5058, 5060, 3, 2378, 1189, 0, 5059, 5057, 1, + 0, 0, 0, 5059, 5058, 1, 0, 0, 0, 5060, 339, 1, 0, 0, 0, 5061, 5065, 5, + 2129, 0, 0, 5062, 5063, 3, 2258, 1129, 0, 5063, 5064, 5, 2369, 0, 0, 5064, + 5066, 1, 0, 0, 0, 5065, 5062, 1, 0, 0, 0, 5065, 5066, 1, 0, 0, 0, 5066, + 5067, 1, 0, 0, 0, 5067, 5069, 3, 2378, 1189, 0, 5068, 5070, 5, 1457, 0, + 0, 5069, 5068, 1, 0, 0, 0, 5069, 5070, 1, 0, 0, 0, 5070, 5075, 1, 0, 0, + 0, 5071, 5073, 5, 66, 0, 0, 5072, 5071, 1, 0, 0, 0, 5072, 5073, 1, 0, 0, + 0, 5073, 5074, 1, 0, 0, 0, 5074, 5076, 3, 2378, 1189, 0, 5075, 5072, 1, + 0, 0, 0, 5075, 5076, 1, 0, 0, 0, 5076, 341, 1, 0, 0, 0, 5077, 5078, 5, + 392, 0, 0, 5078, 5079, 5, 151, 0, 0, 5079, 5080, 5, 2376, 0, 0, 5080, 5085, + 3, 344, 172, 0, 5081, 5082, 5, 2382, 0, 0, 5082, 5084, 3, 344, 172, 0, + 5083, 5081, 1, 0, 0, 0, 5084, 5087, 1, 0, 0, 0, 5085, 5083, 1, 0, 0, 0, + 5085, 5086, 1, 0, 0, 0, 5086, 5088, 1, 0, 0, 0, 5087, 5085, 1, 0, 0, 0, + 5088, 5089, 5, 2377, 0, 0, 5089, 343, 1, 0, 0, 0, 5090, 5094, 3, 346, 173, + 0, 5091, 5093, 3, 330, 165, 0, 5092, 5091, 1, 0, 0, 0, 5093, 5096, 1, 0, + 0, 0, 5094, 5092, 1, 0, 0, 0, 5094, 5095, 1, 0, 0, 0, 5095, 5097, 1, 0, + 0, 0, 5096, 5094, 1, 0, 0, 0, 5097, 5125, 5, 753, 0, 0, 5098, 5102, 5, + 2376, 0, 0, 5099, 5100, 3, 2378, 1189, 0, 5100, 5101, 5, 2369, 0, 0, 5101, + 5103, 1, 0, 0, 0, 5102, 5099, 1, 0, 0, 0, 5102, 5103, 1, 0, 0, 0, 5103, + 5104, 1, 0, 0, 0, 5104, 5114, 3, 2310, 1155, 0, 5105, 5109, 5, 2382, 0, + 0, 5106, 5107, 3, 2378, 1189, 0, 5107, 5108, 5, 2369, 0, 0, 5108, 5110, + 1, 0, 0, 0, 5109, 5106, 1, 0, 0, 0, 5109, 5110, 1, 0, 0, 0, 5110, 5111, + 1, 0, 0, 0, 5111, 5113, 3, 2310, 1155, 0, 5112, 5105, 1, 0, 0, 0, 5113, + 5116, 1, 0, 0, 0, 5114, 5112, 1, 0, 0, 0, 5114, 5115, 1, 0, 0, 0, 5115, + 5117, 1, 0, 0, 0, 5116, 5114, 1, 0, 0, 0, 5117, 5118, 5, 2377, 0, 0, 5118, + 5126, 1, 0, 0, 0, 5119, 5120, 3, 2378, 1189, 0, 5120, 5121, 5, 2369, 0, + 0, 5121, 5123, 1, 0, 0, 0, 5122, 5119, 1, 0, 0, 0, 5122, 5123, 1, 0, 0, + 0, 5123, 5124, 1, 0, 0, 0, 5124, 5126, 3, 2310, 1155, 0, 5125, 5098, 1, + 0, 0, 0, 5125, 5122, 1, 0, 0, 0, 5126, 5127, 1, 0, 0, 0, 5127, 5129, 5, + 1429, 0, 0, 5128, 5130, 5, 410, 0, 0, 5129, 5128, 1, 0, 0, 0, 5129, 5130, + 1, 0, 0, 0, 5130, 5139, 1, 0, 0, 0, 5131, 5132, 5, 2376, 0, 0, 5132, 5133, + 3, 2250, 1125, 0, 5133, 5134, 5, 2382, 0, 0, 5134, 5135, 3, 2250, 1125, + 0, 5135, 5136, 1, 0, 0, 0, 5136, 5137, 5, 2377, 0, 0, 5137, 5140, 1, 0, + 0, 0, 5138, 5140, 3, 2250, 1125, 0, 5139, 5131, 1, 0, 0, 0, 5139, 5138, + 1, 0, 0, 0, 5140, 5141, 1, 0, 0, 0, 5141, 5142, 5, 616, 0, 0, 5142, 5143, + 5, 2376, 0, 0, 5143, 5148, 3, 348, 174, 0, 5144, 5145, 5, 2382, 0, 0, 5145, + 5147, 3, 348, 174, 0, 5146, 5144, 1, 0, 0, 0, 5147, 5150, 1, 0, 0, 0, 5148, + 5146, 1, 0, 0, 0, 5148, 5149, 1, 0, 0, 0, 5149, 5151, 1, 0, 0, 0, 5150, + 5148, 1, 0, 0, 0, 5151, 5152, 5, 2377, 0, 0, 5152, 345, 1, 0, 0, 0, 5153, + 5154, 3, 2258, 1129, 0, 5154, 5155, 5, 2369, 0, 0, 5155, 5157, 1, 0, 0, + 0, 5156, 5153, 1, 0, 0, 0, 5156, 5157, 1, 0, 0, 0, 5157, 5158, 1, 0, 0, + 0, 5158, 5163, 3, 2378, 1189, 0, 5159, 5161, 5, 66, 0, 0, 5160, 5159, 1, + 0, 0, 0, 5160, 5161, 1, 0, 0, 0, 5161, 5162, 1, 0, 0, 0, 5162, 5164, 3, + 2378, 1189, 0, 5163, 5160, 1, 0, 0, 0, 5163, 5164, 1, 0, 0, 0, 5164, 347, + 1, 0, 0, 0, 5165, 5166, 3, 2258, 1129, 0, 5166, 5167, 5, 2369, 0, 0, 5167, + 5169, 1, 0, 0, 0, 5168, 5165, 1, 0, 0, 0, 5168, 5169, 1, 0, 0, 0, 5169, + 5170, 1, 0, 0, 0, 5170, 5175, 3, 2378, 1189, 0, 5171, 5173, 5, 66, 0, 0, + 5172, 5171, 1, 0, 0, 0, 5172, 5173, 1, 0, 0, 0, 5173, 5174, 1, 0, 0, 0, + 5174, 5176, 3, 2378, 1189, 0, 5175, 5172, 1, 0, 0, 0, 5175, 5176, 1, 0, + 0, 0, 5176, 5178, 1, 0, 0, 0, 5177, 5179, 5, 363, 0, 0, 5178, 5177, 1, + 0, 0, 0, 5178, 5179, 1, 0, 0, 0, 5179, 349, 1, 0, 0, 0, 5180, 5181, 5, + 863, 0, 0, 5181, 5182, 5, 2376, 0, 0, 5182, 5187, 3, 352, 176, 0, 5183, + 5184, 5, 2382, 0, 0, 5184, 5186, 3, 352, 176, 0, 5185, 5183, 1, 0, 0, 0, + 5186, 5189, 1, 0, 0, 0, 5187, 5185, 1, 0, 0, 0, 5187, 5188, 1, 0, 0, 0, + 5188, 5190, 1, 0, 0, 0, 5189, 5187, 1, 0, 0, 0, 5190, 5191, 5, 2377, 0, + 0, 5191, 351, 1, 0, 0, 0, 5192, 5195, 3, 2378, 1189, 0, 5193, 5196, 3, + 354, 177, 0, 5194, 5196, 3, 358, 179, 0, 5195, 5193, 1, 0, 0, 0, 5195, + 5194, 1, 0, 0, 0, 5195, 5196, 1, 0, 0, 0, 5196, 353, 1, 0, 0, 0, 5197, + 5198, 5, 514, 0, 0, 5198, 5200, 3, 2378, 1189, 0, 5199, 5201, 3, 356, 178, + 0, 5200, 5199, 1, 0, 0, 0, 5200, 5201, 1, 0, 0, 0, 5201, 355, 1, 0, 0, + 0, 5202, 5203, 5, 34, 0, 0, 5203, 5204, 5, 151, 0, 0, 5204, 5205, 3, 2274, + 1137, 0, 5205, 357, 1, 0, 0, 0, 5206, 5207, 5, 66, 0, 0, 5207, 5208, 5, + 2376, 0, 0, 5208, 5209, 3, 2078, 1039, 0, 5209, 5210, 5, 2377, 0, 0, 5210, + 359, 1, 0, 0, 0, 5211, 5212, 5, 363, 0, 0, 5212, 5213, 5, 862, 0, 0, 5213, + 5214, 3, 2378, 1189, 0, 5214, 361, 1, 0, 0, 0, 5215, 5216, 5, 363, 0, 0, + 5216, 5217, 5, 34, 0, 0, 5217, 5218, 5, 151, 0, 0, 5218, 5219, 3, 2274, + 1137, 0, 5219, 363, 1, 0, 0, 0, 5220, 5221, 5, 155, 0, 0, 5221, 5226, 3, + 366, 183, 0, 5222, 5223, 5, 2382, 0, 0, 5223, 5225, 3, 366, 183, 0, 5224, + 5222, 1, 0, 0, 0, 5225, 5228, 1, 0, 0, 0, 5226, 5224, 1, 0, 0, 0, 5226, + 5227, 1, 0, 0, 0, 5227, 365, 1, 0, 0, 0, 5228, 5226, 1, 0, 0, 0, 5229, + 5230, 5, 862, 0, 0, 5230, 5250, 5, 593, 0, 0, 5231, 5251, 5, 37, 0, 0, + 5232, 5233, 5, 2376, 0, 0, 5233, 5238, 3, 2378, 1189, 0, 5234, 5235, 5, + 2382, 0, 0, 5235, 5237, 3, 2378, 1189, 0, 5236, 5234, 1, 0, 0, 0, 5237, + 5240, 1, 0, 0, 0, 5238, 5236, 1, 0, 0, 0, 5238, 5239, 1, 0, 0, 0, 5239, + 5241, 1, 0, 0, 0, 5240, 5238, 1, 0, 0, 0, 5241, 5242, 5, 2377, 0, 0, 5242, + 5247, 3, 368, 184, 0, 5243, 5244, 5, 2382, 0, 0, 5244, 5246, 3, 368, 184, + 0, 5245, 5243, 1, 0, 0, 0, 5246, 5249, 1, 0, 0, 0, 5247, 5245, 1, 0, 0, + 0, 5247, 5248, 1, 0, 0, 0, 5248, 5251, 1, 0, 0, 0, 5249, 5247, 1, 0, 0, + 0, 5250, 5231, 1, 0, 0, 0, 5250, 5232, 1, 0, 0, 0, 5251, 367, 1, 0, 0, + 0, 5252, 5253, 5, 783, 0, 0, 5253, 5254, 5, 2376, 0, 0, 5254, 5259, 3, + 370, 185, 0, 5255, 5256, 5, 2382, 0, 0, 5256, 5258, 3, 370, 185, 0, 5257, + 5255, 1, 0, 0, 0, 5258, 5261, 1, 0, 0, 0, 5259, 5257, 1, 0, 0, 0, 5259, + 5260, 1, 0, 0, 0, 5260, 5262, 1, 0, 0, 0, 5261, 5259, 1, 0, 0, 0, 5262, + 5263, 5, 2377, 0, 0, 5263, 5264, 3, 372, 186, 0, 5264, 369, 1, 0, 0, 0, + 5265, 5274, 5, 2376, 0, 0, 5266, 5267, 3, 2378, 1189, 0, 5267, 5268, 5, + 2369, 0, 0, 5268, 5270, 1, 0, 0, 0, 5269, 5266, 1, 0, 0, 0, 5269, 5270, + 1, 0, 0, 0, 5270, 5271, 1, 0, 0, 0, 5271, 5272, 3, 2378, 1189, 0, 5272, + 5273, 5, 2369, 0, 0, 5273, 5275, 1, 0, 0, 0, 5274, 5269, 1, 0, 0, 0, 5274, + 5275, 1, 0, 0, 0, 5275, 5276, 1, 0, 0, 0, 5276, 5277, 3, 2378, 1189, 0, + 5277, 5278, 5, 2377, 0, 0, 5278, 371, 1, 0, 0, 0, 5279, 5291, 5, 432, 0, + 0, 5280, 5288, 5, 848, 0, 0, 5281, 5285, 5, 2129, 0, 0, 5282, 5283, 3, + 2258, 1129, 0, 5283, 5284, 5, 2369, 0, 0, 5284, 5286, 1, 0, 0, 0, 5285, + 5282, 1, 0, 0, 0, 5285, 5286, 1, 0, 0, 0, 5286, 5287, 1, 0, 0, 0, 5287, + 5289, 3, 2378, 1189, 0, 5288, 5281, 1, 0, 0, 0, 5288, 5289, 1, 0, 0, 0, + 5289, 5291, 1, 0, 0, 0, 5290, 5279, 1, 0, 0, 0, 5290, 5280, 1, 0, 0, 0, + 5291, 373, 1, 0, 0, 0, 5292, 5293, 5, 514, 0, 0, 5293, 5294, 5, 222, 0, + 0, 5294, 5309, 3, 2310, 1155, 0, 5295, 5297, 5, 66, 0, 0, 5296, 5295, 1, + 0, 0, 0, 5296, 5297, 1, 0, 0, 0, 5297, 5298, 1, 0, 0, 0, 5298, 5306, 3, + 2378, 1189, 0, 5299, 5301, 5, 2382, 0, 0, 5300, 5302, 5, 66, 0, 0, 5301, + 5300, 1, 0, 0, 0, 5301, 5302, 1, 0, 0, 0, 5302, 5303, 1, 0, 0, 0, 5303, + 5305, 3, 2378, 1189, 0, 5304, 5299, 1, 0, 0, 0, 5305, 5308, 1, 0, 0, 0, + 5306, 5304, 1, 0, 0, 0, 5306, 5307, 1, 0, 0, 0, 5307, 5310, 1, 0, 0, 0, + 5308, 5306, 1, 0, 0, 0, 5309, 5296, 1, 0, 0, 0, 5309, 5310, 1, 0, 0, 0, + 5310, 375, 1, 0, 0, 0, 5311, 5312, 5, 453, 0, 0, 5312, 5313, 5, 1388, 0, + 0, 5313, 5315, 5, 2036, 0, 0, 5314, 5316, 7, 44, 0, 0, 5315, 5314, 1, 0, + 0, 0, 5315, 5316, 1, 0, 0, 0, 5316, 377, 1, 0, 0, 0, 5317, 5320, 5, 301, + 0, 0, 5318, 5319, 5, 1219, 0, 0, 5319, 5321, 5, 1463, 0, 0, 5320, 5318, + 1, 0, 0, 0, 5320, 5321, 1, 0, 0, 0, 5321, 5323, 1, 0, 0, 0, 5322, 5324, + 7, 7, 0, 0, 5323, 5322, 1, 0, 0, 0, 5323, 5324, 1, 0, 0, 0, 5324, 5325, + 1, 0, 0, 0, 5325, 5326, 5, 80, 0, 0, 5326, 5330, 5, 392, 0, 0, 5327, 5328, + 3, 2258, 1129, 0, 5328, 5329, 5, 2369, 0, 0, 5329, 5331, 1, 0, 0, 0, 5330, + 5327, 1, 0, 0, 0, 5330, 5331, 1, 0, 0, 0, 5331, 5332, 1, 0, 0, 0, 5332, + 5336, 3, 2378, 1189, 0, 5333, 5334, 5, 1577, 0, 0, 5334, 5335, 5, 2398, + 0, 0, 5335, 5337, 7, 43, 0, 0, 5336, 5333, 1, 0, 0, 0, 5336, 5337, 1, 0, + 0, 0, 5337, 5341, 1, 0, 0, 0, 5338, 5340, 3, 330, 165, 0, 5339, 5338, 1, + 0, 0, 0, 5340, 5343, 1, 0, 0, 0, 5341, 5339, 1, 0, 0, 0, 5341, 5342, 1, + 0, 0, 0, 5342, 5347, 1, 0, 0, 0, 5343, 5341, 1, 0, 0, 0, 5344, 5345, 5, + 392, 0, 0, 5345, 5346, 5, 2053, 0, 0, 5346, 5348, 7, 45, 0, 0, 5347, 5344, + 1, 0, 0, 0, 5347, 5348, 1, 0, 0, 0, 5348, 5349, 1, 0, 0, 0, 5349, 5350, + 3, 380, 190, 0, 5350, 5352, 3, 390, 195, 0, 5351, 5353, 3, 394, 197, 0, + 5352, 5351, 1, 0, 0, 0, 5353, 5354, 1, 0, 0, 0, 5354, 5352, 1, 0, 0, 0, + 5354, 5355, 1, 0, 0, 0, 5355, 5357, 1, 0, 0, 0, 5356, 5358, 3, 402, 201, + 0, 5357, 5356, 1, 0, 0, 0, 5357, 5358, 1, 0, 0, 0, 5358, 379, 1, 0, 0, + 0, 5359, 5360, 5, 2129, 0, 0, 5360, 5365, 3, 382, 191, 0, 5361, 5362, 5, + 2382, 0, 0, 5362, 5364, 3, 382, 191, 0, 5363, 5361, 1, 0, 0, 0, 5364, 5367, + 1, 0, 0, 0, 5365, 5363, 1, 0, 0, 0, 5365, 5366, 1, 0, 0, 0, 5366, 5371, + 1, 0, 0, 0, 5367, 5365, 1, 0, 0, 0, 5368, 5370, 3, 384, 192, 0, 5369, 5368, + 1, 0, 0, 0, 5370, 5373, 1, 0, 0, 0, 5371, 5369, 1, 0, 0, 0, 5371, 5372, + 1, 0, 0, 0, 5372, 381, 1, 0, 0, 0, 5373, 5371, 1, 0, 0, 0, 5374, 5375, + 3, 2258, 1129, 0, 5375, 5376, 5, 2369, 0, 0, 5376, 5378, 1, 0, 0, 0, 5377, + 5374, 1, 0, 0, 0, 5377, 5378, 1, 0, 0, 0, 5378, 5379, 1, 0, 0, 0, 5379, + 5381, 3, 2378, 1189, 0, 5380, 5382, 5, 1457, 0, 0, 5381, 5380, 1, 0, 0, + 0, 5381, 5382, 1, 0, 0, 0, 5382, 5387, 1, 0, 0, 0, 5383, 5385, 5, 66, 0, + 0, 5384, 5383, 1, 0, 0, 0, 5384, 5385, 1, 0, 0, 0, 5385, 5386, 1, 0, 0, + 0, 5386, 5388, 3, 2378, 1189, 0, 5387, 5384, 1, 0, 0, 0, 5387, 5388, 1, + 0, 0, 0, 5388, 383, 1, 0, 0, 0, 5389, 5390, 5, 731, 0, 0, 5390, 5391, 5, + 1271, 0, 0, 5391, 5392, 3, 2378, 1189, 0, 5392, 5393, 5, 1175, 0, 0, 5393, + 5394, 3, 386, 193, 0, 5394, 385, 1, 0, 0, 0, 5395, 5400, 3, 388, 194, 0, + 5396, 5397, 5, 48, 0, 0, 5397, 5399, 3, 388, 194, 0, 5398, 5396, 1, 0, + 0, 0, 5399, 5402, 1, 0, 0, 0, 5400, 5398, 1, 0, 0, 0, 5400, 5401, 1, 0, + 0, 0, 5401, 387, 1, 0, 0, 0, 5402, 5400, 1, 0, 0, 0, 5403, 5404, 3, 2378, + 1189, 0, 5404, 5405, 5, 2369, 0, 0, 5405, 5407, 1, 0, 0, 0, 5406, 5403, + 1, 0, 0, 0, 5406, 5407, 1, 0, 0, 0, 5407, 5408, 1, 0, 0, 0, 5408, 5409, + 3, 2310, 1155, 0, 5409, 5413, 5, 2398, 0, 0, 5410, 5411, 3, 2378, 1189, + 0, 5411, 5412, 5, 2369, 0, 0, 5412, 5414, 1, 0, 0, 0, 5413, 5410, 1, 0, + 0, 0, 5413, 5414, 1, 0, 0, 0, 5414, 5415, 1, 0, 0, 0, 5415, 5416, 3, 2310, + 1155, 0, 5416, 389, 1, 0, 0, 0, 5417, 5418, 5, 81, 0, 0, 5418, 5419, 5, + 2376, 0, 0, 5419, 5424, 3, 392, 196, 0, 5420, 5421, 5, 2382, 0, 0, 5421, + 5423, 3, 392, 196, 0, 5422, 5420, 1, 0, 0, 0, 5423, 5426, 1, 0, 0, 0, 5424, + 5422, 1, 0, 0, 0, 5424, 5425, 1, 0, 0, 0, 5425, 5427, 1, 0, 0, 0, 5426, + 5424, 1, 0, 0, 0, 5427, 5428, 5, 2377, 0, 0, 5428, 391, 1, 0, 0, 0, 5429, + 5430, 3, 2378, 1189, 0, 5430, 5431, 5, 2369, 0, 0, 5431, 5433, 1, 0, 0, + 0, 5432, 5429, 1, 0, 0, 0, 5432, 5433, 1, 0, 0, 0, 5433, 5434, 1, 0, 0, + 0, 5434, 5439, 3, 2310, 1155, 0, 5435, 5437, 5, 66, 0, 0, 5436, 5435, 1, + 0, 0, 0, 5436, 5437, 1, 0, 0, 0, 5437, 5438, 1, 0, 0, 0, 5438, 5440, 3, + 2378, 1189, 0, 5439, 5436, 1, 0, 0, 0, 5439, 5440, 1, 0, 0, 0, 5440, 5444, + 1, 0, 0, 0, 5441, 5443, 3, 330, 165, 0, 5442, 5441, 1, 0, 0, 0, 5443, 5446, + 1, 0, 0, 0, 5444, 5442, 1, 0, 0, 0, 5444, 5445, 1, 0, 0, 0, 5445, 393, + 1, 0, 0, 0, 5446, 5444, 1, 0, 0, 0, 5447, 5448, 5, 781, 0, 0, 5448, 5454, + 3, 2378, 1189, 0, 5449, 5450, 5, 1121, 0, 0, 5450, 5455, 5, 1145, 0, 0, + 5451, 5452, 5, 1597, 0, 0, 5452, 5453, 5, 2180, 0, 0, 5453, 5455, 5, 1145, + 0, 0, 5454, 5449, 1, 0, 0, 0, 5454, 5451, 1, 0, 0, 0, 5454, 5455, 1, 0, + 0, 0, 5455, 5459, 1, 0, 0, 0, 5456, 5457, 5, 781, 0, 0, 5457, 5458, 5, + 2053, 0, 0, 5458, 5460, 7, 46, 0, 0, 5459, 5456, 1, 0, 0, 0, 5459, 5460, + 1, 0, 0, 0, 5460, 5464, 1, 0, 0, 0, 5461, 5463, 3, 330, 165, 0, 5462, 5461, + 1, 0, 0, 0, 5463, 5466, 1, 0, 0, 0, 5464, 5462, 1, 0, 0, 0, 5464, 5465, + 1, 0, 0, 0, 5465, 5467, 1, 0, 0, 0, 5466, 5464, 1, 0, 0, 0, 5467, 5469, + 3, 396, 198, 0, 5468, 5470, 3, 398, 199, 0, 5469, 5468, 1, 0, 0, 0, 5469, + 5470, 1, 0, 0, 0, 5470, 5474, 1, 0, 0, 0, 5471, 5472, 5, 865, 0, 0, 5472, + 5473, 5, 926, 0, 0, 5473, 5475, 3, 2078, 1039, 0, 5474, 5471, 1, 0, 0, + 0, 5474, 5475, 1, 0, 0, 0, 5475, 5479, 1, 0, 0, 0, 5476, 5477, 5, 865, + 0, 0, 5477, 5478, 5, 166, 0, 0, 5478, 5480, 3, 2078, 1039, 0, 5479, 5476, + 1, 0, 0, 0, 5479, 5480, 1, 0, 0, 0, 5480, 5484, 1, 0, 0, 0, 5481, 5482, + 5, 865, 0, 0, 5482, 5483, 5, 386, 0, 0, 5483, 5485, 3, 2078, 1039, 0, 5484, + 5481, 1, 0, 0, 0, 5484, 5485, 1, 0, 0, 0, 5485, 5502, 1, 0, 0, 0, 5486, + 5487, 5, 1215, 0, 0, 5487, 5489, 5, 151, 0, 0, 5488, 5490, 7, 47, 0, 0, + 5489, 5488, 1, 0, 0, 0, 5489, 5490, 1, 0, 0, 0, 5490, 5491, 1, 0, 0, 0, + 5491, 5499, 3, 400, 200, 0, 5492, 5494, 5, 2382, 0, 0, 5493, 5495, 7, 47, + 0, 0, 5494, 5493, 1, 0, 0, 0, 5494, 5495, 1, 0, 0, 0, 5495, 5496, 1, 0, + 0, 0, 5496, 5498, 3, 400, 200, 0, 5497, 5492, 1, 0, 0, 0, 5498, 5501, 1, + 0, 0, 0, 5499, 5497, 1, 0, 0, 0, 5499, 5500, 1, 0, 0, 0, 5500, 5503, 1, + 0, 0, 0, 5501, 5499, 1, 0, 0, 0, 5502, 5486, 1, 0, 0, 0, 5502, 5503, 1, + 0, 0, 0, 5503, 5516, 1, 0, 0, 0, 5504, 5505, 5, 389, 0, 0, 5505, 5506, + 5, 2376, 0, 0, 5506, 5511, 3, 2378, 1189, 0, 5507, 5508, 5, 2382, 0, 0, + 5508, 5510, 3, 2378, 1189, 0, 5509, 5507, 1, 0, 0, 0, 5510, 5513, 1, 0, + 0, 0, 5511, 5509, 1, 0, 0, 0, 5511, 5512, 1, 0, 0, 0, 5512, 5514, 1, 0, + 0, 0, 5513, 5511, 1, 0, 0, 0, 5514, 5515, 5, 2377, 0, 0, 5515, 5517, 1, + 0, 0, 0, 5516, 5504, 1, 0, 0, 0, 5516, 5517, 1, 0, 0, 0, 5517, 395, 1, + 0, 0, 0, 5518, 5531, 5, 753, 0, 0, 5519, 5532, 3, 2378, 1189, 0, 5520, + 5521, 5, 2376, 0, 0, 5521, 5526, 3, 2378, 1189, 0, 5522, 5523, 5, 2382, + 0, 0, 5523, 5525, 3, 2378, 1189, 0, 5524, 5522, 1, 0, 0, 0, 5525, 5528, + 1, 0, 0, 0, 5526, 5524, 1, 0, 0, 0, 5526, 5527, 1, 0, 0, 0, 5527, 5529, + 1, 0, 0, 0, 5528, 5526, 1, 0, 0, 0, 5529, 5530, 5, 2377, 0, 0, 5530, 5532, + 1, 0, 0, 0, 5531, 5519, 1, 0, 0, 0, 5531, 5520, 1, 0, 0, 0, 5532, 397, + 1, 0, 0, 0, 5533, 5534, 5, 42, 0, 0, 5534, 5535, 3, 396, 198, 0, 5535, + 399, 1, 0, 0, 0, 5536, 5538, 3, 2378, 1189, 0, 5537, 5539, 7, 48, 0, 0, + 5538, 5537, 1, 0, 0, 0, 5538, 5539, 1, 0, 0, 0, 5539, 5542, 1, 0, 0, 0, + 5540, 5541, 5, 1146, 0, 0, 5541, 5543, 7, 49, 0, 0, 5542, 5540, 1, 0, 0, + 0, 5542, 5543, 1, 0, 0, 0, 5543, 401, 1, 0, 0, 0, 5544, 5545, 5, 37, 0, + 0, 5545, 5562, 5, 865, 0, 0, 5546, 5547, 5, 926, 0, 0, 5547, 5551, 3, 2078, + 1039, 0, 5548, 5549, 5, 865, 0, 0, 5549, 5550, 5, 166, 0, 0, 5550, 5552, + 3, 2078, 1039, 0, 5551, 5548, 1, 0, 0, 0, 5551, 5552, 1, 0, 0, 0, 5552, + 5563, 1, 0, 0, 0, 5553, 5554, 5, 166, 0, 0, 5554, 5558, 3, 2078, 1039, + 0, 5555, 5556, 5, 865, 0, 0, 5556, 5557, 5, 386, 0, 0, 5557, 5559, 3, 2078, + 1039, 0, 5558, 5555, 1, 0, 0, 0, 5558, 5559, 1, 0, 0, 0, 5559, 5563, 1, + 0, 0, 0, 5560, 5561, 5, 386, 0, 0, 5561, 5563, 3, 2078, 1039, 0, 5562, + 5546, 1, 0, 0, 0, 5562, 5553, 1, 0, 0, 0, 5562, 5560, 1, 0, 0, 0, 5563, + 403, 1, 0, 0, 0, 5564, 5565, 5, 301, 0, 0, 5565, 5566, 5, 82, 0, 0, 5566, + 5567, 5, 1318, 0, 0, 5567, 5569, 3, 2378, 1189, 0, 5568, 5570, 3, 406, + 203, 0, 5569, 5568, 1, 0, 0, 0, 5569, 5570, 1, 0, 0, 0, 5570, 5572, 1, + 0, 0, 0, 5571, 5573, 3, 408, 204, 0, 5572, 5571, 1, 0, 0, 0, 5572, 5573, + 1, 0, 0, 0, 5573, 5575, 1, 0, 0, 0, 5574, 5576, 3, 422, 211, 0, 5575, 5574, + 1, 0, 0, 0, 5575, 5576, 1, 0, 0, 0, 5576, 5583, 1, 0, 0, 0, 5577, 5578, + 5, 2180, 0, 0, 5578, 5579, 3, 2372, 1186, 0, 5579, 5580, 5, 477, 0, 0, + 5580, 5581, 5, 1296, 0, 0, 5581, 5582, 7, 50, 0, 0, 5582, 5584, 1, 0, 0, + 0, 5583, 5577, 1, 0, 0, 0, 5583, 5584, 1, 0, 0, 0, 5584, 5587, 1, 0, 0, + 0, 5585, 5586, 5, 1174, 0, 0, 5586, 5588, 5, 2023, 0, 0, 5587, 5585, 1, + 0, 0, 0, 5587, 5588, 1, 0, 0, 0, 5588, 5590, 1, 0, 0, 0, 5589, 5591, 3, + 762, 381, 0, 5590, 5589, 1, 0, 0, 0, 5590, 5591, 1, 0, 0, 0, 5591, 405, + 1, 0, 0, 0, 5592, 5593, 5, 1363, 0, 0, 5593, 5598, 3, 2362, 1181, 0, 5594, + 5595, 5, 2382, 0, 0, 5595, 5597, 3, 2362, 1181, 0, 5596, 5594, 1, 0, 0, + 0, 5597, 5600, 1, 0, 0, 0, 5598, 5596, 1, 0, 0, 0, 5598, 5599, 1, 0, 0, + 0, 5599, 407, 1, 0, 0, 0, 5600, 5598, 1, 0, 0, 0, 5601, 5604, 3, 410, 205, + 0, 5602, 5604, 3, 418, 209, 0, 5603, 5601, 1, 0, 0, 0, 5603, 5602, 1, 0, + 0, 0, 5604, 5605, 1, 0, 0, 0, 5605, 5603, 1, 0, 0, 0, 5605, 5606, 1, 0, + 0, 0, 5606, 409, 1, 0, 0, 0, 5607, 5608, 5, 11, 0, 0, 5608, 5613, 3, 412, + 206, 0, 5609, 5610, 5, 2382, 0, 0, 5610, 5612, 3, 412, 206, 0, 5611, 5609, + 1, 0, 0, 0, 5612, 5615, 1, 0, 0, 0, 5613, 5611, 1, 0, 0, 0, 5613, 5614, + 1, 0, 0, 0, 5614, 411, 1, 0, 0, 0, 5615, 5613, 1, 0, 0, 0, 5616, 5619, + 3, 414, 207, 0, 5617, 5619, 5, 37, 0, 0, 5618, 5616, 1, 0, 0, 0, 5618, + 5617, 1, 0, 0, 0, 5619, 5620, 1, 0, 0, 0, 5620, 5633, 5, 1175, 0, 0, 5621, + 5622, 5, 395, 0, 0, 5622, 5634, 3, 782, 391, 0, 5623, 5624, 5, 884, 0, + 0, 5624, 5626, 5, 900, 0, 0, 5625, 5623, 1, 0, 0, 0, 5625, 5626, 1, 0, + 0, 0, 5626, 5630, 1, 0, 0, 0, 5627, 5628, 3, 2258, 1129, 0, 5628, 5629, + 5, 2369, 0, 0, 5629, 5631, 1, 0, 0, 0, 5630, 5627, 1, 0, 0, 0, 5630, 5631, + 1, 0, 0, 0, 5631, 5632, 1, 0, 0, 0, 5632, 5634, 3, 2378, 1189, 0, 5633, + 5621, 1, 0, 0, 0, 5633, 5625, 1, 0, 0, 0, 5634, 5640, 1, 0, 0, 0, 5635, + 5638, 3, 416, 208, 0, 5636, 5638, 5, 37, 0, 0, 5637, 5635, 1, 0, 0, 0, + 5637, 5636, 1, 0, 0, 0, 5638, 5640, 1, 0, 0, 0, 5639, 5618, 1, 0, 0, 0, + 5639, 5637, 1, 0, 0, 0, 5640, 413, 1, 0, 0, 0, 5641, 5642, 7, 51, 0, 0, + 5642, 415, 1, 0, 0, 0, 5643, 5651, 3, 2378, 1189, 0, 5644, 5645, 7, 52, + 0, 0, 5645, 5651, 5, 729, 0, 0, 5646, 5647, 5, 812, 0, 0, 5647, 5651, 5, + 1976, 0, 0, 5648, 5649, 7, 53, 0, 0, 5649, 5651, 5, 395, 0, 0, 5650, 5643, + 1, 0, 0, 0, 5650, 5644, 1, 0, 0, 0, 5650, 5646, 1, 0, 0, 0, 5650, 5648, + 1, 0, 0, 0, 5651, 417, 1, 0, 0, 0, 5652, 5653, 5, 11, 0, 0, 5653, 5654, + 5, 236, 0, 0, 5654, 5680, 5, 2398, 0, 0, 5655, 5656, 7, 54, 0, 0, 5656, + 5661, 3, 420, 210, 0, 5657, 5658, 5, 2382, 0, 0, 5658, 5660, 3, 420, 210, + 0, 5659, 5657, 1, 0, 0, 0, 5660, 5663, 1, 0, 0, 0, 5661, 5659, 1, 0, 0, + 0, 5661, 5662, 1, 0, 0, 0, 5662, 5681, 1, 0, 0, 0, 5663, 5661, 1, 0, 0, + 0, 5664, 5665, 5, 431, 0, 0, 5665, 5666, 3, 420, 210, 0, 5666, 5667, 5, + 1175, 0, 0, 5667, 5675, 3, 2378, 1189, 0, 5668, 5669, 5, 2382, 0, 0, 5669, + 5670, 3, 420, 210, 0, 5670, 5671, 5, 1175, 0, 0, 5671, 5672, 3, 2378, 1189, + 0, 5672, 5674, 1, 0, 0, 0, 5673, 5668, 1, 0, 0, 0, 5674, 5677, 1, 0, 0, + 0, 5675, 5673, 1, 0, 0, 0, 5675, 5676, 1, 0, 0, 0, 5676, 5681, 1, 0, 0, + 0, 5677, 5675, 1, 0, 0, 0, 5678, 5679, 5, 1374, 0, 0, 5679, 5681, 7, 55, + 0, 0, 5680, 5655, 1, 0, 0, 0, 5680, 5664, 1, 0, 0, 0, 5680, 5678, 1, 0, + 0, 0, 5681, 419, 1, 0, 0, 0, 5682, 5683, 3, 2378, 1189, 0, 5683, 421, 1, + 0, 0, 0, 5684, 5685, 5, 1496, 0, 0, 5685, 5690, 3, 2280, 1140, 0, 5686, + 5687, 5, 2382, 0, 0, 5687, 5689, 3, 2280, 1140, 0, 5688, 5686, 1, 0, 0, + 0, 5689, 5692, 1, 0, 0, 0, 5690, 5688, 1, 0, 0, 0, 5690, 5691, 1, 0, 0, + 0, 5691, 423, 1, 0, 0, 0, 5692, 5690, 1, 0, 0, 0, 5693, 5694, 5, 301, 0, + 0, 5694, 5696, 5, 279, 0, 0, 5695, 5697, 5, 1488, 0, 0, 5696, 5695, 1, + 0, 0, 0, 5696, 5697, 1, 0, 0, 0, 5697, 5699, 1, 0, 0, 0, 5698, 5700, 5, + 1568, 0, 0, 5699, 5698, 1, 0, 0, 0, 5699, 5700, 1, 0, 0, 0, 5700, 5701, + 1, 0, 0, 0, 5701, 5702, 5, 329, 0, 0, 5702, 5704, 3, 2378, 1189, 0, 5703, + 5705, 3, 428, 214, 0, 5704, 5703, 1, 0, 0, 0, 5704, 5705, 1, 0, 0, 0, 5705, + 5706, 1, 0, 0, 0, 5706, 5716, 7, 56, 0, 0, 5707, 5708, 5, 331, 0, 0, 5708, + 5713, 3, 432, 216, 0, 5709, 5710, 5, 2382, 0, 0, 5710, 5712, 3, 432, 216, + 0, 5711, 5709, 1, 0, 0, 0, 5712, 5715, 1, 0, 0, 0, 5713, 5711, 1, 0, 0, + 0, 5713, 5714, 1, 0, 0, 0, 5714, 5717, 1, 0, 0, 0, 5715, 5713, 1, 0, 0, + 0, 5716, 5707, 1, 0, 0, 0, 5716, 5717, 1, 0, 0, 0, 5717, 5721, 1, 0, 0, + 0, 5718, 5720, 3, 426, 213, 0, 5719, 5718, 1, 0, 0, 0, 5720, 5723, 1, 0, + 0, 0, 5721, 5719, 1, 0, 0, 0, 5721, 5722, 1, 0, 0, 0, 5722, 5725, 1, 0, + 0, 0, 5723, 5721, 1, 0, 0, 0, 5724, 5726, 3, 430, 215, 0, 5725, 5724, 1, + 0, 0, 0, 5725, 5726, 1, 0, 0, 0, 5726, 425, 1, 0, 0, 0, 5727, 5728, 5, + 855, 0, 0, 5728, 5752, 3, 2368, 1184, 0, 5729, 5730, 5, 857, 0, 0, 5730, + 5752, 3, 2368, 1184, 0, 5731, 5732, 5, 856, 0, 0, 5732, 5752, 3, 2368, + 1184, 0, 5733, 5734, 5, 851, 0, 0, 5734, 5752, 3, 2368, 1184, 0, 5735, + 5736, 5, 854, 0, 0, 5736, 5752, 3, 2368, 1184, 0, 5737, 5752, 5, 64, 0, + 0, 5738, 5752, 5, 986, 0, 0, 5739, 5740, 5, 560, 0, 0, 5740, 5752, 5, 815, + 0, 0, 5741, 5742, 5, 1568, 0, 0, 5742, 5743, 5, 1628, 0, 0, 5743, 5744, + 5, 1040, 0, 0, 5744, 5749, 5, 564, 0, 0, 5745, 5746, 5, 330, 0, 0, 5746, + 5750, 5, 94, 0, 0, 5747, 5748, 5, 799, 0, 0, 5748, 5750, 5, 1291, 0, 0, + 5749, 5745, 1, 0, 0, 0, 5749, 5747, 1, 0, 0, 0, 5750, 5752, 1, 0, 0, 0, + 5751, 5727, 1, 0, 0, 0, 5751, 5729, 1, 0, 0, 0, 5751, 5731, 1, 0, 0, 0, + 5751, 5733, 1, 0, 0, 0, 5751, 5735, 1, 0, 0, 0, 5751, 5737, 1, 0, 0, 0, + 5751, 5738, 1, 0, 0, 0, 5751, 5739, 1, 0, 0, 0, 5751, 5741, 1, 0, 0, 0, + 5752, 427, 1, 0, 0, 0, 5753, 5758, 5, 813, 0, 0, 5754, 5756, 5, 593, 0, + 0, 5755, 5754, 1, 0, 0, 0, 5755, 5756, 1, 0, 0, 0, 5756, 5757, 1, 0, 0, + 0, 5757, 5759, 3, 2368, 1184, 0, 5758, 5755, 1, 0, 0, 0, 5758, 5759, 1, + 0, 0, 0, 5759, 5760, 1, 0, 0, 0, 5760, 5771, 3, 432, 216, 0, 5761, 5766, + 5, 2382, 0, 0, 5762, 5764, 5, 593, 0, 0, 5763, 5762, 1, 0, 0, 0, 5763, + 5764, 1, 0, 0, 0, 5764, 5765, 1, 0, 0, 0, 5765, 5767, 3, 2368, 1184, 0, + 5766, 5763, 1, 0, 0, 0, 5766, 5767, 1, 0, 0, 0, 5767, 5768, 1, 0, 0, 0, + 5768, 5770, 3, 432, 216, 0, 5769, 5761, 1, 0, 0, 0, 5770, 5773, 1, 0, 0, + 0, 5771, 5769, 1, 0, 0, 0, 5771, 5772, 1, 0, 0, 0, 5772, 429, 1, 0, 0, + 0, 5773, 5771, 1, 0, 0, 0, 5774, 5775, 5, 181, 0, 0, 5775, 5776, 5, 1568, + 0, 0, 5776, 5777, 3, 2378, 1189, 0, 5777, 431, 1, 0, 0, 0, 5778, 5781, + 3, 914, 457, 0, 5779, 5781, 3, 916, 458, 0, 5780, 5778, 1, 0, 0, 0, 5780, + 5779, 1, 0, 0, 0, 5781, 433, 1, 0, 0, 0, 5782, 5783, 5, 301, 0, 0, 5783, + 5784, 5, 407, 0, 0, 5784, 5797, 3, 2378, 1189, 0, 5785, 5795, 5, 618, 0, + 0, 5786, 5795, 5, 1098, 0, 0, 5787, 5795, 5, 553, 0, 0, 5788, 5791, 5, + 2251, 0, 0, 5789, 5790, 5, 1584, 0, 0, 5790, 5792, 3, 2378, 1189, 0, 5791, + 5789, 1, 0, 0, 0, 5791, 5792, 1, 0, 0, 0, 5792, 5795, 1, 0, 0, 0, 5793, + 5795, 5, 507, 0, 0, 5794, 5785, 1, 0, 0, 0, 5794, 5786, 1, 0, 0, 0, 5794, + 5787, 1, 0, 0, 0, 5794, 5788, 1, 0, 0, 0, 5794, 5793, 1, 0, 0, 0, 5795, + 5796, 1, 0, 0, 0, 5796, 5798, 5, 1425, 0, 0, 5797, 5794, 1, 0, 0, 0, 5797, + 5798, 1, 0, 0, 0, 5798, 5815, 1, 0, 0, 0, 5799, 5801, 3, 88, 44, 0, 5800, + 5799, 1, 0, 0, 0, 5800, 5801, 1, 0, 0, 0, 5801, 5804, 1, 0, 0, 0, 5802, + 5803, 5, 519, 0, 0, 5803, 5805, 3, 2378, 1189, 0, 5804, 5802, 1, 0, 0, + 0, 5804, 5805, 1, 0, 0, 0, 5805, 5806, 1, 0, 0, 0, 5806, 5807, 5, 406, + 0, 0, 5807, 5812, 3, 436, 218, 0, 5808, 5809, 5, 2382, 0, 0, 5809, 5811, + 3, 436, 218, 0, 5810, 5808, 1, 0, 0, 0, 5811, 5814, 1, 0, 0, 0, 5812, 5810, + 1, 0, 0, 0, 5812, 5813, 1, 0, 0, 0, 5813, 5816, 1, 0, 0, 0, 5814, 5812, + 1, 0, 0, 0, 5815, 5800, 1, 0, 0, 0, 5816, 5817, 1, 0, 0, 0, 5817, 5815, + 1, 0, 0, 0, 5817, 5818, 1, 0, 0, 0, 5818, 5832, 1, 0, 0, 0, 5819, 5820, + 5, 80, 0, 0, 5820, 5821, 5, 2372, 0, 0, 5821, 5822, 5, 2398, 0, 0, 5822, + 5829, 5, 2372, 0, 0, 5823, 5824, 5, 2382, 0, 0, 5824, 5825, 5, 2372, 0, + 0, 5825, 5826, 5, 2398, 0, 0, 5826, 5828, 5, 2372, 0, 0, 5827, 5823, 1, + 0, 0, 0, 5828, 5831, 1, 0, 0, 0, 5829, 5827, 1, 0, 0, 0, 5829, 5830, 1, + 0, 0, 0, 5830, 5833, 1, 0, 0, 0, 5831, 5829, 1, 0, 0, 0, 5832, 5819, 1, + 0, 0, 0, 5832, 5833, 1, 0, 0, 0, 5833, 435, 1, 0, 0, 0, 5834, 5837, 5, + 2372, 0, 0, 5835, 5836, 5, 926, 0, 0, 5836, 5838, 3, 2378, 1189, 0, 5837, + 5835, 1, 0, 0, 0, 5837, 5838, 1, 0, 0, 0, 5838, 5841, 1, 0, 0, 0, 5839, + 5840, 5, 1595, 0, 0, 5840, 5842, 3, 1170, 585, 0, 5841, 5839, 1, 0, 0, + 0, 5841, 5842, 1, 0, 0, 0, 5842, 5844, 1, 0, 0, 0, 5843, 5845, 3, 38, 19, + 0, 5844, 5843, 1, 0, 0, 0, 5844, 5845, 1, 0, 0, 0, 5845, 437, 1, 0, 0, + 0, 5846, 5847, 5, 301, 0, 0, 5847, 5848, 5, 438, 0, 0, 5848, 5853, 3, 2378, + 1189, 0, 5849, 5850, 5, 66, 0, 0, 5850, 5851, 5, 188, 0, 0, 5851, 5852, + 5, 1163, 0, 0, 5852, 5854, 3, 2378, 1189, 0, 5853, 5849, 1, 0, 0, 0, 5853, + 5854, 1, 0, 0, 0, 5854, 439, 1, 0, 0, 0, 5855, 5856, 5, 301, 0, 0, 5856, + 5857, 5, 549, 0, 0, 5857, 5859, 5, 62, 0, 0, 5858, 5860, 5, 363, 0, 0, + 5859, 5858, 1, 0, 0, 0, 5859, 5860, 1, 0, 0, 0, 5860, 5861, 1, 0, 0, 0, + 5861, 5862, 3, 2378, 1189, 0, 5862, 5863, 5, 1973, 0, 0, 5863, 5865, 3, + 2378, 1189, 0, 5864, 5866, 3, 442, 221, 0, 5865, 5864, 1, 0, 0, 0, 5865, + 5866, 1, 0, 0, 0, 5866, 5872, 1, 0, 0, 0, 5867, 5869, 5, 1057, 0, 0, 5868, + 5867, 1, 0, 0, 0, 5868, 5869, 1, 0, 0, 0, 5869, 5870, 1, 0, 0, 0, 5870, + 5871, 5, 1185, 0, 0, 5871, 5873, 5, 330, 0, 0, 5872, 5868, 1, 0, 0, 0, + 5872, 5873, 1, 0, 0, 0, 5873, 5874, 1, 0, 0, 0, 5874, 5875, 3, 444, 222, + 0, 5875, 441, 1, 0, 0, 0, 5876, 5877, 5, 1394, 0, 0, 5877, 5878, 5, 2370, + 0, 0, 5878, 5879, 7, 57, 0, 0, 5879, 443, 1, 0, 0, 0, 5880, 5881, 5, 1484, + 0, 0, 5881, 5882, 5, 2370, 0, 0, 5882, 5883, 7, 58, 0, 0, 5883, 445, 1, + 0, 0, 0, 5884, 5887, 5, 301, 0, 0, 5885, 5886, 5, 1219, 0, 0, 5886, 5888, + 5, 1463, 0, 0, 5887, 5885, 1, 0, 0, 0, 5887, 5888, 1, 0, 0, 0, 5888, 5893, + 1, 0, 0, 0, 5889, 5891, 5, 1057, 0, 0, 5890, 5889, 1, 0, 0, 0, 5890, 5891, + 1, 0, 0, 0, 5891, 5892, 1, 0, 0, 0, 5892, 5894, 5, 560, 0, 0, 5893, 5890, + 1, 0, 0, 0, 5893, 5894, 1, 0, 0, 0, 5894, 5895, 1, 0, 0, 0, 5895, 5899, + 5, 617, 0, 0, 5896, 5897, 3, 2258, 1129, 0, 5897, 5898, 5, 2369, 0, 0, + 5898, 5900, 1, 0, 0, 0, 5899, 5896, 1, 0, 0, 0, 5899, 5900, 1, 0, 0, 0, + 5900, 5901, 1, 0, 0, 0, 5901, 5905, 3, 2378, 1189, 0, 5902, 5903, 5, 1577, + 0, 0, 5903, 5904, 5, 2398, 0, 0, 5904, 5906, 7, 43, 0, 0, 5905, 5902, 1, + 0, 0, 0, 5905, 5906, 1, 0, 0, 0, 5906, 5910, 1, 0, 0, 0, 5907, 5909, 3, + 330, 165, 0, 5908, 5907, 1, 0, 0, 0, 5909, 5912, 1, 0, 0, 0, 5910, 5908, + 1, 0, 0, 0, 5910, 5911, 1, 0, 0, 0, 5911, 5913, 1, 0, 0, 0, 5912, 5910, + 1, 0, 0, 0, 5913, 5914, 3, 448, 224, 0, 5914, 5916, 3, 450, 225, 0, 5915, + 5917, 3, 452, 226, 0, 5916, 5915, 1, 0, 0, 0, 5916, 5917, 1, 0, 0, 0, 5917, + 447, 1, 0, 0, 0, 5918, 5922, 5, 2129, 0, 0, 5919, 5920, 3, 2258, 1129, + 0, 5920, 5921, 5, 2369, 0, 0, 5921, 5923, 1, 0, 0, 0, 5922, 5919, 1, 0, + 0, 0, 5922, 5923, 1, 0, 0, 0, 5923, 5924, 1, 0, 0, 0, 5924, 5925, 3, 2378, + 1189, 0, 5925, 449, 1, 0, 0, 0, 5926, 5932, 5, 2376, 0, 0, 5927, 5930, + 3, 2378, 1189, 0, 5928, 5929, 5, 188, 0, 0, 5929, 5931, 5, 1163, 0, 0, + 5930, 5928, 1, 0, 0, 0, 5930, 5931, 1, 0, 0, 0, 5931, 5933, 1, 0, 0, 0, + 5932, 5927, 1, 0, 0, 0, 5933, 5934, 1, 0, 0, 0, 5934, 5932, 1, 0, 0, 0, + 5934, 5935, 1, 0, 0, 0, 5935, 5936, 1, 0, 0, 0, 5936, 5937, 5, 2377, 0, + 0, 5937, 451, 1, 0, 0, 0, 5938, 5939, 5, 615, 0, 0, 5939, 5940, 5, 81, + 0, 0, 5940, 5941, 5, 2376, 0, 0, 5941, 5942, 3, 454, 227, 0, 5942, 5943, + 5, 2377, 0, 0, 5943, 453, 1, 0, 0, 0, 5944, 5948, 3, 456, 228, 0, 5945, + 5947, 3, 330, 165, 0, 5946, 5945, 1, 0, 0, 0, 5947, 5950, 1, 0, 0, 0, 5948, + 5946, 1, 0, 0, 0, 5948, 5949, 1, 0, 0, 0, 5949, 455, 1, 0, 0, 0, 5950, + 5948, 1, 0, 0, 0, 5951, 5952, 7, 59, 0, 0, 5952, 457, 1, 0, 0, 0, 5953, + 5955, 5, 301, 0, 0, 5954, 5956, 7, 60, 0, 0, 5955, 5954, 1, 0, 0, 0, 5955, + 5956, 1, 0, 0, 0, 5956, 5957, 1, 0, 0, 0, 5957, 5958, 5, 659, 0, 0, 5958, + 5959, 3, 2300, 1150, 0, 5959, 5963, 5, 1175, 0, 0, 5960, 5964, 3, 460, + 230, 0, 5961, 5964, 3, 464, 232, 0, 5962, 5964, 3, 466, 233, 0, 5963, 5960, + 1, 0, 0, 0, 5963, 5961, 1, 0, 0, 0, 5963, 5962, 1, 0, 0, 0, 5964, 5966, + 1, 0, 0, 0, 5965, 5967, 7, 61, 0, 0, 5966, 5965, 1, 0, 0, 0, 5966, 5967, + 1, 0, 0, 0, 5967, 5968, 1, 0, 0, 0, 5968, 5969, 5, 2396, 0, 0, 5969, 459, + 1, 0, 0, 0, 5970, 5971, 5, 206, 0, 0, 5971, 5973, 3, 462, 231, 0, 5972, + 5974, 3, 1596, 798, 0, 5973, 5972, 1, 0, 0, 0, 5973, 5974, 1, 0, 0, 0, + 5974, 461, 1, 0, 0, 0, 5975, 5976, 3, 2378, 1189, 0, 5976, 5977, 5, 2369, + 0, 0, 5977, 5979, 1, 0, 0, 0, 5978, 5975, 1, 0, 0, 0, 5978, 5979, 1, 0, + 0, 0, 5979, 5980, 1, 0, 0, 0, 5980, 5981, 3, 2378, 1189, 0, 5981, 463, + 1, 0, 0, 0, 5982, 5984, 3, 2312, 1156, 0, 5983, 5985, 3, 2238, 1119, 0, + 5984, 5983, 1, 0, 0, 0, 5984, 5985, 1, 0, 0, 0, 5985, 5986, 1, 0, 0, 0, + 5986, 5987, 5, 2376, 0, 0, 5987, 5992, 3, 468, 234, 0, 5988, 5989, 5, 2382, + 0, 0, 5989, 5991, 3, 468, 234, 0, 5990, 5988, 1, 0, 0, 0, 5991, 5994, 1, + 0, 0, 0, 5992, 5990, 1, 0, 0, 0, 5992, 5993, 1, 0, 0, 0, 5993, 5995, 1, + 0, 0, 0, 5994, 5992, 1, 0, 0, 0, 5995, 5997, 5, 2377, 0, 0, 5996, 5998, + 3, 472, 236, 0, 5997, 5996, 1, 0, 0, 0, 5997, 5998, 1, 0, 0, 0, 5998, 465, + 1, 0, 0, 0, 5999, 6000, 3, 2312, 1156, 0, 6000, 6003, 5, 2376, 0, 0, 6001, + 6004, 3, 2312, 1156, 0, 6002, 6004, 3, 2238, 1119, 0, 6003, 6001, 1, 0, + 0, 0, 6003, 6002, 1, 0, 0, 0, 6003, 6004, 1, 0, 0, 0, 6004, 6005, 1, 0, + 0, 0, 6005, 6007, 3, 2310, 1155, 0, 6006, 6008, 7, 48, 0, 0, 6007, 6006, + 1, 0, 0, 0, 6007, 6008, 1, 0, 0, 0, 6008, 6020, 1, 0, 0, 0, 6009, 6012, + 5, 2382, 0, 0, 6010, 6013, 3, 2312, 1156, 0, 6011, 6013, 3, 2238, 1119, + 0, 6012, 6010, 1, 0, 0, 0, 6012, 6011, 1, 0, 0, 0, 6012, 6013, 1, 0, 0, + 0, 6013, 6014, 1, 0, 0, 0, 6014, 6016, 3, 2310, 1155, 0, 6015, 6017, 7, + 48, 0, 0, 6016, 6015, 1, 0, 0, 0, 6016, 6017, 1, 0, 0, 0, 6017, 6019, 1, + 0, 0, 0, 6018, 6009, 1, 0, 0, 0, 6019, 6022, 1, 0, 0, 0, 6020, 6018, 1, + 0, 0, 0, 6020, 6021, 1, 0, 0, 0, 6021, 6023, 1, 0, 0, 0, 6022, 6020, 1, + 0, 0, 0, 6023, 6024, 5, 2377, 0, 0, 6024, 6025, 5, 572, 0, 0, 6025, 6026, + 3, 2312, 1156, 0, 6026, 6033, 3, 2238, 1119, 0, 6027, 6028, 5, 2382, 0, + 0, 6028, 6029, 3, 2312, 1156, 0, 6029, 6030, 3, 2238, 1119, 0, 6030, 6032, + 1, 0, 0, 0, 6031, 6027, 1, 0, 0, 0, 6032, 6035, 1, 0, 0, 0, 6033, 6031, + 1, 0, 0, 0, 6033, 6034, 1, 0, 0, 0, 6034, 6036, 1, 0, 0, 0, 6035, 6033, + 1, 0, 0, 0, 6036, 6038, 3, 2240, 1120, 0, 6037, 6039, 3, 486, 243, 0, 6038, + 6037, 1, 0, 0, 0, 6038, 6039, 1, 0, 0, 0, 6039, 6041, 1, 0, 0, 0, 6040, + 6042, 3, 1596, 798, 0, 6041, 6040, 1, 0, 0, 0, 6041, 6042, 1, 0, 0, 0, + 6042, 467, 1, 0, 0, 0, 6043, 6045, 3, 470, 235, 0, 6044, 6046, 7, 48, 0, + 0, 6045, 6044, 1, 0, 0, 0, 6045, 6046, 1, 0, 0, 0, 6046, 469, 1, 0, 0, + 0, 6047, 6050, 3, 2310, 1155, 0, 6048, 6050, 3, 2078, 1039, 0, 6049, 6047, + 1, 0, 0, 0, 6049, 6048, 1, 0, 0, 0, 6050, 471, 1, 0, 0, 0, 6051, 6055, + 3, 482, 241, 0, 6052, 6055, 3, 486, 243, 0, 6053, 6055, 3, 1596, 798, 0, + 6054, 6051, 1, 0, 0, 0, 6054, 6052, 1, 0, 0, 0, 6054, 6053, 1, 0, 0, 0, + 6055, 6056, 1, 0, 0, 0, 6056, 6054, 1, 0, 0, 0, 6056, 6057, 1, 0, 0, 0, + 6057, 6065, 1, 0, 0, 0, 6058, 6059, 5, 673, 0, 0, 6059, 6062, 5, 723, 0, + 0, 6060, 6063, 3, 474, 237, 0, 6061, 6063, 3, 478, 239, 0, 6062, 6060, + 1, 0, 0, 0, 6062, 6061, 1, 0, 0, 0, 6063, 6065, 1, 0, 0, 0, 6064, 6054, + 1, 0, 0, 0, 6064, 6058, 1, 0, 0, 0, 6065, 473, 1, 0, 0, 0, 6066, 6068, + 3, 508, 254, 0, 6067, 6069, 3, 476, 238, 0, 6068, 6067, 1, 0, 0, 0, 6068, + 6069, 1, 0, 0, 0, 6069, 6071, 1, 0, 0, 0, 6070, 6072, 3, 926, 463, 0, 6071, + 6070, 1, 0, 0, 0, 6071, 6072, 1, 0, 0, 0, 6072, 6078, 1, 0, 0, 0, 6073, + 6074, 5, 1244, 0, 0, 6074, 6075, 5, 2376, 0, 0, 6075, 6076, 3, 506, 253, + 0, 6076, 6077, 5, 2377, 0, 0, 6077, 6079, 1, 0, 0, 0, 6078, 6073, 1, 0, + 0, 0, 6078, 6079, 1, 0, 0, 0, 6079, 475, 1, 0, 0, 0, 6080, 6108, 5, 804, + 0, 0, 6081, 6082, 5, 2376, 0, 0, 6082, 6083, 5, 1256, 0, 0, 6083, 6089, + 3, 1704, 852, 0, 6084, 6085, 5, 1244, 0, 0, 6085, 6086, 5, 2376, 0, 0, + 6086, 6087, 3, 506, 253, 0, 6087, 6088, 5, 2377, 0, 0, 6088, 6090, 1, 0, + 0, 0, 6089, 6084, 1, 0, 0, 0, 6089, 6090, 1, 0, 0, 0, 6090, 6103, 1, 0, + 0, 0, 6091, 6092, 5, 2382, 0, 0, 6092, 6093, 5, 1256, 0, 0, 6093, 6099, + 3, 1704, 852, 0, 6094, 6095, 5, 1244, 0, 0, 6095, 6096, 5, 2376, 0, 0, + 6096, 6097, 3, 506, 253, 0, 6097, 6098, 5, 2377, 0, 0, 6098, 6100, 1, 0, + 0, 0, 6099, 6094, 1, 0, 0, 0, 6099, 6100, 1, 0, 0, 0, 6100, 6102, 1, 0, + 0, 0, 6101, 6091, 1, 0, 0, 0, 6102, 6105, 1, 0, 0, 0, 6103, 6101, 1, 0, + 0, 0, 6103, 6104, 1, 0, 0, 0, 6104, 6106, 1, 0, 0, 0, 6105, 6103, 1, 0, + 0, 0, 6106, 6107, 5, 2377, 0, 0, 6107, 6109, 1, 0, 0, 0, 6108, 6081, 1, + 0, 0, 0, 6108, 6109, 1, 0, 0, 0, 6109, 477, 1, 0, 0, 0, 6110, 6111, 5, + 2194, 0, 0, 6111, 6113, 5, 2369, 0, 0, 6112, 6110, 1, 0, 0, 0, 6112, 6113, + 1, 0, 0, 0, 6113, 6114, 1, 0, 0, 0, 6114, 6116, 5, 2211, 0, 0, 6115, 6117, + 3, 480, 240, 0, 6116, 6115, 1, 0, 0, 0, 6116, 6117, 1, 0, 0, 0, 6117, 6119, + 1, 0, 0, 0, 6118, 6120, 3, 926, 463, 0, 6119, 6118, 1, 0, 0, 0, 6119, 6120, + 1, 0, 0, 0, 6120, 479, 1, 0, 0, 0, 6121, 6135, 5, 804, 0, 0, 6122, 6123, + 5, 2376, 0, 0, 6123, 6124, 5, 1256, 0, 0, 6124, 6130, 3, 1704, 852, 0, + 6125, 6126, 5, 2382, 0, 0, 6126, 6127, 5, 1256, 0, 0, 6127, 6129, 3, 1704, + 852, 0, 6128, 6125, 1, 0, 0, 0, 6129, 6132, 1, 0, 0, 0, 6130, 6128, 1, + 0, 0, 0, 6130, 6131, 1, 0, 0, 0, 6131, 6133, 1, 0, 0, 0, 6132, 6130, 1, + 0, 0, 0, 6133, 6134, 5, 2377, 0, 0, 6134, 6136, 1, 0, 0, 0, 6135, 6122, + 1, 0, 0, 0, 6135, 6136, 1, 0, 0, 0, 6136, 481, 1, 0, 0, 0, 6137, 6179, + 5, 586, 0, 0, 6138, 6139, 5, 1256, 0, 0, 6139, 6177, 5, 151, 0, 0, 6140, + 6141, 5, 1399, 0, 0, 6141, 6142, 5, 2376, 0, 0, 6142, 6147, 3, 2310, 1155, + 0, 6143, 6144, 5, 2382, 0, 0, 6144, 6146, 3, 2310, 1155, 0, 6145, 6143, + 1, 0, 0, 0, 6146, 6149, 1, 0, 0, 0, 6147, 6145, 1, 0, 0, 0, 6147, 6148, + 1, 0, 0, 0, 6148, 6150, 1, 0, 0, 0, 6149, 6147, 1, 0, 0, 0, 6150, 6151, + 5, 2377, 0, 0, 6151, 6152, 5, 2376, 0, 0, 6152, 6157, 3, 484, 242, 0, 6153, + 6154, 5, 2382, 0, 0, 6154, 6156, 3, 484, 242, 0, 6155, 6153, 1, 0, 0, 0, + 6156, 6159, 1, 0, 0, 0, 6157, 6155, 1, 0, 0, 0, 6157, 6158, 1, 0, 0, 0, + 6158, 6160, 1, 0, 0, 0, 6159, 6157, 1, 0, 0, 0, 6160, 6161, 5, 2377, 0, + 0, 6161, 6178, 1, 0, 0, 0, 6162, 6163, 5, 603, 0, 0, 6163, 6164, 5, 2376, + 0, 0, 6164, 6169, 3, 2310, 1155, 0, 6165, 6166, 5, 2382, 0, 0, 6166, 6168, + 3, 2310, 1155, 0, 6167, 6165, 1, 0, 0, 0, 6168, 6171, 1, 0, 0, 0, 6169, + 6167, 1, 0, 0, 0, 6169, 6170, 1, 0, 0, 0, 6170, 6172, 1, 0, 0, 0, 6171, + 6169, 1, 0, 0, 0, 6172, 6175, 5, 2377, 0, 0, 6173, 6176, 3, 1116, 558, + 0, 6174, 6176, 3, 1118, 559, 0, 6175, 6173, 1, 0, 0, 0, 6175, 6174, 1, + 0, 0, 0, 6176, 6178, 1, 0, 0, 0, 6177, 6140, 1, 0, 0, 0, 6177, 6162, 1, + 0, 0, 0, 6178, 6180, 1, 0, 0, 0, 6179, 6138, 1, 0, 0, 0, 6179, 6180, 1, + 0, 0, 0, 6180, 483, 1, 0, 0, 0, 6181, 6183, 5, 1256, 0, 0, 6182, 6184, + 3, 1704, 852, 0, 6183, 6182, 1, 0, 0, 0, 6183, 6184, 1, 0, 0, 0, 6184, + 6185, 1, 0, 0, 0, 6185, 6186, 5, 2140, 0, 0, 6186, 6187, 5, 780, 0, 0, + 6187, 6188, 5, 1988, 0, 0, 6188, 6189, 5, 2376, 0, 0, 6189, 6194, 3, 2170, + 1085, 0, 6190, 6191, 5, 2382, 0, 0, 6191, 6193, 3, 2170, 1085, 0, 6192, + 6190, 1, 0, 0, 0, 6193, 6196, 1, 0, 0, 0, 6194, 6192, 1, 0, 0, 0, 6194, + 6195, 1, 0, 0, 0, 6195, 6197, 1, 0, 0, 0, 6196, 6194, 1, 0, 0, 0, 6197, + 6199, 5, 2377, 0, 0, 6198, 6200, 3, 1194, 597, 0, 6199, 6198, 1, 0, 0, + 0, 6199, 6200, 1, 0, 0, 0, 6200, 485, 1, 0, 0, 0, 6201, 6206, 5, 804, 0, + 0, 6202, 6207, 3, 488, 244, 0, 6203, 6207, 3, 490, 245, 0, 6204, 6207, + 3, 494, 247, 0, 6205, 6207, 3, 498, 249, 0, 6206, 6202, 1, 0, 0, 0, 6206, + 6203, 1, 0, 0, 0, 6206, 6204, 1, 0, 0, 0, 6206, 6205, 1, 0, 0, 0, 6206, + 6207, 1, 0, 0, 0, 6207, 487, 1, 0, 0, 0, 6208, 6209, 5, 2376, 0, 0, 6209, + 6214, 3, 492, 246, 0, 6210, 6211, 5, 2382, 0, 0, 6211, 6213, 3, 492, 246, + 0, 6212, 6210, 1, 0, 0, 0, 6213, 6216, 1, 0, 0, 0, 6214, 6212, 1, 0, 0, + 0, 6214, 6215, 1, 0, 0, 0, 6215, 6217, 1, 0, 0, 0, 6216, 6214, 1, 0, 0, + 0, 6217, 6218, 5, 2377, 0, 0, 6218, 489, 1, 0, 0, 0, 6219, 6220, 5, 2376, + 0, 0, 6220, 6225, 3, 492, 246, 0, 6221, 6222, 5, 2382, 0, 0, 6222, 6224, + 3, 492, 246, 0, 6223, 6221, 1, 0, 0, 0, 6224, 6227, 1, 0, 0, 0, 6225, 6223, + 1, 0, 0, 0, 6225, 6226, 1, 0, 0, 0, 6226, 6228, 1, 0, 0, 0, 6227, 6225, + 1, 0, 0, 0, 6228, 6229, 5, 2377, 0, 0, 6229, 491, 1, 0, 0, 0, 6230, 6232, + 5, 1256, 0, 0, 6231, 6233, 3, 1704, 852, 0, 6232, 6231, 1, 0, 0, 0, 6232, + 6233, 1, 0, 0, 0, 6233, 6238, 1, 0, 0, 0, 6234, 6237, 3, 1194, 597, 0, + 6235, 6237, 3, 1608, 804, 0, 6236, 6234, 1, 0, 0, 0, 6236, 6235, 1, 0, + 0, 0, 6237, 6240, 1, 0, 0, 0, 6238, 6236, 1, 0, 0, 0, 6238, 6239, 1, 0, + 0, 0, 6239, 6242, 1, 0, 0, 0, 6240, 6238, 1, 0, 0, 0, 6241, 6243, 5, 2087, + 0, 0, 6242, 6241, 1, 0, 0, 0, 6242, 6243, 1, 0, 0, 0, 6243, 493, 1, 0, + 0, 0, 6244, 6245, 5, 1656, 0, 0, 6245, 6246, 5, 680, 0, 0, 6246, 6247, + 5, 2376, 0, 0, 6247, 6252, 3, 1666, 833, 0, 6248, 6249, 5, 2382, 0, 0, + 6249, 6251, 3, 1666, 833, 0, 6250, 6248, 1, 0, 0, 0, 6251, 6254, 1, 0, + 0, 0, 6252, 6250, 1, 0, 0, 0, 6252, 6253, 1, 0, 0, 0, 6253, 6255, 1, 0, + 0, 0, 6254, 6252, 1, 0, 0, 0, 6255, 6256, 5, 2377, 0, 0, 6256, 6269, 1, + 0, 0, 0, 6257, 6258, 5, 2376, 0, 0, 6258, 6263, 3, 496, 248, 0, 6259, 6260, + 5, 2382, 0, 0, 6260, 6262, 3, 496, 248, 0, 6261, 6259, 1, 0, 0, 0, 6262, + 6265, 1, 0, 0, 0, 6263, 6261, 1, 0, 0, 0, 6263, 6264, 1, 0, 0, 0, 6264, + 6266, 1, 0, 0, 0, 6265, 6263, 1, 0, 0, 0, 6266, 6267, 5, 2377, 0, 0, 6267, + 6269, 1, 0, 0, 0, 6268, 6244, 1, 0, 0, 0, 6268, 6257, 1, 0, 0, 0, 6269, + 495, 1, 0, 0, 0, 6270, 6272, 5, 1256, 0, 0, 6271, 6273, 3, 1704, 852, 0, + 6272, 6271, 1, 0, 0, 0, 6272, 6273, 1, 0, 0, 0, 6273, 6276, 1, 0, 0, 0, + 6274, 6275, 5, 1973, 0, 0, 6275, 6277, 3, 1666, 833, 0, 6276, 6274, 1, + 0, 0, 0, 6276, 6277, 1, 0, 0, 0, 6277, 6279, 1, 0, 0, 0, 6278, 6280, 3, + 1608, 804, 0, 6279, 6278, 1, 0, 0, 0, 6279, 6280, 1, 0, 0, 0, 6280, 6282, + 1, 0, 0, 0, 6281, 6283, 5, 2087, 0, 0, 6282, 6281, 1, 0, 0, 0, 6282, 6283, + 1, 0, 0, 0, 6283, 497, 1, 0, 0, 0, 6284, 6285, 5, 1656, 0, 0, 6285, 6286, + 5, 680, 0, 0, 6286, 6287, 5, 2376, 0, 0, 6287, 6292, 3, 1666, 833, 0, 6288, + 6289, 5, 2382, 0, 0, 6289, 6291, 3, 1666, 833, 0, 6290, 6288, 1, 0, 0, + 0, 6291, 6294, 1, 0, 0, 0, 6292, 6290, 1, 0, 0, 0, 6292, 6293, 1, 0, 0, + 0, 6293, 6295, 1, 0, 0, 0, 6294, 6292, 1, 0, 0, 0, 6295, 6296, 5, 2377, + 0, 0, 6296, 6298, 1, 0, 0, 0, 6297, 6284, 1, 0, 0, 0, 6297, 6298, 1, 0, + 0, 0, 6298, 6299, 1, 0, 0, 0, 6299, 6300, 5, 2376, 0, 0, 6300, 6305, 3, + 500, 250, 0, 6301, 6302, 5, 2382, 0, 0, 6302, 6304, 3, 500, 250, 0, 6303, + 6301, 1, 0, 0, 0, 6304, 6307, 1, 0, 0, 0, 6305, 6303, 1, 0, 0, 0, 6305, + 6306, 1, 0, 0, 0, 6306, 6308, 1, 0, 0, 0, 6307, 6305, 1, 0, 0, 0, 6308, + 6309, 5, 2377, 0, 0, 6309, 499, 1, 0, 0, 0, 6310, 6312, 5, 1256, 0, 0, + 6311, 6313, 3, 1704, 852, 0, 6312, 6311, 1, 0, 0, 0, 6312, 6313, 1, 0, + 0, 0, 6313, 6318, 1, 0, 0, 0, 6314, 6317, 3, 1194, 597, 0, 6315, 6317, + 3, 1608, 804, 0, 6316, 6314, 1, 0, 0, 0, 6316, 6315, 1, 0, 0, 0, 6317, + 6320, 1, 0, 0, 0, 6318, 6316, 1, 0, 0, 0, 6318, 6319, 1, 0, 0, 0, 6319, + 6321, 1, 0, 0, 0, 6320, 6318, 1, 0, 0, 0, 6321, 6323, 5, 2087, 0, 0, 6322, + 6324, 3, 502, 251, 0, 6323, 6322, 1, 0, 0, 0, 6323, 6324, 1, 0, 0, 0, 6324, + 501, 1, 0, 0, 0, 6325, 6326, 5, 1656, 0, 0, 6326, 6327, 5, 680, 0, 0, 6327, + 6328, 5, 2376, 0, 0, 6328, 6333, 3, 1666, 833, 0, 6329, 6330, 5, 2382, + 0, 0, 6330, 6332, 3, 1666, 833, 0, 6331, 6329, 1, 0, 0, 0, 6332, 6335, + 1, 0, 0, 0, 6333, 6331, 1, 0, 0, 0, 6333, 6334, 1, 0, 0, 0, 6334, 6336, + 1, 0, 0, 0, 6335, 6333, 1, 0, 0, 0, 6336, 6337, 5, 2377, 0, 0, 6337, 6350, + 1, 0, 0, 0, 6338, 6339, 5, 2376, 0, 0, 6339, 6344, 3, 504, 252, 0, 6340, + 6341, 5, 2382, 0, 0, 6341, 6343, 3, 504, 252, 0, 6342, 6340, 1, 0, 0, 0, + 6343, 6346, 1, 0, 0, 0, 6344, 6342, 1, 0, 0, 0, 6344, 6345, 1, 0, 0, 0, + 6345, 6347, 1, 0, 0, 0, 6346, 6344, 1, 0, 0, 0, 6347, 6348, 5, 2377, 0, + 0, 6348, 6350, 1, 0, 0, 0, 6349, 6325, 1, 0, 0, 0, 6349, 6338, 1, 0, 0, + 0, 6350, 503, 1, 0, 0, 0, 6351, 6353, 5, 1668, 0, 0, 6352, 6354, 3, 1148, + 574, 0, 6353, 6352, 1, 0, 0, 0, 6353, 6354, 1, 0, 0, 0, 6354, 6357, 1, + 0, 0, 0, 6355, 6356, 5, 1973, 0, 0, 6356, 6358, 3, 1666, 833, 0, 6357, + 6355, 1, 0, 0, 0, 6357, 6358, 1, 0, 0, 0, 6358, 6360, 1, 0, 0, 0, 6359, + 6361, 3, 1608, 804, 0, 6360, 6359, 1, 0, 0, 0, 6360, 6361, 1, 0, 0, 0, + 6361, 6363, 1, 0, 0, 0, 6362, 6364, 5, 2087, 0, 0, 6363, 6362, 1, 0, 0, + 0, 6363, 6364, 1, 0, 0, 0, 6364, 505, 1, 0, 0, 0, 6365, 6366, 5, 2372, + 0, 0, 6366, 507, 1, 0, 0, 0, 6367, 6368, 3, 2378, 1189, 0, 6368, 6369, + 5, 2369, 0, 0, 6369, 6371, 1, 0, 0, 0, 6370, 6367, 1, 0, 0, 0, 6370, 6371, + 1, 0, 0, 0, 6371, 6372, 1, 0, 0, 0, 6372, 6373, 3, 2378, 1189, 0, 6373, + 509, 1, 0, 0, 0, 6374, 6375, 5, 41, 0, 0, 6375, 6376, 5, 659, 0, 0, 6376, + 6379, 3, 2300, 1150, 0, 6377, 6380, 3, 512, 256, 0, 6378, 6380, 3, 514, + 257, 0, 6379, 6377, 1, 0, 0, 0, 6379, 6378, 1, 0, 0, 0, 6380, 6381, 1, + 0, 0, 0, 6381, 6382, 5, 2396, 0, 0, 6382, 511, 1, 0, 0, 0, 6383, 6390, + 3, 1300, 650, 0, 6384, 6390, 3, 1298, 649, 0, 6385, 6390, 3, 1302, 651, + 0, 6386, 6390, 3, 926, 463, 0, 6387, 6390, 3, 1188, 594, 0, 6388, 6390, + 3, 882, 441, 0, 6389, 6383, 1, 0, 0, 0, 6389, 6384, 1, 0, 0, 0, 6389, 6385, + 1, 0, 0, 0, 6389, 6386, 1, 0, 0, 0, 6389, 6387, 1, 0, 0, 0, 6389, 6388, + 1, 0, 0, 0, 6390, 6391, 1, 0, 0, 0, 6391, 6389, 1, 0, 0, 0, 6391, 6392, + 1, 0, 0, 0, 6392, 513, 1, 0, 0, 0, 6393, 6415, 3, 520, 260, 0, 6394, 6395, + 5, 1244, 0, 0, 6395, 6396, 5, 2376, 0, 0, 6396, 6397, 3, 506, 253, 0, 6397, + 6398, 5, 2377, 0, 0, 6398, 6415, 1, 0, 0, 0, 6399, 6415, 5, 233, 0, 0, + 6400, 6415, 3, 1322, 661, 0, 6401, 6415, 5, 2087, 0, 0, 6402, 6415, 3, + 516, 258, 0, 6403, 6404, 5, 1460, 0, 0, 6404, 6405, 5, 2029, 0, 0, 6405, + 6415, 3, 548, 274, 0, 6406, 6415, 5, 214, 0, 0, 6407, 6408, 3, 518, 259, + 0, 6408, 6409, 5, 2100, 0, 0, 6409, 6415, 1, 0, 0, 0, 6410, 6411, 5, 2091, + 0, 0, 6411, 6412, 5, 134, 0, 0, 6412, 6415, 5, 1429, 0, 0, 6413, 6415, + 3, 522, 261, 0, 6414, 6393, 1, 0, 0, 0, 6414, 6394, 1, 0, 0, 0, 6414, 6399, + 1, 0, 0, 0, 6414, 6400, 1, 0, 0, 0, 6414, 6401, 1, 0, 0, 0, 6414, 6402, + 1, 0, 0, 0, 6414, 6403, 1, 0, 0, 0, 6414, 6406, 1, 0, 0, 0, 6414, 6407, + 1, 0, 0, 0, 6414, 6410, 1, 0, 0, 0, 6414, 6413, 1, 0, 0, 0, 6415, 515, + 1, 0, 0, 0, 6416, 6417, 7, 62, 0, 0, 6417, 517, 1, 0, 0, 0, 6418, 6419, + 7, 63, 0, 0, 6419, 519, 1, 0, 0, 0, 6420, 6427, 5, 1413, 0, 0, 6421, 6422, + 5, 1256, 0, 0, 6422, 6428, 3, 1704, 852, 0, 6423, 6424, 5, 1668, 0, 0, + 6424, 6428, 3, 1148, 574, 0, 6425, 6428, 5, 1489, 0, 0, 6426, 6428, 5, + 1095, 0, 0, 6427, 6421, 1, 0, 0, 0, 6427, 6423, 1, 0, 0, 0, 6427, 6425, + 1, 0, 0, 0, 6427, 6426, 1, 0, 0, 0, 6427, 6428, 1, 0, 0, 0, 6428, 6443, + 1, 0, 0, 0, 6429, 6442, 3, 926, 463, 0, 6430, 6431, 5, 1973, 0, 0, 6431, + 6442, 3, 1666, 833, 0, 6432, 6433, 5, 1244, 0, 0, 6433, 6434, 5, 2376, + 0, 0, 6434, 6435, 3, 506, 253, 0, 6435, 6436, 5, 2377, 0, 0, 6436, 6442, + 1, 0, 0, 0, 6437, 6442, 5, 1173, 0, 0, 6438, 6442, 3, 1188, 594, 0, 6439, + 6442, 3, 1608, 804, 0, 6440, 6442, 3, 882, 441, 0, 6441, 6429, 1, 0, 0, + 0, 6441, 6430, 1, 0, 0, 0, 6441, 6432, 1, 0, 0, 0, 6441, 6437, 1, 0, 0, + 0, 6441, 6438, 1, 0, 0, 0, 6441, 6439, 1, 0, 0, 0, 6441, 6440, 1, 0, 0, + 0, 6442, 6445, 1, 0, 0, 0, 6443, 6441, 1, 0, 0, 0, 6443, 6444, 1, 0, 0, + 0, 6444, 521, 1, 0, 0, 0, 6445, 6443, 1, 0, 0, 0, 6446, 6455, 3, 524, 262, + 0, 6447, 6455, 3, 526, 263, 0, 6448, 6455, 3, 530, 265, 0, 6449, 6455, + 3, 534, 267, 0, 6450, 6455, 3, 536, 268, 0, 6451, 6455, 3, 538, 269, 0, + 6452, 6455, 3, 528, 264, 0, 6453, 6455, 3, 542, 271, 0, 6454, 6446, 1, + 0, 0, 0, 6454, 6447, 1, 0, 0, 0, 6454, 6448, 1, 0, 0, 0, 6454, 6449, 1, + 0, 0, 0, 6454, 6450, 1, 0, 0, 0, 6454, 6451, 1, 0, 0, 0, 6454, 6452, 1, + 0, 0, 0, 6454, 6453, 1, 0, 0, 0, 6455, 523, 1, 0, 0, 0, 6456, 6457, 5, + 909, 0, 0, 6457, 6458, 5, 363, 0, 0, 6458, 6462, 5, 81, 0, 0, 6459, 6460, + 5, 564, 0, 0, 6460, 6461, 5, 1256, 0, 0, 6461, 6463, 3, 1704, 852, 0, 6462, + 6459, 1, 0, 0, 0, 6462, 6463, 1, 0, 0, 0, 6463, 6471, 1, 0, 0, 0, 6464, + 6472, 3, 1188, 594, 0, 6465, 6468, 5, 1973, 0, 0, 6466, 6469, 3, 1666, + 833, 0, 6467, 6469, 5, 363, 0, 0, 6468, 6466, 1, 0, 0, 0, 6468, 6467, 1, + 0, 0, 0, 6469, 6472, 1, 0, 0, 0, 6470, 6472, 3, 882, 441, 0, 6471, 6464, + 1, 0, 0, 0, 6471, 6465, 1, 0, 0, 0, 6471, 6470, 1, 0, 0, 0, 6472, 525, + 1, 0, 0, 0, 6473, 6474, 5, 20, 0, 0, 6474, 6476, 5, 1256, 0, 0, 6475, 6477, + 3, 1704, 852, 0, 6476, 6475, 1, 0, 0, 0, 6476, 6477, 1, 0, 0, 0, 6477, + 6480, 1, 0, 0, 0, 6478, 6479, 5, 1973, 0, 0, 6479, 6481, 3, 1666, 833, + 0, 6480, 6478, 1, 0, 0, 0, 6480, 6481, 1, 0, 0, 0, 6481, 6483, 1, 0, 0, + 0, 6482, 6484, 3, 1608, 804, 0, 6483, 6482, 1, 0, 0, 0, 6483, 6484, 1, + 0, 0, 0, 6484, 6486, 1, 0, 0, 0, 6485, 6487, 3, 926, 463, 0, 6486, 6485, + 1, 0, 0, 0, 6486, 6487, 1, 0, 0, 0, 6487, 527, 1, 0, 0, 0, 6488, 6489, + 5, 214, 0, 0, 6489, 6491, 5, 1256, 0, 0, 6490, 6492, 3, 926, 463, 0, 6491, + 6490, 1, 0, 0, 0, 6491, 6492, 1, 0, 0, 0, 6492, 529, 1, 0, 0, 0, 6493, + 6494, 5, 909, 0, 0, 6494, 6495, 5, 1256, 0, 0, 6495, 6511, 3, 1704, 852, + 0, 6496, 6498, 3, 532, 266, 0, 6497, 6496, 1, 0, 0, 0, 6498, 6499, 1, 0, + 0, 0, 6499, 6497, 1, 0, 0, 0, 6499, 6500, 1, 0, 0, 0, 6500, 6512, 1, 0, + 0, 0, 6501, 6502, 5, 1244, 0, 0, 6502, 6503, 5, 2376, 0, 0, 6503, 6504, + 3, 506, 253, 0, 6504, 6505, 5, 2377, 0, 0, 6505, 6512, 1, 0, 0, 0, 6506, + 6512, 5, 214, 0, 0, 6507, 6508, 5, 2091, 0, 0, 6508, 6509, 5, 134, 0, 0, + 6509, 6512, 5, 1429, 0, 0, 6510, 6512, 5, 2087, 0, 0, 6511, 6497, 1, 0, + 0, 0, 6511, 6501, 1, 0, 0, 0, 6511, 6506, 1, 0, 0, 0, 6511, 6507, 1, 0, + 0, 0, 6511, 6510, 1, 0, 0, 0, 6512, 531, 1, 0, 0, 0, 6513, 6519, 3, 1300, + 650, 0, 6514, 6519, 3, 1298, 649, 0, 6515, 6519, 3, 1188, 594, 0, 6516, + 6519, 3, 882, 441, 0, 6517, 6519, 3, 1608, 804, 0, 6518, 6513, 1, 0, 0, + 0, 6518, 6514, 1, 0, 0, 0, 6518, 6515, 1, 0, 0, 0, 6518, 6516, 1, 0, 0, + 0, 6518, 6517, 1, 0, 0, 0, 6519, 533, 1, 0, 0, 0, 6520, 6525, 5, 1460, + 0, 0, 6521, 6522, 5, 1256, 0, 0, 6522, 6526, 3, 1704, 852, 0, 6523, 6524, + 5, 1668, 0, 0, 6524, 6526, 3, 1148, 574, 0, 6525, 6521, 1, 0, 0, 0, 6525, + 6523, 1, 0, 0, 0, 6526, 6527, 1, 0, 0, 0, 6527, 6528, 5, 2029, 0, 0, 6528, + 6529, 3, 546, 273, 0, 6529, 535, 1, 0, 0, 0, 6530, 6531, 5, 425, 0, 0, + 6531, 6532, 5, 1256, 0, 0, 6532, 6533, 3, 1704, 852, 0, 6533, 537, 1, 0, + 0, 0, 6534, 6535, 5, 1612, 0, 0, 6535, 6536, 5, 1256, 0, 0, 6536, 6537, + 3, 544, 272, 0, 6537, 6538, 5, 79, 0, 0, 6538, 6539, 5, 2376, 0, 0, 6539, + 6544, 3, 2170, 1085, 0, 6540, 6541, 5, 2382, 0, 0, 6541, 6543, 3, 2170, + 1085, 0, 6542, 6540, 1, 0, 0, 0, 6543, 6546, 1, 0, 0, 0, 6544, 6542, 1, + 0, 0, 0, 6544, 6545, 1, 0, 0, 0, 6545, 6547, 1, 0, 0, 0, 6546, 6544, 1, + 0, 0, 0, 6547, 6555, 5, 2377, 0, 0, 6548, 6549, 5, 719, 0, 0, 6549, 6550, + 5, 2376, 0, 0, 6550, 6551, 3, 540, 270, 0, 6551, 6552, 5, 2382, 0, 0, 6552, + 6553, 3, 540, 270, 0, 6553, 6554, 5, 2377, 0, 0, 6554, 6556, 1, 0, 0, 0, + 6555, 6548, 1, 0, 0, 0, 6555, 6556, 1, 0, 0, 0, 6556, 6558, 1, 0, 0, 0, + 6557, 6559, 3, 926, 463, 0, 6558, 6557, 1, 0, 0, 0, 6558, 6559, 1, 0, 0, + 0, 6559, 539, 1, 0, 0, 0, 6560, 6578, 5, 1256, 0, 0, 6561, 6573, 3, 1704, + 852, 0, 6562, 6565, 3, 1194, 597, 0, 6563, 6565, 3, 1608, 804, 0, 6564, + 6562, 1, 0, 0, 0, 6564, 6563, 1, 0, 0, 0, 6565, 6566, 1, 0, 0, 0, 6566, + 6564, 1, 0, 0, 0, 6566, 6567, 1, 0, 0, 0, 6567, 6574, 1, 0, 0, 0, 6568, + 6569, 5, 1244, 0, 0, 6569, 6570, 5, 2376, 0, 0, 6570, 6571, 3, 506, 253, + 0, 6571, 6572, 5, 2377, 0, 0, 6572, 6574, 1, 0, 0, 0, 6573, 6564, 1, 0, + 0, 0, 6573, 6568, 1, 0, 0, 0, 6574, 6576, 1, 0, 0, 0, 6575, 6577, 5, 2087, + 0, 0, 6576, 6575, 1, 0, 0, 0, 6576, 6577, 1, 0, 0, 0, 6577, 6579, 1, 0, + 0, 0, 6578, 6561, 1, 0, 0, 0, 6578, 6579, 1, 0, 0, 0, 6579, 541, 1, 0, + 0, 0, 6580, 6581, 5, 909, 0, 0, 6581, 6582, 5, 1668, 0, 0, 6582, 6586, + 3, 1148, 574, 0, 6583, 6587, 5, 2087, 0, 0, 6584, 6587, 3, 1298, 649, 0, + 6585, 6587, 3, 1300, 650, 0, 6586, 6583, 1, 0, 0, 0, 6586, 6584, 1, 0, + 0, 0, 6586, 6585, 1, 0, 0, 0, 6587, 543, 1, 0, 0, 0, 6588, 6589, 3, 1704, + 852, 0, 6589, 545, 1, 0, 0, 0, 6590, 6591, 3, 1704, 852, 0, 6591, 547, + 1, 0, 0, 0, 6592, 6593, 3, 2300, 1150, 0, 6593, 549, 1, 0, 0, 0, 6594, + 6595, 5, 41, 0, 0, 6595, 6596, 5, 688, 0, 0, 6596, 6597, 5, 731, 0, 0, + 6597, 6601, 5, 593, 0, 0, 6598, 6599, 3, 2258, 1129, 0, 6599, 6600, 5, + 2369, 0, 0, 6600, 6602, 1, 0, 0, 0, 6601, 6598, 1, 0, 0, 0, 6601, 6602, + 1, 0, 0, 0, 6602, 6603, 1, 0, 0, 0, 6603, 6604, 3, 2378, 1189, 0, 6604, + 6605, 7, 64, 0, 0, 6605, 6609, 5, 2376, 0, 0, 6606, 6607, 3, 2258, 1129, + 0, 6607, 6608, 5, 2369, 0, 0, 6608, 6610, 1, 0, 0, 0, 6609, 6606, 1, 0, + 0, 0, 6609, 6610, 1, 0, 0, 0, 6610, 6611, 1, 0, 0, 0, 6611, 6612, 3, 2378, + 1189, 0, 6612, 6613, 5, 2376, 0, 0, 6613, 6614, 3, 2378, 1189, 0, 6614, + 6615, 5, 2377, 0, 0, 6615, 6616, 5, 2377, 0, 0, 6616, 551, 1, 0, 0, 0, + 6617, 6618, 5, 301, 0, 0, 6618, 6619, 5, 2121, 0, 0, 6619, 6629, 3, 2324, + 1162, 0, 6620, 6630, 3, 560, 280, 0, 6621, 6630, 3, 562, 281, 0, 6622, + 6630, 3, 564, 282, 0, 6623, 6630, 3, 566, 283, 0, 6624, 6630, 3, 568, 284, + 0, 6625, 6630, 3, 574, 287, 0, 6626, 6630, 3, 576, 288, 0, 6627, 6630, + 3, 578, 289, 0, 6628, 6630, 3, 762, 381, 0, 6629, 6620, 1, 0, 0, 0, 6629, + 6621, 1, 0, 0, 0, 6629, 6622, 1, 0, 0, 0, 6629, 6623, 1, 0, 0, 0, 6629, + 6624, 1, 0, 0, 0, 6629, 6625, 1, 0, 0, 0, 6629, 6626, 1, 0, 0, 0, 6629, + 6627, 1, 0, 0, 0, 6629, 6628, 1, 0, 0, 0, 6630, 6631, 1, 0, 0, 0, 6631, + 6629, 1, 0, 0, 0, 6631, 6632, 1, 0, 0, 0, 6632, 6633, 1, 0, 0, 0, 6633, + 6634, 5, 2396, 0, 0, 6634, 553, 1, 0, 0, 0, 6635, 6636, 5, 41, 0, 0, 6636, + 6637, 5, 2121, 0, 0, 6637, 6649, 3, 2324, 1162, 0, 6638, 6650, 3, 558, + 279, 0, 6639, 6650, 3, 562, 281, 0, 6640, 6650, 3, 564, 282, 0, 6641, 6650, + 3, 566, 283, 0, 6642, 6650, 3, 568, 284, 0, 6643, 6650, 3, 572, 286, 0, + 6644, 6650, 3, 574, 287, 0, 6645, 6650, 3, 576, 288, 0, 6646, 6650, 3, + 580, 290, 0, 6647, 6650, 3, 762, 381, 0, 6648, 6650, 3, 590, 295, 0, 6649, + 6638, 1, 0, 0, 0, 6649, 6639, 1, 0, 0, 0, 6649, 6640, 1, 0, 0, 0, 6649, + 6641, 1, 0, 0, 0, 6649, 6642, 1, 0, 0, 0, 6649, 6643, 1, 0, 0, 0, 6649, + 6644, 1, 0, 0, 0, 6649, 6645, 1, 0, 0, 0, 6649, 6646, 1, 0, 0, 0, 6649, + 6647, 1, 0, 0, 0, 6649, 6648, 1, 0, 0, 0, 6650, 6651, 1, 0, 0, 0, 6651, + 6649, 1, 0, 0, 0, 6651, 6652, 1, 0, 0, 0, 6652, 6653, 1, 0, 0, 0, 6653, + 6654, 5, 2396, 0, 0, 6654, 6667, 1, 0, 0, 0, 6655, 6660, 3, 2324, 1162, + 0, 6656, 6657, 5, 2382, 0, 0, 6657, 6659, 3, 2324, 1162, 0, 6658, 6656, + 1, 0, 0, 0, 6659, 6662, 1, 0, 0, 0, 6660, 6658, 1, 0, 0, 0, 6660, 6661, + 1, 0, 0, 0, 6661, 6663, 1, 0, 0, 0, 6662, 6660, 1, 0, 0, 0, 6663, 6664, + 3, 582, 291, 0, 6664, 6665, 5, 2396, 0, 0, 6665, 6667, 1, 0, 0, 0, 6666, + 6635, 1, 0, 0, 0, 6666, 6655, 1, 0, 0, 0, 6667, 555, 1, 0, 0, 0, 6668, + 6669, 5, 425, 0, 0, 6669, 6670, 5, 2121, 0, 0, 6670, 6672, 3, 2324, 1162, + 0, 6671, 6673, 5, 168, 0, 0, 6672, 6671, 1, 0, 0, 0, 6672, 6673, 1, 0, + 0, 0, 6673, 557, 1, 0, 0, 0, 6674, 6677, 3, 560, 280, 0, 6675, 6676, 5, + 1463, 0, 0, 6676, 6678, 3, 2378, 1189, 0, 6677, 6675, 1, 0, 0, 0, 6677, + 6678, 1, 0, 0, 0, 6678, 559, 1, 0, 0, 0, 6679, 6680, 5, 628, 0, 0, 6680, + 6681, 5, 151, 0, 0, 6681, 6682, 3, 2378, 1189, 0, 6682, 561, 1, 0, 0, 0, + 6683, 6684, 5, 628, 0, 0, 6684, 6687, 7, 65, 0, 0, 6685, 6686, 5, 66, 0, + 0, 6686, 6688, 3, 2372, 1186, 0, 6687, 6685, 1, 0, 0, 0, 6687, 6688, 1, + 0, 0, 0, 6688, 563, 1, 0, 0, 0, 6689, 6690, 7, 66, 0, 0, 6690, 6691, 5, + 1973, 0, 0, 6691, 6692, 3, 2378, 1189, 0, 6692, 565, 1, 0, 0, 0, 6693, + 6696, 5, 1394, 0, 0, 6694, 6697, 3, 1170, 585, 0, 6695, 6697, 5, 2070, + 0, 0, 6696, 6694, 1, 0, 0, 0, 6696, 6695, 1, 0, 0, 0, 6697, 6698, 1, 0, + 0, 0, 6698, 6699, 5, 1175, 0, 0, 6699, 6700, 3, 2378, 1189, 0, 6700, 567, + 1, 0, 0, 0, 6701, 6702, 5, 1367, 0, 0, 6702, 6703, 3, 2378, 1189, 0, 6703, + 569, 1, 0, 0, 0, 6704, 6709, 3, 2280, 1140, 0, 6705, 6706, 5, 2382, 0, + 0, 6706, 6708, 3, 2280, 1140, 0, 6707, 6705, 1, 0, 0, 0, 6708, 6711, 1, + 0, 0, 0, 6709, 6707, 1, 0, 0, 0, 6709, 6710, 1, 0, 0, 0, 6710, 6728, 1, + 0, 0, 0, 6711, 6709, 1, 0, 0, 0, 6712, 6724, 5, 37, 0, 0, 6713, 6714, 5, + 481, 0, 0, 6714, 6719, 3, 2280, 1140, 0, 6715, 6716, 5, 2382, 0, 0, 6716, + 6718, 3, 2280, 1140, 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, 6723, 1, 0, 0, 0, + 6721, 6719, 1, 0, 0, 0, 6722, 6713, 1, 0, 0, 0, 6723, 6726, 1, 0, 0, 0, + 6724, 6722, 1, 0, 0, 0, 6724, 6725, 1, 0, 0, 0, 6725, 6728, 1, 0, 0, 0, + 6726, 6724, 1, 0, 0, 0, 6727, 6704, 1, 0, 0, 0, 6727, 6712, 1, 0, 0, 0, + 6728, 571, 1, 0, 0, 0, 6729, 6730, 5, 363, 0, 0, 6730, 6733, 5, 1494, 0, + 0, 6731, 6734, 5, 1054, 0, 0, 6732, 6734, 3, 570, 285, 0, 6733, 6731, 1, + 0, 0, 0, 6733, 6732, 1, 0, 0, 0, 6734, 573, 1, 0, 0, 0, 6735, 6736, 5, + 1264, 0, 0, 6736, 6737, 5, 498, 0, 0, 6737, 575, 1, 0, 0, 0, 6738, 6739, + 5, 6, 0, 0, 6739, 6740, 7, 67, 0, 0, 6740, 577, 1, 0, 0, 0, 6741, 6742, + 5, 453, 0, 0, 6742, 6743, 5, 440, 0, 0, 6743, 579, 1, 0, 0, 0, 6744, 6754, + 3, 578, 289, 0, 6745, 6746, 5, 564, 0, 0, 6746, 6751, 3, 2382, 1191, 0, + 6747, 6748, 5, 2382, 0, 0, 6748, 6750, 3, 2382, 1191, 0, 6749, 6747, 1, + 0, 0, 0, 6750, 6753, 1, 0, 0, 0, 6751, 6749, 1, 0, 0, 0, 6751, 6752, 1, + 0, 0, 0, 6752, 6755, 1, 0, 0, 0, 6753, 6751, 1, 0, 0, 0, 6754, 6745, 1, + 0, 0, 0, 6754, 6755, 1, 0, 0, 0, 6755, 6757, 1, 0, 0, 0, 6756, 6758, 5, + 560, 0, 0, 6757, 6756, 1, 0, 0, 0, 6757, 6758, 1, 0, 0, 0, 6758, 581, 1, + 0, 0, 0, 6759, 6760, 5, 1490, 0, 0, 6760, 6761, 5, 261, 0, 0, 6761, 6765, + 5, 1992, 0, 0, 6762, 6763, 5, 464, 0, 0, 6763, 6766, 5, 2119, 0, 0, 6764, + 6766, 3, 2324, 1162, 0, 6765, 6762, 1, 0, 0, 0, 6765, 6764, 1, 0, 0, 0, + 6766, 6799, 1, 0, 0, 0, 6767, 6768, 5, 591, 0, 0, 6768, 6769, 5, 261, 0, + 0, 6769, 6796, 5, 1992, 0, 0, 6770, 6771, 5, 464, 0, 0, 6771, 6797, 5, + 2119, 0, 0, 6772, 6780, 3, 2324, 1162, 0, 6773, 6778, 5, 2188, 0, 0, 6774, + 6775, 5, 1057, 0, 0, 6775, 6779, 5, 1496, 0, 0, 6776, 6777, 5, 1494, 0, + 0, 6777, 6779, 3, 570, 285, 0, 6778, 6774, 1, 0, 0, 0, 6778, 6776, 1, 0, + 0, 0, 6779, 6781, 1, 0, 0, 0, 6780, 6773, 1, 0, 0, 0, 6780, 6781, 1, 0, + 0, 0, 6781, 6784, 1, 0, 0, 0, 6782, 6783, 5, 84, 0, 0, 6783, 6785, 5, 1465, + 0, 0, 6784, 6782, 1, 0, 0, 0, 6784, 6785, 1, 0, 0, 0, 6785, 6794, 1, 0, + 0, 0, 6786, 6787, 5, 83, 0, 0, 6787, 6792, 5, 2129, 0, 0, 6788, 6793, 5, + 1264, 0, 0, 6789, 6793, 5, 176, 0, 0, 6790, 6791, 5, 411, 0, 0, 6791, 6793, + 5, 926, 0, 0, 6792, 6788, 1, 0, 0, 0, 6792, 6789, 1, 0, 0, 0, 6792, 6790, + 1, 0, 0, 0, 6793, 6795, 1, 0, 0, 0, 6794, 6786, 1, 0, 0, 0, 6794, 6795, + 1, 0, 0, 0, 6795, 6797, 1, 0, 0, 0, 6796, 6770, 1, 0, 0, 0, 6796, 6772, + 1, 0, 0, 0, 6797, 6799, 1, 0, 0, 0, 6798, 6759, 1, 0, 0, 0, 6798, 6767, + 1, 0, 0, 0, 6799, 583, 1, 0, 0, 0, 6800, 6801, 5, 2376, 0, 0, 6801, 6806, + 3, 2378, 1189, 0, 6802, 6803, 5, 2382, 0, 0, 6803, 6805, 3, 2378, 1189, + 0, 6804, 6802, 1, 0, 0, 0, 6805, 6808, 1, 0, 0, 0, 6806, 6804, 1, 0, 0, + 0, 6806, 6807, 1, 0, 0, 0, 6807, 6809, 1, 0, 0, 0, 6808, 6806, 1, 0, 0, + 0, 6809, 6810, 5, 2377, 0, 0, 6810, 585, 1, 0, 0, 0, 6811, 6812, 5, 1568, + 0, 0, 6812, 6813, 5, 273, 0, 0, 6813, 6817, 5, 2398, 0, 0, 6814, 6818, + 5, 37, 0, 0, 6815, 6818, 5, 363, 0, 0, 6816, 6818, 3, 584, 292, 0, 6817, + 6814, 1, 0, 0, 0, 6817, 6815, 1, 0, 0, 0, 6817, 6816, 1, 0, 0, 0, 6818, + 587, 1, 0, 0, 0, 6819, 6820, 7, 64, 0, 0, 6820, 6821, 5, 273, 0, 0, 6821, + 6822, 5, 2398, 0, 0, 6822, 6823, 3, 584, 292, 0, 6823, 589, 1, 0, 0, 0, + 6824, 6831, 3, 586, 293, 0, 6825, 6828, 3, 588, 294, 0, 6826, 6827, 5, + 564, 0, 0, 6827, 6829, 3, 2272, 1136, 0, 6828, 6826, 1, 0, 0, 0, 6828, + 6829, 1, 0, 0, 0, 6829, 6831, 1, 0, 0, 0, 6830, 6824, 1, 0, 0, 0, 6830, + 6825, 1, 0, 0, 0, 6831, 591, 1, 0, 0, 0, 6832, 6833, 5, 26, 0, 0, 6833, + 6834, 5, 753, 0, 0, 6834, 6839, 5, 836, 0, 0, 6835, 6840, 3, 594, 297, + 0, 6836, 6840, 3, 616, 308, 0, 6837, 6840, 3, 646, 323, 0, 6838, 6840, + 3, 656, 328, 0, 6839, 6835, 1, 0, 0, 0, 6839, 6836, 1, 0, 0, 0, 6839, 6837, + 1, 0, 0, 0, 6839, 6838, 1, 0, 0, 0, 6840, 6841, 1, 0, 0, 0, 6841, 6842, + 5, 2396, 0, 0, 6842, 593, 1, 0, 0, 0, 6843, 6853, 3, 596, 298, 0, 6844, + 6853, 3, 598, 299, 0, 6845, 6853, 3, 602, 301, 0, 6846, 6853, 3, 604, 302, + 0, 6847, 6853, 3, 606, 303, 0, 6848, 6853, 3, 608, 304, 0, 6849, 6853, + 3, 610, 305, 0, 6850, 6853, 3, 612, 306, 0, 6851, 6853, 3, 614, 307, 0, + 6852, 6843, 1, 0, 0, 0, 6852, 6844, 1, 0, 0, 0, 6852, 6845, 1, 0, 0, 0, + 6852, 6846, 1, 0, 0, 0, 6852, 6847, 1, 0, 0, 0, 6852, 6848, 1, 0, 0, 0, + 6852, 6849, 1, 0, 0, 0, 6852, 6850, 1, 0, 0, 0, 6852, 6851, 1, 0, 0, 0, + 6853, 595, 1, 0, 0, 0, 6854, 6865, 5, 301, 0, 0, 6855, 6856, 5, 757, 0, + 0, 6856, 6866, 5, 2372, 0, 0, 6857, 6859, 5, 804, 0, 0, 6858, 6857, 1, + 0, 0, 0, 6858, 6859, 1, 0, 0, 0, 6859, 6860, 1, 0, 0, 0, 6860, 6861, 5, + 90, 0, 0, 6861, 6862, 5, 757, 0, 0, 6862, 6863, 5, 572, 0, 0, 6863, 6864, + 5, 757, 0, 0, 6864, 6866, 5, 2372, 0, 0, 6865, 6855, 1, 0, 0, 0, 6865, + 6858, 1, 0, 0, 0, 6866, 6867, 1, 0, 0, 0, 6867, 6868, 5, 628, 0, 0, 6868, + 6869, 5, 151, 0, 0, 6869, 6870, 3, 662, 331, 0, 6870, 597, 1, 0, 0, 0, + 6871, 6872, 5, 1568, 0, 0, 6872, 6873, 5, 757, 0, 0, 6873, 6875, 5, 1180, + 0, 0, 6874, 6876, 3, 600, 300, 0, 6875, 6874, 1, 0, 0, 0, 6875, 6876, 1, + 0, 0, 0, 6876, 6877, 1, 0, 0, 0, 6877, 6879, 3, 640, 320, 0, 6878, 6880, + 3, 762, 381, 0, 6879, 6878, 1, 0, 0, 0, 6879, 6880, 1, 0, 0, 0, 6880, 599, + 1, 0, 0, 0, 6881, 6882, 5, 560, 0, 0, 6882, 6883, 5, 757, 0, 0, 6883, 601, + 1, 0, 0, 0, 6884, 6885, 5, 1568, 0, 0, 6885, 6886, 5, 757, 0, 0, 6886, + 6888, 5, 204, 0, 0, 6887, 6889, 3, 640, 320, 0, 6888, 6887, 1, 0, 0, 0, + 6888, 6889, 1, 0, 0, 0, 6889, 6891, 1, 0, 0, 0, 6890, 6892, 3, 762, 381, + 0, 6891, 6890, 1, 0, 0, 0, 6891, 6892, 1, 0, 0, 0, 6892, 603, 1, 0, 0, + 0, 6893, 6894, 5, 98, 0, 0, 6894, 6897, 5, 757, 0, 0, 6895, 6896, 5, 2129, + 0, 0, 6896, 6898, 5, 2372, 0, 0, 6897, 6895, 1, 0, 0, 0, 6897, 6898, 1, + 0, 0, 0, 6898, 6900, 1, 0, 0, 0, 6899, 6901, 3, 600, 300, 0, 6900, 6899, + 1, 0, 0, 0, 6900, 6901, 1, 0, 0, 0, 6901, 6902, 1, 0, 0, 0, 6902, 6905, + 3, 640, 320, 0, 6903, 6904, 5, 2029, 0, 0, 6904, 6906, 5, 2372, 0, 0, 6905, + 6903, 1, 0, 0, 0, 6905, 6906, 1, 0, 0, 0, 6906, 605, 1, 0, 0, 0, 6907, + 6908, 5, 41, 0, 0, 6908, 6909, 5, 757, 0, 0, 6909, 6911, 5, 1264, 0, 0, + 6910, 6912, 3, 600, 300, 0, 6911, 6910, 1, 0, 0, 0, 6911, 6912, 1, 0, 0, + 0, 6912, 6913, 1, 0, 0, 0, 6913, 6914, 5, 628, 0, 0, 6914, 6915, 5, 151, + 0, 0, 6915, 6916, 3, 662, 331, 0, 6916, 6917, 5, 1568, 0, 0, 6917, 6919, + 3, 662, 331, 0, 6918, 6920, 3, 658, 329, 0, 6919, 6918, 1, 0, 0, 0, 6919, + 6920, 1, 0, 0, 0, 6920, 607, 1, 0, 0, 0, 6921, 6922, 5, 875, 0, 0, 6922, + 6923, 5, 757, 0, 0, 6923, 6925, 5, 2372, 0, 0, 6924, 6926, 3, 660, 330, + 0, 6925, 6924, 1, 0, 0, 0, 6925, 6926, 1, 0, 0, 0, 6926, 6927, 1, 0, 0, + 0, 6927, 6928, 5, 48, 0, 0, 6928, 6929, 5, 757, 0, 0, 6929, 6931, 5, 2372, + 0, 0, 6930, 6932, 3, 660, 330, 0, 6931, 6930, 1, 0, 0, 0, 6931, 6932, 1, + 0, 0, 0, 6932, 6933, 1, 0, 0, 0, 6933, 6934, 5, 719, 0, 0, 6934, 6935, + 5, 950, 0, 0, 6935, 6936, 5, 757, 0, 0, 6936, 6937, 5, 2372, 0, 0, 6937, + 6938, 3, 660, 330, 0, 6938, 609, 1, 0, 0, 0, 6939, 6940, 5, 875, 0, 0, + 6940, 6941, 5, 757, 0, 0, 6941, 6943, 5, 2372, 0, 0, 6942, 6944, 3, 660, + 330, 0, 6943, 6942, 1, 0, 0, 0, 6943, 6944, 1, 0, 0, 0, 6944, 6945, 1, + 0, 0, 0, 6945, 6946, 5, 719, 0, 0, 6946, 6947, 5, 491, 0, 0, 6947, 6948, + 5, 757, 0, 0, 6948, 6949, 5, 2372, 0, 0, 6949, 6951, 3, 660, 330, 0, 6950, + 6952, 3, 658, 329, 0, 6951, 6950, 1, 0, 0, 0, 6951, 6952, 1, 0, 0, 0, 6952, + 611, 1, 0, 0, 0, 6953, 6955, 5, 560, 0, 0, 6954, 6953, 1, 0, 0, 0, 6954, + 6955, 1, 0, 0, 0, 6955, 6956, 1, 0, 0, 0, 6956, 6957, 5, 2262, 0, 0, 6957, + 6958, 5, 757, 0, 0, 6958, 6959, 5, 628, 0, 0, 6959, 6960, 5, 151, 0, 0, + 6960, 6961, 3, 662, 331, 0, 6961, 6962, 5, 572, 0, 0, 6962, 6963, 5, 2263, + 0, 0, 6963, 6965, 5, 757, 0, 0, 6964, 6966, 3, 600, 300, 0, 6965, 6964, + 1, 0, 0, 0, 6965, 6966, 1, 0, 0, 0, 6966, 6967, 1, 0, 0, 0, 6967, 6969, + 3, 640, 320, 0, 6968, 6970, 3, 658, 329, 0, 6969, 6968, 1, 0, 0, 0, 6969, + 6970, 1, 0, 0, 0, 6970, 613, 1, 0, 0, 0, 6971, 6972, 5, 2264, 0, 0, 6972, + 6973, 5, 757, 0, 0, 6973, 6974, 5, 628, 0, 0, 6974, 6975, 5, 151, 0, 0, + 6975, 6976, 3, 662, 331, 0, 6976, 6977, 5, 2188, 0, 0, 6977, 6978, 5, 2263, + 0, 0, 6978, 6980, 5, 757, 0, 0, 6979, 6981, 3, 600, 300, 0, 6980, 6979, + 1, 0, 0, 0, 6980, 6981, 1, 0, 0, 0, 6981, 6982, 1, 0, 0, 0, 6982, 6984, + 3, 640, 320, 0, 6983, 6985, 3, 658, 329, 0, 6984, 6983, 1, 0, 0, 0, 6984, + 6985, 1, 0, 0, 0, 6985, 615, 1, 0, 0, 0, 6986, 6996, 3, 618, 309, 0, 6987, + 6996, 3, 620, 310, 0, 6988, 6996, 3, 626, 313, 0, 6989, 6996, 3, 628, 314, + 0, 6990, 6996, 3, 630, 315, 0, 6991, 6996, 3, 632, 316, 0, 6992, 6996, + 3, 634, 317, 0, 6993, 6996, 3, 636, 318, 0, 6994, 6996, 3, 638, 319, 0, + 6995, 6986, 1, 0, 0, 0, 6995, 6987, 1, 0, 0, 0, 6995, 6988, 1, 0, 0, 0, + 6995, 6989, 1, 0, 0, 0, 6995, 6990, 1, 0, 0, 0, 6995, 6991, 1, 0, 0, 0, + 6995, 6992, 1, 0, 0, 0, 6995, 6993, 1, 0, 0, 0, 6995, 6994, 1, 0, 0, 0, + 6996, 617, 1, 0, 0, 0, 6997, 6999, 5, 1568, 0, 0, 6998, 7000, 5, 458, 0, + 0, 6999, 6998, 1, 0, 0, 0, 6999, 7000, 1, 0, 0, 0, 7000, 7001, 1, 0, 0, + 0, 7001, 7008, 5, 753, 0, 0, 7002, 7003, 3, 622, 311, 0, 7003, 7004, 5, + 2395, 0, 0, 7004, 7006, 1, 0, 0, 0, 7005, 7002, 1, 0, 0, 0, 7005, 7006, + 1, 0, 0, 0, 7006, 7007, 1, 0, 0, 0, 7007, 7009, 3, 624, 312, 0, 7008, 7005, + 1, 0, 0, 0, 7008, 7009, 1, 0, 0, 0, 7009, 7011, 1, 0, 0, 0, 7010, 7012, + 3, 644, 322, 0, 7011, 7010, 1, 0, 0, 0, 7011, 7012, 1, 0, 0, 0, 7012, 7014, + 1, 0, 0, 0, 7013, 7015, 3, 642, 321, 0, 7014, 7013, 1, 0, 0, 0, 7014, 7015, + 1, 0, 0, 0, 7015, 7017, 1, 0, 0, 0, 7016, 7018, 3, 600, 300, 0, 7017, 7016, + 1, 0, 0, 0, 7017, 7018, 1, 0, 0, 0, 7018, 7019, 1, 0, 0, 0, 7019, 7021, + 3, 640, 320, 0, 7020, 7022, 3, 658, 329, 0, 7021, 7020, 1, 0, 0, 0, 7021, + 7022, 1, 0, 0, 0, 7022, 7024, 1, 0, 0, 0, 7023, 7025, 3, 762, 381, 0, 7024, + 7023, 1, 0, 0, 0, 7024, 7025, 1, 0, 0, 0, 7025, 619, 1, 0, 0, 0, 7026, + 7028, 5, 301, 0, 0, 7027, 7029, 5, 458, 0, 0, 7028, 7027, 1, 0, 0, 0, 7028, + 7029, 1, 0, 0, 0, 7029, 7030, 1, 0, 0, 0, 7030, 7037, 5, 753, 0, 0, 7031, + 7032, 3, 622, 311, 0, 7032, 7033, 5, 2395, 0, 0, 7033, 7035, 1, 0, 0, 0, + 7034, 7031, 1, 0, 0, 0, 7034, 7035, 1, 0, 0, 0, 7035, 7036, 1, 0, 0, 0, + 7036, 7038, 3, 624, 312, 0, 7037, 7034, 1, 0, 0, 0, 7037, 7038, 1, 0, 0, + 0, 7038, 7040, 1, 0, 0, 0, 7039, 7041, 3, 644, 322, 0, 7040, 7039, 1, 0, + 0, 0, 7040, 7041, 1, 0, 0, 0, 7041, 7043, 1, 0, 0, 0, 7042, 7044, 3, 642, + 321, 0, 7043, 7042, 1, 0, 0, 0, 7043, 7044, 1, 0, 0, 0, 7044, 7046, 1, + 0, 0, 0, 7045, 7047, 3, 600, 300, 0, 7046, 7045, 1, 0, 0, 0, 7046, 7047, + 1, 0, 0, 0, 7047, 7048, 1, 0, 0, 0, 7048, 7050, 3, 640, 320, 0, 7049, 7051, + 3, 658, 329, 0, 7050, 7049, 1, 0, 0, 0, 7050, 7051, 1, 0, 0, 0, 7051, 7053, + 1, 0, 0, 0, 7052, 7054, 3, 762, 381, 0, 7053, 7052, 1, 0, 0, 0, 7053, 7054, + 1, 0, 0, 0, 7054, 621, 1, 0, 0, 0, 7055, 7056, 5, 2372, 0, 0, 7056, 623, + 1, 0, 0, 0, 7057, 7058, 5, 2372, 0, 0, 7058, 625, 1, 0, 0, 0, 7059, 7061, + 5, 2125, 0, 0, 7060, 7062, 5, 458, 0, 0, 7061, 7060, 1, 0, 0, 0, 7061, + 7062, 1, 0, 0, 0, 7062, 7063, 1, 0, 0, 0, 7063, 7064, 5, 753, 0, 0, 7064, + 7066, 5, 2372, 0, 0, 7065, 7067, 3, 644, 322, 0, 7066, 7065, 1, 0, 0, 0, + 7066, 7067, 1, 0, 0, 0, 7067, 7069, 1, 0, 0, 0, 7068, 7070, 3, 600, 300, + 0, 7069, 7068, 1, 0, 0, 0, 7069, 7070, 1, 0, 0, 0, 7070, 7071, 1, 0, 0, + 0, 7071, 7073, 3, 640, 320, 0, 7072, 7074, 3, 658, 329, 0, 7073, 7072, + 1, 0, 0, 0, 7073, 7074, 1, 0, 0, 0, 7074, 627, 1, 0, 0, 0, 7075, 7076, + 5, 1568, 0, 0, 7076, 7077, 5, 1978, 0, 0, 7077, 7078, 5, 2372, 0, 0, 7078, + 7079, 5, 564, 0, 0, 7079, 7081, 5, 2372, 0, 0, 7080, 7082, 3, 600, 300, + 0, 7081, 7080, 1, 0, 0, 0, 7081, 7082, 1, 0, 0, 0, 7082, 7083, 1, 0, 0, + 0, 7083, 7085, 3, 640, 320, 0, 7084, 7086, 3, 658, 329, 0, 7085, 7084, + 1, 0, 0, 0, 7085, 7086, 1, 0, 0, 0, 7086, 629, 1, 0, 0, 0, 7087, 7089, + 5, 501, 0, 0, 7088, 7090, 5, 458, 0, 0, 7089, 7088, 1, 0, 0, 0, 7089, 7090, + 1, 0, 0, 0, 7090, 7091, 1, 0, 0, 0, 7091, 7092, 5, 756, 0, 0, 7092, 7093, + 5, 2188, 0, 0, 7093, 7094, 5, 1539, 0, 0, 7094, 7095, 3, 666, 333, 0, 7095, + 7096, 5, 2029, 0, 0, 7096, 7098, 3, 1472, 736, 0, 7097, 7099, 3, 600, 300, + 0, 7098, 7097, 1, 0, 0, 0, 7098, 7099, 1, 0, 0, 0, 7099, 7100, 1, 0, 0, + 0, 7100, 7118, 3, 640, 320, 0, 7101, 7102, 5, 2188, 0, 0, 7102, 7103, 5, + 629, 0, 0, 7103, 7116, 5, 680, 0, 0, 7104, 7109, 5, 2372, 0, 0, 7105, 7106, + 5, 2382, 0, 0, 7106, 7108, 5, 2372, 0, 0, 7107, 7105, 1, 0, 0, 0, 7108, + 7111, 1, 0, 0, 0, 7109, 7107, 1, 0, 0, 0, 7109, 7110, 1, 0, 0, 0, 7110, + 7117, 1, 0, 0, 0, 7111, 7109, 1, 0, 0, 0, 7112, 7113, 5, 2376, 0, 0, 7113, + 7114, 3, 1892, 946, 0, 7114, 7115, 5, 2377, 0, 0, 7115, 7117, 1, 0, 0, + 0, 7116, 7104, 1, 0, 0, 0, 7116, 7112, 1, 0, 0, 0, 7117, 7119, 1, 0, 0, + 0, 7118, 7101, 1, 0, 0, 0, 7118, 7119, 1, 0, 0, 0, 7119, 631, 1, 0, 0, + 0, 7120, 7122, 5, 642, 0, 0, 7121, 7123, 5, 458, 0, 0, 7122, 7121, 1, 0, + 0, 0, 7122, 7123, 1, 0, 0, 0, 7123, 7124, 1, 0, 0, 0, 7124, 7125, 5, 756, + 0, 0, 7125, 7126, 5, 2188, 0, 0, 7126, 7127, 5, 1539, 0, 0, 7127, 7128, + 3, 666, 333, 0, 7128, 7129, 5, 572, 0, 0, 7129, 7131, 3, 1472, 736, 0, + 7130, 7132, 3, 600, 300, 0, 7131, 7130, 1, 0, 0, 0, 7131, 7132, 1, 0, 0, + 0, 7132, 7133, 1, 0, 0, 0, 7133, 7135, 3, 640, 320, 0, 7134, 7136, 3, 658, + 329, 0, 7135, 7134, 1, 0, 0, 0, 7135, 7136, 1, 0, 0, 0, 7136, 633, 1, 0, + 0, 0, 7137, 7139, 5, 1568, 0, 0, 7138, 7140, 5, 458, 0, 0, 7139, 7138, + 1, 0, 0, 0, 7139, 7140, 1, 0, 0, 0, 7140, 7141, 1, 0, 0, 0, 7141, 7142, + 5, 753, 0, 0, 7142, 7143, 5, 628, 0, 0, 7143, 7144, 5, 151, 0, 0, 7144, + 7146, 3, 666, 333, 0, 7145, 7147, 3, 600, 300, 0, 7146, 7145, 1, 0, 0, + 0, 7146, 7147, 1, 0, 0, 0, 7147, 7148, 1, 0, 0, 0, 7148, 7149, 5, 879, + 0, 0, 7149, 7150, 5, 2129, 0, 0, 7150, 7152, 3, 662, 331, 0, 7151, 7153, + 3, 658, 329, 0, 7152, 7151, 1, 0, 0, 0, 7152, 7153, 1, 0, 0, 0, 7153, 635, + 1, 0, 0, 0, 7154, 7156, 5, 1568, 0, 0, 7155, 7157, 5, 458, 0, 0, 7156, + 7155, 1, 0, 0, 0, 7156, 7157, 1, 0, 0, 0, 7157, 7158, 1, 0, 0, 0, 7158, + 7159, 5, 753, 0, 0, 7159, 7160, 5, 628, 0, 0, 7160, 7161, 5, 151, 0, 0, + 7161, 7163, 3, 666, 333, 0, 7162, 7164, 3, 600, 300, 0, 7163, 7162, 1, + 0, 0, 0, 7163, 7164, 1, 0, 0, 0, 7164, 7165, 1, 0, 0, 0, 7165, 7166, 5, + 1489, 0, 0, 7166, 7167, 5, 879, 0, 0, 7167, 7168, 5, 2129, 0, 0, 7168, + 7169, 3, 666, 333, 0, 7169, 637, 1, 0, 0, 0, 7170, 7172, 5, 921, 0, 0, + 7171, 7173, 5, 458, 0, 0, 7172, 7171, 1, 0, 0, 0, 7172, 7173, 1, 0, 0, + 0, 7173, 7174, 1, 0, 0, 0, 7174, 7175, 5, 756, 0, 0, 7175, 7176, 5, 2029, + 0, 0, 7176, 7177, 5, 950, 0, 0, 7177, 7178, 5, 757, 0, 0, 7178, 7179, 5, + 2372, 0, 0, 7179, 7180, 5, 628, 0, 0, 7180, 7181, 5, 151, 0, 0, 7181, 7182, + 3, 662, 331, 0, 7182, 7184, 5, 572, 0, 0, 7183, 7185, 5, 560, 0, 0, 7184, + 7183, 1, 0, 0, 0, 7184, 7185, 1, 0, 0, 0, 7185, 7186, 1, 0, 0, 0, 7186, + 7187, 5, 757, 0, 0, 7187, 7188, 5, 628, 0, 0, 7188, 7189, 5, 151, 0, 0, + 7189, 7204, 3, 662, 331, 0, 7190, 7191, 5, 2188, 0, 0, 7191, 7192, 5, 629, + 0, 0, 7192, 7202, 5, 680, 0, 0, 7193, 7198, 5, 2372, 0, 0, 7194, 7195, + 5, 2382, 0, 0, 7195, 7197, 5, 2372, 0, 0, 7196, 7194, 1, 0, 0, 0, 7197, + 7200, 1, 0, 0, 0, 7198, 7196, 1, 0, 0, 0, 7198, 7199, 1, 0, 0, 0, 7199, + 7203, 1, 0, 0, 0, 7200, 7198, 1, 0, 0, 0, 7201, 7203, 3, 1892, 946, 0, + 7202, 7193, 1, 0, 0, 0, 7202, 7201, 1, 0, 0, 0, 7203, 7205, 1, 0, 0, 0, + 7204, 7190, 1, 0, 0, 0, 7204, 7205, 1, 0, 0, 0, 7205, 7207, 1, 0, 0, 0, + 7206, 7208, 3, 658, 329, 0, 7207, 7206, 1, 0, 0, 0, 7207, 7208, 1, 0, 0, + 0, 7208, 639, 1, 0, 0, 0, 7209, 7210, 5, 628, 0, 0, 7210, 7214, 5, 151, + 0, 0, 7211, 7212, 5, 507, 0, 0, 7212, 7215, 5, 1656, 0, 0, 7213, 7215, + 3, 662, 331, 0, 7214, 7211, 1, 0, 0, 0, 7214, 7213, 1, 0, 0, 0, 7215, 641, + 1, 0, 0, 0, 7216, 7217, 5, 2129, 0, 0, 7217, 7218, 5, 2265, 0, 0, 7218, + 7219, 5, 2372, 0, 0, 7219, 643, 1, 0, 0, 0, 7220, 7221, 5, 2129, 0, 0, + 7221, 7222, 5, 1978, 0, 0, 7222, 7223, 5, 2372, 0, 0, 7223, 645, 1, 0, + 0, 0, 7224, 7229, 3, 648, 324, 0, 7225, 7229, 3, 650, 325, 0, 7226, 7229, + 3, 652, 326, 0, 7227, 7229, 3, 654, 327, 0, 7228, 7224, 1, 0, 0, 0, 7228, + 7225, 1, 0, 0, 0, 7228, 7226, 1, 0, 0, 0, 7228, 7227, 1, 0, 0, 0, 7229, + 647, 1, 0, 0, 0, 7230, 7231, 7, 68, 0, 0, 7231, 7232, 5, 1539, 0, 0, 7232, + 7233, 5, 2372, 0, 0, 7233, 7234, 5, 564, 0, 0, 7234, 7235, 5, 200, 0, 0, + 7235, 7237, 5, 2372, 0, 0, 7236, 7238, 3, 644, 322, 0, 7237, 7236, 1, 0, + 0, 0, 7237, 7238, 1, 0, 0, 0, 7238, 7240, 1, 0, 0, 0, 7239, 7241, 3, 600, + 300, 0, 7240, 7239, 1, 0, 0, 0, 7240, 7241, 1, 0, 0, 0, 7241, 7243, 1, + 0, 0, 0, 7242, 7244, 3, 640, 320, 0, 7243, 7242, 1, 0, 0, 0, 7243, 7244, + 1, 0, 0, 0, 7244, 7246, 1, 0, 0, 0, 7245, 7247, 3, 658, 329, 0, 7246, 7245, + 1, 0, 0, 0, 7246, 7247, 1, 0, 0, 0, 7247, 649, 1, 0, 0, 0, 7248, 7249, + 5, 376, 0, 0, 7249, 7250, 5, 1539, 0, 0, 7250, 7251, 5, 564, 0, 0, 7251, + 7252, 5, 200, 0, 0, 7252, 7254, 5, 2372, 0, 0, 7253, 7255, 3, 600, 300, + 0, 7254, 7253, 1, 0, 0, 0, 7254, 7255, 1, 0, 0, 0, 7255, 7256, 1, 0, 0, + 0, 7256, 7258, 3, 640, 320, 0, 7257, 7259, 3, 658, 329, 0, 7258, 7257, + 1, 0, 0, 0, 7258, 7259, 1, 0, 0, 0, 7259, 651, 1, 0, 0, 0, 7260, 7261, + 7, 68, 0, 0, 7261, 7262, 5, 1539, 0, 0, 7262, 7263, 5, 2372, 0, 0, 7263, + 7264, 5, 564, 0, 0, 7264, 7265, 5, 200, 0, 0, 7265, 7267, 5, 2372, 0, 0, + 7266, 7268, 3, 644, 322, 0, 7267, 7266, 1, 0, 0, 0, 7267, 7268, 1, 0, 0, + 0, 7268, 7269, 1, 0, 0, 0, 7269, 7271, 5, 2029, 0, 0, 7270, 7272, 5, 804, + 0, 0, 7271, 7270, 1, 0, 0, 0, 7271, 7272, 1, 0, 0, 0, 7272, 7273, 1, 0, + 0, 0, 7273, 7274, 5, 90, 0, 0, 7274, 7275, 5, 757, 0, 0, 7275, 7276, 3, + 784, 392, 0, 7276, 653, 1, 0, 0, 0, 7277, 7278, 5, 376, 0, 0, 7278, 7279, + 5, 1539, 0, 0, 7279, 7280, 5, 2372, 0, 0, 7280, 7281, 5, 2387, 0, 0, 7281, + 7282, 5, 564, 0, 0, 7282, 7283, 5, 200, 0, 0, 7283, 7284, 5, 2372, 0, 0, + 7284, 7286, 5, 572, 0, 0, 7285, 7287, 5, 804, 0, 0, 7286, 7285, 1, 0, 0, + 0, 7286, 7287, 1, 0, 0, 0, 7287, 7288, 1, 0, 0, 0, 7288, 7289, 5, 90, 0, + 0, 7289, 7290, 5, 757, 0, 0, 7290, 7291, 3, 784, 392, 0, 7291, 655, 1, + 0, 0, 0, 7292, 7294, 5, 1685, 0, 0, 7293, 7295, 5, 2029, 0, 0, 7294, 7293, + 1, 0, 0, 0, 7294, 7295, 1, 0, 0, 0, 7295, 7296, 1, 0, 0, 0, 7296, 7297, + 5, 784, 0, 0, 7297, 7298, 3, 664, 332, 0, 7298, 7299, 5, 564, 0, 0, 7299, + 7300, 5, 37, 0, 0, 7300, 7301, 5, 271, 0, 0, 7301, 657, 1, 0, 0, 0, 7302, + 7303, 5, 2188, 0, 0, 7303, 7306, 5, 98, 0, 0, 7304, 7305, 5, 2129, 0, 0, + 7305, 7307, 5, 2372, 0, 0, 7306, 7304, 1, 0, 0, 0, 7306, 7307, 1, 0, 0, + 0, 7307, 659, 1, 0, 0, 0, 7308, 7309, 5, 628, 0, 0, 7309, 7310, 5, 151, + 0, 0, 7310, 7311, 3, 662, 331, 0, 7311, 661, 1, 0, 0, 0, 7312, 7313, 5, + 2373, 0, 0, 7313, 663, 1, 0, 0, 0, 7314, 7315, 5, 2372, 0, 0, 7315, 665, + 1, 0, 0, 0, 7316, 7317, 5, 2373, 0, 0, 7317, 667, 1, 0, 0, 0, 7318, 7323, + 5, 45, 0, 0, 7319, 7320, 5, 1976, 0, 0, 7320, 7324, 3, 2312, 1156, 0, 7321, + 7322, 5, 659, 0, 0, 7322, 7324, 3, 2300, 1150, 0, 7323, 7319, 1, 0, 0, + 0, 7323, 7321, 1, 0, 0, 0, 7324, 7326, 1, 0, 0, 0, 7325, 7327, 3, 670, + 335, 0, 7326, 7325, 1, 0, 0, 0, 7326, 7327, 1, 0, 0, 0, 7327, 7332, 1, + 0, 0, 0, 7328, 7329, 5, 45, 0, 0, 7329, 7330, 5, 206, 0, 0, 7330, 7332, + 3, 462, 231, 0, 7331, 7318, 1, 0, 0, 0, 7331, 7328, 1, 0, 0, 0, 7332, 7345, + 1, 0, 0, 0, 7333, 7346, 3, 672, 336, 0, 7334, 7335, 5, 796, 0, 0, 7335, + 7336, 5, 178, 0, 0, 7336, 7338, 5, 1508, 0, 0, 7337, 7339, 3, 680, 340, + 0, 7338, 7337, 1, 0, 0, 0, 7338, 7339, 1, 0, 0, 0, 7339, 7346, 1, 0, 0, + 0, 7340, 7342, 5, 376, 0, 0, 7341, 7343, 5, 1842, 0, 0, 7342, 7341, 1, + 0, 0, 0, 7342, 7343, 1, 0, 0, 0, 7343, 7344, 1, 0, 0, 0, 7344, 7346, 5, + 1639, 0, 0, 7345, 7333, 1, 0, 0, 0, 7345, 7334, 1, 0, 0, 0, 7345, 7340, + 1, 0, 0, 0, 7346, 7347, 1, 0, 0, 0, 7347, 7348, 5, 2396, 0, 0, 7348, 669, + 1, 0, 0, 0, 7349, 7366, 5, 1256, 0, 0, 7350, 7351, 5, 2376, 0, 0, 7351, + 7352, 3, 1704, 852, 0, 7352, 7353, 5, 2377, 0, 0, 7353, 7367, 1, 0, 0, + 0, 7354, 7355, 5, 564, 0, 0, 7355, 7356, 5, 2376, 0, 0, 7356, 7361, 3, + 682, 341, 0, 7357, 7358, 5, 2382, 0, 0, 7358, 7360, 3, 682, 341, 0, 7359, + 7357, 1, 0, 0, 0, 7360, 7363, 1, 0, 0, 0, 7361, 7359, 1, 0, 0, 0, 7361, + 7362, 1, 0, 0, 0, 7362, 7364, 1, 0, 0, 0, 7363, 7361, 1, 0, 0, 0, 7364, + 7365, 5, 2377, 0, 0, 7365, 7367, 1, 0, 0, 0, 7366, 7350, 1, 0, 0, 0, 7366, + 7354, 1, 0, 0, 0, 7367, 7388, 1, 0, 0, 0, 7368, 7385, 5, 1668, 0, 0, 7369, + 7370, 5, 2376, 0, 0, 7370, 7371, 3, 1148, 574, 0, 7371, 7372, 5, 2377, + 0, 0, 7372, 7386, 1, 0, 0, 0, 7373, 7374, 5, 564, 0, 0, 7374, 7375, 5, + 2376, 0, 0, 7375, 7380, 3, 684, 342, 0, 7376, 7377, 5, 2382, 0, 0, 7377, + 7379, 3, 684, 342, 0, 7378, 7376, 1, 0, 0, 0, 7379, 7382, 1, 0, 0, 0, 7380, + 7378, 1, 0, 0, 0, 7380, 7381, 1, 0, 0, 0, 7381, 7383, 1, 0, 0, 0, 7382, + 7380, 1, 0, 0, 0, 7383, 7384, 5, 2377, 0, 0, 7384, 7386, 1, 0, 0, 0, 7385, + 7369, 1, 0, 0, 0, 7385, 7373, 1, 0, 0, 0, 7386, 7388, 1, 0, 0, 0, 7387, + 7349, 1, 0, 0, 0, 7387, 7368, 1, 0, 0, 0, 7388, 671, 1, 0, 0, 0, 7389, + 7390, 5, 2136, 0, 0, 7390, 7391, 5, 1431, 0, 0, 7391, 7396, 5, 2091, 0, + 0, 7392, 7393, 5, 1568, 0, 0, 7393, 7394, 5, 328, 0, 0, 7394, 7395, 5, + 2029, 0, 0, 7395, 7397, 5, 1145, 0, 0, 7396, 7392, 1, 0, 0, 0, 7396, 7397, + 1, 0, 0, 0, 7397, 7419, 1, 0, 0, 0, 7398, 7399, 5, 2136, 0, 0, 7399, 7410, + 5, 1664, 0, 0, 7400, 7401, 5, 168, 0, 0, 7401, 7411, 5, 525, 0, 0, 7402, + 7404, 5, 168, 0, 0, 7403, 7405, 3, 678, 339, 0, 7404, 7403, 1, 0, 0, 0, + 7404, 7405, 1, 0, 0, 0, 7405, 7407, 1, 0, 0, 0, 7406, 7408, 3, 2244, 1122, + 0, 7407, 7406, 1, 0, 0, 0, 7407, 7408, 1, 0, 0, 0, 7408, 7411, 1, 0, 0, + 0, 7409, 7411, 5, 168, 0, 0, 7410, 7400, 1, 0, 0, 0, 7410, 7402, 1, 0, + 0, 0, 7410, 7409, 1, 0, 0, 0, 7410, 7411, 1, 0, 0, 0, 7411, 7413, 1, 0, + 0, 0, 7412, 7414, 3, 678, 339, 0, 7413, 7412, 1, 0, 0, 0, 7413, 7414, 1, + 0, 0, 0, 7414, 7416, 1, 0, 0, 0, 7415, 7417, 3, 2244, 1122, 0, 7416, 7415, + 1, 0, 0, 0, 7416, 7417, 1, 0, 0, 0, 7417, 7419, 1, 0, 0, 0, 7418, 7389, + 1, 0, 0, 0, 7418, 7398, 1, 0, 0, 0, 7419, 673, 1, 0, 0, 0, 7420, 7422, + 5, 243, 0, 0, 7421, 7423, 5, 1842, 0, 0, 7422, 7421, 1, 0, 0, 0, 7422, + 7423, 1, 0, 0, 0, 7423, 7424, 1, 0, 0, 0, 7424, 7426, 5, 1639, 0, 0, 7425, + 7427, 3, 676, 338, 0, 7426, 7425, 1, 0, 0, 0, 7426, 7427, 1, 0, 0, 0, 7427, + 675, 1, 0, 0, 0, 7428, 7476, 5, 564, 0, 0, 7429, 7433, 5, 1976, 0, 0, 7430, + 7432, 3, 676, 338, 0, 7431, 7430, 1, 0, 0, 0, 7432, 7435, 1, 0, 0, 0, 7433, + 7431, 1, 0, 0, 0, 7433, 7434, 1, 0, 0, 0, 7434, 7477, 1, 0, 0, 0, 7435, + 7433, 1, 0, 0, 0, 7436, 7455, 5, 37, 0, 0, 7437, 7439, 5, 655, 0, 0, 7438, + 7437, 1, 0, 0, 0, 7438, 7439, 1, 0, 0, 0, 7439, 7440, 1, 0, 0, 0, 7440, + 7443, 5, 223, 0, 0, 7441, 7442, 5, 1595, 0, 0, 7442, 7444, 5, 2370, 0, + 0, 7443, 7441, 1, 0, 0, 0, 7443, 7444, 1, 0, 0, 0, 7444, 7448, 1, 0, 0, + 0, 7445, 7447, 3, 676, 338, 0, 7446, 7445, 1, 0, 0, 0, 7447, 7450, 1, 0, + 0, 0, 7448, 7446, 1, 0, 0, 0, 7448, 7449, 1, 0, 0, 0, 7449, 7456, 1, 0, + 0, 0, 7450, 7448, 1, 0, 0, 0, 7451, 7453, 5, 804, 0, 0, 7452, 7451, 1, + 0, 0, 0, 7452, 7453, 1, 0, 0, 0, 7453, 7454, 1, 0, 0, 0, 7454, 7456, 5, + 656, 0, 0, 7455, 7438, 1, 0, 0, 0, 7455, 7452, 1, 0, 0, 0, 7456, 7477, + 1, 0, 0, 0, 7457, 7460, 5, 223, 0, 0, 7458, 7459, 5, 1595, 0, 0, 7459, + 7461, 5, 2370, 0, 0, 7460, 7458, 1, 0, 0, 0, 7460, 7461, 1, 0, 0, 0, 7461, + 7466, 1, 0, 0, 0, 7462, 7463, 3, 2310, 1155, 0, 7463, 7464, 5, 1595, 0, + 0, 7464, 7465, 5, 2370, 0, 0, 7465, 7467, 1, 0, 0, 0, 7466, 7462, 1, 0, + 0, 0, 7467, 7468, 1, 0, 0, 0, 7468, 7466, 1, 0, 0, 0, 7468, 7469, 1, 0, + 0, 0, 7469, 7473, 1, 0, 0, 0, 7470, 7472, 3, 676, 338, 0, 7471, 7470, 1, + 0, 0, 0, 7472, 7475, 1, 0, 0, 0, 7473, 7471, 1, 0, 0, 0, 7473, 7474, 1, + 0, 0, 0, 7474, 7477, 1, 0, 0, 0, 7475, 7473, 1, 0, 0, 0, 7476, 7429, 1, + 0, 0, 0, 7476, 7436, 1, 0, 0, 0, 7476, 7457, 1, 0, 0, 0, 7477, 677, 1, + 0, 0, 0, 7478, 7479, 7, 69, 0, 0, 7479, 679, 1, 0, 0, 0, 7480, 7482, 5, + 719, 0, 0, 7481, 7483, 3, 2312, 1156, 0, 7482, 7481, 1, 0, 0, 0, 7482, + 7483, 1, 0, 0, 0, 7483, 681, 1, 0, 0, 0, 7484, 7488, 3, 2170, 1085, 0, + 7485, 7486, 5, 1997, 0, 0, 7486, 7488, 3, 2372, 1186, 0, 7487, 7484, 1, + 0, 0, 0, 7487, 7485, 1, 0, 0, 0, 7488, 683, 1, 0, 0, 0, 7489, 7493, 3, + 2170, 1085, 0, 7490, 7491, 5, 1997, 0, 0, 7491, 7493, 3, 2372, 1186, 0, + 7492, 7489, 1, 0, 0, 0, 7492, 7490, 1, 0, 0, 0, 7493, 685, 1, 0, 0, 0, + 7494, 7495, 5, 74, 0, 0, 7495, 7496, 5, 1639, 0, 0, 7496, 7499, 5, 2188, + 0, 0, 7497, 7500, 3, 688, 344, 0, 7498, 7500, 3, 690, 345, 0, 7499, 7497, + 1, 0, 0, 0, 7499, 7498, 1, 0, 0, 0, 7500, 7502, 1, 0, 0, 0, 7501, 7503, + 3, 710, 355, 0, 7502, 7501, 1, 0, 0, 0, 7502, 7503, 1, 0, 0, 0, 7503, 7504, + 1, 0, 0, 0, 7504, 7505, 5, 2396, 0, 0, 7505, 687, 1, 0, 0, 0, 7506, 7507, + 5, 223, 0, 0, 7507, 7508, 3, 2312, 1156, 0, 7508, 7509, 5, 2369, 0, 0, + 7509, 7517, 3, 2310, 1155, 0, 7510, 7511, 5, 2382, 0, 0, 7511, 7512, 3, + 2312, 1156, 0, 7512, 7513, 5, 2369, 0, 0, 7513, 7514, 3, 2310, 1155, 0, + 7514, 7516, 1, 0, 0, 0, 7515, 7510, 1, 0, 0, 0, 7516, 7519, 1, 0, 0, 0, + 7517, 7515, 1, 0, 0, 0, 7517, 7518, 1, 0, 0, 0, 7518, 7520, 1, 0, 0, 0, + 7519, 7517, 1, 0, 0, 0, 7520, 7521, 3, 694, 347, 0, 7521, 689, 1, 0, 0, + 0, 7522, 7523, 5, 577, 0, 0, 7523, 7528, 3, 2292, 1146, 0, 7524, 7525, + 5, 2382, 0, 0, 7525, 7527, 3, 2292, 1146, 0, 7526, 7524, 1, 0, 0, 0, 7527, + 7530, 1, 0, 0, 0, 7528, 7526, 1, 0, 0, 0, 7528, 7529, 1, 0, 0, 0, 7529, + 7568, 1, 0, 0, 0, 7530, 7528, 1, 0, 0, 0, 7531, 7532, 5, 1240, 0, 0, 7532, + 7537, 3, 2262, 1131, 0, 7533, 7534, 5, 2382, 0, 0, 7534, 7536, 3, 2262, + 1131, 0, 7535, 7533, 1, 0, 0, 0, 7536, 7539, 1, 0, 0, 0, 7537, 7535, 1, + 0, 0, 0, 7537, 7538, 1, 0, 0, 0, 7538, 7568, 1, 0, 0, 0, 7539, 7537, 1, + 0, 0, 0, 7540, 7541, 5, 2052, 0, 0, 7541, 7546, 3, 2286, 1143, 0, 7542, + 7543, 5, 2382, 0, 0, 7543, 7545, 3, 2286, 1143, 0, 7544, 7542, 1, 0, 0, + 0, 7545, 7548, 1, 0, 0, 0, 7546, 7544, 1, 0, 0, 0, 7546, 7547, 1, 0, 0, + 0, 7547, 7568, 1, 0, 0, 0, 7548, 7546, 1, 0, 0, 0, 7549, 7550, 5, 656, + 0, 0, 7550, 7555, 3, 2300, 1150, 0, 7551, 7552, 5, 2382, 0, 0, 7552, 7554, + 3, 2300, 1150, 0, 7553, 7551, 1, 0, 0, 0, 7554, 7557, 1, 0, 0, 0, 7555, + 7553, 1, 0, 0, 0, 7555, 7556, 1, 0, 0, 0, 7556, 7568, 1, 0, 0, 0, 7557, + 7555, 1, 0, 0, 0, 7558, 7559, 5, 674, 0, 0, 7559, 7564, 3, 692, 346, 0, + 7560, 7561, 5, 2382, 0, 0, 7561, 7563, 3, 692, 346, 0, 7562, 7560, 1, 0, + 0, 0, 7563, 7566, 1, 0, 0, 0, 7564, 7562, 1, 0, 0, 0, 7564, 7565, 1, 0, + 0, 0, 7565, 7568, 1, 0, 0, 0, 7566, 7564, 1, 0, 0, 0, 7567, 7522, 1, 0, + 0, 0, 7567, 7531, 1, 0, 0, 0, 7567, 7540, 1, 0, 0, 0, 7567, 7549, 1, 0, + 0, 0, 7567, 7558, 1, 0, 0, 0, 7568, 7580, 1, 0, 0, 0, 7569, 7581, 3, 694, + 347, 0, 7570, 7573, 3, 698, 349, 0, 7571, 7572, 5, 2382, 0, 0, 7572, 7574, + 3, 706, 353, 0, 7573, 7571, 1, 0, 0, 0, 7573, 7574, 1, 0, 0, 0, 7574, 7581, + 1, 0, 0, 0, 7575, 7578, 3, 706, 353, 0, 7576, 7577, 5, 2382, 0, 0, 7577, + 7579, 3, 698, 349, 0, 7578, 7576, 1, 0, 0, 0, 7578, 7579, 1, 0, 0, 0, 7579, + 7581, 1, 0, 0, 0, 7580, 7569, 1, 0, 0, 0, 7580, 7570, 1, 0, 0, 0, 7580, + 7575, 1, 0, 0, 0, 7581, 691, 1, 0, 0, 0, 7582, 7583, 3, 2378, 1189, 0, + 7583, 693, 1, 0, 0, 0, 7584, 7587, 5, 2129, 0, 0, 7585, 7588, 3, 696, 348, + 0, 7586, 7588, 5, 1145, 0, 0, 7587, 7585, 1, 0, 0, 0, 7587, 7586, 1, 0, + 0, 0, 7588, 695, 1, 0, 0, 0, 7589, 7590, 3, 2382, 1191, 0, 7590, 697, 1, + 0, 0, 0, 7591, 7592, 5, 363, 0, 0, 7592, 7593, 5, 292, 0, 0, 7593, 7594, + 5, 2376, 0, 0, 7594, 7595, 3, 700, 350, 0, 7595, 7596, 5, 2382, 0, 0, 7596, + 7597, 3, 702, 351, 0, 7597, 7598, 5, 2382, 0, 0, 7598, 7599, 3, 704, 352, + 0, 7599, 7600, 5, 2377, 0, 0, 7600, 699, 1, 0, 0, 0, 7601, 7602, 5, 2370, + 0, 0, 7602, 701, 1, 0, 0, 0, 7603, 7604, 5, 2370, 0, 0, 7604, 703, 1, 0, + 0, 0, 7605, 7606, 5, 2370, 0, 0, 7606, 705, 1, 0, 0, 0, 7607, 7608, 5, + 363, 0, 0, 7608, 7609, 5, 1547, 0, 0, 7609, 7610, 3, 708, 354, 0, 7610, + 707, 1, 0, 0, 0, 7611, 7612, 5, 2370, 0, 0, 7612, 709, 1, 0, 0, 0, 7613, + 7614, 5, 2188, 0, 0, 7614, 7615, 7, 70, 0, 0, 7615, 7616, 5, 834, 0, 0, + 7616, 7617, 5, 1655, 0, 0, 7617, 7618, 5, 1974, 0, 0, 7618, 711, 1, 0, + 0, 0, 7619, 7620, 4, 356, 0, 0, 7620, 7664, 5, 82, 0, 0, 7621, 7622, 5, + 1318, 0, 0, 7622, 7632, 3, 714, 357, 0, 7623, 7624, 7, 71, 0, 0, 7624, + 7629, 3, 726, 363, 0, 7625, 7626, 5, 2382, 0, 0, 7626, 7628, 3, 726, 363, + 0, 7627, 7625, 1, 0, 0, 0, 7628, 7631, 1, 0, 0, 0, 7629, 7627, 1, 0, 0, + 0, 7629, 7630, 1, 0, 0, 0, 7630, 7633, 1, 0, 0, 0, 7631, 7629, 1, 0, 0, + 0, 7632, 7623, 1, 0, 0, 0, 7632, 7633, 1, 0, 0, 0, 7633, 7639, 1, 0, 0, + 0, 7634, 7636, 5, 2179, 0, 0, 7635, 7637, 5, 1121, 0, 0, 7636, 7635, 1, + 0, 0, 0, 7636, 7637, 1, 0, 0, 0, 7637, 7638, 1, 0, 0, 0, 7638, 7640, 5, + 1679, 0, 0, 7639, 7634, 1, 0, 0, 0, 7639, 7640, 1, 0, 0, 0, 7640, 7665, + 1, 0, 0, 0, 7641, 7642, 5, 277, 0, 0, 7642, 7643, 5, 927, 0, 0, 7643, 7644, + 3, 1014, 507, 0, 7644, 7645, 5, 81, 0, 0, 7645, 7650, 3, 2250, 1125, 0, + 7646, 7647, 5, 2382, 0, 0, 7647, 7649, 3, 2250, 1125, 0, 7648, 7646, 1, + 0, 0, 0, 7649, 7652, 1, 0, 0, 0, 7650, 7648, 1, 0, 0, 0, 7650, 7651, 1, + 0, 0, 0, 7651, 7662, 1, 0, 0, 0, 7652, 7650, 1, 0, 0, 0, 7653, 7654, 5, + 151, 0, 0, 7654, 7659, 3, 726, 363, 0, 7655, 7656, 5, 2382, 0, 0, 7656, + 7658, 3, 726, 363, 0, 7657, 7655, 1, 0, 0, 0, 7658, 7661, 1, 0, 0, 0, 7659, + 7657, 1, 0, 0, 0, 7659, 7660, 1, 0, 0, 0, 7660, 7663, 1, 0, 0, 0, 7661, + 7659, 1, 0, 0, 0, 7662, 7653, 1, 0, 0, 0, 7662, 7663, 1, 0, 0, 0, 7663, + 7665, 1, 0, 0, 0, 7664, 7621, 1, 0, 0, 0, 7664, 7641, 1, 0, 0, 0, 7665, + 7666, 1, 0, 0, 0, 7666, 7667, 5, 2396, 0, 0, 7667, 713, 1, 0, 0, 0, 7668, + 7669, 3, 2376, 1188, 0, 7669, 715, 1, 0, 0, 0, 7670, 7681, 5, 82, 0, 0, + 7671, 7676, 3, 722, 361, 0, 7672, 7677, 3, 724, 362, 0, 7673, 7674, 5, + 680, 0, 0, 7674, 7675, 5, 1564, 0, 0, 7675, 7677, 5, 315, 0, 0, 7676, 7672, + 1, 0, 0, 0, 7676, 7673, 1, 0, 0, 0, 7676, 7677, 1, 0, 0, 0, 7677, 7682, + 1, 0, 0, 0, 7678, 7682, 3, 728, 364, 0, 7679, 7682, 5, 948, 0, 0, 7680, + 7682, 3, 718, 359, 0, 7681, 7671, 1, 0, 0, 0, 7681, 7678, 1, 0, 0, 0, 7681, + 7679, 1, 0, 0, 0, 7681, 7680, 1, 0, 0, 0, 7682, 7685, 1, 0, 0, 0, 7683, + 7684, 5, 151, 0, 0, 7684, 7686, 7, 72, 0, 0, 7685, 7683, 1, 0, 0, 0, 7685, + 7686, 1, 0, 0, 0, 7686, 7692, 1, 0, 0, 0, 7687, 7689, 5, 2179, 0, 0, 7688, + 7690, 5, 1121, 0, 0, 7689, 7688, 1, 0, 0, 0, 7689, 7690, 1, 0, 0, 0, 7690, + 7691, 1, 0, 0, 0, 7691, 7693, 5, 1679, 0, 0, 7692, 7687, 1, 0, 0, 0, 7692, + 7693, 1, 0, 0, 0, 7693, 7695, 1, 0, 0, 0, 7694, 7696, 3, 720, 360, 0, 7695, + 7694, 1, 0, 0, 0, 7695, 7696, 1, 0, 0, 0, 7696, 7697, 1, 0, 0, 0, 7697, + 7698, 5, 2396, 0, 0, 7698, 717, 1, 0, 0, 0, 7699, 7700, 4, 359, 1, 0, 7700, + 7701, 5, 396, 0, 0, 7701, 7702, 3, 724, 362, 0, 7702, 719, 1, 0, 0, 0, + 7703, 7704, 4, 360, 2, 0, 7704, 7705, 5, 270, 0, 0, 7705, 7706, 5, 2398, + 0, 0, 7706, 7707, 7, 73, 0, 0, 7707, 721, 1, 0, 0, 0, 7708, 7714, 3, 740, + 370, 0, 7709, 7711, 5, 37, 0, 0, 7710, 7712, 5, 1635, 0, 0, 7711, 7710, + 1, 0, 0, 0, 7711, 7712, 1, 0, 0, 0, 7712, 7714, 1, 0, 0, 0, 7713, 7708, + 1, 0, 0, 0, 7713, 7709, 1, 0, 0, 0, 7714, 7725, 1, 0, 0, 0, 7715, 7721, + 5, 2382, 0, 0, 7716, 7722, 3, 740, 370, 0, 7717, 7719, 5, 37, 0, 0, 7718, + 7720, 5, 1635, 0, 0, 7719, 7718, 1, 0, 0, 0, 7719, 7720, 1, 0, 0, 0, 7720, + 7722, 1, 0, 0, 0, 7721, 7716, 1, 0, 0, 0, 7721, 7717, 1, 0, 0, 0, 7722, + 7724, 1, 0, 0, 0, 7723, 7715, 1, 0, 0, 0, 7724, 7727, 1, 0, 0, 0, 7725, + 7723, 1, 0, 0, 0, 7725, 7726, 1, 0, 0, 0, 7726, 7745, 1, 0, 0, 0, 7727, + 7725, 1, 0, 0, 0, 7728, 7732, 3, 2362, 1181, 0, 7729, 7730, 5, 37, 0, 0, + 7730, 7732, 5, 1363, 0, 0, 7731, 7728, 1, 0, 0, 0, 7731, 7729, 1, 0, 0, + 0, 7732, 7741, 1, 0, 0, 0, 7733, 7737, 5, 2382, 0, 0, 7734, 7738, 3, 2362, + 1181, 0, 7735, 7736, 5, 37, 0, 0, 7736, 7738, 5, 1363, 0, 0, 7737, 7734, + 1, 0, 0, 0, 7737, 7735, 1, 0, 0, 0, 7738, 7740, 1, 0, 0, 0, 7739, 7733, + 1, 0, 0, 0, 7740, 7743, 1, 0, 0, 0, 7741, 7739, 1, 0, 0, 0, 7741, 7742, + 1, 0, 0, 0, 7742, 7745, 1, 0, 0, 0, 7743, 7741, 1, 0, 0, 0, 7744, 7713, + 1, 0, 0, 0, 7744, 7731, 1, 0, 0, 0, 7745, 723, 1, 0, 0, 0, 7746, 7747, + 5, 151, 0, 0, 7747, 7752, 3, 726, 363, 0, 7748, 7749, 5, 2382, 0, 0, 7749, + 7751, 3, 726, 363, 0, 7750, 7748, 1, 0, 0, 0, 7751, 7754, 1, 0, 0, 0, 7752, + 7750, 1, 0, 0, 0, 7752, 7753, 1, 0, 0, 0, 7753, 725, 1, 0, 0, 0, 7754, + 7752, 1, 0, 0, 0, 7755, 7756, 3, 2382, 1191, 0, 7756, 727, 1, 0, 0, 0, + 7757, 7762, 3, 730, 365, 0, 7758, 7759, 5, 2382, 0, 0, 7759, 7761, 3, 730, + 365, 0, 7760, 7758, 1, 0, 0, 0, 7761, 7764, 1, 0, 0, 0, 7762, 7760, 1, + 0, 0, 0, 7762, 7763, 1, 0, 0, 0, 7763, 7767, 1, 0, 0, 0, 7764, 7762, 1, + 0, 0, 0, 7765, 7767, 5, 37, 0, 0, 7766, 7757, 1, 0, 0, 0, 7766, 7765, 1, + 0, 0, 0, 7767, 7768, 1, 0, 0, 0, 7768, 7769, 3, 732, 366, 0, 7769, 729, + 1, 0, 0, 0, 7770, 7771, 7, 51, 0, 0, 7771, 731, 1, 0, 0, 0, 7772, 7785, + 5, 1175, 0, 0, 7773, 7786, 3, 736, 368, 0, 7774, 7775, 5, 395, 0, 0, 7775, + 7786, 3, 2382, 1191, 0, 7776, 7777, 5, 884, 0, 0, 7777, 7778, 5, 900, 0, + 0, 7778, 7786, 3, 734, 367, 0, 7779, 7780, 4, 366, 3, 0, 7780, 7781, 5, + 1617, 0, 0, 7781, 7782, 5, 2041, 0, 0, 7782, 7783, 5, 1367, 0, 0, 7783, + 7786, 3, 738, 369, 0, 7784, 7786, 5, 363, 0, 0, 7785, 7773, 1, 0, 0, 0, + 7785, 7774, 1, 0, 0, 0, 7785, 7776, 1, 0, 0, 0, 7785, 7779, 1, 0, 0, 0, + 7785, 7784, 1, 0, 0, 0, 7786, 733, 1, 0, 0, 0, 7787, 7788, 3, 2378, 1189, + 0, 7788, 7789, 5, 2369, 0, 0, 7789, 7791, 1, 0, 0, 0, 7790, 7787, 1, 0, + 0, 0, 7790, 7791, 1, 0, 0, 0, 7791, 7792, 1, 0, 0, 0, 7792, 7793, 3, 2378, + 1189, 0, 7793, 735, 1, 0, 0, 0, 7794, 7795, 3, 2378, 1189, 0, 7795, 7796, + 5, 2369, 0, 0, 7796, 7798, 1, 0, 0, 0, 7797, 7794, 1, 0, 0, 0, 7797, 7798, + 1, 0, 0, 0, 7798, 7799, 1, 0, 0, 0, 7799, 7800, 3, 2378, 1189, 0, 7800, + 737, 1, 0, 0, 0, 7801, 7802, 3, 2378, 1189, 0, 7802, 7803, 5, 2369, 0, + 0, 7803, 7805, 1, 0, 0, 0, 7804, 7801, 1, 0, 0, 0, 7804, 7805, 1, 0, 0, + 0, 7805, 7806, 1, 0, 0, 0, 7806, 7807, 3, 2378, 1189, 0, 7807, 739, 1, + 0, 0, 0, 7808, 7809, 5, 41, 0, 0, 7809, 7879, 5, 1842, 0, 0, 7810, 7879, + 5, 206, 0, 0, 7811, 7879, 5, 277, 0, 0, 7812, 7813, 5, 329, 0, 0, 7813, + 7879, 5, 795, 0, 0, 7814, 7879, 5, 392, 0, 0, 7815, 7879, 5, 395, 0, 0, + 7816, 7879, 5, 659, 0, 0, 7817, 7818, 5, 848, 0, 0, 7818, 7879, 5, 2166, + 0, 0, 7819, 7820, 5, 1121, 0, 0, 7820, 7879, 5, 492, 0, 0, 7821, 7879, + 5, 1227, 0, 0, 7822, 7823, 4, 370, 4, 0, 7823, 7824, 5, 1315, 0, 0, 7824, + 7879, 5, 329, 0, 0, 7825, 7879, 5, 1365, 0, 0, 7826, 7879, 5, 1367, 0, + 0, 7827, 7828, 5, 1377, 0, 0, 7828, 7829, 5, 329, 0, 0, 7829, 7879, 5, + 795, 0, 0, 7830, 7831, 5, 1377, 0, 0, 7831, 7879, 5, 1689, 0, 0, 7832, + 7879, 5, 1494, 0, 0, 7833, 7834, 5, 1497, 0, 0, 7834, 7879, 5, 1546, 0, + 0, 7835, 7879, 5, 1554, 0, 0, 7836, 7879, 5, 1564, 0, 0, 7837, 7879, 5, + 1689, 0, 0, 7838, 7839, 5, 1842, 0, 0, 7839, 7879, 5, 82, 0, 0, 7840, 7841, + 5, 1842, 0, 0, 7841, 7879, 5, 591, 0, 0, 7842, 7879, 5, 1976, 0, 0, 7843, + 7879, 5, 1973, 0, 0, 7844, 7879, 5, 2044, 0, 0, 7845, 7879, 5, 2053, 0, + 0, 7846, 7879, 5, 2121, 0, 0, 7847, 7879, 5, 2166, 0, 0, 7848, 7849, 5, + 41, 0, 0, 7849, 7879, 5, 1554, 0, 0, 7850, 7851, 5, 41, 0, 0, 7851, 7879, + 5, 1976, 0, 0, 7852, 7853, 5, 226, 0, 0, 7853, 7879, 5, 1976, 0, 0, 7854, + 7855, 5, 376, 0, 0, 7855, 7879, 5, 1976, 0, 0, 7856, 7857, 5, 489, 0, 0, + 7857, 7879, 5, 1365, 0, 0, 7858, 7859, 5, 591, 0, 0, 7859, 7879, 5, 395, + 0, 0, 7860, 7861, 5, 591, 0, 0, 7861, 7879, 5, 1365, 0, 0, 7862, 7863, + 5, 591, 0, 0, 7863, 7879, 5, 1554, 0, 0, 7864, 7865, 5, 591, 0, 0, 7865, + 7879, 5, 1976, 0, 0, 7866, 7867, 5, 591, 0, 0, 7867, 7879, 5, 2053, 0, + 0, 7868, 7869, 5, 697, 0, 0, 7869, 7879, 5, 1976, 0, 0, 7870, 7871, 5, + 812, 0, 0, 7871, 7879, 5, 1976, 0, 0, 7872, 7873, 5, 1548, 0, 0, 7873, + 7879, 5, 1554, 0, 0, 7874, 7875, 5, 1548, 0, 0, 7875, 7879, 5, 1976, 0, + 0, 7876, 7877, 5, 2091, 0, 0, 7877, 7879, 5, 1976, 0, 0, 7878, 7808, 1, + 0, 0, 0, 7878, 7810, 1, 0, 0, 0, 7878, 7811, 1, 0, 0, 0, 7878, 7812, 1, + 0, 0, 0, 7878, 7814, 1, 0, 0, 0, 7878, 7815, 1, 0, 0, 0, 7878, 7816, 1, + 0, 0, 0, 7878, 7817, 1, 0, 0, 0, 7878, 7819, 1, 0, 0, 0, 7878, 7821, 1, + 0, 0, 0, 7878, 7822, 1, 0, 0, 0, 7878, 7825, 1, 0, 0, 0, 7878, 7826, 1, + 0, 0, 0, 7878, 7827, 1, 0, 0, 0, 7878, 7830, 1, 0, 0, 0, 7878, 7832, 1, + 0, 0, 0, 7878, 7833, 1, 0, 0, 0, 7878, 7835, 1, 0, 0, 0, 7878, 7836, 1, + 0, 0, 0, 7878, 7837, 1, 0, 0, 0, 7878, 7838, 1, 0, 0, 0, 7878, 7840, 1, + 0, 0, 0, 7878, 7842, 1, 0, 0, 0, 7878, 7843, 1, 0, 0, 0, 7878, 7844, 1, + 0, 0, 0, 7878, 7845, 1, 0, 0, 0, 7878, 7846, 1, 0, 0, 0, 7878, 7847, 1, + 0, 0, 0, 7878, 7848, 1, 0, 0, 0, 7878, 7850, 1, 0, 0, 0, 7878, 7852, 1, + 0, 0, 0, 7878, 7854, 1, 0, 0, 0, 7878, 7856, 1, 0, 0, 0, 7878, 7858, 1, + 0, 0, 0, 7878, 7860, 1, 0, 0, 0, 7878, 7862, 1, 0, 0, 0, 7878, 7864, 1, + 0, 0, 0, 7878, 7866, 1, 0, 0, 0, 7878, 7868, 1, 0, 0, 0, 7878, 7870, 1, + 0, 0, 0, 7878, 7872, 1, 0, 0, 0, 7878, 7874, 1, 0, 0, 0, 7878, 7876, 1, + 0, 0, 0, 7879, 741, 1, 0, 0, 0, 7880, 7881, 5, 425, 0, 0, 7881, 7882, 5, + 659, 0, 0, 7882, 7883, 3, 2300, 1150, 0, 7883, 7884, 5, 2396, 0, 0, 7884, + 743, 1, 0, 0, 0, 7885, 7886, 5, 403, 0, 0, 7886, 7887, 5, 1639, 0, 0, 7887, + 8007, 5, 572, 0, 0, 7888, 7892, 5, 223, 0, 0, 7889, 7890, 3, 2258, 1129, + 0, 7890, 7891, 5, 2369, 0, 0, 7891, 7893, 1, 0, 0, 0, 7892, 7889, 1, 0, + 0, 0, 7892, 7893, 1, 0, 0, 0, 7893, 7894, 1, 0, 0, 0, 7894, 7895, 3, 2378, + 1189, 0, 7895, 7896, 5, 2369, 0, 0, 7896, 7909, 3, 2378, 1189, 0, 7897, + 7901, 5, 2382, 0, 0, 7898, 7899, 3, 2258, 1129, 0, 7899, 7900, 5, 2369, + 0, 0, 7900, 7902, 1, 0, 0, 0, 7901, 7898, 1, 0, 0, 0, 7901, 7902, 1, 0, + 0, 0, 7902, 7903, 1, 0, 0, 0, 7903, 7904, 3, 2378, 1189, 0, 7904, 7905, + 5, 2369, 0, 0, 7905, 7906, 3, 2378, 1189, 0, 7906, 7908, 1, 0, 0, 0, 7907, + 7897, 1, 0, 0, 0, 7908, 7911, 1, 0, 0, 0, 7909, 7907, 1, 0, 0, 0, 7909, + 7910, 1, 0, 0, 0, 7910, 8008, 1, 0, 0, 0, 7911, 7909, 1, 0, 0, 0, 7912, + 7916, 5, 577, 0, 0, 7913, 7914, 3, 2258, 1129, 0, 7914, 7915, 5, 2369, + 0, 0, 7915, 7917, 1, 0, 0, 0, 7916, 7913, 1, 0, 0, 0, 7916, 7917, 1, 0, + 0, 0, 7917, 7918, 1, 0, 0, 0, 7918, 7928, 3, 2378, 1189, 0, 7919, 7923, + 5, 2382, 0, 0, 7920, 7921, 3, 2258, 1129, 0, 7921, 7922, 5, 2369, 0, 0, + 7922, 7924, 1, 0, 0, 0, 7923, 7920, 1, 0, 0, 0, 7923, 7924, 1, 0, 0, 0, + 7924, 7925, 1, 0, 0, 0, 7925, 7927, 3, 2378, 1189, 0, 7926, 7919, 1, 0, + 0, 0, 7927, 7930, 1, 0, 0, 0, 7928, 7926, 1, 0, 0, 0, 7928, 7929, 1, 0, + 0, 0, 7929, 8008, 1, 0, 0, 0, 7930, 7928, 1, 0, 0, 0, 7931, 7935, 5, 1240, + 0, 0, 7932, 7933, 3, 2258, 1129, 0, 7933, 7934, 5, 2369, 0, 0, 7934, 7936, + 1, 0, 0, 0, 7935, 7932, 1, 0, 0, 0, 7935, 7936, 1, 0, 0, 0, 7936, 7937, + 1, 0, 0, 0, 7937, 7947, 3, 2378, 1189, 0, 7938, 7942, 5, 2382, 0, 0, 7939, + 7940, 3, 2258, 1129, 0, 7940, 7941, 5, 2369, 0, 0, 7941, 7943, 1, 0, 0, + 0, 7942, 7939, 1, 0, 0, 0, 7942, 7943, 1, 0, 0, 0, 7943, 7944, 1, 0, 0, + 0, 7944, 7946, 3, 2378, 1189, 0, 7945, 7938, 1, 0, 0, 0, 7946, 7949, 1, + 0, 0, 0, 7947, 7945, 1, 0, 0, 0, 7947, 7948, 1, 0, 0, 0, 7948, 8008, 1, + 0, 0, 0, 7949, 7947, 1, 0, 0, 0, 7950, 7954, 5, 2052, 0, 0, 7951, 7952, + 3, 2258, 1129, 0, 7952, 7953, 5, 2369, 0, 0, 7953, 7955, 1, 0, 0, 0, 7954, + 7951, 1, 0, 0, 0, 7954, 7955, 1, 0, 0, 0, 7955, 7956, 1, 0, 0, 0, 7956, + 7966, 3, 2378, 1189, 0, 7957, 7961, 5, 2382, 0, 0, 7958, 7959, 3, 2258, + 1129, 0, 7959, 7960, 5, 2369, 0, 0, 7960, 7962, 1, 0, 0, 0, 7961, 7958, + 1, 0, 0, 0, 7961, 7962, 1, 0, 0, 0, 7962, 7963, 1, 0, 0, 0, 7963, 7965, + 3, 2378, 1189, 0, 7964, 7957, 1, 0, 0, 0, 7965, 7968, 1, 0, 0, 0, 7966, + 7964, 1, 0, 0, 0, 7966, 7967, 1, 0, 0, 0, 7967, 8008, 1, 0, 0, 0, 7968, + 7966, 1, 0, 0, 0, 7969, 7973, 5, 656, 0, 0, 7970, 7971, 3, 2258, 1129, + 0, 7971, 7972, 5, 2369, 0, 0, 7972, 7974, 1, 0, 0, 0, 7973, 7970, 1, 0, + 0, 0, 7973, 7974, 1, 0, 0, 0, 7974, 7975, 1, 0, 0, 0, 7975, 7985, 3, 2378, + 1189, 0, 7976, 7980, 5, 2382, 0, 0, 7977, 7978, 3, 2258, 1129, 0, 7978, + 7979, 5, 2369, 0, 0, 7979, 7981, 1, 0, 0, 0, 7980, 7977, 1, 0, 0, 0, 7980, + 7981, 1, 0, 0, 0, 7981, 7982, 1, 0, 0, 0, 7982, 7984, 3, 2378, 1189, 0, + 7983, 7976, 1, 0, 0, 0, 7984, 7987, 1, 0, 0, 0, 7985, 7983, 1, 0, 0, 0, + 7985, 7986, 1, 0, 0, 0, 7986, 8008, 1, 0, 0, 0, 7987, 7985, 1, 0, 0, 0, + 7988, 7992, 5, 674, 0, 0, 7989, 7990, 3, 2258, 1129, 0, 7990, 7991, 5, + 2369, 0, 0, 7991, 7993, 1, 0, 0, 0, 7992, 7989, 1, 0, 0, 0, 7992, 7993, + 1, 0, 0, 0, 7993, 7994, 1, 0, 0, 0, 7994, 8004, 3, 2378, 1189, 0, 7995, + 7999, 5, 2382, 0, 0, 7996, 7997, 3, 2258, 1129, 0, 7997, 7998, 5, 2369, + 0, 0, 7998, 8000, 1, 0, 0, 0, 7999, 7996, 1, 0, 0, 0, 7999, 8000, 1, 0, + 0, 0, 8000, 8001, 1, 0, 0, 0, 8001, 8003, 3, 2378, 1189, 0, 8002, 7995, + 1, 0, 0, 0, 8003, 8006, 1, 0, 0, 0, 8004, 8002, 1, 0, 0, 0, 8004, 8005, + 1, 0, 0, 0, 8005, 8008, 1, 0, 0, 0, 8006, 8004, 1, 0, 0, 0, 8007, 7888, + 1, 0, 0, 0, 8007, 7912, 1, 0, 0, 0, 8007, 7931, 1, 0, 0, 0, 8007, 7950, + 1, 0, 0, 0, 8007, 7969, 1, 0, 0, 0, 8007, 7988, 1, 0, 0, 0, 8008, 8010, + 1, 0, 0, 0, 8009, 8011, 5, 560, 0, 0, 8010, 8009, 1, 0, 0, 0, 8010, 8011, + 1, 0, 0, 0, 8011, 745, 1, 0, 0, 0, 8012, 8013, 5, 425, 0, 0, 8013, 8017, + 5, 673, 0, 0, 8014, 8015, 3, 2258, 1129, 0, 8015, 8016, 5, 2369, 0, 0, + 8016, 8018, 1, 0, 0, 0, 8017, 8014, 1, 0, 0, 0, 8017, 8018, 1, 0, 0, 0, + 8018, 8019, 1, 0, 0, 0, 8019, 8021, 3, 2378, 1189, 0, 8020, 8022, 5, 560, + 0, 0, 8021, 8020, 1, 0, 0, 0, 8021, 8022, 1, 0, 0, 0, 8022, 747, 1, 0, + 0, 0, 8023, 8024, 5, 425, 0, 0, 8024, 8025, 5, 688, 0, 0, 8025, 8026, 5, + 731, 0, 0, 8026, 8030, 5, 593, 0, 0, 8027, 8028, 3, 2258, 1129, 0, 8028, + 8029, 5, 2369, 0, 0, 8029, 8031, 1, 0, 0, 0, 8030, 8027, 1, 0, 0, 0, 8030, + 8031, 1, 0, 0, 0, 8031, 8032, 1, 0, 0, 0, 8032, 8033, 3, 2378, 1189, 0, + 8033, 749, 1, 0, 0, 0, 8034, 8035, 5, 549, 0, 0, 8035, 8036, 5, 1976, 0, + 0, 8036, 8041, 3, 2312, 1156, 0, 8037, 8038, 5, 2382, 0, 0, 8038, 8040, + 3, 2312, 1156, 0, 8039, 8037, 1, 0, 0, 0, 8040, 8043, 1, 0, 0, 0, 8041, + 8039, 1, 0, 0, 0, 8041, 8042, 1, 0, 0, 0, 8042, 8044, 1, 0, 0, 0, 8043, + 8041, 1, 0, 0, 0, 8044, 8063, 5, 2029, 0, 0, 8045, 8046, 7, 74, 0, 0, 8046, + 8051, 3, 2078, 1039, 0, 8047, 8048, 5, 1475, 0, 0, 8048, 8049, 5, 1317, + 0, 0, 8049, 8051, 3, 752, 376, 0, 8050, 8045, 1, 0, 0, 0, 8050, 8047, 1, + 0, 0, 0, 8051, 8054, 1, 0, 0, 0, 8052, 8053, 7, 17, 0, 0, 8053, 8055, 5, + 2043, 0, 0, 8054, 8052, 1, 0, 0, 0, 8054, 8055, 1, 0, 0, 0, 8055, 8064, + 1, 0, 0, 0, 8056, 8057, 5, 106, 0, 0, 8057, 8061, 5, 425, 0, 0, 8058, 8059, + 5, 1460, 0, 0, 8059, 8060, 5, 2029, 0, 0, 8060, 8062, 3, 2312, 1156, 0, + 8061, 8058, 1, 0, 0, 0, 8061, 8062, 1, 0, 0, 0, 8062, 8064, 1, 0, 0, 0, + 8063, 8050, 1, 0, 0, 0, 8063, 8056, 1, 0, 0, 0, 8064, 751, 1, 0, 0, 0, + 8065, 8070, 3, 2376, 1188, 0, 8066, 8067, 5, 2369, 0, 0, 8067, 8069, 3, + 2378, 1189, 0, 8068, 8066, 1, 0, 0, 0, 8069, 8072, 1, 0, 0, 0, 8070, 8068, + 1, 0, 0, 0, 8070, 8071, 1, 0, 0, 0, 8071, 753, 1, 0, 0, 0, 8072, 8070, + 1, 0, 0, 0, 8073, 8087, 5, 1379, 0, 0, 8074, 8075, 7, 75, 0, 0, 8075, 8088, + 3, 2378, 1189, 0, 8076, 8078, 5, 1973, 0, 0, 8077, 8079, 5, 1568, 0, 0, + 8078, 8077, 1, 0, 0, 0, 8078, 8079, 1, 0, 0, 0, 8079, 8080, 1, 0, 0, 0, + 8080, 8083, 3, 2378, 1189, 0, 8081, 8082, 5, 2121, 0, 0, 8082, 8084, 3, + 2378, 1189, 0, 8083, 8081, 1, 0, 0, 0, 8083, 8084, 1, 0, 0, 0, 8084, 8088, + 1, 0, 0, 0, 8085, 8088, 5, 1419, 0, 0, 8086, 8088, 5, 344, 0, 0, 8087, + 8074, 1, 0, 0, 0, 8087, 8076, 1, 0, 0, 0, 8087, 8085, 1, 0, 0, 0, 8087, + 8086, 1, 0, 0, 0, 8088, 755, 1, 0, 0, 0, 8089, 8101, 5, 987, 0, 0, 8090, + 8092, 3, 722, 361, 0, 8091, 8093, 3, 724, 362, 0, 8092, 8091, 1, 0, 0, + 0, 8092, 8093, 1, 0, 0, 0, 8093, 8102, 1, 0, 0, 0, 8094, 8102, 3, 728, + 364, 0, 8095, 8102, 5, 948, 0, 0, 8096, 8097, 5, 396, 0, 0, 8097, 8099, + 5, 799, 0, 0, 8098, 8100, 3, 724, 362, 0, 8099, 8098, 1, 0, 0, 0, 8099, + 8100, 1, 0, 0, 0, 8100, 8102, 1, 0, 0, 0, 8101, 8090, 1, 0, 0, 0, 8101, + 8094, 1, 0, 0, 0, 8101, 8095, 1, 0, 0, 0, 8101, 8096, 1, 0, 0, 0, 8102, + 8108, 1, 0, 0, 0, 8103, 8105, 5, 2179, 0, 0, 8104, 8106, 5, 1121, 0, 0, + 8105, 8104, 1, 0, 0, 0, 8105, 8106, 1, 0, 0, 0, 8106, 8107, 1, 0, 0, 0, + 8107, 8109, 5, 1679, 0, 0, 8108, 8103, 1, 0, 0, 0, 8108, 8109, 1, 0, 0, + 0, 8109, 8111, 1, 0, 0, 0, 8110, 8112, 3, 762, 381, 0, 8111, 8110, 1, 0, + 0, 0, 8111, 8112, 1, 0, 0, 0, 8112, 757, 1, 0, 0, 0, 8113, 8114, 5, 1460, + 0, 0, 8114, 8115, 3, 736, 368, 0, 8115, 8116, 5, 2029, 0, 0, 8116, 8117, + 3, 736, 368, 0, 8117, 8118, 5, 2396, 0, 0, 8118, 759, 1, 0, 0, 0, 8119, + 8131, 5, 591, 0, 0, 8120, 8122, 5, 2382, 0, 0, 8121, 8120, 1, 0, 0, 0, + 8121, 8122, 1, 0, 0, 0, 8122, 8129, 1, 0, 0, 0, 8123, 8130, 3, 2280, 1140, + 0, 8124, 8130, 3, 2362, 1181, 0, 8125, 8127, 3, 2360, 1180, 0, 8126, 8128, + 3, 2330, 1165, 0, 8127, 8126, 1, 0, 0, 0, 8127, 8128, 1, 0, 0, 0, 8128, + 8130, 1, 0, 0, 0, 8129, 8123, 1, 0, 0, 0, 8129, 8124, 1, 0, 0, 0, 8129, + 8125, 1, 0, 0, 0, 8130, 8132, 1, 0, 0, 0, 8131, 8121, 1, 0, 0, 0, 8132, + 8133, 1, 0, 0, 0, 8133, 8131, 1, 0, 0, 0, 8133, 8134, 1, 0, 0, 0, 8134, + 8137, 1, 0, 0, 0, 8135, 8136, 5, 1175, 0, 0, 8136, 8138, 3, 2326, 1163, + 0, 8137, 8135, 1, 0, 0, 0, 8137, 8138, 1, 0, 0, 0, 8138, 8139, 1, 0, 0, + 0, 8139, 8142, 5, 2029, 0, 0, 8140, 8143, 3, 2278, 1139, 0, 8141, 8143, + 5, 1377, 0, 0, 8142, 8140, 1, 0, 0, 0, 8142, 8141, 1, 0, 0, 0, 8143, 8151, + 1, 0, 0, 0, 8144, 8147, 5, 2382, 0, 0, 8145, 8148, 3, 2278, 1139, 0, 8146, + 8148, 5, 1377, 0, 0, 8147, 8145, 1, 0, 0, 0, 8147, 8146, 1, 0, 0, 0, 8148, + 8150, 1, 0, 0, 0, 8149, 8144, 1, 0, 0, 0, 8150, 8153, 1, 0, 0, 0, 8151, + 8149, 1, 0, 0, 0, 8151, 8152, 1, 0, 0, 0, 8152, 8157, 1, 0, 0, 0, 8153, + 8151, 1, 0, 0, 0, 8154, 8155, 5, 2188, 0, 0, 8155, 8156, 7, 76, 0, 0, 8156, + 8158, 5, 1188, 0, 0, 8157, 8154, 1, 0, 0, 0, 8157, 8158, 1, 0, 0, 0, 8158, + 8162, 1, 0, 0, 0, 8159, 8160, 5, 2188, 0, 0, 8160, 8161, 5, 617, 0, 0, + 8161, 8163, 5, 1188, 0, 0, 8162, 8159, 1, 0, 0, 0, 8162, 8163, 1, 0, 0, + 0, 8163, 8167, 1, 0, 0, 0, 8164, 8165, 5, 2188, 0, 0, 8165, 8166, 5, 591, + 0, 0, 8166, 8168, 5, 1188, 0, 0, 8167, 8164, 1, 0, 0, 0, 8167, 8168, 1, + 0, 0, 0, 8168, 8170, 1, 0, 0, 0, 8169, 8171, 3, 762, 381, 0, 8170, 8169, + 1, 0, 0, 0, 8170, 8171, 1, 0, 0, 0, 8171, 8172, 1, 0, 0, 0, 8172, 8173, + 5, 2396, 0, 0, 8173, 761, 1, 0, 0, 0, 8174, 8175, 5, 270, 0, 0, 8175, 8176, + 5, 2398, 0, 0, 8176, 8177, 7, 73, 0, 0, 8177, 763, 1, 0, 0, 0, 8178, 8187, + 5, 1490, 0, 0, 8179, 8182, 3, 766, 383, 0, 8180, 8182, 3, 770, 385, 0, + 8181, 8179, 1, 0, 0, 0, 8181, 8180, 1, 0, 0, 0, 8182, 8184, 1, 0, 0, 0, + 8183, 8185, 3, 762, 381, 0, 8184, 8183, 1, 0, 0, 0, 8184, 8185, 1, 0, 0, + 0, 8185, 8188, 1, 0, 0, 0, 8186, 8188, 3, 774, 387, 0, 8187, 8181, 1, 0, + 0, 0, 8187, 8186, 1, 0, 0, 0, 8188, 765, 1, 0, 0, 0, 8189, 8194, 3, 2362, + 1181, 0, 8190, 8194, 3, 2280, 1140, 0, 8191, 8192, 5, 37, 0, 0, 8192, 8194, + 5, 1363, 0, 0, 8193, 8189, 1, 0, 0, 0, 8193, 8190, 1, 0, 0, 0, 8193, 8191, + 1, 0, 0, 0, 8194, 8195, 1, 0, 0, 0, 8195, 8196, 5, 572, 0, 0, 8196, 8197, + 3, 768, 384, 0, 8197, 767, 1, 0, 0, 0, 8198, 8201, 3, 2378, 1189, 0, 8199, + 8201, 5, 1377, 0, 0, 8200, 8198, 1, 0, 0, 0, 8200, 8199, 1, 0, 0, 0, 8201, + 8209, 1, 0, 0, 0, 8202, 8205, 5, 2382, 0, 0, 8203, 8206, 3, 2378, 1189, + 0, 8204, 8206, 5, 1377, 0, 0, 8205, 8203, 1, 0, 0, 0, 8205, 8204, 1, 0, + 0, 0, 8206, 8208, 1, 0, 0, 0, 8207, 8202, 1, 0, 0, 0, 8208, 8211, 1, 0, + 0, 0, 8209, 8207, 1, 0, 0, 0, 8209, 8210, 1, 0, 0, 0, 8210, 769, 1, 0, + 0, 0, 8211, 8209, 1, 0, 0, 0, 8212, 8218, 3, 2360, 1180, 0, 8213, 8215, + 5, 37, 0, 0, 8214, 8216, 5, 1363, 0, 0, 8215, 8214, 1, 0, 0, 0, 8215, 8216, + 1, 0, 0, 0, 8216, 8218, 1, 0, 0, 0, 8217, 8212, 1, 0, 0, 0, 8217, 8213, + 1, 0, 0, 0, 8218, 8229, 1, 0, 0, 0, 8219, 8225, 5, 2382, 0, 0, 8220, 8226, + 3, 2360, 1180, 0, 8221, 8223, 5, 37, 0, 0, 8222, 8224, 5, 1363, 0, 0, 8223, + 8222, 1, 0, 0, 0, 8223, 8224, 1, 0, 0, 0, 8224, 8226, 1, 0, 0, 0, 8225, + 8220, 1, 0, 0, 0, 8225, 8221, 1, 0, 0, 0, 8226, 8228, 1, 0, 0, 0, 8227, + 8219, 1, 0, 0, 0, 8228, 8231, 1, 0, 0, 0, 8229, 8227, 1, 0, 0, 0, 8229, + 8230, 1, 0, 0, 0, 8230, 8232, 1, 0, 0, 0, 8231, 8229, 1, 0, 0, 0, 8232, + 8233, 3, 772, 386, 0, 8233, 8234, 5, 572, 0, 0, 8234, 8238, 3, 768, 384, + 0, 8235, 8236, 5, 168, 0, 0, 8236, 8239, 5, 268, 0, 0, 8237, 8239, 5, 560, + 0, 0, 8238, 8235, 1, 0, 0, 0, 8238, 8237, 1, 0, 0, 0, 8238, 8239, 1, 0, + 0, 0, 8239, 771, 1, 0, 0, 0, 8240, 8285, 5, 1175, 0, 0, 8241, 8242, 3, + 2258, 1129, 0, 8242, 8243, 5, 2369, 0, 0, 8243, 8245, 1, 0, 0, 0, 8244, + 8241, 1, 0, 0, 0, 8244, 8245, 1, 0, 0, 0, 8245, 8246, 1, 0, 0, 0, 8246, + 8286, 3, 2378, 1189, 0, 8247, 8248, 5, 2121, 0, 0, 8248, 8253, 3, 2378, + 1189, 0, 8249, 8250, 5, 2382, 0, 0, 8250, 8252, 3, 2378, 1189, 0, 8251, + 8249, 1, 0, 0, 0, 8252, 8255, 1, 0, 0, 0, 8253, 8251, 1, 0, 0, 0, 8253, + 8254, 1, 0, 0, 0, 8254, 8286, 1, 0, 0, 0, 8255, 8253, 1, 0, 0, 0, 8256, + 8257, 5, 395, 0, 0, 8257, 8286, 3, 782, 391, 0, 8258, 8259, 5, 438, 0, + 0, 8259, 8286, 3, 1468, 734, 0, 8260, 8261, 5, 884, 0, 0, 8261, 8265, 5, + 900, 0, 0, 8262, 8263, 3, 2258, 1129, 0, 8263, 8264, 5, 2369, 0, 0, 8264, + 8266, 1, 0, 0, 0, 8265, 8262, 1, 0, 0, 0, 8265, 8266, 1, 0, 0, 0, 8266, + 8267, 1, 0, 0, 0, 8267, 8286, 3, 2378, 1189, 0, 8268, 8269, 5, 729, 0, + 0, 8269, 8273, 7, 77, 0, 0, 8270, 8271, 3, 2258, 1129, 0, 8271, 8272, 5, + 2369, 0, 0, 8272, 8274, 1, 0, 0, 0, 8273, 8270, 1, 0, 0, 0, 8273, 8274, + 1, 0, 0, 0, 8274, 8275, 1, 0, 0, 0, 8275, 8286, 3, 2378, 1189, 0, 8276, + 8277, 5, 1617, 0, 0, 8277, 8278, 5, 2041, 0, 0, 8278, 8282, 5, 1367, 0, + 0, 8279, 8280, 3, 2258, 1129, 0, 8280, 8281, 5, 2369, 0, 0, 8281, 8283, + 1, 0, 0, 0, 8282, 8279, 1, 0, 0, 0, 8282, 8283, 1, 0, 0, 0, 8283, 8284, + 1, 0, 0, 0, 8284, 8286, 3, 2378, 1189, 0, 8285, 8244, 1, 0, 0, 0, 8285, + 8247, 1, 0, 0, 0, 8285, 8256, 1, 0, 0, 0, 8285, 8258, 1, 0, 0, 0, 8285, + 8260, 1, 0, 0, 0, 8285, 8268, 1, 0, 0, 0, 8285, 8276, 1, 0, 0, 0, 8286, + 773, 1, 0, 0, 0, 8287, 8292, 3, 2280, 1140, 0, 8288, 8289, 5, 2382, 0, + 0, 8289, 8291, 3, 2280, 1140, 0, 8290, 8288, 1, 0, 0, 0, 8291, 8294, 1, + 0, 0, 0, 8292, 8290, 1, 0, 0, 0, 8292, 8293, 1, 0, 0, 0, 8293, 8297, 1, + 0, 0, 0, 8294, 8292, 1, 0, 0, 0, 8295, 8297, 5, 37, 0, 0, 8296, 8287, 1, + 0, 0, 0, 8296, 8295, 1, 0, 0, 0, 8297, 8298, 1, 0, 0, 0, 8298, 8299, 5, + 572, 0, 0, 8299, 8304, 3, 776, 388, 0, 8300, 8301, 5, 2382, 0, 0, 8301, + 8303, 3, 776, 388, 0, 8302, 8300, 1, 0, 0, 0, 8303, 8306, 1, 0, 0, 0, 8304, + 8302, 1, 0, 0, 0, 8304, 8305, 1, 0, 0, 0, 8305, 775, 1, 0, 0, 0, 8306, + 8304, 1, 0, 0, 0, 8307, 8311, 7, 78, 0, 0, 8308, 8309, 3, 2258, 1129, 0, + 8309, 8310, 5, 2369, 0, 0, 8310, 8312, 1, 0, 0, 0, 8311, 8308, 1, 0, 0, + 0, 8311, 8312, 1, 0, 0, 0, 8312, 8313, 1, 0, 0, 0, 8313, 8314, 3, 2378, + 1189, 0, 8314, 777, 1, 0, 0, 0, 8315, 8316, 5, 301, 0, 0, 8316, 8317, 5, + 392, 0, 0, 8317, 8319, 3, 2376, 1188, 0, 8318, 8320, 3, 816, 408, 0, 8319, + 8318, 1, 0, 0, 0, 8320, 8321, 1, 0, 0, 0, 8321, 8319, 1, 0, 0, 0, 8321, + 8322, 1, 0, 0, 0, 8322, 8326, 1, 0, 0, 0, 8323, 8327, 3, 818, 409, 0, 8324, + 8327, 3, 822, 411, 0, 8325, 8327, 3, 824, 412, 0, 8326, 8323, 1, 0, 0, + 0, 8326, 8324, 1, 0, 0, 0, 8326, 8325, 1, 0, 0, 0, 8327, 8328, 1, 0, 0, + 0, 8328, 8326, 1, 0, 0, 0, 8328, 8329, 1, 0, 0, 0, 8329, 779, 1, 0, 0, + 0, 8330, 8333, 5, 301, 0, 0, 8331, 8332, 5, 1219, 0, 0, 8332, 8334, 5, + 1463, 0, 0, 8333, 8331, 1, 0, 0, 0, 8333, 8334, 1, 0, 0, 0, 8334, 8335, + 1, 0, 0, 0, 8335, 8336, 5, 395, 0, 0, 8336, 8340, 3, 782, 391, 0, 8337, + 8338, 5, 1577, 0, 0, 8338, 8339, 5, 2398, 0, 0, 8339, 8341, 7, 43, 0, 0, + 8340, 8337, 1, 0, 0, 0, 8340, 8341, 1, 0, 0, 0, 8341, 8342, 1, 0, 0, 0, + 8342, 8343, 5, 66, 0, 0, 8343, 8344, 3, 784, 392, 0, 8344, 8345, 5, 2396, + 0, 0, 8345, 781, 1, 0, 0, 0, 8346, 8347, 3, 2378, 1189, 0, 8347, 783, 1, + 0, 0, 0, 8348, 8349, 5, 2372, 0, 0, 8349, 785, 1, 0, 0, 0, 8350, 8351, + 5, 301, 0, 0, 8351, 8352, 5, 688, 0, 0, 8352, 8353, 5, 731, 0, 0, 8353, + 8357, 5, 593, 0, 0, 8354, 8355, 3, 2258, 1129, 0, 8355, 8356, 5, 2369, + 0, 0, 8356, 8358, 1, 0, 0, 0, 8357, 8354, 1, 0, 0, 0, 8357, 8358, 1, 0, + 0, 0, 8358, 8359, 1, 0, 0, 0, 8359, 8360, 3, 2378, 1189, 0, 8360, 8364, + 5, 2376, 0, 0, 8361, 8362, 3, 2258, 1129, 0, 8362, 8363, 5, 2369, 0, 0, + 8363, 8365, 1, 0, 0, 0, 8364, 8361, 1, 0, 0, 0, 8364, 8365, 1, 0, 0, 0, + 8365, 8366, 1, 0, 0, 0, 8366, 8367, 3, 2378, 1189, 0, 8367, 8368, 5, 2376, + 0, 0, 8368, 8369, 3, 2378, 1189, 0, 8369, 8381, 5, 2377, 0, 0, 8370, 8374, + 5, 2382, 0, 0, 8371, 8372, 3, 2258, 1129, 0, 8372, 8373, 5, 2369, 0, 0, + 8373, 8375, 1, 0, 0, 0, 8374, 8371, 1, 0, 0, 0, 8374, 8375, 1, 0, 0, 0, + 8375, 8376, 1, 0, 0, 0, 8376, 8377, 3, 2378, 1189, 0, 8377, 8378, 5, 2376, + 0, 0, 8378, 8379, 3, 2378, 1189, 0, 8379, 8380, 5, 2377, 0, 0, 8380, 8382, + 1, 0, 0, 0, 8381, 8370, 1, 0, 0, 0, 8382, 8383, 1, 0, 0, 0, 8383, 8381, + 1, 0, 0, 0, 8383, 8384, 1, 0, 0, 0, 8384, 8385, 1, 0, 0, 0, 8385, 8386, + 5, 2377, 0, 0, 8386, 787, 1, 0, 0, 0, 8387, 8388, 5, 425, 0, 0, 8388, 8392, + 5, 617, 0, 0, 8389, 8390, 3, 2258, 1129, 0, 8390, 8391, 5, 2369, 0, 0, + 8391, 8393, 1, 0, 0, 0, 8392, 8389, 1, 0, 0, 0, 8392, 8393, 1, 0, 0, 0, + 8393, 8394, 1, 0, 0, 0, 8394, 8395, 3, 2378, 1189, 0, 8395, 789, 1, 0, + 0, 0, 8396, 8397, 5, 41, 0, 0, 8397, 8398, 5, 784, 0, 0, 8398, 8414, 3, + 812, 406, 0, 8399, 8401, 5, 233, 0, 0, 8400, 8402, 3, 806, 403, 0, 8401, + 8400, 1, 0, 0, 0, 8401, 8402, 1, 0, 0, 0, 8402, 8406, 1, 0, 0, 0, 8403, + 8405, 3, 808, 404, 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, 8411, 1, 0, 0, 0, 8408, + 8406, 1, 0, 0, 0, 8409, 8410, 5, 1488, 0, 0, 8410, 8412, 5, 1570, 0, 0, + 8411, 8409, 1, 0, 0, 0, 8411, 8412, 1, 0, 0, 0, 8412, 8415, 1, 0, 0, 0, + 8413, 8415, 3, 804, 402, 0, 8414, 8399, 1, 0, 0, 0, 8414, 8413, 1, 0, 0, + 0, 8415, 8416, 1, 0, 0, 0, 8416, 8417, 5, 2396, 0, 0, 8417, 791, 1, 0, + 0, 0, 8418, 8419, 5, 425, 0, 0, 8419, 8420, 5, 729, 0, 0, 8420, 8424, 7, + 79, 0, 0, 8421, 8422, 3, 2258, 1129, 0, 8422, 8423, 5, 2369, 0, 0, 8423, + 8425, 1, 0, 0, 0, 8424, 8421, 1, 0, 0, 0, 8424, 8425, 1, 0, 0, 0, 8425, + 8426, 1, 0, 0, 0, 8426, 8427, 3, 2378, 1189, 0, 8427, 793, 1, 0, 0, 0, + 8428, 8429, 5, 425, 0, 0, 8429, 8430, 5, 784, 0, 0, 8430, 8431, 3, 812, + 406, 0, 8431, 795, 1, 0, 0, 0, 8432, 8435, 5, 301, 0, 0, 8433, 8434, 5, + 1219, 0, 0, 8434, 8436, 5, 1463, 0, 0, 8435, 8433, 1, 0, 0, 0, 8435, 8436, + 1, 0, 0, 0, 8436, 8439, 1, 0, 0, 0, 8437, 8438, 5, 48, 0, 0, 8438, 8440, + 7, 80, 0, 0, 8439, 8437, 1, 0, 0, 0, 8439, 8440, 1, 0, 0, 0, 8440, 8442, + 1, 0, 0, 0, 8441, 8443, 5, 1027, 0, 0, 8442, 8441, 1, 0, 0, 0, 8442, 8443, + 1, 0, 0, 0, 8443, 8444, 1, 0, 0, 0, 8444, 8458, 5, 729, 0, 0, 8445, 8446, + 7, 77, 0, 0, 8446, 8450, 5, 925, 0, 0, 8447, 8448, 3, 2258, 1129, 0, 8448, + 8449, 5, 2369, 0, 0, 8449, 8451, 1, 0, 0, 0, 8450, 8447, 1, 0, 0, 0, 8450, + 8451, 1, 0, 0, 0, 8451, 8452, 1, 0, 0, 0, 8452, 8459, 3, 2378, 1189, 0, + 8453, 8456, 5, 192, 0, 0, 8454, 8455, 5, 1526, 0, 0, 8455, 8457, 3, 2378, + 1189, 0, 8456, 8454, 1, 0, 0, 0, 8456, 8457, 1, 0, 0, 0, 8457, 8459, 1, + 0, 0, 0, 8458, 8445, 1, 0, 0, 0, 8458, 8453, 1, 0, 0, 0, 8459, 8463, 1, + 0, 0, 0, 8460, 8461, 5, 1577, 0, 0, 8461, 8462, 5, 2398, 0, 0, 8462, 8464, + 7, 43, 0, 0, 8463, 8460, 1, 0, 0, 0, 8463, 8464, 1, 0, 0, 0, 8464, 8466, + 1, 0, 0, 0, 8465, 8467, 3, 1746, 873, 0, 8466, 8465, 1, 0, 0, 0, 8466, + 8467, 1, 0, 0, 0, 8467, 8485, 1, 0, 0, 0, 8468, 8469, 5, 1470, 0, 0, 8469, + 8480, 5, 2376, 0, 0, 8470, 8471, 5, 2376, 0, 0, 8471, 8473, 5, 2372, 0, + 0, 8472, 8474, 5, 2382, 0, 0, 8473, 8472, 1, 0, 0, 0, 8473, 8474, 1, 0, + 0, 0, 8474, 8477, 1, 0, 0, 0, 8475, 8478, 3, 2378, 1189, 0, 8476, 8478, + 5, 2381, 0, 0, 8477, 8475, 1, 0, 0, 0, 8477, 8476, 1, 0, 0, 0, 8478, 8479, + 1, 0, 0, 0, 8479, 8481, 5, 2377, 0, 0, 8480, 8470, 1, 0, 0, 0, 8481, 8482, + 1, 0, 0, 0, 8482, 8480, 1, 0, 0, 0, 8482, 8483, 1, 0, 0, 0, 8483, 8484, + 1, 0, 0, 0, 8484, 8486, 5, 2377, 0, 0, 8485, 8468, 1, 0, 0, 0, 8485, 8486, + 1, 0, 0, 0, 8486, 8502, 1, 0, 0, 0, 8487, 8498, 5, 2129, 0, 0, 8488, 8489, + 5, 113, 0, 0, 8489, 8490, 5, 2376, 0, 0, 8490, 8491, 3, 2378, 1189, 0, + 8491, 8492, 5, 2382, 0, 0, 8492, 8493, 3, 1472, 736, 0, 8493, 8494, 5, + 2377, 0, 0, 8494, 8499, 1, 0, 0, 0, 8495, 8496, 7, 81, 0, 0, 8496, 8499, + 3, 1892, 946, 0, 8497, 8499, 5, 2372, 0, 0, 8498, 8488, 1, 0, 0, 0, 8498, + 8495, 1, 0, 0, 0, 8498, 8497, 1, 0, 0, 0, 8499, 8503, 1, 0, 0, 0, 8500, + 8501, 5, 66, 0, 0, 8501, 8503, 5, 2372, 0, 0, 8502, 8487, 1, 0, 0, 0, 8502, + 8500, 1, 0, 0, 0, 8503, 797, 1, 0, 0, 0, 8504, 8507, 5, 301, 0, 0, 8505, + 8506, 5, 1219, 0, 0, 8506, 8508, 5, 1463, 0, 0, 8507, 8505, 1, 0, 0, 0, + 8507, 8508, 1, 0, 0, 0, 8508, 8510, 1, 0, 0, 0, 8509, 8511, 7, 82, 0, 0, + 8510, 8509, 1, 0, 0, 0, 8510, 8511, 1, 0, 0, 0, 8511, 8512, 1, 0, 0, 0, + 8512, 8513, 5, 784, 0, 0, 8513, 8514, 3, 800, 400, 0, 8514, 799, 1, 0, + 0, 0, 8515, 8516, 3, 812, 406, 0, 8516, 8517, 7, 20, 0, 0, 8517, 8520, + 3, 2372, 1186, 0, 8518, 8519, 5, 680, 0, 0, 8519, 8521, 3, 782, 391, 0, + 8520, 8518, 1, 0, 0, 0, 8520, 8521, 1, 0, 0, 0, 8521, 8524, 1, 0, 0, 0, + 8522, 8523, 5, 33, 0, 0, 8523, 8525, 3, 2372, 1186, 0, 8524, 8522, 1, 0, + 0, 0, 8524, 8525, 1, 0, 0, 0, 8525, 8528, 1, 0, 0, 0, 8526, 8527, 5, 305, + 0, 0, 8527, 8529, 3, 802, 401, 0, 8528, 8526, 1, 0, 0, 0, 8528, 8529, 1, + 0, 0, 0, 8529, 801, 1, 0, 0, 0, 8530, 8531, 3, 2378, 1189, 0, 8531, 8532, + 5, 2369, 0, 0, 8532, 8534, 1, 0, 0, 0, 8533, 8530, 1, 0, 0, 0, 8533, 8534, + 1, 0, 0, 0, 8534, 8535, 1, 0, 0, 0, 8535, 8536, 3, 2378, 1189, 0, 8536, + 803, 1, 0, 0, 0, 8537, 8538, 4, 402, 5, 0, 8538, 8539, 7, 82, 0, 0, 8539, + 805, 1, 0, 0, 0, 8540, 8541, 4, 403, 6, 0, 8541, 8542, 5, 352, 0, 0, 8542, + 807, 1, 0, 0, 0, 8543, 8544, 3, 2266, 1133, 0, 8544, 8545, 5, 2398, 0, + 0, 8545, 8546, 3, 810, 405, 0, 8546, 809, 1, 0, 0, 0, 8547, 8550, 3, 2382, + 1191, 0, 8548, 8550, 5, 2372, 0, 0, 8549, 8547, 1, 0, 0, 0, 8549, 8548, + 1, 0, 0, 0, 8550, 811, 1, 0, 0, 0, 8551, 8552, 3, 2382, 1191, 0, 8552, + 8553, 5, 2369, 0, 0, 8553, 8555, 1, 0, 0, 0, 8554, 8551, 1, 0, 0, 0, 8554, + 8555, 1, 0, 0, 0, 8555, 8556, 1, 0, 0, 0, 8556, 8557, 3, 2382, 1191, 0, + 8557, 813, 1, 0, 0, 0, 8558, 8559, 5, 41, 0, 0, 8559, 8560, 5, 392, 0, + 0, 8560, 8605, 3, 2376, 1188, 0, 8561, 8566, 5, 20, 0, 0, 8562, 8567, 3, + 816, 408, 0, 8563, 8567, 3, 818, 409, 0, 8564, 8567, 3, 822, 411, 0, 8565, + 8567, 3, 824, 412, 0, 8566, 8562, 1, 0, 0, 0, 8566, 8563, 1, 0, 0, 0, 8566, + 8564, 1, 0, 0, 0, 8566, 8565, 1, 0, 0, 0, 8567, 8569, 1, 0, 0, 0, 8568, + 8561, 1, 0, 0, 0, 8569, 8570, 1, 0, 0, 0, 8570, 8568, 1, 0, 0, 0, 8570, + 8571, 1, 0, 0, 0, 8571, 8606, 1, 0, 0, 0, 8572, 8598, 5, 425, 0, 0, 8573, + 8574, 5, 781, 0, 0, 8574, 8576, 3, 2376, 1188, 0, 8575, 8577, 7, 83, 0, + 0, 8576, 8575, 1, 0, 0, 0, 8576, 8577, 1, 0, 0, 0, 8577, 8599, 1, 0, 0, + 0, 8578, 8579, 5, 617, 0, 0, 8579, 8599, 3, 2376, 1188, 0, 8580, 8581, + 5, 80, 0, 0, 8581, 8596, 3, 2376, 1188, 0, 8582, 8583, 5, 781, 0, 0, 8583, + 8594, 3, 2376, 1188, 0, 8584, 8585, 5, 222, 0, 0, 8585, 8591, 3, 2310, + 1155, 0, 8586, 8587, 5, 2382, 0, 0, 8587, 8588, 5, 222, 0, 0, 8588, 8590, + 3, 2310, 1155, 0, 8589, 8586, 1, 0, 0, 0, 8590, 8593, 1, 0, 0, 0, 8591, + 8589, 1, 0, 0, 0, 8591, 8592, 1, 0, 0, 0, 8592, 8595, 1, 0, 0, 0, 8593, + 8591, 1, 0, 0, 0, 8594, 8584, 1, 0, 0, 0, 8594, 8595, 1, 0, 0, 0, 8595, + 8597, 1, 0, 0, 0, 8596, 8582, 1, 0, 0, 0, 8596, 8597, 1, 0, 0, 0, 8597, + 8599, 1, 0, 0, 0, 8598, 8573, 1, 0, 0, 0, 8598, 8578, 1, 0, 0, 0, 8598, + 8580, 1, 0, 0, 0, 8599, 8601, 1, 0, 0, 0, 8600, 8572, 1, 0, 0, 0, 8601, + 8602, 1, 0, 0, 0, 8602, 8600, 1, 0, 0, 0, 8602, 8603, 1, 0, 0, 0, 8603, + 8606, 1, 0, 0, 0, 8604, 8606, 5, 233, 0, 0, 8605, 8568, 1, 0, 0, 0, 8605, + 8600, 1, 0, 0, 0, 8605, 8604, 1, 0, 0, 0, 8606, 815, 1, 0, 0, 0, 8607, + 8608, 5, 781, 0, 0, 8608, 8609, 3, 2376, 1188, 0, 8609, 8630, 5, 723, 0, + 0, 8610, 8611, 3, 1104, 552, 0, 8611, 8612, 5, 2369, 0, 0, 8612, 8613, + 3, 2310, 1155, 0, 8613, 8631, 1, 0, 0, 0, 8614, 8615, 5, 2376, 0, 0, 8615, + 8616, 3, 1104, 552, 0, 8616, 8617, 5, 2369, 0, 0, 8617, 8625, 3, 2310, + 1155, 0, 8618, 8619, 5, 2382, 0, 0, 8619, 8620, 3, 1104, 552, 0, 8620, + 8621, 5, 2369, 0, 0, 8621, 8622, 3, 2310, 1155, 0, 8622, 8624, 1, 0, 0, + 0, 8623, 8618, 1, 0, 0, 0, 8624, 8627, 1, 0, 0, 0, 8625, 8623, 1, 0, 0, + 0, 8625, 8626, 1, 0, 0, 0, 8626, 8628, 1, 0, 0, 0, 8627, 8625, 1, 0, 0, + 0, 8628, 8629, 5, 2377, 0, 0, 8629, 8631, 1, 0, 0, 0, 8630, 8610, 1, 0, + 0, 0, 8630, 8614, 1, 0, 0, 0, 8631, 8635, 1, 0, 0, 0, 8632, 8633, 5, 1597, + 0, 0, 8633, 8634, 5, 2180, 0, 0, 8634, 8636, 5, 1145, 0, 0, 8635, 8632, + 1, 0, 0, 0, 8635, 8636, 1, 0, 0, 0, 8636, 817, 1, 0, 0, 0, 8637, 8638, + 5, 617, 0, 0, 8638, 8639, 3, 2376, 1188, 0, 8639, 8640, 5, 2376, 0, 0, + 8640, 8644, 3, 2376, 1188, 0, 8641, 8642, 5, 188, 0, 0, 8642, 8643, 5, + 1163, 0, 0, 8643, 8645, 3, 2376, 1188, 0, 8644, 8641, 1, 0, 0, 0, 8645, + 8646, 1, 0, 0, 0, 8646, 8644, 1, 0, 0, 0, 8646, 8647, 1, 0, 0, 0, 8647, + 8649, 1, 0, 0, 0, 8648, 8650, 3, 820, 410, 0, 8649, 8648, 1, 0, 0, 0, 8649, + 8650, 1, 0, 0, 0, 8650, 8651, 1, 0, 0, 0, 8651, 8652, 5, 2377, 0, 0, 8652, + 819, 1, 0, 0, 0, 8653, 8654, 5, 731, 0, 0, 8654, 8655, 5, 753, 0, 0, 8655, + 8656, 3, 826, 413, 0, 8656, 8657, 5, 1429, 0, 0, 8657, 8658, 3, 2376, 1188, + 0, 8658, 8660, 1, 0, 0, 0, 8659, 8653, 1, 0, 0, 0, 8660, 8661, 1, 0, 0, + 0, 8661, 8659, 1, 0, 0, 0, 8661, 8662, 1, 0, 0, 0, 8662, 821, 1, 0, 0, + 0, 8663, 8664, 5, 80, 0, 0, 8664, 8665, 3, 2376, 1188, 0, 8665, 8666, 5, + 389, 0, 0, 8666, 8667, 3, 826, 413, 0, 8667, 8669, 1, 0, 0, 0, 8668, 8663, + 1, 0, 0, 0, 8669, 8670, 1, 0, 0, 0, 8670, 8668, 1, 0, 0, 0, 8670, 8671, + 1, 0, 0, 0, 8671, 823, 1, 0, 0, 0, 8672, 8673, 5, 80, 0, 0, 8673, 8679, + 3, 2376, 1188, 0, 8674, 8675, 5, 781, 0, 0, 8675, 8676, 3, 2376, 1188, + 0, 8676, 8677, 5, 389, 0, 0, 8677, 8678, 3, 826, 413, 0, 8678, 8680, 1, + 0, 0, 0, 8679, 8674, 1, 0, 0, 0, 8680, 8681, 1, 0, 0, 0, 8681, 8679, 1, + 0, 0, 0, 8681, 8682, 1, 0, 0, 0, 8682, 825, 1, 0, 0, 0, 8683, 8696, 3, + 2310, 1155, 0, 8684, 8685, 5, 2376, 0, 0, 8685, 8690, 3, 2310, 1155, 0, + 8686, 8687, 5, 2382, 0, 0, 8687, 8689, 3, 2310, 1155, 0, 8688, 8686, 1, + 0, 0, 0, 8689, 8692, 1, 0, 0, 0, 8690, 8688, 1, 0, 0, 0, 8690, 8691, 1, + 0, 0, 0, 8691, 8693, 1, 0, 0, 0, 8692, 8690, 1, 0, 0, 0, 8693, 8694, 5, + 2377, 0, 0, 8694, 8696, 1, 0, 0, 0, 8695, 8683, 1, 0, 0, 0, 8695, 8684, + 1, 0, 0, 0, 8696, 827, 1, 0, 0, 0, 8697, 8698, 5, 41, 0, 0, 8698, 8699, + 5, 2166, 0, 0, 8699, 8732, 3, 2312, 1156, 0, 8700, 8701, 5, 20, 0, 0, 8701, + 8733, 3, 848, 424, 0, 8702, 8703, 5, 909, 0, 0, 8703, 8704, 5, 267, 0, + 0, 8704, 8705, 3, 2282, 1141, 0, 8705, 8706, 7, 44, 0, 0, 8706, 8733, 1, + 0, 0, 0, 8707, 8724, 5, 425, 0, 0, 8708, 8709, 5, 267, 0, 0, 8709, 8725, + 3, 2282, 1141, 0, 8710, 8711, 5, 1355, 0, 0, 8711, 8725, 5, 753, 0, 0, + 8712, 8713, 5, 2068, 0, 0, 8713, 8714, 5, 2376, 0, 0, 8714, 8719, 3, 2310, + 1155, 0, 8715, 8716, 5, 2382, 0, 0, 8716, 8718, 3, 2310, 1155, 0, 8717, + 8715, 1, 0, 0, 0, 8718, 8721, 1, 0, 0, 0, 8719, 8717, 1, 0, 0, 0, 8719, + 8720, 1, 0, 0, 0, 8720, 8722, 1, 0, 0, 0, 8721, 8719, 1, 0, 0, 0, 8722, + 8723, 5, 2377, 0, 0, 8723, 8725, 1, 0, 0, 0, 8724, 8708, 1, 0, 0, 0, 8724, + 8710, 1, 0, 0, 0, 8724, 8712, 1, 0, 0, 0, 8725, 8733, 1, 0, 0, 0, 8726, + 8733, 5, 233, 0, 0, 8727, 8728, 5, 1408, 0, 0, 8728, 8733, 7, 11, 0, 0, + 8729, 8731, 3, 830, 415, 0, 8730, 8729, 1, 0, 0, 0, 8730, 8731, 1, 0, 0, + 0, 8731, 8733, 1, 0, 0, 0, 8732, 8700, 1, 0, 0, 0, 8732, 8702, 1, 0, 0, + 0, 8732, 8707, 1, 0, 0, 0, 8732, 8726, 1, 0, 0, 0, 8732, 8727, 1, 0, 0, + 0, 8732, 8730, 1, 0, 0, 0, 8733, 8734, 1, 0, 0, 0, 8734, 8735, 5, 2396, + 0, 0, 8735, 829, 1, 0, 0, 0, 8736, 8737, 4, 415, 7, 0, 8737, 8738, 7, 82, + 0, 0, 8738, 831, 1, 0, 0, 0, 8739, 8742, 5, 301, 0, 0, 8740, 8741, 5, 1219, + 0, 0, 8741, 8743, 5, 1463, 0, 0, 8742, 8740, 1, 0, 0, 0, 8742, 8743, 1, + 0, 0, 0, 8743, 8748, 1, 0, 0, 0, 8744, 8746, 5, 1057, 0, 0, 8745, 8744, + 1, 0, 0, 0, 8745, 8746, 1, 0, 0, 0, 8746, 8747, 1, 0, 0, 0, 8747, 8749, + 5, 560, 0, 0, 8748, 8745, 1, 0, 0, 0, 8748, 8749, 1, 0, 0, 0, 8749, 8751, + 1, 0, 0, 0, 8750, 8752, 3, 834, 417, 0, 8751, 8750, 1, 0, 0, 0, 8751, 8752, + 1, 0, 0, 0, 8752, 8753, 1, 0, 0, 0, 8753, 8757, 5, 2166, 0, 0, 8754, 8755, + 3, 2258, 1129, 0, 8755, 8756, 5, 2369, 0, 0, 8756, 8758, 1, 0, 0, 0, 8757, + 8754, 1, 0, 0, 0, 8757, 8758, 1, 0, 0, 0, 8758, 8759, 1, 0, 0, 0, 8759, + 8770, 3, 2378, 1189, 0, 8760, 8761, 5, 1577, 0, 0, 8761, 8768, 5, 2398, + 0, 0, 8762, 8769, 5, 877, 0, 0, 8763, 8765, 5, 2251, 0, 0, 8764, 8763, + 1, 0, 0, 0, 8764, 8765, 1, 0, 0, 0, 8765, 8766, 1, 0, 0, 0, 8766, 8769, + 5, 330, 0, 0, 8767, 8769, 5, 1054, 0, 0, 8768, 8762, 1, 0, 0, 0, 8768, + 8764, 1, 0, 0, 0, 8768, 8767, 1, 0, 0, 0, 8769, 8771, 1, 0, 0, 0, 8770, + 8760, 1, 0, 0, 0, 8770, 8771, 1, 0, 0, 0, 8771, 8773, 1, 0, 0, 0, 8772, + 8774, 3, 836, 418, 0, 8773, 8772, 1, 0, 0, 0, 8773, 8774, 1, 0, 0, 0, 8774, + 8778, 1, 0, 0, 0, 8775, 8776, 5, 363, 0, 0, 8776, 8777, 5, 2248, 0, 0, + 8777, 8779, 3, 2378, 1189, 0, 8778, 8775, 1, 0, 0, 0, 8778, 8779, 1, 0, + 0, 0, 8779, 8782, 1, 0, 0, 0, 8780, 8781, 5, 111, 0, 0, 8781, 8783, 7, + 84, 0, 0, 8782, 8780, 1, 0, 0, 0, 8782, 8783, 1, 0, 0, 0, 8783, 8784, 1, + 0, 0, 0, 8784, 8785, 5, 66, 0, 0, 8785, 8787, 3, 1880, 940, 0, 8786, 8788, + 3, 2066, 1033, 0, 8787, 8786, 1, 0, 0, 0, 8787, 8788, 1, 0, 0, 0, 8788, + 8790, 1, 0, 0, 0, 8789, 8791, 7, 85, 0, 0, 8790, 8789, 1, 0, 0, 0, 8790, + 8791, 1, 0, 0, 0, 8791, 833, 1, 0, 0, 0, 8792, 8799, 5, 439, 0, 0, 8793, + 8795, 5, 437, 0, 0, 8794, 8796, 5, 439, 0, 0, 8795, 8794, 1, 0, 0, 0, 8795, + 8796, 1, 0, 0, 0, 8796, 8799, 1, 0, 0, 0, 8797, 8799, 5, 1053, 0, 0, 8798, + 8792, 1, 0, 0, 0, 8798, 8793, 1, 0, 0, 0, 8798, 8797, 1, 0, 0, 0, 8799, + 835, 1, 0, 0, 0, 8800, 8804, 3, 838, 419, 0, 8801, 8804, 3, 840, 420, 0, + 8802, 8804, 3, 852, 426, 0, 8803, 8800, 1, 0, 0, 0, 8803, 8801, 1, 0, 0, + 0, 8803, 8802, 1, 0, 0, 0, 8804, 837, 1, 0, 0, 0, 8805, 8819, 5, 2376, + 0, 0, 8806, 8808, 5, 2382, 0, 0, 8807, 8806, 1, 0, 0, 0, 8807, 8808, 1, + 0, 0, 0, 8808, 8817, 1, 0, 0, 0, 8809, 8813, 3, 2238, 1119, 0, 8810, 8812, + 3, 842, 421, 0, 8811, 8810, 1, 0, 0, 0, 8812, 8815, 1, 0, 0, 0, 8813, 8811, + 1, 0, 0, 0, 8813, 8814, 1, 0, 0, 0, 8814, 8818, 1, 0, 0, 0, 8815, 8813, + 1, 0, 0, 0, 8816, 8818, 3, 848, 424, 0, 8817, 8809, 1, 0, 0, 0, 8817, 8816, + 1, 0, 0, 0, 8818, 8820, 1, 0, 0, 0, 8819, 8807, 1, 0, 0, 0, 8820, 8821, + 1, 0, 0, 0, 8821, 8819, 1, 0, 0, 0, 8821, 8822, 1, 0, 0, 0, 8822, 8823, + 1, 0, 0, 0, 8823, 8824, 5, 2377, 0, 0, 8824, 839, 1, 0, 0, 0, 8825, 8829, + 5, 1163, 0, 0, 8826, 8827, 3, 2258, 1129, 0, 8827, 8828, 5, 2369, 0, 0, + 8828, 8830, 1, 0, 0, 0, 8829, 8826, 1, 0, 0, 0, 8829, 8830, 1, 0, 0, 0, + 8830, 8831, 1, 0, 0, 0, 8831, 8855, 3, 2378, 1189, 0, 8832, 8833, 5, 2188, + 0, 0, 8833, 8834, 5, 1155, 0, 0, 8834, 8846, 7, 86, 0, 0, 8835, 8847, 5, + 363, 0, 0, 8836, 8837, 5, 2376, 0, 0, 8837, 8842, 5, 2407, 0, 0, 8838, + 8839, 5, 2382, 0, 0, 8839, 8841, 5, 2407, 0, 0, 8840, 8838, 1, 0, 0, 0, + 8841, 8844, 1, 0, 0, 0, 8842, 8840, 1, 0, 0, 0, 8842, 8843, 1, 0, 0, 0, + 8843, 8845, 1, 0, 0, 0, 8844, 8842, 1, 0, 0, 0, 8845, 8847, 5, 2377, 0, + 0, 8846, 8835, 1, 0, 0, 0, 8846, 8836, 1, 0, 0, 0, 8847, 8856, 1, 0, 0, + 0, 8848, 8852, 5, 2063, 0, 0, 8849, 8850, 3, 2258, 1129, 0, 8850, 8851, + 5, 2369, 0, 0, 8851, 8853, 1, 0, 0, 0, 8852, 8849, 1, 0, 0, 0, 8852, 8853, + 1, 0, 0, 0, 8853, 8854, 1, 0, 0, 0, 8854, 8856, 3, 2378, 1189, 0, 8855, + 8832, 1, 0, 0, 0, 8855, 8848, 1, 0, 0, 0, 8856, 8874, 1, 0, 0, 0, 8857, + 8866, 5, 2376, 0, 0, 8858, 8860, 5, 2382, 0, 0, 8859, 8858, 1, 0, 0, 0, + 8859, 8860, 1, 0, 0, 0, 8860, 8864, 1, 0, 0, 0, 8861, 8865, 3, 848, 424, + 0, 8862, 8863, 5, 2407, 0, 0, 8863, 8865, 3, 842, 421, 0, 8864, 8861, 1, + 0, 0, 0, 8864, 8862, 1, 0, 0, 0, 8865, 8867, 1, 0, 0, 0, 8866, 8859, 1, + 0, 0, 0, 8867, 8868, 1, 0, 0, 0, 8868, 8866, 1, 0, 0, 0, 8868, 8869, 1, + 0, 0, 0, 8869, 8870, 1, 0, 0, 0, 8870, 8871, 5, 2377, 0, 0, 8871, 8873, + 1, 0, 0, 0, 8872, 8857, 1, 0, 0, 0, 8873, 8876, 1, 0, 0, 0, 8874, 8872, + 1, 0, 0, 0, 8874, 8875, 1, 0, 0, 0, 8875, 841, 1, 0, 0, 0, 8876, 8874, + 1, 0, 0, 0, 8877, 8878, 5, 267, 0, 0, 8878, 8880, 3, 2282, 1141, 0, 8879, + 8877, 1, 0, 0, 0, 8879, 8880, 1, 0, 0, 0, 8880, 8890, 1, 0, 0, 0, 8881, + 8883, 5, 1121, 0, 0, 8882, 8881, 1, 0, 0, 0, 8882, 8883, 1, 0, 0, 0, 8883, + 8884, 1, 0, 0, 0, 8884, 8891, 5, 1145, 0, 0, 8885, 8891, 5, 2068, 0, 0, + 8886, 8887, 5, 1355, 0, 0, 8887, 8891, 5, 753, 0, 0, 8888, 8891, 3, 1736, + 868, 0, 8889, 8891, 3, 1726, 863, 0, 8890, 8882, 1, 0, 0, 0, 8890, 8885, + 1, 0, 0, 0, 8890, 8886, 1, 0, 0, 0, 8890, 8888, 1, 0, 0, 0, 8890, 8889, + 1, 0, 0, 0, 8891, 8893, 1, 0, 0, 0, 8892, 8894, 3, 850, 425, 0, 8893, 8892, + 1, 0, 0, 0, 8893, 8894, 1, 0, 0, 0, 8894, 843, 1, 0, 0, 0, 8895, 8896, + 5, 1529, 0, 0, 8896, 8897, 5, 723, 0, 0, 8897, 8909, 3, 2312, 1156, 0, + 8898, 8899, 5, 2188, 0, 0, 8899, 8909, 5, 1502, 0, 0, 8900, 8901, 5, 267, + 0, 0, 8901, 8903, 3, 2282, 1141, 0, 8902, 8900, 1, 0, 0, 0, 8902, 8903, + 1, 0, 0, 0, 8903, 8904, 1, 0, 0, 0, 8904, 8906, 3, 1736, 868, 0, 8905, + 8907, 3, 850, 425, 0, 8906, 8905, 1, 0, 0, 0, 8906, 8907, 1, 0, 0, 0, 8907, + 8909, 1, 0, 0, 0, 8908, 8895, 1, 0, 0, 0, 8908, 8898, 1, 0, 0, 0, 8908, + 8902, 1, 0, 0, 0, 8909, 845, 1, 0, 0, 0, 8910, 8911, 5, 1529, 0, 0, 8911, + 8912, 5, 564, 0, 0, 8912, 8913, 5, 2376, 0, 0, 8913, 8914, 3, 2382, 1191, + 0, 8914, 8915, 5, 2377, 0, 0, 8915, 8916, 5, 723, 0, 0, 8916, 8917, 3, + 2312, 1156, 0, 8917, 8946, 1, 0, 0, 0, 8918, 8919, 5, 1431, 0, 0, 8919, + 8920, 5, 2376, 0, 0, 8920, 8921, 3, 2382, 1191, 0, 8921, 8922, 5, 2377, + 0, 0, 8922, 8923, 5, 2188, 0, 0, 8923, 8924, 5, 1502, 0, 0, 8924, 8946, + 1, 0, 0, 0, 8925, 8926, 5, 267, 0, 0, 8926, 8928, 3, 2282, 1141, 0, 8927, + 8925, 1, 0, 0, 0, 8927, 8928, 1, 0, 0, 0, 8928, 8929, 1, 0, 0, 0, 8929, + 8930, 5, 562, 0, 0, 8930, 8931, 5, 753, 0, 0, 8931, 8936, 5, 2376, 0, 0, + 8932, 8934, 5, 2382, 0, 0, 8933, 8932, 1, 0, 0, 0, 8933, 8934, 1, 0, 0, + 0, 8934, 8935, 1, 0, 0, 0, 8935, 8937, 3, 2382, 1191, 0, 8936, 8933, 1, + 0, 0, 0, 8937, 8938, 1, 0, 0, 0, 8938, 8936, 1, 0, 0, 0, 8938, 8939, 1, + 0, 0, 0, 8939, 8940, 1, 0, 0, 0, 8940, 8941, 5, 2377, 0, 0, 8941, 8943, + 3, 1736, 868, 0, 8942, 8944, 3, 850, 425, 0, 8943, 8942, 1, 0, 0, 0, 8943, + 8944, 1, 0, 0, 0, 8944, 8946, 1, 0, 0, 0, 8945, 8910, 1, 0, 0, 0, 8945, + 8918, 1, 0, 0, 0, 8945, 8927, 1, 0, 0, 0, 8946, 847, 1, 0, 0, 0, 8947, + 8948, 5, 267, 0, 0, 8948, 8950, 3, 2282, 1141, 0, 8949, 8947, 1, 0, 0, + 0, 8949, 8950, 1, 0, 0, 0, 8950, 8982, 1, 0, 0, 0, 8951, 8952, 5, 2068, + 0, 0, 8952, 8953, 5, 2376, 0, 0, 8953, 8958, 3, 2310, 1155, 0, 8954, 8955, + 5, 2382, 0, 0, 8955, 8957, 3, 2310, 1155, 0, 8956, 8954, 1, 0, 0, 0, 8957, + 8960, 1, 0, 0, 0, 8958, 8956, 1, 0, 0, 0, 8958, 8959, 1, 0, 0, 0, 8959, + 8961, 1, 0, 0, 0, 8960, 8958, 1, 0, 0, 0, 8961, 8962, 5, 2377, 0, 0, 8962, + 8983, 1, 0, 0, 0, 8963, 8964, 5, 1355, 0, 0, 8964, 8965, 5, 753, 0, 0, + 8965, 8966, 5, 2376, 0, 0, 8966, 8971, 3, 2310, 1155, 0, 8967, 8968, 5, + 2382, 0, 0, 8968, 8970, 3, 2310, 1155, 0, 8969, 8967, 1, 0, 0, 0, 8970, + 8973, 1, 0, 0, 0, 8971, 8969, 1, 0, 0, 0, 8971, 8972, 1, 0, 0, 0, 8972, + 8974, 1, 0, 0, 0, 8973, 8971, 1, 0, 0, 0, 8974, 8975, 5, 2377, 0, 0, 8975, + 8983, 1, 0, 0, 0, 8976, 8983, 3, 1734, 867, 0, 8977, 8978, 5, 186, 0, 0, + 8978, 8979, 5, 2376, 0, 0, 8979, 8980, 3, 2072, 1036, 0, 8980, 8981, 5, + 2377, 0, 0, 8981, 8983, 1, 0, 0, 0, 8982, 8951, 1, 0, 0, 0, 8982, 8963, + 1, 0, 0, 0, 8982, 8976, 1, 0, 0, 0, 8982, 8977, 1, 0, 0, 0, 8983, 8985, + 1, 0, 0, 0, 8984, 8986, 3, 850, 425, 0, 8985, 8984, 1, 0, 0, 0, 8985, 8986, + 1, 0, 0, 0, 8986, 849, 1, 0, 0, 0, 8987, 8989, 5, 1121, 0, 0, 8988, 8987, + 1, 0, 0, 0, 8988, 8989, 1, 0, 0, 0, 8989, 8990, 1, 0, 0, 0, 8990, 8998, + 5, 367, 0, 0, 8991, 8992, 5, 684, 0, 0, 8992, 8998, 7, 87, 0, 0, 8993, + 8998, 7, 44, 0, 0, 8994, 8998, 7, 17, 0, 0, 8995, 8998, 7, 88, 0, 0, 8996, + 8998, 3, 1594, 797, 0, 8997, 8988, 1, 0, 0, 0, 8997, 8991, 1, 0, 0, 0, + 8997, 8993, 1, 0, 0, 0, 8997, 8994, 1, 0, 0, 0, 8997, 8995, 1, 0, 0, 0, + 8997, 8996, 1, 0, 0, 0, 8998, 8999, 1, 0, 0, 0, 8999, 8997, 1, 0, 0, 0, + 8999, 9000, 1, 0, 0, 0, 9000, 851, 1, 0, 0, 0, 9001, 9002, 5, 1163, 0, + 0, 9002, 9004, 5, 2229, 0, 0, 9003, 9005, 3, 854, 427, 0, 9004, 9003, 1, + 0, 0, 0, 9004, 9005, 1, 0, 0, 0, 9005, 9006, 1, 0, 0, 0, 9006, 9007, 5, + 2188, 0, 0, 9007, 9008, 5, 1155, 0, 0, 9008, 9021, 7, 86, 0, 0, 9009, 9022, + 5, 363, 0, 0, 9010, 9011, 5, 2376, 0, 0, 9011, 9016, 3, 2078, 1039, 0, + 9012, 9013, 5, 2382, 0, 0, 9013, 9015, 3, 2078, 1039, 0, 9014, 9012, 1, + 0, 0, 0, 9015, 9018, 1, 0, 0, 0, 9016, 9014, 1, 0, 0, 0, 9016, 9017, 1, + 0, 0, 0, 9017, 9019, 1, 0, 0, 0, 9018, 9016, 1, 0, 0, 0, 9019, 9020, 5, + 2377, 0, 0, 9020, 9022, 1, 0, 0, 0, 9021, 9009, 1, 0, 0, 0, 9021, 9010, + 1, 0, 0, 0, 9022, 853, 1, 0, 0, 0, 9023, 9024, 5, 2224, 0, 0, 9024, 9026, + 3, 856, 428, 0, 9025, 9023, 1, 0, 0, 0, 9025, 9026, 1, 0, 0, 0, 9026, 9027, + 1, 0, 0, 0, 9027, 9033, 5, 441, 0, 0, 9028, 9034, 3, 858, 429, 0, 9029, + 9030, 3, 856, 428, 0, 9030, 9031, 5, 2386, 0, 0, 9031, 9032, 3, 858, 429, + 0, 9032, 9034, 1, 0, 0, 0, 9033, 9028, 1, 0, 0, 0, 9033, 9029, 1, 0, 0, + 0, 9034, 9040, 1, 0, 0, 0, 9035, 9036, 5, 1656, 0, 0, 9036, 9037, 5, 37, + 0, 0, 9037, 9038, 5, 2146, 0, 0, 9038, 9039, 5, 66, 0, 0, 9039, 9041, 7, + 89, 0, 0, 9040, 9035, 1, 0, 0, 0, 9040, 9041, 1, 0, 0, 0, 9041, 9045, 1, + 0, 0, 0, 9042, 9043, 3, 1324, 662, 0, 9043, 9044, 5, 1058, 0, 0, 9044, + 9046, 1, 0, 0, 0, 9045, 9042, 1, 0, 0, 0, 9045, 9046, 1, 0, 0, 0, 9046, + 9050, 1, 0, 0, 0, 9047, 9048, 3, 1324, 662, 0, 9048, 9049, 5, 54, 0, 0, + 9049, 9051, 1, 0, 0, 0, 9050, 9047, 1, 0, 0, 0, 9050, 9051, 1, 0, 0, 0, + 9051, 855, 1, 0, 0, 0, 9052, 9053, 5, 2373, 0, 0, 9053, 857, 1, 0, 0, 0, + 9054, 9055, 5, 2373, 0, 0, 9055, 859, 1, 0, 0, 0, 9056, 9057, 5, 41, 0, + 0, 9057, 9058, 5, 1973, 0, 0, 9058, 9091, 3, 1666, 833, 0, 9059, 9061, + 5, 363, 0, 0, 9060, 9062, 3, 1172, 586, 0, 9061, 9060, 1, 0, 0, 0, 9061, + 9062, 1, 0, 0, 0, 9062, 9064, 1, 0, 0, 0, 9063, 9065, 3, 1190, 595, 0, + 9064, 9063, 1, 0, 0, 0, 9064, 9065, 1, 0, 0, 0, 9065, 9092, 1, 0, 0, 0, + 9066, 9067, 5, 883, 0, 0, 9067, 9068, 5, 505, 0, 0, 9068, 9092, 3, 1170, + 585, 0, 9069, 9070, 5, 1468, 0, 0, 9070, 9092, 3, 1170, 585, 0, 9071, 9092, + 5, 214, 0, 0, 9072, 9073, 5, 1580, 0, 0, 9073, 9076, 5, 1609, 0, 0, 9074, + 9075, 5, 751, 0, 0, 9075, 9077, 3, 1170, 585, 0, 9076, 9074, 1, 0, 0, 0, + 9076, 9077, 1, 0, 0, 0, 9077, 9092, 1, 0, 0, 0, 9078, 9079, 5, 1460, 0, + 0, 9079, 9080, 5, 2029, 0, 0, 9080, 9092, 3, 874, 437, 0, 9081, 9082, 3, + 1394, 697, 0, 9082, 9083, 5, 98, 0, 0, 9083, 9092, 1, 0, 0, 0, 9084, 9092, + 3, 862, 431, 0, 9085, 9092, 3, 864, 432, 0, 9086, 9092, 3, 866, 433, 0, + 9087, 9092, 3, 870, 435, 0, 9088, 9092, 3, 918, 459, 0, 9089, 9092, 3, + 872, 436, 0, 9090, 9092, 3, 892, 446, 0, 9091, 9059, 1, 0, 0, 0, 9091, + 9066, 1, 0, 0, 0, 9091, 9069, 1, 0, 0, 0, 9091, 9071, 1, 0, 0, 0, 9091, + 9072, 1, 0, 0, 0, 9091, 9078, 1, 0, 0, 0, 9091, 9081, 1, 0, 0, 0, 9091, + 9084, 1, 0, 0, 0, 9091, 9085, 1, 0, 0, 0, 9091, 9086, 1, 0, 0, 0, 9091, + 9087, 1, 0, 0, 0, 9091, 9088, 1, 0, 0, 0, 9091, 9089, 1, 0, 0, 0, 9091, + 9090, 1, 0, 0, 0, 9092, 9093, 1, 0, 0, 0, 9093, 9094, 5, 2396, 0, 0, 9094, + 861, 1, 0, 0, 0, 9095, 9098, 5, 20, 0, 0, 9096, 9099, 3, 910, 455, 0, 9097, + 9099, 3, 912, 456, 0, 9098, 9096, 1, 0, 0, 0, 9098, 9097, 1, 0, 0, 0, 9099, + 9142, 1, 0, 0, 0, 9100, 9101, 5, 425, 0, 0, 9101, 9104, 7, 90, 0, 0, 9102, + 9105, 3, 1472, 736, 0, 9103, 9105, 5, 2370, 0, 0, 9104, 9102, 1, 0, 0, + 0, 9104, 9103, 1, 0, 0, 0, 9105, 9108, 1, 0, 0, 0, 9106, 9107, 5, 751, + 0, 0, 9107, 9109, 3, 1170, 585, 0, 9108, 9106, 1, 0, 0, 0, 9108, 9109, + 1, 0, 0, 0, 9109, 9142, 1, 0, 0, 0, 9110, 9111, 5, 1580, 0, 0, 9111, 9114, + 5, 1982, 0, 0, 9112, 9115, 3, 1472, 736, 0, 9113, 9115, 5, 2370, 0, 0, + 9114, 9112, 1, 0, 0, 0, 9114, 9113, 1, 0, 0, 0, 9115, 9118, 1, 0, 0, 0, + 9116, 9117, 5, 751, 0, 0, 9117, 9119, 3, 1170, 585, 0, 9118, 9116, 1, 0, + 0, 0, 9118, 9119, 1, 0, 0, 0, 9119, 9142, 1, 0, 0, 0, 9120, 9121, 5, 1460, + 0, 0, 9121, 9122, 5, 331, 0, 0, 9122, 9127, 3, 1472, 736, 0, 9123, 9124, + 5, 2382, 0, 0, 9124, 9126, 3, 1472, 736, 0, 9125, 9123, 1, 0, 0, 0, 9126, + 9129, 1, 0, 0, 0, 9127, 9125, 1, 0, 0, 0, 9127, 9128, 1, 0, 0, 0, 9128, + 9130, 1, 0, 0, 0, 9129, 9127, 1, 0, 0, 0, 9130, 9131, 5, 2029, 0, 0, 9131, + 9136, 3, 1472, 736, 0, 9132, 9133, 5, 2382, 0, 0, 9133, 9135, 3, 1472, + 736, 0, 9134, 9132, 1, 0, 0, 0, 9135, 9138, 1, 0, 0, 0, 9136, 9134, 1, + 0, 0, 0, 9136, 9137, 1, 0, 0, 0, 9137, 9142, 1, 0, 0, 0, 9138, 9136, 1, + 0, 0, 0, 9139, 9140, 7, 90, 0, 0, 9140, 9142, 3, 678, 339, 0, 9141, 9095, + 1, 0, 0, 0, 9141, 9100, 1, 0, 0, 0, 9141, 9110, 1, 0, 0, 0, 9141, 9120, + 1, 0, 0, 0, 9141, 9139, 1, 0, 0, 0, 9142, 863, 1, 0, 0, 0, 9143, 9150, + 3, 882, 441, 0, 9144, 9146, 5, 1057, 0, 0, 9145, 9144, 1, 0, 0, 0, 9145, + 9146, 1, 0, 0, 0, 9146, 9147, 1, 0, 0, 0, 9147, 9148, 5, 560, 0, 0, 9148, + 9150, 5, 815, 0, 0, 9149, 9143, 1, 0, 0, 0, 9149, 9145, 1, 0, 0, 0, 9150, + 865, 1, 0, 0, 0, 9151, 9152, 5, 1973, 0, 0, 9152, 9155, 5, 593, 0, 0, 9153, + 9156, 3, 868, 434, 0, 9154, 9156, 5, 2372, 0, 0, 9155, 9153, 1, 0, 0, 0, + 9155, 9154, 1, 0, 0, 0, 9156, 867, 1, 0, 0, 0, 9157, 9158, 3, 2382, 1191, + 0, 9158, 869, 1, 0, 0, 0, 9159, 9169, 5, 1173, 0, 0, 9160, 9162, 5, 1160, + 0, 0, 9161, 9163, 7, 91, 0, 0, 9162, 9161, 1, 0, 0, 0, 9162, 9163, 1, 0, + 0, 0, 9163, 9169, 1, 0, 0, 0, 9164, 9165, 5, 1408, 0, 0, 9165, 9169, 7, + 11, 0, 0, 9166, 9169, 5, 1293, 0, 0, 9167, 9169, 5, 1984, 0, 0, 9168, 9159, + 1, 0, 0, 0, 9168, 9160, 1, 0, 0, 0, 9168, 9164, 1, 0, 0, 0, 9168, 9166, + 1, 0, 0, 0, 9168, 9167, 1, 0, 0, 0, 9169, 871, 1, 0, 0, 0, 9170, 9171, + 5, 549, 0, 0, 9171, 9172, 7, 92, 0, 0, 9172, 873, 1, 0, 0, 0, 9173, 9174, + 3, 1666, 833, 0, 9174, 875, 1, 0, 0, 0, 9175, 9177, 5, 301, 0, 0, 9176, + 9178, 7, 93, 0, 0, 9177, 9176, 1, 0, 0, 0, 9177, 9178, 1, 0, 0, 0, 9178, + 9182, 1, 0, 0, 0, 9179, 9183, 3, 878, 439, 0, 9180, 9183, 3, 888, 444, + 0, 9181, 9183, 3, 890, 445, 0, 9182, 9179, 1, 0, 0, 0, 9182, 9180, 1, 0, + 0, 0, 9182, 9181, 1, 0, 0, 0, 9183, 9184, 1, 0, 0, 0, 9184, 9185, 5, 2396, + 0, 0, 9185, 877, 1, 0, 0, 0, 9186, 9187, 5, 1973, 0, 0, 9187, 9189, 3, + 2378, 1189, 0, 9188, 9190, 3, 910, 455, 0, 9189, 9188, 1, 0, 0, 0, 9189, + 9190, 1, 0, 0, 0, 9190, 9208, 1, 0, 0, 0, 9191, 9192, 5, 883, 0, 0, 9192, + 9193, 5, 505, 0, 0, 9193, 9207, 3, 1170, 585, 0, 9194, 9195, 5, 137, 0, + 0, 9195, 9207, 3, 1170, 585, 0, 9196, 9207, 3, 882, 441, 0, 9197, 9198, + 5, 560, 0, 0, 9198, 9207, 5, 815, 0, 0, 9199, 9207, 7, 69, 0, 0, 9200, + 9201, 5, 458, 0, 0, 9201, 9207, 3, 880, 440, 0, 9202, 9207, 5, 363, 0, + 0, 9203, 9207, 3, 884, 442, 0, 9204, 9207, 3, 886, 443, 0, 9205, 9207, + 3, 872, 436, 0, 9206, 9191, 1, 0, 0, 0, 9206, 9194, 1, 0, 0, 0, 9206, 9196, + 1, 0, 0, 0, 9206, 9197, 1, 0, 0, 0, 9206, 9199, 1, 0, 0, 0, 9206, 9200, + 1, 0, 0, 0, 9206, 9202, 1, 0, 0, 0, 9206, 9203, 1, 0, 0, 0, 9206, 9204, + 1, 0, 0, 0, 9206, 9205, 1, 0, 0, 0, 9207, 9210, 1, 0, 0, 0, 9208, 9206, + 1, 0, 0, 0, 9208, 9209, 1, 0, 0, 0, 9209, 879, 1, 0, 0, 0, 9210, 9208, + 1, 0, 0, 0, 9211, 9212, 5, 2129, 0, 0, 9212, 9213, 5, 2372, 0, 0, 9213, + 881, 1, 0, 0, 0, 9214, 9215, 7, 94, 0, 0, 9215, 883, 1, 0, 0, 0, 9216, + 9217, 5, 505, 0, 0, 9217, 9218, 5, 836, 0, 0, 9218, 9225, 5, 804, 0, 0, + 9219, 9226, 5, 87, 0, 0, 9220, 9223, 5, 2066, 0, 0, 9221, 9222, 5, 1595, + 0, 0, 9222, 9224, 3, 1170, 585, 0, 9223, 9221, 1, 0, 0, 0, 9223, 9224, + 1, 0, 0, 0, 9224, 9226, 1, 0, 0, 0, 9225, 9219, 1, 0, 0, 0, 9225, 9220, + 1, 0, 0, 0, 9225, 9226, 1, 0, 0, 0, 9226, 885, 1, 0, 0, 0, 9227, 9228, + 5, 1546, 0, 0, 9228, 9229, 5, 1609, 0, 0, 9229, 9230, 5, 836, 0, 0, 9230, + 9231, 7, 95, 0, 0, 9231, 887, 1, 0, 0, 0, 9232, 9233, 5, 1984, 0, 0, 9233, + 9234, 5, 1973, 0, 0, 9234, 9236, 3, 2378, 1189, 0, 9235, 9237, 3, 912, + 456, 0, 9236, 9235, 1, 0, 0, 0, 9236, 9237, 1, 0, 0, 0, 9237, 9239, 1, + 0, 0, 0, 9238, 9240, 3, 866, 433, 0, 9239, 9238, 1, 0, 0, 0, 9239, 9240, + 1, 0, 0, 0, 9240, 9242, 1, 0, 0, 0, 9241, 9243, 3, 884, 442, 0, 9242, 9241, + 1, 0, 0, 0, 9242, 9243, 1, 0, 0, 0, 9243, 889, 1, 0, 0, 0, 9244, 9245, + 5, 2064, 0, 0, 9245, 9246, 5, 1973, 0, 0, 9246, 9248, 3, 2378, 1189, 0, + 9247, 9249, 3, 910, 455, 0, 9248, 9247, 1, 0, 0, 0, 9248, 9249, 1, 0, 0, + 0, 9249, 9251, 1, 0, 0, 0, 9250, 9252, 3, 884, 442, 0, 9251, 9250, 1, 0, + 0, 0, 9251, 9252, 1, 0, 0, 0, 9252, 9254, 1, 0, 0, 0, 9253, 9255, 3, 892, + 446, 0, 9254, 9253, 1, 0, 0, 0, 9254, 9255, 1, 0, 0, 0, 9255, 891, 1, 0, + 0, 0, 9256, 9257, 5, 1484, 0, 0, 9257, 9258, 7, 96, 0, 0, 9258, 893, 1, + 0, 0, 0, 9259, 9260, 5, 301, 0, 0, 9260, 9261, 5, 1973, 0, 0, 9261, 9262, + 5, 1568, 0, 0, 9262, 9266, 3, 2378, 1189, 0, 9263, 9264, 5, 680, 0, 0, + 9264, 9265, 5, 1573, 0, 0, 9265, 9267, 3, 2378, 1189, 0, 9266, 9263, 1, + 0, 0, 0, 9266, 9267, 1, 0, 0, 0, 9267, 9289, 1, 0, 0, 0, 9268, 9269, 5, + 2129, 0, 0, 9269, 9270, 5, 1983, 0, 0, 9270, 9280, 5, 2376, 0, 0, 9271, + 9272, 5, 331, 0, 0, 9272, 9277, 3, 432, 216, 0, 9273, 9274, 5, 2382, 0, + 0, 9274, 9276, 3, 432, 216, 0, 9275, 9273, 1, 0, 0, 0, 9276, 9279, 1, 0, + 0, 0, 9277, 9275, 1, 0, 0, 0, 9277, 9278, 1, 0, 0, 0, 9278, 9281, 1, 0, + 0, 0, 9279, 9277, 1, 0, 0, 0, 9280, 9271, 1, 0, 0, 0, 9280, 9281, 1, 0, + 0, 0, 9281, 9283, 1, 0, 0, 0, 9282, 9284, 3, 896, 448, 0, 9283, 9282, 1, + 0, 0, 0, 9284, 9285, 1, 0, 0, 0, 9285, 9283, 1, 0, 0, 0, 9285, 9286, 1, + 0, 0, 0, 9286, 9287, 1, 0, 0, 0, 9287, 9288, 5, 2377, 0, 0, 9288, 9290, + 1, 0, 0, 0, 9289, 9268, 1, 0, 0, 0, 9289, 9290, 1, 0, 0, 0, 9290, 895, + 1, 0, 0, 0, 9291, 9292, 5, 883, 0, 0, 9292, 9293, 5, 505, 0, 0, 9293, 9311, + 3, 1170, 585, 0, 9294, 9295, 5, 137, 0, 0, 9295, 9297, 3, 2368, 1184, 0, + 9296, 9298, 5, 749, 0, 0, 9297, 9296, 1, 0, 0, 0, 9297, 9298, 1, 0, 0, + 0, 9298, 9311, 1, 0, 0, 0, 9299, 9311, 3, 882, 441, 0, 9300, 9301, 5, 560, + 0, 0, 9301, 9311, 5, 815, 0, 0, 9302, 9311, 3, 898, 449, 0, 9303, 9311, + 3, 900, 450, 0, 9304, 9311, 5, 1173, 0, 0, 9305, 9311, 5, 1160, 0, 0, 9306, + 9311, 3, 884, 442, 0, 9307, 9311, 3, 886, 443, 0, 9308, 9311, 3, 872, 436, + 0, 9309, 9311, 3, 1478, 739, 0, 9310, 9291, 1, 0, 0, 0, 9310, 9294, 1, + 0, 0, 0, 9310, 9299, 1, 0, 0, 0, 9310, 9300, 1, 0, 0, 0, 9310, 9302, 1, + 0, 0, 0, 9310, 9303, 1, 0, 0, 0, 9310, 9304, 1, 0, 0, 0, 9310, 9305, 1, + 0, 0, 0, 9310, 9306, 1, 0, 0, 0, 9310, 9307, 1, 0, 0, 0, 9310, 9308, 1, + 0, 0, 0, 9310, 9309, 1, 0, 0, 0, 9311, 897, 1, 0, 0, 0, 9312, 9318, 5, + 458, 0, 0, 9313, 9315, 3, 880, 440, 0, 9314, 9313, 1, 0, 0, 0, 9314, 9315, + 1, 0, 0, 0, 9315, 9316, 1, 0, 0, 0, 9316, 9319, 5, 457, 0, 0, 9317, 9319, + 5, 361, 0, 0, 9318, 9314, 1, 0, 0, 0, 9318, 9317, 1, 0, 0, 0, 9319, 899, + 1, 0, 0, 0, 9320, 9322, 5, 363, 0, 0, 9321, 9323, 3, 902, 451, 0, 9322, + 9321, 1, 0, 0, 0, 9322, 9323, 1, 0, 0, 0, 9323, 9325, 1, 0, 0, 0, 9324, + 9326, 3, 906, 453, 0, 9325, 9324, 1, 0, 0, 0, 9325, 9326, 1, 0, 0, 0, 9326, + 9328, 1, 0, 0, 0, 9327, 9329, 3, 908, 454, 0, 9328, 9327, 1, 0, 0, 0, 9328, + 9329, 1, 0, 0, 0, 9329, 9331, 1, 0, 0, 0, 9330, 9332, 3, 1198, 599, 0, + 9331, 9330, 1, 0, 0, 0, 9331, 9332, 1, 0, 0, 0, 9332, 9334, 1, 0, 0, 0, + 9333, 9335, 3, 1190, 595, 0, 9334, 9333, 1, 0, 0, 0, 9334, 9335, 1, 0, + 0, 0, 9335, 901, 1, 0, 0, 0, 9336, 9347, 5, 1976, 0, 0, 9337, 9338, 5, + 242, 0, 0, 9338, 9344, 5, 564, 0, 0, 9339, 9345, 5, 1170, 0, 0, 9340, 9341, + 5, 1388, 0, 0, 9341, 9345, 3, 904, 452, 0, 9342, 9343, 5, 62, 0, 0, 9343, + 9345, 3, 904, 452, 0, 9344, 9339, 1, 0, 0, 0, 9344, 9340, 1, 0, 0, 0, 9344, + 9342, 1, 0, 0, 0, 9345, 9348, 1, 0, 0, 0, 9346, 9348, 5, 1000, 0, 0, 9347, + 9337, 1, 0, 0, 0, 9347, 9346, 1, 0, 0, 0, 9348, 903, 1, 0, 0, 0, 9349, + 9350, 7, 97, 0, 0, 9350, 905, 1, 0, 0, 0, 9351, 9356, 5, 659, 0, 0, 9352, + 9353, 5, 242, 0, 0, 9353, 9354, 5, 28, 0, 0, 9354, 9357, 3, 904, 452, 0, + 9355, 9357, 5, 1000, 0, 0, 9356, 9352, 1, 0, 0, 0, 9356, 9355, 1, 0, 0, + 0, 9357, 907, 1, 0, 0, 0, 9358, 9360, 5, 688, 0, 0, 9359, 9361, 3, 1176, + 588, 0, 9360, 9359, 1, 0, 0, 0, 9360, 9361, 1, 0, 0, 0, 9361, 9386, 1, + 0, 0, 0, 9362, 9384, 5, 1987, 0, 0, 9363, 9368, 3, 2310, 1155, 0, 9364, + 9365, 5, 2382, 0, 0, 9365, 9367, 3, 2310, 1155, 0, 9366, 9364, 1, 0, 0, + 0, 9367, 9370, 1, 0, 0, 0, 9368, 9366, 1, 0, 0, 0, 9368, 9369, 1, 0, 0, + 0, 9369, 9385, 1, 0, 0, 0, 9370, 9368, 1, 0, 0, 0, 9371, 9372, 3, 2310, + 1155, 0, 9372, 9373, 5, 2129, 0, 0, 9373, 9381, 3, 714, 357, 0, 9374, 9375, + 5, 2382, 0, 0, 9375, 9376, 3, 2310, 1155, 0, 9376, 9377, 5, 2129, 0, 0, + 9377, 9378, 3, 714, 357, 0, 9378, 9380, 1, 0, 0, 0, 9379, 9374, 1, 0, 0, + 0, 9380, 9383, 1, 0, 0, 0, 9381, 9379, 1, 0, 0, 0, 9381, 9382, 1, 0, 0, + 0, 9382, 9385, 1, 0, 0, 0, 9383, 9381, 1, 0, 0, 0, 9384, 9363, 1, 0, 0, + 0, 9384, 9371, 1, 0, 0, 0, 9385, 9387, 1, 0, 0, 0, 9386, 9362, 1, 0, 0, + 0, 9386, 9387, 1, 0, 0, 0, 9387, 9391, 1, 0, 0, 0, 9388, 9389, 5, 1057, + 0, 0, 9389, 9391, 5, 688, 0, 0, 9390, 9358, 1, 0, 0, 0, 9390, 9388, 1, + 0, 0, 0, 9391, 909, 1, 0, 0, 0, 9392, 9394, 5, 331, 0, 0, 9393, 9395, 5, + 2382, 0, 0, 9394, 9393, 1, 0, 0, 0, 9394, 9395, 1, 0, 0, 0, 9395, 9396, + 1, 0, 0, 0, 9396, 9397, 3, 914, 457, 0, 9397, 911, 1, 0, 0, 0, 9398, 9400, + 5, 1982, 0, 0, 9399, 9401, 5, 2382, 0, 0, 9400, 9399, 1, 0, 0, 0, 9400, + 9401, 1, 0, 0, 0, 9401, 9402, 1, 0, 0, 0, 9402, 9403, 3, 914, 457, 0, 9403, + 913, 1, 0, 0, 0, 9404, 9406, 5, 2372, 0, 0, 9405, 9404, 1, 0, 0, 0, 9405, + 9406, 1, 0, 0, 0, 9406, 9409, 1, 0, 0, 0, 9407, 9408, 5, 1595, 0, 0, 9408, + 9410, 3, 1170, 585, 0, 9409, 9407, 1, 0, 0, 0, 9409, 9410, 1, 0, 0, 0, + 9410, 9412, 1, 0, 0, 0, 9411, 9413, 5, 1488, 0, 0, 9412, 9411, 1, 0, 0, + 0, 9412, 9413, 1, 0, 0, 0, 9413, 9415, 1, 0, 0, 0, 9414, 9416, 3, 918, + 459, 0, 9415, 9414, 1, 0, 0, 0, 9415, 9416, 1, 0, 0, 0, 9416, 915, 1, 0, + 0, 0, 9417, 9430, 3, 1472, 736, 0, 9418, 9419, 5, 2376, 0, 0, 9419, 9424, + 3, 1472, 736, 0, 9420, 9421, 5, 2382, 0, 0, 9421, 9423, 3, 1472, 736, 0, + 9422, 9420, 1, 0, 0, 0, 9423, 9426, 1, 0, 0, 0, 9424, 9422, 1, 0, 0, 0, + 9424, 9425, 1, 0, 0, 0, 9425, 9427, 1, 0, 0, 0, 9426, 9424, 1, 0, 0, 0, + 9427, 9428, 5, 2377, 0, 0, 9428, 9430, 1, 0, 0, 0, 9429, 9417, 1, 0, 0, + 0, 9429, 9418, 1, 0, 0, 0, 9430, 9433, 1, 0, 0, 0, 9431, 9432, 5, 1595, + 0, 0, 9432, 9434, 3, 1170, 585, 0, 9433, 9431, 1, 0, 0, 0, 9433, 9434, + 1, 0, 0, 0, 9434, 9437, 1, 0, 0, 0, 9435, 9436, 5, 137, 0, 0, 9436, 9438, + 3, 1170, 585, 0, 9437, 9435, 1, 0, 0, 0, 9437, 9438, 1, 0, 0, 0, 9438, + 9440, 1, 0, 0, 0, 9439, 9441, 5, 1488, 0, 0, 9440, 9439, 1, 0, 0, 0, 9440, + 9441, 1, 0, 0, 0, 9441, 917, 1, 0, 0, 0, 9442, 9452, 5, 89, 0, 0, 9443, + 9453, 5, 1161, 0, 0, 9444, 9447, 5, 1175, 0, 0, 9445, 9446, 5, 953, 0, + 0, 9446, 9448, 3, 1170, 585, 0, 9447, 9445, 1, 0, 0, 0, 9447, 9448, 1, + 0, 0, 0, 9448, 9450, 1, 0, 0, 0, 9449, 9451, 3, 920, 460, 0, 9450, 9449, + 1, 0, 0, 0, 9450, 9451, 1, 0, 0, 0, 9451, 9453, 1, 0, 0, 0, 9452, 9443, + 1, 0, 0, 0, 9452, 9444, 1, 0, 0, 0, 9453, 919, 1, 0, 0, 0, 9454, 9457, + 5, 859, 0, 0, 9455, 9458, 5, 2070, 0, 0, 9456, 9458, 3, 1170, 585, 0, 9457, + 9455, 1, 0, 0, 0, 9457, 9456, 1, 0, 0, 0, 9458, 921, 1, 0, 0, 0, 9459, + 9460, 5, 149, 0, 0, 9460, 9461, 7, 87, 0, 0, 9461, 923, 1, 0, 0, 0, 9462, + 9463, 5, 660, 0, 0, 9463, 9464, 7, 98, 0, 0, 9464, 925, 1, 0, 0, 0, 9465, + 9471, 5, 1068, 0, 0, 9466, 9468, 5, 1243, 0, 0, 9467, 9469, 5, 2370, 0, + 0, 9468, 9467, 1, 0, 0, 0, 9468, 9469, 1, 0, 0, 0, 9469, 9471, 1, 0, 0, + 0, 9470, 9465, 1, 0, 0, 0, 9470, 9466, 1, 0, 0, 0, 9471, 927, 1, 0, 0, + 0, 9472, 9473, 5, 41, 0, 0, 9473, 9474, 5, 848, 0, 0, 9474, 9475, 5, 2166, + 0, 0, 9475, 9501, 3, 2312, 1156, 0, 9476, 9502, 3, 1188, 594, 0, 9477, + 9502, 3, 936, 468, 0, 9478, 9502, 3, 1172, 586, 0, 9479, 9484, 3, 1650, + 825, 0, 9480, 9481, 5, 2382, 0, 0, 9481, 9483, 3, 1650, 825, 0, 9482, 9480, + 1, 0, 0, 0, 9483, 9486, 1, 0, 0, 0, 9484, 9482, 1, 0, 0, 0, 9484, 9485, + 1, 0, 0, 0, 9485, 9502, 1, 0, 0, 0, 9486, 9484, 1, 0, 0, 0, 9487, 9492, + 3, 1652, 826, 0, 9488, 9489, 5, 2382, 0, 0, 9489, 9491, 3, 1652, 826, 0, + 9490, 9488, 1, 0, 0, 0, 9491, 9494, 1, 0, 0, 0, 9492, 9490, 1, 0, 0, 0, + 9492, 9493, 1, 0, 0, 0, 9493, 9502, 1, 0, 0, 0, 9494, 9492, 1, 0, 0, 0, + 9495, 9502, 3, 926, 463, 0, 9496, 9502, 3, 882, 441, 0, 9497, 9502, 3, + 1298, 649, 0, 9498, 9502, 3, 1300, 650, 0, 9499, 9502, 3, 1302, 651, 0, + 9500, 9502, 3, 1378, 689, 0, 9501, 9476, 1, 0, 0, 0, 9501, 9477, 1, 0, + 0, 0, 9501, 9478, 1, 0, 0, 0, 9501, 9479, 1, 0, 0, 0, 9501, 9487, 1, 0, + 0, 0, 9501, 9495, 1, 0, 0, 0, 9501, 9496, 1, 0, 0, 0, 9501, 9497, 1, 0, + 0, 0, 9501, 9498, 1, 0, 0, 0, 9501, 9499, 1, 0, 0, 0, 9501, 9500, 1, 0, + 0, 0, 9501, 9502, 1, 0, 0, 0, 9502, 9504, 1, 0, 0, 0, 9503, 9505, 3, 1572, + 786, 0, 9504, 9503, 1, 0, 0, 0, 9504, 9505, 1, 0, 0, 0, 9505, 9509, 1, + 0, 0, 0, 9506, 9507, 5, 2129, 0, 0, 9507, 9508, 5, 659, 0, 0, 9508, 9510, + 3, 1188, 594, 0, 9509, 9506, 1, 0, 0, 0, 9509, 9510, 1, 0, 0, 0, 9510, + 9512, 1, 0, 0, 0, 9511, 9513, 3, 930, 465, 0, 9512, 9511, 1, 0, 0, 0, 9512, + 9513, 1, 0, 0, 0, 9513, 9521, 1, 0, 0, 0, 9514, 9515, 3, 1322, 661, 0, + 9515, 9516, 5, 1388, 0, 0, 9516, 9517, 5, 1492, 0, 0, 9517, 9522, 1, 0, + 0, 0, 9518, 9522, 5, 233, 0, 0, 9519, 9520, 5, 263, 0, 0, 9520, 9522, 5, + 571, 0, 0, 9521, 9514, 1, 0, 0, 0, 9521, 9518, 1, 0, 0, 0, 9521, 9519, + 1, 0, 0, 0, 9521, 9522, 1, 0, 0, 0, 9522, 9523, 1, 0, 0, 0, 9523, 9524, + 5, 2396, 0, 0, 9524, 929, 1, 0, 0, 0, 9525, 9526, 3, 932, 466, 0, 9526, + 931, 1, 0, 0, 0, 9527, 9554, 5, 1432, 0, 0, 9528, 9555, 5, 525, 0, 0, 9529, + 9555, 5, 234, 0, 0, 9530, 9555, 5, 560, 0, 0, 9531, 9532, 5, 1175, 0, 0, + 9532, 9555, 7, 99, 0, 0, 9533, 9534, 5, 1631, 0, 0, 9534, 9535, 5, 2188, + 0, 0, 9535, 9555, 3, 2078, 1039, 0, 9536, 9537, 5, 953, 0, 0, 9537, 9555, + 3, 2078, 1039, 0, 9538, 9539, 5, 2188, 0, 0, 9539, 9540, 5, 1355, 0, 0, + 9540, 9555, 5, 753, 0, 0, 9541, 9543, 5, 2129, 0, 0, 9542, 9544, 5, 363, + 0, 0, 9543, 9542, 1, 0, 0, 0, 9543, 9544, 1, 0, 0, 0, 9544, 9545, 1, 0, + 0, 0, 9545, 9546, 5, 842, 0, 0, 9546, 9547, 5, 1497, 0, 0, 9547, 9549, + 5, 1546, 0, 0, 9548, 9550, 3, 934, 467, 0, 9549, 9548, 1, 0, 0, 0, 9549, + 9550, 1, 0, 0, 0, 9550, 9555, 1, 0, 0, 0, 9551, 9552, 5, 2129, 0, 0, 9552, + 9553, 7, 100, 0, 0, 9553, 9555, 5, 268, 0, 0, 9554, 9528, 1, 0, 0, 0, 9554, + 9529, 1, 0, 0, 0, 9554, 9530, 1, 0, 0, 0, 9554, 9531, 1, 0, 0, 0, 9554, + 9533, 1, 0, 0, 0, 9554, 9536, 1, 0, 0, 0, 9554, 9538, 1, 0, 0, 0, 9554, + 9541, 1, 0, 0, 0, 9554, 9551, 1, 0, 0, 0, 9555, 9556, 1, 0, 0, 0, 9556, + 9554, 1, 0, 0, 0, 9556, 9557, 1, 0, 0, 0, 9557, 933, 1, 0, 0, 0, 9558, + 9559, 3, 2382, 1191, 0, 9559, 935, 1, 0, 0, 0, 9560, 9561, 5, 909, 0, 0, + 9561, 9562, 5, 2376, 0, 0, 9562, 9566, 3, 2310, 1155, 0, 9563, 9564, 5, + 457, 0, 0, 9564, 9567, 3, 1664, 832, 0, 9565, 9567, 5, 361, 0, 0, 9566, + 9563, 1, 0, 0, 0, 9566, 9565, 1, 0, 0, 0, 9566, 9567, 1, 0, 0, 0, 9567, + 9568, 1, 0, 0, 0, 9568, 9569, 5, 2377, 0, 0, 9569, 937, 1, 0, 0, 0, 9570, + 9571, 5, 41, 0, 0, 9571, 9572, 5, 848, 0, 0, 9572, 9573, 5, 2166, 0, 0, + 9573, 9575, 5, 819, 0, 0, 9574, 9576, 5, 560, 0, 0, 9575, 9574, 1, 0, 0, + 0, 9575, 9576, 1, 0, 0, 0, 9576, 9577, 1, 0, 0, 0, 9577, 9578, 5, 1175, + 0, 0, 9578, 9587, 3, 2312, 1156, 0, 9579, 9588, 3, 1188, 594, 0, 9580, + 9588, 3, 940, 470, 0, 9581, 9588, 3, 926, 463, 0, 9582, 9588, 3, 882, 441, + 0, 9583, 9588, 3, 1298, 649, 0, 9584, 9588, 3, 1302, 651, 0, 9585, 9588, + 3, 942, 471, 0, 9586, 9588, 3, 1378, 689, 0, 9587, 9579, 1, 0, 0, 0, 9587, + 9580, 1, 0, 0, 0, 9587, 9581, 1, 0, 0, 0, 9587, 9582, 1, 0, 0, 0, 9587, + 9583, 1, 0, 0, 0, 9587, 9584, 1, 0, 0, 0, 9587, 9585, 1, 0, 0, 0, 9587, + 9586, 1, 0, 0, 0, 9587, 9588, 1, 0, 0, 0, 9588, 9590, 1, 0, 0, 0, 9589, + 9591, 3, 944, 472, 0, 9590, 9589, 1, 0, 0, 0, 9590, 9591, 1, 0, 0, 0, 9591, + 9593, 1, 0, 0, 0, 9592, 9594, 3, 958, 479, 0, 9593, 9592, 1, 0, 0, 0, 9593, + 9594, 1, 0, 0, 0, 9594, 9595, 1, 0, 0, 0, 9595, 9596, 5, 2396, 0, 0, 9596, + 939, 1, 0, 0, 0, 9597, 9598, 5, 20, 0, 0, 9598, 9599, 5, 2376, 0, 0, 9599, + 9600, 3, 2310, 1155, 0, 9600, 9601, 5, 2377, 0, 0, 9601, 941, 1, 0, 0, + 0, 9602, 9603, 5, 921, 0, 0, 9603, 9605, 3, 1194, 597, 0, 9604, 9606, 3, + 926, 463, 0, 9605, 9604, 1, 0, 0, 0, 9605, 9606, 1, 0, 0, 0, 9606, 943, + 1, 0, 0, 0, 9607, 9640, 5, 20, 0, 0, 9608, 9609, 5, 1155, 0, 0, 9609, 9615, + 5, 632, 0, 0, 9610, 9611, 5, 1355, 0, 0, 9611, 9615, 5, 753, 0, 0, 9612, + 9615, 5, 1502, 0, 0, 9613, 9615, 5, 1554, 0, 0, 9614, 9608, 1, 0, 0, 0, + 9614, 9610, 1, 0, 0, 0, 9614, 9612, 1, 0, 0, 0, 9614, 9613, 1, 0, 0, 0, + 9615, 9627, 1, 0, 0, 0, 9616, 9617, 5, 2376, 0, 0, 9617, 9622, 3, 2310, + 1155, 0, 9618, 9619, 5, 2382, 0, 0, 9619, 9621, 3, 2310, 1155, 0, 9620, + 9618, 1, 0, 0, 0, 9621, 9624, 1, 0, 0, 0, 9622, 9620, 1, 0, 0, 0, 9622, + 9623, 1, 0, 0, 0, 9623, 9625, 1, 0, 0, 0, 9624, 9622, 1, 0, 0, 0, 9625, + 9626, 5, 2377, 0, 0, 9626, 9628, 1, 0, 0, 0, 9627, 9616, 1, 0, 0, 0, 9627, + 9628, 1, 0, 0, 0, 9628, 9641, 1, 0, 0, 0, 9629, 9630, 5, 2376, 0, 0, 9630, + 9635, 3, 2310, 1155, 0, 9631, 9632, 5, 2382, 0, 0, 9632, 9634, 3, 2310, + 1155, 0, 9633, 9631, 1, 0, 0, 0, 9634, 9637, 1, 0, 0, 0, 9635, 9633, 1, + 0, 0, 0, 9635, 9636, 1, 0, 0, 0, 9636, 9638, 1, 0, 0, 0, 9637, 9635, 1, + 0, 0, 0, 9638, 9639, 5, 2377, 0, 0, 9639, 9641, 1, 0, 0, 0, 9640, 9614, + 1, 0, 0, 0, 9640, 9629, 1, 0, 0, 0, 9641, 9643, 1, 0, 0, 0, 9642, 9644, + 3, 956, 478, 0, 9643, 9642, 1, 0, 0, 0, 9643, 9644, 1, 0, 0, 0, 9644, 945, + 1, 0, 0, 0, 9645, 9646, 3, 2078, 1039, 0, 9646, 947, 1, 0, 0, 0, 9647, + 9648, 3, 2078, 1039, 0, 9648, 949, 1, 0, 0, 0, 9649, 9650, 7, 101, 0, 0, + 9650, 951, 1, 0, 0, 0, 9651, 9652, 7, 102, 0, 0, 9652, 953, 1, 0, 0, 0, + 9653, 9654, 5, 301, 0, 0, 9654, 9655, 5, 848, 0, 0, 9655, 9656, 5, 2166, + 0, 0, 9656, 9657, 5, 819, 0, 0, 9657, 9658, 5, 1175, 0, 0, 9658, 9668, + 3, 2312, 1156, 0, 9659, 9665, 3, 1188, 594, 0, 9660, 9661, 5, 1973, 0, + 0, 9661, 9665, 3, 2378, 1189, 0, 9662, 9665, 3, 882, 441, 0, 9663, 9665, + 7, 103, 0, 0, 9664, 9659, 1, 0, 0, 0, 9664, 9660, 1, 0, 0, 0, 9664, 9662, + 1, 0, 0, 0, 9664, 9663, 1, 0, 0, 0, 9665, 9666, 1, 0, 0, 0, 9666, 9664, + 1, 0, 0, 0, 9666, 9667, 1, 0, 0, 0, 9667, 9669, 1, 0, 0, 0, 9668, 9664, + 1, 0, 0, 0, 9668, 9669, 1, 0, 0, 0, 9669, 9671, 1, 0, 0, 0, 9670, 9672, + 3, 926, 463, 0, 9671, 9670, 1, 0, 0, 0, 9671, 9672, 1, 0, 0, 0, 9672, 9712, + 1, 0, 0, 0, 9673, 9689, 5, 2188, 0, 0, 9674, 9676, 5, 2382, 0, 0, 9675, + 9674, 1, 0, 0, 0, 9675, 9676, 1, 0, 0, 0, 9676, 9685, 1, 0, 0, 0, 9677, + 9678, 5, 1155, 0, 0, 9678, 9686, 5, 632, 0, 0, 9679, 9680, 5, 1355, 0, + 0, 9680, 9686, 5, 753, 0, 0, 9681, 9686, 5, 1502, 0, 0, 9682, 9686, 5, + 1554, 0, 0, 9683, 9684, 5, 227, 0, 0, 9684, 9686, 5, 1528, 0, 0, 9685, + 9677, 1, 0, 0, 0, 9685, 9679, 1, 0, 0, 0, 9685, 9681, 1, 0, 0, 0, 9685, + 9682, 1, 0, 0, 0, 9685, 9683, 1, 0, 0, 0, 9686, 9688, 1, 0, 0, 0, 9687, + 9675, 1, 0, 0, 0, 9688, 9691, 1, 0, 0, 0, 9689, 9687, 1, 0, 0, 0, 9689, + 9690, 1, 0, 0, 0, 9690, 9705, 1, 0, 0, 0, 9691, 9689, 1, 0, 0, 0, 9692, + 9697, 5, 2376, 0, 0, 9693, 9695, 5, 2382, 0, 0, 9694, 9693, 1, 0, 0, 0, + 9694, 9695, 1, 0, 0, 0, 9695, 9696, 1, 0, 0, 0, 9696, 9698, 3, 2382, 1191, + 0, 9697, 9694, 1, 0, 0, 0, 9698, 9699, 1, 0, 0, 0, 9699, 9697, 1, 0, 0, + 0, 9699, 9700, 1, 0, 0, 0, 9700, 9701, 1, 0, 0, 0, 9701, 9703, 5, 2377, + 0, 0, 9702, 9704, 3, 956, 478, 0, 9703, 9702, 1, 0, 0, 0, 9703, 9704, 1, + 0, 0, 0, 9704, 9706, 1, 0, 0, 0, 9705, 9692, 1, 0, 0, 0, 9705, 9706, 1, + 0, 0, 0, 9706, 9708, 1, 0, 0, 0, 9707, 9709, 3, 958, 479, 0, 9708, 9707, + 1, 0, 0, 0, 9708, 9709, 1, 0, 0, 0, 9709, 9711, 1, 0, 0, 0, 9710, 9673, + 1, 0, 0, 0, 9711, 9714, 1, 0, 0, 0, 9712, 9710, 1, 0, 0, 0, 9712, 9713, + 1, 0, 0, 0, 9713, 955, 1, 0, 0, 0, 9714, 9712, 1, 0, 0, 0, 9715, 9716, + 7, 102, 0, 0, 9716, 9717, 5, 950, 0, 0, 9717, 9718, 5, 2140, 0, 0, 9718, + 957, 1, 0, 0, 0, 9719, 9720, 5, 1379, 0, 0, 9720, 9722, 5, 640, 0, 0, 9721, + 9723, 7, 101, 0, 0, 9722, 9721, 1, 0, 0, 0, 9722, 9723, 1, 0, 0, 0, 9723, + 959, 1, 0, 0, 0, 9724, 9725, 5, 301, 0, 0, 9725, 9726, 5, 848, 0, 0, 9726, + 9727, 5, 2238, 0, 0, 9727, 9732, 3, 970, 485, 0, 9728, 9729, 5, 2376, 0, + 0, 9729, 9730, 3, 2328, 1164, 0, 9730, 9731, 5, 2377, 0, 0, 9731, 9733, + 1, 0, 0, 0, 9732, 9728, 1, 0, 0, 0, 9732, 9733, 1, 0, 0, 0, 9733, 9735, + 1, 0, 0, 0, 9734, 9736, 3, 968, 484, 0, 9735, 9734, 1, 0, 0, 0, 9735, 9736, + 1, 0, 0, 0, 9736, 9738, 1, 0, 0, 0, 9737, 9739, 3, 966, 483, 0, 9738, 9737, + 1, 0, 0, 0, 9738, 9739, 1, 0, 0, 0, 9739, 9742, 1, 0, 0, 0, 9740, 9741, + 7, 17, 0, 0, 9741, 9743, 5, 1376, 0, 0, 9742, 9740, 1, 0, 0, 0, 9742, 9743, + 1, 0, 0, 0, 9743, 9746, 1, 0, 0, 0, 9744, 9747, 3, 976, 488, 0, 9745, 9747, + 3, 978, 489, 0, 9746, 9744, 1, 0, 0, 0, 9746, 9745, 1, 0, 0, 0, 9747, 961, + 1, 0, 0, 0, 9748, 9749, 5, 41, 0, 0, 9749, 9750, 5, 848, 0, 0, 9750, 9751, + 5, 2238, 0, 0, 9751, 9759, 3, 970, 485, 0, 9752, 9760, 3, 968, 484, 0, + 9753, 9760, 3, 966, 483, 0, 9754, 9755, 7, 17, 0, 0, 9755, 9760, 5, 1376, + 0, 0, 9756, 9760, 5, 233, 0, 0, 9757, 9760, 5, 1413, 0, 0, 9758, 9760, + 5, 2087, 0, 0, 9759, 9752, 1, 0, 0, 0, 9759, 9753, 1, 0, 0, 0, 9759, 9754, + 1, 0, 0, 0, 9759, 9756, 1, 0, 0, 0, 9759, 9757, 1, 0, 0, 0, 9759, 9758, + 1, 0, 0, 0, 9760, 963, 1, 0, 0, 0, 9761, 9762, 5, 425, 0, 0, 9762, 9763, + 5, 848, 0, 0, 9763, 9764, 5, 2238, 0, 0, 9764, 9765, 3, 970, 485, 0, 9765, + 965, 1, 0, 0, 0, 9766, 9768, 5, 1432, 0, 0, 9767, 9769, 7, 104, 0, 0, 9768, + 9767, 1, 0, 0, 0, 9768, 9769, 1, 0, 0, 0, 9769, 9781, 1, 0, 0, 0, 9770, + 9779, 5, 1175, 0, 0, 9771, 9780, 5, 378, 0, 0, 9772, 9780, 5, 227, 0, 0, + 9773, 9780, 5, 799, 0, 0, 9774, 9775, 5, 330, 0, 0, 9775, 9780, 5, 920, + 0, 0, 9776, 9777, 5, 799, 0, 0, 9777, 9778, 5, 330, 0, 0, 9778, 9780, 5, + 920, 0, 0, 9779, 9771, 1, 0, 0, 0, 9779, 9772, 1, 0, 0, 0, 9779, 9773, + 1, 0, 0, 0, 9779, 9774, 1, 0, 0, 0, 9779, 9776, 1, 0, 0, 0, 9780, 9782, + 1, 0, 0, 0, 9781, 9770, 1, 0, 0, 0, 9781, 9782, 1, 0, 0, 0, 9782, 967, + 1, 0, 0, 0, 9783, 9784, 5, 1277, 0, 0, 9784, 9793, 3, 2368, 1184, 0, 9785, + 9786, 5, 1280, 0, 0, 9786, 9793, 3, 2368, 1184, 0, 9787, 9788, 5, 1521, + 0, 0, 9788, 9793, 3, 2368, 1184, 0, 9789, 9790, 5, 1973, 0, 0, 9790, 9793, + 3, 1666, 833, 0, 9791, 9793, 7, 103, 0, 0, 9792, 9783, 1, 0, 0, 0, 9792, + 9785, 1, 0, 0, 0, 9792, 9787, 1, 0, 0, 0, 9792, 9789, 1, 0, 0, 0, 9792, + 9791, 1, 0, 0, 0, 9793, 9794, 1, 0, 0, 0, 9794, 9792, 1, 0, 0, 0, 9794, + 9795, 1, 0, 0, 0, 9795, 969, 1, 0, 0, 0, 9796, 9799, 3, 2376, 1188, 0, + 9797, 9798, 5, 2369, 0, 0, 9798, 9800, 3, 2378, 1189, 0, 9799, 9797, 1, + 0, 0, 0, 9799, 9800, 1, 0, 0, 0, 9800, 971, 1, 0, 0, 0, 9801, 9804, 3, + 2376, 1188, 0, 9802, 9803, 5, 2369, 0, 0, 9803, 9805, 3, 2378, 1189, 0, + 9804, 9802, 1, 0, 0, 0, 9804, 9805, 1, 0, 0, 0, 9805, 973, 1, 0, 0, 0, + 9806, 9811, 3, 2376, 1188, 0, 9807, 9808, 5, 2369, 0, 0, 9808, 9810, 3, + 2378, 1189, 0, 9809, 9807, 1, 0, 0, 0, 9810, 9813, 1, 0, 0, 0, 9811, 9809, + 1, 0, 0, 0, 9811, 9812, 1, 0, 0, 0, 9812, 975, 1, 0, 0, 0, 9813, 9811, + 1, 0, 0, 0, 9814, 9815, 5, 1175, 0, 0, 9815, 9816, 3, 2312, 1156, 0, 9816, + 9817, 5, 2376, 0, 0, 9817, 9818, 3, 2328, 1164, 0, 9818, 9819, 5, 2377, + 0, 0, 9819, 977, 1, 0, 0, 0, 9820, 9821, 5, 66, 0, 0, 9821, 9822, 3, 1892, + 946, 0, 9822, 979, 1, 0, 0, 0, 9823, 9824, 5, 41, 0, 0, 9824, 9825, 5, + 1182, 0, 0, 9825, 9829, 3, 972, 486, 0, 9826, 9830, 3, 988, 494, 0, 9827, + 9830, 3, 1000, 500, 0, 9828, 9830, 5, 233, 0, 0, 9829, 9826, 1, 0, 0, 0, + 9829, 9827, 1, 0, 0, 0, 9829, 9828, 1, 0, 0, 0, 9830, 981, 1, 0, 0, 0, + 9831, 9832, 5, 425, 0, 0, 9832, 9833, 5, 1182, 0, 0, 9833, 9835, 3, 972, + 486, 0, 9834, 9836, 5, 560, 0, 0, 9835, 9834, 1, 0, 0, 0, 9835, 9836, 1, + 0, 0, 0, 9836, 983, 1, 0, 0, 0, 9837, 9840, 5, 301, 0, 0, 9838, 9839, 5, + 1219, 0, 0, 9839, 9841, 5, 1463, 0, 0, 9840, 9838, 1, 0, 0, 0, 9840, 9841, + 1, 0, 0, 0, 9841, 9842, 1, 0, 0, 0, 9842, 9843, 5, 1182, 0, 0, 9843, 9844, + 3, 972, 486, 0, 9844, 9845, 5, 125, 0, 0, 9845, 9850, 3, 986, 493, 0, 9846, + 9847, 5, 2382, 0, 0, 9847, 9849, 3, 986, 493, 0, 9848, 9846, 1, 0, 0, 0, + 9849, 9852, 1, 0, 0, 0, 9850, 9848, 1, 0, 0, 0, 9850, 9851, 1, 0, 0, 0, + 9851, 9856, 1, 0, 0, 0, 9852, 9850, 1, 0, 0, 0, 9853, 9854, 5, 1577, 0, + 0, 9854, 9855, 5, 2398, 0, 0, 9855, 9857, 7, 43, 0, 0, 9856, 9853, 1, 0, + 0, 0, 9856, 9857, 1, 0, 0, 0, 9857, 985, 1, 0, 0, 0, 9858, 9859, 5, 2376, + 0, 0, 9859, 9864, 3, 2346, 1173, 0, 9860, 9861, 5, 2382, 0, 0, 9861, 9863, + 3, 2346, 1173, 0, 9862, 9860, 1, 0, 0, 0, 9863, 9866, 1, 0, 0, 0, 9864, + 9862, 1, 0, 0, 0, 9864, 9865, 1, 0, 0, 0, 9865, 9867, 1, 0, 0, 0, 9866, + 9864, 1, 0, 0, 0, 9867, 9868, 5, 2377, 0, 0, 9868, 9870, 5, 1487, 0, 0, + 9869, 9871, 5, 2376, 0, 0, 9870, 9869, 1, 0, 0, 0, 9870, 9871, 1, 0, 0, + 0, 9871, 9872, 1, 0, 0, 0, 9872, 9874, 3, 2346, 1173, 0, 9873, 9875, 5, + 2377, 0, 0, 9874, 9873, 1, 0, 0, 0, 9874, 9875, 1, 0, 0, 0, 9875, 9877, + 1, 0, 0, 0, 9876, 9878, 3, 990, 495, 0, 9877, 9876, 1, 0, 0, 0, 9877, 9878, + 1, 0, 0, 0, 9878, 9879, 1, 0, 0, 0, 9879, 9880, 3, 998, 499, 0, 9880, 987, + 1, 0, 0, 0, 9881, 9882, 5, 20, 0, 0, 9882, 9883, 5, 125, 0, 0, 9883, 9884, + 3, 986, 493, 0, 9884, 989, 1, 0, 0, 0, 9885, 9886, 5, 47, 0, 0, 9886, 9887, + 5, 2029, 0, 0, 9887, 9890, 3, 992, 496, 0, 9888, 9890, 3, 996, 498, 0, + 9889, 9885, 1, 0, 0, 0, 9889, 9888, 1, 0, 0, 0, 9890, 991, 1, 0, 0, 0, + 9891, 9896, 3, 994, 497, 0, 9892, 9893, 5, 2382, 0, 0, 9893, 9895, 3, 994, + 497, 0, 9894, 9892, 1, 0, 0, 0, 9895, 9898, 1, 0, 0, 0, 9896, 9894, 1, + 0, 0, 0, 9896, 9897, 1, 0, 0, 0, 9897, 993, 1, 0, 0, 0, 9898, 9896, 1, + 0, 0, 0, 9899, 9900, 3, 2320, 1160, 0, 9900, 9901, 5, 2376, 0, 0, 9901, + 9906, 3, 2346, 1173, 0, 9902, 9903, 5, 2382, 0, 0, 9903, 9905, 3, 2346, + 1173, 0, 9904, 9902, 1, 0, 0, 0, 9905, 9908, 1, 0, 0, 0, 9906, 9904, 1, + 0, 0, 0, 9906, 9907, 1, 0, 0, 0, 9907, 9909, 1, 0, 0, 0, 9908, 9906, 1, + 0, 0, 0, 9909, 9910, 5, 2377, 0, 0, 9910, 995, 1, 0, 0, 0, 9911, 9912, + 5, 2188, 0, 0, 9912, 9913, 5, 659, 0, 0, 9913, 9914, 5, 277, 0, 0, 9914, + 9915, 5, 2382, 0, 0, 9915, 9916, 5, 1523, 0, 0, 9916, 9917, 5, 277, 0, + 0, 9917, 9921, 3, 2264, 1132, 0, 9918, 9919, 5, 243, 0, 0, 9919, 9920, + 5, 47, 0, 0, 9920, 9922, 5, 330, 0, 0, 9921, 9918, 1, 0, 0, 0, 9921, 9922, + 1, 0, 0, 0, 9922, 9926, 1, 0, 0, 0, 9923, 9924, 5, 2188, 0, 0, 9924, 9925, + 5, 222, 0, 0, 9925, 9927, 5, 277, 0, 0, 9926, 9923, 1, 0, 0, 0, 9926, 9927, + 1, 0, 0, 0, 9927, 997, 1, 0, 0, 0, 9928, 9929, 5, 2129, 0, 0, 9929, 9930, + 3, 974, 487, 0, 9930, 999, 1, 0, 0, 0, 9931, 9932, 5, 425, 0, 0, 9932, + 9933, 5, 125, 0, 0, 9933, 9934, 5, 2376, 0, 0, 9934, 9939, 3, 2346, 1173, + 0, 9935, 9936, 5, 2382, 0, 0, 9936, 9938, 3, 2346, 1173, 0, 9937, 9935, + 1, 0, 0, 0, 9938, 9941, 1, 0, 0, 0, 9939, 9937, 1, 0, 0, 0, 9939, 9940, + 1, 0, 0, 0, 9940, 9942, 1, 0, 0, 0, 9941, 9939, 1, 0, 0, 0, 9942, 9944, + 5, 2377, 0, 0, 9943, 9945, 5, 560, 0, 0, 9944, 9943, 1, 0, 0, 0, 9944, + 9945, 1, 0, 0, 0, 9945, 1001, 1, 0, 0, 0, 9946, 9947, 5, 301, 0, 0, 9947, + 9948, 5, 848, 0, 0, 9948, 9949, 5, 2166, 0, 0, 9949, 9952, 3, 2312, 1156, + 0, 9950, 9951, 5, 1163, 0, 0, 9951, 9953, 3, 2286, 1143, 0, 9952, 9950, + 1, 0, 0, 0, 9952, 9953, 1, 0, 0, 0, 9953, 9971, 1, 0, 0, 0, 9954, 9957, + 5, 2376, 0, 0, 9955, 9958, 3, 1004, 502, 0, 9956, 9958, 3, 1006, 503, 0, + 9957, 9955, 1, 0, 0, 0, 9957, 9956, 1, 0, 0, 0, 9958, 9966, 1, 0, 0, 0, + 9959, 9962, 5, 2382, 0, 0, 9960, 9963, 3, 1004, 502, 0, 9961, 9963, 3, + 1006, 503, 0, 9962, 9960, 1, 0, 0, 0, 9962, 9961, 1, 0, 0, 0, 9963, 9965, + 1, 0, 0, 0, 9964, 9959, 1, 0, 0, 0, 9965, 9968, 1, 0, 0, 0, 9966, 9964, + 1, 0, 0, 0, 9966, 9967, 1, 0, 0, 0, 9967, 9969, 1, 0, 0, 0, 9968, 9966, + 1, 0, 0, 0, 9969, 9970, 5, 2377, 0, 0, 9970, 9972, 1, 0, 0, 0, 9971, 9954, + 1, 0, 0, 0, 9971, 9972, 1, 0, 0, 0, 9972, 9993, 1, 0, 0, 0, 9973, 9974, + 5, 1175, 0, 0, 9974, 9975, 5, 1339, 0, 0, 9975, 9979, 5, 1976, 0, 0, 9976, + 9977, 7, 2, 0, 0, 9977, 9978, 5, 1424, 0, 0, 9978, 9980, 5, 1342, 0, 0, + 9979, 9976, 1, 0, 0, 0, 9979, 9980, 1, 0, 0, 0, 9980, 9994, 1, 0, 0, 0, + 9981, 9983, 3, 1196, 598, 0, 9982, 9981, 1, 0, 0, 0, 9982, 9983, 1, 0, + 0, 0, 9983, 9985, 1, 0, 0, 0, 9984, 9986, 7, 103, 0, 0, 9985, 9984, 1, + 0, 0, 0, 9985, 9986, 1, 0, 0, 0, 9986, 9988, 1, 0, 0, 0, 9987, 9989, 3, + 926, 463, 0, 9988, 9987, 1, 0, 0, 0, 9988, 9989, 1, 0, 0, 0, 9989, 9991, + 1, 0, 0, 0, 9990, 9992, 3, 922, 461, 0, 9991, 9990, 1, 0, 0, 0, 9991, 9992, + 1, 0, 0, 0, 9992, 9994, 1, 0, 0, 0, 9993, 9973, 1, 0, 0, 0, 9993, 9982, + 1, 0, 0, 0, 9994, 10012, 1, 0, 0, 0, 9995, 9996, 5, 2129, 0, 0, 9996, 10006, + 5, 659, 0, 0, 9997, 10001, 3, 1188, 594, 0, 9998, 9999, 5, 1973, 0, 0, + 9999, 10001, 3, 2378, 1189, 0, 10000, 9997, 1, 0, 0, 0, 10000, 9998, 1, + 0, 0, 0, 10001, 10002, 1, 0, 0, 0, 10002, 10000, 1, 0, 0, 0, 10002, 10003, + 1, 0, 0, 0, 10003, 10005, 1, 0, 0, 0, 10004, 10000, 1, 0, 0, 0, 10005, + 10008, 1, 0, 0, 0, 10006, 10004, 1, 0, 0, 0, 10006, 10007, 1, 0, 0, 0, + 10007, 10013, 1, 0, 0, 0, 10008, 10006, 1, 0, 0, 0, 10009, 10010, 5, 2129, + 0, 0, 10010, 10011, 5, 1057, 0, 0, 10011, 10013, 5, 659, 0, 0, 10012, 9995, + 1, 0, 0, 0, 10012, 10009, 1, 0, 0, 0, 10012, 10013, 1, 0, 0, 0, 10013, + 10015, 1, 0, 0, 0, 10014, 10016, 3, 1008, 504, 0, 10015, 10014, 1, 0, 0, + 0, 10015, 10016, 1, 0, 0, 0, 10016, 10019, 1, 0, 0, 0, 10017, 10018, 5, + 564, 0, 0, 10018, 10020, 5, 2091, 0, 0, 10019, 10017, 1, 0, 0, 0, 10019, + 10020, 1, 0, 0, 0, 10020, 10024, 1, 0, 0, 0, 10021, 10022, 7, 17, 0, 0, + 10022, 10023, 5, 1388, 0, 0, 10023, 10025, 5, 1492, 0, 0, 10024, 10021, + 1, 0, 0, 0, 10024, 10025, 1, 0, 0, 0, 10025, 10026, 1, 0, 0, 0, 10026, + 10027, 5, 66, 0, 0, 10027, 10028, 3, 1880, 940, 0, 10028, 10029, 5, 2396, + 0, 0, 10029, 1003, 1, 0, 0, 0, 10030, 10031, 5, 1529, 0, 0, 10031, 10032, + 5, 564, 0, 0, 10032, 10033, 5, 2376, 0, 0, 10033, 10034, 3, 2376, 1188, + 0, 10034, 10035, 5, 2377, 0, 0, 10035, 10039, 5, 723, 0, 0, 10036, 10037, + 3, 2258, 1129, 0, 10037, 10038, 5, 2369, 0, 0, 10038, 10040, 1, 0, 0, 0, + 10039, 10036, 1, 0, 0, 0, 10039, 10040, 1, 0, 0, 0, 10040, 10041, 1, 0, + 0, 0, 10041, 10042, 3, 2376, 1188, 0, 10042, 1005, 1, 0, 0, 0, 10043, 10046, + 3, 2376, 1188, 0, 10044, 10046, 3, 2372, 1186, 0, 10045, 10043, 1, 0, 0, + 0, 10045, 10044, 1, 0, 0, 0, 10046, 10049, 1, 0, 0, 0, 10047, 10048, 5, + 457, 0, 0, 10048, 10050, 3, 1664, 832, 0, 10049, 10047, 1, 0, 0, 0, 10049, + 10050, 1, 0, 0, 0, 10050, 1007, 1, 0, 0, 0, 10051, 10052, 5, 949, 0, 0, + 10052, 10091, 5, 1432, 0, 0, 10053, 10086, 5, 1432, 0, 0, 10054, 10087, + 7, 105, 0, 0, 10055, 10056, 5, 1175, 0, 0, 10056, 10087, 7, 99, 0, 0, 10057, + 10058, 5, 1631, 0, 0, 10058, 10061, 5, 2188, 0, 0, 10059, 10061, 5, 953, + 0, 0, 10060, 10057, 1, 0, 0, 0, 10060, 10059, 1, 0, 0, 0, 10061, 10087, + 1, 0, 0, 0, 10062, 10066, 5, 2188, 0, 0, 10063, 10064, 5, 1355, 0, 0, 10064, + 10067, 5, 753, 0, 0, 10065, 10067, 5, 1502, 0, 0, 10066, 10063, 1, 0, 0, + 0, 10066, 10065, 1, 0, 0, 0, 10067, 10087, 1, 0, 0, 0, 10068, 10081, 5, + 2129, 0, 0, 10069, 10071, 5, 363, 0, 0, 10070, 10072, 7, 106, 0, 0, 10071, + 10070, 1, 0, 0, 0, 10071, 10072, 1, 0, 0, 0, 10072, 10073, 1, 0, 0, 0, + 10073, 10074, 5, 1497, 0, 0, 10074, 10082, 5, 1546, 0, 0, 10075, 10077, + 7, 106, 0, 0, 10076, 10075, 1, 0, 0, 0, 10076, 10077, 1, 0, 0, 0, 10077, + 10078, 1, 0, 0, 0, 10078, 10079, 5, 1497, 0, 0, 10079, 10080, 5, 1546, + 0, 0, 10080, 10082, 5, 2407, 0, 0, 10081, 10069, 1, 0, 0, 0, 10081, 10076, + 1, 0, 0, 0, 10082, 10087, 1, 0, 0, 0, 10083, 10084, 5, 2129, 0, 0, 10084, + 10085, 7, 100, 0, 0, 10085, 10087, 5, 268, 0, 0, 10086, 10054, 1, 0, 0, + 0, 10086, 10055, 1, 0, 0, 0, 10086, 10060, 1, 0, 0, 0, 10086, 10062, 1, + 0, 0, 0, 10086, 10068, 1, 0, 0, 0, 10086, 10083, 1, 0, 0, 0, 10087, 10088, + 1, 0, 0, 0, 10088, 10086, 1, 0, 0, 0, 10088, 10089, 1, 0, 0, 0, 10089, + 10091, 1, 0, 0, 0, 10090, 10051, 1, 0, 0, 0, 10090, 10053, 1, 0, 0, 0, + 10091, 1009, 1, 0, 0, 0, 10092, 10093, 5, 425, 0, 0, 10093, 10094, 5, 848, + 0, 0, 10094, 10095, 5, 2166, 0, 0, 10095, 10098, 3, 2312, 1156, 0, 10096, + 10097, 5, 1351, 0, 0, 10097, 10099, 5, 1976, 0, 0, 10098, 10096, 1, 0, + 0, 0, 10098, 10099, 1, 0, 0, 0, 10099, 10100, 1, 0, 0, 0, 10100, 10101, + 5, 2396, 0, 0, 10101, 1011, 1, 0, 0, 0, 10102, 10105, 5, 301, 0, 0, 10103, + 10104, 5, 1219, 0, 0, 10104, 10106, 5, 1463, 0, 0, 10105, 10103, 1, 0, + 0, 0, 10105, 10106, 1, 0, 0, 0, 10106, 10107, 1, 0, 0, 0, 10107, 10108, + 5, 277, 0, 0, 10108, 10109, 3, 1014, 507, 0, 10109, 10113, 5, 2129, 0, + 0, 10110, 10111, 3, 2320, 1160, 0, 10111, 10112, 5, 2369, 0, 0, 10112, + 10114, 1, 0, 0, 0, 10113, 10110, 1, 0, 0, 0, 10113, 10114, 1, 0, 0, 0, + 10114, 10115, 1, 0, 0, 0, 10115, 10120, 3, 2262, 1131, 0, 10116, 10117, + 5, 683, 0, 0, 10117, 10121, 7, 65, 0, 0, 10118, 10119, 5, 5, 0, 0, 10119, + 10121, 5, 587, 0, 0, 10120, 10116, 1, 0, 0, 0, 10120, 10118, 1, 0, 0, 0, + 10120, 10121, 1, 0, 0, 0, 10121, 10122, 1, 0, 0, 0, 10122, 10123, 5, 2396, + 0, 0, 10123, 1013, 1, 0, 0, 0, 10124, 10125, 3, 2378, 1189, 0, 10125, 1015, + 1, 0, 0, 0, 10126, 10127, 5, 301, 0, 0, 10127, 10128, 5, 206, 0, 0, 10128, + 10129, 3, 462, 231, 0, 10129, 10130, 5, 2376, 0, 0, 10130, 10131, 3, 2310, + 1155, 0, 10131, 10133, 3, 2346, 1173, 0, 10132, 10134, 5, 1604, 0, 0, 10133, + 10132, 1, 0, 0, 0, 10133, 10134, 1, 0, 0, 0, 10134, 10143, 1, 0, 0, 0, + 10135, 10136, 5, 2382, 0, 0, 10136, 10137, 3, 2310, 1155, 0, 10137, 10139, + 3, 2346, 1173, 0, 10138, 10140, 5, 1604, 0, 0, 10139, 10138, 1, 0, 0, 0, + 10139, 10140, 1, 0, 0, 0, 10140, 10142, 1, 0, 0, 0, 10141, 10135, 1, 0, + 0, 0, 10142, 10145, 1, 0, 0, 0, 10143, 10141, 1, 0, 0, 0, 10143, 10144, + 1, 0, 0, 0, 10144, 10146, 1, 0, 0, 0, 10145, 10143, 1, 0, 0, 0, 10146, + 10166, 5, 2377, 0, 0, 10147, 10165, 3, 1188, 594, 0, 10148, 10149, 5, 1595, + 0, 0, 10149, 10165, 3, 1170, 585, 0, 10150, 10151, 5, 1973, 0, 0, 10151, + 10165, 3, 1666, 833, 0, 10152, 10165, 5, 659, 0, 0, 10153, 10154, 5, 1591, + 0, 0, 10154, 10156, 5, 1976, 0, 0, 10155, 10153, 1, 0, 0, 0, 10155, 10156, + 1, 0, 0, 0, 10156, 10157, 1, 0, 0, 0, 10157, 10158, 5, 604, 0, 0, 10158, + 10162, 5, 2370, 0, 0, 10159, 10160, 5, 603, 0, 0, 10160, 10161, 5, 723, + 0, 0, 10161, 10163, 3, 2078, 1039, 0, 10162, 10159, 1, 0, 0, 0, 10162, + 10163, 1, 0, 0, 0, 10163, 10165, 1, 0, 0, 0, 10164, 10147, 1, 0, 0, 0, + 10164, 10148, 1, 0, 0, 0, 10164, 10150, 1, 0, 0, 0, 10164, 10152, 1, 0, + 0, 0, 10164, 10155, 1, 0, 0, 0, 10165, 10168, 1, 0, 0, 0, 10166, 10164, + 1, 0, 0, 0, 10166, 10167, 1, 0, 0, 0, 10167, 10170, 1, 0, 0, 0, 10168, + 10166, 1, 0, 0, 0, 10169, 10171, 3, 926, 463, 0, 10170, 10169, 1, 0, 0, + 0, 10170, 10171, 1, 0, 0, 0, 10171, 10173, 1, 0, 0, 0, 10172, 10174, 7, + 107, 0, 0, 10173, 10172, 1, 0, 0, 0, 10173, 10174, 1, 0, 0, 0, 10174, 10176, + 1, 0, 0, 0, 10175, 10177, 7, 103, 0, 0, 10176, 10175, 1, 0, 0, 0, 10176, + 10177, 1, 0, 0, 0, 10177, 10178, 1, 0, 0, 0, 10178, 10179, 5, 2396, 0, + 0, 10179, 1017, 1, 0, 0, 0, 10180, 10182, 5, 301, 0, 0, 10181, 10183, 5, + 838, 0, 0, 10182, 10181, 1, 0, 0, 0, 10182, 10183, 1, 0, 0, 0, 10183, 10184, + 1, 0, 0, 0, 10184, 10185, 5, 1367, 0, 0, 10185, 10186, 3, 2378, 1189, 0, + 10186, 10189, 5, 793, 0, 0, 10187, 10190, 3, 1020, 510, 0, 10188, 10190, + 3, 1022, 511, 0, 10189, 10187, 1, 0, 0, 0, 10189, 10188, 1, 0, 0, 0, 10190, + 10191, 1, 0, 0, 0, 10191, 10189, 1, 0, 0, 0, 10191, 10192, 1, 0, 0, 0, + 10192, 10194, 1, 0, 0, 0, 10193, 10195, 3, 762, 381, 0, 10194, 10193, 1, + 0, 0, 0, 10194, 10195, 1, 0, 0, 0, 10195, 1019, 1, 0, 0, 0, 10196, 10197, + 7, 108, 0, 0, 10197, 10205, 7, 109, 0, 0, 10198, 10202, 5, 1360, 0, 0, + 10199, 10203, 3, 1170, 585, 0, 10200, 10203, 5, 2070, 0, 0, 10201, 10203, + 5, 363, 0, 0, 10202, 10199, 1, 0, 0, 0, 10202, 10200, 1, 0, 0, 0, 10202, + 10201, 1, 0, 0, 0, 10203, 10205, 1, 0, 0, 0, 10204, 10196, 1, 0, 0, 0, + 10204, 10198, 1, 0, 0, 0, 10205, 1021, 1, 0, 0, 0, 10206, 10210, 7, 110, + 0, 0, 10207, 10211, 3, 2078, 1039, 0, 10208, 10211, 5, 2070, 0, 0, 10209, + 10211, 5, 363, 0, 0, 10210, 10207, 1, 0, 0, 0, 10210, 10208, 1, 0, 0, 0, + 10210, 10209, 1, 0, 0, 0, 10211, 10224, 1, 0, 0, 0, 10212, 10216, 5, 1268, + 0, 0, 10213, 10217, 3, 2292, 1146, 0, 10214, 10217, 5, 1145, 0, 0, 10215, + 10217, 5, 363, 0, 0, 10216, 10213, 1, 0, 0, 0, 10216, 10214, 1, 0, 0, 0, + 10216, 10215, 1, 0, 0, 0, 10217, 10224, 1, 0, 0, 0, 10218, 10221, 5, 1267, + 0, 0, 10219, 10222, 3, 2078, 1039, 0, 10220, 10222, 5, 363, 0, 0, 10221, + 10219, 1, 0, 0, 0, 10221, 10220, 1, 0, 0, 0, 10222, 10224, 1, 0, 0, 0, + 10223, 10206, 1, 0, 0, 0, 10223, 10212, 1, 0, 0, 0, 10223, 10218, 1, 0, + 0, 0, 10224, 1023, 1, 0, 0, 0, 10225, 10226, 5, 301, 0, 0, 10226, 10227, + 5, 809, 0, 0, 10227, 10228, 5, 1367, 0, 0, 10228, 10231, 3, 2378, 1189, + 0, 10229, 10232, 3, 1026, 513, 0, 10230, 10232, 3, 1028, 514, 0, 10231, + 10229, 1, 0, 0, 0, 10231, 10230, 1, 0, 0, 0, 10231, 10232, 1, 0, 0, 0, + 10232, 1025, 1, 0, 0, 0, 10233, 10234, 5, 572, 0, 0, 10234, 10235, 3, 2378, + 1189, 0, 10235, 1027, 1, 0, 0, 0, 10236, 10237, 5, 647, 0, 0, 10237, 10238, + 3, 2378, 1189, 0, 10238, 1029, 1, 0, 0, 0, 10239, 10242, 5, 301, 0, 0, + 10240, 10241, 5, 1219, 0, 0, 10241, 10243, 5, 1463, 0, 0, 10242, 10240, + 1, 0, 0, 0, 10242, 10243, 1, 0, 0, 0, 10243, 10245, 1, 0, 0, 0, 10244, + 10246, 7, 24, 0, 0, 10245, 10244, 1, 0, 0, 0, 10245, 10246, 1, 0, 0, 0, + 10246, 10247, 1, 0, 0, 0, 10247, 10249, 5, 1227, 0, 0, 10248, 10250, 3, + 2378, 1189, 0, 10249, 10248, 1, 0, 0, 0, 10249, 10250, 1, 0, 0, 0, 10250, + 10256, 1, 0, 0, 0, 10251, 10253, 5, 572, 0, 0, 10252, 10254, 7, 24, 0, + 0, 10253, 10252, 1, 0, 0, 0, 10253, 10254, 1, 0, 0, 0, 10254, 10255, 1, + 0, 0, 0, 10255, 10257, 3, 2378, 1189, 0, 10256, 10251, 1, 0, 0, 0, 10256, + 10257, 1, 0, 0, 0, 10257, 10261, 1, 0, 0, 0, 10258, 10259, 5, 564, 0, 0, + 10259, 10260, 5, 172, 0, 0, 10260, 10262, 3, 2378, 1189, 0, 10261, 10258, + 1, 0, 0, 0, 10261, 10262, 1, 0, 0, 0, 10262, 10265, 1, 0, 0, 0, 10263, + 10264, 5, 1175, 0, 0, 10264, 10266, 3, 1796, 898, 0, 10265, 10263, 1, 0, + 0, 0, 10265, 10266, 1, 0, 0, 0, 10266, 1031, 1, 0, 0, 0, 10267, 10269, + 5, 301, 0, 0, 10268, 10270, 5, 196, 0, 0, 10269, 10268, 1, 0, 0, 0, 10269, + 10270, 1, 0, 0, 0, 10270, 10271, 1, 0, 0, 0, 10271, 10272, 5, 1475, 0, + 0, 10272, 10273, 5, 1317, 0, 0, 10273, 10278, 3, 2378, 1189, 0, 10274, + 10275, 5, 564, 0, 0, 10275, 10276, 5, 1315, 0, 0, 10276, 10277, 5, 329, + 0, 0, 10277, 10279, 3, 2378, 1189, 0, 10278, 10274, 1, 0, 0, 0, 10278, + 10279, 1, 0, 0, 0, 10279, 10284, 1, 0, 0, 0, 10280, 10281, 5, 66, 0, 0, + 10281, 10282, 5, 1163, 0, 0, 10282, 10283, 7, 74, 0, 0, 10283, 10285, 3, + 2078, 1039, 0, 10284, 10280, 1, 0, 0, 0, 10284, 10285, 1, 0, 0, 0, 10285, + 10290, 1, 0, 0, 0, 10286, 10291, 5, 1351, 0, 0, 10287, 10288, 5, 599, 0, + 0, 10288, 10289, 5, 549, 0, 0, 10289, 10291, 5, 329, 0, 0, 10290, 10286, + 1, 0, 0, 0, 10290, 10287, 1, 0, 0, 0, 10290, 10291, 1, 0, 0, 0, 10291, + 1033, 1, 0, 0, 0, 10292, 10293, 5, 301, 0, 0, 10293, 10294, 5, 1494, 0, + 0, 10294, 10296, 3, 2280, 1140, 0, 10295, 10297, 3, 1538, 769, 0, 10296, + 10295, 1, 0, 0, 0, 10296, 10297, 1, 0, 0, 0, 10297, 10299, 1, 0, 0, 0, + 10298, 10300, 3, 762, 381, 0, 10299, 10298, 1, 0, 0, 0, 10299, 10300, 1, + 0, 0, 0, 10300, 1035, 1, 0, 0, 0, 10301, 10311, 5, 301, 0, 0, 10302, 10303, + 7, 111, 0, 0, 10303, 10312, 5, 1984, 0, 0, 10304, 10312, 5, 2260, 0, 0, + 10305, 10312, 5, 2250, 0, 0, 10306, 10308, 5, 2254, 0, 0, 10307, 10306, + 1, 0, 0, 0, 10307, 10308, 1, 0, 0, 0, 10308, 10309, 1, 0, 0, 0, 10309, + 10312, 5, 2246, 0, 0, 10310, 10312, 5, 2254, 0, 0, 10311, 10302, 1, 0, + 0, 0, 10311, 10304, 1, 0, 0, 0, 10311, 10305, 1, 0, 0, 0, 10311, 10307, + 1, 0, 0, 0, 10311, 10310, 1, 0, 0, 0, 10311, 10312, 1, 0, 0, 0, 10312, + 10313, 1, 0, 0, 0, 10313, 10317, 5, 1976, 0, 0, 10314, 10315, 3, 2258, + 1129, 0, 10315, 10316, 5, 2369, 0, 0, 10316, 10318, 1, 0, 0, 0, 10317, + 10314, 1, 0, 0, 0, 10317, 10318, 1, 0, 0, 0, 10318, 10319, 1, 0, 0, 0, + 10319, 10330, 3, 1104, 552, 0, 10320, 10321, 5, 1577, 0, 0, 10321, 10328, + 5, 2398, 0, 0, 10322, 10329, 5, 877, 0, 0, 10323, 10325, 5, 2251, 0, 0, + 10324, 10323, 1, 0, 0, 0, 10324, 10325, 1, 0, 0, 0, 10325, 10326, 1, 0, + 0, 0, 10326, 10329, 5, 330, 0, 0, 10327, 10329, 5, 1054, 0, 0, 10328, 10322, + 1, 0, 0, 0, 10328, 10324, 1, 0, 0, 0, 10328, 10327, 1, 0, 0, 0, 10329, + 10331, 1, 0, 0, 0, 10330, 10320, 1, 0, 0, 0, 10330, 10331, 1, 0, 0, 0, + 10331, 10335, 1, 0, 0, 0, 10332, 10336, 3, 1060, 530, 0, 10333, 10336, + 3, 1048, 524, 0, 10334, 10336, 3, 1038, 519, 0, 10335, 10332, 1, 0, 0, + 0, 10335, 10333, 1, 0, 0, 0, 10335, 10334, 1, 0, 0, 0, 10336, 10340, 1, + 0, 0, 0, 10337, 10338, 5, 2283, 0, 0, 10338, 10339, 5, 564, 0, 0, 10339, + 10341, 5, 1408, 0, 0, 10340, 10337, 1, 0, 0, 0, 10340, 10341, 1, 0, 0, + 0, 10341, 10345, 1, 0, 0, 0, 10342, 10343, 5, 2283, 0, 0, 10343, 10344, + 5, 564, 0, 0, 10344, 10346, 5, 2192, 0, 0, 10345, 10342, 1, 0, 0, 0, 10345, + 10346, 1, 0, 0, 0, 10346, 10349, 1, 0, 0, 0, 10347, 10348, 5, 1246, 0, + 0, 10348, 10350, 3, 2312, 1156, 0, 10349, 10347, 1, 0, 0, 0, 10349, 10350, + 1, 0, 0, 0, 10350, 10351, 1, 0, 0, 0, 10351, 10352, 5, 2396, 0, 0, 10352, + 1037, 1, 0, 0, 0, 10353, 10354, 5, 1163, 0, 0, 10354, 10359, 5, 2229, 0, + 0, 10355, 10356, 5, 2376, 0, 0, 10356, 10357, 3, 1056, 528, 0, 10357, 10358, + 5, 2377, 0, 0, 10358, 10360, 1, 0, 0, 0, 10359, 10355, 1, 0, 0, 0, 10359, + 10360, 1, 0, 0, 0, 10360, 10363, 1, 0, 0, 0, 10361, 10362, 5, 2229, 0, + 0, 10362, 10364, 3, 1044, 522, 0, 10363, 10361, 1, 0, 0, 0, 10363, 10364, + 1, 0, 0, 0, 10364, 10366, 1, 0, 0, 0, 10365, 10367, 3, 1046, 523, 0, 10366, + 10365, 1, 0, 0, 0, 10366, 10367, 1, 0, 0, 0, 10367, 10369, 1, 0, 0, 0, + 10368, 10370, 3, 1040, 520, 0, 10369, 10368, 1, 0, 0, 0, 10369, 10370, + 1, 0, 0, 0, 10370, 10375, 1, 0, 0, 0, 10371, 10372, 5, 1175, 0, 0, 10372, + 10373, 5, 227, 0, 0, 10373, 10374, 7, 112, 0, 0, 10374, 10376, 5, 1508, + 0, 0, 10375, 10371, 1, 0, 0, 0, 10375, 10376, 1, 0, 0, 0, 10376, 10378, + 1, 0, 0, 0, 10377, 10379, 3, 1054, 527, 0, 10378, 10377, 1, 0, 0, 0, 10378, + 10379, 1, 0, 0, 0, 10379, 10381, 1, 0, 0, 0, 10380, 10382, 3, 1052, 526, + 0, 10381, 10380, 1, 0, 0, 0, 10381, 10382, 1, 0, 0, 0, 10382, 10384, 1, + 0, 0, 0, 10383, 10385, 3, 1196, 598, 0, 10384, 10383, 1, 0, 0, 0, 10384, + 10385, 1, 0, 0, 0, 10385, 10386, 1, 0, 0, 0, 10386, 10387, 3, 1078, 539, + 0, 10387, 1039, 1, 0, 0, 0, 10388, 10389, 5, 2168, 0, 0, 10389, 10390, + 5, 223, 0, 0, 10390, 10391, 5, 2376, 0, 0, 10391, 10392, 3, 2310, 1155, + 0, 10392, 10393, 5, 66, 0, 0, 10393, 10394, 5, 2376, 0, 0, 10394, 10395, + 3, 2078, 1039, 0, 10395, 10405, 5, 2377, 0, 0, 10396, 10397, 5, 2382, 0, + 0, 10397, 10398, 3, 2310, 1155, 0, 10398, 10399, 5, 66, 0, 0, 10399, 10400, + 5, 2376, 0, 0, 10400, 10401, 3, 2078, 1039, 0, 10401, 10402, 5, 2377, 0, + 0, 10402, 10404, 1, 0, 0, 0, 10403, 10396, 1, 0, 0, 0, 10404, 10407, 1, + 0, 0, 0, 10405, 10403, 1, 0, 0, 0, 10405, 10406, 1, 0, 0, 0, 10406, 10408, + 1, 0, 0, 0, 10407, 10405, 1, 0, 0, 0, 10408, 10409, 5, 2377, 0, 0, 10409, + 1041, 1, 0, 0, 0, 10410, 10412, 5, 2229, 0, 0, 10411, 10413, 5, 222, 0, + 0, 10412, 10411, 1, 0, 0, 0, 10412, 10413, 1, 0, 0, 0, 10413, 10414, 1, + 0, 0, 0, 10414, 10416, 3, 2310, 1155, 0, 10415, 10417, 3, 1044, 522, 0, + 10416, 10415, 1, 0, 0, 0, 10416, 10417, 1, 0, 0, 0, 10417, 10419, 1, 0, + 0, 0, 10418, 10420, 3, 1046, 523, 0, 10419, 10418, 1, 0, 0, 0, 10419, 10420, + 1, 0, 0, 0, 10420, 1043, 1, 0, 0, 0, 10421, 10422, 5, 1656, 0, 0, 10422, + 10446, 5, 66, 0, 0, 10423, 10424, 5, 1155, 0, 0, 10424, 10447, 5, 1452, + 0, 0, 10425, 10427, 7, 113, 0, 0, 10426, 10425, 1, 0, 0, 0, 10426, 10427, + 1, 0, 0, 0, 10427, 10431, 1, 0, 0, 0, 10428, 10432, 5, 201, 0, 0, 10429, + 10430, 5, 116, 0, 0, 10430, 10432, 5, 2230, 0, 0, 10431, 10428, 1, 0, 0, + 0, 10431, 10429, 1, 0, 0, 0, 10432, 10444, 1, 0, 0, 0, 10433, 10438, 3, + 1644, 822, 0, 10434, 10435, 5, 2376, 0, 0, 10435, 10436, 3, 1656, 828, + 0, 10436, 10437, 5, 2377, 0, 0, 10437, 10439, 1, 0, 0, 0, 10438, 10434, + 1, 0, 0, 0, 10438, 10439, 1, 0, 0, 0, 10439, 10445, 1, 0, 0, 0, 10440, + 10441, 5, 2376, 0, 0, 10441, 10442, 3, 1656, 828, 0, 10442, 10443, 5, 2377, + 0, 0, 10443, 10445, 1, 0, 0, 0, 10444, 10433, 1, 0, 0, 0, 10444, 10440, + 1, 0, 0, 0, 10444, 10445, 1, 0, 0, 0, 10445, 10447, 1, 0, 0, 0, 10446, + 10423, 1, 0, 0, 0, 10446, 10426, 1, 0, 0, 0, 10447, 10453, 1, 0, 0, 0, + 10448, 10449, 5, 1656, 0, 0, 10449, 10450, 5, 2146, 0, 0, 10450, 10451, + 5, 66, 0, 0, 10451, 10453, 7, 89, 0, 0, 10452, 10421, 1, 0, 0, 0, 10452, + 10448, 1, 0, 0, 0, 10453, 1045, 1, 0, 0, 0, 10454, 10455, 5, 2224, 0, 0, + 10455, 10457, 5, 2373, 0, 0, 10456, 10454, 1, 0, 0, 0, 10456, 10457, 1, + 0, 0, 0, 10457, 10458, 1, 0, 0, 0, 10458, 10459, 5, 441, 0, 0, 10459, 10463, + 5, 2373, 0, 0, 10460, 10461, 3, 1324, 662, 0, 10461, 10462, 5, 1058, 0, + 0, 10462, 10464, 1, 0, 0, 0, 10463, 10460, 1, 0, 0, 0, 10463, 10464, 1, + 0, 0, 0, 10464, 10468, 1, 0, 0, 0, 10465, 10466, 3, 1324, 662, 0, 10466, + 10467, 5, 54, 0, 0, 10467, 10469, 1, 0, 0, 0, 10468, 10465, 1, 0, 0, 0, + 10468, 10469, 1, 0, 0, 0, 10469, 1047, 1, 0, 0, 0, 10470, 10474, 5, 1163, + 0, 0, 10471, 10472, 3, 2258, 1129, 0, 10472, 10473, 5, 2369, 0, 0, 10473, + 10475, 1, 0, 0, 0, 10474, 10471, 1, 0, 0, 0, 10474, 10475, 1, 0, 0, 0, + 10475, 10476, 1, 0, 0, 0, 10476, 10478, 3, 1050, 525, 0, 10477, 10479, + 3, 1058, 529, 0, 10478, 10477, 1, 0, 0, 0, 10478, 10479, 1, 0, 0, 0, 10479, + 10491, 1, 0, 0, 0, 10480, 10481, 5, 2376, 0, 0, 10481, 10486, 3, 1056, + 528, 0, 10482, 10483, 5, 2382, 0, 0, 10483, 10485, 3, 1056, 528, 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, 10489, 1, 0, 0, 0, 10488, 10486, 1, 0, + 0, 0, 10489, 10490, 5, 2377, 0, 0, 10490, 10492, 1, 0, 0, 0, 10491, 10480, + 1, 0, 0, 0, 10491, 10492, 1, 0, 0, 0, 10492, 10497, 1, 0, 0, 0, 10493, + 10494, 5, 1175, 0, 0, 10494, 10495, 5, 227, 0, 0, 10495, 10496, 7, 112, + 0, 0, 10496, 10498, 5, 1508, 0, 0, 10497, 10493, 1, 0, 0, 0, 10497, 10498, + 1, 0, 0, 0, 10498, 10500, 1, 0, 0, 0, 10499, 10501, 3, 1054, 527, 0, 10500, + 10499, 1, 0, 0, 0, 10500, 10501, 1, 0, 0, 0, 10501, 10503, 1, 0, 0, 0, + 10502, 10504, 3, 1052, 526, 0, 10503, 10502, 1, 0, 0, 0, 10503, 10504, + 1, 0, 0, 0, 10504, 10506, 1, 0, 0, 0, 10505, 10507, 3, 1196, 598, 0, 10506, + 10505, 1, 0, 0, 0, 10506, 10507, 1, 0, 0, 0, 10507, 10508, 1, 0, 0, 0, + 10508, 10509, 3, 1078, 539, 0, 10509, 1049, 1, 0, 0, 0, 10510, 10511, 3, + 2382, 1191, 0, 10511, 1051, 1, 0, 0, 0, 10512, 10514, 5, 1164, 0, 0, 10513, + 10515, 3, 2300, 1150, 0, 10514, 10513, 1, 0, 0, 0, 10514, 10515, 1, 0, + 0, 0, 10515, 10516, 1, 0, 0, 0, 10516, 10520, 5, 2376, 0, 0, 10517, 10521, + 3, 1188, 594, 0, 10518, 10519, 5, 1973, 0, 0, 10519, 10521, 3, 1666, 833, + 0, 10520, 10517, 1, 0, 0, 0, 10520, 10518, 1, 0, 0, 0, 10521, 10522, 1, + 0, 0, 0, 10522, 10520, 1, 0, 0, 0, 10522, 10523, 1, 0, 0, 0, 10523, 10524, + 1, 0, 0, 0, 10524, 10525, 5, 2377, 0, 0, 10525, 1053, 1, 0, 0, 0, 10526, + 10527, 5, 1155, 0, 0, 10527, 10528, 5, 629, 0, 0, 10528, 10533, 5, 723, + 0, 0, 10529, 10530, 5, 1842, 0, 0, 10530, 10534, 5, 584, 0, 0, 10531, 10532, + 5, 1355, 0, 0, 10532, 10534, 5, 753, 0, 0, 10533, 10529, 1, 0, 0, 0, 10533, + 10531, 1, 0, 0, 0, 10534, 1055, 1, 0, 0, 0, 10535, 10538, 3, 2310, 1155, + 0, 10536, 10538, 3, 2250, 1125, 0, 10537, 10535, 1, 0, 0, 0, 10537, 10536, + 1, 0, 0, 0, 10538, 10541, 1, 0, 0, 0, 10539, 10540, 5, 363, 0, 0, 10540, + 10542, 3, 2078, 1039, 0, 10541, 10539, 1, 0, 0, 0, 10541, 10542, 1, 0, + 0, 0, 10542, 10552, 1, 0, 0, 0, 10543, 10548, 3, 842, 421, 0, 10544, 10545, + 5, 2382, 0, 0, 10545, 10547, 3, 842, 421, 0, 10546, 10544, 1, 0, 0, 0, + 10547, 10550, 1, 0, 0, 0, 10548, 10546, 1, 0, 0, 0, 10548, 10549, 1, 0, + 0, 0, 10549, 10553, 1, 0, 0, 0, 10550, 10548, 1, 0, 0, 0, 10551, 10553, + 3, 844, 422, 0, 10552, 10543, 1, 0, 0, 0, 10552, 10551, 1, 0, 0, 0, 10552, + 10553, 1, 0, 0, 0, 10553, 10558, 1, 0, 0, 0, 10554, 10558, 3, 848, 424, + 0, 10555, 10558, 3, 846, 423, 0, 10556, 10558, 3, 1706, 853, 0, 10557, + 10537, 1, 0, 0, 0, 10557, 10554, 1, 0, 0, 0, 10557, 10555, 1, 0, 0, 0, + 10557, 10556, 1, 0, 0, 0, 10558, 1057, 1, 0, 0, 0, 10559, 10561, 5, 1121, + 0, 0, 10560, 10559, 1, 0, 0, 0, 10560, 10561, 1, 0, 0, 0, 10561, 10562, + 1, 0, 0, 0, 10562, 10563, 5, 1673, 0, 0, 10563, 10564, 5, 79, 0, 0, 10564, + 10565, 5, 37, 0, 0, 10565, 10566, 5, 783, 0, 0, 10566, 1059, 1, 0, 0, 0, + 10567, 10568, 5, 2376, 0, 0, 10568, 10573, 3, 1106, 553, 0, 10569, 10570, + 5, 2382, 0, 0, 10570, 10572, 3, 1106, 553, 0, 10571, 10569, 1, 0, 0, 0, + 10572, 10575, 1, 0, 0, 0, 10573, 10571, 1, 0, 0, 0, 10573, 10574, 1, 0, + 0, 0, 10574, 10576, 1, 0, 0, 0, 10575, 10573, 1, 0, 0, 0, 10576, 10577, + 5, 2377, 0, 0, 10577, 10579, 1, 0, 0, 0, 10578, 10567, 1, 0, 0, 0, 10578, + 10579, 1, 0, 0, 0, 10579, 10580, 1, 0, 0, 0, 10580, 10582, 3, 1062, 531, + 0, 10581, 10583, 3, 1068, 534, 0, 10582, 10581, 1, 0, 0, 0, 10582, 10583, + 1, 0, 0, 0, 10583, 10587, 1, 0, 0, 0, 10584, 10585, 5, 363, 0, 0, 10585, + 10586, 5, 2248, 0, 0, 10586, 10588, 3, 1076, 538, 0, 10587, 10584, 1, 0, + 0, 0, 10587, 10588, 1, 0, 0, 0, 10588, 10593, 1, 0, 0, 0, 10589, 10590, + 5, 1175, 0, 0, 10590, 10591, 5, 227, 0, 0, 10591, 10592, 7, 114, 0, 0, + 10592, 10594, 5, 2249, 0, 0, 10593, 10589, 1, 0, 0, 0, 10593, 10594, 1, + 0, 0, 0, 10594, 10599, 1, 0, 0, 0, 10595, 10596, 5, 1175, 0, 0, 10596, + 10597, 5, 227, 0, 0, 10597, 10598, 7, 112, 0, 0, 10598, 10600, 5, 1508, + 0, 0, 10599, 10595, 1, 0, 0, 0, 10599, 10600, 1, 0, 0, 0, 10600, 10602, + 1, 0, 0, 0, 10601, 10603, 3, 1196, 598, 0, 10602, 10601, 1, 0, 0, 0, 10602, + 10603, 1, 0, 0, 0, 10603, 10604, 1, 0, 0, 0, 10604, 10605, 3, 1078, 539, + 0, 10605, 1061, 1, 0, 0, 0, 10606, 10608, 3, 1064, 532, 0, 10607, 10606, + 1, 0, 0, 0, 10607, 10608, 1, 0, 0, 0, 10608, 10610, 1, 0, 0, 0, 10609, + 10611, 3, 1066, 533, 0, 10610, 10609, 1, 0, 0, 0, 10610, 10611, 1, 0, 0, + 0, 10611, 1063, 1, 0, 0, 0, 10612, 10613, 5, 1057, 0, 0, 10613, 10619, + 5, 425, 0, 0, 10614, 10615, 5, 2086, 0, 0, 10615, 10616, 3, 2368, 1184, + 0, 10616, 10617, 5, 342, 0, 0, 10617, 10618, 5, 2253, 0, 0, 10618, 10620, + 1, 0, 0, 0, 10619, 10614, 1, 0, 0, 0, 10619, 10620, 1, 0, 0, 0, 10620, + 1065, 1, 0, 0, 0, 10621, 10622, 5, 1057, 0, 0, 10622, 10634, 5, 376, 0, + 0, 10623, 10625, 5, 810, 0, 0, 10624, 10623, 1, 0, 0, 0, 10624, 10625, + 1, 0, 0, 0, 10625, 10635, 1, 0, 0, 0, 10626, 10627, 5, 2086, 0, 0, 10627, + 10628, 3, 2368, 1184, 0, 10628, 10629, 5, 342, 0, 0, 10629, 10630, 5, 32, + 0, 0, 10630, 10632, 5, 697, 0, 0, 10631, 10633, 5, 810, 0, 0, 10632, 10631, + 1, 0, 0, 0, 10632, 10633, 1, 0, 0, 0, 10633, 10635, 1, 0, 0, 0, 10634, + 10624, 1, 0, 0, 0, 10634, 10626, 1, 0, 0, 0, 10635, 1067, 1, 0, 0, 0, 10636, + 10637, 3, 1070, 535, 0, 10637, 10638, 3, 1072, 536, 0, 10638, 10639, 3, + 1074, 537, 0, 10639, 1069, 1, 0, 0, 0, 10640, 10641, 5, 1057, 0, 0, 10641, + 10647, 5, 425, 0, 0, 10642, 10643, 5, 2086, 0, 0, 10643, 10644, 3, 2368, + 1184, 0, 10644, 10645, 5, 342, 0, 0, 10645, 10646, 5, 2253, 0, 0, 10646, + 10648, 1, 0, 0, 0, 10647, 10642, 1, 0, 0, 0, 10647, 10648, 1, 0, 0, 0, + 10648, 1071, 1, 0, 0, 0, 10649, 10650, 5, 1057, 0, 0, 10650, 10662, 5, + 376, 0, 0, 10651, 10653, 5, 810, 0, 0, 10652, 10651, 1, 0, 0, 0, 10652, + 10653, 1, 0, 0, 0, 10653, 10663, 1, 0, 0, 0, 10654, 10655, 5, 2086, 0, + 0, 10655, 10656, 3, 2368, 1184, 0, 10656, 10657, 5, 342, 0, 0, 10657, 10658, + 5, 32, 0, 0, 10658, 10660, 5, 697, 0, 0, 10659, 10661, 5, 810, 0, 0, 10660, + 10659, 1, 0, 0, 0, 10660, 10661, 1, 0, 0, 0, 10661, 10663, 1, 0, 0, 0, + 10662, 10652, 1, 0, 0, 0, 10662, 10654, 1, 0, 0, 0, 10663, 1073, 1, 0, + 0, 0, 10664, 10665, 5, 2252, 0, 0, 10665, 10666, 5, 2129, 0, 0, 10666, + 10667, 5, 2259, 0, 0, 10667, 10668, 5, 2165, 0, 0, 10668, 10669, 5, 2261, + 0, 0, 10669, 1075, 1, 0, 0, 0, 10670, 10671, 3, 2376, 1188, 0, 10671, 1077, + 1, 0, 0, 0, 10672, 10674, 3, 1670, 835, 0, 10673, 10672, 1, 0, 0, 0, 10673, + 10674, 1, 0, 0, 0, 10674, 10676, 1, 0, 0, 0, 10675, 10677, 3, 1080, 540, + 0, 10676, 10675, 1, 0, 0, 0, 10676, 10677, 1, 0, 0, 0, 10677, 10679, 1, + 0, 0, 0, 10678, 10680, 3, 1082, 541, 0, 10679, 10678, 1, 0, 0, 0, 10679, + 10680, 1, 0, 0, 0, 10680, 10682, 1, 0, 0, 0, 10681, 10683, 3, 1108, 554, + 0, 10682, 10681, 1, 0, 0, 0, 10682, 10683, 1, 0, 0, 0, 10683, 10685, 1, + 0, 0, 0, 10684, 10686, 3, 1084, 542, 0, 10685, 10684, 1, 0, 0, 0, 10685, + 10686, 1, 0, 0, 0, 10686, 10688, 1, 0, 0, 0, 10687, 10689, 7, 103, 0, 0, + 10688, 10687, 1, 0, 0, 0, 10688, 10689, 1, 0, 0, 0, 10689, 10691, 1, 0, + 0, 0, 10690, 10692, 3, 116, 58, 0, 10691, 10690, 1, 0, 0, 0, 10691, 10692, + 1, 0, 0, 0, 10692, 10694, 1, 0, 0, 0, 10693, 10695, 3, 926, 463, 0, 10694, + 10693, 1, 0, 0, 0, 10694, 10695, 1, 0, 0, 0, 10695, 10697, 1, 0, 0, 0, + 10696, 10698, 7, 107, 0, 0, 10697, 10696, 1, 0, 0, 0, 10697, 10698, 1, + 0, 0, 0, 10698, 10702, 1, 0, 0, 0, 10699, 10701, 3, 1592, 796, 0, 10700, + 10699, 1, 0, 0, 0, 10701, 10704, 1, 0, 0, 0, 10702, 10700, 1, 0, 0, 0, + 10702, 10703, 1, 0, 0, 0, 10703, 10706, 1, 0, 0, 0, 10704, 10702, 1, 0, + 0, 0, 10705, 10707, 3, 1286, 643, 0, 10706, 10705, 1, 0, 0, 0, 10706, 10707, + 1, 0, 0, 0, 10707, 10709, 1, 0, 0, 0, 10708, 10710, 3, 1102, 551, 0, 10709, + 10708, 1, 0, 0, 0, 10709, 10710, 1, 0, 0, 0, 10710, 10712, 1, 0, 0, 0, + 10711, 10713, 3, 1288, 644, 0, 10712, 10711, 1, 0, 0, 0, 10712, 10713, + 1, 0, 0, 0, 10713, 10715, 1, 0, 0, 0, 10714, 10716, 3, 1196, 598, 0, 10715, + 10714, 1, 0, 0, 0, 10715, 10716, 1, 0, 0, 0, 10716, 10719, 1, 0, 0, 0, + 10717, 10718, 5, 1507, 0, 0, 10718, 10720, 5, 61, 0, 0, 10719, 10717, 1, + 0, 0, 0, 10719, 10720, 1, 0, 0, 0, 10720, 10733, 1, 0, 0, 0, 10721, 10722, + 5, 66, 0, 0, 10722, 10734, 3, 1880, 940, 0, 10723, 10724, 5, 564, 0, 0, + 10724, 10725, 5, 485, 0, 0, 10725, 10726, 5, 2188, 0, 0, 10726, 10730, + 5, 1976, 0, 0, 10727, 10728, 3, 2258, 1129, 0, 10728, 10729, 5, 2369, 0, + 0, 10729, 10731, 1, 0, 0, 0, 10730, 10727, 1, 0, 0, 0, 10730, 10731, 1, + 0, 0, 0, 10731, 10732, 1, 0, 0, 0, 10732, 10734, 3, 1104, 552, 0, 10733, + 10721, 1, 0, 0, 0, 10733, 10723, 1, 0, 0, 0, 10733, 10734, 1, 0, 0, 0, + 10734, 1079, 1, 0, 0, 0, 10735, 10736, 5, 1408, 0, 0, 10736, 10737, 7, + 11, 0, 0, 10737, 1081, 1, 0, 0, 0, 10738, 10739, 5, 660, 0, 0, 10739, 10740, + 7, 92, 0, 0, 10740, 1083, 1, 0, 0, 0, 10741, 10743, 5, 210, 0, 0, 10742, + 10744, 3, 1086, 543, 0, 10743, 10742, 1, 0, 0, 0, 10743, 10744, 1, 0, 0, + 0, 10744, 10745, 1, 0, 0, 0, 10745, 10751, 3, 1092, 546, 0, 10746, 10748, + 3, 1098, 549, 0, 10747, 10746, 1, 0, 0, 0, 10747, 10748, 1, 0, 0, 0, 10748, + 10749, 1, 0, 0, 0, 10749, 10750, 5, 1175, 0, 0, 10750, 10752, 5, 799, 0, + 0, 10751, 10747, 1, 0, 0, 0, 10751, 10752, 1, 0, 0, 0, 10752, 10759, 1, + 0, 0, 0, 10753, 10755, 3, 1098, 549, 0, 10754, 10753, 1, 0, 0, 0, 10754, + 10755, 1, 0, 0, 0, 10755, 10756, 1, 0, 0, 0, 10756, 10757, 5, 1175, 0, + 0, 10757, 10758, 5, 330, 0, 0, 10758, 10760, 5, 920, 0, 0, 10759, 10754, + 1, 0, 0, 0, 10759, 10760, 1, 0, 0, 0, 10760, 10762, 1, 0, 0, 0, 10761, + 10763, 3, 1100, 550, 0, 10762, 10761, 1, 0, 0, 0, 10762, 10763, 1, 0, 0, + 0, 10763, 1085, 1, 0, 0, 0, 10764, 10765, 3, 2258, 1129, 0, 10765, 10766, + 5, 2369, 0, 0, 10766, 10768, 1, 0, 0, 0, 10767, 10764, 1, 0, 0, 0, 10767, + 10768, 1, 0, 0, 0, 10768, 10769, 1, 0, 0, 0, 10769, 10770, 3, 1104, 552, + 0, 10770, 10775, 3, 1088, 544, 0, 10771, 10772, 5, 2382, 0, 0, 10772, 10774, + 3, 1088, 544, 0, 10773, 10771, 1, 0, 0, 0, 10774, 10777, 1, 0, 0, 0, 10775, + 10773, 1, 0, 0, 0, 10775, 10776, 1, 0, 0, 0, 10776, 1087, 1, 0, 0, 0, 10777, + 10775, 1, 0, 0, 0, 10778, 10782, 5, 731, 0, 0, 10779, 10780, 3, 2258, 1129, + 0, 10780, 10781, 5, 2369, 0, 0, 10781, 10783, 1, 0, 0, 0, 10782, 10779, + 1, 0, 0, 0, 10782, 10783, 1, 0, 0, 0, 10783, 10784, 1, 0, 0, 0, 10784, + 10785, 3, 1104, 552, 0, 10785, 10786, 5, 1175, 0, 0, 10786, 10787, 5, 2376, + 0, 0, 10787, 10788, 3, 1090, 545, 0, 10788, 10789, 5, 2377, 0, 0, 10789, + 1089, 1, 0, 0, 0, 10790, 10791, 3, 2078, 1039, 0, 10791, 1091, 1, 0, 0, + 0, 10792, 10794, 5, 151, 0, 0, 10793, 10795, 7, 115, 0, 0, 10794, 10793, + 1, 0, 0, 0, 10794, 10795, 1, 0, 0, 0, 10795, 10796, 1, 0, 0, 0, 10796, + 10797, 5, 1215, 0, 0, 10797, 10798, 3, 1094, 547, 0, 10798, 1093, 1, 0, + 0, 0, 10799, 10812, 3, 1096, 548, 0, 10800, 10801, 5, 2376, 0, 0, 10801, + 10806, 3, 1096, 548, 0, 10802, 10803, 5, 2382, 0, 0, 10803, 10805, 3, 1096, + 548, 0, 10804, 10802, 1, 0, 0, 0, 10805, 10808, 1, 0, 0, 0, 10806, 10804, + 1, 0, 0, 0, 10806, 10807, 1, 0, 0, 0, 10807, 10809, 1, 0, 0, 0, 10808, + 10806, 1, 0, 0, 0, 10809, 10810, 5, 2377, 0, 0, 10810, 10812, 1, 0, 0, + 0, 10811, 10799, 1, 0, 0, 0, 10811, 10800, 1, 0, 0, 0, 10812, 1095, 1, + 0, 0, 0, 10813, 10814, 5, 2376, 0, 0, 10814, 10819, 3, 2310, 1155, 0, 10815, + 10816, 5, 2382, 0, 0, 10816, 10818, 3, 2310, 1155, 0, 10817, 10815, 1, + 0, 0, 0, 10818, 10821, 1, 0, 0, 0, 10819, 10817, 1, 0, 0, 0, 10819, 10820, + 1, 0, 0, 0, 10820, 10822, 1, 0, 0, 0, 10821, 10819, 1, 0, 0, 0, 10822, + 10823, 5, 2377, 0, 0, 10823, 1097, 1, 0, 0, 0, 10824, 10825, 7, 116, 0, + 0, 10825, 1099, 1, 0, 0, 0, 10826, 10827, 5, 2188, 0, 0, 10827, 10828, + 5, 848, 0, 0, 10828, 10833, 5, 2238, 0, 0, 10829, 10830, 5, 2376, 0, 0, + 10830, 10831, 3, 970, 485, 0, 10831, 10832, 5, 2377, 0, 0, 10832, 10834, + 1, 0, 0, 0, 10833, 10829, 1, 0, 0, 0, 10833, 10834, 1, 0, 0, 0, 10834, + 10839, 1, 0, 0, 0, 10835, 10836, 5, 2186, 0, 0, 10836, 10837, 5, 848, 0, + 0, 10837, 10839, 5, 2238, 0, 0, 10838, 10826, 1, 0, 0, 0, 10838, 10835, + 1, 0, 0, 0, 10839, 1101, 1, 0, 0, 0, 10840, 10841, 5, 398, 0, 0, 10841, + 10842, 5, 816, 0, 0, 10842, 10855, 5, 1464, 0, 0, 10843, 10844, 5, 453, + 0, 0, 10844, 10845, 5, 816, 0, 0, 10845, 10852, 5, 1464, 0, 0, 10846, 10850, + 5, 37, 0, 0, 10847, 10848, 5, 39, 0, 0, 10848, 10850, 5, 1132, 0, 0, 10849, + 10846, 1, 0, 0, 0, 10849, 10847, 1, 0, 0, 0, 10850, 10851, 1, 0, 0, 0, + 10851, 10853, 5, 756, 0, 0, 10852, 10849, 1, 0, 0, 0, 10852, 10853, 1, + 0, 0, 0, 10853, 10855, 1, 0, 0, 0, 10854, 10840, 1, 0, 0, 0, 10854, 10843, + 1, 0, 0, 0, 10855, 1103, 1, 0, 0, 0, 10856, 10857, 3, 2376, 1188, 0, 10857, + 1105, 1, 0, 0, 0, 10858, 10865, 3, 1680, 840, 0, 10859, 10865, 3, 1690, + 845, 0, 10860, 10865, 3, 1674, 837, 0, 10861, 10865, 3, 848, 424, 0, 10862, + 10865, 3, 846, 423, 0, 10863, 10865, 3, 1706, 853, 0, 10864, 10858, 1, + 0, 0, 0, 10864, 10859, 1, 0, 0, 0, 10864, 10860, 1, 0, 0, 0, 10864, 10861, + 1, 0, 0, 0, 10864, 10862, 1, 0, 0, 0, 10864, 10863, 1, 0, 0, 0, 10865, + 1107, 1, 0, 0, 0, 10866, 10875, 3, 1110, 555, 0, 10867, 10875, 3, 1112, + 556, 0, 10868, 10875, 3, 1114, 557, 0, 10869, 10875, 3, 1122, 561, 0, 10870, + 10875, 3, 1124, 562, 0, 10871, 10875, 3, 1126, 563, 0, 10872, 10875, 3, + 1128, 564, 0, 10873, 10875, 3, 1132, 566, 0, 10874, 10866, 1, 0, 0, 0, + 10874, 10867, 1, 0, 0, 0, 10874, 10868, 1, 0, 0, 0, 10874, 10869, 1, 0, + 0, 0, 10874, 10870, 1, 0, 0, 0, 10874, 10871, 1, 0, 0, 0, 10874, 10872, + 1, 0, 0, 0, 10874, 10873, 1, 0, 0, 0, 10875, 1109, 1, 0, 0, 0, 10876, 10877, + 5, 1256, 0, 0, 10877, 10878, 5, 151, 0, 0, 10878, 10879, 5, 1399, 0, 0, + 10879, 10880, 5, 2376, 0, 0, 10880, 10885, 3, 2310, 1155, 0, 10881, 10882, + 5, 2382, 0, 0, 10882, 10884, 3, 2310, 1155, 0, 10883, 10881, 1, 0, 0, 0, + 10884, 10887, 1, 0, 0, 0, 10885, 10883, 1, 0, 0, 0, 10885, 10886, 1, 0, + 0, 0, 10886, 10888, 1, 0, 0, 0, 10887, 10885, 1, 0, 0, 0, 10888, 10908, + 5, 2377, 0, 0, 10889, 10890, 5, 717, 0, 0, 10890, 10891, 5, 2376, 0, 0, + 10891, 10892, 3, 2078, 1039, 0, 10892, 10906, 5, 2377, 0, 0, 10893, 10894, + 5, 1656, 0, 0, 10894, 10895, 5, 680, 0, 0, 10895, 10896, 5, 2376, 0, 0, + 10896, 10901, 3, 1666, 833, 0, 10897, 10898, 5, 2382, 0, 0, 10898, 10900, + 3, 1666, 833, 0, 10899, 10897, 1, 0, 0, 0, 10900, 10903, 1, 0, 0, 0, 10901, + 10899, 1, 0, 0, 0, 10901, 10902, 1, 0, 0, 0, 10902, 10904, 1, 0, 0, 0, + 10903, 10901, 1, 0, 0, 0, 10904, 10905, 5, 2377, 0, 0, 10905, 10907, 1, + 0, 0, 0, 10906, 10893, 1, 0, 0, 0, 10906, 10907, 1, 0, 0, 0, 10907, 10909, + 1, 0, 0, 0, 10908, 10889, 1, 0, 0, 0, 10908, 10909, 1, 0, 0, 0, 10909, + 10910, 1, 0, 0, 0, 10910, 10911, 5, 2376, 0, 0, 10911, 10913, 5, 1256, + 0, 0, 10912, 10914, 3, 1704, 852, 0, 10913, 10912, 1, 0, 0, 0, 10913, 10914, + 1, 0, 0, 0, 10914, 10915, 1, 0, 0, 0, 10915, 10916, 3, 1158, 579, 0, 10916, + 10927, 3, 1162, 581, 0, 10917, 10918, 5, 2382, 0, 0, 10918, 10920, 5, 1256, + 0, 0, 10919, 10921, 3, 1704, 852, 0, 10920, 10919, 1, 0, 0, 0, 10920, 10921, + 1, 0, 0, 0, 10921, 10922, 1, 0, 0, 0, 10922, 10923, 3, 1158, 579, 0, 10923, + 10924, 3, 1162, 581, 0, 10924, 10926, 1, 0, 0, 0, 10925, 10917, 1, 0, 0, + 0, 10926, 10929, 1, 0, 0, 0, 10927, 10925, 1, 0, 0, 0, 10927, 10928, 1, + 0, 0, 0, 10928, 10930, 1, 0, 0, 0, 10929, 10927, 1, 0, 0, 0, 10930, 10931, + 5, 2377, 0, 0, 10931, 1111, 1, 0, 0, 0, 10932, 10933, 5, 1256, 0, 0, 10933, + 10934, 5, 151, 0, 0, 10934, 10935, 5, 796, 0, 0, 10935, 10936, 5, 2376, + 0, 0, 10936, 10937, 3, 2310, 1155, 0, 10937, 10938, 5, 2377, 0, 0, 10938, + 10939, 5, 2376, 0, 0, 10939, 10941, 5, 1256, 0, 0, 10940, 10942, 3, 1704, + 852, 0, 10941, 10940, 1, 0, 0, 0, 10941, 10942, 1, 0, 0, 0, 10942, 10943, + 1, 0, 0, 0, 10943, 10944, 3, 1160, 580, 0, 10944, 10955, 3, 1162, 581, + 0, 10945, 10946, 5, 2382, 0, 0, 10946, 10948, 5, 1256, 0, 0, 10947, 10949, + 3, 1704, 852, 0, 10948, 10947, 1, 0, 0, 0, 10948, 10949, 1, 0, 0, 0, 10949, + 10950, 1, 0, 0, 0, 10950, 10951, 3, 1160, 580, 0, 10951, 10952, 3, 1162, + 581, 0, 10952, 10954, 1, 0, 0, 0, 10953, 10945, 1, 0, 0, 0, 10954, 10957, + 1, 0, 0, 0, 10955, 10953, 1, 0, 0, 0, 10955, 10956, 1, 0, 0, 0, 10956, + 10958, 1, 0, 0, 0, 10957, 10955, 1, 0, 0, 0, 10958, 10959, 5, 2377, 0, + 0, 10959, 1113, 1, 0, 0, 0, 10960, 10961, 5, 1256, 0, 0, 10961, 10962, + 5, 151, 0, 0, 10962, 10963, 5, 603, 0, 0, 10963, 10964, 5, 2376, 0, 0, + 10964, 10969, 3, 2310, 1155, 0, 10965, 10966, 5, 2382, 0, 0, 10966, 10968, + 3, 2310, 1155, 0, 10967, 10965, 1, 0, 0, 0, 10968, 10971, 1, 0, 0, 0, 10969, + 10967, 1, 0, 0, 0, 10969, 10970, 1, 0, 0, 0, 10970, 10972, 1, 0, 0, 0, + 10971, 10969, 1, 0, 0, 0, 10972, 10975, 5, 2377, 0, 0, 10973, 10976, 3, + 1116, 558, 0, 10974, 10976, 3, 1118, 559, 0, 10975, 10973, 1, 0, 0, 0, + 10975, 10974, 1, 0, 0, 0, 10976, 1115, 1, 0, 0, 0, 10977, 10978, 5, 2376, + 0, 0, 10978, 10980, 5, 1256, 0, 0, 10979, 10981, 3, 1704, 852, 0, 10980, + 10979, 1, 0, 0, 0, 10980, 10981, 1, 0, 0, 0, 10981, 10983, 1, 0, 0, 0, + 10982, 10984, 3, 1164, 582, 0, 10983, 10982, 1, 0, 0, 0, 10983, 10984, + 1, 0, 0, 0, 10984, 10995, 1, 0, 0, 0, 10985, 10986, 5, 2382, 0, 0, 10986, + 10988, 5, 1256, 0, 0, 10987, 10989, 3, 1704, 852, 0, 10988, 10987, 1, 0, + 0, 0, 10988, 10989, 1, 0, 0, 0, 10989, 10991, 1, 0, 0, 0, 10990, 10992, + 3, 1164, 582, 0, 10991, 10990, 1, 0, 0, 0, 10991, 10992, 1, 0, 0, 0, 10992, + 10994, 1, 0, 0, 0, 10993, 10985, 1, 0, 0, 0, 10994, 10997, 1, 0, 0, 0, + 10995, 10993, 1, 0, 0, 0, 10995, 10996, 1, 0, 0, 0, 10996, 10998, 1, 0, + 0, 0, 10997, 10995, 1, 0, 0, 0, 10998, 10999, 5, 2377, 0, 0, 10999, 1117, + 1, 0, 0, 0, 11000, 11001, 5, 1258, 0, 0, 11001, 11015, 3, 1120, 560, 0, + 11002, 11003, 5, 1656, 0, 0, 11003, 11004, 5, 680, 0, 0, 11004, 11005, + 5, 2376, 0, 0, 11005, 11010, 3, 1666, 833, 0, 11006, 11007, 5, 2382, 0, + 0, 11007, 11009, 3, 1666, 833, 0, 11008, 11006, 1, 0, 0, 0, 11009, 11012, + 1, 0, 0, 0, 11010, 11008, 1, 0, 0, 0, 11010, 11011, 1, 0, 0, 0, 11011, + 11013, 1, 0, 0, 0, 11012, 11010, 1, 0, 0, 0, 11013, 11014, 5, 2377, 0, + 0, 11014, 11016, 1, 0, 0, 0, 11015, 11002, 1, 0, 0, 0, 11015, 11016, 1, + 0, 0, 0, 11016, 11019, 1, 0, 0, 0, 11017, 11020, 3, 1172, 586, 0, 11018, + 11020, 3, 1608, 804, 0, 11019, 11017, 1, 0, 0, 0, 11019, 11018, 1, 0, 0, + 0, 11019, 11020, 1, 0, 0, 0, 11020, 11035, 1, 0, 0, 0, 11021, 11022, 5, + 1231, 0, 0, 11022, 11023, 5, 1656, 0, 0, 11023, 11024, 5, 680, 0, 0, 11024, + 11025, 5, 2376, 0, 0, 11025, 11030, 3, 1666, 833, 0, 11026, 11027, 5, 2382, + 0, 0, 11027, 11029, 3, 1666, 833, 0, 11028, 11026, 1, 0, 0, 0, 11029, 11032, + 1, 0, 0, 0, 11030, 11028, 1, 0, 0, 0, 11030, 11031, 1, 0, 0, 0, 11031, + 11033, 1, 0, 0, 0, 11032, 11030, 1, 0, 0, 0, 11033, 11034, 5, 2377, 0, + 0, 11034, 11036, 1, 0, 0, 0, 11035, 11021, 1, 0, 0, 0, 11035, 11036, 1, + 0, 0, 0, 11036, 1119, 1, 0, 0, 0, 11037, 11038, 5, 2370, 0, 0, 11038, 1121, + 1, 0, 0, 0, 11039, 11040, 5, 1256, 0, 0, 11040, 11041, 5, 151, 0, 0, 11041, + 11042, 5, 1399, 0, 0, 11042, 11043, 5, 2376, 0, 0, 11043, 11048, 3, 2310, + 1155, 0, 11044, 11045, 5, 2382, 0, 0, 11045, 11047, 3, 2310, 1155, 0, 11046, + 11044, 1, 0, 0, 0, 11047, 11050, 1, 0, 0, 0, 11048, 11046, 1, 0, 0, 0, + 11048, 11049, 1, 0, 0, 0, 11049, 11051, 1, 0, 0, 0, 11050, 11048, 1, 0, + 0, 0, 11051, 11071, 5, 2377, 0, 0, 11052, 11053, 5, 717, 0, 0, 11053, 11054, + 5, 2376, 0, 0, 11054, 11055, 3, 2078, 1039, 0, 11055, 11069, 5, 2377, 0, + 0, 11056, 11057, 5, 1656, 0, 0, 11057, 11058, 5, 680, 0, 0, 11058, 11059, + 5, 2376, 0, 0, 11059, 11064, 3, 1666, 833, 0, 11060, 11061, 5, 2382, 0, + 0, 11061, 11063, 3, 1666, 833, 0, 11062, 11060, 1, 0, 0, 0, 11063, 11066, + 1, 0, 0, 0, 11064, 11062, 1, 0, 0, 0, 11064, 11065, 1, 0, 0, 0, 11065, + 11067, 1, 0, 0, 0, 11066, 11064, 1, 0, 0, 0, 11067, 11068, 5, 2377, 0, + 0, 11068, 11070, 1, 0, 0, 0, 11069, 11056, 1, 0, 0, 0, 11069, 11070, 1, + 0, 0, 0, 11070, 11072, 1, 0, 0, 0, 11071, 11052, 1, 0, 0, 0, 11071, 11072, + 1, 0, 0, 0, 11072, 11076, 1, 0, 0, 0, 11073, 11077, 3, 1142, 571, 0, 11074, + 11077, 3, 1144, 572, 0, 11075, 11077, 3, 1146, 573, 0, 11076, 11073, 1, + 0, 0, 0, 11076, 11074, 1, 0, 0, 0, 11076, 11075, 1, 0, 0, 0, 11077, 11078, + 1, 0, 0, 0, 11078, 11079, 5, 2376, 0, 0, 11079, 11084, 3, 1134, 567, 0, + 11080, 11081, 5, 2382, 0, 0, 11081, 11083, 3, 1134, 567, 0, 11082, 11080, + 1, 0, 0, 0, 11083, 11086, 1, 0, 0, 0, 11084, 11082, 1, 0, 0, 0, 11084, + 11085, 1, 0, 0, 0, 11085, 11087, 1, 0, 0, 0, 11086, 11084, 1, 0, 0, 0, + 11087, 11088, 5, 2377, 0, 0, 11088, 1123, 1, 0, 0, 0, 11089, 11090, 5, + 1256, 0, 0, 11090, 11091, 5, 151, 0, 0, 11091, 11092, 5, 796, 0, 0, 11092, + 11093, 5, 2376, 0, 0, 11093, 11094, 3, 2310, 1155, 0, 11094, 11098, 5, + 2377, 0, 0, 11095, 11099, 3, 1142, 571, 0, 11096, 11099, 3, 1144, 572, + 0, 11097, 11099, 3, 1146, 573, 0, 11098, 11095, 1, 0, 0, 0, 11098, 11096, + 1, 0, 0, 0, 11098, 11097, 1, 0, 0, 0, 11099, 11100, 1, 0, 0, 0, 11100, + 11101, 5, 2376, 0, 0, 11101, 11106, 3, 1136, 568, 0, 11102, 11103, 5, 2382, + 0, 0, 11103, 11105, 3, 1136, 568, 0, 11104, 11102, 1, 0, 0, 0, 11105, 11108, + 1, 0, 0, 0, 11106, 11104, 1, 0, 0, 0, 11106, 11107, 1, 0, 0, 0, 11107, + 11109, 1, 0, 0, 0, 11108, 11106, 1, 0, 0, 0, 11109, 11110, 5, 2377, 0, + 0, 11110, 1125, 1, 0, 0, 0, 11111, 11112, 5, 1256, 0, 0, 11112, 11113, + 5, 151, 0, 0, 11113, 11114, 5, 603, 0, 0, 11114, 11117, 5, 2376, 0, 0, + 11115, 11116, 5, 2382, 0, 0, 11116, 11118, 3, 2310, 1155, 0, 11117, 11115, + 1, 0, 0, 0, 11118, 11119, 1, 0, 0, 0, 11119, 11117, 1, 0, 0, 0, 11119, + 11120, 1, 0, 0, 0, 11120, 11121, 1, 0, 0, 0, 11121, 11125, 5, 2377, 0, + 0, 11122, 11126, 3, 1142, 571, 0, 11123, 11126, 3, 1144, 572, 0, 11124, + 11126, 3, 1146, 573, 0, 11125, 11122, 1, 0, 0, 0, 11125, 11123, 1, 0, 0, + 0, 11125, 11124, 1, 0, 0, 0, 11126, 11129, 1, 0, 0, 0, 11127, 11130, 3, + 1116, 558, 0, 11128, 11130, 3, 1118, 559, 0, 11129, 11127, 1, 0, 0, 0, + 11129, 11128, 1, 0, 0, 0, 11130, 1127, 1, 0, 0, 0, 11131, 11132, 5, 1256, + 0, 0, 11132, 11133, 5, 151, 0, 0, 11133, 11134, 5, 1428, 0, 0, 11134, 11135, + 5, 2376, 0, 0, 11135, 11136, 3, 2382, 1191, 0, 11136, 11148, 5, 2377, 0, + 0, 11137, 11138, 5, 2376, 0, 0, 11138, 11143, 3, 1130, 565, 0, 11139, 11140, + 5, 2382, 0, 0, 11140, 11142, 3, 1130, 565, 0, 11141, 11139, 1, 0, 0, 0, + 11142, 11145, 1, 0, 0, 0, 11143, 11141, 1, 0, 0, 0, 11143, 11144, 1, 0, + 0, 0, 11144, 11146, 1, 0, 0, 0, 11145, 11143, 1, 0, 0, 0, 11146, 11147, + 5, 2377, 0, 0, 11147, 11149, 1, 0, 0, 0, 11148, 11137, 1, 0, 0, 0, 11148, + 11149, 1, 0, 0, 0, 11149, 1129, 1, 0, 0, 0, 11150, 11152, 5, 1256, 0, 0, + 11151, 11153, 3, 1704, 852, 0, 11152, 11151, 1, 0, 0, 0, 11152, 11153, + 1, 0, 0, 0, 11153, 11154, 1, 0, 0, 0, 11154, 11155, 3, 1162, 581, 0, 11155, + 1131, 1, 0, 0, 0, 11156, 11157, 5, 1256, 0, 0, 11157, 11158, 5, 151, 0, + 0, 11158, 11169, 5, 1842, 0, 0, 11159, 11160, 5, 1258, 0, 0, 11160, 11170, + 5, 2370, 0, 0, 11161, 11166, 3, 1130, 565, 0, 11162, 11163, 5, 2382, 0, + 0, 11163, 11165, 3, 1130, 565, 0, 11164, 11162, 1, 0, 0, 0, 11165, 11168, + 1, 0, 0, 0, 11166, 11164, 1, 0, 0, 0, 11166, 11167, 1, 0, 0, 0, 11167, + 11170, 1, 0, 0, 0, 11168, 11166, 1, 0, 0, 0, 11169, 11159, 1, 0, 0, 0, + 11169, 11161, 1, 0, 0, 0, 11169, 11170, 1, 0, 0, 0, 11170, 1133, 1, 0, + 0, 0, 11171, 11173, 5, 1256, 0, 0, 11172, 11174, 3, 1704, 852, 0, 11173, + 11172, 1, 0, 0, 0, 11173, 11174, 1, 0, 0, 0, 11174, 11175, 1, 0, 0, 0, + 11175, 11176, 3, 1158, 579, 0, 11176, 11209, 3, 1162, 581, 0, 11177, 11202, + 5, 2376, 0, 0, 11178, 11183, 3, 1150, 575, 0, 11179, 11180, 5, 2382, 0, + 0, 11180, 11182, 3, 1150, 575, 0, 11181, 11179, 1, 0, 0, 0, 11182, 11185, + 1, 0, 0, 0, 11183, 11181, 1, 0, 0, 0, 11183, 11184, 1, 0, 0, 0, 11184, + 11203, 1, 0, 0, 0, 11185, 11183, 1, 0, 0, 0, 11186, 11191, 3, 1152, 576, + 0, 11187, 11188, 5, 2382, 0, 0, 11188, 11190, 3, 1152, 576, 0, 11189, 11187, + 1, 0, 0, 0, 11190, 11193, 1, 0, 0, 0, 11191, 11189, 1, 0, 0, 0, 11191, + 11192, 1, 0, 0, 0, 11192, 11203, 1, 0, 0, 0, 11193, 11191, 1, 0, 0, 0, + 11194, 11199, 3, 1154, 577, 0, 11195, 11196, 5, 2382, 0, 0, 11196, 11198, + 3, 1154, 577, 0, 11197, 11195, 1, 0, 0, 0, 11198, 11201, 1, 0, 0, 0, 11199, + 11197, 1, 0, 0, 0, 11199, 11200, 1, 0, 0, 0, 11200, 11203, 1, 0, 0, 0, + 11201, 11199, 1, 0, 0, 0, 11202, 11178, 1, 0, 0, 0, 11202, 11186, 1, 0, + 0, 0, 11202, 11194, 1, 0, 0, 0, 11203, 11204, 1, 0, 0, 0, 11204, 11205, + 5, 2377, 0, 0, 11205, 11208, 1, 0, 0, 0, 11206, 11208, 3, 1156, 578, 0, + 11207, 11177, 1, 0, 0, 0, 11207, 11206, 1, 0, 0, 0, 11208, 11210, 1, 0, + 0, 0, 11209, 11207, 1, 0, 0, 0, 11209, 11210, 1, 0, 0, 0, 11210, 1135, + 1, 0, 0, 0, 11211, 11213, 5, 1256, 0, 0, 11212, 11214, 3, 1704, 852, 0, + 11213, 11212, 1, 0, 0, 0, 11213, 11214, 1, 0, 0, 0, 11214, 11215, 1, 0, + 0, 0, 11215, 11216, 3, 1160, 580, 0, 11216, 11249, 3, 1162, 581, 0, 11217, + 11242, 5, 2376, 0, 0, 11218, 11223, 3, 1150, 575, 0, 11219, 11220, 5, 2382, + 0, 0, 11220, 11222, 3, 1150, 575, 0, 11221, 11219, 1, 0, 0, 0, 11222, 11225, + 1, 0, 0, 0, 11223, 11221, 1, 0, 0, 0, 11223, 11224, 1, 0, 0, 0, 11224, + 11243, 1, 0, 0, 0, 11225, 11223, 1, 0, 0, 0, 11226, 11231, 3, 1152, 576, + 0, 11227, 11228, 5, 2382, 0, 0, 11228, 11230, 3, 1152, 576, 0, 11229, 11227, + 1, 0, 0, 0, 11230, 11233, 1, 0, 0, 0, 11231, 11229, 1, 0, 0, 0, 11231, + 11232, 1, 0, 0, 0, 11232, 11243, 1, 0, 0, 0, 11233, 11231, 1, 0, 0, 0, + 11234, 11239, 3, 1154, 577, 0, 11235, 11236, 5, 2382, 0, 0, 11236, 11238, + 3, 1154, 577, 0, 11237, 11235, 1, 0, 0, 0, 11238, 11241, 1, 0, 0, 0, 11239, + 11237, 1, 0, 0, 0, 11239, 11240, 1, 0, 0, 0, 11240, 11243, 1, 0, 0, 0, + 11241, 11239, 1, 0, 0, 0, 11242, 11218, 1, 0, 0, 0, 11242, 11226, 1, 0, + 0, 0, 11242, 11234, 1, 0, 0, 0, 11243, 11244, 1, 0, 0, 0, 11244, 11245, + 5, 2377, 0, 0, 11245, 11248, 1, 0, 0, 0, 11246, 11248, 3, 1156, 578, 0, + 11247, 11217, 1, 0, 0, 0, 11247, 11246, 1, 0, 0, 0, 11248, 11250, 1, 0, + 0, 0, 11249, 11247, 1, 0, 0, 0, 11249, 11250, 1, 0, 0, 0, 11250, 1137, + 1, 0, 0, 0, 11251, 11252, 5, 1668, 0, 0, 11252, 11283, 5, 1983, 0, 0, 11253, + 11278, 5, 2376, 0, 0, 11254, 11259, 3, 1150, 575, 0, 11255, 11256, 5, 2382, + 0, 0, 11256, 11258, 3, 1150, 575, 0, 11257, 11255, 1, 0, 0, 0, 11258, 11261, + 1, 0, 0, 0, 11259, 11257, 1, 0, 0, 0, 11259, 11260, 1, 0, 0, 0, 11260, + 11279, 1, 0, 0, 0, 11261, 11259, 1, 0, 0, 0, 11262, 11267, 3, 1152, 576, + 0, 11263, 11264, 5, 2382, 0, 0, 11264, 11266, 3, 1152, 576, 0, 11265, 11263, + 1, 0, 0, 0, 11266, 11269, 1, 0, 0, 0, 11267, 11265, 1, 0, 0, 0, 11267, + 11268, 1, 0, 0, 0, 11268, 11279, 1, 0, 0, 0, 11269, 11267, 1, 0, 0, 0, + 11270, 11275, 3, 1154, 577, 0, 11271, 11272, 5, 2382, 0, 0, 11272, 11274, + 3, 1154, 577, 0, 11273, 11271, 1, 0, 0, 0, 11274, 11277, 1, 0, 0, 0, 11275, + 11273, 1, 0, 0, 0, 11275, 11276, 1, 0, 0, 0, 11276, 11279, 1, 0, 0, 0, + 11277, 11275, 1, 0, 0, 0, 11278, 11254, 1, 0, 0, 0, 11278, 11262, 1, 0, + 0, 0, 11278, 11270, 1, 0, 0, 0, 11279, 11280, 1, 0, 0, 0, 11280, 11281, + 5, 2377, 0, 0, 11281, 11284, 1, 0, 0, 0, 11282, 11284, 3, 1140, 570, 0, + 11283, 11253, 1, 0, 0, 0, 11283, 11282, 1, 0, 0, 0, 11284, 1139, 1, 0, + 0, 0, 11285, 11286, 5, 2370, 0, 0, 11286, 1141, 1, 0, 0, 0, 11287, 11288, + 5, 1668, 0, 0, 11288, 11289, 5, 151, 0, 0, 11289, 11290, 5, 1399, 0, 0, + 11290, 11291, 5, 2376, 0, 0, 11291, 11296, 3, 2310, 1155, 0, 11292, 11293, + 5, 2382, 0, 0, 11293, 11295, 3, 2310, 1155, 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, 11299, 1, 0, 0, 0, 11298, 11296, 1, 0, 0, 0, 11299, 11301, + 5, 2377, 0, 0, 11300, 11302, 3, 1138, 569, 0, 11301, 11300, 1, 0, 0, 0, + 11301, 11302, 1, 0, 0, 0, 11302, 1143, 1, 0, 0, 0, 11303, 11304, 5, 1668, + 0, 0, 11304, 11305, 5, 151, 0, 0, 11305, 11306, 5, 796, 0, 0, 11306, 11307, + 5, 2376, 0, 0, 11307, 11308, 3, 2310, 1155, 0, 11308, 11310, 5, 2377, 0, + 0, 11309, 11311, 3, 1138, 569, 0, 11310, 11309, 1, 0, 0, 0, 11310, 11311, + 1, 0, 0, 0, 11311, 1145, 1, 0, 0, 0, 11312, 11313, 5, 1668, 0, 0, 11313, + 11314, 5, 151, 0, 0, 11314, 11315, 5, 603, 0, 0, 11315, 11316, 5, 2376, + 0, 0, 11316, 11321, 3, 2310, 1155, 0, 11317, 11318, 5, 2382, 0, 0, 11318, + 11320, 3, 2310, 1155, 0, 11319, 11317, 1, 0, 0, 0, 11320, 11323, 1, 0, + 0, 0, 11321, 11319, 1, 0, 0, 0, 11321, 11322, 1, 0, 0, 0, 11322, 11324, + 1, 0, 0, 0, 11323, 11321, 1, 0, 0, 0, 11324, 11343, 5, 2377, 0, 0, 11325, + 11326, 5, 1667, 0, 0, 11326, 11340, 5, 2370, 0, 0, 11327, 11328, 5, 1656, + 0, 0, 11328, 11329, 5, 680, 0, 0, 11329, 11330, 5, 2376, 0, 0, 11330, 11335, + 3, 1666, 833, 0, 11331, 11332, 5, 2382, 0, 0, 11332, 11334, 3, 1666, 833, + 0, 11333, 11331, 1, 0, 0, 0, 11334, 11337, 1, 0, 0, 0, 11335, 11333, 1, + 0, 0, 0, 11335, 11336, 1, 0, 0, 0, 11336, 11338, 1, 0, 0, 0, 11337, 11335, + 1, 0, 0, 0, 11338, 11339, 5, 2377, 0, 0, 11339, 11341, 1, 0, 0, 0, 11340, + 11327, 1, 0, 0, 0, 11340, 11341, 1, 0, 0, 0, 11341, 11344, 1, 0, 0, 0, + 11342, 11344, 3, 1138, 569, 0, 11343, 11325, 1, 0, 0, 0, 11343, 11342, + 1, 0, 0, 0, 11343, 11344, 1, 0, 0, 0, 11344, 1147, 1, 0, 0, 0, 11345, 11346, + 3, 1704, 852, 0, 11346, 1149, 1, 0, 0, 0, 11347, 11349, 5, 1668, 0, 0, + 11348, 11350, 3, 1148, 574, 0, 11349, 11348, 1, 0, 0, 0, 11349, 11350, + 1, 0, 0, 0, 11350, 11351, 1, 0, 0, 0, 11351, 11353, 3, 1158, 579, 0, 11352, + 11354, 3, 1164, 582, 0, 11353, 11352, 1, 0, 0, 0, 11353, 11354, 1, 0, 0, + 0, 11354, 1151, 1, 0, 0, 0, 11355, 11357, 5, 1668, 0, 0, 11356, 11358, + 3, 1148, 574, 0, 11357, 11356, 1, 0, 0, 0, 11357, 11358, 1, 0, 0, 0, 11358, + 11359, 1, 0, 0, 0, 11359, 11361, 3, 1160, 580, 0, 11360, 11362, 3, 1164, + 582, 0, 11361, 11360, 1, 0, 0, 0, 11361, 11362, 1, 0, 0, 0, 11362, 1153, + 1, 0, 0, 0, 11363, 11365, 5, 1668, 0, 0, 11364, 11366, 3, 1148, 574, 0, + 11365, 11364, 1, 0, 0, 0, 11365, 11366, 1, 0, 0, 0, 11366, 11368, 1, 0, + 0, 0, 11367, 11369, 3, 1164, 582, 0, 11368, 11367, 1, 0, 0, 0, 11368, 11369, + 1, 0, 0, 0, 11369, 1155, 1, 0, 0, 0, 11370, 11371, 5, 1667, 0, 0, 11371, + 11385, 5, 2370, 0, 0, 11372, 11373, 5, 1656, 0, 0, 11373, 11374, 5, 680, + 0, 0, 11374, 11375, 5, 2376, 0, 0, 11375, 11380, 3, 1666, 833, 0, 11376, + 11377, 5, 2382, 0, 0, 11377, 11379, 3, 1666, 833, 0, 11378, 11376, 1, 0, + 0, 0, 11379, 11382, 1, 0, 0, 0, 11380, 11378, 1, 0, 0, 0, 11380, 11381, + 1, 0, 0, 0, 11381, 11383, 1, 0, 0, 0, 11382, 11380, 1, 0, 0, 0, 11383, + 11384, 5, 2377, 0, 0, 11384, 11386, 1, 0, 0, 0, 11385, 11372, 1, 0, 0, + 0, 11385, 11386, 1, 0, 0, 0, 11386, 1157, 1, 0, 0, 0, 11387, 11388, 5, + 2140, 0, 0, 11388, 11389, 5, 780, 0, 0, 11389, 11390, 5, 1988, 0, 0, 11390, + 11391, 5, 2376, 0, 0, 11391, 11396, 3, 2170, 1085, 0, 11392, 11393, 5, + 2382, 0, 0, 11393, 11395, 3, 2170, 1085, 0, 11394, 11392, 1, 0, 0, 0, 11395, + 11398, 1, 0, 0, 0, 11396, 11394, 1, 0, 0, 0, 11396, 11397, 1, 0, 0, 0, + 11397, 11399, 1, 0, 0, 0, 11398, 11396, 1, 0, 0, 0, 11399, 11400, 5, 2377, + 0, 0, 11400, 1159, 1, 0, 0, 0, 11401, 11402, 5, 2140, 0, 0, 11402, 11422, + 5, 2376, 0, 0, 11403, 11408, 3, 2170, 1085, 0, 11404, 11405, 5, 2382, 0, + 0, 11405, 11407, 3, 2170, 1085, 0, 11406, 11404, 1, 0, 0, 0, 11407, 11410, + 1, 0, 0, 0, 11408, 11406, 1, 0, 0, 0, 11408, 11409, 1, 0, 0, 0, 11409, + 11423, 1, 0, 0, 0, 11410, 11408, 1, 0, 0, 0, 11411, 11412, 5, 1997, 0, + 0, 11412, 11418, 3, 2170, 1085, 0, 11413, 11414, 5, 2382, 0, 0, 11414, + 11415, 5, 1997, 0, 0, 11415, 11417, 3, 2170, 1085, 0, 11416, 11413, 1, + 0, 0, 0, 11417, 11420, 1, 0, 0, 0, 11418, 11416, 1, 0, 0, 0, 11418, 11419, + 1, 0, 0, 0, 11419, 11423, 1, 0, 0, 0, 11420, 11418, 1, 0, 0, 0, 11421, + 11423, 5, 363, 0, 0, 11422, 11403, 1, 0, 0, 0, 11422, 11411, 1, 0, 0, 0, + 11422, 11421, 1, 0, 0, 0, 11423, 11424, 1, 0, 0, 0, 11424, 11425, 5, 2377, + 0, 0, 11425, 1161, 1, 0, 0, 0, 11426, 11428, 3, 1192, 596, 0, 11427, 11426, + 1, 0, 0, 0, 11427, 11428, 1, 0, 0, 0, 11428, 11430, 1, 0, 0, 0, 11429, + 11431, 3, 1194, 597, 0, 11430, 11429, 1, 0, 0, 0, 11430, 11431, 1, 0, 0, + 0, 11431, 11434, 1, 0, 0, 0, 11432, 11435, 3, 1172, 586, 0, 11433, 11435, + 3, 1608, 804, 0, 11434, 11432, 1, 0, 0, 0, 11434, 11433, 1, 0, 0, 0, 11434, + 11435, 1, 0, 0, 0, 11435, 11440, 1, 0, 0, 0, 11436, 11438, 5, 1231, 0, + 0, 11437, 11439, 3, 1194, 597, 0, 11438, 11437, 1, 0, 0, 0, 11438, 11439, + 1, 0, 0, 0, 11439, 11441, 1, 0, 0, 0, 11440, 11436, 1, 0, 0, 0, 11440, + 11441, 1, 0, 0, 0, 11441, 11447, 1, 0, 0, 0, 11442, 11446, 3, 1650, 825, + 0, 11443, 11446, 3, 1640, 820, 0, 11444, 11446, 3, 1698, 849, 0, 11445, + 11442, 1, 0, 0, 0, 11445, 11443, 1, 0, 0, 0, 11445, 11444, 1, 0, 0, 0, + 11446, 11449, 1, 0, 0, 0, 11447, 11445, 1, 0, 0, 0, 11447, 11448, 1, 0, + 0, 0, 11448, 1163, 1, 0, 0, 0, 11449, 11447, 1, 0, 0, 0, 11450, 11451, + 5, 1973, 0, 0, 11451, 11471, 3, 1666, 833, 0, 11452, 11455, 5, 1231, 0, + 0, 11453, 11454, 5, 1973, 0, 0, 11454, 11456, 3, 1666, 833, 0, 11455, 11453, + 1, 0, 0, 0, 11455, 11456, 1, 0, 0, 0, 11456, 11471, 1, 0, 0, 0, 11457, + 11471, 3, 1172, 586, 0, 11458, 11471, 3, 1608, 804, 0, 11459, 11471, 3, + 1166, 583, 0, 11460, 11461, 5, 2147, 0, 0, 11461, 11462, 3, 1668, 834, + 0, 11462, 11463, 5, 1656, 0, 0, 11463, 11465, 5, 66, 0, 0, 11464, 11466, + 7, 113, 0, 0, 11465, 11464, 1, 0, 0, 0, 11465, 11466, 1, 0, 0, 0, 11466, + 11467, 1, 0, 0, 0, 11467, 11468, 5, 800, 0, 0, 11468, 11469, 3, 1644, 822, + 0, 11469, 11471, 1, 0, 0, 0, 11470, 11450, 1, 0, 0, 0, 11470, 11452, 1, + 0, 0, 0, 11470, 11457, 1, 0, 0, 0, 11470, 11458, 1, 0, 0, 0, 11470, 11459, + 1, 0, 0, 0, 11470, 11460, 1, 0, 0, 0, 11471, 11472, 1, 0, 0, 0, 11472, + 11470, 1, 0, 0, 0, 11472, 11473, 1, 0, 0, 0, 11473, 1165, 1, 0, 0, 0, 11474, + 11475, 5, 800, 0, 0, 11475, 11476, 5, 2376, 0, 0, 11476, 11477, 3, 1646, + 823, 0, 11477, 11478, 5, 2377, 0, 0, 11478, 11479, 5, 1656, 0, 0, 11479, + 11481, 5, 66, 0, 0, 11480, 11482, 7, 113, 0, 0, 11481, 11480, 1, 0, 0, + 0, 11481, 11482, 1, 0, 0, 0, 11482, 11496, 1, 0, 0, 0, 11483, 11489, 3, + 1644, 822, 0, 11484, 11485, 5, 2376, 0, 0, 11485, 11486, 5, 1973, 0, 0, + 11486, 11487, 3, 1666, 833, 0, 11487, 11488, 5, 2377, 0, 0, 11488, 11490, + 1, 0, 0, 0, 11489, 11484, 1, 0, 0, 0, 11489, 11490, 1, 0, 0, 0, 11490, + 11497, 1, 0, 0, 0, 11491, 11492, 5, 2376, 0, 0, 11492, 11493, 5, 1973, + 0, 0, 11493, 11494, 3, 1666, 833, 0, 11494, 11495, 5, 2377, 0, 0, 11495, + 11497, 1, 0, 0, 0, 11496, 11483, 1, 0, 0, 0, 11496, 11491, 1, 0, 0, 0, + 11497, 1167, 1, 0, 0, 0, 11498, 11499, 3, 2310, 1155, 0, 11499, 11501, + 3, 2346, 1173, 0, 11500, 11502, 5, 1604, 0, 0, 11501, 11500, 1, 0, 0, 0, + 11501, 11502, 1, 0, 0, 0, 11502, 11505, 1, 0, 0, 0, 11503, 11504, 5, 363, + 0, 0, 11504, 11506, 3, 2078, 1039, 0, 11505, 11503, 1, 0, 0, 0, 11505, + 11506, 1, 0, 0, 0, 11506, 11526, 1, 0, 0, 0, 11507, 11510, 5, 457, 0, 0, + 11508, 11509, 5, 2129, 0, 0, 11509, 11511, 5, 2372, 0, 0, 11510, 11508, + 1, 0, 0, 0, 11510, 11511, 1, 0, 0, 0, 11511, 11515, 1, 0, 0, 0, 11512, + 11513, 5, 628, 0, 0, 11513, 11514, 5, 151, 0, 0, 11514, 11516, 5, 2407, + 0, 0, 11515, 11512, 1, 0, 0, 0, 11515, 11516, 1, 0, 0, 0, 11516, 11518, + 1, 0, 0, 0, 11517, 11519, 5, 2372, 0, 0, 11518, 11517, 1, 0, 0, 0, 11518, + 11519, 1, 0, 0, 0, 11519, 11524, 1, 0, 0, 0, 11520, 11522, 5, 1057, 0, + 0, 11521, 11520, 1, 0, 0, 0, 11521, 11522, 1, 0, 0, 0, 11522, 11523, 1, + 0, 0, 0, 11523, 11525, 5, 1514, 0, 0, 11524, 11521, 1, 0, 0, 0, 11524, + 11525, 1, 0, 0, 0, 11525, 11527, 1, 0, 0, 0, 11526, 11507, 1, 0, 0, 0, + 11526, 11527, 1, 0, 0, 0, 11527, 11530, 1, 0, 0, 0, 11528, 11529, 5, 1121, + 0, 0, 11529, 11531, 5, 1145, 0, 0, 11530, 11528, 1, 0, 0, 0, 11530, 11531, + 1, 0, 0, 0, 11531, 11533, 1, 0, 0, 0, 11532, 11534, 7, 17, 0, 0, 11533, + 11532, 1, 0, 0, 0, 11533, 11534, 1, 0, 0, 0, 11534, 1169, 1, 0, 0, 0, 11535, + 11537, 5, 2370, 0, 0, 11536, 11538, 7, 117, 0, 0, 11537, 11536, 1, 0, 0, + 0, 11537, 11538, 1, 0, 0, 0, 11538, 1171, 1, 0, 0, 0, 11539, 11549, 5, + 242, 0, 0, 11540, 11550, 5, 100, 0, 0, 11541, 11547, 5, 564, 0, 0, 11542, + 11548, 5, 1170, 0, 0, 11543, 11545, 7, 118, 0, 0, 11544, 11546, 7, 97, + 0, 0, 11545, 11544, 1, 0, 0, 0, 11545, 11546, 1, 0, 0, 0, 11546, 11548, + 1, 0, 0, 0, 11547, 11542, 1, 0, 0, 0, 11547, 11543, 1, 0, 0, 0, 11548, + 11550, 1, 0, 0, 0, 11549, 11540, 1, 0, 0, 0, 11549, 11541, 1, 0, 0, 0, + 11549, 11550, 1, 0, 0, 0, 11550, 11553, 1, 0, 0, 0, 11551, 11553, 5, 1000, + 0, 0, 11552, 11539, 1, 0, 0, 0, 11552, 11551, 1, 0, 0, 0, 11553, 1173, + 1, 0, 0, 0, 11554, 11556, 3, 1186, 593, 0, 11555, 11554, 1, 0, 0, 0, 11556, + 11557, 1, 0, 0, 0, 11557, 11555, 1, 0, 0, 0, 11557, 11558, 1, 0, 0, 0, + 11558, 11574, 1, 0, 0, 0, 11559, 11561, 5, 688, 0, 0, 11560, 11562, 3, + 1176, 588, 0, 11561, 11560, 1, 0, 0, 0, 11561, 11562, 1, 0, 0, 0, 11562, + 11566, 1, 0, 0, 0, 11563, 11564, 5, 1057, 0, 0, 11564, 11566, 5, 688, 0, + 0, 11565, 11559, 1, 0, 0, 0, 11565, 11563, 1, 0, 0, 0, 11566, 11570, 1, + 0, 0, 0, 11567, 11569, 3, 1186, 593, 0, 11568, 11567, 1, 0, 0, 0, 11569, + 11572, 1, 0, 0, 0, 11570, 11568, 1, 0, 0, 0, 11570, 11571, 1, 0, 0, 0, + 11571, 11574, 1, 0, 0, 0, 11572, 11570, 1, 0, 0, 0, 11573, 11555, 1, 0, + 0, 0, 11573, 11565, 1, 0, 0, 0, 11574, 1175, 1, 0, 0, 0, 11575, 11577, + 3, 1178, 589, 0, 11576, 11578, 3, 1180, 590, 0, 11577, 11576, 1, 0, 0, + 0, 11577, 11578, 1, 0, 0, 0, 11578, 11580, 1, 0, 0, 0, 11579, 11581, 3, + 1182, 591, 0, 11580, 11579, 1, 0, 0, 0, 11580, 11581, 1, 0, 0, 0, 11581, + 11583, 1, 0, 0, 0, 11582, 11584, 3, 1184, 592, 0, 11583, 11582, 1, 0, 0, + 0, 11583, 11584, 1, 0, 0, 0, 11584, 11598, 1, 0, 0, 0, 11585, 11587, 3, + 1180, 590, 0, 11586, 11588, 3, 1182, 591, 0, 11587, 11586, 1, 0, 0, 0, + 11587, 11588, 1, 0, 0, 0, 11588, 11590, 1, 0, 0, 0, 11589, 11591, 3, 1184, + 592, 0, 11590, 11589, 1, 0, 0, 0, 11590, 11591, 1, 0, 0, 0, 11591, 11598, + 1, 0, 0, 0, 11592, 11594, 3, 1182, 591, 0, 11593, 11595, 3, 1184, 592, + 0, 11594, 11593, 1, 0, 0, 0, 11594, 11595, 1, 0, 0, 0, 11595, 11598, 1, + 0, 0, 0, 11596, 11598, 3, 1184, 592, 0, 11597, 11575, 1, 0, 0, 0, 11597, + 11585, 1, 0, 0, 0, 11597, 11592, 1, 0, 0, 0, 11597, 11596, 1, 0, 0, 0, + 11598, 1177, 1, 0, 0, 0, 11599, 11600, 5, 870, 0, 0, 11600, 11606, 5, 564, + 0, 0, 11601, 11607, 5, 414, 0, 0, 11602, 11604, 7, 119, 0, 0, 11603, 11605, + 7, 97, 0, 0, 11604, 11603, 1, 0, 0, 0, 11604, 11605, 1, 0, 0, 0, 11605, + 11607, 1, 0, 0, 0, 11606, 11601, 1, 0, 0, 0, 11606, 11602, 1, 0, 0, 0, + 11607, 11611, 1, 0, 0, 0, 11608, 11609, 5, 1057, 0, 0, 11609, 11611, 5, + 870, 0, 0, 11610, 11599, 1, 0, 0, 0, 11610, 11608, 1, 0, 0, 0, 11611, 1179, + 1, 0, 0, 0, 11612, 11613, 5, 1357, 0, 0, 11613, 11614, 7, 120, 0, 0, 11614, + 1181, 1, 0, 0, 0, 11615, 11624, 5, 413, 0, 0, 11616, 11625, 5, 88, 0, 0, + 11617, 11622, 5, 151, 0, 0, 11618, 11619, 5, 1502, 0, 0, 11619, 11623, + 5, 1399, 0, 0, 11620, 11623, 5, 1256, 0, 0, 11621, 11623, 5, 1668, 0, 0, + 11622, 11618, 1, 0, 0, 0, 11622, 11620, 1, 0, 0, 0, 11622, 11621, 1, 0, + 0, 0, 11623, 11625, 1, 0, 0, 0, 11624, 11616, 1, 0, 0, 0, 11624, 11617, + 1, 0, 0, 0, 11624, 11625, 1, 0, 0, 0, 11625, 11634, 1, 0, 0, 0, 11626, + 11627, 5, 564, 0, 0, 11627, 11632, 5, 1561, 0, 0, 11628, 11633, 5, 363, + 0, 0, 11629, 11633, 5, 37, 0, 0, 11630, 11633, 3, 2376, 1188, 0, 11631, + 11633, 5, 1054, 0, 0, 11632, 11628, 1, 0, 0, 0, 11632, 11629, 1, 0, 0, + 0, 11632, 11630, 1, 0, 0, 0, 11632, 11631, 1, 0, 0, 0, 11633, 11635, 1, + 0, 0, 0, 11634, 11626, 1, 0, 0, 0, 11634, 11635, 1, 0, 0, 0, 11635, 1183, + 1, 0, 0, 0, 11636, 11638, 5, 430, 0, 0, 11637, 11639, 5, 37, 0, 0, 11638, + 11637, 1, 0, 0, 0, 11638, 11639, 1, 0, 0, 0, 11639, 11643, 1, 0, 0, 0, + 11640, 11641, 5, 1057, 0, 0, 11641, 11643, 5, 430, 0, 0, 11642, 11636, + 1, 0, 0, 0, 11642, 11640, 1, 0, 0, 0, 11643, 1185, 1, 0, 0, 0, 11644, 11646, + 5, 688, 0, 0, 11645, 11647, 3, 1178, 589, 0, 11646, 11645, 1, 0, 0, 0, + 11646, 11647, 1, 0, 0, 0, 11647, 11651, 1, 0, 0, 0, 11648, 11649, 5, 1057, + 0, 0, 11649, 11651, 5, 688, 0, 0, 11650, 11644, 1, 0, 0, 0, 11650, 11648, + 1, 0, 0, 0, 11651, 11652, 1, 0, 0, 0, 11652, 11653, 5, 2376, 0, 0, 11653, + 11654, 3, 2328, 1164, 0, 11654, 11655, 5, 2377, 0, 0, 11655, 1187, 1, 0, + 0, 0, 11656, 11657, 5, 1277, 0, 0, 11657, 11669, 5, 2370, 0, 0, 11658, + 11659, 5, 1280, 0, 0, 11659, 11669, 5, 2370, 0, 0, 11660, 11661, 5, 685, + 0, 0, 11661, 11669, 5, 2370, 0, 0, 11662, 11663, 5, 860, 0, 0, 11663, 11669, + 5, 2370, 0, 0, 11664, 11665, 5, 243, 0, 0, 11665, 11669, 5, 1639, 0, 0, + 11666, 11669, 3, 1190, 595, 0, 11667, 11669, 3, 674, 337, 0, 11668, 11656, + 1, 0, 0, 0, 11668, 11658, 1, 0, 0, 0, 11668, 11660, 1, 0, 0, 0, 11668, + 11662, 1, 0, 0, 0, 11668, 11664, 1, 0, 0, 0, 11668, 11666, 1, 0, 0, 0, + 11668, 11667, 1, 0, 0, 0, 11669, 11670, 1, 0, 0, 0, 11670, 11668, 1, 0, + 0, 0, 11670, 11671, 1, 0, 0, 0, 11671, 1189, 1, 0, 0, 0, 11672, 11673, + 5, 1655, 0, 0, 11673, 11701, 5, 2376, 0, 0, 11674, 11675, 5, 682, 0, 0, + 11675, 11702, 3, 1170, 585, 0, 11676, 11677, 5, 953, 0, 0, 11677, 11702, + 3, 1170, 585, 0, 11678, 11679, 5, 881, 0, 0, 11679, 11702, 7, 121, 0, 0, + 11680, 11681, 5, 852, 0, 0, 11681, 11702, 7, 121, 0, 0, 11682, 11683, 5, + 1278, 0, 0, 11683, 11702, 5, 2370, 0, 0, 11684, 11685, 5, 569, 0, 0, 11685, + 11702, 5, 2370, 0, 0, 11686, 11687, 5, 568, 0, 0, 11687, 11688, 5, 597, + 0, 0, 11688, 11702, 5, 2370, 0, 0, 11689, 11692, 5, 1184, 0, 0, 11690, + 11693, 3, 1170, 585, 0, 11691, 11693, 5, 1145, 0, 0, 11692, 11690, 1, 0, + 0, 0, 11692, 11691, 1, 0, 0, 0, 11693, 11702, 1, 0, 0, 0, 11694, 11695, + 5, 148, 0, 0, 11695, 11702, 7, 122, 0, 0, 11696, 11697, 5, 550, 0, 0, 11697, + 11702, 7, 123, 0, 0, 11698, 11699, 5, 175, 0, 0, 11699, 11702, 7, 123, + 0, 0, 11700, 11702, 5, 457, 0, 0, 11701, 11674, 1, 0, 0, 0, 11701, 11676, + 1, 0, 0, 0, 11701, 11678, 1, 0, 0, 0, 11701, 11680, 1, 0, 0, 0, 11701, + 11682, 1, 0, 0, 0, 11701, 11684, 1, 0, 0, 0, 11701, 11686, 1, 0, 0, 0, + 11701, 11689, 1, 0, 0, 0, 11701, 11694, 1, 0, 0, 0, 11701, 11696, 1, 0, + 0, 0, 11701, 11698, 1, 0, 0, 0, 11701, 11700, 1, 0, 0, 0, 11702, 11703, + 1, 0, 0, 0, 11703, 11701, 1, 0, 0, 0, 11703, 11704, 1, 0, 0, 0, 11704, + 11705, 1, 0, 0, 0, 11705, 11706, 5, 2377, 0, 0, 11706, 1191, 1, 0, 0, 0, + 11707, 11708, 5, 1546, 0, 0, 11708, 11709, 5, 304, 0, 0, 11709, 11710, + 7, 87, 0, 0, 11710, 1193, 1, 0, 0, 0, 11711, 11723, 3, 1188, 594, 0, 11712, + 11718, 5, 1973, 0, 0, 11713, 11719, 3, 2378, 1189, 0, 11714, 11716, 5, + 1568, 0, 0, 11715, 11714, 1, 0, 0, 0, 11715, 11716, 1, 0, 0, 0, 11716, + 11717, 1, 0, 0, 0, 11717, 11719, 3, 2376, 1188, 0, 11718, 11713, 1, 0, + 0, 0, 11718, 11715, 1, 0, 0, 0, 11719, 11723, 1, 0, 0, 0, 11720, 11723, + 3, 1172, 586, 0, 11721, 11723, 3, 882, 441, 0, 11722, 11711, 1, 0, 0, 0, + 11722, 11712, 1, 0, 0, 0, 11722, 11720, 1, 0, 0, 0, 11722, 11721, 1, 0, + 0, 0, 11723, 11724, 1, 0, 0, 0, 11724, 11722, 1, 0, 0, 0, 11724, 11725, + 1, 0, 0, 0, 11725, 1195, 1, 0, 0, 0, 11726, 11728, 3, 1192, 596, 0, 11727, + 11726, 1, 0, 0, 0, 11727, 11728, 1, 0, 0, 0, 11728, 11729, 1, 0, 0, 0, + 11729, 11731, 3, 1194, 597, 0, 11730, 11732, 3, 1172, 586, 0, 11731, 11730, + 1, 0, 0, 0, 11731, 11732, 1, 0, 0, 0, 11732, 11734, 1, 0, 0, 0, 11733, + 11735, 3, 1174, 587, 0, 11734, 11733, 1, 0, 0, 0, 11734, 11735, 1, 0, 0, + 0, 11735, 11737, 1, 0, 0, 0, 11736, 11738, 3, 1198, 599, 0, 11737, 11736, + 1, 0, 0, 0, 11737, 11738, 1, 0, 0, 0, 11738, 11781, 1, 0, 0, 0, 11739, + 11741, 3, 1192, 596, 0, 11740, 11739, 1, 0, 0, 0, 11740, 11741, 1, 0, 0, + 0, 11741, 11765, 1, 0, 0, 0, 11742, 11755, 5, 1218, 0, 0, 11743, 11745, + 5, 608, 0, 0, 11744, 11746, 3, 1194, 597, 0, 11745, 11744, 1, 0, 0, 0, + 11745, 11746, 1, 0, 0, 0, 11746, 11747, 1, 0, 0, 0, 11747, 11756, 3, 1214, + 607, 0, 11748, 11750, 5, 659, 0, 0, 11749, 11751, 3, 1194, 597, 0, 11750, + 11749, 1, 0, 0, 0, 11750, 11751, 1, 0, 0, 0, 11751, 11752, 1, 0, 0, 0, + 11752, 11756, 3, 1604, 802, 0, 11753, 11754, 5, 507, 0, 0, 11754, 11756, + 3, 1216, 608, 0, 11755, 11743, 1, 0, 0, 0, 11755, 11748, 1, 0, 0, 0, 11755, + 11753, 1, 0, 0, 0, 11756, 11766, 1, 0, 0, 0, 11757, 11758, 5, 507, 0, 0, + 11758, 11759, 5, 1256, 0, 0, 11759, 11760, 5, 81, 0, 0, 11760, 11763, 3, + 1216, 608, 0, 11761, 11762, 5, 1450, 0, 0, 11762, 11764, 5, 793, 0, 0, + 11763, 11761, 1, 0, 0, 0, 11763, 11764, 1, 0, 0, 0, 11764, 11766, 1, 0, + 0, 0, 11765, 11742, 1, 0, 0, 0, 11765, 11757, 1, 0, 0, 0, 11766, 11781, + 1, 0, 0, 0, 11767, 11768, 5, 206, 0, 0, 11768, 11769, 3, 462, 231, 0, 11769, + 11770, 5, 2376, 0, 0, 11770, 11775, 3, 2310, 1155, 0, 11771, 11772, 5, + 2382, 0, 0, 11772, 11774, 3, 2310, 1155, 0, 11773, 11771, 1, 0, 0, 0, 11774, + 11777, 1, 0, 0, 0, 11775, 11773, 1, 0, 0, 0, 11775, 11776, 1, 0, 0, 0, + 11776, 11778, 1, 0, 0, 0, 11777, 11775, 1, 0, 0, 0, 11778, 11779, 5, 2377, + 0, 0, 11779, 11781, 1, 0, 0, 0, 11780, 11727, 1, 0, 0, 0, 11780, 11740, + 1, 0, 0, 0, 11780, 11767, 1, 0, 0, 0, 11781, 1197, 1, 0, 0, 0, 11782, 11792, + 5, 639, 0, 0, 11783, 11784, 5, 20, 0, 0, 11784, 11785, 5, 1318, 0, 0, 11785, + 11793, 3, 1200, 600, 0, 11786, 11787, 7, 124, 0, 0, 11787, 11788, 5, 1318, + 0, 0, 11788, 11793, 3, 1200, 600, 0, 11789, 11793, 5, 375, 0, 0, 11790, + 11793, 5, 452, 0, 0, 11791, 11793, 5, 397, 0, 0, 11792, 11783, 1, 0, 0, + 0, 11792, 11786, 1, 0, 0, 0, 11792, 11789, 1, 0, 0, 0, 11792, 11790, 1, + 0, 0, 0, 11792, 11791, 1, 0, 0, 0, 11793, 1199, 1, 0, 0, 0, 11794, 11798, + 3, 1202, 601, 0, 11795, 11798, 3, 1204, 602, 0, 11796, 11798, 3, 1210, + 605, 0, 11797, 11794, 1, 0, 0, 0, 11797, 11795, 1, 0, 0, 0, 11797, 11796, + 1, 0, 0, 0, 11798, 1201, 1, 0, 0, 0, 11799, 11800, 3, 1172, 586, 0, 11800, + 11801, 3, 1208, 604, 0, 11801, 11802, 3, 1206, 603, 0, 11802, 11819, 1, + 0, 0, 0, 11803, 11804, 7, 125, 0, 0, 11804, 11805, 5, 1656, 0, 0, 11805, + 11809, 5, 242, 0, 0, 11806, 11810, 5, 28, 0, 0, 11807, 11808, 5, 564, 0, + 0, 11808, 11810, 5, 1388, 0, 0, 11809, 11806, 1, 0, 0, 0, 11809, 11807, + 1, 0, 0, 0, 11810, 11811, 1, 0, 0, 0, 11811, 11812, 5, 1507, 0, 0, 11812, + 11813, 5, 32, 0, 0, 11813, 11814, 3, 1212, 606, 0, 11814, 11815, 5, 1163, + 0, 0, 11815, 11816, 5, 1057, 0, 0, 11816, 11817, 5, 907, 0, 0, 11817, 11819, + 1, 0, 0, 0, 11818, 11799, 1, 0, 0, 0, 11818, 11803, 1, 0, 0, 0, 11819, + 1203, 1, 0, 0, 0, 11820, 11821, 5, 1993, 0, 0, 11821, 11822, 5, 2029, 0, + 0, 11822, 11836, 3, 1666, 833, 0, 11823, 11825, 3, 1208, 604, 0, 11824, + 11823, 1, 0, 0, 0, 11824, 11825, 1, 0, 0, 0, 11825, 11828, 1, 0, 0, 0, + 11826, 11827, 5, 1175, 0, 0, 11827, 11829, 3, 2292, 1146, 0, 11828, 11826, + 1, 0, 0, 0, 11828, 11829, 1, 0, 0, 0, 11829, 11837, 1, 0, 0, 0, 11830, + 11831, 5, 1408, 0, 0, 11831, 11833, 5, 1174, 0, 0, 11832, 11834, 3, 1208, + 604, 0, 11833, 11832, 1, 0, 0, 0, 11833, 11834, 1, 0, 0, 0, 11834, 11835, + 1, 0, 0, 0, 11835, 11837, 3, 1206, 603, 0, 11836, 11824, 1, 0, 0, 0, 11836, + 11830, 1, 0, 0, 0, 11837, 1205, 1, 0, 0, 0, 11838, 11839, 5, 32, 0, 0, + 11839, 11840, 3, 1212, 606, 0, 11840, 11844, 5, 1163, 0, 0, 11841, 11842, + 5, 1057, 0, 0, 11842, 11845, 7, 126, 0, 0, 11843, 11845, 5, 304, 0, 0, + 11844, 11841, 1, 0, 0, 0, 11844, 11843, 1, 0, 0, 0, 11845, 11849, 1, 0, + 0, 0, 11846, 11847, 5, 1175, 0, 0, 11847, 11849, 3, 2292, 1146, 0, 11848, + 11838, 1, 0, 0, 0, 11848, 11846, 1, 0, 0, 0, 11849, 1207, 1, 0, 0, 0, 11850, + 11851, 7, 127, 0, 0, 11851, 1209, 1, 0, 0, 0, 11852, 11853, 5, 1568, 0, + 0, 11853, 11855, 5, 688, 0, 0, 11854, 11856, 3, 1176, 588, 0, 11855, 11854, + 1, 0, 0, 0, 11855, 11856, 1, 0, 0, 0, 11856, 11863, 1, 0, 0, 0, 11857, + 11858, 5, 909, 0, 0, 11858, 11859, 5, 688, 0, 0, 11859, 11863, 3, 1178, + 589, 0, 11860, 11861, 5, 1057, 0, 0, 11861, 11863, 5, 688, 0, 0, 11862, + 11852, 1, 0, 0, 0, 11862, 11857, 1, 0, 0, 0, 11862, 11860, 1, 0, 0, 0, + 11863, 11865, 1, 0, 0, 0, 11864, 11866, 5, 1546, 0, 0, 11865, 11864, 1, + 0, 0, 0, 11865, 11866, 1, 0, 0, 0, 11866, 11867, 1, 0, 0, 0, 11867, 11868, + 3, 1206, 603, 0, 11868, 1211, 1, 0, 0, 0, 11869, 11870, 3, 2368, 1184, + 0, 11870, 11871, 7, 128, 0, 0, 11871, 1213, 1, 0, 0, 0, 11872, 11874, 3, + 1172, 586, 0, 11873, 11872, 1, 0, 0, 0, 11873, 11874, 1, 0, 0, 0, 11874, + 11876, 1, 0, 0, 0, 11875, 11877, 3, 1174, 587, 0, 11876, 11875, 1, 0, 0, + 0, 11876, 11877, 1, 0, 0, 0, 11877, 11879, 1, 0, 0, 0, 11878, 11880, 3, + 1198, 599, 0, 11879, 11878, 1, 0, 0, 0, 11879, 11880, 1, 0, 0, 0, 11880, + 1215, 1, 0, 0, 0, 11881, 11884, 5, 2376, 0, 0, 11882, 11883, 5, 2053, 0, + 0, 11883, 11885, 3, 1218, 609, 0, 11884, 11882, 1, 0, 0, 0, 11884, 11885, + 1, 0, 0, 0, 11885, 11886, 1, 0, 0, 0, 11886, 11887, 3, 1220, 610, 0, 11887, + 11894, 5, 2377, 0, 0, 11888, 11889, 5, 1450, 0, 0, 11889, 11892, 5, 793, + 0, 0, 11890, 11893, 3, 2368, 1184, 0, 11891, 11893, 5, 2070, 0, 0, 11892, + 11890, 1, 0, 0, 0, 11892, 11891, 1, 0, 0, 0, 11893, 11895, 1, 0, 0, 0, + 11894, 11888, 1, 0, 0, 0, 11894, 11895, 1, 0, 0, 0, 11895, 11897, 1, 0, + 0, 0, 11896, 11898, 3, 1174, 587, 0, 11897, 11896, 1, 0, 0, 0, 11897, 11898, + 1, 0, 0, 0, 11898, 1217, 1, 0, 0, 0, 11899, 11900, 7, 129, 0, 0, 11900, + 1219, 1, 0, 0, 0, 11901, 11902, 5, 363, 0, 0, 11902, 11903, 5, 395, 0, + 0, 11903, 11905, 3, 782, 391, 0, 11904, 11901, 1, 0, 0, 0, 11904, 11905, + 1, 0, 0, 0, 11905, 11920, 1, 0, 0, 0, 11906, 11907, 5, 4, 0, 0, 11907, + 11918, 5, 1244, 0, 0, 11908, 11909, 5, 2376, 0, 0, 11909, 11910, 5, 2372, + 0, 0, 11910, 11919, 5, 2377, 0, 0, 11911, 11912, 5, 2376, 0, 0, 11912, + 11913, 3, 1222, 611, 0, 11913, 11914, 5, 2377, 0, 0, 11914, 11919, 1, 0, + 0, 0, 11915, 11916, 5, 2129, 0, 0, 11916, 11917, 5, 201, 0, 0, 11917, 11919, + 3, 1880, 940, 0, 11918, 11908, 1, 0, 0, 0, 11918, 11911, 1, 0, 0, 0, 11918, + 11915, 1, 0, 0, 0, 11919, 11921, 1, 0, 0, 0, 11920, 11906, 1, 0, 0, 0, + 11920, 11921, 1, 0, 0, 0, 11921, 11939, 1, 0, 0, 0, 11922, 11923, 5, 807, + 0, 0, 11923, 11924, 5, 2376, 0, 0, 11924, 11925, 3, 782, 391, 0, 11925, + 11926, 5, 2395, 0, 0, 11926, 11934, 5, 2372, 0, 0, 11927, 11928, 5, 2382, + 0, 0, 11928, 11929, 3, 782, 391, 0, 11929, 11930, 5, 2395, 0, 0, 11930, + 11931, 5, 2372, 0, 0, 11931, 11933, 1, 0, 0, 0, 11932, 11927, 1, 0, 0, + 0, 11933, 11936, 1, 0, 0, 0, 11934, 11932, 1, 0, 0, 0, 11934, 11935, 1, + 0, 0, 0, 11935, 11937, 1, 0, 0, 0, 11936, 11934, 1, 0, 0, 0, 11937, 11938, + 5, 2377, 0, 0, 11938, 11940, 1, 0, 0, 0, 11939, 11922, 1, 0, 0, 0, 11939, + 11940, 1, 0, 0, 0, 11940, 1221, 1, 0, 0, 0, 11941, 11943, 3, 1224, 612, + 0, 11942, 11941, 1, 0, 0, 0, 11942, 11943, 1, 0, 0, 0, 11943, 11945, 1, + 0, 0, 0, 11944, 11946, 3, 1240, 620, 0, 11945, 11944, 1, 0, 0, 0, 11945, + 11946, 1, 0, 0, 0, 11946, 11948, 1, 0, 0, 0, 11947, 11949, 3, 1274, 637, + 0, 11948, 11947, 1, 0, 0, 0, 11948, 11949, 1, 0, 0, 0, 11949, 1223, 1, + 0, 0, 0, 11950, 11964, 5, 2315, 0, 0, 11951, 11952, 7, 130, 0, 0, 11952, + 11965, 5, 2370, 0, 0, 11953, 11954, 5, 2317, 0, 0, 11954, 11960, 5, 151, + 0, 0, 11955, 11957, 5, 2356, 0, 0, 11956, 11955, 1, 0, 0, 0, 11956, 11957, + 1, 0, 0, 0, 11957, 11958, 1, 0, 0, 0, 11958, 11961, 5, 2355, 0, 0, 11959, + 11961, 5, 2372, 0, 0, 11960, 11956, 1, 0, 0, 0, 11960, 11959, 1, 0, 0, + 0, 11961, 11965, 1, 0, 0, 0, 11962, 11963, 5, 2318, 0, 0, 11963, 11965, + 5, 2372, 0, 0, 11964, 11951, 1, 0, 0, 0, 11964, 11953, 1, 0, 0, 0, 11964, + 11962, 1, 0, 0, 0, 11965, 11967, 1, 0, 0, 0, 11966, 11968, 3, 1228, 614, + 0, 11967, 11966, 1, 0, 0, 0, 11967, 11968, 1, 0, 0, 0, 11968, 1225, 1, + 0, 0, 0, 11969, 11970, 7, 131, 0, 0, 11970, 1227, 1, 0, 0, 0, 11971, 11973, + 3, 1230, 615, 0, 11972, 11971, 1, 0, 0, 0, 11973, 11974, 1, 0, 0, 0, 11974, + 11972, 1, 0, 0, 0, 11974, 11975, 1, 0, 0, 0, 11975, 1229, 1, 0, 0, 0, 11976, + 11977, 5, 2314, 0, 0, 11977, 12029, 3, 2316, 1158, 0, 11978, 11982, 5, + 2319, 0, 0, 11979, 11980, 3, 1236, 618, 0, 11980, 11981, 5, 2395, 0, 0, + 11981, 11983, 1, 0, 0, 0, 11982, 11979, 1, 0, 0, 0, 11982, 11983, 1, 0, + 0, 0, 11983, 11984, 1, 0, 0, 0, 11984, 12029, 3, 1238, 619, 0, 11985, 11986, + 7, 132, 0, 0, 11986, 12029, 5, 2372, 0, 0, 11987, 11988, 5, 330, 0, 0, + 11988, 11989, 5, 723, 0, 0, 11989, 11990, 7, 133, 0, 0, 11990, 12029, 5, + 2323, 0, 0, 11991, 11992, 5, 2324, 0, 0, 11992, 12029, 7, 134, 0, 0, 11993, + 11994, 5, 1660, 0, 0, 11994, 11995, 5, 2326, 0, 0, 11995, 11996, 5, 2327, + 0, 0, 11996, 11997, 5, 680, 0, 0, 11997, 12029, 7, 135, 0, 0, 11998, 11999, + 5, 799, 0, 0, 11999, 12000, 5, 2180, 0, 0, 12000, 12029, 3, 2072, 1036, + 0, 12001, 12029, 3, 1232, 616, 0, 12002, 12003, 5, 2330, 0, 0, 12003, 12029, + 5, 2370, 0, 0, 12004, 12029, 5, 2331, 0, 0, 12005, 12006, 7, 136, 0, 0, + 12006, 12029, 5, 2370, 0, 0, 12007, 12019, 5, 2333, 0, 0, 12008, 12009, + 5, 543, 0, 0, 12009, 12011, 5, 534, 0, 0, 12010, 12012, 5, 635, 0, 0, 12011, + 12010, 1, 0, 0, 0, 12011, 12012, 1, 0, 0, 0, 12012, 12020, 1, 0, 0, 0, + 12013, 12014, 5, 37, 0, 0, 12014, 12016, 5, 2334, 0, 0, 12015, 12017, 5, + 635, 0, 0, 12016, 12015, 1, 0, 0, 0, 12016, 12017, 1, 0, 0, 0, 12017, 12020, + 1, 0, 0, 0, 12018, 12020, 5, 1054, 0, 0, 12019, 12008, 1, 0, 0, 0, 12019, + 12013, 1, 0, 0, 0, 12019, 12018, 1, 0, 0, 0, 12020, 12029, 1, 0, 0, 0, + 12021, 12022, 5, 2335, 0, 0, 12022, 12023, 5, 2376, 0, 0, 12023, 12024, + 7, 137, 0, 0, 12024, 12029, 5, 2377, 0, 0, 12025, 12029, 7, 138, 0, 0, + 12026, 12027, 5, 2340, 0, 0, 12027, 12029, 5, 2370, 0, 0, 12028, 11976, + 1, 0, 0, 0, 12028, 11978, 1, 0, 0, 0, 12028, 11985, 1, 0, 0, 0, 12028, + 11987, 1, 0, 0, 0, 12028, 11991, 1, 0, 0, 0, 12028, 11993, 1, 0, 0, 0, + 12028, 11998, 1, 0, 0, 0, 12028, 12001, 1, 0, 0, 0, 12028, 12002, 1, 0, + 0, 0, 12028, 12004, 1, 0, 0, 0, 12028, 12005, 1, 0, 0, 0, 12028, 12007, + 1, 0, 0, 0, 12028, 12021, 1, 0, 0, 0, 12028, 12025, 1, 0, 0, 0, 12028, + 12026, 1, 0, 0, 0, 12029, 1231, 1, 0, 0, 0, 12030, 12032, 3, 1234, 617, + 0, 12031, 12030, 1, 0, 0, 0, 12032, 12033, 1, 0, 0, 0, 12033, 12031, 1, + 0, 0, 0, 12033, 12034, 1, 0, 0, 0, 12034, 1233, 1, 0, 0, 0, 12035, 12066, + 5, 2341, 0, 0, 12036, 12040, 5, 2342, 0, 0, 12037, 12038, 3, 1236, 618, + 0, 12038, 12039, 5, 2395, 0, 0, 12039, 12041, 1, 0, 0, 0, 12040, 12037, + 1, 0, 0, 0, 12040, 12041, 1, 0, 0, 0, 12041, 12043, 1, 0, 0, 0, 12042, + 12044, 3, 1238, 619, 0, 12043, 12042, 1, 0, 0, 0, 12043, 12044, 1, 0, 0, + 0, 12044, 12066, 1, 0, 0, 0, 12045, 12066, 5, 2343, 0, 0, 12046, 12050, + 5, 2344, 0, 0, 12047, 12048, 3, 1236, 618, 0, 12048, 12049, 5, 2395, 0, + 0, 12049, 12051, 1, 0, 0, 0, 12050, 12047, 1, 0, 0, 0, 12050, 12051, 1, + 0, 0, 0, 12051, 12053, 1, 0, 0, 0, 12052, 12054, 3, 1238, 619, 0, 12053, + 12052, 1, 0, 0, 0, 12053, 12054, 1, 0, 0, 0, 12054, 12066, 1, 0, 0, 0, + 12055, 12066, 5, 2345, 0, 0, 12056, 12060, 5, 813, 0, 0, 12057, 12058, + 3, 1236, 618, 0, 12058, 12059, 5, 2395, 0, 0, 12059, 12061, 1, 0, 0, 0, + 12060, 12057, 1, 0, 0, 0, 12060, 12061, 1, 0, 0, 0, 12061, 12063, 1, 0, + 0, 0, 12062, 12064, 3, 1238, 619, 0, 12063, 12062, 1, 0, 0, 0, 12063, 12064, + 1, 0, 0, 0, 12064, 12066, 1, 0, 0, 0, 12065, 12035, 1, 0, 0, 0, 12065, + 12036, 1, 0, 0, 0, 12065, 12045, 1, 0, 0, 0, 12065, 12046, 1, 0, 0, 0, + 12065, 12055, 1, 0, 0, 0, 12065, 12056, 1, 0, 0, 0, 12066, 1235, 1, 0, + 0, 0, 12067, 12068, 3, 782, 391, 0, 12068, 1237, 1, 0, 0, 0, 12069, 12070, + 5, 2372, 0, 0, 12070, 1239, 1, 0, 0, 0, 12071, 12073, 5, 2346, 0, 0, 12072, + 12074, 3, 1242, 621, 0, 12073, 12072, 1, 0, 0, 0, 12073, 12074, 1, 0, 0, + 0, 12074, 12076, 1, 0, 0, 0, 12075, 12077, 3, 1246, 623, 0, 12076, 12075, + 1, 0, 0, 0, 12076, 12077, 1, 0, 0, 0, 12077, 1241, 1, 0, 0, 0, 12078, 12080, + 3, 1244, 622, 0, 12079, 12078, 1, 0, 0, 0, 12080, 12081, 1, 0, 0, 0, 12081, + 12079, 1, 0, 0, 0, 12081, 12082, 1, 0, 0, 0, 12082, 1243, 1, 0, 0, 0, 12083, + 12114, 5, 2347, 0, 0, 12084, 12087, 5, 2348, 0, 0, 12085, 12086, 7, 2, + 0, 0, 12086, 12088, 5, 2349, 0, 0, 12087, 12085, 1, 0, 0, 0, 12087, 12088, + 1, 0, 0, 0, 12088, 12114, 1, 0, 0, 0, 12089, 12114, 3, 1268, 634, 0, 12090, + 12114, 3, 1270, 635, 0, 12091, 12092, 5, 37, 0, 0, 12092, 12093, 5, 2346, + 0, 0, 12093, 12094, 5, 2350, 0, 0, 12094, 12095, 5, 2351, 0, 0, 12095, + 12114, 5, 2346, 0, 0, 12096, 12097, 5, 893, 0, 0, 12097, 12098, 5, 2352, + 0, 0, 12098, 12099, 5, 2140, 0, 0, 12099, 12100, 5, 2327, 0, 0, 12100, + 12114, 5, 1145, 0, 0, 12101, 12102, 5, 1450, 0, 0, 12102, 12103, 5, 1508, + 0, 0, 12103, 12104, 5, 2188, 0, 0, 12104, 12105, 5, 37, 0, 0, 12105, 12106, + 5, 1145, 0, 0, 12106, 12114, 5, 2346, 0, 0, 12107, 12109, 3, 1272, 636, + 0, 12108, 12107, 1, 0, 0, 0, 12109, 12110, 1, 0, 0, 0, 12110, 12108, 1, + 0, 0, 0, 12110, 12111, 1, 0, 0, 0, 12111, 12114, 1, 0, 0, 0, 12112, 12114, + 7, 139, 0, 0, 12113, 12083, 1, 0, 0, 0, 12113, 12084, 1, 0, 0, 0, 12113, + 12089, 1, 0, 0, 0, 12113, 12090, 1, 0, 0, 0, 12113, 12091, 1, 0, 0, 0, + 12113, 12096, 1, 0, 0, 0, 12113, 12101, 1, 0, 0, 0, 12113, 12108, 1, 0, + 0, 0, 12113, 12112, 1, 0, 0, 0, 12114, 1245, 1, 0, 0, 0, 12115, 12116, + 5, 2376, 0, 0, 12116, 12121, 3, 1248, 624, 0, 12117, 12118, 5, 2382, 0, + 0, 12118, 12120, 3, 1248, 624, 0, 12119, 12117, 1, 0, 0, 0, 12120, 12123, + 1, 0, 0, 0, 12121, 12119, 1, 0, 0, 0, 12121, 12122, 1, 0, 0, 0, 12122, + 12124, 1, 0, 0, 0, 12123, 12121, 1, 0, 0, 0, 12124, 12125, 5, 2377, 0, + 0, 12125, 1247, 1, 0, 0, 0, 12126, 12128, 3, 1250, 625, 0, 12127, 12129, + 3, 1252, 626, 0, 12128, 12127, 1, 0, 0, 0, 12128, 12129, 1, 0, 0, 0, 12129, + 12131, 1, 0, 0, 0, 12130, 12132, 3, 1262, 631, 0, 12131, 12130, 1, 0, 0, + 0, 12131, 12132, 1, 0, 0, 0, 12132, 12134, 1, 0, 0, 0, 12133, 12135, 3, + 1264, 632, 0, 12134, 12133, 1, 0, 0, 0, 12134, 12135, 1, 0, 0, 0, 12135, + 12137, 1, 0, 0, 0, 12136, 12138, 3, 1266, 633, 0, 12137, 12136, 1, 0, 0, + 0, 12137, 12138, 1, 0, 0, 0, 12138, 1249, 1, 0, 0, 0, 12139, 12140, 3, + 2310, 1155, 0, 12140, 1251, 1, 0, 0, 0, 12141, 12143, 5, 2354, 0, 0, 12142, + 12141, 1, 0, 0, 0, 12142, 12143, 1, 0, 0, 0, 12143, 12144, 1, 0, 0, 0, + 12144, 12149, 5, 2376, 0, 0, 12145, 12150, 3, 1254, 627, 0, 12146, 12147, + 5, 2379, 0, 0, 12147, 12148, 7, 140, 0, 0, 12148, 12150, 3, 1256, 628, + 0, 12149, 12145, 1, 0, 0, 0, 12149, 12146, 1, 0, 0, 0, 12150, 12156, 1, + 0, 0, 0, 12151, 12154, 7, 141, 0, 0, 12152, 12155, 3, 1258, 629, 0, 12153, + 12155, 3, 1260, 630, 0, 12154, 12152, 1, 0, 0, 0, 12154, 12153, 1, 0, 0, + 0, 12155, 12157, 1, 0, 0, 0, 12156, 12151, 1, 0, 0, 0, 12156, 12157, 1, + 0, 0, 0, 12157, 12158, 1, 0, 0, 0, 12158, 12159, 5, 2377, 0, 0, 12159, + 1253, 1, 0, 0, 0, 12160, 12161, 5, 2370, 0, 0, 12161, 1255, 1, 0, 0, 0, + 12162, 12163, 5, 2370, 0, 0, 12163, 1257, 1, 0, 0, 0, 12164, 12165, 5, + 2370, 0, 0, 12165, 1259, 1, 0, 0, 0, 12166, 12167, 5, 2370, 0, 0, 12167, + 1261, 1, 0, 0, 0, 12168, 12170, 5, 2357, 0, 0, 12169, 12168, 1, 0, 0, 0, + 12169, 12170, 1, 0, 0, 0, 12170, 12171, 1, 0, 0, 0, 12171, 12173, 5, 710, + 0, 0, 12172, 12174, 5, 507, 0, 0, 12173, 12172, 1, 0, 0, 0, 12173, 12174, + 1, 0, 0, 0, 12174, 12178, 1, 0, 0, 0, 12175, 12176, 5, 2376, 0, 0, 12176, + 12177, 5, 2370, 0, 0, 12177, 12179, 5, 2377, 0, 0, 12178, 12175, 1, 0, + 0, 0, 12178, 12179, 1, 0, 0, 0, 12179, 12181, 1, 0, 0, 0, 12180, 12182, + 3, 1268, 634, 0, 12181, 12180, 1, 0, 0, 0, 12181, 12182, 1, 0, 0, 0, 12182, + 12259, 1, 0, 0, 0, 12183, 12194, 7, 142, 0, 0, 12184, 12188, 5, 507, 0, + 0, 12185, 12186, 5, 2376, 0, 0, 12186, 12187, 5, 2370, 0, 0, 12187, 12189, + 5, 2377, 0, 0, 12188, 12185, 1, 0, 0, 0, 12188, 12189, 1, 0, 0, 0, 12189, + 12191, 1, 0, 0, 0, 12190, 12192, 3, 1268, 634, 0, 12191, 12190, 1, 0, 0, + 0, 12191, 12192, 1, 0, 0, 0, 12192, 12195, 1, 0, 0, 0, 12193, 12195, 3, + 2348, 1174, 0, 12194, 12184, 1, 0, 0, 0, 12194, 12193, 1, 0, 0, 0, 12194, + 12195, 1, 0, 0, 0, 12195, 12259, 1, 0, 0, 0, 12196, 12259, 5, 2359, 0, + 0, 12197, 12199, 5, 2360, 0, 0, 12198, 12200, 5, 2361, 0, 0, 12199, 12198, + 1, 0, 0, 0, 12199, 12200, 1, 0, 0, 0, 12200, 12259, 1, 0, 0, 0, 12201, + 12203, 5, 551, 0, 0, 12202, 12204, 5, 507, 0, 0, 12203, 12202, 1, 0, 0, + 0, 12203, 12204, 1, 0, 0, 0, 12204, 12208, 1, 0, 0, 0, 12205, 12206, 5, + 2376, 0, 0, 12206, 12207, 5, 2370, 0, 0, 12207, 12209, 5, 2377, 0, 0, 12208, + 12205, 1, 0, 0, 0, 12208, 12209, 1, 0, 0, 0, 12209, 12211, 1, 0, 0, 0, + 12210, 12212, 3, 1268, 634, 0, 12211, 12210, 1, 0, 0, 0, 12211, 12212, + 1, 0, 0, 0, 12212, 12259, 1, 0, 0, 0, 12213, 12259, 5, 421, 0, 0, 12214, + 12216, 5, 120, 0, 0, 12215, 12217, 5, 507, 0, 0, 12216, 12215, 1, 0, 0, + 0, 12216, 12217, 1, 0, 0, 0, 12217, 12221, 1, 0, 0, 0, 12218, 12219, 5, + 2376, 0, 0, 12219, 12220, 5, 2370, 0, 0, 12220, 12222, 5, 2377, 0, 0, 12221, + 12218, 1, 0, 0, 0, 12221, 12222, 1, 0, 0, 0, 12222, 12224, 1, 0, 0, 0, + 12223, 12225, 3, 1268, 634, 0, 12224, 12223, 1, 0, 0, 0, 12224, 12225, + 1, 0, 0, 0, 12225, 12259, 1, 0, 0, 0, 12226, 12259, 5, 117, 0, 0, 12227, + 12231, 5, 1402, 0, 0, 12228, 12229, 5, 2376, 0, 0, 12229, 12230, 5, 2370, + 0, 0, 12230, 12232, 5, 2377, 0, 0, 12231, 12228, 1, 0, 0, 0, 12231, 12232, + 1, 0, 0, 0, 12232, 12259, 1, 0, 0, 0, 12233, 12237, 5, 182, 0, 0, 12234, + 12235, 5, 2376, 0, 0, 12235, 12236, 5, 2370, 0, 0, 12236, 12238, 5, 2377, + 0, 0, 12237, 12234, 1, 0, 0, 0, 12237, 12238, 1, 0, 0, 0, 12238, 12240, + 1, 0, 0, 0, 12239, 12241, 3, 1268, 634, 0, 12240, 12239, 1, 0, 0, 0, 12240, + 12241, 1, 0, 0, 0, 12241, 12243, 1, 0, 0, 0, 12242, 12244, 3, 1270, 635, + 0, 12243, 12242, 1, 0, 0, 0, 12243, 12244, 1, 0, 0, 0, 12244, 12246, 1, + 0, 0, 0, 12245, 12247, 3, 1272, 636, 0, 12246, 12245, 1, 0, 0, 0, 12246, + 12247, 1, 0, 0, 0, 12247, 12259, 1, 0, 0, 0, 12248, 12249, 7, 143, 0, 0, + 12249, 12253, 5, 2376, 0, 0, 12250, 12251, 3, 2368, 1184, 0, 12251, 12252, + 5, 2382, 0, 0, 12252, 12254, 1, 0, 0, 0, 12253, 12250, 1, 0, 0, 0, 12253, + 12254, 1, 0, 0, 0, 12254, 12255, 1, 0, 0, 0, 12255, 12256, 3, 2368, 1184, + 0, 12256, 12257, 5, 2377, 0, 0, 12257, 12259, 1, 0, 0, 0, 12258, 12169, + 1, 0, 0, 0, 12258, 12183, 1, 0, 0, 0, 12258, 12196, 1, 0, 0, 0, 12258, + 12197, 1, 0, 0, 0, 12258, 12201, 1, 0, 0, 0, 12258, 12213, 1, 0, 0, 0, + 12258, 12214, 1, 0, 0, 0, 12258, 12226, 1, 0, 0, 0, 12258, 12227, 1, 0, + 0, 0, 12258, 12233, 1, 0, 0, 0, 12258, 12248, 1, 0, 0, 0, 12259, 1263, + 1, 0, 0, 0, 12260, 12261, 7, 144, 0, 0, 12261, 12262, 3, 2072, 1036, 0, + 12262, 1265, 1, 0, 0, 0, 12263, 12267, 5, 2302, 0, 0, 12264, 12265, 3, + 1236, 618, 0, 12265, 12266, 5, 2395, 0, 0, 12266, 12268, 1, 0, 0, 0, 12267, + 12264, 1, 0, 0, 0, 12267, 12268, 1, 0, 0, 0, 12268, 12270, 1, 0, 0, 0, + 12269, 12271, 3, 1238, 619, 0, 12270, 12269, 1, 0, 0, 0, 12270, 12271, + 1, 0, 0, 0, 12271, 1267, 1, 0, 0, 0, 12272, 12273, 5, 2303, 0, 0, 12273, + 12274, 5, 151, 0, 0, 12274, 12277, 3, 1226, 613, 0, 12275, 12276, 5, 48, + 0, 0, 12276, 12278, 3, 1226, 613, 0, 12277, 12275, 1, 0, 0, 0, 12277, 12278, + 1, 0, 0, 0, 12278, 12298, 1, 0, 0, 0, 12279, 12280, 5, 2304, 0, 0, 12280, + 12283, 5, 151, 0, 0, 12281, 12284, 3, 1226, 613, 0, 12282, 12284, 5, 2183, + 0, 0, 12283, 12281, 1, 0, 0, 0, 12283, 12282, 1, 0, 0, 0, 12284, 12295, + 1, 0, 0, 0, 12285, 12287, 5, 2305, 0, 0, 12286, 12285, 1, 0, 0, 0, 12286, + 12287, 1, 0, 0, 0, 12287, 12288, 1, 0, 0, 0, 12288, 12289, 5, 2303, 0, + 0, 12289, 12290, 5, 151, 0, 0, 12290, 12293, 3, 1226, 613, 0, 12291, 12292, + 5, 48, 0, 0, 12292, 12294, 3, 1226, 613, 0, 12293, 12291, 1, 0, 0, 0, 12293, + 12294, 1, 0, 0, 0, 12294, 12296, 1, 0, 0, 0, 12295, 12286, 1, 0, 0, 0, + 12295, 12296, 1, 0, 0, 0, 12296, 12298, 1, 0, 0, 0, 12297, 12272, 1, 0, + 0, 0, 12297, 12279, 1, 0, 0, 0, 12298, 1269, 1, 0, 0, 0, 12299, 12300, + 7, 145, 0, 0, 12300, 1271, 1, 0, 0, 0, 12301, 12303, 5, 2309, 0, 0, 12302, + 12304, 7, 146, 0, 0, 12303, 12302, 1, 0, 0, 0, 12303, 12304, 1, 0, 0, 0, + 12304, 12305, 1, 0, 0, 0, 12305, 12306, 5, 2310, 0, 0, 12306, 12307, 3, + 946, 473, 0, 12307, 1273, 1, 0, 0, 0, 12308, 12309, 5, 222, 0, 0, 12309, + 12310, 5, 2311, 0, 0, 12310, 12311, 5, 2376, 0, 0, 12311, 12316, 3, 1276, + 638, 0, 12312, 12313, 5, 2382, 0, 0, 12313, 12315, 3, 1276, 638, 0, 12314, + 12312, 1, 0, 0, 0, 12315, 12318, 1, 0, 0, 0, 12316, 12314, 1, 0, 0, 0, + 12316, 12317, 1, 0, 0, 0, 12317, 12319, 1, 0, 0, 0, 12318, 12316, 1, 0, + 0, 0, 12319, 12320, 5, 2377, 0, 0, 12320, 1275, 1, 0, 0, 0, 12321, 12322, + 3, 2310, 1155, 0, 12322, 12358, 5, 572, 0, 0, 12323, 12359, 5, 1145, 0, + 0, 12324, 12325, 5, 265, 0, 0, 12325, 12359, 5, 2372, 0, 0, 12326, 12327, + 5, 244, 0, 0, 12327, 12328, 5, 2376, 0, 0, 12328, 12333, 3, 1284, 642, + 0, 12329, 12330, 5, 2382, 0, 0, 12330, 12332, 3, 1284, 642, 0, 12331, 12329, + 1, 0, 0, 0, 12332, 12335, 1, 0, 0, 0, 12333, 12331, 1, 0, 0, 0, 12333, + 12334, 1, 0, 0, 0, 12334, 12336, 1, 0, 0, 0, 12335, 12333, 1, 0, 0, 0, + 12336, 12337, 5, 2377, 0, 0, 12337, 12359, 1, 0, 0, 0, 12338, 12339, 5, + 2312, 0, 0, 12339, 12340, 5, 2376, 0, 0, 12340, 12345, 3, 1280, 640, 0, + 12341, 12342, 5, 2382, 0, 0, 12342, 12344, 3, 1280, 640, 0, 12343, 12341, + 1, 0, 0, 0, 12344, 12347, 1, 0, 0, 0, 12345, 12343, 1, 0, 0, 0, 12345, + 12346, 1, 0, 0, 0, 12346, 12348, 1, 0, 0, 0, 12347, 12345, 1, 0, 0, 0, + 12348, 12350, 5, 2377, 0, 0, 12349, 12351, 3, 1282, 641, 0, 12350, 12349, + 1, 0, 0, 0, 12350, 12351, 1, 0, 0, 0, 12351, 12359, 1, 0, 0, 0, 12352, + 12353, 5, 2313, 0, 0, 12353, 12354, 3, 1278, 639, 0, 12354, 12355, 5, 2376, + 0, 0, 12355, 12356, 5, 2370, 0, 0, 12356, 12357, 5, 2377, 0, 0, 12357, + 12359, 1, 0, 0, 0, 12358, 12323, 1, 0, 0, 0, 12358, 12324, 1, 0, 0, 0, + 12358, 12326, 1, 0, 0, 0, 12358, 12338, 1, 0, 0, 0, 12358, 12352, 1, 0, + 0, 0, 12359, 1277, 1, 0, 0, 0, 12360, 12361, 3, 2310, 1155, 0, 12361, 1279, + 1, 0, 0, 0, 12362, 12367, 3, 2310, 1155, 0, 12363, 12364, 5, 265, 0, 0, + 12364, 12365, 5, 2372, 0, 0, 12365, 12367, 5, 2395, 0, 0, 12366, 12362, + 1, 0, 0, 0, 12366, 12363, 1, 0, 0, 0, 12367, 1281, 1, 0, 0, 0, 12368, 12369, + 5, 572, 0, 0, 12369, 12373, 5, 2376, 0, 0, 12370, 12371, 3, 1236, 618, + 0, 12371, 12372, 5, 2395, 0, 0, 12372, 12374, 1, 0, 0, 0, 12373, 12370, + 1, 0, 0, 0, 12373, 12374, 1, 0, 0, 0, 12374, 12376, 1, 0, 0, 0, 12375, + 12377, 3, 1238, 619, 0, 12376, 12375, 1, 0, 0, 0, 12376, 12377, 1, 0, 0, + 0, 12377, 12389, 1, 0, 0, 0, 12378, 12382, 5, 2382, 0, 0, 12379, 12380, + 3, 1236, 618, 0, 12380, 12381, 5, 2395, 0, 0, 12381, 12383, 1, 0, 0, 0, + 12382, 12379, 1, 0, 0, 0, 12382, 12383, 1, 0, 0, 0, 12383, 12385, 1, 0, + 0, 0, 12384, 12386, 3, 1238, 619, 0, 12385, 12384, 1, 0, 0, 0, 12385, 12386, + 1, 0, 0, 0, 12386, 12388, 1, 0, 0, 0, 12387, 12378, 1, 0, 0, 0, 12388, + 12391, 1, 0, 0, 0, 12389, 12387, 1, 0, 0, 0, 12389, 12390, 1, 0, 0, 0, + 12390, 12392, 1, 0, 0, 0, 12391, 12389, 1, 0, 0, 0, 12392, 12399, 5, 2377, + 0, 0, 12393, 12399, 5, 201, 0, 0, 12394, 12399, 5, 133, 0, 0, 12395, 12396, + 5, 2314, 0, 0, 12396, 12397, 5, 2398, 0, 0, 12397, 12399, 3, 2316, 1158, + 0, 12398, 12368, 1, 0, 0, 0, 12398, 12393, 1, 0, 0, 0, 12398, 12394, 1, + 0, 0, 0, 12398, 12395, 1, 0, 0, 0, 12399, 1283, 1, 0, 0, 0, 12400, 12404, + 3, 2310, 1155, 0, 12401, 12402, 5, 265, 0, 0, 12402, 12404, 5, 2372, 0, + 0, 12403, 12400, 1, 0, 0, 0, 12403, 12401, 1, 0, 0, 0, 12404, 1285, 1, + 0, 0, 0, 12405, 12407, 7, 17, 0, 0, 12406, 12405, 1, 0, 0, 0, 12406, 12407, + 1, 0, 0, 0, 12407, 12408, 1, 0, 0, 0, 12408, 12409, 5, 1507, 0, 0, 12409, + 12410, 5, 920, 0, 0, 12410, 1287, 1, 0, 0, 0, 12411, 12412, 5, 549, 0, + 0, 12412, 12414, 5, 62, 0, 0, 12413, 12415, 3, 2378, 1189, 0, 12414, 12413, + 1, 0, 0, 0, 12414, 12415, 1, 0, 0, 0, 12415, 12420, 1, 0, 0, 0, 12416, + 12417, 5, 1057, 0, 0, 12417, 12418, 5, 549, 0, 0, 12418, 12420, 5, 62, + 0, 0, 12419, 12411, 1, 0, 0, 0, 12419, 12416, 1, 0, 0, 0, 12420, 1289, + 1, 0, 0, 0, 12421, 12422, 5, 2370, 0, 0, 12422, 1291, 1, 0, 0, 0, 12423, + 12424, 5, 20, 0, 0, 12424, 12425, 5, 1682, 0, 0, 12425, 12428, 5, 819, + 0, 0, 12426, 12429, 3, 1294, 647, 0, 12427, 12429, 3, 1296, 648, 0, 12428, + 12426, 1, 0, 0, 0, 12428, 12427, 1, 0, 0, 0, 12429, 12439, 1, 0, 0, 0, + 12430, 12431, 5, 2382, 0, 0, 12431, 12432, 5, 1682, 0, 0, 12432, 12435, + 5, 819, 0, 0, 12433, 12436, 3, 1294, 647, 0, 12434, 12436, 3, 1296, 648, + 0, 12435, 12433, 1, 0, 0, 0, 12435, 12434, 1, 0, 0, 0, 12436, 12438, 1, + 0, 0, 0, 12437, 12430, 1, 0, 0, 0, 12438, 12441, 1, 0, 0, 0, 12439, 12437, + 1, 0, 0, 0, 12439, 12440, 1, 0, 0, 0, 12440, 12464, 1, 0, 0, 0, 12441, + 12439, 1, 0, 0, 0, 12442, 12443, 5, 425, 0, 0, 12443, 12444, 5, 1682, 0, + 0, 12444, 12448, 5, 819, 0, 0, 12445, 12449, 3, 1296, 648, 0, 12446, 12447, + 5, 593, 0, 0, 12447, 12449, 3, 1290, 645, 0, 12448, 12445, 1, 0, 0, 0, + 12448, 12446, 1, 0, 0, 0, 12449, 12460, 1, 0, 0, 0, 12450, 12451, 5, 2382, + 0, 0, 12451, 12452, 5, 1682, 0, 0, 12452, 12456, 5, 819, 0, 0, 12453, 12457, + 3, 1296, 648, 0, 12454, 12455, 5, 593, 0, 0, 12455, 12457, 3, 1290, 645, + 0, 12456, 12453, 1, 0, 0, 0, 12456, 12454, 1, 0, 0, 0, 12457, 12459, 1, + 0, 0, 0, 12458, 12450, 1, 0, 0, 0, 12459, 12462, 1, 0, 0, 0, 12460, 12458, + 1, 0, 0, 0, 12460, 12461, 1, 0, 0, 0, 12461, 12464, 1, 0, 0, 0, 12462, + 12460, 1, 0, 0, 0, 12463, 12423, 1, 0, 0, 0, 12463, 12442, 1, 0, 0, 0, + 12464, 1293, 1, 0, 0, 0, 12465, 12466, 5, 593, 0, 0, 12466, 12467, 3, 1290, + 645, 0, 12467, 12468, 5, 2376, 0, 0, 12468, 12471, 3, 2382, 1191, 0, 12469, + 12470, 5, 1057, 0, 0, 12470, 12472, 5, 819, 0, 0, 12471, 12469, 1, 0, 0, + 0, 12471, 12472, 1, 0, 0, 0, 12472, 12481, 1, 0, 0, 0, 12473, 12474, 5, + 2382, 0, 0, 12474, 12477, 3, 2382, 1191, 0, 12475, 12476, 5, 1057, 0, 0, + 12476, 12478, 5, 819, 0, 0, 12477, 12475, 1, 0, 0, 0, 12477, 12478, 1, + 0, 0, 0, 12478, 12480, 1, 0, 0, 0, 12479, 12473, 1, 0, 0, 0, 12480, 12483, + 1, 0, 0, 0, 12481, 12479, 1, 0, 0, 0, 12481, 12482, 1, 0, 0, 0, 12482, + 12484, 1, 0, 0, 0, 12483, 12481, 1, 0, 0, 0, 12484, 12486, 5, 2377, 0, + 0, 12485, 12487, 5, 43, 0, 0, 12486, 12485, 1, 0, 0, 0, 12486, 12487, 1, + 0, 0, 0, 12487, 1295, 1, 0, 0, 0, 12488, 12489, 5, 330, 0, 0, 12489, 12501, + 5, 2376, 0, 0, 12490, 12492, 5, 2382, 0, 0, 12491, 12490, 1, 0, 0, 0, 12491, + 12492, 1, 0, 0, 0, 12492, 12499, 1, 0, 0, 0, 12493, 12500, 5, 37, 0, 0, + 12494, 12495, 5, 1355, 0, 0, 12495, 12500, 5, 753, 0, 0, 12496, 12500, + 5, 2068, 0, 0, 12497, 12498, 5, 562, 0, 0, 12498, 12500, 5, 753, 0, 0, + 12499, 12493, 1, 0, 0, 0, 12499, 12494, 1, 0, 0, 0, 12499, 12496, 1, 0, + 0, 0, 12499, 12497, 1, 0, 0, 0, 12500, 12502, 1, 0, 0, 0, 12501, 12491, + 1, 0, 0, 0, 12502, 12503, 1, 0, 0, 0, 12503, 12501, 1, 0, 0, 0, 12503, + 12504, 1, 0, 0, 0, 12504, 12505, 1, 0, 0, 0, 12505, 12506, 5, 2377, 0, + 0, 12506, 12507, 5, 223, 0, 0, 12507, 1297, 1, 0, 0, 0, 12508, 12509, 5, + 38, 0, 0, 12509, 12522, 5, 505, 0, 0, 12510, 12517, 5, 2376, 0, 0, 12511, + 12512, 5, 1595, 0, 0, 12512, 12518, 3, 1170, 585, 0, 12513, 12514, 5, 331, + 0, 0, 12514, 12518, 5, 2372, 0, 0, 12515, 12516, 5, 700, 0, 0, 12516, 12518, + 5, 2370, 0, 0, 12517, 12511, 1, 0, 0, 0, 12517, 12513, 1, 0, 0, 0, 12517, + 12515, 1, 0, 0, 0, 12518, 12519, 1, 0, 0, 0, 12519, 12517, 1, 0, 0, 0, + 12519, 12520, 1, 0, 0, 0, 12520, 12521, 1, 0, 0, 0, 12521, 12523, 5, 2377, + 0, 0, 12522, 12510, 1, 0, 0, 0, 12522, 12523, 1, 0, 0, 0, 12523, 1299, + 1, 0, 0, 0, 12524, 12525, 5, 351, 0, 0, 12525, 12528, 5, 2088, 0, 0, 12526, + 12527, 5, 751, 0, 0, 12527, 12529, 3, 1170, 585, 0, 12528, 12526, 1, 0, + 0, 0, 12528, 12529, 1, 0, 0, 0, 12529, 1301, 1, 0, 0, 0, 12530, 12531, + 5, 1580, 0, 0, 12531, 12533, 5, 1609, 0, 0, 12532, 12534, 5, 231, 0, 0, + 12533, 12532, 1, 0, 0, 0, 12533, 12534, 1, 0, 0, 0, 12534, 12536, 1, 0, + 0, 0, 12535, 12537, 5, 168, 0, 0, 12536, 12535, 1, 0, 0, 0, 12536, 12537, + 1, 0, 0, 0, 12537, 1303, 1, 0, 0, 0, 12538, 12540, 7, 147, 0, 0, 12539, + 12538, 1, 0, 0, 0, 12539, 12540, 1, 0, 0, 0, 12540, 12541, 1, 0, 0, 0, + 12541, 12542, 5, 1415, 0, 0, 12542, 1305, 1, 0, 0, 0, 12543, 12545, 5, + 2095, 0, 0, 12544, 12546, 5, 1121, 0, 0, 12545, 12544, 1, 0, 0, 0, 12545, + 12546, 1, 0, 0, 0, 12546, 12547, 1, 0, 0, 0, 12547, 12548, 5, 647, 0, 0, + 12548, 12549, 5, 330, 0, 0, 12549, 12550, 1, 0, 0, 0, 12550, 12551, 3, + 1670, 835, 0, 12551, 1307, 1, 0, 0, 0, 12552, 12553, 5, 2046, 0, 0, 12553, + 12554, 5, 1976, 0, 0, 12554, 12556, 3, 2312, 1156, 0, 12555, 12557, 5, + 1379, 0, 0, 12556, 12555, 1, 0, 0, 0, 12556, 12557, 1, 0, 0, 0, 12557, + 12558, 1, 0, 0, 0, 12558, 12559, 5, 2396, 0, 0, 12559, 1309, 1, 0, 0, 0, + 12560, 12561, 5, 425, 0, 0, 12561, 12562, 5, 1976, 0, 0, 12562, 12565, + 3, 2312, 1156, 0, 12563, 12564, 5, 168, 0, 0, 12564, 12566, 5, 268, 0, + 0, 12565, 12563, 1, 0, 0, 0, 12565, 12566, 1, 0, 0, 0, 12566, 12568, 1, + 0, 0, 0, 12567, 12569, 5, 1379, 0, 0, 12568, 12567, 1, 0, 0, 0, 12568, + 12569, 1, 0, 0, 0, 12569, 12570, 1, 0, 0, 0, 12570, 12571, 5, 2396, 0, + 0, 12571, 1311, 1, 0, 0, 0, 12572, 12573, 5, 425, 0, 0, 12573, 12574, 5, + 1973, 0, 0, 12574, 12579, 3, 2378, 1189, 0, 12575, 12577, 7, 148, 0, 0, + 12576, 12578, 5, 1394, 0, 0, 12577, 12576, 1, 0, 0, 0, 12577, 12578, 1, + 0, 0, 0, 12578, 12580, 1, 0, 0, 0, 12579, 12575, 1, 0, 0, 0, 12579, 12580, + 1, 0, 0, 0, 12580, 12582, 1, 0, 0, 0, 12581, 12583, 3, 1316, 658, 0, 12582, + 12581, 1, 0, 0, 0, 12582, 12583, 1, 0, 0, 0, 12583, 1313, 1, 0, 0, 0, 12584, + 12585, 5, 425, 0, 0, 12585, 12586, 5, 1973, 0, 0, 12586, 12587, 5, 1568, + 0, 0, 12587, 12589, 3, 2378, 1189, 0, 12588, 12590, 3, 1316, 658, 0, 12589, + 12588, 1, 0, 0, 0, 12589, 12590, 1, 0, 0, 0, 12590, 1315, 1, 0, 0, 0, 12591, + 12592, 5, 647, 0, 0, 12592, 12595, 5, 276, 0, 0, 12593, 12594, 7, 149, + 0, 0, 12594, 12596, 5, 332, 0, 0, 12595, 12593, 1, 0, 0, 0, 12595, 12596, + 1, 0, 0, 0, 12596, 12599, 1, 0, 0, 0, 12597, 12598, 5, 168, 0, 0, 12598, + 12600, 5, 268, 0, 0, 12599, 12597, 1, 0, 0, 0, 12599, 12600, 1, 0, 0, 0, + 12600, 1317, 1, 0, 0, 0, 12601, 12602, 5, 425, 0, 0, 12602, 12603, 5, 2166, + 0, 0, 12603, 12606, 3, 2312, 1156, 0, 12604, 12605, 5, 168, 0, 0, 12605, + 12607, 5, 267, 0, 0, 12606, 12604, 1, 0, 0, 0, 12606, 12607, 1, 0, 0, 0, + 12607, 12608, 1, 0, 0, 0, 12608, 12609, 5, 2396, 0, 0, 12609, 1319, 1, + 0, 0, 0, 12610, 12611, 5, 226, 0, 0, 12611, 12612, 5, 1175, 0, 0, 12612, + 12613, 5, 222, 0, 0, 12613, 12614, 3, 2310, 1155, 0, 12614, 12615, 5, 723, + 0, 0, 12615, 12616, 3, 2372, 1186, 0, 12616, 1321, 1, 0, 0, 0, 12617, 12618, + 7, 17, 0, 0, 12618, 1323, 1, 0, 0, 0, 12619, 12620, 7, 150, 0, 0, 12620, + 1325, 1, 0, 0, 0, 12621, 12623, 5, 41, 0, 0, 12622, 12624, 5, 1377, 0, + 0, 12623, 12622, 1, 0, 0, 0, 12623, 12624, 1, 0, 0, 0, 12624, 12625, 1, + 0, 0, 0, 12625, 12629, 5, 1689, 0, 0, 12626, 12627, 3, 2258, 1129, 0, 12627, + 12628, 5, 2369, 0, 0, 12628, 12630, 1, 0, 0, 0, 12629, 12626, 1, 0, 0, + 0, 12629, 12630, 1, 0, 0, 0, 12630, 12631, 1, 0, 0, 0, 12631, 12632, 3, + 2318, 1159, 0, 12632, 12633, 7, 151, 0, 0, 12633, 1327, 1, 0, 0, 0, 12634, + 12637, 5, 301, 0, 0, 12635, 12636, 5, 1219, 0, 0, 12636, 12638, 5, 1463, + 0, 0, 12637, 12635, 1, 0, 0, 0, 12637, 12638, 1, 0, 0, 0, 12638, 12639, + 1, 0, 0, 0, 12639, 12640, 5, 1377, 0, 0, 12640, 12641, 5, 1689, 0, 0, 12641, + 12642, 3, 2318, 1159, 0, 12642, 12646, 5, 564, 0, 0, 12643, 12644, 3, 2258, + 1129, 0, 12644, 12645, 5, 2369, 0, 0, 12645, 12647, 1, 0, 0, 0, 12646, + 12643, 1, 0, 0, 0, 12646, 12647, 1, 0, 0, 0, 12647, 12648, 1, 0, 0, 0, + 12648, 12651, 3, 2320, 1160, 0, 12649, 12650, 5, 2384, 0, 0, 12650, 12652, + 3, 2308, 1154, 0, 12651, 12649, 1, 0, 0, 0, 12651, 12652, 1, 0, 0, 0, 12652, + 12677, 1, 0, 0, 0, 12653, 12656, 5, 301, 0, 0, 12654, 12655, 5, 1219, 0, + 0, 12655, 12657, 5, 1463, 0, 0, 12656, 12654, 1, 0, 0, 0, 12656, 12657, + 1, 0, 0, 0, 12657, 12658, 1, 0, 0, 0, 12658, 12662, 5, 1689, 0, 0, 12659, + 12660, 3, 2258, 1129, 0, 12660, 12661, 5, 2369, 0, 0, 12661, 12663, 1, + 0, 0, 0, 12662, 12659, 1, 0, 0, 0, 12662, 12663, 1, 0, 0, 0, 12663, 12664, + 1, 0, 0, 0, 12664, 12665, 3, 2318, 1159, 0, 12665, 12669, 5, 564, 0, 0, + 12666, 12667, 3, 2258, 1129, 0, 12667, 12668, 5, 2369, 0, 0, 12668, 12670, + 1, 0, 0, 0, 12669, 12666, 1, 0, 0, 0, 12669, 12670, 1, 0, 0, 0, 12670, + 12671, 1, 0, 0, 0, 12671, 12674, 3, 2320, 1160, 0, 12672, 12673, 5, 2384, + 0, 0, 12673, 12675, 3, 2308, 1154, 0, 12674, 12672, 1, 0, 0, 0, 12674, + 12675, 1, 0, 0, 0, 12675, 12677, 1, 0, 0, 0, 12676, 12634, 1, 0, 0, 0, + 12676, 12653, 1, 0, 0, 0, 12677, 1329, 1, 0, 0, 0, 12678, 12680, 5, 425, + 0, 0, 12679, 12681, 5, 1377, 0, 0, 12680, 12679, 1, 0, 0, 0, 12680, 12681, + 1, 0, 0, 0, 12681, 12682, 1, 0, 0, 0, 12682, 12686, 5, 1689, 0, 0, 12683, + 12684, 3, 2258, 1129, 0, 12684, 12685, 5, 2369, 0, 0, 12685, 12687, 1, + 0, 0, 0, 12686, 12683, 1, 0, 0, 0, 12686, 12687, 1, 0, 0, 0, 12687, 12688, + 1, 0, 0, 0, 12688, 12690, 3, 2318, 1159, 0, 12689, 12691, 5, 560, 0, 0, + 12690, 12689, 1, 0, 0, 0, 12690, 12691, 1, 0, 0, 0, 12691, 1331, 1, 0, + 0, 0, 12692, 12693, 5, 301, 0, 0, 12693, 12696, 5, 1611, 0, 0, 12694, 12695, + 5, 2398, 0, 0, 12695, 12697, 3, 1334, 667, 0, 12696, 12694, 1, 0, 0, 0, + 12696, 12697, 1, 0, 0, 0, 12697, 12698, 1, 0, 0, 0, 12698, 12709, 5, 572, + 0, 0, 12699, 12702, 5, 1297, 0, 0, 12700, 12701, 5, 2398, 0, 0, 12701, + 12703, 3, 1336, 668, 0, 12702, 12700, 1, 0, 0, 0, 12702, 12703, 1, 0, 0, + 0, 12703, 12706, 1, 0, 0, 0, 12704, 12705, 5, 66, 0, 0, 12705, 12707, 5, + 284, 0, 0, 12706, 12704, 1, 0, 0, 0, 12706, 12707, 1, 0, 0, 0, 12707, 12710, + 1, 0, 0, 0, 12708, 12710, 5, 871, 0, 0, 12709, 12699, 1, 0, 0, 0, 12709, + 12708, 1, 0, 0, 0, 12710, 1333, 1, 0, 0, 0, 12711, 12712, 5, 2372, 0, 0, + 12712, 1335, 1, 0, 0, 0, 12713, 12714, 5, 2372, 0, 0, 12714, 1337, 1, 0, + 0, 0, 12715, 12716, 5, 226, 0, 0, 12716, 12717, 5, 1175, 0, 0, 12717, 12718, + 5, 1976, 0, 0, 12718, 12719, 3, 2312, 1156, 0, 12719, 12720, 5, 723, 0, + 0, 12720, 12721, 3, 2372, 1186, 0, 12721, 1339, 1, 0, 0, 0, 12722, 12723, + 5, 226, 0, 0, 12723, 12724, 5, 1175, 0, 0, 12724, 12725, 5, 848, 0, 0, + 12725, 12726, 5, 2166, 0, 0, 12726, 12727, 3, 2312, 1156, 0, 12727, 12728, + 5, 723, 0, 0, 12728, 12729, 3, 2372, 1186, 0, 12729, 1341, 1, 0, 0, 0, + 12730, 12731, 5, 41, 0, 0, 12731, 12732, 5, 44, 0, 0, 12732, 12736, 5, + 2166, 0, 0, 12733, 12734, 3, 2258, 1129, 0, 12734, 12735, 5, 2369, 0, 0, + 12735, 12737, 1, 0, 0, 0, 12736, 12733, 1, 0, 0, 0, 12736, 12737, 1, 0, + 0, 0, 12737, 12738, 1, 0, 0, 0, 12738, 12745, 3, 2378, 1189, 0, 12739, + 12740, 5, 1460, 0, 0, 12740, 12741, 5, 2029, 0, 0, 12741, 12746, 3, 2378, + 1189, 0, 12742, 12746, 5, 233, 0, 0, 12743, 12746, 3, 1344, 672, 0, 12744, + 12746, 3, 1350, 675, 0, 12745, 12739, 1, 0, 0, 0, 12745, 12742, 1, 0, 0, + 0, 12745, 12743, 1, 0, 0, 0, 12745, 12744, 1, 0, 0, 0, 12746, 1343, 1, + 0, 0, 0, 12747, 12748, 5, 20, 0, 0, 12748, 12749, 5, 155, 0, 0, 12749, + 12750, 5, 862, 0, 0, 12750, 12751, 5, 593, 0, 0, 12751, 12754, 5, 2376, + 0, 0, 12752, 12755, 5, 37, 0, 0, 12753, 12755, 3, 1348, 674, 0, 12754, + 12752, 1, 0, 0, 0, 12754, 12753, 1, 0, 0, 0, 12754, 12755, 1, 0, 0, 0, + 12755, 12756, 1, 0, 0, 0, 12756, 12757, 5, 2377, 0, 0, 12757, 12758, 5, + 783, 0, 0, 12758, 12759, 5, 2376, 0, 0, 12759, 12764, 3, 1346, 673, 0, + 12760, 12761, 5, 2382, 0, 0, 12761, 12763, 3, 1346, 673, 0, 12762, 12760, + 1, 0, 0, 0, 12763, 12766, 1, 0, 0, 0, 12764, 12762, 1, 0, 0, 0, 12764, + 12765, 1, 0, 0, 0, 12765, 12767, 1, 0, 0, 0, 12766, 12764, 1, 0, 0, 0, + 12767, 12768, 5, 2377, 0, 0, 12768, 1345, 1, 0, 0, 0, 12769, 12770, 3, + 2378, 1189, 0, 12770, 12771, 5, 2369, 0, 0, 12771, 12773, 1, 0, 0, 0, 12772, + 12769, 1, 0, 0, 0, 12772, 12773, 1, 0, 0, 0, 12773, 12774, 1, 0, 0, 0, + 12774, 12775, 3, 2378, 1189, 0, 12775, 12776, 5, 2369, 0, 0, 12776, 12778, + 1, 0, 0, 0, 12777, 12772, 1, 0, 0, 0, 12777, 12778, 1, 0, 0, 0, 12778, + 12779, 1, 0, 0, 0, 12779, 12780, 3, 2378, 1189, 0, 12780, 1347, 1, 0, 0, + 0, 12781, 12786, 3, 2378, 1189, 0, 12782, 12783, 5, 2382, 0, 0, 12783, + 12785, 3, 2378, 1189, 0, 12784, 12782, 1, 0, 0, 0, 12785, 12788, 1, 0, + 0, 0, 12786, 12784, 1, 0, 0, 0, 12786, 12787, 1, 0, 0, 0, 12787, 1349, + 1, 0, 0, 0, 12788, 12786, 1, 0, 0, 0, 12789, 12790, 5, 425, 0, 0, 12790, + 12791, 5, 155, 0, 0, 12791, 12792, 5, 862, 0, 0, 12792, 12793, 5, 593, + 0, 0, 12793, 12796, 5, 2376, 0, 0, 12794, 12797, 5, 37, 0, 0, 12795, 12797, + 3, 1348, 674, 0, 12796, 12794, 1, 0, 0, 0, 12796, 12795, 1, 0, 0, 0, 12796, + 12797, 1, 0, 0, 0, 12797, 12798, 1, 0, 0, 0, 12798, 12799, 5, 2377, 0, + 0, 12799, 12800, 5, 783, 0, 0, 12800, 12801, 5, 2376, 0, 0, 12801, 12806, + 3, 1346, 673, 0, 12802, 12803, 5, 2382, 0, 0, 12803, 12805, 3, 1346, 673, + 0, 12804, 12802, 1, 0, 0, 0, 12805, 12808, 1, 0, 0, 0, 12806, 12804, 1, + 0, 0, 0, 12806, 12807, 1, 0, 0, 0, 12807, 12809, 1, 0, 0, 0, 12808, 12806, + 1, 0, 0, 0, 12809, 12810, 5, 2377, 0, 0, 12810, 1351, 1, 0, 0, 0, 12811, + 12812, 5, 41, 0, 0, 12812, 12813, 5, 80, 0, 0, 12813, 12817, 5, 392, 0, + 0, 12814, 12815, 3, 2258, 1129, 0, 12815, 12816, 5, 2369, 0, 0, 12816, + 12818, 1, 0, 0, 0, 12817, 12814, 1, 0, 0, 0, 12817, 12818, 1, 0, 0, 0, + 12818, 12819, 1, 0, 0, 0, 12819, 12824, 3, 2378, 1189, 0, 12820, 12821, + 5, 1460, 0, 0, 12821, 12822, 5, 2029, 0, 0, 12822, 12825, 3, 2378, 1189, + 0, 12823, 12825, 5, 233, 0, 0, 12824, 12820, 1, 0, 0, 0, 12824, 12823, + 1, 0, 0, 0, 12825, 1353, 1, 0, 0, 0, 12826, 12827, 5, 41, 0, 0, 12827, + 12828, 5, 82, 0, 0, 12828, 12829, 5, 1318, 0, 0, 12829, 12831, 3, 2378, + 1189, 0, 12830, 12832, 5, 20, 0, 0, 12831, 12830, 1, 0, 0, 0, 12831, 12832, + 1, 0, 0, 0, 12832, 12846, 1, 0, 0, 0, 12833, 12835, 3, 406, 203, 0, 12834, + 12833, 1, 0, 0, 0, 12834, 12835, 1, 0, 0, 0, 12835, 12837, 1, 0, 0, 0, + 12836, 12838, 3, 408, 204, 0, 12837, 12836, 1, 0, 0, 0, 12837, 12838, 1, + 0, 0, 0, 12838, 12840, 1, 0, 0, 0, 12839, 12841, 3, 422, 211, 0, 12840, + 12839, 1, 0, 0, 0, 12840, 12841, 1, 0, 0, 0, 12841, 12847, 1, 0, 0, 0, + 12842, 12843, 5, 1174, 0, 0, 12843, 12845, 5, 2023, 0, 0, 12844, 12842, + 1, 0, 0, 0, 12844, 12845, 1, 0, 0, 0, 12845, 12847, 1, 0, 0, 0, 12846, + 12834, 1, 0, 0, 0, 12846, 12844, 1, 0, 0, 0, 12847, 12849, 1, 0, 0, 0, + 12848, 12850, 5, 425, 0, 0, 12849, 12848, 1, 0, 0, 0, 12849, 12850, 1, + 0, 0, 0, 12850, 12864, 1, 0, 0, 0, 12851, 12853, 3, 406, 203, 0, 12852, + 12851, 1, 0, 0, 0, 12852, 12853, 1, 0, 0, 0, 12853, 12855, 1, 0, 0, 0, + 12854, 12856, 3, 408, 204, 0, 12855, 12854, 1, 0, 0, 0, 12855, 12856, 1, + 0, 0, 0, 12856, 12858, 1, 0, 0, 0, 12857, 12859, 3, 422, 211, 0, 12858, + 12857, 1, 0, 0, 0, 12858, 12859, 1, 0, 0, 0, 12859, 12865, 1, 0, 0, 0, + 12860, 12861, 5, 1174, 0, 0, 12861, 12863, 5, 2023, 0, 0, 12862, 12860, + 1, 0, 0, 0, 12862, 12863, 1, 0, 0, 0, 12863, 12865, 1, 0, 0, 0, 12864, + 12852, 1, 0, 0, 0, 12864, 12862, 1, 0, 0, 0, 12865, 12874, 1, 0, 0, 0, + 12866, 12872, 5, 247, 0, 0, 12867, 12873, 5, 425, 0, 0, 12868, 12869, 5, + 2372, 0, 0, 12869, 12870, 5, 477, 0, 0, 12870, 12871, 5, 1296, 0, 0, 12871, + 12873, 7, 50, 0, 0, 12872, 12867, 1, 0, 0, 0, 12872, 12868, 1, 0, 0, 0, + 12873, 12875, 1, 0, 0, 0, 12874, 12866, 1, 0, 0, 0, 12874, 12875, 1, 0, + 0, 0, 12875, 1355, 1, 0, 0, 0, 12876, 12877, 5, 41, 0, 0, 12877, 12878, + 5, 206, 0, 0, 12878, 12885, 3, 462, 231, 0, 12879, 12886, 3, 1188, 594, + 0, 12880, 12881, 5, 1595, 0, 0, 12881, 12886, 3, 1170, 585, 0, 12882, 12886, + 3, 1298, 649, 0, 12883, 12886, 3, 1300, 650, 0, 12884, 12886, 3, 1378, + 689, 0, 12885, 12879, 1, 0, 0, 0, 12885, 12880, 1, 0, 0, 0, 12885, 12882, + 1, 0, 0, 0, 12885, 12883, 1, 0, 0, 0, 12885, 12884, 1, 0, 0, 0, 12886, + 12887, 1, 0, 0, 0, 12887, 12885, 1, 0, 0, 0, 12887, 12888, 1, 0, 0, 0, + 12888, 12890, 1, 0, 0, 0, 12889, 12891, 3, 926, 463, 0, 12890, 12889, 1, + 0, 0, 0, 12890, 12891, 1, 0, 0, 0, 12891, 12892, 1, 0, 0, 0, 12892, 12893, + 5, 2396, 0, 0, 12893, 1357, 1, 0, 0, 0, 12894, 12895, 5, 425, 0, 0, 12895, + 12896, 5, 44, 0, 0, 12896, 12900, 5, 2166, 0, 0, 12897, 12898, 3, 2258, + 1129, 0, 12898, 12899, 5, 2369, 0, 0, 12899, 12901, 1, 0, 0, 0, 12900, + 12897, 1, 0, 0, 0, 12900, 12901, 1, 0, 0, 0, 12901, 12902, 1, 0, 0, 0, + 12902, 12903, 3, 2378, 1189, 0, 12903, 1359, 1, 0, 0, 0, 12904, 12905, + 5, 425, 0, 0, 12905, 12906, 5, 80, 0, 0, 12906, 12910, 5, 392, 0, 0, 12907, + 12908, 3, 2258, 1129, 0, 12908, 12909, 5, 2369, 0, 0, 12909, 12911, 1, + 0, 0, 0, 12910, 12907, 1, 0, 0, 0, 12910, 12911, 1, 0, 0, 0, 12911, 12912, + 1, 0, 0, 0, 12912, 12913, 3, 2378, 1189, 0, 12913, 1361, 1, 0, 0, 0, 12914, + 12915, 5, 425, 0, 0, 12915, 12916, 5, 82, 0, 0, 12916, 12917, 5, 1318, + 0, 0, 12917, 12918, 3, 2378, 1189, 0, 12918, 1363, 1, 0, 0, 0, 12919, 12920, + 5, 425, 0, 0, 12920, 12921, 5, 549, 0, 0, 12921, 12922, 5, 62, 0, 0, 12922, + 12923, 3, 2378, 1189, 0, 12923, 1365, 1, 0, 0, 0, 12924, 12925, 5, 425, + 0, 0, 12925, 12926, 5, 206, 0, 0, 12926, 12933, 3, 462, 231, 0, 12927, + 12928, 5, 647, 0, 0, 12928, 12931, 5, 1974, 0, 0, 12929, 12930, 5, 168, + 0, 0, 12930, 12932, 5, 268, 0, 0, 12931, 12929, 1, 0, 0, 0, 12931, 12932, + 1, 0, 0, 0, 12932, 12934, 1, 0, 0, 0, 12933, 12927, 1, 0, 0, 0, 12933, + 12934, 1, 0, 0, 0, 12934, 1367, 1, 0, 0, 0, 12935, 12936, 5, 425, 0, 0, + 12936, 12937, 5, 277, 0, 0, 12937, 12938, 3, 2378, 1189, 0, 12938, 1369, + 1, 0, 0, 0, 12939, 12940, 5, 425, 0, 0, 12940, 12941, 5, 395, 0, 0, 12941, + 12942, 3, 2378, 1189, 0, 12942, 1371, 1, 0, 0, 0, 12943, 12944, 5, 425, + 0, 0, 12944, 12945, 5, 407, 0, 0, 12945, 12954, 3, 2378, 1189, 0, 12946, + 12948, 5, 560, 0, 0, 12947, 12946, 1, 0, 0, 0, 12947, 12948, 1, 0, 0, 0, + 12948, 12949, 1, 0, 0, 0, 12949, 12952, 5, 647, 0, 0, 12950, 12952, 5, + 487, 0, 0, 12951, 12947, 1, 0, 0, 0, 12951, 12950, 1, 0, 0, 0, 12952, 12953, + 1, 0, 0, 0, 12953, 12955, 5, 276, 0, 0, 12954, 12951, 1, 0, 0, 0, 12954, + 12955, 1, 0, 0, 0, 12955, 1373, 1, 0, 0, 0, 12956, 12957, 5, 425, 0, 0, + 12957, 12958, 5, 438, 0, 0, 12958, 12960, 3, 2378, 1189, 0, 12959, 12961, + 5, 168, 0, 0, 12960, 12959, 1, 0, 0, 0, 12960, 12961, 1, 0, 0, 0, 12961, + 1375, 1, 0, 0, 0, 12962, 12963, 5, 2046, 0, 0, 12963, 12964, 5, 206, 0, + 0, 12964, 12967, 3, 462, 231, 0, 12965, 12966, 7, 152, 0, 0, 12966, 12968, + 5, 1655, 0, 0, 12967, 12965, 1, 0, 0, 0, 12967, 12968, 1, 0, 0, 0, 12968, + 1377, 1, 0, 0, 0, 12969, 12970, 7, 103, 0, 0, 12970, 1379, 1, 0, 0, 0, + 12971, 12972, 3, 2382, 1191, 0, 12972, 1381, 1, 0, 0, 0, 12973, 12974, + 5, 41, 0, 0, 12974, 12990, 3, 1384, 692, 0, 12975, 12991, 3, 1386, 693, + 0, 12976, 12991, 3, 1392, 696, 0, 12977, 12991, 3, 1408, 704, 0, 12978, + 12991, 3, 1418, 709, 0, 12979, 12991, 3, 1436, 718, 0, 12980, 12991, 3, + 1440, 720, 0, 12981, 12991, 3, 1456, 728, 0, 12982, 12991, 3, 1460, 730, + 0, 12983, 12991, 3, 1462, 731, 0, 12984, 12991, 3, 1474, 737, 0, 12985, + 12991, 3, 1476, 738, 0, 12986, 12991, 3, 1478, 739, 0, 12987, 12991, 3, + 1480, 740, 0, 12988, 12991, 3, 1486, 743, 0, 12989, 12991, 3, 1488, 744, + 0, 12990, 12975, 1, 0, 0, 0, 12990, 12976, 1, 0, 0, 0, 12990, 12977, 1, + 0, 0, 0, 12990, 12978, 1, 0, 0, 0, 12990, 12979, 1, 0, 0, 0, 12990, 12980, + 1, 0, 0, 0, 12990, 12981, 1, 0, 0, 0, 12990, 12982, 1, 0, 0, 0, 12990, + 12983, 1, 0, 0, 0, 12990, 12984, 1, 0, 0, 0, 12990, 12985, 1, 0, 0, 0, + 12990, 12986, 1, 0, 0, 0, 12990, 12987, 1, 0, 0, 0, 12990, 12988, 1, 0, + 0, 0, 12990, 12989, 1, 0, 0, 0, 12991, 12992, 1, 0, 0, 0, 12992, 12993, + 5, 2396, 0, 0, 12993, 1383, 1, 0, 0, 0, 12994, 12996, 5, 1315, 0, 0, 12995, + 12994, 1, 0, 0, 0, 12995, 12996, 1, 0, 0, 0, 12996, 12997, 1, 0, 0, 0, + 12997, 12999, 5, 329, 0, 0, 12998, 13000, 3, 1380, 690, 0, 12999, 12998, + 1, 0, 0, 0, 12999, 13000, 1, 0, 0, 0, 13000, 1385, 1, 0, 0, 0, 13001, 13004, + 5, 917, 0, 0, 13002, 13003, 7, 153, 0, 0, 13003, 13005, 5, 329, 0, 0, 13004, + 13002, 1, 0, 0, 0, 13004, 13005, 1, 0, 0, 0, 13005, 13021, 1, 0, 0, 0, + 13006, 13009, 5, 1180, 0, 0, 13007, 13008, 5, 1408, 0, 0, 13008, 13010, + 5, 2192, 0, 0, 13009, 13007, 1, 0, 0, 0, 13009, 13010, 1, 0, 0, 0, 13010, + 13012, 1, 0, 0, 0, 13011, 13013, 3, 1388, 694, 0, 13012, 13011, 1, 0, 0, + 0, 13012, 13013, 1, 0, 0, 0, 13013, 13015, 1, 0, 0, 0, 13014, 13016, 3, + 1390, 695, 0, 13015, 13014, 1, 0, 0, 0, 13015, 13016, 1, 0, 0, 0, 13016, + 13021, 1, 0, 0, 0, 13017, 13018, 5, 1180, 0, 0, 13018, 13019, 5, 1408, + 0, 0, 13019, 13021, 5, 1174, 0, 0, 13020, 13001, 1, 0, 0, 0, 13020, 13006, + 1, 0, 0, 0, 13020, 13017, 1, 0, 0, 0, 13021, 1387, 1, 0, 0, 0, 13022, 13023, + 7, 56, 0, 0, 13023, 1389, 1, 0, 0, 0, 13024, 13025, 7, 154, 0, 0, 13025, + 1391, 1, 0, 0, 0, 13026, 13032, 3, 1396, 698, 0, 13027, 13032, 3, 1404, + 702, 0, 13028, 13029, 3, 1394, 697, 0, 13029, 13030, 5, 98, 0, 0, 13030, + 13032, 1, 0, 0, 0, 13031, 13026, 1, 0, 0, 0, 13031, 13027, 1, 0, 0, 0, + 13031, 13028, 1, 0, 0, 0, 13032, 1393, 1, 0, 0, 0, 13033, 13034, 7, 155, + 0, 0, 13034, 1395, 1, 0, 0, 0, 13035, 13037, 5, 1417, 0, 0, 13036, 13038, + 5, 91, 0, 0, 13037, 13036, 1, 0, 0, 0, 13037, 13038, 1, 0, 0, 0, 13038, + 13041, 1, 0, 0, 0, 13039, 13040, 5, 572, 0, 0, 13040, 13042, 5, 2372, 0, + 0, 13041, 13039, 1, 0, 0, 0, 13041, 13042, 1, 0, 0, 0, 13042, 13065, 1, + 0, 0, 0, 13043, 13048, 3, 1398, 699, 0, 13044, 13048, 3, 1400, 700, 0, + 13045, 13046, 5, 813, 0, 0, 13046, 13048, 5, 2372, 0, 0, 13047, 13043, + 1, 0, 0, 0, 13047, 13044, 1, 0, 0, 0, 13047, 13045, 1, 0, 0, 0, 13047, + 13048, 1, 0, 0, 0, 13048, 13058, 1, 0, 0, 0, 13049, 13055, 5, 1986, 0, + 0, 13050, 13051, 5, 39, 0, 0, 13051, 13052, 5, 2370, 0, 0, 13052, 13055, + 5, 287, 0, 0, 13053, 13055, 3, 926, 463, 0, 13054, 13049, 1, 0, 0, 0, 13054, + 13050, 1, 0, 0, 0, 13054, 13053, 1, 0, 0, 0, 13055, 13056, 1, 0, 0, 0, + 13056, 13054, 1, 0, 0, 0, 13056, 13057, 1, 0, 0, 0, 13057, 13059, 1, 0, + 0, 0, 13058, 13054, 1, 0, 0, 0, 13058, 13059, 1, 0, 0, 0, 13059, 13066, + 1, 0, 0, 0, 13060, 13062, 5, 278, 0, 0, 13061, 13063, 5, 363, 0, 0, 13062, + 13061, 1, 0, 0, 0, 13062, 13063, 1, 0, 0, 0, 13063, 13066, 1, 0, 0, 0, + 13064, 13066, 5, 163, 0, 0, 13065, 13047, 1, 0, 0, 0, 13065, 13060, 1, + 0, 0, 0, 13065, 13064, 1, 0, 0, 0, 13066, 1397, 1, 0, 0, 0, 13067, 13069, + 5, 1628, 0, 0, 13068, 13067, 1, 0, 0, 0, 13068, 13069, 1, 0, 0, 0, 13069, + 13070, 1, 0, 0, 0, 13070, 13090, 5, 329, 0, 0, 13071, 13078, 5, 2086, 0, + 0, 13072, 13079, 5, 163, 0, 0, 13073, 13074, 5, 2001, 0, 0, 13074, 13079, + 5, 2372, 0, 0, 13075, 13076, 5, 179, 0, 0, 13076, 13079, 5, 2370, 0, 0, + 13077, 13079, 5, 264, 0, 0, 13078, 13072, 1, 0, 0, 0, 13078, 13073, 1, + 0, 0, 0, 13078, 13075, 1, 0, 0, 0, 13078, 13077, 1, 0, 0, 0, 13079, 13087, + 1, 0, 0, 0, 13080, 13081, 5, 2129, 0, 0, 13081, 13082, 5, 98, 0, 0, 13082, + 13087, 5, 279, 0, 0, 13083, 13084, 5, 1602, 0, 0, 13084, 13085, 5, 2001, + 0, 0, 13085, 13087, 5, 2372, 0, 0, 13086, 13071, 1, 0, 0, 0, 13086, 13080, + 1, 0, 0, 0, 13086, 13083, 1, 0, 0, 0, 13087, 13088, 1, 0, 0, 0, 13088, + 13086, 1, 0, 0, 0, 13088, 13089, 1, 0, 0, 0, 13089, 13091, 1, 0, 0, 0, + 13090, 13086, 1, 0, 0, 0, 13090, 13091, 1, 0, 0, 0, 13091, 1399, 1, 0, + 0, 0, 13092, 13093, 5, 1973, 0, 0, 13093, 13098, 3, 1666, 833, 0, 13094, + 13095, 5, 2382, 0, 0, 13095, 13097, 3, 1666, 833, 0, 13096, 13094, 1, 0, + 0, 0, 13097, 13100, 1, 0, 0, 0, 13098, 13096, 1, 0, 0, 0, 13098, 13099, + 1, 0, 0, 0, 13099, 13114, 1, 0, 0, 0, 13100, 13098, 1, 0, 0, 0, 13101, + 13102, 5, 331, 0, 0, 13102, 13114, 5, 2372, 0, 0, 13103, 13109, 3, 1470, + 735, 0, 13104, 13105, 5, 2382, 0, 0, 13105, 13108, 5, 2372, 0, 0, 13106, + 13108, 3, 1470, 735, 0, 13107, 13104, 1, 0, 0, 0, 13107, 13106, 1, 0, 0, + 0, 13108, 13111, 1, 0, 0, 0, 13109, 13107, 1, 0, 0, 0, 13109, 13110, 1, + 0, 0, 0, 13110, 13114, 1, 0, 0, 0, 13111, 13109, 1, 0, 0, 0, 13112, 13114, + 3, 1402, 701, 0, 13113, 13092, 1, 0, 0, 0, 13113, 13101, 1, 0, 0, 0, 13113, + 13103, 1, 0, 0, 0, 13113, 13112, 1, 0, 0, 0, 13114, 1401, 1, 0, 0, 0, 13115, + 13116, 4, 701, 8, 0, 13116, 13137, 5, 1628, 0, 0, 13117, 13118, 5, 1973, + 0, 0, 13118, 13123, 3, 1666, 833, 0, 13119, 13120, 5, 2382, 0, 0, 13120, + 13122, 3, 1666, 833, 0, 13121, 13119, 1, 0, 0, 0, 13122, 13125, 1, 0, 0, + 0, 13123, 13121, 1, 0, 0, 0, 13123, 13124, 1, 0, 0, 0, 13124, 13138, 1, + 0, 0, 0, 13125, 13123, 1, 0, 0, 0, 13126, 13127, 5, 331, 0, 0, 13127, 13138, + 5, 2372, 0, 0, 13128, 13134, 3, 1470, 735, 0, 13129, 13130, 5, 2382, 0, + 0, 13130, 13133, 5, 2372, 0, 0, 13131, 13133, 3, 1470, 735, 0, 13132, 13129, + 1, 0, 0, 0, 13132, 13131, 1, 0, 0, 0, 13133, 13136, 1, 0, 0, 0, 13134, + 13132, 1, 0, 0, 0, 13134, 13135, 1, 0, 0, 0, 13135, 13138, 1, 0, 0, 0, + 13136, 13134, 1, 0, 0, 0, 13137, 13117, 1, 0, 0, 0, 13137, 13126, 1, 0, + 0, 0, 13137, 13128, 1, 0, 0, 0, 13138, 13139, 1, 0, 0, 0, 13139, 13142, + 5, 2086, 0, 0, 13140, 13141, 5, 264, 0, 0, 13141, 13143, 5, 2188, 0, 0, + 13142, 13140, 1, 0, 0, 0, 13142, 13143, 1, 0, 0, 0, 13143, 13144, 1, 0, + 0, 0, 13144, 13145, 5, 279, 0, 0, 13145, 1403, 1, 0, 0, 0, 13146, 13181, + 5, 1417, 0, 0, 13147, 13148, 5, 834, 0, 0, 13148, 13149, 5, 1628, 0, 0, + 13149, 13171, 5, 329, 0, 0, 13150, 13151, 5, 2129, 0, 0, 13151, 13152, + 5, 315, 0, 0, 13152, 13166, 5, 813, 0, 0, 13153, 13156, 5, 405, 0, 0, 13154, + 13155, 5, 572, 0, 0, 13155, 13157, 5, 1564, 0, 0, 13156, 13154, 1, 0, 0, + 0, 13156, 13157, 1, 0, 0, 0, 13157, 13166, 1, 0, 0, 0, 13158, 13166, 5, + 1013, 0, 0, 13159, 13160, 5, 2086, 0, 0, 13160, 13161, 5, 179, 0, 0, 13161, + 13166, 5, 2370, 0, 0, 13162, 13163, 5, 2086, 0, 0, 13163, 13166, 5, 264, + 0, 0, 13164, 13166, 3, 926, 463, 0, 13165, 13150, 1, 0, 0, 0, 13165, 13153, + 1, 0, 0, 0, 13165, 13158, 1, 0, 0, 0, 13165, 13159, 1, 0, 0, 0, 13165, + 13162, 1, 0, 0, 0, 13165, 13164, 1, 0, 0, 0, 13166, 13167, 1, 0, 0, 0, + 13167, 13165, 1, 0, 0, 0, 13167, 13168, 1, 0, 0, 0, 13168, 13172, 1, 0, + 0, 0, 13169, 13172, 5, 542, 0, 0, 13170, 13172, 5, 163, 0, 0, 13171, 13165, + 1, 0, 0, 0, 13171, 13169, 1, 0, 0, 0, 13171, 13170, 1, 0, 0, 0, 13171, + 13172, 1, 0, 0, 0, 13172, 13182, 1, 0, 0, 0, 13173, 13174, 5, 2029, 0, + 0, 13174, 13175, 5, 816, 0, 0, 13175, 13179, 5, 1628, 0, 0, 13176, 13180, + 3, 1406, 703, 0, 13177, 13178, 5, 751, 0, 0, 13178, 13180, 5, 630, 0, 0, + 13179, 13176, 1, 0, 0, 0, 13179, 13177, 1, 0, 0, 0, 13180, 13182, 1, 0, + 0, 0, 13181, 13147, 1, 0, 0, 0, 13181, 13173, 1, 0, 0, 0, 13182, 1405, + 1, 0, 0, 0, 13183, 13184, 3, 2382, 1191, 0, 13184, 1407, 1, 0, 0, 0, 13185, + 13186, 5, 1460, 0, 0, 13186, 13187, 5, 534, 0, 0, 13187, 13192, 3, 1472, + 736, 0, 13188, 13189, 5, 2382, 0, 0, 13189, 13191, 3, 1472, 736, 0, 13190, + 13188, 1, 0, 0, 0, 13191, 13194, 1, 0, 0, 0, 13192, 13190, 1, 0, 0, 0, + 13192, 13193, 1, 0, 0, 0, 13193, 13195, 1, 0, 0, 0, 13194, 13192, 1, 0, + 0, 0, 13195, 13196, 5, 2029, 0, 0, 13196, 13197, 3, 1472, 736, 0, 13197, + 13203, 1, 0, 0, 0, 13198, 13203, 3, 1410, 705, 0, 13199, 13203, 3, 1412, + 706, 0, 13200, 13203, 3, 1414, 707, 0, 13201, 13203, 3, 1416, 708, 0, 13202, + 13185, 1, 0, 0, 0, 13202, 13198, 1, 0, 0, 0, 13202, 13199, 1, 0, 0, 0, + 13202, 13200, 1, 0, 0, 0, 13202, 13201, 1, 0, 0, 0, 13203, 1409, 1, 0, + 0, 0, 13204, 13205, 5, 301, 0, 0, 13205, 13208, 5, 331, 0, 0, 13206, 13209, + 3, 1472, 736, 0, 13207, 13209, 3, 1470, 735, 0, 13208, 13206, 1, 0, 0, + 0, 13208, 13207, 1, 0, 0, 0, 13209, 13217, 1, 0, 0, 0, 13210, 13213, 5, + 2382, 0, 0, 13211, 13214, 3, 1472, 736, 0, 13212, 13214, 3, 1470, 735, + 0, 13213, 13211, 1, 0, 0, 0, 13213, 13212, 1, 0, 0, 0, 13214, 13216, 1, + 0, 0, 0, 13215, 13210, 1, 0, 0, 0, 13216, 13219, 1, 0, 0, 0, 13217, 13215, + 1, 0, 0, 0, 13217, 13218, 1, 0, 0, 0, 13218, 13222, 1, 0, 0, 0, 13219, + 13217, 1, 0, 0, 0, 13220, 13221, 5, 66, 0, 0, 13221, 13223, 5, 950, 0, + 0, 13222, 13220, 1, 0, 0, 0, 13222, 13223, 1, 0, 0, 0, 13223, 1411, 1, + 0, 0, 0, 13224, 13227, 5, 331, 0, 0, 13225, 13228, 3, 1472, 736, 0, 13226, + 13228, 3, 1470, 735, 0, 13227, 13225, 1, 0, 0, 0, 13227, 13226, 1, 0, 0, + 0, 13228, 13236, 1, 0, 0, 0, 13229, 13232, 5, 2382, 0, 0, 13230, 13233, + 3, 1472, 736, 0, 13231, 13233, 3, 1470, 735, 0, 13232, 13230, 1, 0, 0, + 0, 13232, 13231, 1, 0, 0, 0, 13233, 13235, 1, 0, 0, 0, 13234, 13229, 1, + 0, 0, 0, 13235, 13238, 1, 0, 0, 0, 13236, 13234, 1, 0, 0, 0, 13236, 13237, + 1, 0, 0, 0, 13237, 13250, 1, 0, 0, 0, 13238, 13236, 1, 0, 0, 0, 13239, + 13251, 5, 1173, 0, 0, 13240, 13243, 5, 1160, 0, 0, 13241, 13242, 5, 564, + 0, 0, 13242, 13244, 5, 425, 0, 0, 13243, 13241, 1, 0, 0, 0, 13243, 13244, + 1, 0, 0, 0, 13244, 13251, 1, 0, 0, 0, 13245, 13246, 5, 1468, 0, 0, 13246, + 13251, 3, 1170, 585, 0, 13247, 13251, 3, 918, 459, 0, 13248, 13249, 5, + 459, 0, 0, 13249, 13251, 5, 98, 0, 0, 13250, 13239, 1, 0, 0, 0, 13250, + 13240, 1, 0, 0, 0, 13250, 13245, 1, 0, 0, 0, 13250, 13247, 1, 0, 0, 0, + 13250, 13248, 1, 0, 0, 0, 13251, 1413, 1, 0, 0, 0, 13252, 13255, 5, 1982, + 0, 0, 13253, 13256, 3, 1472, 736, 0, 13254, 13256, 3, 1470, 735, 0, 13255, + 13253, 1, 0, 0, 0, 13255, 13254, 1, 0, 0, 0, 13256, 13264, 1, 0, 0, 0, + 13257, 13260, 5, 2382, 0, 0, 13258, 13261, 3, 1472, 736, 0, 13259, 13261, + 3, 1470, 735, 0, 13260, 13258, 1, 0, 0, 0, 13260, 13259, 1, 0, 0, 0, 13261, + 13263, 1, 0, 0, 0, 13262, 13257, 1, 0, 0, 0, 13263, 13266, 1, 0, 0, 0, + 13264, 13262, 1, 0, 0, 0, 13264, 13265, 1, 0, 0, 0, 13265, 13275, 1, 0, + 0, 0, 13266, 13264, 1, 0, 0, 0, 13267, 13268, 5, 1468, 0, 0, 13268, 13276, + 3, 1170, 585, 0, 13269, 13276, 3, 918, 459, 0, 13270, 13271, 5, 425, 0, + 0, 13271, 13272, 5, 647, 0, 0, 13272, 13276, 5, 332, 0, 0, 13273, 13276, + 5, 1173, 0, 0, 13274, 13276, 5, 1160, 0, 0, 13275, 13267, 1, 0, 0, 0, 13275, + 13269, 1, 0, 0, 0, 13275, 13270, 1, 0, 0, 0, 13275, 13273, 1, 0, 0, 0, + 13275, 13274, 1, 0, 0, 0, 13276, 1415, 1, 0, 0, 0, 13277, 13278, 5, 921, + 0, 0, 13278, 13281, 5, 331, 0, 0, 13279, 13282, 3, 1472, 736, 0, 13280, + 13282, 3, 1470, 735, 0, 13281, 13279, 1, 0, 0, 0, 13281, 13280, 1, 0, 0, + 0, 13282, 13290, 1, 0, 0, 0, 13283, 13286, 5, 2382, 0, 0, 13284, 13287, + 3, 1472, 736, 0, 13285, 13287, 3, 1470, 735, 0, 13286, 13284, 1, 0, 0, + 0, 13286, 13285, 1, 0, 0, 0, 13287, 13289, 1, 0, 0, 0, 13288, 13283, 1, + 0, 0, 0, 13289, 13292, 1, 0, 0, 0, 13290, 13288, 1, 0, 0, 0, 13290, 13291, + 1, 0, 0, 0, 13291, 13295, 1, 0, 0, 0, 13292, 13290, 1, 0, 0, 0, 13293, + 13294, 5, 2029, 0, 0, 13294, 13296, 3, 1472, 736, 0, 13295, 13293, 1, 0, + 0, 0, 13295, 13296, 1, 0, 0, 0, 13296, 13298, 1, 0, 0, 0, 13297, 13299, + 5, 1488, 0, 0, 13298, 13297, 1, 0, 0, 0, 13298, 13299, 1, 0, 0, 0, 13299, + 13301, 1, 0, 0, 0, 13300, 13302, 5, 751, 0, 0, 13301, 13300, 1, 0, 0, 0, + 13301, 13302, 1, 0, 0, 0, 13302, 1417, 1, 0, 0, 0, 13303, 13305, 5, 64, + 0, 0, 13304, 13306, 5, 839, 0, 0, 13305, 13304, 1, 0, 0, 0, 13305, 13306, + 1, 0, 0, 0, 13306, 13309, 1, 0, 0, 0, 13307, 13309, 5, 986, 0, 0, 13308, + 13303, 1, 0, 0, 0, 13308, 13307, 1, 0, 0, 0, 13309, 13360, 1, 0, 0, 0, + 13310, 13312, 5, 1057, 0, 0, 13311, 13310, 1, 0, 0, 0, 13311, 13312, 1, + 0, 0, 0, 13312, 13313, 1, 0, 0, 0, 13313, 13314, 5, 560, 0, 0, 13314, 13360, + 5, 815, 0, 0, 13315, 13316, 5, 1568, 0, 0, 13316, 13317, 5, 1628, 0, 0, + 13317, 13318, 5, 1040, 0, 0, 13318, 13323, 5, 564, 0, 0, 13319, 13320, + 5, 330, 0, 0, 13320, 13324, 5, 94, 0, 0, 13321, 13322, 5, 799, 0, 0, 13322, + 13324, 5, 1291, 0, 0, 13323, 13319, 1, 0, 0, 0, 13323, 13321, 1, 0, 0, + 0, 13324, 13360, 1, 0, 0, 0, 13325, 13326, 5, 1460, 0, 0, 13326, 13327, + 5, 534, 0, 0, 13327, 13332, 3, 1472, 736, 0, 13328, 13329, 5, 2382, 0, + 0, 13329, 13331, 3, 1472, 736, 0, 13330, 13328, 1, 0, 0, 0, 13331, 13334, + 1, 0, 0, 0, 13332, 13330, 1, 0, 0, 0, 13332, 13333, 1, 0, 0, 0, 13333, + 13335, 1, 0, 0, 0, 13334, 13332, 1, 0, 0, 0, 13335, 13336, 5, 2029, 0, + 0, 13336, 13337, 3, 1472, 736, 0, 13337, 13360, 1, 0, 0, 0, 13338, 13340, + 5, 198, 0, 0, 13339, 13341, 5, 2059, 0, 0, 13340, 13339, 1, 0, 0, 0, 13340, + 13341, 1, 0, 0, 0, 13341, 13342, 1, 0, 0, 0, 13342, 13343, 5, 813, 0, 0, + 13343, 13348, 3, 1434, 717, 0, 13344, 13345, 5, 2382, 0, 0, 13345, 13347, + 3, 1434, 717, 0, 13346, 13344, 1, 0, 0, 0, 13347, 13350, 1, 0, 0, 0, 13348, + 13346, 1, 0, 0, 0, 13348, 13349, 1, 0, 0, 0, 13349, 13353, 1, 0, 0, 0, + 13350, 13348, 1, 0, 0, 0, 13351, 13352, 5, 2083, 0, 0, 13352, 13354, 5, + 331, 0, 0, 13353, 13351, 1, 0, 0, 0, 13353, 13354, 1, 0, 0, 0, 13354, 13360, + 1, 0, 0, 0, 13355, 13360, 3, 1420, 710, 0, 13356, 13360, 3, 1424, 712, + 0, 13357, 13360, 3, 1426, 713, 0, 13358, 13360, 3, 1428, 714, 0, 13359, + 13308, 1, 0, 0, 0, 13359, 13311, 1, 0, 0, 0, 13359, 13315, 1, 0, 0, 0, + 13359, 13325, 1, 0, 0, 0, 13359, 13338, 1, 0, 0, 0, 13359, 13355, 1, 0, + 0, 0, 13359, 13356, 1, 0, 0, 0, 13359, 13357, 1, 0, 0, 0, 13359, 13358, + 1, 0, 0, 0, 13360, 1419, 1, 0, 0, 0, 13361, 13363, 5, 20, 0, 0, 13362, + 13364, 5, 1628, 0, 0, 13363, 13362, 1, 0, 0, 0, 13363, 13364, 1, 0, 0, + 0, 13364, 13365, 1, 0, 0, 0, 13365, 13401, 5, 813, 0, 0, 13366, 13367, + 5, 700, 0, 0, 13367, 13371, 5, 2372, 0, 0, 13368, 13369, 5, 1991, 0, 0, + 13369, 13371, 5, 2370, 0, 0, 13370, 13366, 1, 0, 0, 0, 13370, 13368, 1, + 0, 0, 0, 13370, 13371, 1, 0, 0, 0, 13371, 13373, 1, 0, 0, 0, 13372, 13374, + 3, 1422, 711, 0, 13373, 13372, 1, 0, 0, 0, 13374, 13375, 1, 0, 0, 0, 13375, + 13373, 1, 0, 0, 0, 13375, 13376, 1, 0, 0, 0, 13376, 13402, 1, 0, 0, 0, + 13377, 13378, 5, 865, 0, 0, 13378, 13380, 3, 1472, 736, 0, 13379, 13381, + 5, 1488, 0, 0, 13380, 13379, 1, 0, 0, 0, 13380, 13381, 1, 0, 0, 0, 13381, + 13389, 1, 0, 0, 0, 13382, 13383, 5, 2382, 0, 0, 13383, 13385, 3, 1472, + 736, 0, 13384, 13386, 5, 1488, 0, 0, 13385, 13384, 1, 0, 0, 0, 13385, 13386, + 1, 0, 0, 0, 13386, 13388, 1, 0, 0, 0, 13387, 13382, 1, 0, 0, 0, 13388, + 13391, 1, 0, 0, 0, 13389, 13387, 1, 0, 0, 0, 13389, 13390, 1, 0, 0, 0, + 13390, 13392, 1, 0, 0, 0, 13391, 13389, 1, 0, 0, 0, 13392, 13393, 5, 2029, + 0, 0, 13393, 13398, 3, 1434, 717, 0, 13394, 13395, 5, 2382, 0, 0, 13395, + 13397, 3, 1434, 717, 0, 13396, 13394, 1, 0, 0, 0, 13397, 13400, 1, 0, 0, + 0, 13398, 13396, 1, 0, 0, 0, 13398, 13399, 1, 0, 0, 0, 13399, 13402, 1, + 0, 0, 0, 13400, 13398, 1, 0, 0, 0, 13401, 13370, 1, 0, 0, 0, 13401, 13377, + 1, 0, 0, 0, 13402, 1421, 1, 0, 0, 0, 13403, 13404, 5, 593, 0, 0, 13404, + 13406, 5, 2370, 0, 0, 13405, 13403, 1, 0, 0, 0, 13405, 13406, 1, 0, 0, + 0, 13406, 13407, 1, 0, 0, 0, 13407, 13408, 3, 916, 458, 0, 13408, 1423, + 1, 0, 0, 0, 13409, 13411, 5, 425, 0, 0, 13410, 13412, 5, 1628, 0, 0, 13411, + 13410, 1, 0, 0, 0, 13411, 13412, 1, 0, 0, 0, 13412, 13413, 1, 0, 0, 0, + 13413, 13431, 5, 813, 0, 0, 13414, 13419, 3, 1434, 717, 0, 13415, 13416, + 5, 2382, 0, 0, 13416, 13418, 3, 1434, 717, 0, 13417, 13415, 1, 0, 0, 0, + 13418, 13421, 1, 0, 0, 0, 13419, 13417, 1, 0, 0, 0, 13419, 13420, 1, 0, + 0, 0, 13420, 13432, 1, 0, 0, 0, 13421, 13419, 1, 0, 0, 0, 13422, 13423, + 5, 865, 0, 0, 13423, 13428, 3, 1472, 736, 0, 13424, 13425, 5, 2382, 0, + 0, 13425, 13427, 3, 1472, 736, 0, 13426, 13424, 1, 0, 0, 0, 13427, 13430, + 1, 0, 0, 0, 13428, 13426, 1, 0, 0, 0, 13428, 13429, 1, 0, 0, 0, 13429, + 13432, 1, 0, 0, 0, 13430, 13428, 1, 0, 0, 0, 13431, 13414, 1, 0, 0, 0, + 13431, 13422, 1, 0, 0, 0, 13432, 1425, 1, 0, 0, 0, 13433, 13434, 5, 1686, + 0, 0, 13434, 13435, 5, 37, 0, 0, 13435, 13436, 5, 814, 0, 0, 13436, 13437, + 5, 2029, 0, 0, 13437, 13438, 5, 137, 0, 0, 13438, 13439, 5, 2370, 0, 0, + 13439, 1427, 1, 0, 0, 0, 13440, 13441, 3, 1430, 715, 0, 13441, 13442, 5, + 1682, 0, 0, 13442, 13446, 5, 819, 0, 0, 13443, 13447, 5, 330, 0, 0, 13444, + 13447, 3, 1296, 648, 0, 13445, 13447, 3, 1432, 716, 0, 13446, 13443, 1, + 0, 0, 0, 13446, 13444, 1, 0, 0, 0, 13446, 13445, 1, 0, 0, 0, 13447, 1429, + 1, 0, 0, 0, 13448, 13449, 7, 9, 0, 0, 13449, 1431, 1, 0, 0, 0, 13450, 13451, + 5, 330, 0, 0, 13451, 13452, 5, 564, 0, 0, 13452, 13453, 5, 1364, 0, 0, + 13453, 13454, 5, 1464, 0, 0, 13454, 1433, 1, 0, 0, 0, 13455, 13456, 5, + 593, 0, 0, 13456, 13470, 5, 2370, 0, 0, 13457, 13458, 5, 2376, 0, 0, 13458, + 13463, 3, 1472, 736, 0, 13459, 13460, 5, 2382, 0, 0, 13460, 13462, 3, 1472, + 736, 0, 13461, 13459, 1, 0, 0, 0, 13462, 13465, 1, 0, 0, 0, 13463, 13461, + 1, 0, 0, 0, 13463, 13464, 1, 0, 0, 0, 13464, 13466, 1, 0, 0, 0, 13465, + 13463, 1, 0, 0, 0, 13466, 13467, 5, 2377, 0, 0, 13467, 13470, 1, 0, 0, + 0, 13468, 13470, 3, 1472, 736, 0, 13469, 13455, 1, 0, 0, 0, 13469, 13457, + 1, 0, 0, 0, 13469, 13468, 1, 0, 0, 0, 13470, 1435, 1, 0, 0, 0, 13471, 13473, + 5, 301, 0, 0, 13472, 13474, 7, 156, 0, 0, 13473, 13472, 1, 0, 0, 0, 13473, + 13474, 1, 0, 0, 0, 13474, 13475, 1, 0, 0, 0, 13475, 13476, 5, 1628, 0, + 0, 13476, 13477, 5, 279, 0, 0, 13477, 13478, 5, 66, 0, 0, 13478, 13480, + 3, 1472, 736, 0, 13479, 13481, 5, 1488, 0, 0, 13480, 13479, 1, 0, 0, 0, + 13480, 13481, 1, 0, 0, 0, 13481, 13493, 1, 0, 0, 0, 13482, 13483, 5, 98, + 0, 0, 13483, 13484, 5, 279, 0, 0, 13484, 13490, 5, 2029, 0, 0, 13485, 13487, + 3, 1472, 736, 0, 13486, 13488, 5, 1488, 0, 0, 13487, 13486, 1, 0, 0, 0, + 13487, 13488, 1, 0, 0, 0, 13488, 13491, 1, 0, 0, 0, 13489, 13491, 3, 1438, + 719, 0, 13490, 13485, 1, 0, 0, 0, 13490, 13489, 1, 0, 0, 0, 13491, 13493, + 1, 0, 0, 0, 13492, 13471, 1, 0, 0, 0, 13492, 13482, 1, 0, 0, 0, 13493, + 1437, 1, 0, 0, 0, 13494, 13500, 5, 2031, 0, 0, 13495, 13496, 5, 66, 0, + 0, 13496, 13498, 3, 1472, 736, 0, 13497, 13499, 5, 1488, 0, 0, 13498, 13497, + 1, 0, 0, 0, 13498, 13499, 1, 0, 0, 0, 13499, 13501, 1, 0, 0, 0, 13500, + 13495, 1, 0, 0, 0, 13500, 13501, 1, 0, 0, 0, 13501, 13503, 1, 0, 0, 0, + 13502, 13504, 7, 56, 0, 0, 13503, 13502, 1, 0, 0, 0, 13503, 13504, 1, 0, + 0, 0, 13504, 1439, 1, 0, 0, 0, 13505, 13513, 3, 1442, 721, 0, 13506, 13513, + 3, 1444, 722, 0, 13507, 13513, 3, 1446, 723, 0, 13508, 13513, 3, 1448, + 724, 0, 13509, 13513, 3, 1450, 725, 0, 13510, 13513, 3, 1452, 726, 0, 13511, + 13513, 3, 1454, 727, 0, 13512, 13505, 1, 0, 0, 0, 13512, 13506, 1, 0, 0, + 0, 13512, 13507, 1, 0, 0, 0, 13512, 13508, 1, 0, 0, 0, 13512, 13509, 1, + 0, 0, 0, 13512, 13510, 1, 0, 0, 0, 13512, 13511, 1, 0, 0, 0, 13513, 13515, + 1, 0, 0, 0, 13514, 13516, 3, 926, 463, 0, 13515, 13514, 1, 0, 0, 0, 13515, + 13516, 1, 0, 0, 0, 13516, 1441, 1, 0, 0, 0, 13517, 13519, 5, 12, 0, 0, + 13518, 13520, 7, 156, 0, 0, 13519, 13518, 1, 0, 0, 0, 13519, 13520, 1, + 0, 0, 0, 13520, 13521, 1, 0, 0, 0, 13521, 13522, 5, 1628, 0, 0, 13522, + 13525, 5, 329, 0, 0, 13523, 13524, 5, 542, 0, 0, 13524, 13526, 5, 59, 0, + 0, 13525, 13523, 1, 0, 0, 0, 13525, 13526, 1, 0, 0, 0, 13526, 1443, 1, + 0, 0, 0, 13527, 13528, 5, 1568, 0, 0, 13528, 13529, 5, 1628, 0, 0, 13529, + 13530, 5, 329, 0, 0, 13530, 13531, 5, 2029, 0, 0, 13531, 13532, 5, 853, + 0, 0, 13532, 13533, 7, 157, 0, 0, 13533, 1445, 1, 0, 0, 0, 13534, 13537, + 5, 1439, 0, 0, 13535, 13536, 5, 1219, 0, 0, 13536, 13538, 5, 1463, 0, 0, + 13537, 13535, 1, 0, 0, 0, 13537, 13538, 1, 0, 0, 0, 13538, 13539, 1, 0, + 0, 0, 13539, 13540, 7, 156, 0, 0, 13540, 13541, 5, 813, 0, 0, 13541, 1447, + 1, 0, 0, 0, 13542, 13543, 7, 158, 0, 0, 13543, 13544, 5, 2029, 0, 0, 13544, + 13573, 5, 1685, 0, 0, 13545, 13566, 5, 2029, 0, 0, 13546, 13548, 7, 156, + 0, 0, 13547, 13546, 1, 0, 0, 0, 13547, 13548, 1, 0, 0, 0, 13548, 13549, + 1, 0, 0, 0, 13549, 13555, 5, 1355, 0, 0, 13550, 13552, 5, 1298, 0, 0, 13551, + 13550, 1, 0, 0, 0, 13551, 13552, 1, 0, 0, 0, 13552, 13553, 1, 0, 0, 0, + 13553, 13555, 5, 1628, 0, 0, 13554, 13547, 1, 0, 0, 0, 13554, 13551, 1, + 0, 0, 0, 13555, 13562, 1, 0, 0, 0, 13556, 13558, 7, 2, 0, 0, 13557, 13556, + 1, 0, 0, 0, 13557, 13558, 1, 0, 0, 0, 13558, 13559, 1, 0, 0, 0, 13559, + 13560, 5, 1564, 0, 0, 13560, 13561, 5, 1581, 0, 0, 13561, 13563, 7, 0, + 0, 0, 13562, 13557, 1, 0, 0, 0, 13562, 13563, 1, 0, 0, 0, 13563, 13567, + 1, 0, 0, 0, 13564, 13565, 5, 816, 0, 0, 13565, 13567, 5, 1628, 0, 0, 13566, + 13554, 1, 0, 0, 0, 13566, 13564, 1, 0, 0, 0, 13567, 13571, 1, 0, 0, 0, + 13568, 13569, 5, 816, 0, 0, 13569, 13571, 5, 1628, 0, 0, 13570, 13545, + 1, 0, 0, 0, 13570, 13568, 1, 0, 0, 0, 13571, 13574, 1, 0, 0, 0, 13572, + 13574, 5, 163, 0, 0, 13573, 13570, 1, 0, 0, 0, 13573, 13572, 1, 0, 0, 0, + 13573, 13574, 1, 0, 0, 0, 13574, 1449, 1, 0, 0, 0, 13575, 13576, 5, 1631, + 0, 0, 13576, 13577, 5, 816, 0, 0, 13577, 13578, 5, 1628, 0, 0, 13578, 13580, + 5, 59, 0, 0, 13579, 13581, 5, 640, 0, 0, 13580, 13579, 1, 0, 0, 0, 13580, + 13581, 1, 0, 0, 0, 13581, 13583, 1, 0, 0, 0, 13582, 13584, 5, 1013, 0, + 0, 13583, 13582, 1, 0, 0, 0, 13583, 13584, 1, 0, 0, 0, 13584, 13596, 1, + 0, 0, 0, 13585, 13586, 5, 950, 0, 0, 13586, 13587, 5, 1355, 0, 0, 13587, + 13597, 3, 2382, 1191, 0, 13588, 13590, 5, 682, 0, 0, 13589, 13591, 5, 2370, + 0, 0, 13590, 13589, 1, 0, 0, 0, 13590, 13591, 1, 0, 0, 0, 13591, 13597, + 1, 0, 0, 0, 13592, 13593, 5, 1597, 0, 0, 13593, 13594, 5, 517, 0, 0, 13594, + 13597, 5, 2035, 0, 0, 13595, 13597, 5, 542, 0, 0, 13596, 13585, 1, 0, 0, + 0, 13596, 13588, 1, 0, 0, 0, 13596, 13592, 1, 0, 0, 0, 13596, 13595, 1, + 0, 0, 0, 13596, 13597, 1, 0, 0, 0, 13597, 1451, 1, 0, 0, 0, 13598, 13599, + 7, 159, 0, 0, 13599, 13600, 5, 816, 0, 0, 13600, 13601, 5, 1628, 0, 0, + 13601, 13602, 5, 59, 0, 0, 13602, 1453, 1, 0, 0, 0, 13603, 13604, 5, 281, + 0, 0, 13604, 13605, 5, 2029, 0, 0, 13605, 13606, 7, 160, 0, 0, 13606, 13607, + 5, 1628, 0, 0, 13607, 1455, 1, 0, 0, 0, 13608, 13609, 5, 363, 0, 0, 13609, + 13610, 5, 438, 0, 0, 13610, 13611, 5, 2398, 0, 0, 13611, 13655, 3, 1468, + 734, 0, 13612, 13613, 5, 1568, 0, 0, 13613, 13614, 5, 363, 0, 0, 13614, + 13615, 7, 93, 0, 0, 13615, 13655, 5, 1973, 0, 0, 13616, 13617, 5, 363, + 0, 0, 13617, 13618, 5, 1973, 0, 0, 13618, 13655, 3, 1666, 833, 0, 13619, + 13620, 5, 363, 0, 0, 13620, 13621, 5, 1984, 0, 0, 13621, 13624, 5, 1973, + 0, 0, 13622, 13625, 3, 1666, 833, 0, 13623, 13625, 3, 868, 434, 0, 13624, + 13622, 1, 0, 0, 0, 13624, 13623, 1, 0, 0, 0, 13625, 13655, 1, 0, 0, 0, + 13626, 13627, 5, 1460, 0, 0, 13627, 13628, 5, 588, 0, 0, 13628, 13629, + 5, 2029, 0, 0, 13629, 13632, 3, 1466, 733, 0, 13630, 13631, 5, 2369, 0, + 0, 13631, 13633, 3, 1464, 732, 0, 13632, 13630, 1, 0, 0, 0, 13633, 13634, + 1, 0, 0, 0, 13634, 13632, 1, 0, 0, 0, 13634, 13635, 1, 0, 0, 0, 13635, + 13655, 1, 0, 0, 0, 13636, 13637, 5, 453, 0, 0, 13637, 13638, 5, 134, 0, + 0, 13638, 13639, 5, 179, 0, 0, 13639, 13646, 5, 2033, 0, 0, 13640, 13641, + 5, 2129, 0, 0, 13641, 13642, 5, 534, 0, 0, 13642, 13644, 3, 1472, 736, + 0, 13643, 13645, 5, 1488, 0, 0, 13644, 13643, 1, 0, 0, 0, 13644, 13645, + 1, 0, 0, 0, 13645, 13647, 1, 0, 0, 0, 13646, 13640, 1, 0, 0, 0, 13646, + 13647, 1, 0, 0, 0, 13647, 13655, 1, 0, 0, 0, 13648, 13649, 5, 398, 0, 0, + 13649, 13650, 5, 134, 0, 0, 13650, 13651, 5, 179, 0, 0, 13651, 13655, 5, + 2033, 0, 0, 13652, 13655, 3, 872, 436, 0, 13653, 13655, 3, 1458, 729, 0, + 13654, 13608, 1, 0, 0, 0, 13654, 13612, 1, 0, 0, 0, 13654, 13616, 1, 0, + 0, 0, 13654, 13619, 1, 0, 0, 0, 13654, 13626, 1, 0, 0, 0, 13654, 13636, + 1, 0, 0, 0, 13654, 13648, 1, 0, 0, 0, 13654, 13652, 1, 0, 0, 0, 13654, + 13653, 1, 0, 0, 0, 13655, 1457, 1, 0, 0, 0, 13656, 13657, 5, 1568, 0, 0, + 13657, 13658, 5, 2002, 0, 0, 13658, 13659, 5, 2398, 0, 0, 13659, 13660, + 5, 2372, 0, 0, 13660, 1459, 1, 0, 0, 0, 13661, 13662, 3, 1322, 661, 0, + 13662, 13663, 5, 700, 0, 0, 13663, 13664, 5, 2372, 0, 0, 13664, 1461, 1, + 0, 0, 0, 13665, 13666, 5, 600, 0, 0, 13666, 13667, 7, 161, 0, 0, 13667, + 1463, 1, 0, 0, 0, 13668, 13669, 3, 2382, 1191, 0, 13669, 1465, 1, 0, 0, + 0, 13670, 13671, 3, 2382, 1191, 0, 13671, 1467, 1, 0, 0, 0, 13672, 13673, + 3, 2382, 1191, 0, 13673, 1469, 1, 0, 0, 0, 13674, 13675, 5, 2370, 0, 0, + 13675, 1471, 1, 0, 0, 0, 13676, 13677, 5, 2372, 0, 0, 13677, 1473, 1, 0, + 0, 0, 13678, 13679, 5, 1346, 0, 0, 13679, 13680, 5, 892, 0, 0, 13680, 13681, + 5, 284, 0, 0, 13681, 13685, 3, 2378, 1189, 0, 13682, 13683, 5, 2188, 0, + 0, 13683, 13684, 7, 162, 0, 0, 13684, 13686, 5, 1425, 0, 0, 13685, 13682, + 1, 0, 0, 0, 13685, 13686, 1, 0, 0, 0, 13686, 13690, 1, 0, 0, 0, 13687, + 13688, 5, 564, 0, 0, 13688, 13689, 5, 329, 0, 0, 13689, 13691, 3, 2378, + 1189, 0, 13690, 13687, 1, 0, 0, 0, 13690, 13691, 1, 0, 0, 0, 13691, 1475, + 1, 0, 0, 0, 13692, 13693, 5, 425, 0, 0, 13693, 13694, 5, 892, 0, 0, 13694, + 13695, 5, 284, 0, 0, 13695, 13696, 3, 2378, 1189, 0, 13696, 1477, 1, 0, + 0, 0, 13697, 13698, 7, 163, 0, 0, 13698, 13699, 5, 826, 0, 0, 13699, 13700, + 5, 2192, 0, 0, 13700, 13701, 5, 1373, 0, 0, 13701, 1479, 1, 0, 0, 0, 13702, + 13705, 3, 1482, 741, 0, 13703, 13705, 3, 1484, 742, 0, 13704, 13702, 1, + 0, 0, 0, 13704, 13703, 1, 0, 0, 0, 13705, 1481, 1, 0, 0, 0, 13706, 13707, + 5, 1568, 0, 0, 13707, 13708, 5, 771, 0, 0, 13708, 13709, 5, 2398, 0, 0, + 13709, 13710, 7, 164, 0, 0, 13710, 1483, 1, 0, 0, 0, 13711, 13712, 5, 1568, + 0, 0, 13712, 13713, 5, 772, 0, 0, 13713, 13714, 5, 2398, 0, 0, 13714, 13715, + 5, 2372, 0, 0, 13715, 1485, 1, 0, 0, 0, 13716, 13717, 5, 1371, 0, 0, 13717, + 13718, 7, 165, 0, 0, 13718, 13719, 5, 366, 0, 0, 13719, 13720, 5, 2398, + 0, 0, 13720, 13721, 3, 2378, 1189, 0, 13721, 1487, 1, 0, 0, 0, 13722, 13723, + 5, 2095, 0, 0, 13723, 13724, 5, 1688, 0, 0, 13724, 13725, 7, 92, 0, 0, + 13725, 1489, 1, 0, 0, 0, 13726, 13728, 5, 41, 0, 0, 13727, 13729, 5, 1575, + 0, 0, 13728, 13727, 1, 0, 0, 0, 13728, 13729, 1, 0, 0, 0, 13729, 13731, + 1, 0, 0, 0, 13730, 13732, 5, 1377, 0, 0, 13731, 13730, 1, 0, 0, 0, 13731, + 13732, 1, 0, 0, 0, 13732, 13733, 1, 0, 0, 0, 13733, 13734, 5, 329, 0, 0, + 13734, 13735, 5, 795, 0, 0, 13735, 13746, 3, 2308, 1154, 0, 13736, 13737, + 5, 261, 0, 0, 13737, 13738, 5, 2029, 0, 0, 13738, 13739, 3, 2324, 1162, + 0, 13739, 13740, 5, 628, 0, 0, 13740, 13741, 5, 151, 0, 0, 13741, 13743, + 3, 1492, 746, 0, 13742, 13744, 3, 1494, 747, 0, 13743, 13742, 1, 0, 0, + 0, 13743, 13744, 1, 0, 0, 0, 13744, 13747, 1, 0, 0, 0, 13745, 13747, 3, + 1494, 747, 0, 13746, 13736, 1, 0, 0, 0, 13746, 13745, 1, 0, 0, 0, 13747, + 1491, 1, 0, 0, 0, 13748, 13751, 3, 2378, 1189, 0, 13749, 13751, 3, 2368, + 1184, 0, 13750, 13748, 1, 0, 0, 0, 13750, 13749, 1, 0, 0, 0, 13751, 1493, + 1, 0, 0, 0, 13752, 13753, 5, 83, 0, 0, 13753, 13754, 5, 151, 0, 0, 13754, + 13755, 3, 2324, 1162, 0, 13755, 13756, 5, 628, 0, 0, 13756, 13757, 5, 151, + 0, 0, 13757, 13758, 3, 1492, 746, 0, 13758, 1495, 1, 0, 0, 0, 13759, 13760, + 5, 301, 0, 0, 13760, 13761, 5, 329, 0, 0, 13761, 13800, 3, 1380, 690, 0, + 13762, 13763, 5, 2121, 0, 0, 13763, 13764, 7, 166, 0, 0, 13764, 13765, + 5, 628, 0, 0, 13765, 13766, 5, 151, 0, 0, 13766, 13801, 3, 1492, 746, 0, + 13767, 13768, 5, 279, 0, 0, 13768, 13801, 5, 1488, 0, 0, 13769, 13770, + 7, 167, 0, 0, 13770, 13801, 5, 2370, 0, 0, 13771, 13773, 5, 930, 0, 0, + 13772, 13771, 1, 0, 0, 0, 13772, 13773, 1, 0, 0, 0, 13773, 13774, 1, 0, + 0, 0, 13774, 13775, 5, 181, 0, 0, 13775, 13776, 5, 1568, 0, 0, 13776, 13801, + 3, 2316, 1158, 0, 13777, 13778, 5, 1568, 0, 0, 13778, 13779, 5, 363, 0, + 0, 13779, 13780, 7, 93, 0, 0, 13780, 13801, 5, 1973, 0, 0, 13781, 13801, + 3, 1498, 749, 0, 13782, 13801, 3, 1502, 751, 0, 13783, 13801, 3, 1458, + 729, 0, 13784, 13786, 7, 93, 0, 0, 13785, 13784, 1, 0, 0, 0, 13785, 13786, + 1, 0, 0, 0, 13786, 13787, 1, 0, 0, 0, 13787, 13788, 5, 2114, 0, 0, 13788, + 13789, 5, 1973, 0, 0, 13789, 13790, 3, 868, 434, 0, 13790, 13791, 5, 331, + 0, 0, 13791, 13796, 3, 914, 457, 0, 13792, 13793, 5, 2382, 0, 0, 13793, + 13795, 3, 914, 457, 0, 13794, 13792, 1, 0, 0, 0, 13795, 13798, 1, 0, 0, + 0, 13796, 13794, 1, 0, 0, 0, 13796, 13797, 1, 0, 0, 0, 13797, 13801, 1, + 0, 0, 0, 13798, 13796, 1, 0, 0, 0, 13799, 13801, 3, 1504, 752, 0, 13800, + 13762, 1, 0, 0, 0, 13800, 13767, 1, 0, 0, 0, 13800, 13769, 1, 0, 0, 0, + 13800, 13772, 1, 0, 0, 0, 13800, 13777, 1, 0, 0, 0, 13800, 13781, 1, 0, + 0, 0, 13800, 13782, 1, 0, 0, 0, 13800, 13783, 1, 0, 0, 0, 13800, 13785, + 1, 0, 0, 0, 13800, 13799, 1, 0, 0, 0, 13801, 13802, 1, 0, 0, 0, 13802, + 13800, 1, 0, 0, 0, 13802, 13803, 1, 0, 0, 0, 13803, 1497, 1, 0, 0, 0, 13804, + 13805, 5, 813, 0, 0, 13805, 13810, 3, 1500, 750, 0, 13806, 13807, 5, 2382, + 0, 0, 13807, 13809, 3, 1500, 750, 0, 13808, 13806, 1, 0, 0, 0, 13809, 13812, + 1, 0, 0, 0, 13810, 13808, 1, 0, 0, 0, 13810, 13811, 1, 0, 0, 0, 13811, + 13820, 1, 0, 0, 0, 13812, 13810, 1, 0, 0, 0, 13813, 13814, 7, 168, 0, 0, + 13814, 13820, 5, 2370, 0, 0, 13815, 13820, 5, 64, 0, 0, 13816, 13820, 5, + 986, 0, 0, 13817, 13818, 5, 560, 0, 0, 13818, 13820, 5, 815, 0, 0, 13819, + 13804, 1, 0, 0, 0, 13819, 13813, 1, 0, 0, 0, 13819, 13815, 1, 0, 0, 0, + 13819, 13816, 1, 0, 0, 0, 13819, 13817, 1, 0, 0, 0, 13820, 1499, 1, 0, + 0, 0, 13821, 13822, 5, 593, 0, 0, 13822, 13824, 5, 2370, 0, 0, 13823, 13821, + 1, 0, 0, 0, 13823, 13824, 1, 0, 0, 0, 13824, 13825, 1, 0, 0, 0, 13825, + 13826, 3, 432, 216, 0, 13826, 1501, 1, 0, 0, 0, 13827, 13828, 5, 505, 0, + 0, 13828, 13829, 5, 836, 0, 0, 13829, 13846, 5, 804, 0, 0, 13830, 13832, + 5, 1693, 0, 0, 13831, 13830, 1, 0, 0, 0, 13831, 13832, 1, 0, 0, 0, 13832, + 13833, 1, 0, 0, 0, 13833, 13834, 5, 331, 0, 0, 13834, 13839, 3, 432, 216, + 0, 13835, 13836, 5, 2382, 0, 0, 13836, 13838, 3, 432, 216, 0, 13837, 13835, + 1, 0, 0, 0, 13838, 13841, 1, 0, 0, 0, 13839, 13837, 1, 0, 0, 0, 13839, + 13840, 1, 0, 0, 0, 13840, 13846, 1, 0, 0, 0, 13841, 13839, 1, 0, 0, 0, + 13842, 13846, 3, 1514, 757, 0, 13843, 13846, 3, 1516, 758, 0, 13844, 13846, + 3, 1518, 759, 0, 13845, 13827, 1, 0, 0, 0, 13845, 13831, 1, 0, 0, 0, 13845, + 13842, 1, 0, 0, 0, 13845, 13843, 1, 0, 0, 0, 13845, 13844, 1, 0, 0, 0, + 13846, 1503, 1, 0, 0, 0, 13847, 13848, 5, 453, 0, 0, 13848, 13849, 5, 1315, + 0, 0, 13849, 13862, 5, 329, 0, 0, 13850, 13852, 5, 1543, 0, 0, 13851, 13853, + 3, 1506, 753, 0, 13852, 13851, 1, 0, 0, 0, 13852, 13853, 1, 0, 0, 0, 13853, + 13856, 1, 0, 0, 0, 13854, 13855, 5, 1842, 0, 0, 13855, 13857, 3, 1510, + 755, 0, 13856, 13854, 1, 0, 0, 0, 13856, 13857, 1, 0, 0, 0, 13857, 13860, + 1, 0, 0, 0, 13858, 13859, 5, 1693, 0, 0, 13859, 13861, 3, 1510, 755, 0, + 13860, 13858, 1, 0, 0, 0, 13860, 13861, 1, 0, 0, 0, 13861, 13863, 1, 0, + 0, 0, 13862, 13850, 1, 0, 0, 0, 13862, 13863, 1, 0, 0, 0, 13863, 13865, + 1, 0, 0, 0, 13864, 13866, 3, 1512, 756, 0, 13865, 13864, 1, 0, 0, 0, 13865, + 13866, 1, 0, 0, 0, 13866, 1505, 1, 0, 0, 0, 13867, 13868, 5, 535, 0, 0, + 13868, 13881, 5, 2398, 0, 0, 13869, 13870, 5, 2376, 0, 0, 13870, 13875, + 3, 1508, 754, 0, 13871, 13872, 5, 2382, 0, 0, 13872, 13874, 3, 1508, 754, + 0, 13873, 13871, 1, 0, 0, 0, 13874, 13877, 1, 0, 0, 0, 13875, 13873, 1, + 0, 0, 0, 13875, 13876, 1, 0, 0, 0, 13876, 13878, 1, 0, 0, 0, 13877, 13875, + 1, 0, 0, 0, 13878, 13879, 5, 2377, 0, 0, 13879, 13882, 1, 0, 0, 0, 13880, + 13882, 5, 1054, 0, 0, 13881, 13869, 1, 0, 0, 0, 13881, 13880, 1, 0, 0, + 0, 13882, 1507, 1, 0, 0, 0, 13883, 13886, 5, 2372, 0, 0, 13884, 13885, + 5, 2382, 0, 0, 13885, 13887, 5, 2372, 0, 0, 13886, 13884, 1, 0, 0, 0, 13886, + 13887, 1, 0, 0, 0, 13887, 1509, 1, 0, 0, 0, 13888, 13892, 5, 332, 0, 0, + 13889, 13890, 5, 1595, 0, 0, 13890, 13893, 3, 1170, 585, 0, 13891, 13893, + 3, 918, 459, 0, 13892, 13889, 1, 0, 0, 0, 13892, 13891, 1, 0, 0, 0, 13893, + 13894, 1, 0, 0, 0, 13894, 13892, 1, 0, 0, 0, 13894, 13895, 1, 0, 0, 0, + 13895, 1511, 1, 0, 0, 0, 13896, 13897, 5, 804, 0, 0, 13897, 13898, 5, 2064, + 0, 0, 13898, 13899, 7, 92, 0, 0, 13899, 1513, 1, 0, 0, 0, 13900, 13901, + 5, 363, 0, 0, 13901, 13902, 5, 1973, 0, 0, 13902, 13905, 3, 1666, 833, + 0, 13903, 13904, 5, 331, 0, 0, 13904, 13906, 3, 914, 457, 0, 13905, 13903, + 1, 0, 0, 0, 13905, 13906, 1, 0, 0, 0, 13906, 13908, 1, 0, 0, 0, 13907, + 13909, 3, 884, 442, 0, 13908, 13907, 1, 0, 0, 0, 13908, 13909, 1, 0, 0, + 0, 13909, 1515, 1, 0, 0, 0, 13910, 13912, 7, 93, 0, 0, 13911, 13910, 1, + 0, 0, 0, 13911, 13912, 1, 0, 0, 0, 13912, 13913, 1, 0, 0, 0, 13913, 13921, + 5, 363, 0, 0, 13914, 13915, 5, 1984, 0, 0, 13915, 13922, 5, 1973, 0, 0, + 13916, 13917, 5, 804, 0, 0, 13917, 13918, 5, 1984, 0, 0, 13918, 13919, + 5, 1973, 0, 0, 13919, 13920, 5, 564, 0, 0, 13920, 13922, 7, 169, 0, 0, + 13921, 13914, 1, 0, 0, 0, 13921, 13916, 1, 0, 0, 0, 13922, 13923, 1, 0, + 0, 0, 13923, 13933, 3, 1666, 833, 0, 13924, 13925, 5, 1982, 0, 0, 13925, + 13930, 3, 432, 216, 0, 13926, 13927, 5, 2382, 0, 0, 13927, 13929, 3, 432, + 216, 0, 13928, 13926, 1, 0, 0, 0, 13929, 13932, 1, 0, 0, 0, 13930, 13928, + 1, 0, 0, 0, 13930, 13931, 1, 0, 0, 0, 13931, 13934, 1, 0, 0, 0, 13932, + 13930, 1, 0, 0, 0, 13933, 13924, 1, 0, 0, 0, 13933, 13934, 1, 0, 0, 0, + 13934, 13936, 1, 0, 0, 0, 13935, 13937, 3, 884, 442, 0, 13936, 13935, 1, + 0, 0, 0, 13936, 13937, 1, 0, 0, 0, 13937, 1517, 1, 0, 0, 0, 13938, 13940, + 7, 93, 0, 0, 13939, 13938, 1, 0, 0, 0, 13939, 13940, 1, 0, 0, 0, 13940, + 13941, 1, 0, 0, 0, 13941, 13942, 5, 2064, 0, 0, 13942, 13943, 5, 1973, + 0, 0, 13943, 13953, 3, 1666, 833, 0, 13944, 13945, 5, 331, 0, 0, 13945, + 13950, 3, 432, 216, 0, 13946, 13947, 5, 2382, 0, 0, 13947, 13949, 3, 432, + 216, 0, 13948, 13946, 1, 0, 0, 0, 13949, 13952, 1, 0, 0, 0, 13950, 13948, + 1, 0, 0, 0, 13950, 13951, 1, 0, 0, 0, 13951, 13954, 1, 0, 0, 0, 13952, + 13950, 1, 0, 0, 0, 13953, 13944, 1, 0, 0, 0, 13953, 13954, 1, 0, 0, 0, + 13954, 1519, 1, 0, 0, 0, 13955, 13956, 5, 425, 0, 0, 13956, 13959, 5, 329, + 0, 0, 13957, 13958, 5, 647, 0, 0, 13958, 13960, 5, 99, 0, 0, 13959, 13957, + 1, 0, 0, 0, 13959, 13960, 1, 0, 0, 0, 13960, 13962, 1, 0, 0, 0, 13961, + 13963, 5, 1077, 0, 0, 13962, 13961, 1, 0, 0, 0, 13962, 13963, 1, 0, 0, + 0, 13963, 1521, 1, 0, 0, 0, 13964, 13966, 5, 301, 0, 0, 13965, 13967, 5, + 1575, 0, 0, 13966, 13965, 1, 0, 0, 0, 13966, 13967, 1, 0, 0, 0, 13967, + 13969, 1, 0, 0, 0, 13968, 13970, 5, 1377, 0, 0, 13969, 13968, 1, 0, 0, + 0, 13969, 13970, 1, 0, 0, 0, 13970, 13971, 1, 0, 0, 0, 13971, 13972, 5, + 329, 0, 0, 13972, 13973, 5, 795, 0, 0, 13973, 13989, 3, 1524, 762, 0, 13974, + 13975, 5, 261, 0, 0, 13975, 13984, 5, 2029, 0, 0, 13976, 13985, 5, 320, + 0, 0, 13977, 13978, 3, 2324, 1162, 0, 13978, 13979, 5, 628, 0, 0, 13979, + 13980, 5, 151, 0, 0, 13980, 13982, 3, 1492, 746, 0, 13981, 13983, 3, 1494, + 747, 0, 13982, 13981, 1, 0, 0, 0, 13982, 13983, 1, 0, 0, 0, 13983, 13985, + 1, 0, 0, 0, 13984, 13976, 1, 0, 0, 0, 13984, 13977, 1, 0, 0, 0, 13985, + 13988, 1, 0, 0, 0, 13986, 13988, 3, 1494, 747, 0, 13987, 13974, 1, 0, 0, + 0, 13987, 13986, 1, 0, 0, 0, 13988, 13991, 1, 0, 0, 0, 13989, 13987, 1, + 0, 0, 0, 13989, 13990, 1, 0, 0, 0, 13990, 13994, 1, 0, 0, 0, 13991, 13989, + 1, 0, 0, 0, 13992, 13993, 5, 2129, 0, 0, 13993, 13995, 5, 2372, 0, 0, 13994, + 13992, 1, 0, 0, 0, 13994, 13995, 1, 0, 0, 0, 13995, 1523, 1, 0, 0, 0, 13996, + 14001, 3, 1380, 690, 0, 13997, 13998, 5, 2369, 0, 0, 13998, 14000, 3, 2378, + 1189, 0, 13999, 13997, 1, 0, 0, 0, 14000, 14003, 1, 0, 0, 0, 14001, 13999, + 1, 0, 0, 0, 14001, 14002, 1, 0, 0, 0, 14002, 14006, 1, 0, 0, 0, 14003, + 14001, 1, 0, 0, 0, 14004, 14005, 5, 2384, 0, 0, 14005, 14007, 3, 2378, + 1189, 0, 14006, 14004, 1, 0, 0, 0, 14006, 14007, 1, 0, 0, 0, 14007, 1525, + 1, 0, 0, 0, 14008, 14010, 5, 425, 0, 0, 14009, 14011, 5, 1377, 0, 0, 14010, + 14009, 1, 0, 0, 0, 14010, 14011, 1, 0, 0, 0, 14011, 14012, 1, 0, 0, 0, + 14012, 14013, 5, 329, 0, 0, 14013, 14014, 5, 795, 0, 0, 14014, 14015, 3, + 1524, 762, 0, 14015, 1527, 1, 0, 0, 0, 14016, 14017, 5, 41, 0, 0, 14017, + 14018, 5, 1973, 0, 0, 14018, 14019, 5, 1568, 0, 0, 14019, 14020, 3, 2378, + 1189, 0, 14020, 14021, 3, 1530, 765, 0, 14021, 1529, 1, 0, 0, 0, 14022, + 14050, 3, 900, 450, 0, 14023, 14024, 5, 883, 0, 0, 14024, 14025, 5, 505, + 0, 0, 14025, 14050, 3, 1170, 585, 0, 14026, 14027, 5, 1468, 0, 0, 14027, + 14050, 3, 1170, 585, 0, 14028, 14050, 5, 214, 0, 0, 14029, 14030, 5, 1580, + 0, 0, 14030, 14033, 5, 1609, 0, 0, 14031, 14032, 5, 751, 0, 0, 14032, 14034, + 3, 1170, 585, 0, 14033, 14031, 1, 0, 0, 0, 14033, 14034, 1, 0, 0, 0, 14034, + 14050, 1, 0, 0, 0, 14035, 14036, 5, 1460, 0, 0, 14036, 14037, 5, 2029, + 0, 0, 14037, 14050, 3, 2378, 1189, 0, 14038, 14039, 7, 155, 0, 0, 14039, + 14050, 5, 98, 0, 0, 14040, 14050, 3, 862, 431, 0, 14041, 14050, 3, 864, + 432, 0, 14042, 14050, 3, 866, 433, 0, 14043, 14050, 3, 870, 435, 0, 14044, + 14050, 3, 918, 459, 0, 14045, 14050, 3, 872, 436, 0, 14046, 14050, 3, 892, + 446, 0, 14047, 14050, 3, 1532, 766, 0, 14048, 14050, 3, 1478, 739, 0, 14049, + 14022, 1, 0, 0, 0, 14049, 14023, 1, 0, 0, 0, 14049, 14026, 1, 0, 0, 0, + 14049, 14028, 1, 0, 0, 0, 14049, 14029, 1, 0, 0, 0, 14049, 14035, 1, 0, + 0, 0, 14049, 14038, 1, 0, 0, 0, 14049, 14040, 1, 0, 0, 0, 14049, 14041, + 1, 0, 0, 0, 14049, 14042, 1, 0, 0, 0, 14049, 14043, 1, 0, 0, 0, 14049, + 14044, 1, 0, 0, 0, 14049, 14045, 1, 0, 0, 0, 14049, 14046, 1, 0, 0, 0, + 14049, 14047, 1, 0, 0, 0, 14049, 14048, 1, 0, 0, 0, 14050, 1531, 1, 0, + 0, 0, 14051, 14076, 5, 458, 0, 0, 14052, 14058, 5, 1160, 0, 0, 14053, 14055, + 3, 880, 440, 0, 14054, 14053, 1, 0, 0, 0, 14054, 14055, 1, 0, 0, 0, 14055, + 14056, 1, 0, 0, 0, 14056, 14059, 5, 457, 0, 0, 14057, 14059, 5, 361, 0, + 0, 14058, 14054, 1, 0, 0, 0, 14058, 14057, 1, 0, 0, 0, 14059, 14077, 1, + 0, 0, 0, 14060, 14066, 5, 1173, 0, 0, 14061, 14063, 3, 880, 440, 0, 14062, + 14061, 1, 0, 0, 0, 14062, 14063, 1, 0, 0, 0, 14063, 14064, 1, 0, 0, 0, + 14064, 14067, 7, 170, 0, 0, 14065, 14067, 5, 361, 0, 0, 14066, 14062, 1, + 0, 0, 0, 14066, 14065, 1, 0, 0, 0, 14067, 14069, 1, 0, 0, 0, 14068, 14070, + 3, 1534, 767, 0, 14069, 14068, 1, 0, 0, 0, 14069, 14070, 1, 0, 0, 0, 14070, + 14077, 1, 0, 0, 0, 14071, 14072, 5, 542, 0, 0, 14072, 14074, 7, 171, 0, + 0, 14073, 14075, 3, 1534, 767, 0, 14074, 14073, 1, 0, 0, 0, 14074, 14075, + 1, 0, 0, 0, 14075, 14077, 1, 0, 0, 0, 14076, 14052, 1, 0, 0, 0, 14076, + 14060, 1, 0, 0, 0, 14076, 14071, 1, 0, 0, 0, 14077, 1533, 1, 0, 0, 0, 14078, + 14079, 5, 535, 0, 0, 14079, 14080, 5, 2398, 0, 0, 14080, 14081, 5, 2376, + 0, 0, 14081, 14082, 5, 2372, 0, 0, 14082, 14083, 5, 2382, 0, 0, 14083, + 14090, 5, 2372, 0, 0, 14084, 14085, 5, 2382, 0, 0, 14085, 14086, 5, 2372, + 0, 0, 14086, 14087, 5, 2382, 0, 0, 14087, 14089, 5, 2372, 0, 0, 14088, + 14084, 1, 0, 0, 0, 14089, 14092, 1, 0, 0, 0, 14090, 14088, 1, 0, 0, 0, + 14090, 14091, 1, 0, 0, 0, 14091, 14093, 1, 0, 0, 0, 14092, 14090, 1, 0, + 0, 0, 14093, 14095, 5, 2377, 0, 0, 14094, 14096, 5, 751, 0, 0, 14095, 14094, + 1, 0, 0, 0, 14095, 14096, 1, 0, 0, 0, 14096, 1535, 1, 0, 0, 0, 14097, 14098, + 5, 41, 0, 0, 14098, 14099, 5, 1494, 0, 0, 14099, 14100, 3, 2280, 1140, + 0, 14100, 14102, 3, 1538, 769, 0, 14101, 14103, 3, 762, 381, 0, 14102, + 14101, 1, 0, 0, 0, 14102, 14103, 1, 0, 0, 0, 14103, 1537, 1, 0, 0, 0, 14104, + 14105, 5, 1121, 0, 0, 14105, 14124, 5, 628, 0, 0, 14106, 14121, 5, 628, + 0, 0, 14107, 14108, 5, 151, 0, 0, 14108, 14122, 3, 2376, 1188, 0, 14109, + 14110, 5, 2129, 0, 0, 14110, 14113, 3, 2376, 1188, 0, 14111, 14112, 5, + 2369, 0, 0, 14112, 14114, 3, 2378, 1189, 0, 14113, 14111, 1, 0, 0, 0, 14113, + 14114, 1, 0, 0, 0, 14114, 14122, 1, 0, 0, 0, 14115, 14122, 5, 508, 0, 0, + 14116, 14119, 5, 587, 0, 0, 14117, 14118, 5, 66, 0, 0, 14118, 14120, 5, + 2372, 0, 0, 14119, 14117, 1, 0, 0, 0, 14119, 14120, 1, 0, 0, 0, 14120, + 14122, 1, 0, 0, 0, 14121, 14107, 1, 0, 0, 0, 14121, 14109, 1, 0, 0, 0, + 14121, 14115, 1, 0, 0, 0, 14121, 14116, 1, 0, 0, 0, 14122, 14124, 1, 0, + 0, 0, 14123, 14104, 1, 0, 0, 0, 14123, 14106, 1, 0, 0, 0, 14124, 1539, + 1, 0, 0, 0, 14125, 14126, 5, 41, 0, 0, 14126, 14127, 5, 1976, 0, 0, 14127, + 14131, 3, 2312, 1156, 0, 14128, 14130, 3, 1542, 771, 0, 14129, 14128, 1, + 0, 0, 0, 14130, 14133, 1, 0, 0, 0, 14131, 14129, 1, 0, 0, 0, 14131, 14132, + 1, 0, 0, 0, 14132, 14140, 1, 0, 0, 0, 14133, 14131, 1, 0, 0, 0, 14134, + 14141, 1, 0, 0, 0, 14135, 14141, 3, 1544, 772, 0, 14136, 14141, 3, 1712, + 856, 0, 14137, 14141, 3, 1612, 806, 0, 14138, 14141, 3, 1546, 773, 0, 14139, + 14141, 3, 1602, 801, 0, 14140, 14134, 1, 0, 0, 0, 14140, 14135, 1, 0, 0, + 0, 14140, 14136, 1, 0, 0, 0, 14140, 14137, 1, 0, 0, 0, 14140, 14138, 1, + 0, 0, 0, 14140, 14139, 1, 0, 0, 0, 14141, 14154, 1, 0, 0, 0, 14142, 14151, + 3, 1592, 796, 0, 14143, 14148, 3, 1322, 661, 0, 14144, 14145, 5, 1976, + 0, 0, 14145, 14149, 5, 812, 0, 0, 14146, 14147, 5, 37, 0, 0, 14147, 14149, + 5, 2043, 0, 0, 14148, 14144, 1, 0, 0, 0, 14148, 14146, 1, 0, 0, 0, 14149, + 14151, 1, 0, 0, 0, 14150, 14142, 1, 0, 0, 0, 14150, 14143, 1, 0, 0, 0, + 14151, 14152, 1, 0, 0, 0, 14152, 14150, 1, 0, 0, 0, 14152, 14153, 1, 0, + 0, 0, 14153, 14155, 1, 0, 0, 0, 14154, 14150, 1, 0, 0, 0, 14154, 14155, + 1, 0, 0, 0, 14155, 14156, 1, 0, 0, 0, 14156, 14157, 5, 2396, 0, 0, 14157, + 1541, 1, 0, 0, 0, 14158, 14160, 5, 1057, 0, 0, 14159, 14158, 1, 0, 0, 0, + 14159, 14160, 1, 0, 0, 0, 14160, 14161, 1, 0, 0, 0, 14161, 14162, 5, 2283, + 0, 0, 14162, 14163, 5, 564, 0, 0, 14163, 14164, 7, 172, 0, 0, 14164, 1543, + 1, 0, 0, 0, 14165, 14177, 3, 1570, 785, 0, 14166, 14167, 5, 1460, 0, 0, + 14167, 14168, 5, 2029, 0, 0, 14168, 14177, 3, 2312, 1156, 0, 14169, 14177, + 3, 1302, 651, 0, 14170, 14171, 5, 1408, 0, 0, 14171, 14177, 5, 1174, 0, + 0, 14172, 14173, 5, 1408, 0, 0, 14173, 14177, 5, 2192, 0, 0, 14174, 14175, + 5, 1451, 0, 0, 14175, 14177, 5, 2372, 0, 0, 14176, 14165, 1, 0, 0, 0, 14176, + 14166, 1, 0, 0, 0, 14176, 14169, 1, 0, 0, 0, 14176, 14170, 1, 0, 0, 0, + 14176, 14172, 1, 0, 0, 0, 14176, 14174, 1, 0, 0, 0, 14177, 1545, 1, 0, + 0, 0, 14178, 14188, 3, 1548, 774, 0, 14179, 14188, 3, 1550, 775, 0, 14180, + 14188, 3, 1552, 776, 0, 14181, 14188, 3, 1554, 777, 0, 14182, 14188, 3, + 1556, 778, 0, 14183, 14188, 3, 1558, 779, 0, 14184, 14188, 3, 1560, 780, + 0, 14185, 14188, 3, 1562, 781, 0, 14186, 14188, 3, 1564, 782, 0, 14187, + 14178, 1, 0, 0, 0, 14187, 14179, 1, 0, 0, 0, 14187, 14180, 1, 0, 0, 0, + 14187, 14181, 1, 0, 0, 0, 14187, 14182, 1, 0, 0, 0, 14187, 14183, 1, 0, + 0, 0, 14187, 14184, 1, 0, 0, 0, 14187, 14185, 1, 0, 0, 0, 14187, 14186, + 1, 0, 0, 0, 14188, 1547, 1, 0, 0, 0, 14189, 14206, 5, 20, 0, 0, 14190, + 14207, 3, 1134, 567, 0, 14191, 14207, 3, 1136, 568, 0, 14192, 14194, 5, + 1256, 0, 0, 14193, 14195, 3, 1704, 852, 0, 14194, 14193, 1, 0, 0, 0, 14194, + 14195, 1, 0, 0, 0, 14195, 14198, 1, 0, 0, 0, 14196, 14197, 5, 1973, 0, + 0, 14197, 14199, 3, 1666, 833, 0, 14198, 14196, 1, 0, 0, 0, 14198, 14199, + 1, 0, 0, 0, 14199, 14201, 1, 0, 0, 0, 14200, 14202, 3, 1608, 804, 0, 14201, + 14200, 1, 0, 0, 0, 14201, 14202, 1, 0, 0, 0, 14202, 14204, 1, 0, 0, 0, + 14203, 14205, 5, 2087, 0, 0, 14204, 14203, 1, 0, 0, 0, 14204, 14205, 1, + 0, 0, 0, 14205, 14207, 1, 0, 0, 0, 14206, 14190, 1, 0, 0, 0, 14206, 14191, + 1, 0, 0, 0, 14206, 14192, 1, 0, 0, 0, 14207, 1549, 1, 0, 0, 0, 14208, 14211, + 5, 425, 0, 0, 14209, 14212, 3, 1566, 783, 0, 14210, 14212, 3, 1568, 784, + 0, 14211, 14209, 1, 0, 0, 0, 14211, 14210, 1, 0, 0, 0, 14212, 14217, 1, + 0, 0, 0, 14213, 14215, 3, 1580, 790, 0, 14214, 14216, 3, 926, 463, 0, 14215, + 14214, 1, 0, 0, 0, 14215, 14216, 1, 0, 0, 0, 14216, 14218, 1, 0, 0, 0, + 14217, 14213, 1, 0, 0, 0, 14217, 14218, 1, 0, 0, 0, 14218, 1551, 1, 0, + 0, 0, 14219, 14220, 5, 875, 0, 0, 14220, 14221, 5, 1256, 0, 0, 14221, 14222, + 3, 1704, 852, 0, 14222, 14223, 5, 48, 0, 0, 14223, 14224, 3, 1704, 852, + 0, 14224, 14225, 5, 719, 0, 0, 14225, 14226, 5, 1256, 0, 0, 14226, 14227, + 3, 1704, 852, 0, 14227, 1553, 1, 0, 0, 0, 14228, 14249, 5, 909, 0, 0, 14229, + 14250, 1, 0, 0, 0, 14230, 14250, 3, 1108, 554, 0, 14231, 14232, 5, 1256, + 0, 0, 14232, 14235, 3, 1704, 852, 0, 14233, 14234, 7, 9, 0, 0, 14234, 14236, + 3, 1160, 580, 0, 14235, 14233, 1, 0, 0, 0, 14235, 14236, 1, 0, 0, 0, 14236, + 14239, 1, 0, 0, 0, 14237, 14238, 5, 20, 0, 0, 14238, 14240, 3, 1150, 575, + 0, 14239, 14237, 1, 0, 0, 0, 14239, 14240, 1, 0, 0, 0, 14240, 14247, 1, + 0, 0, 0, 14241, 14243, 5, 1413, 0, 0, 14242, 14241, 1, 0, 0, 0, 14242, + 14243, 1, 0, 0, 0, 14243, 14244, 1, 0, 0, 0, 14244, 14245, 5, 2087, 0, + 0, 14245, 14246, 5, 804, 0, 0, 14246, 14248, 5, 656, 0, 0, 14247, 14242, + 1, 0, 0, 0, 14247, 14248, 1, 0, 0, 0, 14248, 14250, 1, 0, 0, 0, 14249, + 14229, 1, 0, 0, 0, 14249, 14230, 1, 0, 0, 0, 14249, 14231, 1, 0, 0, 0, + 14250, 14252, 1, 0, 0, 0, 14251, 14253, 5, 1173, 0, 0, 14252, 14251, 1, + 0, 0, 0, 14252, 14253, 1, 0, 0, 0, 14253, 14258, 1, 0, 0, 0, 14254, 14256, + 3, 1580, 790, 0, 14255, 14257, 3, 926, 463, 0, 14256, 14255, 1, 0, 0, 0, + 14256, 14257, 1, 0, 0, 0, 14257, 14259, 1, 0, 0, 0, 14258, 14254, 1, 0, + 0, 0, 14258, 14259, 1, 0, 0, 0, 14259, 1555, 1, 0, 0, 0, 14260, 14261, + 5, 1612, 0, 0, 14261, 14262, 5, 1256, 0, 0, 14262, 14263, 3, 1704, 852, + 0, 14263, 14264, 5, 719, 0, 0, 14264, 14281, 5, 2376, 0, 0, 14265, 14270, + 3, 1134, 567, 0, 14266, 14267, 5, 2382, 0, 0, 14267, 14269, 3, 1134, 567, + 0, 14268, 14266, 1, 0, 0, 0, 14269, 14272, 1, 0, 0, 0, 14270, 14268, 1, + 0, 0, 0, 14270, 14271, 1, 0, 0, 0, 14271, 14282, 1, 0, 0, 0, 14272, 14270, + 1, 0, 0, 0, 14273, 14278, 3, 1136, 568, 0, 14274, 14275, 5, 2382, 0, 0, + 14275, 14277, 3, 1136, 568, 0, 14276, 14274, 1, 0, 0, 0, 14277, 14280, + 1, 0, 0, 0, 14278, 14276, 1, 0, 0, 0, 14278, 14279, 1, 0, 0, 0, 14279, + 14282, 1, 0, 0, 0, 14280, 14278, 1, 0, 0, 0, 14281, 14265, 1, 0, 0, 0, + 14281, 14273, 1, 0, 0, 0, 14282, 14283, 1, 0, 0, 0, 14283, 14284, 5, 2377, + 0, 0, 14284, 1557, 1, 0, 0, 0, 14285, 14288, 5, 2046, 0, 0, 14286, 14289, + 3, 1566, 783, 0, 14287, 14289, 3, 1568, 784, 0, 14288, 14286, 1, 0, 0, + 0, 14288, 14287, 1, 0, 0, 0, 14289, 14298, 1, 0, 0, 0, 14290, 14292, 5, + 425, 0, 0, 14291, 14293, 5, 37, 0, 0, 14292, 14291, 1, 0, 0, 0, 14292, + 14293, 1, 0, 0, 0, 14293, 14296, 1, 0, 0, 0, 14294, 14296, 5, 1488, 0, + 0, 14295, 14290, 1, 0, 0, 0, 14295, 14294, 1, 0, 0, 0, 14295, 14296, 1, + 0, 0, 0, 14296, 14297, 1, 0, 0, 0, 14297, 14299, 5, 1655, 0, 0, 14298, + 14295, 1, 0, 0, 0, 14298, 14299, 1, 0, 0, 0, 14299, 14301, 1, 0, 0, 0, + 14300, 14302, 5, 168, 0, 0, 14301, 14300, 1, 0, 0, 0, 14301, 14302, 1, + 0, 0, 0, 14302, 14307, 1, 0, 0, 0, 14303, 14305, 3, 1580, 790, 0, 14304, + 14306, 3, 926, 463, 0, 14305, 14304, 1, 0, 0, 0, 14305, 14306, 1, 0, 0, + 0, 14306, 14308, 1, 0, 0, 0, 14307, 14303, 1, 0, 0, 0, 14307, 14308, 1, + 0, 0, 0, 14308, 1559, 1, 0, 0, 0, 14309, 14310, 5, 485, 0, 0, 14310, 14311, + 5, 1256, 0, 0, 14311, 14312, 3, 1704, 852, 0, 14312, 14313, 5, 2188, 0, + 0, 14313, 14314, 5, 1976, 0, 0, 14314, 14317, 3, 2312, 1156, 0, 14315, + 14316, 7, 102, 0, 0, 14316, 14318, 5, 656, 0, 0, 14317, 14315, 1, 0, 0, + 0, 14317, 14318, 1, 0, 0, 0, 14318, 14321, 1, 0, 0, 0, 14319, 14320, 7, + 2, 0, 0, 14320, 14322, 5, 2138, 0, 0, 14321, 14319, 1, 0, 0, 0, 14321, + 14322, 1, 0, 0, 0, 14322, 1561, 1, 0, 0, 0, 14323, 14324, 5, 214, 0, 0, + 14324, 14326, 5, 1256, 0, 0, 14325, 14327, 3, 926, 463, 0, 14326, 14325, + 1, 0, 0, 0, 14326, 14327, 1, 0, 0, 0, 14327, 14331, 1, 0, 0, 0, 14328, + 14329, 3, 1324, 662, 0, 14329, 14330, 5, 210, 0, 0, 14330, 14332, 1, 0, + 0, 0, 14331, 14328, 1, 0, 0, 0, 14331, 14332, 1, 0, 0, 0, 14332, 1563, + 1, 0, 0, 0, 14333, 14334, 5, 1568, 0, 0, 14334, 14335, 5, 717, 0, 0, 14335, + 14338, 5, 2376, 0, 0, 14336, 14339, 3, 2364, 1182, 0, 14337, 14339, 3, + 2078, 1039, 0, 14338, 14336, 1, 0, 0, 0, 14338, 14337, 1, 0, 0, 0, 14338, + 14339, 1, 0, 0, 0, 14339, 14340, 1, 0, 0, 0, 14340, 14341, 5, 2377, 0, + 0, 14341, 1565, 1, 0, 0, 0, 14342, 14370, 7, 173, 0, 0, 14343, 14371, 3, + 1704, 852, 0, 14344, 14345, 5, 2376, 0, 0, 14345, 14350, 3, 1704, 852, + 0, 14346, 14347, 5, 2382, 0, 0, 14347, 14349, 3, 1704, 852, 0, 14348, 14346, + 1, 0, 0, 0, 14349, 14352, 1, 0, 0, 0, 14350, 14348, 1, 0, 0, 0, 14350, + 14351, 1, 0, 0, 0, 14351, 14353, 1, 0, 0, 0, 14352, 14350, 1, 0, 0, 0, + 14353, 14354, 5, 2377, 0, 0, 14354, 14371, 1, 0, 0, 0, 14355, 14357, 5, + 564, 0, 0, 14356, 14358, 5, 2376, 0, 0, 14357, 14356, 1, 0, 0, 0, 14357, + 14358, 1, 0, 0, 0, 14358, 14359, 1, 0, 0, 0, 14359, 14364, 3, 682, 341, + 0, 14360, 14361, 5, 2382, 0, 0, 14361, 14363, 3, 682, 341, 0, 14362, 14360, + 1, 0, 0, 0, 14363, 14366, 1, 0, 0, 0, 14364, 14362, 1, 0, 0, 0, 14364, + 14365, 1, 0, 0, 0, 14365, 14368, 1, 0, 0, 0, 14366, 14364, 1, 0, 0, 0, + 14367, 14369, 5, 2377, 0, 0, 14368, 14367, 1, 0, 0, 0, 14368, 14369, 1, + 0, 0, 0, 14369, 14371, 1, 0, 0, 0, 14370, 14343, 1, 0, 0, 0, 14370, 14344, + 1, 0, 0, 0, 14370, 14355, 1, 0, 0, 0, 14371, 1567, 1, 0, 0, 0, 14372, 14404, + 7, 174, 0, 0, 14373, 14376, 3, 1704, 852, 0, 14374, 14375, 5, 2091, 0, + 0, 14375, 14377, 5, 656, 0, 0, 14376, 14374, 1, 0, 0, 0, 14376, 14377, + 1, 0, 0, 0, 14377, 14405, 1, 0, 0, 0, 14378, 14379, 5, 2376, 0, 0, 14379, + 14384, 3, 1704, 852, 0, 14380, 14381, 5, 2382, 0, 0, 14381, 14383, 3, 1704, + 852, 0, 14382, 14380, 1, 0, 0, 0, 14383, 14386, 1, 0, 0, 0, 14384, 14382, + 1, 0, 0, 0, 14384, 14385, 1, 0, 0, 0, 14385, 14387, 1, 0, 0, 0, 14386, + 14384, 1, 0, 0, 0, 14387, 14388, 5, 2377, 0, 0, 14388, 14405, 1, 0, 0, + 0, 14389, 14391, 5, 564, 0, 0, 14390, 14392, 5, 2376, 0, 0, 14391, 14390, + 1, 0, 0, 0, 14391, 14392, 1, 0, 0, 0, 14392, 14393, 1, 0, 0, 0, 14393, + 14398, 3, 684, 342, 0, 14394, 14395, 5, 2382, 0, 0, 14395, 14397, 3, 684, + 342, 0, 14396, 14394, 1, 0, 0, 0, 14397, 14400, 1, 0, 0, 0, 14398, 14396, + 1, 0, 0, 0, 14398, 14399, 1, 0, 0, 0, 14399, 14402, 1, 0, 0, 0, 14400, + 14398, 1, 0, 0, 0, 14401, 14403, 5, 2377, 0, 0, 14402, 14401, 1, 0, 0, + 0, 14402, 14403, 1, 0, 0, 0, 14403, 14405, 1, 0, 0, 0, 14404, 14373, 1, + 0, 0, 0, 14404, 14378, 1, 0, 0, 0, 14404, 14389, 1, 0, 0, 0, 14405, 1569, + 1, 0, 0, 0, 14406, 14425, 3, 1188, 594, 0, 14407, 14425, 3, 882, 441, 0, + 14408, 14425, 3, 1172, 586, 0, 14409, 14425, 3, 1174, 587, 0, 14410, 14425, + 3, 1292, 646, 0, 14411, 14425, 3, 1298, 649, 0, 14412, 14425, 3, 1300, + 650, 0, 14413, 14425, 7, 103, 0, 0, 14414, 14415, 5, 1480, 0, 0, 14415, + 14416, 5, 2376, 0, 0, 14416, 14417, 5, 906, 0, 0, 14417, 14418, 7, 175, + 0, 0, 14418, 14425, 5, 2377, 0, 0, 14419, 14425, 3, 1306, 653, 0, 14420, + 14425, 3, 1304, 652, 0, 14421, 14425, 3, 926, 463, 0, 14422, 14425, 3, + 1286, 643, 0, 14423, 14425, 3, 1288, 644, 0, 14424, 14406, 1, 0, 0, 0, + 14424, 14407, 1, 0, 0, 0, 14424, 14408, 1, 0, 0, 0, 14424, 14409, 1, 0, + 0, 0, 14424, 14410, 1, 0, 0, 0, 14424, 14411, 1, 0, 0, 0, 14424, 14412, + 1, 0, 0, 0, 14424, 14413, 1, 0, 0, 0, 14424, 14414, 1, 0, 0, 0, 14424, + 14419, 1, 0, 0, 0, 14424, 14420, 1, 0, 0, 0, 14424, 14421, 1, 0, 0, 0, + 14424, 14422, 1, 0, 0, 0, 14424, 14423, 1, 0, 0, 0, 14425, 14426, 1, 0, + 0, 0, 14426, 14424, 1, 0, 0, 0, 14426, 14427, 1, 0, 0, 0, 14427, 14429, + 1, 0, 0, 0, 14428, 14430, 3, 1572, 786, 0, 14429, 14428, 1, 0, 0, 0, 14429, + 14430, 1, 0, 0, 0, 14430, 1571, 1, 0, 0, 0, 14431, 14436, 3, 1604, 802, + 0, 14432, 14436, 3, 1576, 788, 0, 14433, 14436, 3, 1574, 787, 0, 14434, + 14436, 5, 214, 0, 0, 14435, 14431, 1, 0, 0, 0, 14435, 14432, 1, 0, 0, 0, + 14435, 14433, 1, 0, 0, 0, 14435, 14434, 1, 0, 0, 0, 14436, 1573, 1, 0, + 0, 0, 14437, 14438, 5, 841, 0, 0, 14438, 14441, 5, 1976, 0, 0, 14439, 14442, + 3, 1298, 649, 0, 14440, 14442, 3, 1300, 650, 0, 14441, 14439, 1, 0, 0, + 0, 14441, 14440, 1, 0, 0, 0, 14442, 1575, 1, 0, 0, 0, 14443, 14454, 3, + 1578, 789, 0, 14444, 14449, 5, 1231, 0, 0, 14445, 14450, 3, 1194, 597, + 0, 14446, 14450, 3, 1298, 649, 0, 14447, 14450, 3, 1302, 651, 0, 14448, + 14450, 3, 1300, 650, 0, 14449, 14445, 1, 0, 0, 0, 14449, 14446, 1, 0, 0, + 0, 14449, 14447, 1, 0, 0, 0, 14449, 14448, 1, 0, 0, 0, 14450, 14451, 1, + 0, 0, 0, 14451, 14449, 1, 0, 0, 0, 14451, 14452, 1, 0, 0, 0, 14452, 14454, + 1, 0, 0, 0, 14453, 14443, 1, 0, 0, 0, 14453, 14444, 1, 0, 0, 0, 14454, + 1577, 1, 0, 0, 0, 14455, 14456, 5, 20, 0, 0, 14456, 14458, 5, 1231, 0, + 0, 14457, 14459, 3, 1194, 597, 0, 14458, 14457, 1, 0, 0, 0, 14458, 14459, + 1, 0, 0, 0, 14459, 14476, 1, 0, 0, 0, 14460, 14461, 5, 2376, 0, 0, 14461, + 14463, 5, 1256, 0, 0, 14462, 14464, 3, 1194, 597, 0, 14463, 14462, 1, 0, + 0, 0, 14463, 14464, 1, 0, 0, 0, 14464, 14472, 1, 0, 0, 0, 14465, 14466, + 5, 2382, 0, 0, 14466, 14468, 5, 1256, 0, 0, 14467, 14469, 3, 1194, 597, + 0, 14468, 14467, 1, 0, 0, 0, 14468, 14469, 1, 0, 0, 0, 14469, 14471, 1, + 0, 0, 0, 14470, 14465, 1, 0, 0, 0, 14471, 14474, 1, 0, 0, 0, 14472, 14470, + 1, 0, 0, 0, 14472, 14473, 1, 0, 0, 0, 14473, 14475, 1, 0, 0, 0, 14474, + 14472, 1, 0, 0, 0, 14475, 14477, 5, 2377, 0, 0, 14476, 14460, 1, 0, 0, + 0, 14476, 14477, 1, 0, 0, 0, 14477, 1579, 1, 0, 0, 0, 14478, 14481, 3, + 1582, 791, 0, 14479, 14481, 3, 1584, 792, 0, 14480, 14478, 1, 0, 0, 0, + 14480, 14479, 1, 0, 0, 0, 14481, 1581, 1, 0, 0, 0, 14482, 14483, 7, 176, + 0, 0, 14483, 14484, 5, 586, 0, 0, 14484, 14485, 5, 656, 0, 0, 14485, 1583, + 1, 0, 0, 0, 14486, 14487, 5, 2091, 0, 0, 14487, 14492, 5, 656, 0, 0, 14488, + 14489, 5, 2376, 0, 0, 14489, 14490, 3, 1586, 793, 0, 14490, 14491, 5, 2377, + 0, 0, 14491, 14493, 1, 0, 0, 0, 14492, 14488, 1, 0, 0, 0, 14492, 14493, + 1, 0, 0, 0, 14493, 1585, 1, 0, 0, 0, 14494, 14495, 3, 2300, 1150, 0, 14495, + 14498, 5, 2376, 0, 0, 14496, 14499, 3, 1588, 794, 0, 14497, 14499, 3, 1590, + 795, 0, 14498, 14496, 1, 0, 0, 0, 14498, 14497, 1, 0, 0, 0, 14499, 14500, + 1, 0, 0, 0, 14500, 14505, 5, 2377, 0, 0, 14501, 14502, 5, 2382, 0, 0, 14502, + 14504, 3, 1584, 792, 0, 14503, 14501, 1, 0, 0, 0, 14504, 14507, 1, 0, 0, + 0, 14505, 14503, 1, 0, 0, 0, 14505, 14506, 1, 0, 0, 0, 14506, 1587, 1, + 0, 0, 0, 14507, 14505, 1, 0, 0, 0, 14508, 14510, 3, 540, 270, 0, 14509, + 14511, 3, 502, 251, 0, 14510, 14509, 1, 0, 0, 0, 14510, 14511, 1, 0, 0, + 0, 14511, 14516, 1, 0, 0, 0, 14512, 14513, 5, 2382, 0, 0, 14513, 14515, + 3, 1588, 794, 0, 14514, 14512, 1, 0, 0, 0, 14515, 14518, 1, 0, 0, 0, 14516, + 14514, 1, 0, 0, 0, 14516, 14517, 1, 0, 0, 0, 14517, 1589, 1, 0, 0, 0, 14518, + 14516, 1, 0, 0, 0, 14519, 14521, 5, 1668, 0, 0, 14520, 14522, 3, 1148, + 574, 0, 14521, 14520, 1, 0, 0, 0, 14521, 14522, 1, 0, 0, 0, 14522, 14525, + 1, 0, 0, 0, 14523, 14524, 5, 1973, 0, 0, 14524, 14526, 3, 1666, 833, 0, + 14525, 14523, 1, 0, 0, 0, 14525, 14526, 1, 0, 0, 0, 14526, 14531, 1, 0, + 0, 0, 14527, 14528, 5, 2382, 0, 0, 14528, 14530, 3, 1590, 795, 0, 14529, + 14527, 1, 0, 0, 0, 14530, 14533, 1, 0, 0, 0, 14531, 14529, 1, 0, 0, 0, + 14531, 14532, 1, 0, 0, 0, 14532, 1591, 1, 0, 0, 0, 14533, 14531, 1, 0, + 0, 0, 14534, 14536, 7, 17, 0, 0, 14535, 14537, 7, 88, 0, 0, 14536, 14535, + 1, 0, 0, 0, 14536, 14537, 1, 0, 0, 0, 14537, 14554, 1, 0, 0, 0, 14538, + 14539, 5, 2068, 0, 0, 14539, 14540, 5, 2376, 0, 0, 14540, 14545, 3, 2310, + 1155, 0, 14541, 14542, 5, 2382, 0, 0, 14542, 14544, 3, 2310, 1155, 0, 14543, + 14541, 1, 0, 0, 0, 14544, 14547, 1, 0, 0, 0, 14545, 14543, 1, 0, 0, 0, + 14545, 14546, 1, 0, 0, 0, 14546, 14548, 1, 0, 0, 0, 14547, 14545, 1, 0, + 0, 0, 14548, 14549, 5, 2377, 0, 0, 14549, 14555, 1, 0, 0, 0, 14550, 14551, + 5, 1355, 0, 0, 14551, 14555, 5, 753, 0, 0, 14552, 14553, 5, 267, 0, 0, + 14553, 14555, 3, 2282, 1141, 0, 14554, 14538, 1, 0, 0, 0, 14554, 14550, + 1, 0, 0, 0, 14554, 14552, 1, 0, 0, 0, 14555, 14557, 1, 0, 0, 0, 14556, + 14558, 3, 1594, 797, 0, 14557, 14556, 1, 0, 0, 0, 14557, 14558, 1, 0, 0, + 0, 14558, 14560, 1, 0, 0, 0, 14559, 14561, 3, 1600, 800, 0, 14560, 14559, + 1, 0, 0, 0, 14560, 14561, 1, 0, 0, 0, 14561, 14563, 1, 0, 0, 0, 14562, + 14564, 5, 168, 0, 0, 14563, 14562, 1, 0, 0, 0, 14563, 14564, 1, 0, 0, 0, + 14564, 14567, 1, 0, 0, 0, 14565, 14566, 7, 148, 0, 0, 14566, 14568, 5, + 659, 0, 0, 14567, 14565, 1, 0, 0, 0, 14567, 14568, 1, 0, 0, 0, 14568, 1593, + 1, 0, 0, 0, 14569, 14570, 5, 2129, 0, 0, 14570, 14577, 5, 659, 0, 0, 14571, + 14578, 3, 2300, 1150, 0, 14572, 14573, 5, 2376, 0, 0, 14573, 14574, 3, + 458, 229, 0, 14574, 14575, 5, 2377, 0, 0, 14575, 14578, 1, 0, 0, 0, 14576, + 14578, 3, 1596, 798, 0, 14577, 14571, 1, 0, 0, 0, 14577, 14572, 1, 0, 0, + 0, 14577, 14576, 1, 0, 0, 0, 14577, 14578, 1, 0, 0, 0, 14578, 1595, 1, + 0, 0, 0, 14579, 14594, 3, 1188, 594, 0, 14580, 14594, 3, 882, 441, 0, 14581, + 14594, 5, 1173, 0, 0, 14582, 14585, 5, 1973, 0, 0, 14583, 14586, 3, 1666, + 833, 0, 14584, 14586, 5, 363, 0, 0, 14585, 14583, 1, 0, 0, 0, 14585, 14584, + 1, 0, 0, 0, 14586, 14594, 1, 0, 0, 0, 14587, 14594, 3, 1608, 804, 0, 14588, + 14594, 3, 1598, 799, 0, 14589, 14594, 5, 1489, 0, 0, 14590, 14594, 3, 516, + 258, 0, 14591, 14594, 3, 924, 462, 0, 14592, 14594, 3, 926, 463, 0, 14593, + 14579, 1, 0, 0, 0, 14593, 14580, 1, 0, 0, 0, 14593, 14581, 1, 0, 0, 0, + 14593, 14582, 1, 0, 0, 0, 14593, 14587, 1, 0, 0, 0, 14593, 14588, 1, 0, + 0, 0, 14593, 14589, 1, 0, 0, 0, 14593, 14590, 1, 0, 0, 0, 14593, 14591, + 1, 0, 0, 0, 14593, 14592, 1, 0, 0, 0, 14594, 14595, 1, 0, 0, 0, 14595, + 14593, 1, 0, 0, 0, 14595, 14596, 1, 0, 0, 0, 14596, 1597, 1, 0, 0, 0, 14597, + 14598, 7, 177, 0, 0, 14598, 1599, 1, 0, 0, 0, 14599, 14600, 5, 484, 0, + 0, 14600, 14601, 5, 719, 0, 0, 14601, 14602, 3, 2312, 1156, 0, 14602, 1601, + 1, 0, 0, 0, 14603, 14605, 5, 921, 0, 0, 14604, 14606, 5, 1173, 0, 0, 14605, + 14604, 1, 0, 0, 0, 14605, 14606, 1, 0, 0, 0, 14606, 14608, 1, 0, 0, 0, + 14607, 14609, 3, 1194, 597, 0, 14608, 14607, 1, 0, 0, 0, 14608, 14609, + 1, 0, 0, 0, 14609, 14611, 1, 0, 0, 0, 14610, 14612, 3, 1172, 586, 0, 14611, + 14610, 1, 0, 0, 0, 14611, 14612, 1, 0, 0, 0, 14612, 14614, 1, 0, 0, 0, + 14613, 14615, 3, 1604, 802, 0, 14614, 14613, 1, 0, 0, 0, 14614, 14615, + 1, 0, 0, 0, 14615, 14620, 1, 0, 0, 0, 14616, 14619, 3, 1650, 825, 0, 14617, + 14619, 3, 1640, 820, 0, 14618, 14616, 1, 0, 0, 0, 14618, 14617, 1, 0, 0, + 0, 14619, 14622, 1, 0, 0, 0, 14620, 14618, 1, 0, 0, 0, 14620, 14621, 1, + 0, 0, 0, 14621, 14624, 1, 0, 0, 0, 14622, 14620, 1, 0, 0, 0, 14623, 14625, + 3, 926, 463, 0, 14624, 14623, 1, 0, 0, 0, 14624, 14625, 1, 0, 0, 0, 14625, + 1603, 1, 0, 0, 0, 14626, 14631, 3, 1606, 803, 0, 14627, 14628, 5, 1279, + 0, 0, 14628, 14631, 5, 2370, 0, 0, 14629, 14631, 3, 1608, 804, 0, 14630, + 14626, 1, 0, 0, 0, 14630, 14627, 1, 0, 0, 0, 14630, 14629, 1, 0, 0, 0, + 14631, 14632, 1, 0, 0, 0, 14632, 14630, 1, 0, 0, 0, 14632, 14633, 1, 0, + 0, 0, 14633, 14635, 1, 0, 0, 0, 14634, 14636, 3, 1610, 805, 0, 14635, 14634, + 1, 0, 0, 0, 14635, 14636, 1, 0, 0, 0, 14636, 14639, 1, 0, 0, 0, 14637, + 14639, 3, 1610, 805, 0, 14638, 14630, 1, 0, 0, 0, 14638, 14637, 1, 0, 0, + 0, 14639, 1605, 1, 0, 0, 0, 14640, 14641, 5, 841, 0, 0, 14641, 14644, 5, + 1976, 0, 0, 14642, 14644, 5, 1041, 0, 0, 14643, 14640, 1, 0, 0, 0, 14643, + 14642, 1, 0, 0, 0, 14644, 1607, 1, 0, 0, 0, 14645, 14649, 5, 1000, 0, 0, + 14646, 14647, 5, 242, 0, 0, 14647, 14649, 5, 2370, 0, 0, 14648, 14645, + 1, 0, 0, 0, 14648, 14646, 1, 0, 0, 0, 14649, 1609, 1, 0, 0, 0, 14650, 14651, + 5, 647, 0, 0, 14651, 14653, 3, 2310, 1155, 0, 14652, 14650, 1, 0, 0, 0, + 14652, 14653, 1, 0, 0, 0, 14653, 14654, 1, 0, 0, 0, 14654, 14656, 5, 1231, + 0, 0, 14655, 14657, 3, 1194, 597, 0, 14656, 14655, 1, 0, 0, 0, 14656, 14657, + 1, 0, 0, 0, 14657, 1611, 1, 0, 0, 0, 14658, 14663, 3, 1624, 812, 0, 14659, + 14663, 3, 1618, 809, 0, 14660, 14663, 3, 1614, 807, 0, 14661, 14663, 3, + 1652, 826, 0, 14662, 14658, 1, 0, 0, 0, 14662, 14659, 1, 0, 0, 0, 14662, + 14660, 1, 0, 0, 0, 14662, 14661, 1, 0, 0, 0, 14663, 1613, 1, 0, 0, 0, 14664, + 14665, 5, 909, 0, 0, 14665, 14666, 5, 942, 0, 0, 14666, 14667, 5, 1976, + 0, 0, 14667, 14668, 3, 1616, 808, 0, 14668, 14669, 5, 1487, 0, 0, 14669, + 14670, 5, 66, 0, 0, 14670, 14671, 7, 178, 0, 0, 14671, 1615, 1, 0, 0, 0, + 14672, 14673, 3, 2312, 1156, 0, 14673, 1617, 1, 0, 0, 0, 14674, 14675, + 5, 1460, 0, 0, 14675, 14676, 5, 222, 0, 0, 14676, 14677, 3, 1620, 810, + 0, 14677, 14678, 5, 2029, 0, 0, 14678, 14679, 3, 1622, 811, 0, 14679, 1619, + 1, 0, 0, 0, 14680, 14681, 3, 2310, 1155, 0, 14681, 1621, 1, 0, 0, 0, 14682, + 14683, 3, 2310, 1155, 0, 14683, 1623, 1, 0, 0, 0, 14684, 14689, 3, 1712, + 856, 0, 14685, 14689, 3, 1636, 818, 0, 14686, 14689, 3, 1628, 814, 0, 14687, + 14689, 3, 1626, 813, 0, 14688, 14684, 1, 0, 0, 0, 14688, 14685, 1, 0, 0, + 0, 14688, 14686, 1, 0, 0, 0, 14688, 14687, 1, 0, 0, 0, 14689, 14690, 1, + 0, 0, 0, 14690, 14688, 1, 0, 0, 0, 14690, 14691, 1, 0, 0, 0, 14691, 1625, + 1, 0, 0, 0, 14692, 14693, 5, 1568, 0, 0, 14693, 14707, 5, 2088, 0, 0, 14694, + 14695, 5, 222, 0, 0, 14695, 14708, 3, 2310, 1155, 0, 14696, 14697, 5, 2376, + 0, 0, 14697, 14702, 3, 2310, 1155, 0, 14698, 14699, 5, 2382, 0, 0, 14699, + 14701, 3, 2310, 1155, 0, 14700, 14698, 1, 0, 0, 0, 14701, 14704, 1, 0, + 0, 0, 14702, 14700, 1, 0, 0, 0, 14702, 14703, 1, 0, 0, 0, 14703, 14705, + 1, 0, 0, 0, 14704, 14702, 1, 0, 0, 0, 14705, 14706, 5, 2377, 0, 0, 14706, + 14708, 1, 0, 0, 0, 14707, 14694, 1, 0, 0, 0, 14707, 14696, 1, 0, 0, 0, + 14708, 14714, 1, 0, 0, 0, 14709, 14710, 5, 168, 0, 0, 14710, 14713, 5, + 268, 0, 0, 14711, 14713, 5, 720, 0, 0, 14712, 14709, 1, 0, 0, 0, 14712, + 14711, 1, 0, 0, 0, 14713, 14716, 1, 0, 0, 0, 14714, 14712, 1, 0, 0, 0, + 14714, 14715, 1, 0, 0, 0, 14715, 14755, 1, 0, 0, 0, 14716, 14714, 1, 0, + 0, 0, 14717, 14731, 5, 425, 0, 0, 14718, 14719, 5, 222, 0, 0, 14719, 14732, + 3, 2310, 1155, 0, 14720, 14721, 5, 2376, 0, 0, 14721, 14726, 3, 2310, 1155, + 0, 14722, 14723, 5, 2382, 0, 0, 14723, 14725, 3, 2310, 1155, 0, 14724, + 14722, 1, 0, 0, 0, 14725, 14728, 1, 0, 0, 0, 14726, 14724, 1, 0, 0, 0, + 14726, 14727, 1, 0, 0, 0, 14727, 14729, 1, 0, 0, 0, 14728, 14726, 1, 0, + 0, 0, 14729, 14730, 5, 2377, 0, 0, 14730, 14732, 1, 0, 0, 0, 14731, 14718, + 1, 0, 0, 0, 14731, 14720, 1, 0, 0, 0, 14732, 14738, 1, 0, 0, 0, 14733, + 14734, 5, 168, 0, 0, 14734, 14737, 5, 268, 0, 0, 14735, 14737, 5, 720, + 0, 0, 14736, 14733, 1, 0, 0, 0, 14736, 14735, 1, 0, 0, 0, 14737, 14740, + 1, 0, 0, 0, 14738, 14736, 1, 0, 0, 0, 14738, 14739, 1, 0, 0, 0, 14739, + 14743, 1, 0, 0, 0, 14740, 14738, 1, 0, 0, 0, 14741, 14742, 5, 187, 0, 0, + 14742, 14744, 5, 2370, 0, 0, 14743, 14741, 1, 0, 0, 0, 14743, 14744, 1, + 0, 0, 0, 14744, 14755, 1, 0, 0, 0, 14745, 14750, 5, 425, 0, 0, 14746, 14747, + 5, 2088, 0, 0, 14747, 14751, 5, 223, 0, 0, 14748, 14749, 5, 223, 0, 0, + 14749, 14751, 5, 278, 0, 0, 14750, 14746, 1, 0, 0, 0, 14750, 14748, 1, + 0, 0, 0, 14751, 14752, 1, 0, 0, 0, 14752, 14753, 5, 187, 0, 0, 14753, 14755, + 5, 2370, 0, 0, 14754, 14692, 1, 0, 0, 0, 14754, 14717, 1, 0, 0, 0, 14754, + 14745, 1, 0, 0, 0, 14755, 1627, 1, 0, 0, 0, 14756, 14778, 5, 909, 0, 0, + 14757, 14758, 5, 2376, 0, 0, 14758, 14763, 3, 1632, 816, 0, 14759, 14760, + 5, 2382, 0, 0, 14760, 14762, 3, 1632, 816, 0, 14761, 14759, 1, 0, 0, 0, + 14762, 14765, 1, 0, 0, 0, 14763, 14761, 1, 0, 0, 0, 14763, 14764, 1, 0, + 0, 0, 14764, 14766, 1, 0, 0, 0, 14765, 14763, 1, 0, 0, 0, 14766, 14767, + 5, 2377, 0, 0, 14767, 14779, 1, 0, 0, 0, 14768, 14769, 5, 2376, 0, 0, 14769, + 14770, 3, 1630, 815, 0, 14770, 14771, 5, 2382, 0, 0, 14771, 14772, 3, 1630, + 815, 0, 14772, 14773, 1, 0, 0, 0, 14773, 14774, 5, 2377, 0, 0, 14774, 14779, + 1, 0, 0, 0, 14775, 14779, 3, 1632, 816, 0, 14776, 14779, 3, 1630, 815, + 0, 14777, 14779, 3, 1634, 817, 0, 14778, 14757, 1, 0, 0, 0, 14778, 14768, + 1, 0, 0, 0, 14778, 14775, 1, 0, 0, 0, 14778, 14776, 1, 0, 0, 0, 14778, + 14777, 1, 0, 0, 0, 14779, 1629, 1, 0, 0, 0, 14780, 14781, 3, 2310, 1155, + 0, 14781, 14782, 7, 62, 0, 0, 14782, 1631, 1, 0, 0, 0, 14783, 14785, 3, + 2310, 1155, 0, 14784, 14786, 3, 2346, 1173, 0, 14785, 14784, 1, 0, 0, 0, + 14785, 14786, 1, 0, 0, 0, 14786, 14789, 1, 0, 0, 0, 14787, 14788, 5, 2247, + 0, 0, 14788, 14790, 3, 1682, 841, 0, 14789, 14787, 1, 0, 0, 0, 14789, 14790, + 1, 0, 0, 0, 14790, 14797, 1, 0, 0, 0, 14791, 14794, 5, 363, 0, 0, 14792, + 14793, 5, 1175, 0, 0, 14793, 14795, 5, 1145, 0, 0, 14794, 14792, 1, 0, + 0, 0, 14794, 14795, 1, 0, 0, 0, 14795, 14796, 1, 0, 0, 0, 14796, 14798, + 3, 2078, 1039, 0, 14797, 14791, 1, 0, 0, 0, 14797, 14798, 1, 0, 0, 0, 14798, + 14802, 1, 0, 0, 0, 14799, 14800, 5, 457, 0, 0, 14800, 14803, 3, 1664, 832, + 0, 14801, 14803, 5, 361, 0, 0, 14802, 14799, 1, 0, 0, 0, 14802, 14801, + 1, 0, 0, 0, 14802, 14803, 1, 0, 0, 0, 14803, 14807, 1, 0, 0, 0, 14804, + 14806, 3, 842, 421, 0, 14805, 14804, 1, 0, 0, 0, 14806, 14809, 1, 0, 0, + 0, 14807, 14805, 1, 0, 0, 0, 14807, 14808, 1, 0, 0, 0, 14808, 14811, 1, + 0, 0, 0, 14809, 14807, 1, 0, 0, 0, 14810, 14812, 3, 1650, 825, 0, 14811, + 14810, 1, 0, 0, 0, 14811, 14812, 1, 0, 0, 0, 14812, 1633, 1, 0, 0, 0, 14813, + 14814, 5, 222, 0, 0, 14814, 14816, 3, 2310, 1155, 0, 14815, 14817, 5, 1121, + 0, 0, 14816, 14815, 1, 0, 0, 0, 14816, 14817, 1, 0, 0, 0, 14817, 14818, + 1, 0, 0, 0, 14818, 14819, 5, 1673, 0, 0, 14819, 14820, 5, 79, 0, 0, 14820, + 14821, 5, 37, 0, 0, 14821, 14823, 5, 783, 0, 0, 14822, 14824, 5, 560, 0, + 0, 14823, 14822, 1, 0, 0, 0, 14823, 14824, 1, 0, 0, 0, 14824, 1635, 1, + 0, 0, 0, 14825, 14847, 5, 20, 0, 0, 14826, 14829, 5, 2376, 0, 0, 14827, + 14830, 3, 1680, 840, 0, 14828, 14830, 3, 1690, 845, 0, 14829, 14827, 1, + 0, 0, 0, 14829, 14828, 1, 0, 0, 0, 14830, 14838, 1, 0, 0, 0, 14831, 14834, + 5, 2382, 0, 0, 14832, 14835, 3, 1680, 840, 0, 14833, 14835, 3, 1690, 845, + 0, 14834, 14832, 1, 0, 0, 0, 14834, 14833, 1, 0, 0, 0, 14835, 14837, 1, + 0, 0, 0, 14836, 14831, 1, 0, 0, 0, 14837, 14840, 1, 0, 0, 0, 14838, 14836, + 1, 0, 0, 0, 14838, 14839, 1, 0, 0, 0, 14839, 14841, 1, 0, 0, 0, 14840, + 14838, 1, 0, 0, 0, 14841, 14842, 5, 2377, 0, 0, 14842, 14848, 1, 0, 0, + 0, 14843, 14846, 3, 1680, 840, 0, 14844, 14846, 3, 1690, 845, 0, 14845, + 14843, 1, 0, 0, 0, 14845, 14844, 1, 0, 0, 0, 14846, 14848, 1, 0, 0, 0, + 14847, 14826, 1, 0, 0, 0, 14847, 14845, 1, 0, 0, 0, 14848, 14850, 1, 0, + 0, 0, 14849, 14851, 3, 1670, 835, 0, 14850, 14849, 1, 0, 0, 0, 14850, 14851, + 1, 0, 0, 0, 14851, 1637, 1, 0, 0, 0, 14852, 14853, 5, 909, 0, 0, 14853, + 14854, 5, 2147, 0, 0, 14854, 14855, 3, 1668, 834, 0, 14855, 14856, 5, 2376, + 0, 0, 14856, 14857, 3, 1654, 827, 0, 14857, 14858, 5, 2377, 0, 0, 14858, + 1639, 1, 0, 0, 0, 14859, 14860, 5, 2147, 0, 0, 14860, 14866, 3, 1668, 834, + 0, 14861, 14863, 3, 1702, 851, 0, 14862, 14861, 1, 0, 0, 0, 14862, 14863, + 1, 0, 0, 0, 14863, 14864, 1, 0, 0, 0, 14864, 14867, 3, 1642, 821, 0, 14865, + 14867, 3, 1702, 851, 0, 14866, 14862, 1, 0, 0, 0, 14866, 14865, 1, 0, 0, + 0, 14867, 1641, 1, 0, 0, 0, 14868, 14869, 5, 1656, 0, 0, 14869, 14871, + 5, 66, 0, 0, 14870, 14872, 7, 113, 0, 0, 14871, 14870, 1, 0, 0, 0, 14871, + 14872, 1, 0, 0, 0, 14872, 14873, 1, 0, 0, 0, 14873, 14882, 5, 800, 0, 0, + 14874, 14876, 3, 1644, 822, 0, 14875, 14874, 1, 0, 0, 0, 14875, 14876, + 1, 0, 0, 0, 14876, 14877, 1, 0, 0, 0, 14877, 14878, 5, 2376, 0, 0, 14878, + 14879, 3, 1648, 824, 0, 14879, 14880, 5, 2377, 0, 0, 14880, 14883, 1, 0, + 0, 0, 14881, 14883, 3, 1644, 822, 0, 14882, 14875, 1, 0, 0, 0, 14882, 14881, + 1, 0, 0, 0, 14883, 1643, 1, 0, 0, 0, 14884, 14885, 3, 2382, 1191, 0, 14885, + 1645, 1, 0, 0, 0, 14886, 14889, 3, 2382, 1191, 0, 14887, 14889, 3, 2372, + 1186, 0, 14888, 14886, 1, 0, 0, 0, 14888, 14887, 1, 0, 0, 0, 14889, 1647, + 1, 0, 0, 0, 14890, 14891, 5, 1973, 0, 0, 14891, 14898, 3, 2378, 1189, 0, + 14892, 14894, 3, 1656, 828, 0, 14893, 14895, 3, 1190, 595, 0, 14894, 14893, + 1, 0, 0, 0, 14894, 14895, 1, 0, 0, 0, 14895, 14898, 1, 0, 0, 0, 14896, + 14898, 3, 1190, 595, 0, 14897, 14890, 1, 0, 0, 0, 14897, 14892, 1, 0, 0, + 0, 14897, 14896, 1, 0, 0, 0, 14898, 1649, 1, 0, 0, 0, 14899, 14944, 5, + 800, 0, 0, 14900, 14901, 5, 2376, 0, 0, 14901, 14906, 3, 1646, 823, 0, + 14902, 14903, 5, 2382, 0, 0, 14903, 14905, 3, 1646, 823, 0, 14904, 14902, + 1, 0, 0, 0, 14905, 14908, 1, 0, 0, 0, 14906, 14904, 1, 0, 0, 0, 14906, + 14907, 1, 0, 0, 0, 14907, 14909, 1, 0, 0, 0, 14908, 14906, 1, 0, 0, 0, + 14909, 14910, 5, 2377, 0, 0, 14910, 14911, 5, 1656, 0, 0, 14911, 14921, + 5, 66, 0, 0, 14912, 14922, 7, 113, 0, 0, 14913, 14917, 5, 2376, 0, 0, 14914, + 14916, 3, 1648, 824, 0, 14915, 14914, 1, 0, 0, 0, 14916, 14919, 1, 0, 0, + 0, 14917, 14915, 1, 0, 0, 0, 14917, 14918, 1, 0, 0, 0, 14918, 14920, 1, + 0, 0, 0, 14919, 14917, 1, 0, 0, 0, 14920, 14922, 5, 2377, 0, 0, 14921, + 14912, 1, 0, 0, 0, 14921, 14913, 1, 0, 0, 0, 14922, 14923, 1, 0, 0, 0, + 14923, 14921, 1, 0, 0, 0, 14923, 14924, 1, 0, 0, 0, 14924, 14945, 1, 0, + 0, 0, 14925, 14926, 5, 2376, 0, 0, 14926, 14927, 3, 1646, 823, 0, 14927, + 14928, 5, 2377, 0, 0, 14928, 14929, 5, 1656, 0, 0, 14929, 14940, 5, 66, + 0, 0, 14930, 14941, 7, 113, 0, 0, 14931, 14941, 3, 1644, 822, 0, 14932, + 14936, 5, 2376, 0, 0, 14933, 14935, 3, 1648, 824, 0, 14934, 14933, 1, 0, + 0, 0, 14935, 14938, 1, 0, 0, 0, 14936, 14934, 1, 0, 0, 0, 14936, 14937, + 1, 0, 0, 0, 14937, 14939, 1, 0, 0, 0, 14938, 14936, 1, 0, 0, 0, 14939, + 14941, 5, 2377, 0, 0, 14940, 14930, 1, 0, 0, 0, 14940, 14931, 1, 0, 0, + 0, 14940, 14932, 1, 0, 0, 0, 14941, 14942, 1, 0, 0, 0, 14942, 14940, 1, + 0, 0, 0, 14942, 14943, 1, 0, 0, 0, 14943, 14945, 1, 0, 0, 0, 14944, 14900, + 1, 0, 0, 0, 14944, 14925, 1, 0, 0, 0, 14945, 1651, 1, 0, 0, 0, 14946, 14947, + 5, 909, 0, 0, 14947, 14948, 5, 800, 0, 0, 14948, 14949, 5, 2376, 0, 0, + 14949, 14950, 3, 1646, 823, 0, 14950, 14951, 5, 2377, 0, 0, 14951, 14952, + 5, 2376, 0, 0, 14952, 14953, 3, 1654, 827, 0, 14953, 14954, 5, 2377, 0, + 0, 14954, 1653, 1, 0, 0, 0, 14955, 14980, 3, 1190, 595, 0, 14956, 14957, + 7, 179, 0, 0, 14957, 14980, 5, 2370, 0, 0, 14958, 14959, 5, 1413, 0, 0, + 14959, 14980, 5, 570, 0, 0, 14960, 14980, 3, 1662, 831, 0, 14961, 14980, + 3, 1658, 829, 0, 14962, 14980, 3, 1660, 830, 0, 14963, 14964, 5, 457, 0, + 0, 14964, 14980, 3, 1664, 832, 0, 14965, 14980, 5, 361, 0, 0, 14966, 14980, + 5, 155, 0, 0, 14967, 14972, 5, 155, 0, 0, 14968, 14972, 5, 993, 0, 0, 14969, + 14970, 5, 155, 0, 0, 14970, 14972, 5, 1409, 0, 0, 14971, 14967, 1, 0, 0, + 0, 14971, 14968, 1, 0, 0, 0, 14971, 14969, 1, 0, 0, 0, 14972, 14974, 1, + 0, 0, 0, 14973, 14975, 3, 882, 441, 0, 14974, 14973, 1, 0, 0, 0, 14974, + 14975, 1, 0, 0, 0, 14975, 14980, 1, 0, 0, 0, 14976, 14980, 3, 1298, 649, + 0, 14977, 14980, 3, 1302, 651, 0, 14978, 14980, 3, 1300, 650, 0, 14979, + 14955, 1, 0, 0, 0, 14979, 14956, 1, 0, 0, 0, 14979, 14958, 1, 0, 0, 0, + 14979, 14960, 1, 0, 0, 0, 14979, 14961, 1, 0, 0, 0, 14979, 14962, 1, 0, + 0, 0, 14979, 14963, 1, 0, 0, 0, 14979, 14965, 1, 0, 0, 0, 14979, 14966, + 1, 0, 0, 0, 14979, 14971, 1, 0, 0, 0, 14979, 14976, 1, 0, 0, 0, 14979, + 14977, 1, 0, 0, 0, 14979, 14978, 1, 0, 0, 0, 14980, 14981, 1, 0, 0, 0, + 14981, 14979, 1, 0, 0, 0, 14981, 14982, 1, 0, 0, 0, 14982, 1655, 1, 0, + 0, 0, 14983, 14984, 7, 17, 0, 0, 14984, 14985, 5, 1655, 0, 0, 14985, 14986, + 5, 680, 0, 0, 14986, 15009, 5, 1507, 0, 0, 14987, 14988, 5, 191, 0, 0, + 14988, 15009, 5, 2370, 0, 0, 14989, 14990, 5, 1281, 0, 0, 14990, 15009, + 5, 2370, 0, 0, 14991, 14992, 5, 570, 0, 0, 14992, 15009, 5, 2370, 0, 0, + 14993, 15009, 3, 1662, 831, 0, 14994, 15009, 3, 1658, 829, 0, 14995, 15009, + 3, 1660, 830, 0, 14996, 14997, 5, 457, 0, 0, 14997, 15009, 3, 1664, 832, + 0, 14998, 15009, 5, 361, 0, 0, 14999, 15004, 5, 155, 0, 0, 15000, 15004, + 5, 993, 0, 0, 15001, 15002, 5, 155, 0, 0, 15002, 15004, 5, 1409, 0, 0, + 15003, 14999, 1, 0, 0, 0, 15003, 15000, 1, 0, 0, 0, 15003, 15001, 1, 0, + 0, 0, 15004, 15006, 1, 0, 0, 0, 15005, 15007, 3, 882, 441, 0, 15006, 15005, + 1, 0, 0, 0, 15006, 15007, 1, 0, 0, 0, 15007, 15009, 1, 0, 0, 0, 15008, + 14983, 1, 0, 0, 0, 15008, 14987, 1, 0, 0, 0, 15008, 14989, 1, 0, 0, 0, + 15008, 14991, 1, 0, 0, 0, 15008, 14993, 1, 0, 0, 0, 15008, 14994, 1, 0, + 0, 0, 15008, 14995, 1, 0, 0, 0, 15008, 14996, 1, 0, 0, 0, 15008, 14998, + 1, 0, 0, 0, 15008, 15003, 1, 0, 0, 0, 15009, 15010, 1, 0, 0, 0, 15010, + 15008, 1, 0, 0, 0, 15010, 15011, 1, 0, 0, 0, 15011, 1657, 1, 0, 0, 0, 15012, + 15013, 7, 180, 0, 0, 15013, 1659, 1, 0, 0, 0, 15014, 15020, 5, 1000, 0, + 0, 15015, 15017, 5, 242, 0, 0, 15016, 15018, 7, 181, 0, 0, 15017, 15016, + 1, 0, 0, 0, 15017, 15018, 1, 0, 0, 0, 15018, 15020, 1, 0, 0, 0, 15019, + 15014, 1, 0, 0, 0, 15019, 15015, 1, 0, 0, 0, 15020, 1661, 1, 0, 0, 0, 15021, + 15027, 5, 1484, 0, 0, 15022, 15028, 5, 2281, 0, 0, 15023, 15024, 5, 2284, + 0, 0, 15024, 15028, 5, 2370, 0, 0, 15025, 15028, 5, 88, 0, 0, 15026, 15028, + 5, 1054, 0, 0, 15027, 15022, 1, 0, 0, 0, 15027, 15023, 1, 0, 0, 0, 15027, + 15025, 1, 0, 0, 0, 15027, 15026, 1, 0, 0, 0, 15027, 15028, 1, 0, 0, 0, + 15028, 1663, 1, 0, 0, 0, 15029, 15030, 5, 2129, 0, 0, 15030, 15032, 5, + 2372, 0, 0, 15031, 15029, 1, 0, 0, 0, 15031, 15032, 1, 0, 0, 0, 15032, + 15036, 1, 0, 0, 0, 15033, 15034, 5, 628, 0, 0, 15034, 15035, 5, 151, 0, + 0, 15035, 15037, 5, 2407, 0, 0, 15036, 15033, 1, 0, 0, 0, 15036, 15037, + 1, 0, 0, 0, 15037, 15039, 1, 0, 0, 0, 15038, 15040, 5, 2372, 0, 0, 15039, + 15038, 1, 0, 0, 0, 15039, 15040, 1, 0, 0, 0, 15040, 15045, 1, 0, 0, 0, + 15041, 15043, 5, 1057, 0, 0, 15042, 15041, 1, 0, 0, 0, 15042, 15043, 1, + 0, 0, 0, 15043, 15044, 1, 0, 0, 0, 15044, 15046, 5, 1514, 0, 0, 15045, + 15042, 1, 0, 0, 0, 15045, 15046, 1, 0, 0, 0, 15046, 1665, 1, 0, 0, 0, 15047, + 15048, 3, 2378, 1189, 0, 15048, 1667, 1, 0, 0, 0, 15049, 15050, 3, 2378, + 1189, 0, 15050, 15051, 5, 2369, 0, 0, 15051, 15053, 1, 0, 0, 0, 15052, + 15049, 1, 0, 0, 0, 15052, 15053, 1, 0, 0, 0, 15053, 15057, 1, 0, 0, 0, + 15054, 15055, 3, 2378, 1189, 0, 15055, 15056, 5, 2369, 0, 0, 15056, 15058, + 1, 0, 0, 0, 15057, 15054, 1, 0, 0, 0, 15057, 15058, 1, 0, 0, 0, 15058, + 15059, 1, 0, 0, 0, 15059, 15060, 3, 2378, 1189, 0, 15060, 1669, 1, 0, 0, + 0, 15061, 15082, 3, 1710, 855, 0, 15062, 15082, 3, 1698, 849, 0, 15063, + 15066, 3, 1640, 820, 0, 15064, 15066, 3, 1650, 825, 0, 15065, 15063, 1, + 0, 0, 0, 15065, 15064, 1, 0, 0, 0, 15066, 15078, 1, 0, 0, 0, 15067, 15068, + 5, 2376, 0, 0, 15068, 15073, 3, 1672, 836, 0, 15069, 15070, 5, 2382, 0, + 0, 15070, 15072, 3, 1672, 836, 0, 15071, 15069, 1, 0, 0, 0, 15072, 15075, + 1, 0, 0, 0, 15073, 15071, 1, 0, 0, 0, 15073, 15074, 1, 0, 0, 0, 15074, + 15076, 1, 0, 0, 0, 15075, 15073, 1, 0, 0, 0, 15076, 15077, 5, 2377, 0, + 0, 15077, 15079, 1, 0, 0, 0, 15078, 15067, 1, 0, 0, 0, 15078, 15079, 1, + 0, 0, 0, 15079, 15082, 1, 0, 0, 0, 15080, 15082, 3, 1042, 521, 0, 15081, + 15061, 1, 0, 0, 0, 15081, 15062, 1, 0, 0, 0, 15081, 15065, 1, 0, 0, 0, + 15081, 15080, 1, 0, 0, 0, 15082, 15083, 1, 0, 0, 0, 15083, 15081, 1, 0, + 0, 0, 15083, 15084, 1, 0, 0, 0, 15084, 1671, 1, 0, 0, 0, 15085, 15118, + 5, 800, 0, 0, 15086, 15087, 5, 2376, 0, 0, 15087, 15088, 3, 1646, 823, + 0, 15088, 15089, 5, 2382, 0, 0, 15089, 15090, 3, 1646, 823, 0, 15090, 15091, + 1, 0, 0, 0, 15091, 15092, 5, 2377, 0, 0, 15092, 15093, 5, 1656, 0, 0, 15093, + 15099, 5, 66, 0, 0, 15094, 15100, 7, 113, 0, 0, 15095, 15096, 5, 2376, + 0, 0, 15096, 15097, 3, 1648, 824, 0, 15097, 15098, 5, 2377, 0, 0, 15098, + 15100, 1, 0, 0, 0, 15099, 15094, 1, 0, 0, 0, 15099, 15095, 1, 0, 0, 0, + 15100, 15101, 1, 0, 0, 0, 15101, 15099, 1, 0, 0, 0, 15101, 15102, 1, 0, + 0, 0, 15102, 15119, 1, 0, 0, 0, 15103, 15104, 5, 2376, 0, 0, 15104, 15105, + 3, 1646, 823, 0, 15105, 15106, 5, 2377, 0, 0, 15106, 15107, 5, 1656, 0, + 0, 15107, 15114, 5, 66, 0, 0, 15108, 15115, 7, 113, 0, 0, 15109, 15115, + 3, 1644, 822, 0, 15110, 15111, 5, 2376, 0, 0, 15111, 15112, 3, 1648, 824, + 0, 15112, 15113, 5, 2377, 0, 0, 15113, 15115, 1, 0, 0, 0, 15114, 15108, + 1, 0, 0, 0, 15114, 15109, 1, 0, 0, 0, 15114, 15110, 1, 0, 0, 0, 15115, + 15116, 1, 0, 0, 0, 15116, 15114, 1, 0, 0, 0, 15116, 15117, 1, 0, 0, 0, + 15117, 15119, 1, 0, 0, 0, 15118, 15086, 1, 0, 0, 0, 15118, 15103, 1, 0, + 0, 0, 15119, 1673, 1, 0, 0, 0, 15120, 15121, 4, 837, 9, 0, 15121, 15122, + 5, 2369, 0, 0, 15122, 15123, 5, 564, 0, 0, 15123, 15130, 3, 2310, 1155, + 0, 15124, 15125, 5, 2376, 0, 0, 15125, 15126, 3, 1676, 838, 0, 15126, 15127, + 5, 2382, 0, 0, 15127, 15128, 3, 1678, 839, 0, 15128, 15129, 5, 2377, 0, + 0, 15129, 15131, 1, 0, 0, 0, 15130, 15124, 1, 0, 0, 0, 15130, 15131, 1, + 0, 0, 0, 15131, 1675, 1, 0, 0, 0, 15132, 15133, 3, 2310, 1155, 0, 15133, + 1677, 1, 0, 0, 0, 15134, 15135, 3, 2310, 1155, 0, 15135, 1679, 1, 0, 0, + 0, 15136, 15145, 3, 2310, 1155, 0, 15137, 15140, 3, 2346, 1173, 0, 15138, + 15140, 3, 2382, 1191, 0, 15139, 15137, 1, 0, 0, 0, 15139, 15138, 1, 0, + 0, 0, 15140, 15143, 1, 0, 0, 0, 15141, 15142, 5, 2247, 0, 0, 15142, 15144, + 3, 1682, 841, 0, 15143, 15141, 1, 0, 0, 0, 15143, 15144, 1, 0, 0, 0, 15144, + 15146, 1, 0, 0, 0, 15145, 15139, 1, 0, 0, 0, 15145, 15146, 1, 0, 0, 0, + 15146, 15148, 1, 0, 0, 0, 15147, 15149, 5, 1604, 0, 0, 15148, 15147, 1, + 0, 0, 0, 15148, 15149, 1, 0, 0, 0, 15149, 15151, 1, 0, 0, 0, 15150, 15152, + 7, 62, 0, 0, 15151, 15150, 1, 0, 0, 0, 15151, 15152, 1, 0, 0, 0, 15152, + 15160, 1, 0, 0, 0, 15153, 15156, 5, 363, 0, 0, 15154, 15155, 5, 1175, 0, + 0, 15155, 15157, 5, 1145, 0, 0, 15156, 15154, 1, 0, 0, 0, 15156, 15157, + 1, 0, 0, 0, 15157, 15158, 1, 0, 0, 0, 15158, 15161, 3, 2078, 1039, 0, 15159, + 15161, 3, 1684, 842, 0, 15160, 15153, 1, 0, 0, 0, 15160, 15159, 1, 0, 0, + 0, 15160, 15161, 1, 0, 0, 0, 15161, 15164, 1, 0, 0, 0, 15162, 15163, 5, + 457, 0, 0, 15163, 15165, 3, 1664, 832, 0, 15164, 15162, 1, 0, 0, 0, 15164, + 15165, 1, 0, 0, 0, 15165, 15172, 1, 0, 0, 0, 15166, 15168, 3, 842, 421, + 0, 15167, 15166, 1, 0, 0, 0, 15168, 15169, 1, 0, 0, 0, 15169, 15167, 1, + 0, 0, 0, 15169, 15170, 1, 0, 0, 0, 15170, 15173, 1, 0, 0, 0, 15171, 15173, + 3, 844, 422, 0, 15172, 15167, 1, 0, 0, 0, 15172, 15171, 1, 0, 0, 0, 15172, + 15173, 1, 0, 0, 0, 15173, 1681, 1, 0, 0, 0, 15174, 15175, 3, 2378, 1189, + 0, 15175, 1683, 1, 0, 0, 0, 15176, 15184, 5, 584, 0, 0, 15177, 15185, 5, + 43, 0, 0, 15178, 15179, 5, 151, 0, 0, 15179, 15182, 5, 363, 0, 0, 15180, + 15181, 5, 1175, 0, 0, 15181, 15183, 5, 1145, 0, 0, 15182, 15180, 1, 0, + 0, 0, 15182, 15183, 1, 0, 0, 0, 15183, 15185, 1, 0, 0, 0, 15184, 15177, + 1, 0, 0, 0, 15184, 15178, 1, 0, 0, 0, 15184, 15185, 1, 0, 0, 0, 15185, + 15186, 1, 0, 0, 0, 15186, 15187, 5, 66, 0, 0, 15187, 15189, 5, 630, 0, + 0, 15188, 15190, 3, 1686, 843, 0, 15189, 15188, 1, 0, 0, 0, 15189, 15190, + 1, 0, 0, 0, 15190, 1685, 1, 0, 0, 0, 15191, 15193, 3, 1688, 844, 0, 15192, + 15191, 1, 0, 0, 0, 15193, 15194, 1, 0, 0, 0, 15194, 15192, 1, 0, 0, 0, + 15194, 15195, 1, 0, 0, 0, 15195, 15205, 1, 0, 0, 0, 15196, 15198, 5, 2376, + 0, 0, 15197, 15199, 3, 1688, 844, 0, 15198, 15197, 1, 0, 0, 0, 15199, 15200, + 1, 0, 0, 0, 15200, 15198, 1, 0, 0, 0, 15200, 15201, 1, 0, 0, 0, 15201, + 15202, 1, 0, 0, 0, 15202, 15203, 5, 2377, 0, 0, 15203, 15205, 1, 0, 0, + 0, 15204, 15192, 1, 0, 0, 0, 15204, 15196, 1, 0, 0, 0, 15205, 1687, 1, + 0, 0, 0, 15206, 15207, 5, 1631, 0, 0, 15207, 15211, 5, 2188, 0, 0, 15208, + 15212, 3, 2368, 1184, 0, 15209, 15210, 5, 793, 0, 0, 15210, 15212, 5, 2141, + 0, 0, 15211, 15208, 1, 0, 0, 0, 15211, 15209, 1, 0, 0, 0, 15212, 15230, + 1, 0, 0, 0, 15213, 15214, 5, 649, 0, 0, 15214, 15215, 5, 151, 0, 0, 15215, + 15230, 3, 2368, 1184, 0, 15216, 15217, 5, 861, 0, 0, 15217, 15230, 3, 2368, + 1184, 0, 15218, 15230, 5, 1042, 0, 0, 15219, 15220, 5, 889, 0, 0, 15220, + 15230, 3, 2368, 1184, 0, 15221, 15230, 5, 1045, 0, 0, 15222, 15230, 5, + 327, 0, 0, 15223, 15230, 5, 1010, 0, 0, 15224, 15225, 5, 155, 0, 0, 15225, + 15230, 3, 2368, 1184, 0, 15226, 15230, 5, 993, 0, 0, 15227, 15230, 5, 1215, + 0, 0, 15228, 15230, 5, 1060, 0, 0, 15229, 15206, 1, 0, 0, 0, 15229, 15213, + 1, 0, 0, 0, 15229, 15216, 1, 0, 0, 0, 15229, 15218, 1, 0, 0, 0, 15229, + 15219, 1, 0, 0, 0, 15229, 15221, 1, 0, 0, 0, 15229, 15222, 1, 0, 0, 0, + 15229, 15223, 1, 0, 0, 0, 15229, 15224, 1, 0, 0, 0, 15229, 15226, 1, 0, + 0, 0, 15229, 15227, 1, 0, 0, 0, 15229, 15228, 1, 0, 0, 0, 15230, 1689, + 1, 0, 0, 0, 15231, 15236, 3, 2310, 1155, 0, 15232, 15233, 3, 2346, 1173, + 0, 15233, 15234, 5, 2247, 0, 0, 15234, 15235, 3, 1682, 841, 0, 15235, 15237, + 1, 0, 0, 0, 15236, 15232, 1, 0, 0, 0, 15236, 15237, 1, 0, 0, 0, 15237, + 15239, 1, 0, 0, 0, 15238, 15240, 7, 62, 0, 0, 15239, 15238, 1, 0, 0, 0, + 15239, 15240, 1, 0, 0, 0, 15240, 15242, 1, 0, 0, 0, 15241, 15243, 3, 1692, + 846, 0, 15242, 15241, 1, 0, 0, 0, 15242, 15243, 1, 0, 0, 0, 15243, 15245, + 1, 0, 0, 0, 15244, 15246, 5, 2168, 0, 0, 15245, 15244, 1, 0, 0, 0, 15245, + 15246, 1, 0, 0, 0, 15246, 15248, 1, 0, 0, 0, 15247, 15249, 3, 1694, 847, + 0, 15248, 15247, 1, 0, 0, 0, 15248, 15249, 1, 0, 0, 0, 15249, 15258, 1, + 0, 0, 0, 15250, 15251, 5, 2087, 0, 0, 15251, 15256, 5, 106, 0, 0, 15252, + 15253, 5, 315, 0, 0, 15253, 15257, 5, 438, 0, 0, 15254, 15255, 5, 438, + 0, 0, 15255, 15257, 3, 1468, 734, 0, 15256, 15252, 1, 0, 0, 0, 15256, 15254, + 1, 0, 0, 0, 15257, 15259, 1, 0, 0, 0, 15258, 15250, 1, 0, 0, 0, 15258, + 15259, 1, 0, 0, 0, 15259, 15269, 1, 0, 0, 0, 15260, 15261, 5, 2087, 0, + 0, 15261, 15262, 5, 108, 0, 0, 15262, 15267, 5, 2188, 0, 0, 15263, 15264, + 7, 182, 0, 0, 15264, 15268, 5, 438, 0, 0, 15265, 15266, 5, 438, 0, 0, 15266, + 15268, 3, 1468, 734, 0, 15267, 15263, 1, 0, 0, 0, 15267, 15265, 1, 0, 0, + 0, 15268, 15270, 1, 0, 0, 0, 15269, 15260, 1, 0, 0, 0, 15269, 15270, 1, + 0, 0, 0, 15270, 15274, 1, 0, 0, 0, 15271, 15273, 3, 842, 421, 0, 15272, + 15271, 1, 0, 0, 0, 15273, 15276, 1, 0, 0, 0, 15274, 15272, 1, 0, 0, 0, + 15274, 15275, 1, 0, 0, 0, 15275, 1691, 1, 0, 0, 0, 15276, 15274, 1, 0, + 0, 0, 15277, 15285, 5, 584, 0, 0, 15278, 15286, 5, 43, 0, 0, 15279, 15280, + 5, 151, 0, 0, 15280, 15283, 5, 363, 0, 0, 15281, 15282, 5, 1175, 0, 0, + 15282, 15284, 5, 1145, 0, 0, 15283, 15281, 1, 0, 0, 0, 15283, 15284, 1, + 0, 0, 0, 15284, 15286, 1, 0, 0, 0, 15285, 15278, 1, 0, 0, 0, 15285, 15279, + 1, 0, 0, 0, 15285, 15286, 1, 0, 0, 0, 15286, 15287, 1, 0, 0, 0, 15287, + 15288, 5, 66, 0, 0, 15288, 15298, 5, 630, 0, 0, 15289, 15294, 5, 2376, + 0, 0, 15290, 15293, 3, 326, 163, 0, 15291, 15293, 3, 324, 162, 0, 15292, + 15290, 1, 0, 0, 0, 15292, 15291, 1, 0, 0, 0, 15293, 15296, 1, 0, 0, 0, + 15294, 15292, 1, 0, 0, 0, 15294, 15295, 1, 0, 0, 0, 15295, 15297, 1, 0, + 0, 0, 15296, 15294, 1, 0, 0, 0, 15297, 15299, 5, 2377, 0, 0, 15298, 15289, + 1, 0, 0, 0, 15298, 15299, 1, 0, 0, 0, 15299, 1693, 1, 0, 0, 0, 15300, 15301, + 5, 477, 0, 0, 15301, 15306, 5, 2129, 0, 0, 15302, 15303, 7, 182, 0, 0, + 15303, 15307, 5, 438, 0, 0, 15304, 15305, 5, 438, 0, 0, 15305, 15307, 3, + 1468, 734, 0, 15306, 15302, 1, 0, 0, 0, 15306, 15304, 1, 0, 0, 0, 15307, + 1695, 1, 0, 0, 0, 15308, 15309, 5, 1256, 0, 0, 15309, 15310, 3, 1704, 852, + 0, 15310, 1697, 1, 0, 0, 0, 15311, 15312, 5, 942, 0, 0, 15312, 15315, 5, + 1976, 0, 0, 15313, 15316, 3, 1700, 850, 0, 15314, 15316, 5, 225, 0, 0, + 15315, 15313, 1, 0, 0, 0, 15315, 15314, 1, 0, 0, 0, 15316, 15318, 1, 0, + 0, 0, 15317, 15319, 3, 1702, 851, 0, 15318, 15317, 1, 0, 0, 0, 15318, 15319, + 1, 0, 0, 0, 15319, 15321, 1, 0, 0, 0, 15320, 15322, 7, 183, 0, 0, 15321, + 15320, 1, 0, 0, 0, 15321, 15322, 1, 0, 0, 0, 15322, 15323, 1, 0, 0, 0, + 15323, 15324, 5, 1656, 0, 0, 15324, 15325, 5, 66, 0, 0, 15325, 15339, 3, + 2312, 1156, 0, 15326, 15333, 5, 2376, 0, 0, 15327, 15328, 5, 2376, 0, 0, + 15328, 15329, 3, 1056, 528, 0, 15329, 15330, 5, 2377, 0, 0, 15330, 15334, + 1, 0, 0, 0, 15331, 15334, 3, 1196, 598, 0, 15332, 15334, 3, 1670, 835, + 0, 15333, 15327, 1, 0, 0, 0, 15333, 15331, 1, 0, 0, 0, 15333, 15332, 1, + 0, 0, 0, 15334, 15335, 1, 0, 0, 0, 15335, 15333, 1, 0, 0, 0, 15335, 15336, + 1, 0, 0, 0, 15336, 15337, 1, 0, 0, 0, 15337, 15338, 5, 2377, 0, 0, 15338, + 15340, 1, 0, 0, 0, 15339, 15326, 1, 0, 0, 0, 15339, 15340, 1, 0, 0, 0, + 15340, 15346, 1, 0, 0, 0, 15341, 15343, 5, 1487, 0, 0, 15342, 15344, 5, + 66, 0, 0, 15343, 15342, 1, 0, 0, 0, 15343, 15344, 1, 0, 0, 0, 15344, 15345, + 1, 0, 0, 0, 15345, 15347, 7, 178, 0, 0, 15346, 15341, 1, 0, 0, 0, 15346, + 15347, 1, 0, 0, 0, 15347, 1699, 1, 0, 0, 0, 15348, 15349, 3, 2382, 1191, + 0, 15349, 1701, 1, 0, 0, 0, 15350, 15352, 5, 441, 0, 0, 15351, 15350, 1, + 0, 0, 0, 15351, 15352, 1, 0, 0, 0, 15352, 15353, 1, 0, 0, 0, 15353, 15354, + 5, 723, 0, 0, 15354, 15356, 5, 1163, 0, 0, 15355, 15357, 5, 2053, 0, 0, + 15356, 15355, 1, 0, 0, 0, 15356, 15357, 1, 0, 0, 0, 15357, 15358, 1, 0, + 0, 0, 15358, 15359, 5, 2376, 0, 0, 15359, 15360, 3, 2286, 1143, 0, 15360, + 15361, 5, 2377, 0, 0, 15361, 15370, 1, 0, 0, 0, 15362, 15364, 5, 1121, + 0, 0, 15363, 15362, 1, 0, 0, 0, 15363, 15364, 1, 0, 0, 0, 15364, 15365, + 1, 0, 0, 0, 15365, 15366, 5, 1673, 0, 0, 15366, 15367, 5, 79, 0, 0, 15367, + 15368, 5, 37, 0, 0, 15368, 15370, 5, 783, 0, 0, 15369, 15351, 1, 0, 0, + 0, 15369, 15363, 1, 0, 0, 0, 15370, 1703, 1, 0, 0, 0, 15371, 15374, 3, + 2382, 1191, 0, 15372, 15374, 5, 2373, 0, 0, 15373, 15371, 1, 0, 0, 0, 15373, + 15372, 1, 0, 0, 0, 15374, 1705, 1, 0, 0, 0, 15375, 15376, 5, 1682, 0, 0, + 15376, 15379, 5, 819, 0, 0, 15377, 15380, 3, 1294, 647, 0, 15378, 15380, + 3, 1296, 648, 0, 15379, 15377, 1, 0, 0, 0, 15379, 15378, 1, 0, 0, 0, 15380, + 1707, 1, 0, 0, 0, 15381, 15382, 3, 2382, 1191, 0, 15382, 1709, 1, 0, 0, + 0, 15383, 15384, 5, 222, 0, 0, 15384, 15385, 3, 2382, 1191, 0, 15385, 15386, + 3, 1702, 851, 0, 15386, 1711, 1, 0, 0, 0, 15387, 15388, 5, 20, 0, 0, 15388, + 15396, 5, 2376, 0, 0, 15389, 15391, 3, 848, 424, 0, 15390, 15389, 1, 0, + 0, 0, 15391, 15394, 1, 0, 0, 0, 15392, 15390, 1, 0, 0, 0, 15392, 15393, + 1, 0, 0, 0, 15393, 15397, 1, 0, 0, 0, 15394, 15392, 1, 0, 0, 0, 15395, + 15397, 3, 846, 423, 0, 15396, 15392, 1, 0, 0, 0, 15396, 15395, 1, 0, 0, + 0, 15397, 15398, 1, 0, 0, 0, 15398, 15444, 5, 2377, 0, 0, 15399, 15407, + 5, 20, 0, 0, 15400, 15402, 3, 848, 424, 0, 15401, 15400, 1, 0, 0, 0, 15402, + 15405, 1, 0, 0, 0, 15403, 15401, 1, 0, 0, 0, 15403, 15404, 1, 0, 0, 0, + 15404, 15408, 1, 0, 0, 0, 15405, 15403, 1, 0, 0, 0, 15406, 15408, 3, 846, + 423, 0, 15407, 15403, 1, 0, 0, 0, 15407, 15406, 1, 0, 0, 0, 15408, 15444, + 1, 0, 0, 0, 15409, 15426, 5, 909, 0, 0, 15410, 15411, 5, 267, 0, 0, 15411, + 15427, 3, 2282, 1141, 0, 15412, 15413, 5, 1355, 0, 0, 15413, 15427, 5, + 753, 0, 0, 15414, 15415, 5, 2068, 0, 0, 15415, 15416, 5, 2376, 0, 0, 15416, + 15421, 3, 2310, 1155, 0, 15417, 15418, 5, 2382, 0, 0, 15418, 15420, 3, + 2310, 1155, 0, 15419, 15417, 1, 0, 0, 0, 15420, 15423, 1, 0, 0, 0, 15421, + 15419, 1, 0, 0, 0, 15421, 15422, 1, 0, 0, 0, 15422, 15424, 1, 0, 0, 0, + 15423, 15421, 1, 0, 0, 0, 15424, 15425, 5, 2377, 0, 0, 15425, 15427, 1, + 0, 0, 0, 15426, 15410, 1, 0, 0, 0, 15426, 15412, 1, 0, 0, 0, 15426, 15414, + 1, 0, 0, 0, 15427, 15428, 1, 0, 0, 0, 15428, 15430, 3, 850, 425, 0, 15429, + 15431, 5, 168, 0, 0, 15430, 15429, 1, 0, 0, 0, 15430, 15431, 1, 0, 0, 0, + 15431, 15444, 1, 0, 0, 0, 15432, 15433, 5, 1460, 0, 0, 15433, 15434, 5, + 267, 0, 0, 15434, 15435, 3, 1714, 857, 0, 15435, 15436, 5, 2029, 0, 0, + 15436, 15437, 3, 1716, 858, 0, 15437, 15444, 1, 0, 0, 0, 15438, 15440, + 3, 1718, 859, 0, 15439, 15438, 1, 0, 0, 0, 15440, 15441, 1, 0, 0, 0, 15441, + 15439, 1, 0, 0, 0, 15441, 15442, 1, 0, 0, 0, 15442, 15444, 1, 0, 0, 0, + 15443, 15387, 1, 0, 0, 0, 15443, 15399, 1, 0, 0, 0, 15443, 15409, 1, 0, + 0, 0, 15443, 15432, 1, 0, 0, 0, 15443, 15439, 1, 0, 0, 0, 15444, 1713, + 1, 0, 0, 0, 15445, 15446, 3, 2282, 1141, 0, 15446, 1715, 1, 0, 0, 0, 15447, + 15448, 3, 2282, 1141, 0, 15448, 1717, 1, 0, 0, 0, 15449, 15450, 5, 425, + 0, 0, 15450, 15451, 3, 1720, 860, 0, 15451, 1719, 1, 0, 0, 0, 15452, 15453, + 5, 1355, 0, 0, 15453, 15467, 5, 753, 0, 0, 15454, 15455, 5, 2068, 0, 0, + 15455, 15456, 5, 2376, 0, 0, 15456, 15461, 3, 2310, 1155, 0, 15457, 15458, + 5, 2382, 0, 0, 15458, 15460, 3, 2310, 1155, 0, 15459, 15457, 1, 0, 0, 0, + 15460, 15463, 1, 0, 0, 0, 15461, 15459, 1, 0, 0, 0, 15461, 15462, 1, 0, + 0, 0, 15462, 15464, 1, 0, 0, 0, 15463, 15461, 1, 0, 0, 0, 15464, 15465, + 5, 2377, 0, 0, 15465, 15467, 1, 0, 0, 0, 15466, 15452, 1, 0, 0, 0, 15466, + 15454, 1, 0, 0, 0, 15467, 15469, 1, 0, 0, 0, 15468, 15470, 5, 168, 0, 0, + 15469, 15468, 1, 0, 0, 0, 15469, 15470, 1, 0, 0, 0, 15470, 15472, 1, 0, + 0, 0, 15471, 15473, 7, 148, 0, 0, 15472, 15471, 1, 0, 0, 0, 15472, 15473, + 1, 0, 0, 0, 15473, 15480, 1, 0, 0, 0, 15474, 15475, 5, 267, 0, 0, 15475, + 15477, 3, 2282, 1141, 0, 15476, 15478, 5, 168, 0, 0, 15477, 15476, 1, 0, + 0, 0, 15477, 15478, 1, 0, 0, 0, 15478, 15480, 1, 0, 0, 0, 15479, 15466, + 1, 0, 0, 0, 15479, 15474, 1, 0, 0, 0, 15480, 1721, 1, 0, 0, 0, 15481, 15484, + 5, 20, 0, 0, 15482, 15483, 5, 267, 0, 0, 15483, 15485, 3, 2282, 1141, 0, + 15484, 15482, 1, 0, 0, 0, 15484, 15485, 1, 0, 0, 0, 15485, 15486, 1, 0, + 0, 0, 15486, 15493, 3, 1724, 862, 0, 15487, 15490, 5, 2382, 0, 0, 15488, + 15489, 5, 267, 0, 0, 15489, 15491, 3, 2282, 1141, 0, 15490, 15488, 1, 0, + 0, 0, 15490, 15491, 1, 0, 0, 0, 15491, 15492, 1, 0, 0, 0, 15492, 15494, + 3, 1724, 862, 0, 15493, 15487, 1, 0, 0, 0, 15494, 15495, 1, 0, 0, 0, 15495, + 15493, 1, 0, 0, 0, 15495, 15496, 1, 0, 0, 0, 15496, 1723, 1, 0, 0, 0, 15497, + 15502, 3, 1742, 871, 0, 15498, 15502, 3, 1734, 867, 0, 15499, 15502, 3, + 1740, 870, 0, 15500, 15502, 3, 1726, 863, 0, 15501, 15497, 1, 0, 0, 0, + 15501, 15498, 1, 0, 0, 0, 15501, 15499, 1, 0, 0, 0, 15501, 15500, 1, 0, + 0, 0, 15502, 1725, 1, 0, 0, 0, 15503, 15504, 5, 186, 0, 0, 15504, 15505, + 5, 2376, 0, 0, 15505, 15506, 3, 2072, 1036, 0, 15506, 15508, 5, 2377, 0, + 0, 15507, 15509, 5, 398, 0, 0, 15508, 15507, 1, 0, 0, 0, 15508, 15509, + 1, 0, 0, 0, 15509, 1727, 1, 0, 0, 0, 15510, 15511, 5, 425, 0, 0, 15511, + 15512, 5, 267, 0, 0, 15512, 15513, 3, 2282, 1141, 0, 15513, 1729, 1, 0, + 0, 0, 15514, 15515, 5, 453, 0, 0, 15515, 15516, 5, 267, 0, 0, 15516, 15517, + 3, 2282, 1141, 0, 15517, 1731, 1, 0, 0, 0, 15518, 15519, 5, 398, 0, 0, + 15519, 15520, 5, 267, 0, 0, 15520, 15521, 3, 2282, 1141, 0, 15521, 1733, + 1, 0, 0, 0, 15522, 15523, 5, 562, 0, 0, 15523, 15524, 5, 753, 0, 0, 15524, + 15525, 3, 2330, 1165, 0, 15525, 15527, 3, 1736, 868, 0, 15526, 15528, 3, + 1738, 869, 0, 15527, 15526, 1, 0, 0, 0, 15527, 15528, 1, 0, 0, 0, 15528, + 1735, 1, 0, 0, 0, 15529, 15530, 5, 1429, 0, 0, 15530, 15532, 3, 2312, 1156, + 0, 15531, 15533, 3, 2330, 1165, 0, 15532, 15531, 1, 0, 0, 0, 15532, 15533, + 1, 0, 0, 0, 15533, 15541, 1, 0, 0, 0, 15534, 15535, 5, 1175, 0, 0, 15535, + 15539, 5, 376, 0, 0, 15536, 15540, 5, 168, 0, 0, 15537, 15538, 5, 1568, + 0, 0, 15538, 15540, 5, 1145, 0, 0, 15539, 15536, 1, 0, 0, 0, 15539, 15537, + 1, 0, 0, 0, 15540, 15542, 1, 0, 0, 0, 15541, 15534, 1, 0, 0, 0, 15541, + 15542, 1, 0, 0, 0, 15542, 1737, 1, 0, 0, 0, 15543, 15544, 5, 1175, 0, 0, + 15544, 15548, 5, 376, 0, 0, 15545, 15549, 5, 168, 0, 0, 15546, 15547, 5, + 1568, 0, 0, 15547, 15549, 5, 1145, 0, 0, 15548, 15545, 1, 0, 0, 0, 15548, + 15546, 1, 0, 0, 0, 15549, 1739, 1, 0, 0, 0, 15550, 15551, 5, 2068, 0, 0, + 15551, 15553, 3, 2330, 1165, 0, 15552, 15554, 3, 1594, 797, 0, 15553, 15552, + 1, 0, 0, 0, 15553, 15554, 1, 0, 0, 0, 15554, 1741, 1, 0, 0, 0, 15555, 15556, + 5, 1355, 0, 0, 15556, 15557, 5, 753, 0, 0, 15557, 15559, 3, 2330, 1165, + 0, 15558, 15560, 3, 1594, 797, 0, 15559, 15558, 1, 0, 0, 0, 15559, 15560, + 1, 0, 0, 0, 15560, 1743, 1, 0, 0, 0, 15561, 15562, 5, 356, 0, 0, 15562, + 15564, 3, 1762, 881, 0, 15563, 15561, 1, 0, 0, 0, 15563, 15564, 1, 0, 0, + 0, 15564, 15565, 1, 0, 0, 0, 15565, 15566, 5, 107, 0, 0, 15566, 15573, + 3, 1792, 896, 0, 15567, 15569, 5, 482, 0, 0, 15568, 15570, 3, 1840, 920, + 0, 15569, 15568, 1, 0, 0, 0, 15570, 15571, 1, 0, 0, 0, 15571, 15569, 1, + 0, 0, 0, 15571, 15572, 1, 0, 0, 0, 15572, 15574, 1, 0, 0, 0, 15573, 15567, + 1, 0, 0, 0, 15573, 15574, 1, 0, 0, 0, 15574, 15575, 1, 0, 0, 0, 15575, + 15576, 5, 459, 0, 0, 15576, 15577, 5, 2396, 0, 0, 15577, 1745, 1, 0, 0, + 0, 15578, 15579, 5, 85, 0, 0, 15579, 15580, 7, 84, 0, 0, 15580, 1747, 1, + 0, 0, 0, 15581, 15584, 5, 760, 0, 0, 15582, 15585, 3, 1750, 875, 0, 15583, + 15585, 3, 1752, 876, 0, 15584, 15582, 1, 0, 0, 0, 15584, 15583, 1, 0, 0, + 0, 15585, 1749, 1, 0, 0, 0, 15586, 15587, 5, 729, 0, 0, 15587, 15588, 5, + 926, 0, 0, 15588, 15589, 5, 2372, 0, 0, 15589, 1751, 1, 0, 0, 0, 15590, + 15593, 5, 199, 0, 0, 15591, 15592, 5, 926, 0, 0, 15592, 15594, 5, 2372, + 0, 0, 15593, 15591, 1, 0, 0, 0, 15593, 15594, 1, 0, 0, 0, 15594, 15595, + 1, 0, 0, 0, 15595, 15596, 5, 784, 0, 0, 15596, 15598, 3, 2376, 1188, 0, + 15597, 15599, 3, 1754, 877, 0, 15598, 15597, 1, 0, 0, 0, 15598, 15599, + 1, 0, 0, 0, 15599, 15602, 1, 0, 0, 0, 15600, 15601, 5, 2188, 0, 0, 15601, + 15603, 5, 277, 0, 0, 15602, 15600, 1, 0, 0, 0, 15602, 15603, 1, 0, 0, 0, + 15603, 15605, 1, 0, 0, 0, 15604, 15606, 3, 1756, 878, 0, 15605, 15604, + 1, 0, 0, 0, 15605, 15606, 1, 0, 0, 0, 15606, 1753, 1, 0, 0, 0, 15607, 15608, + 5, 33, 0, 0, 15608, 15609, 5, 680, 0, 0, 15609, 15610, 5, 2376, 0, 0, 15610, + 15611, 3, 2076, 1038, 0, 15611, 15612, 5, 2377, 0, 0, 15612, 1755, 1, 0, + 0, 0, 15613, 15614, 5, 1244, 0, 0, 15614, 15619, 5, 2376, 0, 0, 15615, + 15620, 3, 2076, 1038, 0, 15616, 15617, 5, 2369, 0, 0, 15617, 15618, 5, + 2369, 0, 0, 15618, 15620, 5, 2369, 0, 0, 15619, 15615, 1, 0, 0, 0, 15619, + 15616, 1, 0, 0, 0, 15620, 15621, 1, 0, 0, 0, 15621, 15622, 5, 2377, 0, + 0, 15622, 1757, 1, 0, 0, 0, 15623, 15627, 3, 2266, 1133, 0, 15624, 15626, + 7, 184, 0, 0, 15625, 15624, 1, 0, 0, 0, 15626, 15629, 1, 0, 0, 0, 15627, + 15625, 1, 0, 0, 0, 15627, 15628, 1, 0, 0, 0, 15628, 15631, 1, 0, 0, 0, + 15629, 15627, 1, 0, 0, 0, 15630, 15632, 3, 2344, 1172, 0, 15631, 15630, + 1, 0, 0, 0, 15631, 15632, 1, 0, 0, 0, 15632, 15634, 1, 0, 0, 0, 15633, + 15635, 3, 1760, 880, 0, 15634, 15633, 1, 0, 0, 0, 15634, 15635, 1, 0, 0, + 0, 15635, 1759, 1, 0, 0, 0, 15636, 15637, 7, 185, 0, 0, 15637, 15638, 3, + 2078, 1039, 0, 15638, 1761, 1, 0, 0, 0, 15639, 15641, 3, 1764, 882, 0, + 15640, 15639, 1, 0, 0, 0, 15641, 15642, 1, 0, 0, 0, 15642, 15640, 1, 0, + 0, 0, 15642, 15643, 1, 0, 0, 0, 15643, 1763, 1, 0, 0, 0, 15644, 15655, + 3, 1776, 888, 0, 15645, 15655, 3, 1774, 887, 0, 15646, 15655, 3, 1766, + 883, 0, 15647, 15655, 3, 1768, 884, 0, 15648, 15655, 3, 1770, 885, 0, 15649, + 15655, 3, 1784, 892, 0, 15650, 15655, 3, 156, 78, 0, 15651, 15655, 3, 158, + 79, 0, 15652, 15655, 3, 172, 86, 0, 15653, 15655, 3, 170, 85, 0, 15654, + 15644, 1, 0, 0, 0, 15654, 15645, 1, 0, 0, 0, 15654, 15646, 1, 0, 0, 0, + 15654, 15647, 1, 0, 0, 0, 15654, 15648, 1, 0, 0, 0, 15654, 15649, 1, 0, + 0, 0, 15654, 15650, 1, 0, 0, 0, 15654, 15651, 1, 0, 0, 0, 15654, 15652, + 1, 0, 0, 0, 15654, 15653, 1, 0, 0, 0, 15655, 1765, 1, 0, 0, 0, 15656, 15658, + 3, 2376, 1188, 0, 15657, 15659, 5, 265, 0, 0, 15658, 15657, 1, 0, 0, 0, + 15658, 15659, 1, 0, 0, 0, 15659, 15660, 1, 0, 0, 0, 15660, 15663, 3, 2344, + 1172, 0, 15661, 15662, 5, 1121, 0, 0, 15662, 15664, 5, 1145, 0, 0, 15663, + 15661, 1, 0, 0, 0, 15663, 15664, 1, 0, 0, 0, 15664, 15666, 1, 0, 0, 0, + 15665, 15667, 3, 1760, 880, 0, 15666, 15665, 1, 0, 0, 0, 15666, 15667, + 1, 0, 0, 0, 15667, 15668, 1, 0, 0, 0, 15668, 15669, 5, 2396, 0, 0, 15669, + 1767, 1, 0, 0, 0, 15670, 15671, 5, 1678, 0, 0, 15671, 15672, 3, 2376, 1188, + 0, 15672, 15673, 5, 723, 0, 0, 15673, 15679, 3, 2344, 1172, 0, 15674, 15675, + 5, 1399, 0, 0, 15675, 15676, 3, 2078, 1039, 0, 15676, 15677, 5, 2368, 0, + 0, 15677, 15678, 3, 2078, 1039, 0, 15678, 15680, 1, 0, 0, 0, 15679, 15674, + 1, 0, 0, 0, 15679, 15680, 1, 0, 0, 0, 15680, 15683, 1, 0, 0, 0, 15681, + 15682, 5, 1121, 0, 0, 15682, 15684, 5, 1145, 0, 0, 15683, 15681, 1, 0, + 0, 0, 15683, 15684, 1, 0, 0, 0, 15684, 15685, 1, 0, 0, 0, 15685, 15686, + 5, 2396, 0, 0, 15686, 1769, 1, 0, 0, 0, 15687, 15688, 5, 322, 0, 0, 15688, + 15700, 3, 2376, 1188, 0, 15689, 15690, 5, 2376, 0, 0, 15690, 15695, 3, + 1772, 886, 0, 15691, 15692, 5, 2382, 0, 0, 15692, 15694, 3, 1772, 886, + 0, 15693, 15691, 1, 0, 0, 0, 15694, 15697, 1, 0, 0, 0, 15695, 15693, 1, + 0, 0, 0, 15695, 15696, 1, 0, 0, 0, 15696, 15698, 1, 0, 0, 0, 15697, 15695, + 1, 0, 0, 0, 15698, 15699, 5, 2377, 0, 0, 15699, 15701, 1, 0, 0, 0, 15700, + 15689, 1, 0, 0, 0, 15700, 15701, 1, 0, 0, 0, 15701, 15704, 1, 0, 0, 0, + 15702, 15703, 5, 1487, 0, 0, 15703, 15705, 3, 2344, 1172, 0, 15704, 15702, + 1, 0, 0, 0, 15704, 15705, 1, 0, 0, 0, 15705, 15708, 1, 0, 0, 0, 15706, + 15707, 5, 723, 0, 0, 15707, 15709, 3, 1882, 941, 0, 15708, 15706, 1, 0, + 0, 0, 15708, 15709, 1, 0, 0, 0, 15709, 15710, 1, 0, 0, 0, 15710, 15711, + 5, 2396, 0, 0, 15711, 1771, 1, 0, 0, 0, 15712, 15717, 3, 2266, 1133, 0, + 15713, 15715, 5, 680, 0, 0, 15714, 15713, 1, 0, 0, 0, 15714, 15715, 1, + 0, 0, 0, 15715, 15716, 1, 0, 0, 0, 15716, 15718, 3, 2344, 1172, 0, 15717, + 15714, 1, 0, 0, 0, 15717, 15718, 1, 0, 0, 0, 15718, 15720, 1, 0, 0, 0, + 15719, 15721, 3, 1760, 880, 0, 15720, 15719, 1, 0, 0, 0, 15720, 15721, + 1, 0, 0, 0, 15721, 1773, 1, 0, 0, 0, 15722, 15723, 3, 2376, 1188, 0, 15723, + 15724, 5, 482, 0, 0, 15724, 15725, 5, 2396, 0, 0, 15725, 1775, 1, 0, 0, + 0, 15726, 15757, 5, 1338, 0, 0, 15727, 15758, 5, 1557, 0, 0, 15728, 15758, + 5, 92, 0, 0, 15729, 15730, 5, 483, 0, 0, 15730, 15731, 5, 2376, 0, 0, 15731, + 15732, 3, 2290, 1145, 0, 15732, 15733, 5, 2382, 0, 0, 15733, 15734, 3, + 2370, 1185, 0, 15734, 15735, 5, 2377, 0, 0, 15735, 15758, 1, 0, 0, 0, 15736, + 15737, 5, 686, 0, 0, 15737, 15738, 5, 2376, 0, 0, 15738, 15739, 3, 2376, + 1188, 0, 15739, 15740, 5, 2382, 0, 0, 15740, 15741, 3, 2078, 1039, 0, 15741, + 15742, 5, 2377, 0, 0, 15742, 15758, 1, 0, 0, 0, 15743, 15744, 5, 1478, + 0, 0, 15744, 15747, 5, 2376, 0, 0, 15745, 15748, 3, 2376, 1188, 0, 15746, + 15748, 5, 363, 0, 0, 15747, 15745, 1, 0, 0, 0, 15747, 15746, 1, 0, 0, 0, + 15748, 15751, 1, 0, 0, 0, 15749, 15750, 5, 2382, 0, 0, 15750, 15752, 3, + 2376, 1188, 0, 15751, 15749, 1, 0, 0, 0, 15752, 15753, 1, 0, 0, 0, 15753, + 15751, 1, 0, 0, 0, 15753, 15754, 1, 0, 0, 0, 15754, 15755, 1, 0, 0, 0, + 15755, 15756, 5, 2377, 0, 0, 15756, 15758, 1, 0, 0, 0, 15757, 15727, 1, + 0, 0, 0, 15757, 15728, 1, 0, 0, 0, 15757, 15729, 1, 0, 0, 0, 15757, 15736, + 1, 0, 0, 0, 15757, 15743, 1, 0, 0, 0, 15758, 15759, 1, 0, 0, 0, 15759, + 15760, 5, 2396, 0, 0, 15760, 1777, 1, 0, 0, 0, 15761, 15762, 5, 1414, 0, + 0, 15762, 15763, 5, 2376, 0, 0, 15763, 15768, 3, 1780, 890, 0, 15764, 15765, + 5, 2382, 0, 0, 15765, 15767, 3, 1780, 890, 0, 15766, 15764, 1, 0, 0, 0, + 15767, 15770, 1, 0, 0, 0, 15768, 15766, 1, 0, 0, 0, 15768, 15769, 1, 0, + 0, 0, 15769, 15771, 1, 0, 0, 0, 15770, 15768, 1, 0, 0, 0, 15771, 15772, + 5, 2377, 0, 0, 15772, 1779, 1, 0, 0, 0, 15773, 15775, 3, 2310, 1155, 0, + 15774, 15776, 3, 2344, 1172, 0, 15775, 15774, 1, 0, 0, 0, 15775, 15776, + 1, 0, 0, 0, 15776, 15779, 1, 0, 0, 0, 15777, 15778, 5, 1121, 0, 0, 15778, + 15780, 5, 1145, 0, 0, 15779, 15777, 1, 0, 0, 0, 15779, 15780, 1, 0, 0, + 0, 15780, 15782, 1, 0, 0, 0, 15781, 15783, 3, 1760, 880, 0, 15782, 15781, + 1, 0, 0, 0, 15782, 15783, 1, 0, 0, 0, 15783, 1781, 1, 0, 0, 0, 15784, 15785, + 5, 1431, 0, 0, 15785, 15788, 5, 322, 0, 0, 15786, 15787, 5, 1487, 0, 0, + 15787, 15789, 3, 2344, 1172, 0, 15788, 15786, 1, 0, 0, 0, 15788, 15789, + 1, 0, 0, 0, 15789, 1783, 1, 0, 0, 0, 15790, 15791, 5, 2053, 0, 0, 15791, + 15792, 3, 2376, 1188, 0, 15792, 15797, 5, 723, 0, 0, 15793, 15798, 3, 1786, + 893, 0, 15794, 15798, 3, 1790, 895, 0, 15795, 15798, 3, 1778, 889, 0, 15796, + 15798, 3, 1782, 891, 0, 15797, 15793, 1, 0, 0, 0, 15797, 15794, 1, 0, 0, + 0, 15797, 15795, 1, 0, 0, 0, 15797, 15796, 1, 0, 0, 0, 15798, 15799, 1, + 0, 0, 0, 15799, 15800, 5, 2396, 0, 0, 15800, 1785, 1, 0, 0, 0, 15801, 15802, + 5, 1976, 0, 0, 15802, 15803, 5, 1163, 0, 0, 15803, 15805, 3, 2344, 1172, + 0, 15804, 15806, 3, 1788, 894, 0, 15805, 15804, 1, 0, 0, 0, 15805, 15806, + 1, 0, 0, 0, 15806, 15809, 1, 0, 0, 0, 15807, 15808, 5, 1121, 0, 0, 15808, + 15810, 5, 1145, 0, 0, 15809, 15807, 1, 0, 0, 0, 15809, 15810, 1, 0, 0, + 0, 15810, 1787, 1, 0, 0, 0, 15811, 15814, 5, 655, 0, 0, 15812, 15814, 5, + 659, 0, 0, 15813, 15811, 1, 0, 0, 0, 15813, 15812, 1, 0, 0, 0, 15814, 15815, + 1, 0, 0, 0, 15815, 15816, 5, 151, 0, 0, 15816, 15817, 3, 2344, 1172, 0, + 15817, 1789, 1, 0, 0, 0, 15818, 15822, 5, 2147, 0, 0, 15819, 15820, 5, + 2149, 0, 0, 15820, 15822, 5, 65, 0, 0, 15821, 15818, 1, 0, 0, 0, 15821, + 15819, 1, 0, 0, 0, 15822, 15823, 1, 0, 0, 0, 15823, 15824, 5, 2376, 0, + 0, 15824, 15825, 3, 2078, 1039, 0, 15825, 15826, 5, 2377, 0, 0, 15826, + 15827, 5, 1163, 0, 0, 15827, 15830, 3, 2344, 1172, 0, 15828, 15829, 5, + 1121, 0, 0, 15829, 15831, 5, 1145, 0, 0, 15830, 15828, 1, 0, 0, 0, 15830, + 15831, 1, 0, 0, 0, 15831, 1791, 1, 0, 0, 0, 15832, 15833, 3, 1796, 898, + 0, 15833, 15834, 7, 186, 0, 0, 15834, 15837, 1, 0, 0, 0, 15835, 15837, + 3, 1794, 897, 0, 15836, 15832, 1, 0, 0, 0, 15836, 15835, 1, 0, 0, 0, 15837, + 15838, 1, 0, 0, 0, 15838, 15836, 1, 0, 0, 0, 15838, 15839, 1, 0, 0, 0, + 15839, 1793, 1, 0, 0, 0, 15840, 15841, 5, 2394, 0, 0, 15841, 15842, 5, + 2394, 0, 0, 15842, 15843, 3, 2284, 1142, 0, 15843, 15844, 5, 2393, 0, 0, + 15844, 15845, 5, 2393, 0, 0, 15845, 1795, 1, 0, 0, 0, 15846, 15863, 3, + 1838, 919, 0, 15847, 15863, 3, 1844, 922, 0, 15848, 15863, 3, 1800, 900, + 0, 15849, 15863, 3, 1802, 901, 0, 15850, 15863, 3, 1804, 902, 0, 15851, + 15863, 3, 1806, 903, 0, 15852, 15863, 3, 1808, 904, 0, 15853, 15863, 3, + 1814, 907, 0, 15854, 15863, 3, 1818, 909, 0, 15855, 15863, 3, 1828, 914, + 0, 15856, 15863, 3, 1830, 915, 0, 15857, 15863, 3, 1832, 916, 0, 15858, + 15863, 3, 2114, 1057, 0, 15859, 15863, 3, 1846, 923, 0, 15860, 15863, 3, + 1836, 918, 0, 15861, 15863, 3, 1834, 917, 0, 15862, 15846, 1, 0, 0, 0, + 15862, 15847, 1, 0, 0, 0, 15862, 15848, 1, 0, 0, 0, 15862, 15849, 1, 0, + 0, 0, 15862, 15850, 1, 0, 0, 0, 15862, 15851, 1, 0, 0, 0, 15862, 15852, + 1, 0, 0, 0, 15862, 15853, 1, 0, 0, 0, 15862, 15854, 1, 0, 0, 0, 15862, + 15855, 1, 0, 0, 0, 15862, 15856, 1, 0, 0, 0, 15862, 15857, 1, 0, 0, 0, + 15862, 15858, 1, 0, 0, 0, 15862, 15859, 1, 0, 0, 0, 15862, 15860, 1, 0, + 0, 0, 15862, 15861, 1, 0, 0, 0, 15863, 1797, 1, 0, 0, 0, 15864, 15866, + 8, 187, 0, 0, 15865, 15864, 1, 0, 0, 0, 15866, 15867, 1, 0, 0, 0, 15867, + 15865, 1, 0, 0, 0, 15867, 15868, 1, 0, 0, 0, 15868, 1799, 1, 0, 0, 0, 15869, + 15872, 3, 2354, 1177, 0, 15870, 15872, 3, 2352, 1176, 0, 15871, 15869, + 1, 0, 0, 0, 15871, 15870, 1, 0, 0, 0, 15872, 15873, 1, 0, 0, 0, 15873, + 15874, 5, 2385, 0, 0, 15874, 15875, 3, 2078, 1039, 0, 15875, 1801, 1, 0, + 0, 0, 15876, 15878, 5, 278, 0, 0, 15877, 15879, 3, 2284, 1142, 0, 15878, + 15877, 1, 0, 0, 0, 15878, 15879, 1, 0, 0, 0, 15879, 15882, 1, 0, 0, 0, + 15880, 15881, 5, 2180, 0, 0, 15881, 15883, 3, 2072, 1036, 0, 15882, 15880, + 1, 0, 0, 0, 15882, 15883, 1, 0, 0, 0, 15883, 1803, 1, 0, 0, 0, 15884, 15886, + 5, 494, 0, 0, 15885, 15887, 3, 2284, 1142, 0, 15886, 15885, 1, 0, 0, 0, + 15886, 15887, 1, 0, 0, 0, 15887, 15890, 1, 0, 0, 0, 15888, 15889, 5, 2180, + 0, 0, 15889, 15891, 3, 2072, 1036, 0, 15890, 15888, 1, 0, 0, 0, 15890, + 15891, 1, 0, 0, 0, 15891, 1805, 1, 0, 0, 0, 15892, 15893, 5, 590, 0, 0, + 15893, 15894, 3, 2284, 1142, 0, 15894, 1807, 1, 0, 0, 0, 15895, 15896, + 5, 634, 0, 0, 15896, 15897, 3, 2072, 1036, 0, 15897, 15898, 5, 1989, 0, + 0, 15898, 15902, 3, 1792, 896, 0, 15899, 15901, 3, 1810, 905, 0, 15900, + 15899, 1, 0, 0, 0, 15901, 15904, 1, 0, 0, 0, 15902, 15900, 1, 0, 0, 0, + 15902, 15903, 1, 0, 0, 0, 15903, 15906, 1, 0, 0, 0, 15904, 15902, 1, 0, + 0, 0, 15905, 15907, 3, 1812, 906, 0, 15906, 15905, 1, 0, 0, 0, 15906, 15907, + 1, 0, 0, 0, 15907, 15908, 1, 0, 0, 0, 15908, 15909, 5, 459, 0, 0, 15909, + 15910, 5, 634, 0, 0, 15910, 1809, 1, 0, 0, 0, 15911, 15912, 5, 447, 0, + 0, 15912, 15913, 3, 2072, 1036, 0, 15913, 15914, 5, 1989, 0, 0, 15914, + 15915, 3, 1792, 896, 0, 15915, 1811, 1, 0, 0, 0, 15916, 15917, 5, 446, + 0, 0, 15917, 15918, 3, 1792, 896, 0, 15918, 1813, 1, 0, 0, 0, 15919, 15921, + 3, 1794, 897, 0, 15920, 15919, 1, 0, 0, 0, 15920, 15921, 1, 0, 0, 0, 15921, + 15926, 1, 0, 0, 0, 15922, 15923, 5, 2182, 0, 0, 15923, 15927, 3, 2072, + 1036, 0, 15924, 15925, 5, 564, 0, 0, 15925, 15927, 3, 1816, 908, 0, 15926, + 15922, 1, 0, 0, 0, 15926, 15924, 1, 0, 0, 0, 15926, 15927, 1, 0, 0, 0, + 15927, 15928, 1, 0, 0, 0, 15928, 15929, 5, 825, 0, 0, 15929, 15930, 3, + 1792, 896, 0, 15930, 15931, 5, 459, 0, 0, 15931, 15933, 5, 825, 0, 0, 15932, + 15934, 3, 2284, 1142, 0, 15933, 15932, 1, 0, 0, 0, 15933, 15934, 1, 0, + 0, 0, 15934, 1815, 1, 0, 0, 0, 15935, 15936, 3, 2300, 1150, 0, 15936, 15938, + 5, 680, 0, 0, 15937, 15939, 5, 1489, 0, 0, 15938, 15937, 1, 0, 0, 0, 15938, + 15939, 1, 0, 0, 0, 15939, 15940, 1, 0, 0, 0, 15940, 15941, 3, 1824, 912, + 0, 15941, 15942, 5, 2368, 0, 0, 15942, 15943, 3, 1826, 913, 0, 15943, 15961, + 1, 0, 0, 0, 15944, 15945, 3, 2304, 1152, 0, 15945, 15958, 5, 680, 0, 0, + 15946, 15952, 3, 2302, 1151, 0, 15947, 15949, 5, 2376, 0, 0, 15948, 15950, + 3, 2076, 1038, 0, 15949, 15948, 1, 0, 0, 0, 15949, 15950, 1, 0, 0, 0, 15950, + 15951, 1, 0, 0, 0, 15951, 15953, 5, 2377, 0, 0, 15952, 15947, 1, 0, 0, + 0, 15952, 15953, 1, 0, 0, 0, 15953, 15959, 1, 0, 0, 0, 15954, 15955, 5, + 2376, 0, 0, 15955, 15956, 3, 1882, 941, 0, 15956, 15957, 5, 2377, 0, 0, + 15957, 15959, 1, 0, 0, 0, 15958, 15946, 1, 0, 0, 0, 15958, 15954, 1, 0, + 0, 0, 15959, 15961, 1, 0, 0, 0, 15960, 15935, 1, 0, 0, 0, 15960, 15944, + 1, 0, 0, 0, 15961, 1817, 1, 0, 0, 0, 15962, 15963, 5, 559, 0, 0, 15963, + 15964, 3, 2300, 1150, 0, 15964, 15965, 5, 680, 0, 0, 15965, 15966, 3, 1820, + 910, 0, 15966, 15969, 3, 1846, 923, 0, 15967, 15968, 5, 1518, 0, 0, 15968, + 15970, 5, 484, 0, 0, 15969, 15967, 1, 0, 0, 0, 15969, 15970, 1, 0, 0, 0, + 15970, 1819, 1, 0, 0, 0, 15971, 15972, 3, 1824, 912, 0, 15972, 15973, 5, + 2368, 0, 0, 15973, 15974, 3, 1826, 913, 0, 15974, 15985, 1, 0, 0, 0, 15975, + 15976, 5, 676, 0, 0, 15976, 15977, 5, 1163, 0, 0, 15977, 15979, 3, 2306, + 1153, 0, 15978, 15980, 3, 1822, 911, 0, 15979, 15978, 1, 0, 0, 0, 15979, + 15980, 1, 0, 0, 0, 15980, 15985, 1, 0, 0, 0, 15981, 15982, 5, 2140, 0, + 0, 15982, 15983, 5, 1163, 0, 0, 15983, 15985, 3, 2300, 1150, 0, 15984, + 15971, 1, 0, 0, 0, 15984, 15975, 1, 0, 0, 0, 15984, 15981, 1, 0, 0, 0, + 15985, 1821, 1, 0, 0, 0, 15986, 15987, 5, 112, 0, 0, 15987, 15988, 3, 1824, + 912, 0, 15988, 15989, 5, 48, 0, 0, 15989, 15990, 3, 1826, 913, 0, 15990, + 1823, 1, 0, 0, 0, 15991, 15992, 3, 2100, 1050, 0, 15992, 1825, 1, 0, 0, + 0, 15993, 15994, 3, 2100, 1050, 0, 15994, 1827, 1, 0, 0, 0, 15995, 15996, + 5, 1145, 0, 0, 15996, 1829, 1, 0, 0, 0, 15997, 15999, 5, 1396, 0, 0, 15998, + 16000, 3, 2290, 1145, 0, 15999, 15998, 1, 0, 0, 0, 15999, 16000, 1, 0, + 0, 0, 16000, 1831, 1, 0, 0, 0, 16001, 16003, 5, 1487, 0, 0, 16002, 16004, + 3, 2078, 1039, 0, 16003, 16002, 1, 0, 0, 0, 16003, 16004, 1, 0, 0, 0, 16004, + 1833, 1, 0, 0, 0, 16005, 16007, 5, 162, 0, 0, 16006, 16005, 1, 0, 0, 0, + 16006, 16007, 1, 0, 0, 0, 16007, 16008, 1, 0, 0, 0, 16008, 16010, 3, 2260, + 1130, 0, 16009, 16011, 3, 2334, 1167, 0, 16010, 16009, 1, 0, 0, 0, 16010, + 16011, 1, 0, 0, 0, 16011, 16014, 1, 0, 0, 0, 16012, 16013, 5, 719, 0, 0, + 16013, 16015, 3, 2352, 1176, 0, 16014, 16012, 1, 0, 0, 0, 16014, 16015, + 1, 0, 0, 0, 16015, 1835, 1, 0, 0, 0, 16016, 16017, 5, 1301, 0, 0, 16017, + 16018, 5, 1507, 0, 0, 16018, 16019, 5, 2376, 0, 0, 16019, 16020, 3, 2078, + 1039, 0, 16020, 16021, 5, 2377, 0, 0, 16021, 1837, 1, 0, 0, 0, 16022, 16023, + 5, 107, 0, 0, 16023, 16030, 3, 1792, 896, 0, 16024, 16026, 5, 482, 0, 0, + 16025, 16027, 3, 1840, 920, 0, 16026, 16025, 1, 0, 0, 0, 16027, 16028, + 1, 0, 0, 0, 16028, 16026, 1, 0, 0, 0, 16028, 16029, 1, 0, 0, 0, 16029, + 16031, 1, 0, 0, 0, 16030, 16024, 1, 0, 0, 0, 16030, 16031, 1, 0, 0, 0, + 16031, 16032, 1, 0, 0, 0, 16032, 16034, 5, 459, 0, 0, 16033, 16035, 3, + 2284, 1142, 0, 16034, 16033, 1, 0, 0, 0, 16034, 16035, 1, 0, 0, 0, 16035, + 1839, 1, 0, 0, 0, 16036, 16037, 5, 2180, 0, 0, 16037, 16042, 3, 2290, 1145, + 0, 16038, 16039, 5, 1219, 0, 0, 16039, 16041, 3, 2290, 1145, 0, 16040, + 16038, 1, 0, 0, 0, 16041, 16044, 1, 0, 0, 0, 16042, 16040, 1, 0, 0, 0, + 16042, 16043, 1, 0, 0, 0, 16043, 16045, 1, 0, 0, 0, 16044, 16042, 1, 0, + 0, 0, 16045, 16046, 5, 1989, 0, 0, 16046, 16047, 3, 1792, 896, 0, 16047, + 1841, 1, 0, 0, 0, 16048, 16052, 5, 356, 0, 0, 16049, 16051, 3, 1764, 882, + 0, 16050, 16049, 1, 0, 0, 0, 16051, 16054, 1, 0, 0, 0, 16052, 16050, 1, + 0, 0, 0, 16052, 16053, 1, 0, 0, 0, 16053, 16056, 1, 0, 0, 0, 16054, 16052, + 1, 0, 0, 0, 16055, 16048, 1, 0, 0, 0, 16055, 16056, 1, 0, 0, 0, 16056, + 16057, 1, 0, 0, 0, 16057, 16058, 3, 1838, 919, 0, 16058, 1843, 1, 0, 0, + 0, 16059, 16061, 5, 356, 0, 0, 16060, 16059, 1, 0, 0, 0, 16060, 16061, + 1, 0, 0, 0, 16061, 16063, 1, 0, 0, 0, 16062, 16064, 3, 1764, 882, 0, 16063, + 16062, 1, 0, 0, 0, 16064, 16065, 1, 0, 0, 0, 16065, 16063, 1, 0, 0, 0, + 16065, 16066, 1, 0, 0, 0, 16066, 16067, 1, 0, 0, 0, 16067, 16068, 3, 1838, + 919, 0, 16068, 1845, 1, 0, 0, 0, 16069, 16074, 3, 1848, 924, 0, 16070, + 16074, 3, 1852, 926, 0, 16071, 16074, 3, 1854, 927, 0, 16072, 16074, 3, + 1864, 932, 0, 16073, 16069, 1, 0, 0, 0, 16073, 16070, 1, 0, 0, 0, 16073, + 16071, 1, 0, 0, 0, 16073, 16072, 1, 0, 0, 0, 16074, 1847, 1, 0, 0, 0, 16075, + 16076, 5, 489, 0, 0, 16076, 16077, 5, 640, 0, 0, 16077, 16087, 3, 2078, + 1039, 0, 16078, 16080, 3, 2244, 1122, 0, 16079, 16081, 3, 2194, 1097, 0, + 16080, 16079, 1, 0, 0, 0, 16080, 16081, 1, 0, 0, 0, 16081, 16088, 1, 0, + 0, 0, 16082, 16084, 3, 2194, 1097, 0, 16083, 16085, 3, 1850, 925, 0, 16084, + 16083, 1, 0, 0, 0, 16084, 16085, 1, 0, 0, 0, 16085, 16088, 1, 0, 0, 0, + 16086, 16088, 3, 1850, 925, 0, 16087, 16078, 1, 0, 0, 0, 16087, 16082, + 1, 0, 0, 0, 16087, 16086, 1, 0, 0, 0, 16087, 16088, 1, 0, 0, 0, 16088, + 1849, 1, 0, 0, 0, 16089, 16090, 7, 188, 0, 0, 16090, 16091, 3, 2244, 1122, + 0, 16091, 1851, 1, 0, 0, 0, 16092, 16100, 3, 2032, 1016, 0, 16093, 16100, + 3, 2044, 1022, 0, 16094, 16100, 3, 1882, 941, 0, 16095, 16100, 3, 2006, + 1003, 0, 16096, 16100, 3, 2012, 1006, 0, 16097, 16100, 3, 2014, 1007, 0, + 16098, 16100, 3, 1878, 939, 0, 16099, 16092, 1, 0, 0, 0, 16099, 16093, + 1, 0, 0, 0, 16099, 16094, 1, 0, 0, 0, 16099, 16095, 1, 0, 0, 0, 16099, + 16096, 1, 0, 0, 0, 16099, 16097, 1, 0, 0, 0, 16099, 16098, 1, 0, 0, 0, + 16100, 1853, 1, 0, 0, 0, 16101, 16106, 3, 1856, 928, 0, 16102, 16106, 3, + 1858, 929, 0, 16103, 16106, 3, 1860, 930, 0, 16104, 16106, 3, 1862, 931, + 0, 16105, 16101, 1, 0, 0, 0, 16105, 16102, 1, 0, 0, 0, 16105, 16103, 1, + 0, 0, 0, 16105, 16104, 1, 0, 0, 0, 16106, 1855, 1, 0, 0, 0, 16107, 16108, + 5, 204, 0, 0, 16108, 16109, 3, 2302, 1151, 0, 16109, 1857, 1, 0, 0, 0, + 16110, 16111, 5, 1180, 0, 0, 16111, 16117, 3, 2302, 1151, 0, 16112, 16114, + 5, 2376, 0, 0, 16113, 16115, 3, 2076, 1038, 0, 16114, 16113, 1, 0, 0, 0, + 16114, 16115, 1, 0, 0, 0, 16115, 16116, 1, 0, 0, 0, 16116, 16118, 5, 2377, + 0, 0, 16117, 16112, 1, 0, 0, 0, 16117, 16118, 1, 0, 0, 0, 16118, 1859, + 1, 0, 0, 0, 16119, 16120, 5, 533, 0, 0, 16120, 16148, 3, 2302, 1151, 0, + 16121, 16122, 5, 719, 0, 0, 16122, 16127, 3, 2298, 1149, 0, 16123, 16124, + 5, 2382, 0, 0, 16124, 16126, 3, 2298, 1149, 0, 16125, 16123, 1, 0, 0, 0, + 16126, 16129, 1, 0, 0, 0, 16127, 16125, 1, 0, 0, 0, 16127, 16128, 1, 0, + 0, 0, 16128, 16149, 1, 0, 0, 0, 16129, 16127, 1, 0, 0, 0, 16130, 16131, + 5, 150, 0, 0, 16131, 16132, 5, 219, 0, 0, 16132, 16133, 5, 719, 0, 0, 16133, + 16138, 3, 2298, 1149, 0, 16134, 16135, 5, 2382, 0, 0, 16135, 16137, 3, + 2298, 1149, 0, 16136, 16134, 1, 0, 0, 0, 16137, 16140, 1, 0, 0, 0, 16138, + 16136, 1, 0, 0, 0, 16138, 16139, 1, 0, 0, 0, 16139, 16146, 1, 0, 0, 0, + 16140, 16138, 1, 0, 0, 0, 16141, 16144, 5, 793, 0, 0, 16142, 16145, 3, + 2368, 1184, 0, 16143, 16145, 3, 2298, 1149, 0, 16144, 16142, 1, 0, 0, 0, + 16144, 16143, 1, 0, 0, 0, 16145, 16147, 1, 0, 0, 0, 16146, 16141, 1, 0, + 0, 0, 16146, 16147, 1, 0, 0, 0, 16147, 16149, 1, 0, 0, 0, 16148, 16121, + 1, 0, 0, 0, 16148, 16130, 1, 0, 0, 0, 16149, 1861, 1, 0, 0, 0, 16150, 16151, + 5, 1180, 0, 0, 16151, 16152, 3, 2298, 1149, 0, 16152, 16155, 5, 564, 0, + 0, 16153, 16156, 3, 1882, 941, 0, 16154, 16156, 3, 2078, 1039, 0, 16155, + 16153, 1, 0, 0, 0, 16155, 16154, 1, 0, 0, 0, 16156, 16158, 1, 0, 0, 0, + 16157, 16159, 3, 2194, 1097, 0, 16158, 16157, 1, 0, 0, 0, 16158, 16159, + 1, 0, 0, 0, 16159, 1863, 1, 0, 0, 0, 16160, 16166, 3, 1866, 933, 0, 16161, + 16166, 3, 1868, 934, 0, 16162, 16166, 3, 1870, 935, 0, 16163, 16166, 3, + 1874, 937, 0, 16164, 16166, 3, 1876, 938, 0, 16165, 16160, 1, 0, 0, 0, + 16165, 16161, 1, 0, 0, 0, 16165, 16162, 1, 0, 0, 0, 16165, 16163, 1, 0, + 0, 0, 16165, 16164, 1, 0, 0, 0, 16166, 1865, 1, 0, 0, 0, 16167, 16168, + 5, 1568, 0, 0, 16168, 16182, 5, 2035, 0, 0, 16169, 16170, 5, 1408, 0, 0, + 16170, 16183, 7, 11, 0, 0, 16171, 16172, 5, 725, 0, 0, 16172, 16176, 5, + 781, 0, 0, 16173, 16177, 5, 1556, 0, 0, 16174, 16175, 5, 1408, 0, 0, 16175, + 16177, 5, 228, 0, 0, 16176, 16173, 1, 0, 0, 0, 16176, 16174, 1, 0, 0, 0, + 16177, 16183, 1, 0, 0, 0, 16178, 16179, 5, 2125, 0, 0, 16179, 16180, 5, + 1497, 0, 0, 16180, 16181, 5, 1546, 0, 0, 16181, 16183, 3, 2254, 1127, 0, + 16182, 16169, 1, 0, 0, 0, 16182, 16171, 1, 0, 0, 0, 16182, 16178, 1, 0, + 0, 0, 16182, 16183, 1, 0, 0, 0, 16183, 16186, 1, 0, 0, 0, 16184, 16185, + 5, 926, 0, 0, 16185, 16187, 3, 2372, 1186, 0, 16186, 16184, 1, 0, 0, 0, + 16186, 16187, 1, 0, 0, 0, 16187, 1867, 1, 0, 0, 0, 16188, 16189, 5, 1568, + 0, 0, 16189, 16199, 7, 189, 0, 0, 16190, 16200, 5, 37, 0, 0, 16191, 16196, + 3, 2282, 1141, 0, 16192, 16193, 5, 2382, 0, 0, 16193, 16195, 3, 2282, 1141, + 0, 16194, 16192, 1, 0, 0, 0, 16195, 16198, 1, 0, 0, 0, 16196, 16194, 1, + 0, 0, 0, 16196, 16197, 1, 0, 0, 0, 16197, 16200, 1, 0, 0, 0, 16198, 16196, + 1, 0, 0, 0, 16199, 16190, 1, 0, 0, 0, 16199, 16191, 1, 0, 0, 0, 16200, + 16201, 1, 0, 0, 0, 16201, 16202, 7, 87, 0, 0, 16202, 1869, 1, 0, 0, 0, + 16203, 16205, 5, 227, 0, 0, 16204, 16206, 5, 2189, 0, 0, 16205, 16204, + 1, 0, 0, 0, 16205, 16206, 1, 0, 0, 0, 16206, 16223, 1, 0, 0, 0, 16207, + 16208, 5, 226, 0, 0, 16208, 16210, 5, 2372, 0, 0, 16209, 16211, 3, 1872, + 936, 0, 16210, 16209, 1, 0, 0, 0, 16210, 16211, 1, 0, 0, 0, 16211, 16224, + 1, 0, 0, 0, 16212, 16221, 5, 560, 0, 0, 16213, 16216, 5, 2372, 0, 0, 16214, + 16215, 5, 2382, 0, 0, 16215, 16217, 3, 2368, 1184, 0, 16216, 16214, 1, + 0, 0, 0, 16216, 16217, 1, 0, 0, 0, 16217, 16222, 1, 0, 0, 0, 16218, 16219, + 5, 289, 0, 0, 16219, 16222, 5, 2372, 0, 0, 16220, 16222, 5, 288, 0, 0, + 16221, 16213, 1, 0, 0, 0, 16221, 16218, 1, 0, 0, 0, 16221, 16220, 1, 0, + 0, 0, 16222, 16224, 1, 0, 0, 0, 16223, 16207, 1, 0, 0, 0, 16223, 16212, + 1, 0, 0, 0, 16223, 16224, 1, 0, 0, 0, 16224, 1871, 1, 0, 0, 0, 16225, 16227, + 5, 2192, 0, 0, 16226, 16228, 7, 0, 0, 0, 16227, 16226, 1, 0, 0, 0, 16227, + 16228, 1, 0, 0, 0, 16228, 16230, 1, 0, 0, 0, 16229, 16231, 7, 190, 0, 0, + 16230, 16229, 1, 0, 0, 0, 16230, 16231, 1, 0, 0, 0, 16231, 1873, 1, 0, + 0, 0, 16232, 16234, 5, 1497, 0, 0, 16233, 16235, 5, 2189, 0, 0, 16234, + 16233, 1, 0, 0, 0, 16234, 16235, 1, 0, 0, 0, 16235, 16243, 1, 0, 0, 0, + 16236, 16238, 5, 2029, 0, 0, 16237, 16239, 5, 1517, 0, 0, 16238, 16237, + 1, 0, 0, 0, 16238, 16239, 1, 0, 0, 0, 16239, 16240, 1, 0, 0, 0, 16240, + 16244, 3, 2252, 1126, 0, 16241, 16242, 5, 560, 0, 0, 16242, 16244, 3, 2372, + 1186, 0, 16243, 16236, 1, 0, 0, 0, 16243, 16241, 1, 0, 0, 0, 16243, 16244, + 1, 0, 0, 0, 16244, 1875, 1, 0, 0, 0, 16245, 16246, 5, 1517, 0, 0, 16246, + 16247, 3, 2252, 1126, 0, 16247, 1877, 1, 0, 0, 0, 16248, 16249, 5, 499, + 0, 0, 16249, 16254, 5, 1307, 0, 0, 16250, 16251, 5, 1568, 0, 0, 16251, + 16252, 5, 1633, 0, 0, 16252, 16253, 5, 2398, 0, 0, 16253, 16255, 3, 2372, + 1186, 0, 16254, 16250, 1, 0, 0, 0, 16254, 16255, 1, 0, 0, 0, 16255, 16258, + 1, 0, 0, 0, 16256, 16257, 5, 719, 0, 0, 16257, 16259, 3, 2312, 1156, 0, + 16258, 16256, 1, 0, 0, 0, 16258, 16259, 1, 0, 0, 0, 16259, 16260, 1, 0, + 0, 0, 16260, 16266, 5, 564, 0, 0, 16261, 16267, 3, 1882, 941, 0, 16262, + 16267, 3, 2006, 1003, 0, 16263, 16267, 3, 2012, 1006, 0, 16264, 16267, + 3, 2014, 1007, 0, 16265, 16267, 3, 2032, 1016, 0, 16266, 16261, 1, 0, 0, + 0, 16266, 16262, 1, 0, 0, 0, 16266, 16263, 1, 0, 0, 0, 16266, 16264, 1, + 0, 0, 0, 16266, 16265, 1, 0, 0, 0, 16267, 1879, 1, 0, 0, 0, 16268, 16269, + 3, 1892, 946, 0, 16269, 1881, 1, 0, 0, 0, 16270, 16277, 3, 1880, 940, 0, + 16271, 16276, 3, 2000, 1000, 0, 16272, 16276, 3, 1992, 996, 0, 16273, 16276, + 3, 1996, 998, 0, 16274, 16276, 3, 1998, 999, 0, 16275, 16271, 1, 0, 0, + 0, 16275, 16272, 1, 0, 0, 0, 16275, 16273, 1, 0, 0, 0, 16275, 16274, 1, + 0, 0, 0, 16276, 16279, 1, 0, 0, 0, 16277, 16275, 1, 0, 0, 0, 16277, 16278, + 1, 0, 0, 0, 16278, 1883, 1, 0, 0, 0, 16279, 16277, 1, 0, 0, 0, 16280, 16281, + 5, 2188, 0, 0, 16281, 16286, 3, 1886, 943, 0, 16282, 16283, 5, 2382, 0, + 0, 16283, 16285, 3, 1886, 943, 0, 16284, 16282, 1, 0, 0, 0, 16285, 16288, + 1, 0, 0, 0, 16286, 16284, 1, 0, 0, 0, 16286, 16287, 1, 0, 0, 0, 16287, + 1885, 1, 0, 0, 0, 16288, 16286, 1, 0, 0, 0, 16289, 16291, 3, 2276, 1138, + 0, 16290, 16292, 3, 2330, 1165, 0, 16291, 16290, 1, 0, 0, 0, 16291, 16292, + 1, 0, 0, 0, 16292, 16293, 1, 0, 0, 0, 16293, 16294, 5, 66, 0, 0, 16294, + 16295, 5, 2376, 0, 0, 16295, 16297, 3, 1892, 946, 0, 16296, 16298, 3, 1992, + 996, 0, 16297, 16296, 1, 0, 0, 0, 16297, 16298, 1, 0, 0, 0, 16298, 16299, + 1, 0, 0, 0, 16299, 16301, 5, 2377, 0, 0, 16300, 16302, 3, 1888, 944, 0, + 16301, 16300, 1, 0, 0, 0, 16301, 16302, 1, 0, 0, 0, 16302, 16304, 1, 0, + 0, 0, 16303, 16305, 3, 1890, 945, 0, 16304, 16303, 1, 0, 0, 0, 16304, 16305, + 1, 0, 0, 0, 16305, 1887, 1, 0, 0, 0, 16306, 16307, 5, 1536, 0, 0, 16307, + 16308, 7, 191, 0, 0, 16308, 16309, 5, 543, 0, 0, 16309, 16310, 5, 151, + 0, 0, 16310, 16312, 3, 2310, 1155, 0, 16311, 16313, 5, 67, 0, 0, 16312, + 16311, 1, 0, 0, 0, 16312, 16313, 1, 0, 0, 0, 16313, 16315, 1, 0, 0, 0, + 16314, 16316, 5, 385, 0, 0, 16315, 16314, 1, 0, 0, 0, 16315, 16316, 1, + 0, 0, 0, 16316, 16319, 1, 0, 0, 0, 16317, 16318, 5, 1146, 0, 0, 16318, + 16320, 5, 543, 0, 0, 16319, 16317, 1, 0, 0, 0, 16319, 16320, 1, 0, 0, 0, + 16320, 16323, 1, 0, 0, 0, 16321, 16322, 5, 1146, 0, 0, 16322, 16324, 5, + 762, 0, 0, 16323, 16321, 1, 0, 0, 0, 16323, 16324, 1, 0, 0, 0, 16324, 16343, + 1, 0, 0, 0, 16325, 16326, 5, 2382, 0, 0, 16326, 16328, 3, 2310, 1155, 0, + 16327, 16329, 5, 67, 0, 0, 16328, 16327, 1, 0, 0, 0, 16328, 16329, 1, 0, + 0, 0, 16329, 16331, 1, 0, 0, 0, 16330, 16332, 5, 385, 0, 0, 16331, 16330, + 1, 0, 0, 0, 16331, 16332, 1, 0, 0, 0, 16332, 16335, 1, 0, 0, 0, 16333, + 16334, 5, 1146, 0, 0, 16334, 16336, 5, 543, 0, 0, 16335, 16333, 1, 0, 0, + 0, 16335, 16336, 1, 0, 0, 0, 16336, 16339, 1, 0, 0, 0, 16337, 16338, 5, + 1146, 0, 0, 16338, 16340, 5, 762, 0, 0, 16339, 16337, 1, 0, 0, 0, 16339, + 16340, 1, 0, 0, 0, 16340, 16342, 1, 0, 0, 0, 16341, 16325, 1, 0, 0, 0, + 16342, 16345, 1, 0, 0, 0, 16343, 16341, 1, 0, 0, 0, 16343, 16344, 1, 0, + 0, 0, 16344, 16346, 1, 0, 0, 0, 16345, 16343, 1, 0, 0, 0, 16346, 16347, + 5, 1568, 0, 0, 16347, 16348, 3, 2310, 1155, 0, 16348, 1889, 1, 0, 0, 0, + 16349, 16350, 5, 327, 0, 0, 16350, 16351, 3, 2328, 1164, 0, 16351, 16352, + 5, 1568, 0, 0, 16352, 16353, 3, 2310, 1155, 0, 16353, 16354, 5, 2029, 0, + 0, 16354, 16355, 3, 2078, 1039, 0, 16355, 16356, 5, 363, 0, 0, 16356, 16357, + 3, 2078, 1039, 0, 16357, 1891, 1, 0, 0, 0, 16358, 16362, 3, 1894, 947, + 0, 16359, 16361, 3, 1896, 948, 0, 16360, 16359, 1, 0, 0, 0, 16361, 16364, + 1, 0, 0, 0, 16362, 16360, 1, 0, 0, 0, 16362, 16363, 1, 0, 0, 0, 16363, + 1893, 1, 0, 0, 0, 16364, 16362, 1, 0, 0, 0, 16365, 16371, 3, 1898, 949, + 0, 16366, 16367, 5, 2376, 0, 0, 16367, 16368, 3, 1892, 946, 0, 16368, 16369, + 5, 2377, 0, 0, 16369, 16371, 1, 0, 0, 0, 16370, 16365, 1, 0, 0, 0, 16370, + 16366, 1, 0, 0, 0, 16371, 1895, 1, 0, 0, 0, 16372, 16374, 5, 2067, 0, 0, + 16373, 16375, 5, 37, 0, 0, 16374, 16373, 1, 0, 0, 0, 16374, 16375, 1, 0, + 0, 0, 16375, 16379, 1, 0, 0, 0, 16376, 16379, 5, 716, 0, 0, 16377, 16379, + 5, 885, 0, 0, 16378, 16372, 1, 0, 0, 0, 16378, 16376, 1, 0, 0, 0, 16378, + 16377, 1, 0, 0, 0, 16379, 16380, 1, 0, 0, 0, 16380, 16381, 3, 1894, 947, + 0, 16381, 1897, 1, 0, 0, 0, 16382, 16384, 3, 1884, 942, 0, 16383, 16382, + 1, 0, 0, 0, 16383, 16384, 1, 0, 0, 0, 16384, 16385, 1, 0, 0, 0, 16385, + 16387, 5, 1548, 0, 0, 16386, 16388, 7, 192, 0, 0, 16387, 16386, 1, 0, 0, + 0, 16387, 16388, 1, 0, 0, 0, 16388, 16389, 1, 0, 0, 0, 16389, 16391, 3, + 1900, 950, 0, 16390, 16392, 3, 2244, 1122, 0, 16391, 16390, 1, 0, 0, 0, + 16391, 16392, 1, 0, 0, 0, 16392, 16393, 1, 0, 0, 0, 16393, 16395, 3, 1902, + 951, 0, 16394, 16396, 3, 2240, 1120, 0, 16395, 16394, 1, 0, 0, 0, 16395, + 16396, 1, 0, 0, 0, 16396, 16398, 1, 0, 0, 0, 16397, 16399, 3, 1946, 973, + 0, 16398, 16397, 1, 0, 0, 0, 16398, 16399, 1, 0, 0, 0, 16399, 16401, 1, + 0, 0, 0, 16400, 16402, 3, 1950, 975, 0, 16401, 16400, 1, 0, 0, 0, 16401, + 16402, 1, 0, 0, 0, 16402, 16404, 1, 0, 0, 0, 16403, 16405, 3, 1962, 981, + 0, 16404, 16403, 1, 0, 0, 0, 16404, 16405, 1, 0, 0, 0, 16405, 16407, 1, + 0, 0, 0, 16406, 16408, 3, 1992, 996, 0, 16407, 16406, 1, 0, 0, 0, 16407, + 16408, 1, 0, 0, 0, 16408, 16410, 1, 0, 0, 0, 16409, 16411, 3, 1998, 999, + 0, 16410, 16409, 1, 0, 0, 0, 16410, 16411, 1, 0, 0, 0, 16411, 1899, 1, + 0, 0, 0, 16412, 16422, 5, 2379, 0, 0, 16413, 16418, 3, 1904, 952, 0, 16414, + 16415, 5, 2382, 0, 0, 16415, 16417, 3, 1904, 952, 0, 16416, 16414, 1, 0, + 0, 0, 16417, 16420, 1, 0, 0, 0, 16418, 16416, 1, 0, 0, 0, 16418, 16419, + 1, 0, 0, 0, 16419, 16422, 1, 0, 0, 0, 16420, 16418, 1, 0, 0, 0, 16421, + 16412, 1, 0, 0, 0, 16421, 16413, 1, 0, 0, 0, 16422, 1901, 1, 0, 0, 0, 16423, + 16424, 5, 572, 0, 0, 16424, 16425, 3, 1908, 954, 0, 16425, 1903, 1, 0, + 0, 0, 16426, 16432, 3, 1906, 953, 0, 16427, 16429, 3, 2078, 1039, 0, 16428, + 16430, 3, 2236, 1118, 0, 16429, 16428, 1, 0, 0, 0, 16429, 16430, 1, 0, + 0, 0, 16430, 16432, 1, 0, 0, 0, 16431, 16426, 1, 0, 0, 0, 16431, 16427, + 1, 0, 0, 0, 16432, 1905, 1, 0, 0, 0, 16433, 16434, 3, 2312, 1156, 0, 16434, + 16435, 5, 2369, 0, 0, 16435, 16436, 5, 2379, 0, 0, 16436, 1907, 1, 0, 0, + 0, 16437, 16442, 3, 1910, 955, 0, 16438, 16439, 5, 2382, 0, 0, 16439, 16441, + 3, 1910, 955, 0, 16440, 16438, 1, 0, 0, 0, 16441, 16444, 1, 0, 0, 0, 16442, + 16440, 1, 0, 0, 0, 16442, 16443, 1, 0, 0, 0, 16443, 1909, 1, 0, 0, 0, 16444, + 16442, 1, 0, 0, 0, 16445, 16449, 3, 1912, 956, 0, 16446, 16448, 3, 1916, + 958, 0, 16447, 16446, 1, 0, 0, 0, 16448, 16451, 1, 0, 0, 0, 16449, 16447, + 1, 0, 0, 0, 16449, 16450, 1, 0, 0, 0, 16450, 16454, 1, 0, 0, 0, 16451, + 16449, 1, 0, 0, 0, 16452, 16455, 3, 1928, 964, 0, 16453, 16455, 3, 1940, + 970, 0, 16454, 16452, 1, 0, 0, 0, 16454, 16453, 1, 0, 0, 0, 16454, 16455, + 1, 0, 0, 0, 16455, 1911, 1, 0, 0, 0, 16456, 16460, 3, 1914, 957, 0, 16457, + 16459, 3, 1926, 963, 0, 16458, 16457, 1, 0, 0, 0, 16459, 16462, 1, 0, 0, + 0, 16460, 16458, 1, 0, 0, 0, 16460, 16461, 1, 0, 0, 0, 16461, 16465, 1, + 0, 0, 0, 16462, 16460, 1, 0, 0, 0, 16463, 16464, 4, 956, 10, 0, 16464, + 16466, 3, 2238, 1119, 0, 16465, 16463, 1, 0, 0, 0, 16465, 16466, 1, 0, + 0, 0, 16466, 1913, 1, 0, 0, 0, 16467, 16470, 3, 2062, 1031, 0, 16468, 16471, + 3, 1928, 964, 0, 16469, 16471, 3, 1940, 970, 0, 16470, 16468, 1, 0, 0, + 0, 16470, 16469, 1, 0, 0, 0, 16470, 16471, 1, 0, 0, 0, 16471, 16491, 1, + 0, 0, 0, 16472, 16473, 5, 2376, 0, 0, 16473, 16477, 3, 1910, 955, 0, 16474, + 16476, 3, 1896, 948, 0, 16475, 16474, 1, 0, 0, 0, 16476, 16479, 1, 0, 0, + 0, 16477, 16475, 1, 0, 0, 0, 16477, 16478, 1, 0, 0, 0, 16478, 16480, 1, + 0, 0, 0, 16479, 16477, 1, 0, 0, 0, 16480, 16483, 5, 2377, 0, 0, 16481, + 16484, 3, 1928, 964, 0, 16482, 16484, 3, 1940, 970, 0, 16483, 16481, 1, + 0, 0, 0, 16483, 16482, 1, 0, 0, 0, 16483, 16484, 1, 0, 0, 0, 16484, 16491, + 1, 0, 0, 0, 16485, 16486, 5, 1174, 0, 0, 16486, 16487, 5, 2376, 0, 0, 16487, + 16488, 3, 2062, 1031, 0, 16488, 16489, 5, 2377, 0, 0, 16489, 16491, 1, + 0, 0, 0, 16490, 16467, 1, 0, 0, 0, 16490, 16472, 1, 0, 0, 0, 16490, 16485, + 1, 0, 0, 0, 16491, 1915, 1, 0, 0, 0, 16492, 16494, 3, 1924, 962, 0, 16493, + 16492, 1, 0, 0, 0, 16493, 16494, 1, 0, 0, 0, 16494, 16496, 1, 0, 0, 0, + 16495, 16497, 7, 193, 0, 0, 16496, 16495, 1, 0, 0, 0, 16496, 16497, 1, + 0, 0, 0, 16497, 16500, 1, 0, 0, 0, 16498, 16501, 5, 691, 0, 0, 16499, 16501, + 3, 1922, 961, 0, 16500, 16498, 1, 0, 0, 0, 16500, 16499, 1, 0, 0, 0, 16500, + 16501, 1, 0, 0, 0, 16501, 16502, 1, 0, 0, 0, 16502, 16503, 5, 731, 0, 0, + 16503, 16505, 3, 1912, 956, 0, 16504, 16506, 3, 1924, 962, 0, 16505, 16504, + 1, 0, 0, 0, 16505, 16506, 1, 0, 0, 0, 16506, 16511, 1, 0, 0, 0, 16507, + 16510, 3, 1918, 959, 0, 16508, 16510, 3, 1920, 960, 0, 16509, 16507, 1, + 0, 0, 0, 16509, 16508, 1, 0, 0, 0, 16510, 16513, 1, 0, 0, 0, 16511, 16509, + 1, 0, 0, 0, 16511, 16512, 1, 0, 0, 0, 16512, 1917, 1, 0, 0, 0, 16513, 16511, + 1, 0, 0, 0, 16514, 16515, 5, 1175, 0, 0, 16515, 16516, 3, 2072, 1036, 0, + 16516, 1919, 1, 0, 0, 0, 16517, 16518, 5, 2129, 0, 0, 16518, 16519, 3, + 2330, 1165, 0, 16519, 1921, 1, 0, 0, 0, 16520, 16522, 7, 194, 0, 0, 16521, + 16523, 5, 1225, 0, 0, 16522, 16521, 1, 0, 0, 0, 16522, 16523, 1, 0, 0, + 0, 16523, 1923, 1, 0, 0, 0, 16524, 16525, 5, 1256, 0, 0, 16525, 16533, + 5, 151, 0, 0, 16526, 16529, 5, 2376, 0, 0, 16527, 16530, 3, 1892, 946, + 0, 16528, 16530, 3, 2076, 1038, 0, 16529, 16527, 1, 0, 0, 0, 16529, 16528, + 1, 0, 0, 0, 16529, 16530, 1, 0, 0, 0, 16530, 16531, 1, 0, 0, 0, 16531, + 16534, 5, 2377, 0, 0, 16532, 16534, 3, 2076, 1038, 0, 16533, 16526, 1, + 0, 0, 0, 16533, 16532, 1, 0, 0, 0, 16534, 1925, 1, 0, 0, 0, 16535, 16536, + 5, 2163, 0, 0, 16536, 16537, 5, 112, 0, 0, 16537, 16538, 7, 74, 0, 0, 16538, + 16544, 3, 2078, 1039, 0, 16539, 16540, 5, 66, 0, 0, 16540, 16541, 5, 1163, + 0, 0, 16541, 16542, 7, 195, 0, 0, 16542, 16544, 3, 2078, 1039, 0, 16543, + 16535, 1, 0, 0, 0, 16543, 16539, 1, 0, 0, 0, 16544, 1927, 1, 0, 0, 0, 16545, + 16547, 5, 1303, 0, 0, 16546, 16548, 5, 2230, 0, 0, 16547, 16546, 1, 0, + 0, 0, 16547, 16548, 1, 0, 0, 0, 16548, 16549, 1, 0, 0, 0, 16549, 16550, + 5, 2376, 0, 0, 16550, 16555, 3, 1930, 965, 0, 16551, 16552, 5, 2382, 0, + 0, 16552, 16554, 3, 1930, 965, 0, 16553, 16551, 1, 0, 0, 0, 16554, 16557, + 1, 0, 0, 0, 16555, 16553, 1, 0, 0, 0, 16555, 16556, 1, 0, 0, 0, 16556, + 16558, 1, 0, 0, 0, 16557, 16555, 1, 0, 0, 0, 16558, 16559, 3, 1932, 966, + 0, 16559, 16560, 3, 1934, 967, 0, 16560, 16561, 5, 2377, 0, 0, 16561, 1929, + 1, 0, 0, 0, 16562, 16563, 3, 2274, 1137, 0, 16563, 16564, 5, 2376, 0, 0, + 16564, 16565, 3, 2078, 1039, 0, 16565, 16567, 5, 2377, 0, 0, 16566, 16568, + 3, 2236, 1118, 0, 16567, 16566, 1, 0, 0, 0, 16567, 16568, 1, 0, 0, 0, 16568, + 1931, 1, 0, 0, 0, 16569, 16572, 5, 564, 0, 0, 16570, 16573, 3, 2310, 1155, + 0, 16571, 16573, 3, 2330, 1165, 0, 16572, 16570, 1, 0, 0, 0, 16572, 16571, + 1, 0, 0, 0, 16573, 1933, 1, 0, 0, 0, 16574, 16575, 5, 680, 0, 0, 16575, + 16593, 5, 2376, 0, 0, 16576, 16594, 3, 1892, 946, 0, 16577, 16582, 5, 53, + 0, 0, 16578, 16579, 5, 2382, 0, 0, 16579, 16581, 5, 53, 0, 0, 16580, 16578, + 1, 0, 0, 0, 16581, 16584, 1, 0, 0, 0, 16582, 16580, 1, 0, 0, 0, 16582, + 16583, 1, 0, 0, 0, 16583, 16594, 1, 0, 0, 0, 16584, 16582, 1, 0, 0, 0, + 16585, 16590, 3, 1936, 968, 0, 16586, 16587, 5, 2382, 0, 0, 16587, 16589, + 3, 1936, 968, 0, 16588, 16586, 1, 0, 0, 0, 16589, 16592, 1, 0, 0, 0, 16590, + 16588, 1, 0, 0, 0, 16590, 16591, 1, 0, 0, 0, 16591, 16594, 1, 0, 0, 0, + 16592, 16590, 1, 0, 0, 0, 16593, 16576, 1, 0, 0, 0, 16593, 16577, 1, 0, + 0, 0, 16593, 16585, 1, 0, 0, 0, 16594, 16595, 1, 0, 0, 0, 16595, 16596, + 5, 2377, 0, 0, 16596, 1935, 1, 0, 0, 0, 16597, 16599, 3, 1938, 969, 0, + 16598, 16600, 3, 2236, 1118, 0, 16599, 16598, 1, 0, 0, 0, 16599, 16600, + 1, 0, 0, 0, 16600, 1937, 1, 0, 0, 0, 16601, 16608, 3, 2078, 1039, 0, 16602, + 16604, 5, 2376, 0, 0, 16603, 16605, 3, 2076, 1038, 0, 16604, 16603, 1, + 0, 0, 0, 16604, 16605, 1, 0, 0, 0, 16605, 16606, 1, 0, 0, 0, 16606, 16608, + 5, 2377, 0, 0, 16607, 16601, 1, 0, 0, 0, 16607, 16602, 1, 0, 0, 0, 16608, + 1939, 1, 0, 0, 0, 16609, 16612, 5, 2079, 0, 0, 16610, 16611, 7, 196, 0, + 0, 16611, 16613, 5, 1146, 0, 0, 16612, 16610, 1, 0, 0, 0, 16612, 16613, + 1, 0, 0, 0, 16613, 16614, 1, 0, 0, 0, 16614, 16617, 5, 2376, 0, 0, 16615, + 16618, 3, 2310, 1155, 0, 16616, 16618, 3, 2330, 1165, 0, 16617, 16615, + 1, 0, 0, 0, 16617, 16616, 1, 0, 0, 0, 16618, 16619, 1, 0, 0, 0, 16619, + 16620, 3, 1932, 966, 0, 16620, 16621, 3, 1942, 971, 0, 16621, 16622, 5, + 2377, 0, 0, 16622, 1941, 1, 0, 0, 0, 16623, 16624, 5, 680, 0, 0, 16624, + 16625, 5, 2376, 0, 0, 16625, 16630, 3, 1944, 972, 0, 16626, 16627, 5, 2382, + 0, 0, 16627, 16629, 3, 1944, 972, 0, 16628, 16626, 1, 0, 0, 0, 16629, 16632, + 1, 0, 0, 0, 16630, 16628, 1, 0, 0, 0, 16630, 16631, 1, 0, 0, 0, 16631, + 16633, 1, 0, 0, 0, 16632, 16630, 1, 0, 0, 0, 16633, 16634, 5, 2377, 0, + 0, 16634, 1943, 1, 0, 0, 0, 16635, 16638, 3, 2310, 1155, 0, 16636, 16638, + 3, 2330, 1165, 0, 16637, 16635, 1, 0, 0, 0, 16637, 16636, 1, 0, 0, 0, 16638, + 16654, 1, 0, 0, 0, 16639, 16652, 5, 66, 0, 0, 16640, 16653, 3, 2364, 1182, + 0, 16641, 16642, 5, 2376, 0, 0, 16642, 16647, 3, 2364, 1182, 0, 16643, + 16644, 5, 2382, 0, 0, 16644, 16646, 3, 2364, 1182, 0, 16645, 16643, 1, + 0, 0, 0, 16646, 16649, 1, 0, 0, 0, 16647, 16645, 1, 0, 0, 0, 16647, 16648, + 1, 0, 0, 0, 16648, 16650, 1, 0, 0, 0, 16649, 16647, 1, 0, 0, 0, 16650, + 16651, 5, 2377, 0, 0, 16651, 16653, 1, 0, 0, 0, 16652, 16640, 1, 0, 0, + 0, 16652, 16641, 1, 0, 0, 0, 16653, 16655, 1, 0, 0, 0, 16654, 16639, 1, + 0, 0, 0, 16654, 16655, 1, 0, 0, 0, 16655, 1945, 1, 0, 0, 0, 16656, 16657, + 5, 261, 0, 0, 16657, 16659, 5, 151, 0, 0, 16658, 16660, 5, 1010, 0, 0, + 16659, 16658, 1, 0, 0, 0, 16659, 16660, 1, 0, 0, 0, 16660, 16661, 1, 0, + 0, 0, 16661, 16663, 3, 2072, 1036, 0, 16662, 16664, 3, 1948, 974, 0, 16663, + 16662, 1, 0, 0, 0, 16663, 16664, 1, 0, 0, 0, 16664, 16674, 1, 0, 0, 0, + 16665, 16666, 3, 1948, 974, 0, 16666, 16667, 5, 261, 0, 0, 16667, 16669, + 5, 151, 0, 0, 16668, 16670, 5, 1010, 0, 0, 16669, 16668, 1, 0, 0, 0, 16669, + 16670, 1, 0, 0, 0, 16670, 16671, 1, 0, 0, 0, 16671, 16672, 3, 2072, 1036, + 0, 16672, 16674, 1, 0, 0, 0, 16673, 16656, 1, 0, 0, 0, 16673, 16665, 1, + 0, 0, 0, 16674, 1947, 1, 0, 0, 0, 16675, 16676, 5, 1631, 0, 0, 16676, 16677, + 5, 2188, 0, 0, 16677, 16678, 3, 2072, 1036, 0, 16678, 1949, 1, 0, 0, 0, + 16679, 16680, 5, 593, 0, 0, 16680, 16681, 5, 151, 0, 0, 16681, 16686, 3, + 1952, 976, 0, 16682, 16683, 5, 2382, 0, 0, 16683, 16685, 3, 1952, 976, + 0, 16684, 16682, 1, 0, 0, 0, 16685, 16688, 1, 0, 0, 0, 16686, 16684, 1, + 0, 0, 0, 16686, 16687, 1, 0, 0, 0, 16687, 16690, 1, 0, 0, 0, 16688, 16686, + 1, 0, 0, 0, 16689, 16691, 3, 1960, 980, 0, 16690, 16689, 1, 0, 0, 0, 16690, + 16691, 1, 0, 0, 0, 16691, 16706, 1, 0, 0, 0, 16692, 16703, 3, 1960, 980, + 0, 16693, 16694, 5, 593, 0, 0, 16694, 16695, 5, 151, 0, 0, 16695, 16700, + 3, 1952, 976, 0, 16696, 16697, 5, 2382, 0, 0, 16697, 16699, 3, 1952, 976, + 0, 16698, 16696, 1, 0, 0, 0, 16699, 16702, 1, 0, 0, 0, 16700, 16698, 1, + 0, 0, 0, 16700, 16701, 1, 0, 0, 0, 16701, 16704, 1, 0, 0, 0, 16702, 16700, + 1, 0, 0, 0, 16703, 16693, 1, 0, 0, 0, 16703, 16704, 1, 0, 0, 0, 16704, + 16706, 1, 0, 0, 0, 16705, 16679, 1, 0, 0, 0, 16705, 16692, 1, 0, 0, 0, + 16706, 1951, 1, 0, 0, 0, 16707, 16711, 3, 1956, 978, 0, 16708, 16711, 3, + 1954, 977, 0, 16709, 16711, 3, 2078, 1039, 0, 16710, 16707, 1, 0, 0, 0, + 16710, 16708, 1, 0, 0, 0, 16710, 16709, 1, 0, 0, 0, 16711, 1953, 1, 0, + 0, 0, 16712, 16713, 7, 197, 0, 0, 16713, 16714, 5, 2376, 0, 0, 16714, 16719, + 3, 1958, 979, 0, 16715, 16716, 5, 2382, 0, 0, 16716, 16718, 3, 1958, 979, + 0, 16717, 16715, 1, 0, 0, 0, 16718, 16721, 1, 0, 0, 0, 16719, 16717, 1, + 0, 0, 0, 16719, 16720, 1, 0, 0, 0, 16720, 16722, 1, 0, 0, 0, 16721, 16719, + 1, 0, 0, 0, 16722, 16723, 5, 2377, 0, 0, 16723, 1955, 1, 0, 0, 0, 16724, + 16725, 5, 595, 0, 0, 16725, 16726, 5, 1569, 0, 0, 16726, 16727, 5, 2376, + 0, 0, 16727, 16732, 3, 1958, 979, 0, 16728, 16729, 5, 2382, 0, 0, 16729, + 16731, 3, 1958, 979, 0, 16730, 16728, 1, 0, 0, 0, 16731, 16734, 1, 0, 0, + 0, 16732, 16730, 1, 0, 0, 0, 16732, 16733, 1, 0, 0, 0, 16733, 16735, 1, + 0, 0, 0, 16734, 16732, 1, 0, 0, 0, 16735, 16736, 5, 2377, 0, 0, 16736, + 1957, 1, 0, 0, 0, 16737, 16745, 3, 1954, 977, 0, 16738, 16740, 5, 2376, + 0, 0, 16739, 16741, 3, 2076, 1038, 0, 16740, 16739, 1, 0, 0, 0, 16740, + 16741, 1, 0, 0, 0, 16741, 16742, 1, 0, 0, 0, 16742, 16745, 5, 2377, 0, + 0, 16743, 16745, 3, 2078, 1039, 0, 16744, 16737, 1, 0, 0, 0, 16744, 16738, + 1, 0, 0, 0, 16744, 16743, 1, 0, 0, 0, 16745, 1959, 1, 0, 0, 0, 16746, 16747, + 5, 606, 0, 0, 16747, 16748, 3, 2072, 1036, 0, 16748, 1961, 1, 0, 0, 0, + 16749, 16753, 5, 900, 0, 0, 16750, 16752, 3, 1964, 982, 0, 16751, 16750, + 1, 0, 0, 0, 16752, 16755, 1, 0, 0, 0, 16753, 16751, 1, 0, 0, 0, 16753, + 16754, 1, 0, 0, 0, 16754, 16757, 1, 0, 0, 0, 16755, 16753, 1, 0, 0, 0, + 16756, 16758, 3, 1966, 983, 0, 16757, 16756, 1, 0, 0, 0, 16757, 16758, + 1, 0, 0, 0, 16758, 16762, 1, 0, 0, 0, 16759, 16761, 3, 1968, 984, 0, 16760, + 16759, 1, 0, 0, 0, 16761, 16764, 1, 0, 0, 0, 16762, 16760, 1, 0, 0, 0, + 16762, 16763, 1, 0, 0, 0, 16763, 16765, 1, 0, 0, 0, 16764, 16762, 1, 0, + 0, 0, 16765, 16766, 3, 1970, 985, 0, 16766, 1963, 1, 0, 0, 0, 16767, 16768, + 7, 198, 0, 0, 16768, 16776, 5, 935, 0, 0, 16769, 16773, 5, 2068, 0, 0, + 16770, 16774, 5, 392, 0, 0, 16771, 16772, 5, 1591, 0, 0, 16772, 16774, + 5, 1428, 0, 0, 16773, 16770, 1, 0, 0, 0, 16773, 16771, 1, 0, 0, 0, 16774, + 16776, 1, 0, 0, 0, 16775, 16767, 1, 0, 0, 0, 16775, 16769, 1, 0, 0, 0, + 16776, 1965, 1, 0, 0, 0, 16777, 16778, 5, 1487, 0, 0, 16778, 16779, 7, + 199, 0, 0, 16779, 16780, 5, 1508, 0, 0, 16780, 1967, 1, 0, 0, 0, 16781, + 16782, 5, 1428, 0, 0, 16782, 16783, 3, 2268, 1134, 0, 16783, 16784, 5, + 1175, 0, 0, 16784, 16785, 5, 2376, 0, 0, 16785, 16786, 3, 1892, 946, 0, + 16786, 16787, 5, 2377, 0, 0, 16787, 16791, 3, 1972, 986, 0, 16788, 16790, + 3, 1964, 982, 0, 16789, 16788, 1, 0, 0, 0, 16790, 16793, 1, 0, 0, 0, 16791, + 16789, 1, 0, 0, 0, 16791, 16792, 1, 0, 0, 0, 16792, 1969, 1, 0, 0, 0, 16793, + 16791, 1, 0, 0, 0, 16794, 16795, 5, 832, 0, 0, 16795, 16797, 3, 2270, 1135, + 0, 16796, 16794, 1, 0, 0, 0, 16796, 16797, 1, 0, 0, 0, 16797, 16798, 1, + 0, 0, 0, 16798, 16802, 3, 1972, 986, 0, 16799, 16801, 3, 1964, 982, 0, + 16800, 16799, 1, 0, 0, 0, 16801, 16804, 1, 0, 0, 0, 16802, 16800, 1, 0, + 0, 0, 16802, 16803, 1, 0, 0, 0, 16803, 16805, 1, 0, 0, 0, 16804, 16802, + 1, 0, 0, 0, 16805, 16806, 3, 1980, 990, 0, 16806, 1971, 1, 0, 0, 0, 16807, + 16809, 3, 1974, 987, 0, 16808, 16807, 1, 0, 0, 0, 16808, 16809, 1, 0, 0, + 0, 16809, 16810, 1, 0, 0, 0, 16810, 16811, 5, 392, 0, 0, 16811, 16812, + 5, 151, 0, 0, 16812, 16813, 3, 1976, 988, 0, 16813, 16814, 5, 863, 0, 0, + 16814, 16815, 3, 1976, 988, 0, 16815, 1973, 1, 0, 0, 0, 16816, 16817, 5, + 1256, 0, 0, 16817, 16818, 5, 151, 0, 0, 16818, 16819, 3, 1976, 988, 0, + 16819, 1975, 1, 0, 0, 0, 16820, 16821, 5, 2376, 0, 0, 16821, 16826, 3, + 1978, 989, 0, 16822, 16823, 5, 2382, 0, 0, 16823, 16825, 3, 1978, 989, + 0, 16824, 16822, 1, 0, 0, 0, 16825, 16828, 1, 0, 0, 0, 16826, 16824, 1, + 0, 0, 0, 16826, 16827, 1, 0, 0, 0, 16827, 16829, 1, 0, 0, 0, 16828, 16826, + 1, 0, 0, 0, 16829, 16830, 5, 2377, 0, 0, 16830, 1977, 1, 0, 0, 0, 16831, + 16834, 3, 2078, 1039, 0, 16832, 16834, 3, 1898, 949, 0, 16833, 16831, 1, + 0, 0, 0, 16833, 16832, 1, 0, 0, 0, 16834, 16836, 1, 0, 0, 0, 16835, 16837, + 3, 2236, 1118, 0, 16836, 16835, 1, 0, 0, 0, 16836, 16837, 1, 0, 0, 0, 16837, + 1979, 1, 0, 0, 0, 16838, 16840, 3, 1982, 991, 0, 16839, 16838, 1, 0, 0, + 0, 16839, 16840, 1, 0, 0, 0, 16840, 16841, 1, 0, 0, 0, 16841, 16850, 5, + 2376, 0, 0, 16842, 16847, 3, 1984, 992, 0, 16843, 16844, 5, 2382, 0, 0, + 16844, 16846, 3, 1984, 992, 0, 16845, 16843, 1, 0, 0, 0, 16846, 16849, + 1, 0, 0, 0, 16847, 16845, 1, 0, 0, 0, 16847, 16848, 1, 0, 0, 0, 16848, + 16851, 1, 0, 0, 0, 16849, 16847, 1, 0, 0, 0, 16850, 16842, 1, 0, 0, 0, + 16850, 16851, 1, 0, 0, 0, 16851, 16852, 1, 0, 0, 0, 16852, 16853, 5, 2377, + 0, 0, 16853, 1981, 1, 0, 0, 0, 16854, 16860, 5, 1512, 0, 0, 16855, 16861, + 5, 2091, 0, 0, 16856, 16858, 5, 2097, 0, 0, 16857, 16859, 5, 37, 0, 0, + 16858, 16857, 1, 0, 0, 0, 16858, 16859, 1, 0, 0, 0, 16859, 16861, 1, 0, + 0, 0, 16860, 16855, 1, 0, 0, 0, 16860, 16856, 1, 0, 0, 0, 16860, 16861, + 1, 0, 0, 0, 16861, 16864, 1, 0, 0, 0, 16862, 16863, 7, 200, 0, 0, 16863, + 16865, 5, 1215, 0, 0, 16864, 16862, 1, 0, 0, 0, 16864, 16865, 1, 0, 0, + 0, 16865, 16867, 1, 0, 0, 0, 16866, 16868, 3, 1988, 994, 0, 16867, 16866, + 1, 0, 0, 0, 16867, 16868, 1, 0, 0, 0, 16868, 1983, 1, 0, 0, 0, 16869, 16875, + 5, 2091, 0, 0, 16870, 16872, 5, 2097, 0, 0, 16871, 16873, 5, 37, 0, 0, + 16872, 16871, 1, 0, 0, 0, 16872, 16873, 1, 0, 0, 0, 16873, 16875, 1, 0, + 0, 0, 16874, 16869, 1, 0, 0, 0, 16874, 16870, 1, 0, 0, 0, 16874, 16875, + 1, 0, 0, 0, 16875, 16876, 1, 0, 0, 0, 16876, 16878, 3, 1986, 993, 0, 16877, + 16879, 3, 1992, 996, 0, 16878, 16877, 1, 0, 0, 0, 16878, 16879, 1, 0, 0, + 0, 16879, 16880, 1, 0, 0, 0, 16880, 16881, 5, 2398, 0, 0, 16881, 16882, + 3, 2078, 1039, 0, 16882, 1985, 1, 0, 0, 0, 16883, 16884, 3, 2104, 1052, + 0, 16884, 1987, 1, 0, 0, 0, 16885, 16886, 5, 727, 0, 0, 16886, 16887, 5, + 2376, 0, 0, 16887, 16888, 3, 2078, 1039, 0, 16888, 16890, 5, 2377, 0, 0, + 16889, 16891, 3, 1990, 995, 0, 16890, 16889, 1, 0, 0, 0, 16890, 16891, + 1, 0, 0, 0, 16891, 1989, 1, 0, 0, 0, 16892, 16893, 5, 2086, 0, 0, 16893, + 16894, 5, 2376, 0, 0, 16894, 16895, 3, 2072, 1036, 0, 16895, 16896, 5, + 2377, 0, 0, 16896, 1991, 1, 0, 0, 0, 16897, 16899, 5, 1215, 0, 0, 16898, + 16900, 5, 1582, 0, 0, 16899, 16898, 1, 0, 0, 0, 16899, 16900, 1, 0, 0, + 0, 16900, 16901, 1, 0, 0, 0, 16901, 16902, 5, 151, 0, 0, 16902, 16907, + 3, 1994, 997, 0, 16903, 16904, 5, 2382, 0, 0, 16904, 16906, 3, 1994, 997, + 0, 16905, 16903, 1, 0, 0, 0, 16906, 16909, 1, 0, 0, 0, 16907, 16905, 1, + 0, 0, 0, 16907, 16908, 1, 0, 0, 0, 16908, 1993, 1, 0, 0, 0, 16909, 16907, + 1, 0, 0, 0, 16910, 16912, 3, 2078, 1039, 0, 16911, 16913, 7, 48, 0, 0, + 16912, 16911, 1, 0, 0, 0, 16912, 16913, 1, 0, 0, 0, 16913, 16916, 1, 0, + 0, 0, 16914, 16915, 5, 1146, 0, 0, 16915, 16917, 7, 49, 0, 0, 16916, 16914, + 1, 0, 0, 0, 16916, 16917, 1, 0, 0, 0, 16917, 1995, 1, 0, 0, 0, 16918, 16919, + 5, 1162, 0, 0, 16919, 16920, 3, 2078, 1039, 0, 16920, 16921, 7, 201, 0, + 0, 16921, 1997, 1, 0, 0, 0, 16922, 16923, 5, 533, 0, 0, 16923, 16928, 7, + 202, 0, 0, 16924, 16926, 3, 2078, 1039, 0, 16925, 16927, 5, 1286, 0, 0, + 16926, 16925, 1, 0, 0, 0, 16926, 16927, 1, 0, 0, 0, 16927, 16929, 1, 0, + 0, 0, 16928, 16924, 1, 0, 0, 0, 16928, 16929, 1, 0, 0, 0, 16929, 16930, + 1, 0, 0, 0, 16930, 16934, 7, 201, 0, 0, 16931, 16935, 5, 1174, 0, 0, 16932, + 16933, 5, 2188, 0, 0, 16933, 16935, 5, 1994, 0, 0, 16934, 16931, 1, 0, + 0, 0, 16934, 16932, 1, 0, 0, 0, 16935, 1999, 1, 0, 0, 0, 16936, 16937, + 5, 564, 0, 0, 16937, 16939, 5, 2091, 0, 0, 16938, 16940, 3, 2002, 1001, + 0, 16939, 16938, 1, 0, 0, 0, 16939, 16940, 1, 0, 0, 0, 16940, 16942, 1, + 0, 0, 0, 16941, 16943, 3, 2004, 1002, 0, 16942, 16941, 1, 0, 0, 0, 16942, + 16943, 1, 0, 0, 0, 16943, 2001, 1, 0, 0, 0, 16944, 16945, 5, 1163, 0, 0, + 16945, 16946, 3, 2328, 1164, 0, 16946, 2003, 1, 0, 0, 0, 16947, 16948, + 5, 1597, 0, 0, 16948, 16953, 5, 810, 0, 0, 16949, 16953, 5, 1136, 0, 0, + 16950, 16951, 5, 2173, 0, 0, 16951, 16953, 3, 2078, 1039, 0, 16952, 16947, + 1, 0, 0, 0, 16952, 16949, 1, 0, 0, 0, 16952, 16950, 1, 0, 0, 0, 16953, + 2005, 1, 0, 0, 0, 16954, 16955, 5, 2091, 0, 0, 16955, 16956, 3, 2052, 1026, + 0, 16956, 16958, 3, 2008, 1004, 0, 16957, 16959, 3, 2240, 1120, 0, 16958, + 16957, 1, 0, 0, 0, 16958, 16959, 1, 0, 0, 0, 16959, 16961, 1, 0, 0, 0, + 16960, 16962, 3, 2054, 1027, 0, 16961, 16960, 1, 0, 0, 0, 16961, 16962, + 1, 0, 0, 0, 16962, 16964, 1, 0, 0, 0, 16963, 16965, 3, 2056, 1028, 0, 16964, + 16963, 1, 0, 0, 0, 16964, 16965, 1, 0, 0, 0, 16965, 2007, 1, 0, 0, 0, 16966, + 16982, 5, 1568, 0, 0, 16967, 16972, 3, 2010, 1005, 0, 16968, 16969, 5, + 2382, 0, 0, 16969, 16971, 3, 2010, 1005, 0, 16970, 16968, 1, 0, 0, 0, 16971, + 16974, 1, 0, 0, 0, 16972, 16970, 1, 0, 0, 0, 16972, 16973, 1, 0, 0, 0, + 16973, 16983, 1, 0, 0, 0, 16974, 16972, 1, 0, 0, 0, 16975, 16976, 5, 2141, + 0, 0, 16976, 16977, 5, 2376, 0, 0, 16977, 16978, 3, 2376, 1188, 0, 16978, + 16979, 5, 2377, 0, 0, 16979, 16980, 5, 2398, 0, 0, 16980, 16981, 3, 2078, + 1039, 0, 16981, 16983, 1, 0, 0, 0, 16982, 16967, 1, 0, 0, 0, 16982, 16975, + 1, 0, 0, 0, 16983, 2009, 1, 0, 0, 0, 16984, 16985, 3, 2310, 1155, 0, 16985, + 16986, 5, 2398, 0, 0, 16986, 16987, 3, 2078, 1039, 0, 16987, 16999, 1, + 0, 0, 0, 16988, 16989, 3, 2330, 1165, 0, 16989, 16990, 5, 2398, 0, 0, 16990, + 16991, 3, 1892, 946, 0, 16991, 16999, 1, 0, 0, 0, 16992, 16993, 5, 2376, + 0, 0, 16993, 16994, 3, 2310, 1155, 0, 16994, 16995, 5, 2377, 0, 0, 16995, + 16996, 5, 2398, 0, 0, 16996, 16997, 3, 2078, 1039, 0, 16997, 16999, 1, + 0, 0, 0, 16998, 16984, 1, 0, 0, 0, 16998, 16988, 1, 0, 0, 0, 16998, 16992, + 1, 0, 0, 0, 16999, 2011, 1, 0, 0, 0, 17000, 17002, 5, 376, 0, 0, 17001, + 17003, 5, 572, 0, 0, 17002, 17001, 1, 0, 0, 0, 17002, 17003, 1, 0, 0, 0, + 17003, 17004, 1, 0, 0, 0, 17004, 17006, 3, 2052, 1026, 0, 17005, 17007, + 3, 2240, 1120, 0, 17006, 17005, 1, 0, 0, 0, 17006, 17007, 1, 0, 0, 0, 17007, + 17009, 1, 0, 0, 0, 17008, 17010, 3, 2054, 1027, 0, 17009, 17008, 1, 0, + 0, 0, 17009, 17010, 1, 0, 0, 0, 17010, 17012, 1, 0, 0, 0, 17011, 17013, + 3, 2056, 1028, 0, 17012, 17011, 1, 0, 0, 0, 17012, 17013, 1, 0, 0, 0, 17013, + 2013, 1, 0, 0, 0, 17014, 17017, 5, 697, 0, 0, 17015, 17018, 3, 2016, 1008, + 0, 17016, 17018, 3, 2018, 1009, 0, 17017, 17015, 1, 0, 0, 0, 17017, 17016, + 1, 0, 0, 0, 17018, 2015, 1, 0, 0, 0, 17019, 17025, 3, 2028, 1014, 0, 17020, + 17022, 3, 2030, 1015, 0, 17021, 17023, 3, 2054, 1027, 0, 17022, 17021, + 1, 0, 0, 0, 17022, 17023, 1, 0, 0, 0, 17023, 17026, 1, 0, 0, 0, 17024, + 17026, 3, 1882, 941, 0, 17025, 17020, 1, 0, 0, 0, 17025, 17024, 1, 0, 0, + 0, 17026, 17028, 1, 0, 0, 0, 17027, 17029, 3, 2056, 1028, 0, 17028, 17027, + 1, 0, 0, 0, 17028, 17029, 1, 0, 0, 0, 17029, 2017, 1, 0, 0, 0, 17030, 17032, + 5, 37, 0, 0, 17031, 17033, 3, 2020, 1010, 0, 17032, 17031, 1, 0, 0, 0, + 17033, 17034, 1, 0, 0, 0, 17034, 17032, 1, 0, 0, 0, 17034, 17035, 1, 0, + 0, 0, 17035, 17038, 1, 0, 0, 0, 17036, 17038, 3, 2022, 1011, 0, 17037, + 17030, 1, 0, 0, 0, 17037, 17036, 1, 0, 0, 0, 17038, 17039, 1, 0, 0, 0, + 17039, 17040, 3, 1882, 941, 0, 17040, 2019, 1, 0, 0, 0, 17041, 17043, 3, + 2028, 1014, 0, 17042, 17044, 3, 2030, 1015, 0, 17043, 17042, 1, 0, 0, 0, + 17043, 17044, 1, 0, 0, 0, 17044, 17046, 1, 0, 0, 0, 17045, 17047, 3, 2056, + 1028, 0, 17046, 17045, 1, 0, 0, 0, 17046, 17047, 1, 0, 0, 0, 17047, 2021, + 1, 0, 0, 0, 17048, 17050, 7, 203, 0, 0, 17049, 17048, 1, 0, 0, 0, 17049, + 17050, 1, 0, 0, 0, 17050, 17052, 1, 0, 0, 0, 17051, 17053, 3, 2024, 1012, + 0, 17052, 17051, 1, 0, 0, 0, 17053, 17054, 1, 0, 0, 0, 17054, 17052, 1, + 0, 0, 0, 17054, 17055, 1, 0, 0, 0, 17055, 17057, 1, 0, 0, 0, 17056, 17058, + 3, 2026, 1013, 0, 17057, 17056, 1, 0, 0, 0, 17057, 17058, 1, 0, 0, 0, 17058, + 2023, 1, 0, 0, 0, 17059, 17060, 5, 2180, 0, 0, 17060, 17061, 3, 2072, 1036, + 0, 17061, 17063, 5, 1989, 0, 0, 17062, 17064, 3, 2020, 1010, 0, 17063, + 17062, 1, 0, 0, 0, 17064, 17065, 1, 0, 0, 0, 17065, 17063, 1, 0, 0, 0, + 17065, 17066, 1, 0, 0, 0, 17066, 2025, 1, 0, 0, 0, 17067, 17069, 5, 446, + 0, 0, 17068, 17070, 3, 2020, 1010, 0, 17069, 17068, 1, 0, 0, 0, 17070, + 17071, 1, 0, 0, 0, 17071, 17069, 1, 0, 0, 0, 17071, 17072, 1, 0, 0, 0, + 17072, 2027, 1, 0, 0, 0, 17073, 17074, 5, 719, 0, 0, 17074, 17076, 3, 2052, + 1026, 0, 17075, 17077, 3, 2330, 1165, 0, 17076, 17075, 1, 0, 0, 0, 17076, + 17077, 1, 0, 0, 0, 17077, 2029, 1, 0, 0, 0, 17078, 17084, 5, 2140, 0, 0, + 17079, 17085, 3, 2078, 1039, 0, 17080, 17081, 5, 2376, 0, 0, 17081, 17082, + 3, 2076, 1038, 0, 17082, 17083, 5, 2377, 0, 0, 17083, 17085, 1, 0, 0, 0, + 17084, 17079, 1, 0, 0, 0, 17084, 17080, 1, 0, 0, 0, 17085, 2031, 1, 0, + 0, 0, 17086, 17087, 5, 875, 0, 0, 17087, 17088, 5, 719, 0, 0, 17088, 17089, + 3, 2042, 1021, 0, 17089, 17090, 5, 2129, 0, 0, 17090, 17091, 3, 2042, 1021, + 0, 17091, 17092, 5, 1175, 0, 0, 17092, 17093, 5, 2376, 0, 0, 17093, 17094, + 3, 2072, 1036, 0, 17094, 17103, 5, 2377, 0, 0, 17095, 17097, 3, 2034, 1017, + 0, 17096, 17098, 3, 2040, 1020, 0, 17097, 17096, 1, 0, 0, 0, 17097, 17098, + 1, 0, 0, 0, 17098, 17104, 1, 0, 0, 0, 17099, 17101, 3, 2040, 1020, 0, 17100, + 17102, 3, 2034, 1017, 0, 17101, 17100, 1, 0, 0, 0, 17101, 17102, 1, 0, + 0, 0, 17102, 17104, 1, 0, 0, 0, 17103, 17095, 1, 0, 0, 0, 17103, 17099, + 1, 0, 0, 0, 17103, 17104, 1, 0, 0, 0, 17104, 17106, 1, 0, 0, 0, 17105, + 17107, 3, 2056, 1028, 0, 17106, 17105, 1, 0, 0, 0, 17106, 17107, 1, 0, + 0, 0, 17107, 2033, 1, 0, 0, 0, 17108, 17109, 5, 2180, 0, 0, 17109, 17110, + 5, 843, 0, 0, 17110, 17111, 5, 1989, 0, 0, 17111, 17112, 5, 2091, 0, 0, + 17112, 17113, 5, 1568, 0, 0, 17113, 17118, 3, 2036, 1018, 0, 17114, 17115, + 5, 2382, 0, 0, 17115, 17117, 3, 2036, 1018, 0, 17116, 17114, 1, 0, 0, 0, + 17117, 17120, 1, 0, 0, 0, 17118, 17116, 1, 0, 0, 0, 17118, 17119, 1, 0, + 0, 0, 17119, 17122, 1, 0, 0, 0, 17120, 17118, 1, 0, 0, 0, 17121, 17123, + 3, 2240, 1120, 0, 17122, 17121, 1, 0, 0, 0, 17122, 17123, 1, 0, 0, 0, 17123, + 17125, 1, 0, 0, 0, 17124, 17126, 3, 2038, 1019, 0, 17125, 17124, 1, 0, + 0, 0, 17125, 17126, 1, 0, 0, 0, 17126, 2035, 1, 0, 0, 0, 17127, 17128, + 3, 2310, 1155, 0, 17128, 17129, 5, 2398, 0, 0, 17129, 17130, 3, 2078, 1039, + 0, 17130, 2037, 1, 0, 0, 0, 17131, 17132, 5, 376, 0, 0, 17132, 17133, 3, + 2240, 1120, 0, 17133, 2039, 1, 0, 0, 0, 17134, 17135, 5, 2180, 0, 0, 17135, + 17136, 5, 1121, 0, 0, 17136, 17137, 5, 843, 0, 0, 17137, 17138, 5, 1989, + 0, 0, 17138, 17140, 5, 697, 0, 0, 17139, 17141, 3, 2330, 1165, 0, 17140, + 17139, 1, 0, 0, 0, 17140, 17141, 1, 0, 0, 0, 17141, 17142, 1, 0, 0, 0, + 17142, 17144, 3, 2030, 1015, 0, 17143, 17145, 3, 2240, 1120, 0, 17144, + 17143, 1, 0, 0, 0, 17144, 17145, 1, 0, 0, 0, 17145, 2041, 1, 0, 0, 0, 17146, + 17152, 3, 2312, 1156, 0, 17147, 17148, 5, 2376, 0, 0, 17148, 17149, 3, + 1882, 941, 0, 17149, 17150, 5, 2377, 0, 0, 17150, 17152, 1, 0, 0, 0, 17151, + 17146, 1, 0, 0, 0, 17151, 17147, 1, 0, 0, 0, 17152, 17154, 1, 0, 0, 0, + 17153, 17155, 3, 2238, 1119, 0, 17154, 17153, 1, 0, 0, 0, 17154, 17155, + 1, 0, 0, 0, 17155, 2043, 1, 0, 0, 0, 17156, 17157, 5, 812, 0, 0, 17157, + 17158, 5, 1976, 0, 0, 17158, 17163, 3, 2048, 1024, 0, 17159, 17160, 5, + 2382, 0, 0, 17160, 17162, 3, 2048, 1024, 0, 17161, 17159, 1, 0, 0, 0, 17162, + 17165, 1, 0, 0, 0, 17163, 17161, 1, 0, 0, 0, 17163, 17164, 1, 0, 0, 0, + 17164, 17166, 1, 0, 0, 0, 17165, 17163, 1, 0, 0, 0, 17166, 17167, 5, 680, + 0, 0, 17167, 17168, 3, 2050, 1025, 0, 17168, 17170, 5, 906, 0, 0, 17169, + 17171, 3, 2046, 1023, 0, 17170, 17169, 1, 0, 0, 0, 17170, 17171, 1, 0, + 0, 0, 17171, 2045, 1, 0, 0, 0, 17172, 17173, 5, 2173, 0, 0, 17173, 17176, + 3, 2078, 1039, 0, 17174, 17176, 5, 1136, 0, 0, 17175, 17172, 1, 0, 0, 0, + 17175, 17174, 1, 0, 0, 0, 17176, 2047, 1, 0, 0, 0, 17177, 17179, 3, 2312, + 1156, 0, 17178, 17180, 3, 2234, 1117, 0, 17179, 17178, 1, 0, 0, 0, 17179, + 17180, 1, 0, 0, 0, 17180, 2049, 1, 0, 0, 0, 17181, 17182, 5, 1507, 0, 0, + 17182, 17194, 5, 1576, 0, 0, 17183, 17184, 5, 1507, 0, 0, 17184, 17194, + 5, 488, 0, 0, 17185, 17187, 5, 1576, 0, 0, 17186, 17188, 5, 2091, 0, 0, + 17187, 17186, 1, 0, 0, 0, 17187, 17188, 1, 0, 0, 0, 17188, 17194, 1, 0, + 0, 0, 17189, 17190, 5, 1576, 0, 0, 17190, 17191, 5, 1507, 0, 0, 17191, + 17194, 5, 488, 0, 0, 17192, 17194, 5, 488, 0, 0, 17193, 17181, 1, 0, 0, + 0, 17193, 17183, 1, 0, 0, 0, 17193, 17185, 1, 0, 0, 0, 17193, 17189, 1, + 0, 0, 0, 17193, 17192, 1, 0, 0, 0, 17194, 2051, 1, 0, 0, 0, 17195, 17202, + 3, 2062, 1031, 0, 17196, 17197, 5, 1174, 0, 0, 17197, 17198, 5, 2376, 0, + 0, 17198, 17199, 3, 2062, 1031, 0, 17199, 17200, 5, 2377, 0, 0, 17200, + 17202, 1, 0, 0, 0, 17201, 17195, 1, 0, 0, 0, 17201, 17196, 1, 0, 0, 0, + 17202, 17204, 1, 0, 0, 0, 17203, 17205, 3, 2238, 1119, 0, 17204, 17203, + 1, 0, 0, 0, 17204, 17205, 1, 0, 0, 0, 17205, 2053, 1, 0, 0, 0, 17206, 17207, + 7, 188, 0, 0, 17207, 17208, 3, 2076, 1038, 0, 17208, 17209, 3, 2244, 1122, + 0, 17209, 2055, 1, 0, 0, 0, 17210, 17211, 5, 819, 0, 0, 17211, 17213, 5, + 472, 0, 0, 17212, 17214, 3, 2058, 1029, 0, 17213, 17212, 1, 0, 0, 0, 17213, + 17214, 1, 0, 0, 0, 17214, 17216, 1, 0, 0, 0, 17215, 17217, 3, 2078, 1039, + 0, 17216, 17215, 1, 0, 0, 0, 17216, 17217, 1, 0, 0, 0, 17217, 17219, 1, + 0, 0, 0, 17218, 17220, 3, 2060, 1030, 0, 17219, 17218, 1, 0, 0, 0, 17219, + 17220, 1, 0, 0, 0, 17220, 2057, 1, 0, 0, 0, 17221, 17222, 5, 719, 0, 0, + 17222, 17223, 3, 2312, 1156, 0, 17223, 2059, 1, 0, 0, 0, 17224, 17225, + 5, 1450, 0, 0, 17225, 17228, 5, 793, 0, 0, 17226, 17229, 5, 2070, 0, 0, + 17227, 17229, 3, 2078, 1039, 0, 17228, 17226, 1, 0, 0, 0, 17228, 17227, + 1, 0, 0, 0, 17229, 2061, 1, 0, 0, 0, 17230, 17248, 3, 2064, 1032, 0, 17231, + 17232, 5, 2376, 0, 0, 17232, 17234, 3, 1882, 941, 0, 17233, 17235, 3, 2066, + 1033, 0, 17234, 17233, 1, 0, 0, 0, 17234, 17235, 1, 0, 0, 0, 17235, 17236, + 1, 0, 0, 0, 17236, 17237, 5, 2377, 0, 0, 17237, 17248, 1, 0, 0, 0, 17238, + 17240, 3, 2312, 1156, 0, 17239, 17241, 3, 2068, 1034, 0, 17240, 17239, + 1, 0, 0, 0, 17240, 17241, 1, 0, 0, 0, 17241, 17248, 1, 0, 0, 0, 17242, + 17245, 3, 2140, 1070, 0, 17243, 17244, 5, 66, 0, 0, 17244, 17246, 3, 2376, + 1188, 0, 17245, 17243, 1, 0, 0, 0, 17245, 17246, 1, 0, 0, 0, 17246, 17248, + 1, 0, 0, 0, 17247, 17230, 1, 0, 0, 0, 17247, 17231, 1, 0, 0, 0, 17247, + 17238, 1, 0, 0, 0, 17247, 17242, 1, 0, 0, 0, 17248, 2063, 1, 0, 0, 0, 17249, + 17260, 7, 204, 0, 0, 17250, 17251, 5, 2376, 0, 0, 17251, 17252, 3, 1892, + 946, 0, 17252, 17253, 5, 2377, 0, 0, 17253, 17261, 1, 0, 0, 0, 17254, 17255, + 5, 2376, 0, 0, 17255, 17256, 3, 2078, 1039, 0, 17256, 17258, 5, 2377, 0, + 0, 17257, 17259, 3, 2380, 1190, 0, 17258, 17257, 1, 0, 0, 0, 17258, 17259, + 1, 0, 0, 0, 17259, 17261, 1, 0, 0, 0, 17260, 17250, 1, 0, 0, 0, 17260, + 17254, 1, 0, 0, 0, 17261, 2065, 1, 0, 0, 0, 17262, 17271, 5, 2188, 0, 0, + 17263, 17264, 5, 1408, 0, 0, 17264, 17272, 5, 1174, 0, 0, 17265, 17266, + 5, 186, 0, 0, 17266, 17269, 5, 1188, 0, 0, 17267, 17268, 5, 267, 0, 0, + 17268, 17270, 3, 2282, 1141, 0, 17269, 17267, 1, 0, 0, 0, 17269, 17270, + 1, 0, 0, 0, 17270, 17272, 1, 0, 0, 0, 17271, 17263, 1, 0, 0, 0, 17271, + 17265, 1, 0, 0, 0, 17272, 2067, 1, 0, 0, 0, 17273, 17275, 5, 1515, 0, 0, + 17274, 17276, 5, 134, 0, 0, 17275, 17274, 1, 0, 0, 0, 17275, 17276, 1, + 0, 0, 0, 17276, 17277, 1, 0, 0, 0, 17277, 17278, 5, 2376, 0, 0, 17278, + 17281, 3, 2078, 1039, 0, 17279, 17280, 5, 2382, 0, 0, 17280, 17282, 3, + 2078, 1039, 0, 17281, 17279, 1, 0, 0, 0, 17281, 17282, 1, 0, 0, 0, 17282, + 17283, 1, 0, 0, 0, 17283, 17285, 5, 2377, 0, 0, 17284, 17286, 3, 2070, + 1035, 0, 17285, 17284, 1, 0, 0, 0, 17285, 17286, 1, 0, 0, 0, 17286, 2069, + 1, 0, 0, 0, 17287, 17288, 5, 1543, 0, 0, 17288, 17289, 5, 2376, 0, 0, 17289, + 17290, 3, 2078, 1039, 0, 17290, 17291, 5, 2377, 0, 0, 17291, 2071, 1, 0, + 0, 0, 17292, 17295, 3, 2078, 1039, 0, 17293, 17295, 3, 2074, 1037, 0, 17294, + 17292, 1, 0, 0, 0, 17294, 17293, 1, 0, 0, 0, 17295, 2073, 1, 0, 0, 0, 17296, + 17297, 3, 2310, 1155, 0, 17297, 17299, 5, 723, 0, 0, 17298, 17300, 5, 1121, + 0, 0, 17299, 17298, 1, 0, 0, 0, 17299, 17300, 1, 0, 0, 0, 17300, 17301, + 1, 0, 0, 0, 17301, 17304, 5, 738, 0, 0, 17302, 17303, 5, 565, 0, 0, 17303, + 17305, 5, 738, 0, 0, 17304, 17302, 1, 0, 0, 0, 17304, 17305, 1, 0, 0, 0, + 17305, 17307, 1, 0, 0, 0, 17306, 17308, 7, 205, 0, 0, 17307, 17306, 1, + 0, 0, 0, 17307, 17308, 1, 0, 0, 0, 17308, 17312, 1, 0, 0, 0, 17309, 17310, + 7, 2, 0, 0, 17310, 17311, 5, 2068, 0, 0, 17311, 17313, 5, 756, 0, 0, 17312, + 17309, 1, 0, 0, 0, 17312, 17313, 1, 0, 0, 0, 17313, 17320, 1, 0, 0, 0, + 17314, 17315, 5, 734, 0, 0, 17315, 17316, 5, 2376, 0, 0, 17316, 17317, + 3, 2076, 1038, 0, 17317, 17318, 5, 2377, 0, 0, 17318, 17320, 1, 0, 0, 0, + 17319, 17296, 1, 0, 0, 0, 17319, 17314, 1, 0, 0, 0, 17320, 2075, 1, 0, + 0, 0, 17321, 17326, 3, 2078, 1039, 0, 17322, 17323, 5, 2382, 0, 0, 17323, + 17325, 3, 2078, 1039, 0, 17324, 17322, 1, 0, 0, 0, 17325, 17328, 1, 0, + 0, 0, 17326, 17324, 1, 0, 0, 0, 17326, 17327, 1, 0, 0, 0, 17327, 2077, + 1, 0, 0, 0, 17328, 17326, 1, 0, 0, 0, 17329, 17332, 3, 2080, 1040, 0, 17330, + 17332, 3, 2082, 1041, 0, 17331, 17329, 1, 0, 0, 0, 17331, 17330, 1, 0, + 0, 0, 17332, 2079, 1, 0, 0, 0, 17333, 17334, 5, 322, 0, 0, 17334, 17335, + 5, 2376, 0, 0, 17335, 17336, 3, 1892, 946, 0, 17336, 17337, 5, 2377, 0, + 0, 17337, 2081, 1, 0, 0, 0, 17338, 17339, 6, 1041, -1, 0, 17339, 17340, + 3, 2084, 1042, 0, 17340, 17349, 1, 0, 0, 0, 17341, 17342, 10, 2, 0, 0, + 17342, 17343, 5, 48, 0, 0, 17343, 17348, 3, 2082, 1041, 3, 17344, 17345, + 10, 1, 0, 0, 17345, 17346, 5, 1219, 0, 0, 17346, 17348, 3, 2082, 1041, + 2, 17347, 17341, 1, 0, 0, 0, 17347, 17344, 1, 0, 0, 0, 17348, 17351, 1, + 0, 0, 0, 17349, 17347, 1, 0, 0, 0, 17349, 17350, 1, 0, 0, 0, 17350, 2083, + 1, 0, 0, 0, 17351, 17349, 1, 0, 0, 0, 17352, 17354, 5, 1121, 0, 0, 17353, + 17352, 1, 0, 0, 0, 17353, 17354, 1, 0, 0, 0, 17354, 17355, 1, 0, 0, 0, + 17355, 17363, 3, 2088, 1044, 0, 17356, 17358, 5, 723, 0, 0, 17357, 17359, + 5, 1121, 0, 0, 17358, 17357, 1, 0, 0, 0, 17358, 17359, 1, 0, 0, 0, 17359, + 17360, 1, 0, 0, 0, 17360, 17362, 3, 2086, 1043, 0, 17361, 17356, 1, 0, + 0, 0, 17362, 17365, 1, 0, 0, 0, 17363, 17361, 1, 0, 0, 0, 17363, 17364, + 1, 0, 0, 0, 17364, 2085, 1, 0, 0, 0, 17365, 17363, 1, 0, 0, 0, 17366, 17392, + 5, 1145, 0, 0, 17367, 17392, 5, 928, 0, 0, 17368, 17392, 5, 1348, 0, 0, + 17369, 17392, 5, 677, 0, 0, 17370, 17371, 5, 35, 0, 0, 17371, 17392, 5, + 1568, 0, 0, 17372, 17392, 5, 451, 0, 0, 17373, 17375, 5, 1163, 0, 0, 17374, + 17376, 5, 2053, 0, 0, 17375, 17374, 1, 0, 0, 0, 17375, 17376, 1, 0, 0, + 0, 17376, 17377, 1, 0, 0, 0, 17377, 17379, 5, 2376, 0, 0, 17378, 17380, + 5, 1174, 0, 0, 17379, 17378, 1, 0, 0, 0, 17379, 17380, 1, 0, 0, 0, 17380, + 17381, 1, 0, 0, 0, 17381, 17386, 3, 2344, 1172, 0, 17382, 17383, 5, 2382, + 0, 0, 17383, 17385, 3, 2344, 1172, 0, 17384, 17382, 1, 0, 0, 0, 17385, + 17388, 1, 0, 0, 0, 17386, 17384, 1, 0, 0, 0, 17386, 17387, 1, 0, 0, 0, + 17387, 17389, 1, 0, 0, 0, 17388, 17386, 1, 0, 0, 0, 17389, 17390, 5, 2377, + 0, 0, 17390, 17392, 1, 0, 0, 0, 17391, 17366, 1, 0, 0, 0, 17391, 17367, + 1, 0, 0, 0, 17391, 17368, 1, 0, 0, 0, 17391, 17369, 1, 0, 0, 0, 17391, + 17370, 1, 0, 0, 0, 17391, 17372, 1, 0, 0, 0, 17391, 17373, 1, 0, 0, 0, + 17392, 2087, 1, 0, 0, 0, 17393, 17399, 3, 2090, 1045, 0, 17394, 17396, + 7, 206, 0, 0, 17395, 17397, 5, 1163, 0, 0, 17396, 17395, 1, 0, 0, 0, 17396, + 17397, 1, 0, 0, 0, 17397, 17398, 1, 0, 0, 0, 17398, 17400, 3, 2100, 1050, + 0, 17399, 17394, 1, 0, 0, 0, 17399, 17400, 1, 0, 0, 0, 17400, 2089, 1, + 0, 0, 0, 17401, 17402, 6, 1045, -1, 0, 17402, 17403, 3, 2092, 1046, 0, + 17403, 17410, 1, 0, 0, 0, 17404, 17405, 10, 2, 0, 0, 17405, 17406, 3, 2094, + 1047, 0, 17406, 17407, 3, 2090, 1045, 3, 17407, 17409, 1, 0, 0, 0, 17408, + 17404, 1, 0, 0, 0, 17409, 17412, 1, 0, 0, 0, 17410, 17408, 1, 0, 0, 0, + 17410, 17411, 1, 0, 0, 0, 17411, 2091, 1, 0, 0, 0, 17412, 17410, 1, 0, + 0, 0, 17413, 17429, 3, 2100, 1050, 0, 17414, 17416, 5, 1121, 0, 0, 17415, + 17414, 1, 0, 0, 0, 17415, 17416, 1, 0, 0, 0, 17416, 17427, 1, 0, 0, 0, + 17417, 17418, 5, 680, 0, 0, 17418, 17428, 3, 2096, 1048, 0, 17419, 17420, + 5, 112, 0, 0, 17420, 17428, 3, 2098, 1049, 0, 17421, 17422, 7, 207, 0, + 0, 17422, 17425, 3, 2100, 1050, 0, 17423, 17424, 5, 473, 0, 0, 17424, 17426, + 3, 2100, 1050, 0, 17425, 17423, 1, 0, 0, 0, 17425, 17426, 1, 0, 0, 0, 17426, + 17428, 1, 0, 0, 0, 17427, 17417, 1, 0, 0, 0, 17427, 17419, 1, 0, 0, 0, + 17427, 17421, 1, 0, 0, 0, 17428, 17430, 1, 0, 0, 0, 17429, 17415, 1, 0, + 0, 0, 17429, 17430, 1, 0, 0, 0, 17430, 2093, 1, 0, 0, 0, 17431, 17446, + 5, 2398, 0, 0, 17432, 17440, 5, 2389, 0, 0, 17433, 17434, 5, 2394, 0, 0, + 17434, 17440, 5, 2393, 0, 0, 17435, 17436, 5, 2392, 0, 0, 17436, 17440, + 5, 2398, 0, 0, 17437, 17438, 5, 2390, 0, 0, 17438, 17440, 5, 2398, 0, 0, + 17439, 17432, 1, 0, 0, 0, 17439, 17433, 1, 0, 0, 0, 17439, 17435, 1, 0, + 0, 0, 17439, 17437, 1, 0, 0, 0, 17440, 17446, 1, 0, 0, 0, 17441, 17443, + 7, 208, 0, 0, 17442, 17444, 5, 2398, 0, 0, 17443, 17442, 1, 0, 0, 0, 17443, + 17444, 1, 0, 0, 0, 17444, 17446, 1, 0, 0, 0, 17445, 17431, 1, 0, 0, 0, + 17445, 17439, 1, 0, 0, 0, 17445, 17441, 1, 0, 0, 0, 17446, 2095, 1, 0, + 0, 0, 17447, 17448, 5, 2376, 0, 0, 17448, 17449, 3, 1892, 946, 0, 17449, + 17450, 5, 2377, 0, 0, 17450, 17466, 1, 0, 0, 0, 17451, 17452, 5, 2376, + 0, 0, 17452, 17457, 3, 2100, 1050, 0, 17453, 17454, 5, 2382, 0, 0, 17454, + 17456, 3, 2100, 1050, 0, 17455, 17453, 1, 0, 0, 0, 17456, 17459, 1, 0, + 0, 0, 17457, 17455, 1, 0, 0, 0, 17457, 17458, 1, 0, 0, 0, 17458, 17460, + 1, 0, 0, 0, 17459, 17457, 1, 0, 0, 0, 17460, 17461, 5, 2377, 0, 0, 17461, + 17466, 1, 0, 0, 0, 17462, 17466, 3, 2364, 1182, 0, 17463, 17466, 3, 2352, + 1176, 0, 17464, 17466, 3, 2354, 1177, 0, 17465, 17447, 1, 0, 0, 0, 17465, + 17451, 1, 0, 0, 0, 17465, 17462, 1, 0, 0, 0, 17465, 17463, 1, 0, 0, 0, + 17465, 17464, 1, 0, 0, 0, 17466, 2097, 1, 0, 0, 0, 17467, 17468, 3, 2100, + 1050, 0, 17468, 17469, 5, 48, 0, 0, 17469, 17470, 3, 2100, 1050, 0, 17470, + 2099, 1, 0, 0, 0, 17471, 17472, 6, 1050, -1, 0, 17472, 17481, 3, 2104, + 1052, 0, 17473, 17478, 5, 79, 0, 0, 17474, 17479, 5, 804, 0, 0, 17475, + 17476, 5, 2001, 0, 0, 17476, 17477, 5, 2239, 0, 0, 17477, 17479, 3, 2100, + 1050, 0, 17478, 17474, 1, 0, 0, 0, 17478, 17475, 1, 0, 0, 0, 17479, 17482, + 1, 0, 0, 0, 17480, 17482, 3, 2102, 1051, 0, 17481, 17473, 1, 0, 0, 0, 17481, + 17480, 1, 0, 0, 0, 17481, 17482, 1, 0, 0, 0, 17482, 17486, 1, 0, 0, 0, + 17483, 17484, 5, 1175, 0, 0, 17484, 17485, 5, 1231, 0, 0, 17485, 17487, + 7, 209, 0, 0, 17486, 17483, 1, 0, 0, 0, 17486, 17487, 1, 0, 0, 0, 17487, + 17500, 1, 0, 0, 0, 17488, 17489, 10, 3, 0, 0, 17489, 17490, 7, 210, 0, + 0, 17490, 17499, 3, 2100, 1050, 4, 17491, 17492, 10, 2, 0, 0, 17492, 17493, + 7, 140, 0, 0, 17493, 17499, 3, 2100, 1050, 3, 17494, 17495, 10, 1, 0, 0, + 17495, 17496, 5, 2397, 0, 0, 17496, 17497, 5, 2397, 0, 0, 17497, 17499, + 3, 2100, 1050, 2, 17498, 17488, 1, 0, 0, 0, 17498, 17491, 1, 0, 0, 0, 17498, + 17494, 1, 0, 0, 0, 17499, 17502, 1, 0, 0, 0, 17500, 17498, 1, 0, 0, 0, + 17500, 17501, 1, 0, 0, 0, 17501, 2101, 1, 0, 0, 0, 17502, 17500, 1, 0, + 0, 0, 17503, 17508, 5, 341, 0, 0, 17504, 17505, 5, 2376, 0, 0, 17505, 17506, + 3, 2100, 1050, 0, 17506, 17507, 5, 2377, 0, 0, 17507, 17509, 1, 0, 0, 0, + 17508, 17504, 1, 0, 0, 0, 17508, 17509, 1, 0, 0, 0, 17509, 17510, 1, 0, + 0, 0, 17510, 17511, 5, 2029, 0, 0, 17511, 17516, 5, 1537, 0, 0, 17512, + 17513, 5, 2376, 0, 0, 17513, 17514, 3, 2100, 1050, 0, 17514, 17515, 5, + 2377, 0, 0, 17515, 17517, 1, 0, 0, 0, 17516, 17512, 1, 0, 0, 0, 17516, + 17517, 1, 0, 0, 0, 17517, 17531, 1, 0, 0, 0, 17518, 17523, 5, 2235, 0, + 0, 17519, 17520, 5, 2376, 0, 0, 17520, 17521, 3, 2100, 1050, 0, 17521, + 17522, 5, 2377, 0, 0, 17522, 17524, 1, 0, 0, 0, 17523, 17519, 1, 0, 0, + 0, 17523, 17524, 1, 0, 0, 0, 17524, 17525, 1, 0, 0, 0, 17525, 17526, 5, + 2029, 0, 0, 17526, 17531, 5, 914, 0, 0, 17527, 17528, 3, 2100, 1050, 0, + 17528, 17529, 7, 211, 0, 0, 17529, 17531, 1, 0, 0, 0, 17530, 17503, 1, + 0, 0, 0, 17530, 17518, 1, 0, 0, 0, 17530, 17527, 1, 0, 0, 0, 17531, 2103, + 1, 0, 0, 0, 17532, 17537, 3, 2112, 1056, 0, 17533, 17534, 5, 2399, 0, 0, + 17534, 17535, 3, 2106, 1053, 0, 17535, 17536, 5, 2400, 0, 0, 17536, 17538, + 1, 0, 0, 0, 17537, 17533, 1, 0, 0, 0, 17537, 17538, 1, 0, 0, 0, 17538, + 2105, 1, 0, 0, 0, 17539, 17542, 5, 53, 0, 0, 17540, 17542, 3, 2078, 1039, + 0, 17541, 17539, 1, 0, 0, 0, 17541, 17540, 1, 0, 0, 0, 17542, 17550, 1, + 0, 0, 0, 17543, 17546, 5, 2382, 0, 0, 17544, 17547, 5, 53, 0, 0, 17545, + 17547, 3, 2078, 1039, 0, 17546, 17544, 1, 0, 0, 0, 17546, 17545, 1, 0, + 0, 0, 17547, 17549, 1, 0, 0, 0, 17548, 17543, 1, 0, 0, 0, 17549, 17552, + 1, 0, 0, 0, 17550, 17548, 1, 0, 0, 0, 17550, 17551, 1, 0, 0, 0, 17551, + 17563, 1, 0, 0, 0, 17552, 17550, 1, 0, 0, 0, 17553, 17558, 3, 2108, 1054, + 0, 17554, 17555, 5, 2382, 0, 0, 17555, 17557, 3, 2108, 1054, 0, 17556, + 17554, 1, 0, 0, 0, 17557, 17560, 1, 0, 0, 0, 17558, 17556, 1, 0, 0, 0, + 17558, 17559, 1, 0, 0, 0, 17559, 17563, 1, 0, 0, 0, 17560, 17558, 1, 0, + 0, 0, 17561, 17563, 3, 2110, 1055, 0, 17562, 17541, 1, 0, 0, 0, 17562, + 17553, 1, 0, 0, 0, 17562, 17561, 1, 0, 0, 0, 17563, 2107, 1, 0, 0, 0, 17564, + 17565, 5, 564, 0, 0, 17565, 17583, 3, 2310, 1155, 0, 17566, 17567, 5, 680, + 0, 0, 17567, 17569, 5, 2376, 0, 0, 17568, 17570, 3, 2076, 1038, 0, 17569, + 17568, 1, 0, 0, 0, 17569, 17570, 1, 0, 0, 0, 17570, 17571, 1, 0, 0, 0, + 17571, 17584, 5, 2377, 0, 0, 17572, 17573, 5, 792, 0, 0, 17573, 17575, + 3, 2078, 1039, 0, 17574, 17572, 1, 0, 0, 0, 17574, 17575, 1, 0, 0, 0, 17575, + 17576, 1, 0, 0, 0, 17576, 17577, 5, 572, 0, 0, 17577, 17578, 3, 2078, 1039, + 0, 17578, 17579, 5, 2029, 0, 0, 17579, 17580, 3, 2078, 1039, 0, 17580, + 17581, 7, 212, 0, 0, 17581, 17582, 3, 2078, 1039, 0, 17582, 17584, 1, 0, + 0, 0, 17583, 17566, 1, 0, 0, 0, 17583, 17574, 1, 0, 0, 0, 17584, 2109, + 1, 0, 0, 0, 17585, 17586, 5, 564, 0, 0, 17586, 17587, 3, 2330, 1165, 0, + 17587, 17588, 5, 680, 0, 0, 17588, 17595, 5, 2376, 0, 0, 17589, 17596, + 3, 1892, 946, 0, 17590, 17592, 5, 2376, 0, 0, 17591, 17593, 3, 2076, 1038, + 0, 17592, 17591, 1, 0, 0, 0, 17592, 17593, 1, 0, 0, 0, 17593, 17594, 1, + 0, 0, 0, 17594, 17596, 5, 2377, 0, 0, 17595, 17589, 1, 0, 0, 0, 17595, + 17590, 1, 0, 0, 0, 17596, 17597, 1, 0, 0, 0, 17597, 17598, 5, 2377, 0, + 0, 17598, 2111, 1, 0, 0, 0, 17599, 17600, 7, 140, 0, 0, 17600, 17616, 3, + 2112, 1056, 0, 17601, 17602, 5, 1358, 0, 0, 17602, 17616, 3, 2112, 1056, + 0, 17603, 17604, 5, 260, 0, 0, 17604, 17616, 3, 2112, 1056, 0, 17605, 17606, + 5, 950, 0, 0, 17606, 17616, 3, 2112, 1056, 0, 17607, 17608, 5, 410, 0, + 0, 17608, 17616, 3, 2112, 1056, 0, 17609, 17610, 5, 37, 0, 0, 17610, 17616, + 3, 2112, 1056, 0, 17611, 17616, 3, 2114, 1057, 0, 17612, 17616, 3, 2128, + 1064, 0, 17613, 17616, 3, 2132, 1066, 0, 17614, 17616, 3, 2126, 1063, 0, + 17615, 17599, 1, 0, 0, 0, 17615, 17601, 1, 0, 0, 0, 17615, 17603, 1, 0, + 0, 0, 17615, 17605, 1, 0, 0, 0, 17615, 17607, 1, 0, 0, 0, 17615, 17609, + 1, 0, 0, 0, 17615, 17611, 1, 0, 0, 0, 17615, 17612, 1, 0, 0, 0, 17615, + 17613, 1, 0, 0, 0, 17615, 17614, 1, 0, 0, 0, 17616, 2113, 1, 0, 0, 0, 17617, + 17620, 3, 2120, 1060, 0, 17618, 17620, 3, 2116, 1058, 0, 17619, 17617, + 1, 0, 0, 0, 17619, 17618, 1, 0, 0, 0, 17620, 2115, 1, 0, 0, 0, 17621, 17623, + 3, 2284, 1142, 0, 17622, 17621, 1, 0, 0, 0, 17622, 17623, 1, 0, 0, 0, 17623, + 17624, 1, 0, 0, 0, 17624, 17625, 5, 169, 0, 0, 17625, 17627, 3, 2078, 1039, + 0, 17626, 17628, 3, 2118, 1059, 0, 17627, 17626, 1, 0, 0, 0, 17628, 17629, + 1, 0, 0, 0, 17629, 17627, 1, 0, 0, 0, 17629, 17630, 1, 0, 0, 0, 17630, + 17632, 1, 0, 0, 0, 17631, 17633, 3, 2124, 1062, 0, 17632, 17631, 1, 0, + 0, 0, 17632, 17633, 1, 0, 0, 0, 17633, 17634, 1, 0, 0, 0, 17634, 17636, + 5, 459, 0, 0, 17635, 17637, 5, 169, 0, 0, 17636, 17635, 1, 0, 0, 0, 17636, + 17637, 1, 0, 0, 0, 17637, 17639, 1, 0, 0, 0, 17638, 17640, 3, 2284, 1142, + 0, 17639, 17638, 1, 0, 0, 0, 17639, 17640, 1, 0, 0, 0, 17640, 2117, 1, + 0, 0, 0, 17641, 17642, 5, 2180, 0, 0, 17642, 17643, 3, 2078, 1039, 0, 17643, + 17646, 5, 1989, 0, 0, 17644, 17647, 3, 1792, 896, 0, 17645, 17647, 3, 2078, + 1039, 0, 17646, 17644, 1, 0, 0, 0, 17646, 17645, 1, 0, 0, 0, 17647, 2119, + 1, 0, 0, 0, 17648, 17650, 3, 2284, 1142, 0, 17649, 17648, 1, 0, 0, 0, 17649, + 17650, 1, 0, 0, 0, 17650, 17651, 1, 0, 0, 0, 17651, 17653, 5, 169, 0, 0, + 17652, 17654, 3, 2122, 1061, 0, 17653, 17652, 1, 0, 0, 0, 17654, 17655, + 1, 0, 0, 0, 17655, 17653, 1, 0, 0, 0, 17655, 17656, 1, 0, 0, 0, 17656, + 17658, 1, 0, 0, 0, 17657, 17659, 3, 2124, 1062, 0, 17658, 17657, 1, 0, + 0, 0, 17658, 17659, 1, 0, 0, 0, 17659, 17660, 1, 0, 0, 0, 17660, 17662, + 5, 459, 0, 0, 17661, 17663, 5, 169, 0, 0, 17662, 17661, 1, 0, 0, 0, 17662, + 17663, 1, 0, 0, 0, 17663, 17665, 1, 0, 0, 0, 17664, 17666, 3, 2284, 1142, + 0, 17665, 17664, 1, 0, 0, 0, 17665, 17666, 1, 0, 0, 0, 17666, 2121, 1, + 0, 0, 0, 17667, 17668, 5, 2180, 0, 0, 17668, 17669, 3, 2078, 1039, 0, 17669, + 17672, 5, 1989, 0, 0, 17670, 17673, 3, 1792, 896, 0, 17671, 17673, 3, 2078, + 1039, 0, 17672, 17670, 1, 0, 0, 0, 17672, 17671, 1, 0, 0, 0, 17673, 2123, + 1, 0, 0, 0, 17674, 17677, 5, 446, 0, 0, 17675, 17678, 3, 1792, 896, 0, + 17676, 17678, 3, 2078, 1039, 0, 17677, 17675, 1, 0, 0, 0, 17677, 17676, + 1, 0, 0, 0, 17678, 2125, 1, 0, 0, 0, 17679, 17680, 3, 2358, 1179, 0, 17680, + 17681, 3, 2380, 1190, 0, 17681, 17699, 1, 0, 0, 0, 17682, 17699, 3, 2352, + 1176, 0, 17683, 17699, 3, 2366, 1183, 0, 17684, 17699, 3, 2354, 1177, 0, + 17685, 17686, 5, 2376, 0, 0, 17686, 17687, 3, 1892, 946, 0, 17687, 17691, + 5, 2377, 0, 0, 17688, 17690, 3, 1896, 948, 0, 17689, 17688, 1, 0, 0, 0, + 17690, 17693, 1, 0, 0, 0, 17691, 17689, 1, 0, 0, 0, 17691, 17692, 1, 0, + 0, 0, 17692, 17699, 1, 0, 0, 0, 17693, 17691, 1, 0, 0, 0, 17694, 17695, + 5, 2376, 0, 0, 17695, 17696, 3, 2076, 1038, 0, 17696, 17697, 5, 2377, 0, + 0, 17697, 17699, 1, 0, 0, 0, 17698, 17679, 1, 0, 0, 0, 17698, 17682, 1, + 0, 0, 0, 17698, 17683, 1, 0, 0, 0, 17698, 17684, 1, 0, 0, 0, 17698, 17685, + 1, 0, 0, 0, 17698, 17694, 1, 0, 0, 0, 17699, 2127, 1, 0, 0, 0, 17700, 17709, + 7, 213, 0, 0, 17701, 17702, 5, 2376, 0, 0, 17702, 17703, 3, 1880, 940, + 0, 17703, 17704, 5, 2377, 0, 0, 17704, 17710, 1, 0, 0, 0, 17705, 17706, + 5, 2376, 0, 0, 17706, 17707, 3, 2078, 1039, 0, 17707, 17708, 5, 2377, 0, + 0, 17708, 17710, 1, 0, 0, 0, 17709, 17701, 1, 0, 0, 0, 17709, 17705, 1, + 0, 0, 0, 17710, 2129, 1, 0, 0, 0, 17711, 17712, 5, 2291, 0, 0, 17712, 17713, + 5, 2376, 0, 0, 17713, 17714, 3, 2078, 1039, 0, 17714, 17715, 5, 2382, 0, + 0, 17715, 17718, 3, 2078, 1039, 0, 17716, 17717, 5, 2382, 0, 0, 17717, + 17719, 3, 2078, 1039, 0, 17718, 17716, 1, 0, 0, 0, 17718, 17719, 1, 0, + 0, 0, 17719, 17720, 1, 0, 0, 0, 17720, 17721, 5, 2377, 0, 0, 17721, 17798, + 1, 0, 0, 0, 17722, 17723, 5, 2292, 0, 0, 17723, 17727, 5, 2376, 0, 0, 17724, + 17728, 3, 2358, 1179, 0, 17725, 17728, 3, 2132, 1066, 0, 17726, 17728, + 3, 2078, 1039, 0, 17727, 17724, 1, 0, 0, 0, 17727, 17725, 1, 0, 0, 0, 17727, + 17726, 1, 0, 0, 0, 17728, 17731, 1, 0, 0, 0, 17729, 17730, 5, 2382, 0, + 0, 17730, 17732, 3, 2372, 1186, 0, 17731, 17729, 1, 0, 0, 0, 17731, 17732, + 1, 0, 0, 0, 17732, 17735, 1, 0, 0, 0, 17733, 17734, 5, 2382, 0, 0, 17734, + 17736, 3, 2372, 1186, 0, 17735, 17733, 1, 0, 0, 0, 17735, 17736, 1, 0, + 0, 0, 17736, 17737, 1, 0, 0, 0, 17737, 17738, 5, 2377, 0, 0, 17738, 17798, + 1, 0, 0, 0, 17739, 17740, 5, 2276, 0, 0, 17740, 17741, 5, 2376, 0, 0, 17741, + 17742, 3, 2076, 1038, 0, 17742, 17743, 5, 2377, 0, 0, 17743, 17798, 1, + 0, 0, 0, 17744, 17745, 5, 190, 0, 0, 17745, 17746, 5, 2376, 0, 0, 17746, + 17747, 3, 2100, 1050, 0, 17747, 17748, 5, 2129, 0, 0, 17748, 17749, 5, + 936, 0, 0, 17749, 17750, 5, 2377, 0, 0, 17750, 17798, 1, 0, 0, 0, 17751, + 17752, 5, 2286, 0, 0, 17752, 17753, 5, 2376, 0, 0, 17753, 17754, 3, 2078, + 1039, 0, 17754, 17755, 5, 2382, 0, 0, 17755, 17756, 3, 2078, 1039, 0, 17756, + 17757, 5, 2377, 0, 0, 17757, 17798, 1, 0, 0, 0, 17758, 17759, 5, 2293, + 0, 0, 17759, 17767, 5, 2376, 0, 0, 17760, 17762, 7, 214, 0, 0, 17761, 17760, + 1, 0, 0, 0, 17761, 17762, 1, 0, 0, 0, 17762, 17764, 1, 0, 0, 0, 17763, + 17765, 3, 2372, 1186, 0, 17764, 17763, 1, 0, 0, 0, 17764, 17765, 1, 0, + 0, 0, 17765, 17766, 1, 0, 0, 0, 17766, 17768, 5, 572, 0, 0, 17767, 17761, + 1, 0, 0, 0, 17767, 17768, 1, 0, 0, 0, 17768, 17769, 1, 0, 0, 0, 17769, + 17770, 3, 2100, 1050, 0, 17770, 17771, 5, 2377, 0, 0, 17771, 17798, 1, + 0, 0, 0, 17772, 17773, 5, 2300, 0, 0, 17773, 17777, 5, 2376, 0, 0, 17774, + 17778, 3, 2358, 1179, 0, 17775, 17778, 3, 2132, 1066, 0, 17776, 17778, + 3, 2078, 1039, 0, 17777, 17774, 1, 0, 0, 0, 17777, 17775, 1, 0, 0, 0, 17777, + 17776, 1, 0, 0, 0, 17778, 17785, 1, 0, 0, 0, 17779, 17780, 5, 363, 0, 0, + 17780, 17781, 3, 2100, 1050, 0, 17781, 17782, 5, 1175, 0, 0, 17782, 17783, + 5, 282, 0, 0, 17783, 17784, 5, 470, 0, 0, 17784, 17786, 1, 0, 0, 0, 17785, + 17779, 1, 0, 0, 0, 17785, 17786, 1, 0, 0, 0, 17786, 17793, 1, 0, 0, 0, + 17787, 17788, 5, 2382, 0, 0, 17788, 17791, 3, 2372, 1186, 0, 17789, 17790, + 5, 2382, 0, 0, 17790, 17792, 3, 2372, 1186, 0, 17791, 17789, 1, 0, 0, 0, + 17791, 17792, 1, 0, 0, 0, 17792, 17794, 1, 0, 0, 0, 17793, 17787, 1, 0, + 0, 0, 17793, 17794, 1, 0, 0, 0, 17794, 17795, 1, 0, 0, 0, 17795, 17796, + 5, 2377, 0, 0, 17796, 17798, 1, 0, 0, 0, 17797, 17711, 1, 0, 0, 0, 17797, + 17722, 1, 0, 0, 0, 17797, 17739, 1, 0, 0, 0, 17797, 17744, 1, 0, 0, 0, + 17797, 17751, 1, 0, 0, 0, 17797, 17758, 1, 0, 0, 0, 17797, 17772, 1, 0, + 0, 0, 17798, 2131, 1, 0, 0, 0, 17799, 17804, 3, 2130, 1065, 0, 17800, 17804, + 3, 2172, 1086, 0, 17801, 17804, 3, 2134, 1067, 0, 17802, 17804, 3, 2178, + 1089, 0, 17803, 17799, 1, 0, 0, 0, 17803, 17800, 1, 0, 0, 0, 17803, 17801, + 1, 0, 0, 0, 17803, 17802, 1, 0, 0, 0, 17804, 2133, 1, 0, 0, 0, 17805, 17806, + 5, 733, 0, 0, 17806, 17807, 5, 2376, 0, 0, 17807, 17812, 3, 2142, 1071, + 0, 17808, 17809, 5, 2382, 0, 0, 17809, 17811, 3, 2142, 1071, 0, 17810, + 17808, 1, 0, 0, 0, 17811, 17814, 1, 0, 0, 0, 17812, 17810, 1, 0, 0, 0, + 17812, 17813, 1, 0, 0, 0, 17813, 17816, 1, 0, 0, 0, 17814, 17812, 1, 0, + 0, 0, 17815, 17817, 3, 2144, 1072, 0, 17816, 17815, 1, 0, 0, 0, 17816, + 17817, 1, 0, 0, 0, 17817, 17819, 1, 0, 0, 0, 17818, 17820, 3, 2146, 1073, + 0, 17819, 17818, 1, 0, 0, 0, 17819, 17820, 1, 0, 0, 0, 17820, 17822, 1, + 0, 0, 0, 17821, 17823, 5, 1659, 0, 0, 17822, 17821, 1, 0, 0, 0, 17822, + 17823, 1, 0, 0, 0, 17823, 17824, 1, 0, 0, 0, 17824, 17825, 5, 2377, 0, + 0, 17825, 17996, 1, 0, 0, 0, 17826, 17827, 5, 732, 0, 0, 17827, 17828, + 5, 2376, 0, 0, 17828, 17831, 3, 2078, 1039, 0, 17829, 17830, 5, 565, 0, + 0, 17830, 17832, 5, 738, 0, 0, 17831, 17829, 1, 0, 0, 0, 17831, 17832, + 1, 0, 0, 0, 17832, 17834, 1, 0, 0, 0, 17833, 17835, 3, 1992, 996, 0, 17834, + 17833, 1, 0, 0, 0, 17834, 17835, 1, 0, 0, 0, 17835, 17837, 1, 0, 0, 0, + 17836, 17838, 3, 2144, 1072, 0, 17837, 17836, 1, 0, 0, 0, 17837, 17838, + 1, 0, 0, 0, 17838, 17840, 1, 0, 0, 0, 17839, 17841, 3, 2146, 1073, 0, 17840, + 17839, 1, 0, 0, 0, 17840, 17841, 1, 0, 0, 0, 17841, 17843, 1, 0, 0, 0, + 17842, 17844, 5, 1659, 0, 0, 17843, 17842, 1, 0, 0, 0, 17843, 17844, 1, + 0, 0, 0, 17844, 17845, 1, 0, 0, 0, 17845, 17846, 5, 2377, 0, 0, 17846, + 17996, 1, 0, 0, 0, 17847, 17848, 5, 740, 0, 0, 17848, 17849, 5, 2376, 0, + 0, 17849, 17850, 3, 2136, 1068, 0, 17850, 17851, 5, 2377, 0, 0, 17851, + 17996, 1, 0, 0, 0, 17852, 17853, 5, 739, 0, 0, 17853, 17855, 5, 2376, 0, + 0, 17854, 17856, 5, 753, 0, 0, 17855, 17854, 1, 0, 0, 0, 17855, 17856, + 1, 0, 0, 0, 17856, 17857, 1, 0, 0, 0, 17857, 17858, 3, 2078, 1039, 0, 17858, + 17859, 5, 2141, 0, 0, 17859, 17863, 3, 2078, 1039, 0, 17860, 17861, 7, + 215, 0, 0, 17861, 17862, 5, 1175, 0, 0, 17862, 17864, 5, 1145, 0, 0, 17863, + 17860, 1, 0, 0, 0, 17863, 17864, 1, 0, 0, 0, 17864, 17879, 1, 0, 0, 0, + 17865, 17877, 5, 1486, 0, 0, 17866, 17873, 5, 2142, 0, 0, 17867, 17868, + 5, 2376, 0, 0, 17868, 17870, 5, 2370, 0, 0, 17869, 17871, 7, 216, 0, 0, + 17870, 17869, 1, 0, 0, 0, 17870, 17871, 1, 0, 0, 0, 17871, 17872, 1, 0, + 0, 0, 17872, 17874, 5, 2377, 0, 0, 17873, 17867, 1, 0, 0, 0, 17873, 17874, + 1, 0, 0, 0, 17874, 17878, 1, 0, 0, 0, 17875, 17878, 5, 201, 0, 0, 17876, + 17878, 5, 133, 0, 0, 17877, 17866, 1, 0, 0, 0, 17877, 17875, 1, 0, 0, 0, + 17877, 17876, 1, 0, 0, 0, 17878, 17880, 1, 0, 0, 0, 17879, 17865, 1, 0, + 0, 0, 17879, 17880, 1, 0, 0, 0, 17880, 17882, 1, 0, 0, 0, 17881, 17883, + 5, 1659, 0, 0, 17882, 17881, 1, 0, 0, 0, 17882, 17883, 1, 0, 0, 0, 17883, + 17887, 1, 0, 0, 0, 17884, 17885, 5, 2188, 0, 0, 17885, 17886, 5, 2068, + 0, 0, 17886, 17888, 5, 756, 0, 0, 17887, 17884, 1, 0, 0, 0, 17887, 17888, + 1, 0, 0, 0, 17888, 17889, 1, 0, 0, 0, 17889, 17890, 5, 2377, 0, 0, 17890, + 17996, 1, 0, 0, 0, 17891, 17892, 5, 742, 0, 0, 17892, 17893, 5, 2376, 0, + 0, 17893, 17896, 3, 2078, 1039, 0, 17894, 17895, 5, 565, 0, 0, 17895, 17897, + 5, 738, 0, 0, 17896, 17894, 1, 0, 0, 0, 17896, 17897, 1, 0, 0, 0, 17897, + 17898, 1, 0, 0, 0, 17898, 17899, 5, 2382, 0, 0, 17899, 17901, 5, 2372, + 0, 0, 17900, 17902, 3, 2154, 1077, 0, 17901, 17900, 1, 0, 0, 0, 17901, + 17902, 1, 0, 0, 0, 17902, 17904, 1, 0, 0, 0, 17903, 17905, 3, 2158, 1079, + 0, 17904, 17903, 1, 0, 0, 0, 17904, 17905, 1, 0, 0, 0, 17905, 17907, 1, + 0, 0, 0, 17906, 17908, 3, 2160, 1080, 0, 17907, 17906, 1, 0, 0, 0, 17907, + 17908, 1, 0, 0, 0, 17908, 17910, 1, 0, 0, 0, 17909, 17911, 3, 2162, 1081, + 0, 17910, 17909, 1, 0, 0, 0, 17910, 17911, 1, 0, 0, 0, 17911, 17912, 1, + 0, 0, 0, 17912, 17913, 5, 2377, 0, 0, 17913, 17996, 1, 0, 0, 0, 17914, + 17915, 5, 743, 0, 0, 17915, 17916, 5, 2376, 0, 0, 17916, 17919, 5, 2372, + 0, 0, 17917, 17918, 5, 1486, 0, 0, 17918, 17920, 3, 2156, 1078, 0, 17919, + 17917, 1, 0, 0, 0, 17919, 17920, 1, 0, 0, 0, 17920, 17922, 1, 0, 0, 0, + 17921, 17923, 5, 1352, 0, 0, 17922, 17921, 1, 0, 0, 0, 17922, 17923, 1, + 0, 0, 0, 17923, 17925, 1, 0, 0, 0, 17924, 17926, 5, 68, 0, 0, 17925, 17924, + 1, 0, 0, 0, 17925, 17926, 1, 0, 0, 0, 17926, 17928, 1, 0, 0, 0, 17927, + 17929, 5, 2046, 0, 0, 17928, 17927, 1, 0, 0, 0, 17928, 17929, 1, 0, 0, + 0, 17929, 17938, 1, 0, 0, 0, 17930, 17935, 5, 1145, 0, 0, 17931, 17935, + 5, 470, 0, 0, 17932, 17933, 5, 451, 0, 0, 17933, 17935, 7, 217, 0, 0, 17934, + 17930, 1, 0, 0, 0, 17934, 17931, 1, 0, 0, 0, 17934, 17932, 1, 0, 0, 0, + 17935, 17936, 1, 0, 0, 0, 17936, 17937, 5, 1175, 0, 0, 17937, 17939, 5, + 470, 0, 0, 17938, 17934, 1, 0, 0, 0, 17938, 17939, 1, 0, 0, 0, 17939, 17940, + 1, 0, 0, 0, 17940, 17996, 5, 2377, 0, 0, 17941, 17942, 5, 747, 0, 0, 17942, + 17943, 5, 2376, 0, 0, 17943, 17944, 3, 2078, 1039, 0, 17944, 17945, 5, + 2382, 0, 0, 17945, 17950, 3, 2148, 1074, 0, 17946, 17947, 5, 2382, 0, 0, + 17947, 17949, 3, 2148, 1074, 0, 17948, 17946, 1, 0, 0, 0, 17949, 17952, + 1, 0, 0, 0, 17950, 17948, 1, 0, 0, 0, 17950, 17951, 1, 0, 0, 0, 17951, + 17953, 1, 0, 0, 0, 17952, 17950, 1, 0, 0, 0, 17953, 17954, 5, 2377, 0, + 0, 17954, 17996, 1, 0, 0, 0, 17955, 17956, 5, 748, 0, 0, 17956, 17957, + 5, 2376, 0, 0, 17957, 17960, 3, 2078, 1039, 0, 17958, 17959, 5, 565, 0, + 0, 17959, 17961, 5, 738, 0, 0, 17960, 17958, 1, 0, 0, 0, 17960, 17961, + 1, 0, 0, 0, 17961, 17993, 1, 0, 0, 0, 17962, 17964, 5, 2382, 0, 0, 17963, + 17965, 5, 2372, 0, 0, 17964, 17963, 1, 0, 0, 0, 17964, 17965, 1, 0, 0, + 0, 17965, 17967, 1, 0, 0, 0, 17966, 17968, 3, 2164, 1082, 0, 17967, 17966, + 1, 0, 0, 0, 17967, 17968, 1, 0, 0, 0, 17968, 17977, 1, 0, 0, 0, 17969, + 17974, 5, 470, 0, 0, 17970, 17974, 5, 1145, 0, 0, 17971, 17972, 5, 363, + 0, 0, 17972, 17974, 3, 2170, 1085, 0, 17973, 17969, 1, 0, 0, 0, 17973, + 17970, 1, 0, 0, 0, 17973, 17971, 1, 0, 0, 0, 17973, 17974, 1, 0, 0, 0, + 17974, 17975, 1, 0, 0, 0, 17975, 17976, 5, 1175, 0, 0, 17976, 17978, 5, + 470, 0, 0, 17977, 17973, 1, 0, 0, 0, 17977, 17978, 1, 0, 0, 0, 17978, 17987, + 1, 0, 0, 0, 17979, 17984, 5, 470, 0, 0, 17980, 17984, 5, 1145, 0, 0, 17981, + 17982, 5, 363, 0, 0, 17982, 17984, 3, 2170, 1085, 0, 17983, 17979, 1, 0, + 0, 0, 17983, 17980, 1, 0, 0, 0, 17983, 17981, 1, 0, 0, 0, 17983, 17984, + 1, 0, 0, 0, 17984, 17985, 1, 0, 0, 0, 17985, 17986, 5, 1175, 0, 0, 17986, + 17988, 5, 451, 0, 0, 17987, 17983, 1, 0, 0, 0, 17987, 17988, 1, 0, 0, 0, + 17988, 17990, 1, 0, 0, 0, 17989, 17991, 3, 2168, 1084, 0, 17990, 17989, + 1, 0, 0, 0, 17990, 17991, 1, 0, 0, 0, 17991, 17992, 1, 0, 0, 0, 17992, + 17994, 5, 2377, 0, 0, 17993, 17962, 1, 0, 0, 0, 17993, 17994, 1, 0, 0, + 0, 17994, 17996, 1, 0, 0, 0, 17995, 17805, 1, 0, 0, 0, 17995, 17826, 1, + 0, 0, 0, 17995, 17847, 1, 0, 0, 0, 17995, 17852, 1, 0, 0, 0, 17995, 17891, + 1, 0, 0, 0, 17995, 17914, 1, 0, 0, 0, 17995, 17941, 1, 0, 0, 0, 17995, + 17955, 1, 0, 0, 0, 17996, 2135, 1, 0, 0, 0, 17997, 18002, 3, 2138, 1069, + 0, 17998, 17999, 5, 2382, 0, 0, 17999, 18001, 3, 2138, 1069, 0, 18000, + 17998, 1, 0, 0, 0, 18001, 18004, 1, 0, 0, 0, 18002, 18000, 1, 0, 0, 0, + 18002, 18003, 1, 0, 0, 0, 18003, 18007, 1, 0, 0, 0, 18004, 18002, 1, 0, + 0, 0, 18005, 18007, 5, 2379, 0, 0, 18006, 17997, 1, 0, 0, 0, 18006, 18005, + 1, 0, 0, 0, 18007, 18009, 1, 0, 0, 0, 18008, 18010, 3, 2144, 1072, 0, 18009, + 18008, 1, 0, 0, 0, 18009, 18010, 1, 0, 0, 0, 18010, 18012, 1, 0, 0, 0, + 18011, 18013, 3, 2146, 1073, 0, 18012, 18011, 1, 0, 0, 0, 18012, 18013, + 1, 0, 0, 0, 18013, 18015, 1, 0, 0, 0, 18014, 18016, 5, 1659, 0, 0, 18015, + 18014, 1, 0, 0, 0, 18015, 18016, 1, 0, 0, 0, 18016, 18020, 1, 0, 0, 0, + 18017, 18018, 5, 2188, 0, 0, 18018, 18019, 5, 2068, 0, 0, 18019, 18021, + 5, 756, 0, 0, 18020, 18017, 1, 0, 0, 0, 18020, 18021, 1, 0, 0, 0, 18021, + 2137, 1, 0, 0, 0, 18022, 18024, 5, 753, 0, 0, 18023, 18022, 1, 0, 0, 0, + 18023, 18024, 1, 0, 0, 0, 18024, 18025, 1, 0, 0, 0, 18025, 18027, 3, 2078, + 1039, 0, 18026, 18028, 7, 218, 0, 0, 18027, 18026, 1, 0, 0, 0, 18027, 18028, + 1, 0, 0, 0, 18028, 18029, 1, 0, 0, 0, 18029, 18030, 3, 2078, 1039, 0, 18030, + 18040, 1, 0, 0, 0, 18031, 18032, 3, 2078, 1039, 0, 18032, 18033, 5, 2395, + 0, 0, 18033, 18036, 3, 2078, 1039, 0, 18034, 18035, 5, 565, 0, 0, 18035, + 18037, 5, 738, 0, 0, 18036, 18034, 1, 0, 0, 0, 18036, 18037, 1, 0, 0, 0, + 18037, 18040, 1, 0, 0, 0, 18038, 18040, 3, 2376, 1188, 0, 18039, 18023, + 1, 0, 0, 0, 18039, 18031, 1, 0, 0, 0, 18039, 18038, 1, 0, 0, 0, 18040, + 2139, 1, 0, 0, 0, 18041, 18042, 5, 744, 0, 0, 18042, 18043, 5, 2376, 0, + 0, 18043, 18046, 3, 2078, 1039, 0, 18044, 18045, 5, 565, 0, 0, 18045, 18047, + 5, 738, 0, 0, 18046, 18044, 1, 0, 0, 0, 18046, 18047, 1, 0, 0, 0, 18047, + 18050, 1, 0, 0, 0, 18048, 18049, 5, 2382, 0, 0, 18049, 18051, 5, 2372, + 0, 0, 18050, 18048, 1, 0, 0, 0, 18050, 18051, 1, 0, 0, 0, 18051, 18055, + 1, 0, 0, 0, 18052, 18053, 7, 219, 0, 0, 18053, 18054, 5, 1175, 0, 0, 18054, + 18056, 5, 470, 0, 0, 18055, 18052, 1, 0, 0, 0, 18055, 18056, 1, 0, 0, 0, + 18056, 18060, 1, 0, 0, 0, 18057, 18058, 7, 220, 0, 0, 18058, 18059, 5, + 1175, 0, 0, 18059, 18061, 5, 451, 0, 0, 18060, 18057, 1, 0, 0, 0, 18060, + 18061, 1, 0, 0, 0, 18061, 18063, 1, 0, 0, 0, 18062, 18064, 3, 2150, 1075, + 0, 18063, 18062, 1, 0, 0, 0, 18063, 18064, 1, 0, 0, 0, 18064, 18065, 1, + 0, 0, 0, 18065, 18066, 5, 2377, 0, 0, 18066, 2141, 1, 0, 0, 0, 18067, 18073, + 3, 2078, 1039, 0, 18068, 18073, 5, 2372, 0, 0, 18069, 18073, 5, 1145, 0, + 0, 18070, 18073, 5, 2370, 0, 0, 18071, 18073, 3, 2134, 1067, 0, 18072, + 18067, 1, 0, 0, 0, 18072, 18068, 1, 0, 0, 0, 18072, 18069, 1, 0, 0, 0, + 18072, 18070, 1, 0, 0, 0, 18072, 18071, 1, 0, 0, 0, 18073, 18076, 1, 0, + 0, 0, 18074, 18075, 5, 565, 0, 0, 18075, 18077, 5, 738, 0, 0, 18076, 18074, + 1, 0, 0, 0, 18076, 18077, 1, 0, 0, 0, 18077, 2143, 1, 0, 0, 0, 18078, 18079, + 7, 215, 0, 0, 18079, 18080, 5, 1175, 0, 0, 18080, 18081, 5, 1145, 0, 0, + 18081, 2145, 1, 0, 0, 0, 18082, 18094, 5, 1486, 0, 0, 18083, 18090, 5, + 2142, 0, 0, 18084, 18085, 5, 2376, 0, 0, 18085, 18087, 5, 2370, 0, 0, 18086, + 18088, 7, 216, 0, 0, 18087, 18086, 1, 0, 0, 0, 18087, 18088, 1, 0, 0, 0, + 18088, 18089, 1, 0, 0, 0, 18089, 18091, 5, 2377, 0, 0, 18090, 18084, 1, + 0, 0, 0, 18090, 18091, 1, 0, 0, 0, 18091, 18095, 1, 0, 0, 0, 18092, 18095, + 5, 201, 0, 0, 18093, 18095, 5, 133, 0, 0, 18094, 18083, 1, 0, 0, 0, 18094, + 18092, 1, 0, 0, 0, 18094, 18093, 1, 0, 0, 0, 18095, 2147, 1, 0, 0, 0, 18096, + 18097, 5, 1459, 0, 0, 18097, 18103, 5, 2372, 0, 0, 18098, 18100, 7, 221, + 0, 0, 18099, 18098, 1, 0, 0, 0, 18099, 18100, 1, 0, 0, 0, 18100, 18101, + 1, 0, 0, 0, 18101, 18102, 5, 1175, 0, 0, 18102, 18104, 5, 893, 0, 0, 18103, + 18099, 1, 0, 0, 0, 18103, 18104, 1, 0, 0, 0, 18104, 18184, 1, 0, 0, 0, + 18105, 18106, 5, 697, 0, 0, 18106, 18107, 5, 2372, 0, 0, 18107, 18108, + 5, 2398, 0, 0, 18108, 18112, 5, 2372, 0, 0, 18109, 18110, 7, 222, 0, 0, + 18110, 18111, 5, 1175, 0, 0, 18111, 18113, 5, 491, 0, 0, 18112, 18109, + 1, 0, 0, 0, 18112, 18113, 1, 0, 0, 0, 18113, 18119, 1, 0, 0, 0, 18114, + 18116, 7, 223, 0, 0, 18115, 18114, 1, 0, 0, 0, 18115, 18116, 1, 0, 0, 0, + 18116, 18117, 1, 0, 0, 0, 18117, 18118, 5, 1175, 0, 0, 18118, 18120, 5, + 1145, 0, 0, 18119, 18115, 1, 0, 0, 0, 18119, 18120, 1, 0, 0, 0, 18120, + 18184, 1, 0, 0, 0, 18121, 18122, 5, 1463, 0, 0, 18122, 18123, 5, 2372, + 0, 0, 18123, 18124, 5, 2398, 0, 0, 18124, 18128, 5, 2372, 0, 0, 18125, + 18126, 7, 224, 0, 0, 18126, 18127, 5, 1175, 0, 0, 18127, 18129, 5, 893, + 0, 0, 18128, 18125, 1, 0, 0, 0, 18128, 18129, 1, 0, 0, 0, 18129, 18135, + 1, 0, 0, 0, 18130, 18132, 7, 225, 0, 0, 18131, 18130, 1, 0, 0, 0, 18131, + 18132, 1, 0, 0, 0, 18132, 18133, 1, 0, 0, 0, 18133, 18134, 5, 1175, 0, + 0, 18134, 18136, 5, 1145, 0, 0, 18135, 18131, 1, 0, 0, 0, 18135, 18136, + 1, 0, 0, 0, 18136, 18184, 1, 0, 0, 0, 18137, 18140, 3, 2078, 1039, 0, 18138, + 18139, 5, 565, 0, 0, 18139, 18141, 5, 738, 0, 0, 18140, 18138, 1, 0, 0, + 0, 18140, 18141, 1, 0, 0, 0, 18141, 18184, 1, 0, 0, 0, 18142, 18143, 5, + 55, 0, 0, 18143, 18144, 5, 2372, 0, 0, 18144, 18145, 5, 2398, 0, 0, 18145, + 18149, 5, 2372, 0, 0, 18146, 18147, 7, 224, 0, 0, 18147, 18148, 5, 1175, + 0, 0, 18148, 18150, 5, 893, 0, 0, 18149, 18146, 1, 0, 0, 0, 18149, 18150, + 1, 0, 0, 0, 18150, 18156, 1, 0, 0, 0, 18151, 18153, 7, 225, 0, 0, 18152, + 18151, 1, 0, 0, 0, 18152, 18153, 1, 0, 0, 0, 18153, 18154, 1, 0, 0, 0, + 18154, 18155, 5, 1175, 0, 0, 18155, 18157, 5, 1145, 0, 0, 18156, 18152, + 1, 0, 0, 0, 18156, 18157, 1, 0, 0, 0, 18157, 18184, 1, 0, 0, 0, 18158, + 18159, 5, 1568, 0, 0, 18159, 18160, 5, 2372, 0, 0, 18160, 18161, 5, 2398, + 0, 0, 18161, 18164, 3, 2078, 1039, 0, 18162, 18163, 5, 565, 0, 0, 18163, + 18165, 5, 738, 0, 0, 18164, 18162, 1, 0, 0, 0, 18164, 18165, 1, 0, 0, 0, + 18165, 18169, 1, 0, 0, 0, 18166, 18167, 7, 222, 0, 0, 18167, 18168, 5, + 1175, 0, 0, 18168, 18170, 5, 491, 0, 0, 18169, 18166, 1, 0, 0, 0, 18169, + 18170, 1, 0, 0, 0, 18170, 18174, 1, 0, 0, 0, 18171, 18172, 7, 224, 0, 0, + 18172, 18173, 5, 1175, 0, 0, 18173, 18175, 5, 893, 0, 0, 18174, 18171, + 1, 0, 0, 0, 18174, 18175, 1, 0, 0, 0, 18175, 18181, 1, 0, 0, 0, 18176, + 18178, 7, 225, 0, 0, 18177, 18176, 1, 0, 0, 0, 18177, 18178, 1, 0, 0, 0, + 18178, 18179, 1, 0, 0, 0, 18179, 18180, 5, 1175, 0, 0, 18180, 18182, 5, + 1145, 0, 0, 18181, 18177, 1, 0, 0, 0, 18181, 18182, 1, 0, 0, 0, 18182, + 18184, 1, 0, 0, 0, 18183, 18096, 1, 0, 0, 0, 18183, 18105, 1, 0, 0, 0, + 18183, 18121, 1, 0, 0, 0, 18183, 18137, 1, 0, 0, 0, 18183, 18142, 1, 0, + 0, 0, 18183, 18158, 1, 0, 0, 0, 18184, 2149, 1, 0, 0, 0, 18185, 18186, + 5, 223, 0, 0, 18186, 18187, 5, 2376, 0, 0, 18187, 18192, 3, 2152, 1076, + 0, 18188, 18189, 5, 2382, 0, 0, 18189, 18191, 3, 2152, 1076, 0, 18190, + 18188, 1, 0, 0, 0, 18191, 18194, 1, 0, 0, 0, 18192, 18190, 1, 0, 0, 0, + 18192, 18193, 1, 0, 0, 0, 18193, 18195, 1, 0, 0, 0, 18194, 18192, 1, 0, + 0, 0, 18195, 18196, 5, 2377, 0, 0, 18196, 2151, 1, 0, 0, 0, 18197, 18199, + 3, 2078, 1039, 0, 18198, 18200, 3, 2166, 1083, 0, 18199, 18198, 1, 0, 0, + 0, 18199, 18200, 1, 0, 0, 0, 18200, 18211, 1, 0, 0, 0, 18201, 18203, 5, + 492, 0, 0, 18202, 18201, 1, 0, 0, 0, 18202, 18203, 1, 0, 0, 0, 18203, 18204, + 1, 0, 0, 0, 18204, 18205, 5, 1271, 0, 0, 18205, 18212, 5, 2372, 0, 0, 18206, + 18209, 5, 2046, 0, 0, 18207, 18208, 5, 1271, 0, 0, 18208, 18210, 5, 2372, + 0, 0, 18209, 18207, 1, 0, 0, 0, 18209, 18210, 1, 0, 0, 0, 18210, 18212, + 1, 0, 0, 0, 18211, 18202, 1, 0, 0, 0, 18211, 18206, 1, 0, 0, 0, 18211, + 18212, 1, 0, 0, 0, 18212, 18214, 1, 0, 0, 0, 18213, 18215, 3, 2160, 1080, + 0, 18214, 18213, 1, 0, 0, 0, 18214, 18215, 1, 0, 0, 0, 18215, 18217, 1, + 0, 0, 0, 18216, 18218, 3, 2162, 1081, 0, 18217, 18216, 1, 0, 0, 0, 18217, + 18218, 1, 0, 0, 0, 18218, 18251, 1, 0, 0, 0, 18219, 18221, 3, 2078, 1039, + 0, 18220, 18222, 3, 2156, 1078, 0, 18221, 18220, 1, 0, 0, 0, 18221, 18222, + 1, 0, 0, 0, 18222, 18224, 1, 0, 0, 0, 18223, 18225, 5, 2046, 0, 0, 18224, + 18223, 1, 0, 0, 0, 18224, 18225, 1, 0, 0, 0, 18225, 18226, 1, 0, 0, 0, + 18226, 18227, 5, 565, 0, 0, 18227, 18229, 5, 738, 0, 0, 18228, 18230, 3, + 2158, 1079, 0, 18229, 18228, 1, 0, 0, 0, 18229, 18230, 1, 0, 0, 0, 18230, + 18231, 1, 0, 0, 0, 18231, 18232, 5, 1271, 0, 0, 18232, 18233, 5, 2372, + 0, 0, 18233, 18251, 1, 0, 0, 0, 18234, 18236, 5, 942, 0, 0, 18235, 18237, + 5, 1271, 0, 0, 18236, 18235, 1, 0, 0, 0, 18236, 18237, 1, 0, 0, 0, 18237, + 18238, 1, 0, 0, 0, 18238, 18242, 3, 2078, 1039, 0, 18239, 18240, 5, 2399, + 0, 0, 18240, 18241, 5, 2379, 0, 0, 18241, 18243, 5, 2400, 0, 0, 18242, + 18239, 1, 0, 0, 0, 18242, 18243, 1, 0, 0, 0, 18243, 18244, 1, 0, 0, 0, + 18244, 18245, 3, 2150, 1075, 0, 18245, 18251, 1, 0, 0, 0, 18246, 18247, + 3, 2078, 1039, 0, 18247, 18248, 5, 564, 0, 0, 18248, 18249, 5, 1216, 0, + 0, 18249, 18251, 1, 0, 0, 0, 18250, 18197, 1, 0, 0, 0, 18250, 18219, 1, + 0, 0, 0, 18250, 18234, 1, 0, 0, 0, 18250, 18246, 1, 0, 0, 0, 18251, 2153, + 1, 0, 0, 0, 18252, 18253, 5, 1486, 0, 0, 18253, 18255, 3, 2156, 1078, 0, + 18254, 18252, 1, 0, 0, 0, 18254, 18255, 1, 0, 0, 0, 18255, 18257, 1, 0, + 0, 0, 18256, 18258, 5, 1352, 0, 0, 18257, 18256, 1, 0, 0, 0, 18257, 18258, + 1, 0, 0, 0, 18258, 18260, 1, 0, 0, 0, 18259, 18261, 5, 68, 0, 0, 18260, + 18259, 1, 0, 0, 0, 18260, 18261, 1, 0, 0, 0, 18261, 2155, 1, 0, 0, 0, 18262, + 18269, 5, 2142, 0, 0, 18263, 18264, 5, 2376, 0, 0, 18264, 18266, 5, 2370, + 0, 0, 18265, 18267, 7, 216, 0, 0, 18266, 18265, 1, 0, 0, 0, 18266, 18267, + 1, 0, 0, 0, 18267, 18268, 1, 0, 0, 0, 18268, 18270, 5, 2377, 0, 0, 18269, + 18263, 1, 0, 0, 0, 18269, 18270, 1, 0, 0, 0, 18270, 18274, 1, 0, 0, 0, + 18271, 18274, 5, 201, 0, 0, 18272, 18274, 5, 133, 0, 0, 18273, 18262, 1, + 0, 0, 0, 18273, 18271, 1, 0, 0, 0, 18273, 18272, 1, 0, 0, 0, 18274, 2157, + 1, 0, 0, 0, 18275, 18277, 5, 2186, 0, 0, 18276, 18278, 5, 65, 0, 0, 18277, + 18276, 1, 0, 0, 0, 18277, 18278, 1, 0, 0, 0, 18278, 18279, 1, 0, 0, 0, + 18279, 18289, 5, 2191, 0, 0, 18280, 18282, 5, 2188, 0, 0, 18281, 18283, + 7, 226, 0, 0, 18282, 18281, 1, 0, 0, 0, 18282, 18283, 1, 0, 0, 0, 18283, + 18285, 1, 0, 0, 0, 18284, 18286, 5, 65, 0, 0, 18285, 18284, 1, 0, 0, 0, + 18285, 18286, 1, 0, 0, 0, 18286, 18287, 1, 0, 0, 0, 18287, 18289, 5, 2191, + 0, 0, 18288, 18275, 1, 0, 0, 0, 18288, 18280, 1, 0, 0, 0, 18289, 2159, + 1, 0, 0, 0, 18290, 18298, 5, 470, 0, 0, 18291, 18298, 5, 1145, 0, 0, 18292, + 18298, 5, 451, 0, 0, 18293, 18294, 5, 451, 0, 0, 18294, 18298, 5, 65, 0, + 0, 18295, 18296, 5, 451, 0, 0, 18296, 18298, 5, 1155, 0, 0, 18297, 18290, + 1, 0, 0, 0, 18297, 18291, 1, 0, 0, 0, 18297, 18292, 1, 0, 0, 0, 18297, + 18293, 1, 0, 0, 0, 18297, 18295, 1, 0, 0, 0, 18297, 18298, 1, 0, 0, 0, + 18298, 18299, 1, 0, 0, 0, 18299, 18300, 5, 1175, 0, 0, 18300, 18301, 5, + 470, 0, 0, 18301, 2161, 1, 0, 0, 0, 18302, 18310, 5, 470, 0, 0, 18303, + 18310, 5, 1145, 0, 0, 18304, 18310, 5, 451, 0, 0, 18305, 18306, 5, 451, + 0, 0, 18306, 18310, 5, 65, 0, 0, 18307, 18308, 5, 451, 0, 0, 18308, 18310, + 5, 1155, 0, 0, 18309, 18302, 1, 0, 0, 0, 18309, 18303, 1, 0, 0, 0, 18309, + 18304, 1, 0, 0, 0, 18309, 18305, 1, 0, 0, 0, 18309, 18307, 1, 0, 0, 0, + 18309, 18310, 1, 0, 0, 0, 18310, 18311, 1, 0, 0, 0, 18311, 18312, 5, 1175, + 0, 0, 18312, 18313, 5, 451, 0, 0, 18313, 2163, 1, 0, 0, 0, 18314, 18316, + 5, 1486, 0, 0, 18315, 18317, 3, 2166, 1083, 0, 18316, 18315, 1, 0, 0, 0, + 18316, 18317, 1, 0, 0, 0, 18317, 18319, 1, 0, 0, 0, 18318, 18320, 5, 68, + 0, 0, 18319, 18318, 1, 0, 0, 0, 18319, 18320, 1, 0, 0, 0, 18320, 2165, + 1, 0, 0, 0, 18321, 18328, 5, 2142, 0, 0, 18322, 18323, 5, 2376, 0, 0, 18323, + 18325, 5, 2370, 0, 0, 18324, 18326, 7, 216, 0, 0, 18325, 18324, 1, 0, 0, + 0, 18325, 18326, 1, 0, 0, 0, 18326, 18327, 1, 0, 0, 0, 18327, 18329, 5, + 2377, 0, 0, 18328, 18322, 1, 0, 0, 0, 18328, 18329, 1, 0, 0, 0, 18329, + 18331, 1, 0, 0, 0, 18330, 18332, 5, 2046, 0, 0, 18331, 18330, 1, 0, 0, + 0, 18331, 18332, 1, 0, 0, 0, 18332, 18356, 1, 0, 0, 0, 18333, 18356, 5, + 201, 0, 0, 18334, 18356, 5, 339, 0, 0, 18335, 18336, 5, 1147, 0, 0, 18336, + 18337, 5, 2376, 0, 0, 18337, 18340, 5, 710, 0, 0, 18338, 18339, 5, 2382, + 0, 0, 18339, 18341, 5, 710, 0, 0, 18340, 18338, 1, 0, 0, 0, 18340, 18341, + 1, 0, 0, 0, 18341, 18342, 1, 0, 0, 0, 18342, 18356, 5, 2377, 0, 0, 18343, + 18346, 5, 1997, 0, 0, 18344, 18345, 5, 2188, 0, 0, 18345, 18347, 5, 2002, + 0, 0, 18346, 18344, 1, 0, 0, 0, 18346, 18347, 1, 0, 0, 0, 18347, 18356, + 1, 0, 0, 0, 18348, 18356, 5, 1534, 0, 0, 18349, 18353, 3, 2078, 1039, 0, + 18350, 18351, 5, 2129, 0, 0, 18351, 18352, 5, 171, 0, 0, 18352, 18354, + 5, 841, 0, 0, 18353, 18350, 1, 0, 0, 0, 18353, 18354, 1, 0, 0, 0, 18354, + 18356, 1, 0, 0, 0, 18355, 18321, 1, 0, 0, 0, 18355, 18333, 1, 0, 0, 0, + 18355, 18334, 1, 0, 0, 0, 18355, 18335, 1, 0, 0, 0, 18355, 18343, 1, 0, + 0, 0, 18355, 18348, 1, 0, 0, 0, 18355, 18349, 1, 0, 0, 0, 18356, 2167, + 1, 0, 0, 0, 18357, 18358, 7, 225, 0, 0, 18358, 18359, 5, 1175, 0, 0, 18359, + 18368, 5, 894, 0, 0, 18360, 18361, 5, 2376, 0, 0, 18361, 18362, 5, 893, + 0, 0, 18362, 18369, 5, 330, 0, 0, 18363, 18364, 5, 512, 0, 0, 18364, 18369, + 5, 330, 0, 0, 18365, 18366, 5, 2053, 0, 0, 18366, 18367, 5, 470, 0, 0, + 18367, 18369, 5, 2377, 0, 0, 18368, 18360, 1, 0, 0, 0, 18368, 18363, 1, + 0, 0, 0, 18368, 18365, 1, 0, 0, 0, 18368, 18369, 1, 0, 0, 0, 18369, 2169, + 1, 0, 0, 0, 18370, 18375, 5, 2372, 0, 0, 18371, 18375, 3, 2130, 1065, 0, + 18372, 18375, 3, 2368, 1184, 0, 18373, 18375, 5, 861, 0, 0, 18374, 18370, + 1, 0, 0, 0, 18374, 18371, 1, 0, 0, 0, 18374, 18372, 1, 0, 0, 0, 18374, + 18373, 1, 0, 0, 0, 18375, 2171, 1, 0, 0, 0, 18376, 18379, 3, 2174, 1087, + 0, 18377, 18380, 3, 2108, 1054, 0, 18378, 18380, 3, 2110, 1055, 0, 18379, + 18377, 1, 0, 0, 0, 18379, 18378, 1, 0, 0, 0, 18379, 18380, 1, 0, 0, 0, + 18380, 2173, 1, 0, 0, 0, 18381, 18382, 5, 2294, 0, 0, 18382, 18384, 5, + 2376, 0, 0, 18383, 18385, 7, 227, 0, 0, 18384, 18383, 1, 0, 0, 0, 18384, + 18385, 1, 0, 0, 0, 18385, 18386, 1, 0, 0, 0, 18386, 18387, 3, 2078, 1039, + 0, 18387, 18388, 5, 2377, 0, 0, 18388, 18440, 1, 0, 0, 0, 18389, 18390, + 5, 294, 0, 0, 18390, 18398, 5, 2376, 0, 0, 18391, 18399, 5, 2379, 0, 0, + 18392, 18394, 7, 192, 0, 0, 18393, 18392, 1, 0, 0, 0, 18393, 18394, 1, + 0, 0, 0, 18394, 18395, 1, 0, 0, 0, 18395, 18397, 3, 2100, 1050, 0, 18396, + 18393, 1, 0, 0, 0, 18396, 18397, 1, 0, 0, 0, 18397, 18399, 1, 0, 0, 0, + 18398, 18391, 1, 0, 0, 0, 18398, 18396, 1, 0, 0, 0, 18399, 18400, 1, 0, + 0, 0, 18400, 18402, 5, 2377, 0, 0, 18401, 18403, 3, 2186, 1093, 0, 18402, + 18401, 1, 0, 0, 0, 18402, 18403, 1, 0, 0, 0, 18403, 18440, 1, 0, 0, 0, + 18404, 18405, 5, 2289, 0, 0, 18405, 18406, 5, 2376, 0, 0, 18406, 18409, + 3, 2078, 1039, 0, 18407, 18408, 5, 2382, 0, 0, 18408, 18410, 5, 2370, 0, + 0, 18409, 18407, 1, 0, 0, 0, 18409, 18410, 1, 0, 0, 0, 18410, 18411, 1, + 0, 0, 0, 18411, 18412, 5, 2377, 0, 0, 18412, 18440, 1, 0, 0, 0, 18413, + 18414, 5, 2273, 0, 0, 18414, 18416, 5, 2376, 0, 0, 18415, 18417, 7, 227, + 0, 0, 18416, 18415, 1, 0, 0, 0, 18416, 18417, 1, 0, 0, 0, 18417, 18418, + 1, 0, 0, 0, 18418, 18419, 3, 2078, 1039, 0, 18419, 18420, 5, 2377, 0, 0, + 18420, 18440, 1, 0, 0, 0, 18421, 18422, 5, 2281, 0, 0, 18422, 18424, 5, + 2376, 0, 0, 18423, 18425, 7, 227, 0, 0, 18424, 18423, 1, 0, 0, 0, 18424, + 18425, 1, 0, 0, 0, 18425, 18426, 1, 0, 0, 0, 18426, 18427, 3, 2078, 1039, + 0, 18427, 18428, 5, 2377, 0, 0, 18428, 18440, 1, 0, 0, 0, 18429, 18430, + 5, 2298, 0, 0, 18430, 18431, 5, 2376, 0, 0, 18431, 18432, 3, 2076, 1038, + 0, 18432, 18433, 5, 2377, 0, 0, 18433, 18440, 1, 0, 0, 0, 18434, 18435, + 5, 2299, 0, 0, 18435, 18436, 5, 2376, 0, 0, 18436, 18437, 3, 2076, 1038, + 0, 18437, 18438, 5, 2377, 0, 0, 18438, 18440, 1, 0, 0, 0, 18439, 18381, + 1, 0, 0, 0, 18439, 18389, 1, 0, 0, 0, 18439, 18404, 1, 0, 0, 0, 18439, + 18413, 1, 0, 0, 0, 18439, 18421, 1, 0, 0, 0, 18439, 18429, 1, 0, 0, 0, + 18439, 18434, 1, 0, 0, 0, 18440, 2175, 1, 0, 0, 0, 18441, 18442, 5, 1175, + 0, 0, 18442, 18443, 5, 1231, 0, 0, 18443, 18445, 7, 209, 0, 0, 18444, 18446, + 5, 2372, 0, 0, 18445, 18444, 1, 0, 0, 0, 18445, 18446, 1, 0, 0, 0, 18446, + 18449, 1, 0, 0, 0, 18447, 18448, 7, 2, 0, 0, 18448, 18450, 5, 294, 0, 0, + 18449, 18447, 1, 0, 0, 0, 18449, 18450, 1, 0, 0, 0, 18450, 2177, 1, 0, + 0, 0, 18451, 18452, 3, 2180, 1090, 0, 18452, 18454, 3, 2336, 1168, 0, 18453, + 18455, 3, 2186, 1093, 0, 18454, 18453, 1, 0, 0, 0, 18454, 18455, 1, 0, + 0, 0, 18455, 18839, 1, 0, 0, 0, 18456, 18457, 3, 2382, 1191, 0, 18457, + 18459, 3, 2338, 1169, 0, 18458, 18460, 3, 2194, 1097, 0, 18459, 18458, + 1, 0, 0, 0, 18459, 18460, 1, 0, 0, 0, 18460, 18839, 1, 0, 0, 0, 18461, + 18462, 5, 294, 0, 0, 18462, 18468, 5, 2376, 0, 0, 18463, 18469, 5, 2379, + 0, 0, 18464, 18466, 7, 192, 0, 0, 18465, 18464, 1, 0, 0, 0, 18465, 18466, + 1, 0, 0, 0, 18466, 18467, 1, 0, 0, 0, 18467, 18469, 3, 2100, 1050, 0, 18468, + 18463, 1, 0, 0, 0, 18468, 18465, 1, 0, 0, 0, 18469, 18470, 1, 0, 0, 0, + 18470, 18472, 5, 2377, 0, 0, 18471, 18473, 3, 2186, 1093, 0, 18472, 18471, + 1, 0, 0, 0, 18472, 18473, 1, 0, 0, 0, 18473, 18839, 1, 0, 0, 0, 18474, + 18475, 7, 228, 0, 0, 18475, 18482, 5, 2376, 0, 0, 18476, 18477, 5, 923, + 0, 0, 18477, 18478, 5, 2376, 0, 0, 18478, 18479, 3, 1892, 946, 0, 18479, + 18480, 5, 2377, 0, 0, 18480, 18483, 1, 0, 0, 0, 18481, 18483, 3, 2100, + 1050, 0, 18482, 18476, 1, 0, 0, 0, 18482, 18481, 1, 0, 0, 0, 18483, 18484, + 1, 0, 0, 0, 18484, 18485, 5, 66, 0, 0, 18485, 18492, 3, 2344, 1172, 0, + 18486, 18487, 5, 363, 0, 0, 18487, 18488, 3, 2100, 1050, 0, 18488, 18489, + 5, 1175, 0, 0, 18489, 18490, 5, 282, 0, 0, 18490, 18491, 5, 470, 0, 0, + 18491, 18493, 1, 0, 0, 0, 18492, 18486, 1, 0, 0, 0, 18492, 18493, 1, 0, + 0, 0, 18493, 18500, 1, 0, 0, 0, 18494, 18495, 5, 2382, 0, 0, 18495, 18498, + 3, 2372, 1186, 0, 18496, 18497, 5, 2382, 0, 0, 18497, 18499, 3, 2372, 1186, + 0, 18498, 18496, 1, 0, 0, 0, 18498, 18499, 1, 0, 0, 0, 18499, 18501, 1, + 0, 0, 0, 18500, 18494, 1, 0, 0, 0, 18500, 18501, 1, 0, 0, 0, 18501, 18502, + 1, 0, 0, 0, 18502, 18503, 5, 2377, 0, 0, 18503, 18839, 1, 0, 0, 0, 18504, + 18505, 5, 214, 0, 0, 18505, 18506, 5, 2376, 0, 0, 18506, 18512, 3, 2358, + 1179, 0, 18507, 18510, 5, 2382, 0, 0, 18508, 18511, 3, 2368, 1184, 0, 18509, + 18511, 3, 2372, 1186, 0, 18510, 18508, 1, 0, 0, 0, 18510, 18509, 1, 0, + 0, 0, 18511, 18513, 1, 0, 0, 0, 18512, 18507, 1, 0, 0, 0, 18512, 18513, + 1, 0, 0, 0, 18513, 18514, 1, 0, 0, 0, 18514, 18515, 5, 2377, 0, 0, 18515, + 18839, 1, 0, 0, 0, 18516, 18517, 5, 219, 0, 0, 18517, 18519, 5, 2376, 0, + 0, 18518, 18520, 7, 229, 0, 0, 18519, 18518, 1, 0, 0, 0, 18519, 18520, + 1, 0, 0, 0, 18520, 18521, 1, 0, 0, 0, 18521, 18523, 3, 2100, 1050, 0, 18522, + 18524, 3, 2198, 1099, 0, 18523, 18522, 1, 0, 0, 0, 18523, 18524, 1, 0, + 0, 0, 18524, 18525, 1, 0, 0, 0, 18525, 18526, 5, 2377, 0, 0, 18526, 18839, + 1, 0, 0, 0, 18527, 18528, 3, 2182, 1091, 0, 18528, 18530, 3, 2334, 1167, + 0, 18529, 18531, 3, 2200, 1100, 0, 18530, 18529, 1, 0, 0, 0, 18531, 18532, + 1, 0, 0, 0, 18532, 18530, 1, 0, 0, 0, 18532, 18533, 1, 0, 0, 0, 18533, + 18839, 1, 0, 0, 0, 18534, 18535, 5, 2268, 0, 0, 18535, 18537, 5, 2376, + 0, 0, 18536, 18538, 7, 192, 0, 0, 18537, 18536, 1, 0, 0, 0, 18537, 18538, + 1, 0, 0, 0, 18538, 18539, 1, 0, 0, 0, 18539, 18542, 3, 2342, 1171, 0, 18540, + 18541, 5, 2382, 0, 0, 18541, 18543, 5, 2372, 0, 0, 18542, 18540, 1, 0, + 0, 0, 18542, 18543, 1, 0, 0, 0, 18543, 18545, 1, 0, 0, 0, 18544, 18546, + 3, 2176, 1088, 0, 18545, 18544, 1, 0, 0, 0, 18545, 18546, 1, 0, 0, 0, 18546, + 18547, 1, 0, 0, 0, 18547, 18554, 5, 2377, 0, 0, 18548, 18549, 5, 2185, + 0, 0, 18549, 18550, 5, 593, 0, 0, 18550, 18551, 5, 2376, 0, 0, 18551, 18552, + 3, 1992, 996, 0, 18552, 18553, 5, 2377, 0, 0, 18553, 18555, 1, 0, 0, 0, + 18554, 18548, 1, 0, 0, 0, 18554, 18555, 1, 0, 0, 0, 18555, 18557, 1, 0, + 0, 0, 18556, 18558, 3, 2186, 1093, 0, 18557, 18556, 1, 0, 0, 0, 18557, + 18558, 1, 0, 0, 0, 18558, 18839, 1, 0, 0, 0, 18559, 18560, 3, 2302, 1151, + 0, 18560, 18561, 7, 230, 0, 0, 18561, 18839, 1, 0, 0, 0, 18562, 18563, + 5, 357, 0, 0, 18563, 18564, 5, 2376, 0, 0, 18564, 18566, 3, 2100, 1050, + 0, 18565, 18567, 7, 231, 0, 0, 18566, 18565, 1, 0, 0, 0, 18566, 18567, + 1, 0, 0, 0, 18567, 18568, 1, 0, 0, 0, 18568, 18569, 5, 2377, 0, 0, 18569, + 18839, 1, 0, 0, 0, 18570, 18571, 5, 510, 0, 0, 18571, 18572, 5, 2376, 0, + 0, 18572, 18573, 3, 2382, 1191, 0, 18573, 18574, 5, 572, 0, 0, 18574, 18575, + 3, 2100, 1050, 0, 18575, 18576, 5, 2377, 0, 0, 18576, 18839, 1, 0, 0, 0, + 18577, 18578, 7, 232, 0, 0, 18578, 18580, 3, 2336, 1168, 0, 18579, 18581, + 3, 2340, 1170, 0, 18580, 18579, 1, 0, 0, 0, 18580, 18581, 1, 0, 0, 0, 18581, + 18582, 1, 0, 0, 0, 18582, 18583, 3, 2186, 1093, 0, 18583, 18839, 1, 0, + 0, 0, 18584, 18585, 3, 2184, 1092, 0, 18585, 18586, 5, 2376, 0, 0, 18586, + 18588, 3, 2076, 1038, 0, 18587, 18589, 3, 2202, 1101, 0, 18588, 18587, + 1, 0, 0, 0, 18588, 18589, 1, 0, 0, 0, 18589, 18591, 1, 0, 0, 0, 18590, + 18592, 3, 2194, 1097, 0, 18591, 18590, 1, 0, 0, 0, 18591, 18592, 1, 0, + 0, 0, 18592, 18593, 1, 0, 0, 0, 18593, 18594, 5, 2377, 0, 0, 18594, 18839, + 1, 0, 0, 0, 18595, 18596, 7, 233, 0, 0, 18596, 18597, 5, 2376, 0, 0, 18597, + 18604, 3, 2100, 1050, 0, 18598, 18599, 5, 363, 0, 0, 18599, 18600, 3, 2100, + 1050, 0, 18600, 18601, 5, 1175, 0, 0, 18601, 18602, 5, 282, 0, 0, 18602, + 18603, 5, 470, 0, 0, 18603, 18605, 1, 0, 0, 0, 18604, 18598, 1, 0, 0, 0, + 18604, 18605, 1, 0, 0, 0, 18605, 18612, 1, 0, 0, 0, 18606, 18607, 5, 2382, + 0, 0, 18607, 18610, 3, 2372, 1186, 0, 18608, 18609, 5, 2382, 0, 0, 18609, + 18611, 3, 2372, 1186, 0, 18610, 18608, 1, 0, 0, 0, 18610, 18611, 1, 0, + 0, 0, 18611, 18613, 1, 0, 0, 0, 18612, 18606, 1, 0, 0, 0, 18612, 18613, + 1, 0, 0, 0, 18613, 18614, 1, 0, 0, 0, 18614, 18615, 5, 2377, 0, 0, 18615, + 18839, 1, 0, 0, 0, 18616, 18617, 7, 234, 0, 0, 18617, 18618, 5, 2376, 0, + 0, 18618, 18625, 3, 2100, 1050, 0, 18619, 18620, 5, 363, 0, 0, 18620, 18621, + 3, 2100, 1050, 0, 18621, 18622, 5, 1175, 0, 0, 18622, 18623, 5, 282, 0, + 0, 18623, 18624, 5, 470, 0, 0, 18624, 18626, 1, 0, 0, 0, 18625, 18619, + 1, 0, 0, 0, 18625, 18626, 1, 0, 0, 0, 18626, 18627, 1, 0, 0, 0, 18627, + 18628, 5, 2377, 0, 0, 18628, 18839, 1, 0, 0, 0, 18629, 18630, 5, 2040, + 0, 0, 18630, 18631, 5, 2376, 0, 0, 18631, 18634, 3, 2078, 1039, 0, 18632, + 18633, 5, 2129, 0, 0, 18633, 18635, 7, 235, 0, 0, 18634, 18632, 1, 0, 0, + 0, 18634, 18635, 1, 0, 0, 0, 18635, 18640, 1, 0, 0, 0, 18636, 18637, 5, + 2382, 0, 0, 18637, 18639, 3, 2078, 1039, 0, 18638, 18636, 1, 0, 0, 0, 18639, + 18642, 1, 0, 0, 0, 18640, 18638, 1, 0, 0, 0, 18640, 18641, 1, 0, 0, 0, + 18641, 18643, 1, 0, 0, 0, 18642, 18640, 1, 0, 0, 0, 18643, 18644, 5, 2377, + 0, 0, 18644, 18839, 1, 0, 0, 0, 18645, 18646, 5, 2042, 0, 0, 18646, 18647, + 5, 2376, 0, 0, 18647, 18648, 3, 2078, 1039, 0, 18648, 18650, 5, 66, 0, + 0, 18649, 18651, 5, 1431, 0, 0, 18650, 18649, 1, 0, 0, 0, 18650, 18651, + 1, 0, 0, 0, 18651, 18652, 1, 0, 0, 0, 18652, 18653, 3, 2344, 1172, 0, 18653, + 18654, 5, 2377, 0, 0, 18654, 18839, 1, 0, 0, 0, 18655, 18656, 5, 2293, + 0, 0, 18656, 18664, 5, 2376, 0, 0, 18657, 18659, 7, 214, 0, 0, 18658, 18657, + 1, 0, 0, 0, 18658, 18659, 1, 0, 0, 0, 18659, 18661, 1, 0, 0, 0, 18660, + 18662, 3, 2372, 1186, 0, 18661, 18660, 1, 0, 0, 0, 18661, 18662, 1, 0, + 0, 0, 18662, 18663, 1, 0, 0, 0, 18663, 18665, 5, 572, 0, 0, 18664, 18658, + 1, 0, 0, 0, 18664, 18665, 1, 0, 0, 0, 18665, 18666, 1, 0, 0, 0, 18666, + 18667, 3, 2100, 1050, 0, 18667, 18668, 5, 2377, 0, 0, 18668, 18839, 1, + 0, 0, 0, 18669, 18670, 5, 2137, 0, 0, 18670, 18671, 5, 2376, 0, 0, 18671, + 18672, 3, 2100, 1050, 0, 18672, 18673, 5, 66, 0, 0, 18673, 18680, 3, 2344, + 1172, 0, 18674, 18675, 5, 2382, 0, 0, 18675, 18678, 3, 2372, 1186, 0, 18676, + 18677, 5, 2382, 0, 0, 18677, 18679, 3, 2372, 1186, 0, 18678, 18676, 1, + 0, 0, 0, 18678, 18679, 1, 0, 0, 0, 18679, 18681, 1, 0, 0, 0, 18680, 18674, + 1, 0, 0, 0, 18680, 18681, 1, 0, 0, 0, 18681, 18682, 1, 0, 0, 0, 18682, + 18683, 5, 2377, 0, 0, 18683, 18839, 1, 0, 0, 0, 18684, 18685, 5, 2198, + 0, 0, 18685, 18686, 5, 2376, 0, 0, 18686, 18688, 3, 2078, 1039, 0, 18687, + 18689, 3, 1992, 996, 0, 18688, 18687, 1, 0, 0, 0, 18688, 18689, 1, 0, 0, + 0, 18689, 18690, 1, 0, 0, 0, 18690, 18693, 5, 2377, 0, 0, 18691, 18692, + 5, 2369, 0, 0, 18692, 18694, 3, 2354, 1177, 0, 18693, 18691, 1, 0, 0, 0, + 18693, 18694, 1, 0, 0, 0, 18694, 18839, 1, 0, 0, 0, 18695, 18696, 7, 236, + 0, 0, 18696, 18697, 5, 2376, 0, 0, 18697, 18702, 3, 2214, 1107, 0, 18698, + 18699, 5, 2382, 0, 0, 18699, 18701, 3, 2214, 1107, 0, 18700, 18698, 1, + 0, 0, 0, 18701, 18704, 1, 0, 0, 0, 18702, 18700, 1, 0, 0, 0, 18702, 18703, + 1, 0, 0, 0, 18703, 18705, 1, 0, 0, 0, 18704, 18702, 1, 0, 0, 0, 18705, + 18708, 5, 2377, 0, 0, 18706, 18707, 5, 2369, 0, 0, 18707, 18709, 3, 2354, + 1177, 0, 18708, 18706, 1, 0, 0, 0, 18708, 18709, 1, 0, 0, 0, 18709, 18839, + 1, 0, 0, 0, 18710, 18711, 5, 2207, 0, 0, 18711, 18713, 5, 2376, 0, 0, 18712, + 18714, 7, 237, 0, 0, 18713, 18712, 1, 0, 0, 0, 18713, 18714, 1, 0, 0, 0, + 18714, 18716, 1, 0, 0, 0, 18715, 18717, 7, 238, 0, 0, 18716, 18715, 1, + 0, 0, 0, 18716, 18717, 1, 0, 0, 0, 18717, 18718, 1, 0, 0, 0, 18718, 18721, + 3, 2078, 1039, 0, 18719, 18720, 5, 2382, 0, 0, 18720, 18722, 3, 2206, 1103, + 0, 18721, 18719, 1, 0, 0, 0, 18721, 18722, 1, 0, 0, 0, 18722, 18730, 1, + 0, 0, 0, 18723, 18724, 5, 2382, 0, 0, 18724, 18726, 3, 2078, 1039, 0, 18725, + 18727, 3, 2236, 1118, 0, 18726, 18725, 1, 0, 0, 0, 18726, 18727, 1, 0, + 0, 0, 18727, 18729, 1, 0, 0, 0, 18728, 18723, 1, 0, 0, 0, 18729, 18732, + 1, 0, 0, 0, 18730, 18728, 1, 0, 0, 0, 18730, 18731, 1, 0, 0, 0, 18731, + 18733, 1, 0, 0, 0, 18732, 18730, 1, 0, 0, 0, 18733, 18736, 5, 2377, 0, + 0, 18734, 18735, 5, 2369, 0, 0, 18735, 18737, 3, 2354, 1177, 0, 18736, + 18734, 1, 0, 0, 0, 18736, 18737, 1, 0, 0, 0, 18737, 18839, 1, 0, 0, 0, + 18738, 18739, 5, 2209, 0, 0, 18739, 18740, 5, 2376, 0, 0, 18740, 18742, + 3, 2078, 1039, 0, 18741, 18743, 3, 2204, 1102, 0, 18742, 18741, 1, 0, 0, + 0, 18742, 18743, 1, 0, 0, 0, 18743, 18744, 1, 0, 0, 0, 18744, 18745, 5, + 2377, 0, 0, 18745, 18839, 1, 0, 0, 0, 18746, 18747, 5, 2218, 0, 0, 18747, + 18748, 5, 2376, 0, 0, 18748, 18749, 7, 239, 0, 0, 18749, 18751, 3, 2100, + 1050, 0, 18750, 18752, 5, 2178, 0, 0, 18751, 18750, 1, 0, 0, 0, 18751, + 18752, 1, 0, 0, 0, 18752, 18753, 1, 0, 0, 0, 18753, 18756, 5, 2377, 0, + 0, 18754, 18755, 5, 2369, 0, 0, 18755, 18757, 3, 2354, 1177, 0, 18756, + 18754, 1, 0, 0, 0, 18756, 18757, 1, 0, 0, 0, 18757, 18839, 1, 0, 0, 0, + 18758, 18759, 5, 2220, 0, 0, 18759, 18764, 5, 2376, 0, 0, 18760, 18761, + 5, 926, 0, 0, 18761, 18765, 3, 2376, 1188, 0, 18762, 18763, 5, 476, 0, + 0, 18763, 18765, 3, 2100, 1050, 0, 18764, 18760, 1, 0, 0, 0, 18764, 18762, + 1, 0, 0, 0, 18765, 18768, 1, 0, 0, 0, 18766, 18767, 5, 2382, 0, 0, 18767, + 18769, 3, 2100, 1050, 0, 18768, 18766, 1, 0, 0, 0, 18768, 18769, 1, 0, + 0, 0, 18769, 18770, 1, 0, 0, 0, 18770, 18773, 5, 2377, 0, 0, 18771, 18772, + 5, 2369, 0, 0, 18772, 18774, 3, 2354, 1177, 0, 18773, 18771, 1, 0, 0, 0, + 18773, 18774, 1, 0, 0, 0, 18774, 18839, 1, 0, 0, 0, 18775, 18776, 5, 2222, + 0, 0, 18776, 18777, 5, 2376, 0, 0, 18777, 18779, 3, 2100, 1050, 0, 18778, + 18780, 3, 2204, 1102, 0, 18779, 18778, 1, 0, 0, 0, 18779, 18780, 1, 0, + 0, 0, 18780, 18781, 1, 0, 0, 0, 18781, 18782, 5, 1486, 0, 0, 18782, 18786, + 5, 275, 0, 0, 18783, 18784, 5, 1145, 0, 0, 18784, 18785, 5, 1175, 0, 0, + 18785, 18787, 5, 451, 0, 0, 18786, 18783, 1, 0, 0, 0, 18786, 18787, 1, + 0, 0, 0, 18787, 18788, 1, 0, 0, 0, 18788, 18791, 5, 2377, 0, 0, 18789, + 18790, 5, 2369, 0, 0, 18790, 18792, 3, 2354, 1177, 0, 18791, 18789, 1, + 0, 0, 0, 18791, 18792, 1, 0, 0, 0, 18792, 18839, 1, 0, 0, 0, 18793, 18794, + 5, 2223, 0, 0, 18794, 18795, 5, 2376, 0, 0, 18795, 18798, 3, 2100, 1050, + 0, 18796, 18797, 5, 2382, 0, 0, 18797, 18799, 3, 2216, 1108, 0, 18798, + 18796, 1, 0, 0, 0, 18798, 18799, 1, 0, 0, 0, 18799, 18802, 1, 0, 0, 0, + 18800, 18801, 5, 2382, 0, 0, 18801, 18803, 3, 2218, 1109, 0, 18802, 18800, + 1, 0, 0, 0, 18802, 18803, 1, 0, 0, 0, 18803, 18804, 1, 0, 0, 0, 18804, + 18807, 5, 2377, 0, 0, 18805, 18806, 5, 2369, 0, 0, 18806, 18808, 3, 2354, + 1177, 0, 18807, 18805, 1, 0, 0, 0, 18807, 18808, 1, 0, 0, 0, 18808, 18839, + 1, 0, 0, 0, 18809, 18810, 5, 2225, 0, 0, 18810, 18811, 5, 2376, 0, 0, 18811, + 18812, 7, 239, 0, 0, 18812, 18815, 3, 2100, 1050, 0, 18813, 18814, 5, 66, + 0, 0, 18814, 18816, 3, 2344, 1172, 0, 18815, 18813, 1, 0, 0, 0, 18815, + 18816, 1, 0, 0, 0, 18816, 18818, 1, 0, 0, 0, 18817, 18819, 3, 2220, 1110, + 0, 18818, 18817, 1, 0, 0, 0, 18818, 18819, 1, 0, 0, 0, 18819, 18821, 1, + 0, 0, 0, 18820, 18822, 3, 2222, 1111, 0, 18821, 18820, 1, 0, 0, 0, 18821, + 18822, 1, 0, 0, 0, 18822, 18824, 1, 0, 0, 0, 18823, 18825, 3, 2224, 1112, + 0, 18824, 18823, 1, 0, 0, 0, 18824, 18825, 1, 0, 0, 0, 18825, 18828, 1, + 0, 0, 0, 18826, 18827, 7, 240, 0, 0, 18827, 18829, 5, 364, 0, 0, 18828, + 18826, 1, 0, 0, 0, 18828, 18829, 1, 0, 0, 0, 18829, 18830, 1, 0, 0, 0, + 18830, 18833, 5, 2377, 0, 0, 18831, 18832, 5, 2369, 0, 0, 18832, 18834, + 3, 2354, 1177, 0, 18833, 18831, 1, 0, 0, 0, 18833, 18834, 1, 0, 0, 0, 18834, + 18839, 1, 0, 0, 0, 18835, 18836, 5, 2001, 0, 0, 18836, 18839, 5, 2372, + 0, 0, 18837, 18839, 3, 2314, 1157, 0, 18838, 18451, 1, 0, 0, 0, 18838, + 18456, 1, 0, 0, 0, 18838, 18461, 1, 0, 0, 0, 18838, 18474, 1, 0, 0, 0, + 18838, 18504, 1, 0, 0, 0, 18838, 18516, 1, 0, 0, 0, 18838, 18527, 1, 0, + 0, 0, 18838, 18534, 1, 0, 0, 0, 18838, 18559, 1, 0, 0, 0, 18838, 18562, + 1, 0, 0, 0, 18838, 18570, 1, 0, 0, 0, 18838, 18577, 1, 0, 0, 0, 18838, + 18584, 1, 0, 0, 0, 18838, 18595, 1, 0, 0, 0, 18838, 18616, 1, 0, 0, 0, + 18838, 18629, 1, 0, 0, 0, 18838, 18645, 1, 0, 0, 0, 18838, 18655, 1, 0, + 0, 0, 18838, 18669, 1, 0, 0, 0, 18838, 18684, 1, 0, 0, 0, 18838, 18695, + 1, 0, 0, 0, 18838, 18710, 1, 0, 0, 0, 18838, 18738, 1, 0, 0, 0, 18838, + 18746, 1, 0, 0, 0, 18838, 18758, 1, 0, 0, 0, 18838, 18775, 1, 0, 0, 0, + 18838, 18793, 1, 0, 0, 0, 18838, 18809, 1, 0, 0, 0, 18838, 18835, 1, 0, + 0, 0, 18838, 18837, 1, 0, 0, 0, 18839, 2179, 1, 0, 0, 0, 18840, 18841, + 7, 241, 0, 0, 18841, 2181, 1, 0, 0, 0, 18842, 18843, 7, 242, 0, 0, 18843, + 2183, 1, 0, 0, 0, 18844, 18845, 7, 243, 0, 0, 18845, 2185, 1, 0, 0, 0, + 18846, 18847, 5, 1233, 0, 0, 18847, 18868, 5, 2376, 0, 0, 18848, 18850, + 3, 1924, 962, 0, 18849, 18848, 1, 0, 0, 0, 18849, 18850, 1, 0, 0, 0, 18850, + 18855, 1, 0, 0, 0, 18851, 18853, 3, 1992, 996, 0, 18852, 18854, 3, 2188, + 1094, 0, 18853, 18852, 1, 0, 0, 0, 18853, 18854, 1, 0, 0, 0, 18854, 18856, + 1, 0, 0, 0, 18855, 18851, 1, 0, 0, 0, 18855, 18856, 1, 0, 0, 0, 18856, + 18869, 1, 0, 0, 0, 18857, 18858, 5, 617, 0, 0, 18858, 18859, 3, 2378, 1189, + 0, 18859, 18860, 5, 1162, 0, 0, 18860, 18866, 3, 2368, 1184, 0, 18861, + 18862, 5, 9, 0, 0, 18862, 18863, 5, 46, 0, 0, 18863, 18864, 5, 79, 0, 0, + 18864, 18865, 5, 781, 0, 0, 18865, 18867, 3, 2378, 1189, 0, 18866, 18861, + 1, 0, 0, 0, 18866, 18867, 1, 0, 0, 0, 18867, 18869, 1, 0, 0, 0, 18868, + 18849, 1, 0, 0, 0, 18868, 18857, 1, 0, 0, 0, 18869, 18870, 1, 0, 0, 0, + 18870, 18871, 5, 2377, 0, 0, 18871, 2187, 1, 0, 0, 0, 18872, 18879, 3, + 2190, 1095, 0, 18873, 18874, 5, 112, 0, 0, 18874, 18875, 3, 2192, 1096, + 0, 18875, 18876, 5, 48, 0, 0, 18876, 18877, 3, 2192, 1096, 0, 18877, 18880, + 1, 0, 0, 0, 18878, 18880, 3, 2192, 1096, 0, 18879, 18873, 1, 0, 0, 0, 18879, + 18878, 1, 0, 0, 0, 18880, 2189, 1, 0, 0, 0, 18881, 18882, 7, 244, 0, 0, + 18882, 2191, 1, 0, 0, 0, 18883, 18884, 5, 2060, 0, 0, 18884, 18891, 5, + 1341, 0, 0, 18885, 18886, 5, 315, 0, 0, 18886, 18891, 5, 1507, 0, 0, 18887, + 18888, 3, 2100, 1050, 0, 18888, 18889, 7, 245, 0, 0, 18889, 18891, 1, 0, + 0, 0, 18890, 18883, 1, 0, 0, 0, 18890, 18885, 1, 0, 0, 0, 18890, 18887, + 1, 0, 0, 0, 18891, 2193, 1, 0, 0, 0, 18892, 18902, 5, 2129, 0, 0, 18893, + 18903, 5, 2379, 0, 0, 18894, 18899, 3, 2196, 1098, 0, 18895, 18896, 5, + 2382, 0, 0, 18896, 18898, 3, 2196, 1098, 0, 18897, 18895, 1, 0, 0, 0, 18898, + 18901, 1, 0, 0, 0, 18899, 18897, 1, 0, 0, 0, 18899, 18900, 1, 0, 0, 0, + 18900, 18903, 1, 0, 0, 0, 18901, 18899, 1, 0, 0, 0, 18902, 18893, 1, 0, + 0, 0, 18902, 18894, 1, 0, 0, 0, 18903, 2195, 1, 0, 0, 0, 18904, 18906, + 5, 680, 0, 0, 18905, 18907, 5, 1229, 0, 0, 18906, 18905, 1, 0, 0, 0, 18906, + 18907, 1, 0, 0, 0, 18907, 18910, 1, 0, 0, 0, 18908, 18910, 5, 1229, 0, + 0, 18909, 18904, 1, 0, 0, 0, 18909, 18908, 1, 0, 0, 0, 18909, 18910, 1, + 0, 0, 0, 18910, 18911, 1, 0, 0, 0, 18911, 18912, 3, 1904, 952, 0, 18912, + 2197, 1, 0, 0, 0, 18913, 18914, 5, 1215, 0, 0, 18914, 18915, 5, 151, 0, + 0, 18915, 18916, 3, 2100, 1050, 0, 18916, 2199, 1, 0, 0, 0, 18917, 18918, + 5, 2185, 0, 0, 18918, 18919, 5, 593, 0, 0, 18919, 18920, 5, 2376, 0, 0, + 18920, 18921, 3, 1992, 996, 0, 18921, 18922, 5, 2377, 0, 0, 18922, 18925, + 1, 0, 0, 0, 18923, 18925, 3, 2186, 1093, 0, 18924, 18917, 1, 0, 0, 0, 18924, + 18923, 1, 0, 0, 0, 18925, 2201, 1, 0, 0, 0, 18926, 18948, 5, 292, 0, 0, + 18927, 18929, 5, 900, 0, 0, 18928, 18930, 5, 88, 0, 0, 18929, 18928, 1, + 0, 0, 0, 18929, 18930, 1, 0, 0, 0, 18930, 18949, 1, 0, 0, 0, 18931, 18932, + 5, 2376, 0, 0, 18932, 18937, 3, 2248, 1124, 0, 18933, 18934, 5, 2382, 0, + 0, 18934, 18936, 3, 2248, 1124, 0, 18935, 18933, 1, 0, 0, 0, 18936, 18939, + 1, 0, 0, 0, 18937, 18935, 1, 0, 0, 0, 18937, 18938, 1, 0, 0, 0, 18938, + 18940, 1, 0, 0, 0, 18939, 18937, 1, 0, 0, 0, 18940, 18941, 5, 2377, 0, + 0, 18941, 18942, 5, 2140, 0, 0, 18942, 18944, 5, 2376, 0, 0, 18943, 18945, + 3, 2076, 1038, 0, 18944, 18943, 1, 0, 0, 0, 18944, 18945, 1, 0, 0, 0, 18945, + 18946, 1, 0, 0, 0, 18946, 18947, 5, 2377, 0, 0, 18947, 18949, 1, 0, 0, + 0, 18948, 18927, 1, 0, 0, 0, 18948, 18931, 1, 0, 0, 0, 18949, 2203, 1, + 0, 0, 0, 18950, 18953, 5, 1260, 0, 0, 18951, 18952, 5, 151, 0, 0, 18952, + 18954, 5, 2141, 0, 0, 18953, 18951, 1, 0, 0, 0, 18953, 18954, 1, 0, 0, + 0, 18954, 18955, 1, 0, 0, 0, 18955, 18957, 3, 2078, 1039, 0, 18956, 18958, + 3, 2236, 1118, 0, 18957, 18956, 1, 0, 0, 0, 18957, 18958, 1, 0, 0, 0, 18958, + 18966, 1, 0, 0, 0, 18959, 18960, 5, 2382, 0, 0, 18960, 18962, 3, 2078, + 1039, 0, 18961, 18963, 3, 2236, 1118, 0, 18962, 18961, 1, 0, 0, 0, 18962, + 18963, 1, 0, 0, 0, 18963, 18965, 1, 0, 0, 0, 18964, 18959, 1, 0, 0, 0, + 18965, 18968, 1, 0, 0, 0, 18966, 18964, 1, 0, 0, 0, 18966, 18967, 1, 0, + 0, 0, 18967, 2205, 1, 0, 0, 0, 18968, 18966, 1, 0, 0, 0, 18969, 18970, + 5, 2199, 0, 0, 18970, 18972, 5, 2376, 0, 0, 18971, 18973, 7, 237, 0, 0, + 18972, 18971, 1, 0, 0, 0, 18972, 18973, 1, 0, 0, 0, 18973, 18975, 1, 0, + 0, 0, 18974, 18976, 7, 246, 0, 0, 18975, 18974, 1, 0, 0, 0, 18975, 18976, + 1, 0, 0, 0, 18976, 18977, 1, 0, 0, 0, 18977, 18982, 3, 2214, 1107, 0, 18978, + 18979, 5, 2382, 0, 0, 18979, 18981, 3, 2214, 1107, 0, 18980, 18978, 1, + 0, 0, 0, 18981, 18984, 1, 0, 0, 0, 18982, 18980, 1, 0, 0, 0, 18982, 18983, + 1, 0, 0, 0, 18983, 18985, 1, 0, 0, 0, 18984, 18982, 1, 0, 0, 0, 18985, + 18986, 5, 2377, 0, 0, 18986, 2207, 1, 0, 0, 0, 18987, 18988, 5, 2217, 0, + 0, 18988, 18992, 5, 2376, 0, 0, 18989, 18990, 3, 2100, 1050, 0, 18990, + 18991, 3, 2236, 1118, 0, 18991, 18993, 1, 0, 0, 0, 18992, 18989, 1, 0, + 0, 0, 18992, 18993, 1, 0, 0, 0, 18993, 19000, 1, 0, 0, 0, 18994, 18995, + 5, 2382, 0, 0, 18995, 18996, 3, 2100, 1050, 0, 18996, 18997, 3, 2236, 1118, + 0, 18997, 18999, 1, 0, 0, 0, 18998, 18994, 1, 0, 0, 0, 18999, 19002, 1, + 0, 0, 0, 19000, 18998, 1, 0, 0, 0, 19000, 19001, 1, 0, 0, 0, 19001, 19004, + 1, 0, 0, 0, 19002, 19000, 1, 0, 0, 0, 19003, 19005, 3, 2212, 1106, 0, 19004, + 19003, 1, 0, 0, 0, 19004, 19005, 1, 0, 0, 0, 19005, 19006, 1, 0, 0, 0, + 19006, 19007, 5, 2377, 0, 0, 19007, 2209, 1, 0, 0, 0, 19008, 19019, 3, + 2246, 1123, 0, 19009, 19010, 5, 564, 0, 0, 19010, 19020, 5, 1216, 0, 0, + 19011, 19014, 3, 2344, 1172, 0, 19012, 19013, 5, 1271, 0, 0, 19013, 19015, + 3, 2100, 1050, 0, 19014, 19012, 1, 0, 0, 0, 19014, 19015, 1, 0, 0, 0, 19015, + 19017, 1, 0, 0, 0, 19016, 19018, 3, 2212, 1106, 0, 19017, 19016, 1, 0, + 0, 0, 19017, 19018, 1, 0, 0, 0, 19018, 19020, 1, 0, 0, 0, 19019, 19009, + 1, 0, 0, 0, 19019, 19011, 1, 0, 0, 0, 19020, 2211, 1, 0, 0, 0, 19021, 19022, + 5, 363, 0, 0, 19022, 19023, 3, 2100, 1050, 0, 19023, 2213, 1, 0, 0, 0, + 19024, 19031, 3, 2078, 1039, 0, 19025, 19029, 5, 66, 0, 0, 19026, 19030, + 3, 2378, 1189, 0, 19027, 19028, 5, 476, 0, 0, 19028, 19030, 3, 2100, 1050, + 0, 19029, 19026, 1, 0, 0, 0, 19029, 19027, 1, 0, 0, 0, 19030, 19032, 1, + 0, 0, 0, 19031, 19025, 1, 0, 0, 0, 19031, 19032, 1, 0, 0, 0, 19032, 2215, + 1, 0, 0, 0, 19033, 19037, 5, 2165, 0, 0, 19034, 19035, 5, 1057, 0, 0, 19035, + 19038, 5, 2141, 0, 0, 19036, 19038, 3, 2078, 1039, 0, 19037, 19034, 1, + 0, 0, 0, 19037, 19036, 1, 0, 0, 0, 19038, 2217, 1, 0, 0, 0, 19039, 19045, + 5, 1623, 0, 0, 19040, 19046, 5, 2236, 0, 0, 19041, 19043, 5, 1057, 0, 0, + 19042, 19044, 5, 2141, 0, 0, 19043, 19042, 1, 0, 0, 0, 19043, 19044, 1, + 0, 0, 0, 19044, 19046, 1, 0, 0, 0, 19045, 19040, 1, 0, 0, 0, 19045, 19041, + 1, 0, 0, 0, 19046, 2219, 1, 0, 0, 0, 19047, 19048, 5, 456, 0, 0, 19048, + 19049, 3, 2100, 1050, 0, 19049, 2221, 1, 0, 0, 0, 19050, 19051, 5, 2165, + 0, 0, 19051, 19052, 3, 2100, 1050, 0, 19052, 2223, 1, 0, 0, 0, 19053, 19054, + 5, 1057, 0, 0, 19054, 19062, 5, 651, 0, 0, 19055, 19059, 5, 651, 0, 0, + 19056, 19057, 5, 1595, 0, 0, 19057, 19058, 5, 2398, 0, 0, 19058, 19060, + 3, 2100, 1050, 0, 19059, 19056, 1, 0, 0, 0, 19059, 19060, 1, 0, 0, 0, 19060, + 19062, 1, 0, 0, 0, 19061, 19053, 1, 0, 0, 0, 19061, 19055, 1, 0, 0, 0, + 19062, 2225, 1, 0, 0, 0, 19063, 19073, 5, 2383, 0, 0, 19064, 19073, 5, + 494, 0, 0, 19065, 19073, 5, 2405, 0, 0, 19066, 19067, 5, 1579, 0, 0, 19067, + 19073, 7, 247, 0, 0, 19068, 19073, 5, 2406, 0, 0, 19069, 19073, 3, 2228, + 1114, 0, 19070, 19073, 3, 2230, 1115, 0, 19071, 19073, 3, 2232, 1116, 0, + 19072, 19063, 1, 0, 0, 0, 19072, 19064, 1, 0, 0, 0, 19072, 19065, 1, 0, + 0, 0, 19072, 19066, 1, 0, 0, 0, 19072, 19068, 1, 0, 0, 0, 19072, 19069, + 1, 0, 0, 0, 19072, 19070, 1, 0, 0, 0, 19072, 19071, 1, 0, 0, 0, 19073, + 2227, 1, 0, 0, 0, 19074, 19075, 5, 2179, 0, 0, 19075, 19091, 7, 248, 0, + 0, 19076, 19082, 5, 494, 0, 0, 19077, 19083, 5, 1680, 0, 0, 19078, 19083, + 5, 521, 0, 0, 19079, 19083, 5, 2175, 0, 0, 19080, 19083, 3, 2298, 1149, + 0, 19081, 19083, 3, 2368, 1184, 0, 19082, 19077, 1, 0, 0, 0, 19082, 19078, + 1, 0, 0, 0, 19082, 19079, 1, 0, 0, 0, 19082, 19080, 1, 0, 0, 0, 19082, + 19081, 1, 0, 0, 0, 19083, 19085, 1, 0, 0, 0, 19084, 19086, 7, 249, 0, 0, + 19085, 19084, 1, 0, 0, 0, 19085, 19086, 1, 0, 0, 0, 19086, 19092, 1, 0, + 0, 0, 19087, 19089, 5, 278, 0, 0, 19088, 19090, 7, 250, 0, 0, 19089, 19088, + 1, 0, 0, 0, 19089, 19090, 1, 0, 0, 0, 19090, 19092, 1, 0, 0, 0, 19091, + 19076, 1, 0, 0, 0, 19091, 19087, 1, 0, 0, 0, 19092, 2229, 1, 0, 0, 0, 19093, + 19094, 5, 1568, 0, 0, 19094, 19100, 3, 2382, 1191, 0, 19095, 19101, 5, + 2372, 0, 0, 19096, 19101, 5, 1175, 0, 0, 19097, 19101, 5, 1161, 0, 0, 19098, + 19101, 3, 2368, 1184, 0, 19099, 19101, 3, 2382, 1191, 0, 19100, 19095, + 1, 0, 0, 0, 19100, 19096, 1, 0, 0, 0, 19100, 19097, 1, 0, 0, 0, 19100, + 19098, 1, 0, 0, 0, 19100, 19099, 1, 0, 0, 0, 19101, 2231, 1, 0, 0, 0, 19102, + 19112, 5, 2009, 0, 0, 19103, 19107, 5, 1631, 0, 0, 19104, 19106, 3, 2378, + 1189, 0, 19105, 19104, 1, 0, 0, 0, 19106, 19109, 1, 0, 0, 0, 19107, 19105, + 1, 0, 0, 0, 19107, 19108, 1, 0, 0, 0, 19108, 19113, 1, 0, 0, 0, 19109, + 19107, 1, 0, 0, 0, 19110, 19113, 5, 1579, 0, 0, 19111, 19113, 5, 1654, + 0, 0, 19112, 19103, 1, 0, 0, 0, 19112, 19110, 1, 0, 0, 0, 19112, 19111, + 1, 0, 0, 0, 19112, 19113, 1, 0, 0, 0, 19113, 2233, 1, 0, 0, 0, 19114, 19116, + 7, 251, 0, 0, 19115, 19117, 5, 564, 0, 0, 19116, 19115, 1, 0, 0, 0, 19116, + 19117, 1, 0, 0, 0, 19117, 19118, 1, 0, 0, 0, 19118, 19120, 5, 2376, 0, + 0, 19119, 19121, 3, 2076, 1038, 0, 19120, 19119, 1, 0, 0, 0, 19120, 19121, + 1, 0, 0, 0, 19121, 19122, 1, 0, 0, 0, 19122, 19123, 5, 2377, 0, 0, 19123, + 2235, 1, 0, 0, 0, 19124, 19126, 5, 66, 0, 0, 19125, 19124, 1, 0, 0, 0, + 19125, 19126, 1, 0, 0, 0, 19126, 19129, 1, 0, 0, 0, 19127, 19130, 3, 2376, + 1188, 0, 19128, 19130, 3, 2372, 1186, 0, 19129, 19127, 1, 0, 0, 0, 19129, + 19128, 1, 0, 0, 0, 19130, 19133, 1, 0, 0, 0, 19131, 19133, 5, 66, 0, 0, + 19132, 19125, 1, 0, 0, 0, 19132, 19131, 1, 0, 0, 0, 19133, 2237, 1, 0, + 0, 0, 19134, 19137, 3, 2376, 1188, 0, 19135, 19137, 3, 2372, 1186, 0, 19136, + 19134, 1, 0, 0, 0, 19136, 19135, 1, 0, 0, 0, 19137, 2239, 1, 0, 0, 0, 19138, + 19144, 5, 2181, 0, 0, 19139, 19140, 5, 315, 0, 0, 19140, 19141, 5, 1163, + 0, 0, 19141, 19145, 3, 2302, 1151, 0, 19142, 19145, 3, 2078, 1039, 0, 19143, + 19145, 3, 2242, 1121, 0, 19144, 19139, 1, 0, 0, 0, 19144, 19142, 1, 0, + 0, 0, 19144, 19143, 1, 0, 0, 0, 19145, 2241, 1, 0, 0, 0, 19146, 19147, + 3, 2078, 1039, 0, 19147, 19148, 3, 2094, 1047, 0, 19148, 19149, 7, 252, + 0, 0, 19149, 19150, 5, 2376, 0, 0, 19150, 19155, 3, 2078, 1039, 0, 19151, + 19152, 5, 2382, 0, 0, 19152, 19154, 3, 2078, 1039, 0, 19153, 19151, 1, + 0, 0, 0, 19154, 19157, 1, 0, 0, 0, 19155, 19153, 1, 0, 0, 0, 19155, 19156, + 1, 0, 0, 0, 19156, 19158, 1, 0, 0, 0, 19157, 19155, 1, 0, 0, 0, 19158, + 19159, 5, 2377, 0, 0, 19159, 2243, 1, 0, 0, 0, 19160, 19161, 5, 150, 0, + 0, 19161, 19163, 5, 219, 0, 0, 19162, 19160, 1, 0, 0, 0, 19162, 19163, + 1, 0, 0, 0, 19163, 19164, 1, 0, 0, 0, 19164, 19167, 5, 719, 0, 0, 19165, + 19168, 3, 2354, 1177, 0, 19166, 19168, 3, 2352, 1176, 0, 19167, 19165, + 1, 0, 0, 0, 19167, 19166, 1, 0, 0, 0, 19168, 19176, 1, 0, 0, 0, 19169, + 19172, 5, 2382, 0, 0, 19170, 19173, 3, 2354, 1177, 0, 19171, 19173, 3, + 2352, 1176, 0, 19172, 19170, 1, 0, 0, 0, 19172, 19171, 1, 0, 0, 0, 19173, + 19175, 1, 0, 0, 0, 19174, 19169, 1, 0, 0, 0, 19175, 19178, 1, 0, 0, 0, + 19176, 19174, 1, 0, 0, 0, 19176, 19177, 1, 0, 0, 0, 19177, 2245, 1, 0, + 0, 0, 19178, 19176, 1, 0, 0, 0, 19179, 19182, 3, 2376, 1188, 0, 19180, + 19182, 3, 2372, 1186, 0, 19181, 19179, 1, 0, 0, 0, 19181, 19180, 1, 0, + 0, 0, 19182, 2247, 1, 0, 0, 0, 19183, 19184, 3, 2376, 1188, 0, 19184, 2249, + 1, 0, 0, 0, 19185, 19186, 3, 2376, 1188, 0, 19186, 2251, 1, 0, 0, 0, 19187, + 19188, 3, 2376, 1188, 0, 19188, 2253, 1, 0, 0, 0, 19189, 19190, 3, 2376, + 1188, 0, 19190, 2255, 1, 0, 0, 0, 19191, 19192, 3, 2376, 1188, 0, 19192, + 2257, 1, 0, 0, 0, 19193, 19194, 3, 2376, 1188, 0, 19194, 2259, 1, 0, 0, + 0, 19195, 19200, 3, 2376, 1188, 0, 19196, 19197, 5, 2369, 0, 0, 19197, + 19199, 3, 2378, 1189, 0, 19198, 19196, 1, 0, 0, 0, 19199, 19202, 1, 0, + 0, 0, 19200, 19198, 1, 0, 0, 0, 19200, 19201, 1, 0, 0, 0, 19201, 19205, + 1, 0, 0, 0, 19202, 19200, 1, 0, 0, 0, 19203, 19204, 5, 2384, 0, 0, 19204, + 19206, 3, 2308, 1154, 0, 19205, 19203, 1, 0, 0, 0, 19205, 19206, 1, 0, + 0, 0, 19206, 2261, 1, 0, 0, 0, 19207, 19208, 3, 2376, 1188, 0, 19208, 2263, + 1, 0, 0, 0, 19209, 19212, 3, 2376, 1188, 0, 19210, 19211, 5, 2369, 0, 0, + 19211, 19213, 3, 2378, 1189, 0, 19212, 19210, 1, 0, 0, 0, 19212, 19213, + 1, 0, 0, 0, 19213, 2265, 1, 0, 0, 0, 19214, 19215, 3, 2376, 1188, 0, 19215, + 2267, 1, 0, 0, 0, 19216, 19217, 3, 2376, 1188, 0, 19217, 2269, 1, 0, 0, + 0, 19218, 19219, 3, 2376, 1188, 0, 19219, 2271, 1, 0, 0, 0, 19220, 19223, + 3, 2376, 1188, 0, 19221, 19222, 5, 2369, 0, 0, 19222, 19224, 3, 2378, 1189, + 0, 19223, 19221, 1, 0, 0, 0, 19223, 19224, 1, 0, 0, 0, 19224, 2273, 1, + 0, 0, 0, 19225, 19230, 3, 2376, 1188, 0, 19226, 19227, 5, 2369, 0, 0, 19227, + 19229, 3, 2378, 1189, 0, 19228, 19226, 1, 0, 0, 0, 19229, 19232, 1, 0, + 0, 0, 19230, 19228, 1, 0, 0, 0, 19230, 19231, 1, 0, 0, 0, 19231, 2275, + 1, 0, 0, 0, 19232, 19230, 1, 0, 0, 0, 19233, 19234, 3, 2376, 1188, 0, 19234, + 2277, 1, 0, 0, 0, 19235, 19237, 3, 2378, 1189, 0, 19236, 19238, 3, 560, + 280, 0, 19237, 19236, 1, 0, 0, 0, 19237, 19238, 1, 0, 0, 0, 19238, 2279, + 1, 0, 0, 0, 19239, 19243, 3, 2378, 1189, 0, 19240, 19243, 5, 261, 0, 0, + 19241, 19243, 5, 1471, 0, 0, 19242, 19239, 1, 0, 0, 0, 19242, 19240, 1, + 0, 0, 0, 19242, 19241, 1, 0, 0, 0, 19243, 2281, 1, 0, 0, 0, 19244, 19249, + 3, 2376, 1188, 0, 19245, 19246, 5, 2369, 0, 0, 19246, 19248, 3, 2378, 1189, + 0, 19247, 19245, 1, 0, 0, 0, 19248, 19251, 1, 0, 0, 0, 19249, 19247, 1, + 0, 0, 0, 19249, 19250, 1, 0, 0, 0, 19250, 19254, 1, 0, 0, 0, 19251, 19249, + 1, 0, 0, 0, 19252, 19253, 5, 2384, 0, 0, 19253, 19255, 3, 2308, 1154, 0, + 19254, 19252, 1, 0, 0, 0, 19254, 19255, 1, 0, 0, 0, 19255, 2283, 1, 0, + 0, 0, 19256, 19257, 3, 2378, 1189, 0, 19257, 2285, 1, 0, 0, 0, 19258, 19263, + 3, 2378, 1189, 0, 19259, 19260, 5, 2369, 0, 0, 19260, 19262, 3, 2378, 1189, + 0, 19261, 19259, 1, 0, 0, 0, 19262, 19265, 1, 0, 0, 0, 19263, 19261, 1, + 0, 0, 0, 19263, 19264, 1, 0, 0, 0, 19264, 2287, 1, 0, 0, 0, 19265, 19263, + 1, 0, 0, 0, 19266, 19271, 3, 2378, 1189, 0, 19267, 19268, 5, 2369, 0, 0, + 19268, 19270, 3, 2378, 1189, 0, 19269, 19267, 1, 0, 0, 0, 19270, 19273, + 1, 0, 0, 0, 19271, 19269, 1, 0, 0, 0, 19271, 19272, 1, 0, 0, 0, 19272, + 2289, 1, 0, 0, 0, 19273, 19271, 1, 0, 0, 0, 19274, 19279, 3, 2376, 1188, + 0, 19275, 19276, 5, 2369, 0, 0, 19276, 19278, 3, 2378, 1189, 0, 19277, + 19275, 1, 0, 0, 0, 19278, 19281, 1, 0, 0, 0, 19279, 19277, 1, 0, 0, 0, + 19279, 19280, 1, 0, 0, 0, 19280, 2291, 1, 0, 0, 0, 19281, 19279, 1, 0, + 0, 0, 19282, 19285, 3, 2376, 1188, 0, 19283, 19284, 5, 2369, 0, 0, 19284, + 19286, 3, 2378, 1189, 0, 19285, 19283, 1, 0, 0, 0, 19285, 19286, 1, 0, + 0, 0, 19286, 2293, 1, 0, 0, 0, 19287, 19290, 3, 2376, 1188, 0, 19288, 19289, + 5, 2369, 0, 0, 19289, 19291, 3, 2378, 1189, 0, 19290, 19288, 1, 0, 0, 0, + 19290, 19291, 1, 0, 0, 0, 19291, 2295, 1, 0, 0, 0, 19292, 19295, 3, 2376, + 1188, 0, 19293, 19294, 5, 2369, 0, 0, 19294, 19296, 3, 2378, 1189, 0, 19295, + 19293, 1, 0, 0, 0, 19295, 19296, 1, 0, 0, 0, 19296, 2297, 1, 0, 0, 0, 19297, + 19298, 5, 2401, 0, 0, 19298, 19300, 3, 2316, 1158, 0, 19299, 19297, 1, + 0, 0, 0, 19299, 19300, 1, 0, 0, 0, 19300, 19301, 1, 0, 0, 0, 19301, 19304, + 3, 2378, 1189, 0, 19302, 19303, 5, 2369, 0, 0, 19303, 19305, 3, 2378, 1189, + 0, 19304, 19302, 1, 0, 0, 0, 19304, 19305, 1, 0, 0, 0, 19305, 19308, 1, + 0, 0, 0, 19306, 19308, 3, 2352, 1176, 0, 19307, 19299, 1, 0, 0, 0, 19307, + 19306, 1, 0, 0, 0, 19308, 2299, 1, 0, 0, 0, 19309, 19312, 3, 2376, 1188, + 0, 19310, 19311, 5, 2369, 0, 0, 19311, 19313, 3, 2378, 1189, 0, 19312, + 19310, 1, 0, 0, 0, 19312, 19313, 1, 0, 0, 0, 19313, 2301, 1, 0, 0, 0, 19314, + 19317, 3, 2354, 1177, 0, 19315, 19317, 3, 2352, 1176, 0, 19316, 19314, + 1, 0, 0, 0, 19316, 19315, 1, 0, 0, 0, 19317, 2303, 1, 0, 0, 0, 19318, 19321, + 3, 2376, 1188, 0, 19319, 19321, 3, 2352, 1176, 0, 19320, 19318, 1, 0, 0, + 0, 19320, 19319, 1, 0, 0, 0, 19321, 2305, 1, 0, 0, 0, 19322, 19325, 3, + 2376, 1188, 0, 19323, 19324, 5, 2369, 0, 0, 19324, 19326, 3, 2378, 1189, + 0, 19325, 19323, 1, 0, 0, 0, 19325, 19326, 1, 0, 0, 0, 19326, 2307, 1, + 0, 0, 0, 19327, 19328, 3, 2376, 1188, 0, 19328, 2309, 1, 0, 0, 0, 19329, + 19334, 3, 2376, 1188, 0, 19330, 19331, 5, 2369, 0, 0, 19331, 19333, 3, + 2378, 1189, 0, 19332, 19330, 1, 0, 0, 0, 19333, 19336, 1, 0, 0, 0, 19334, + 19332, 1, 0, 0, 0, 19334, 19335, 1, 0, 0, 0, 19335, 2311, 1, 0, 0, 0, 19336, + 19334, 1, 0, 0, 0, 19337, 19340, 3, 2376, 1188, 0, 19338, 19339, 5, 2369, + 0, 0, 19339, 19341, 3, 2378, 1189, 0, 19340, 19338, 1, 0, 0, 0, 19340, + 19341, 1, 0, 0, 0, 19341, 19352, 1, 0, 0, 0, 19342, 19343, 5, 2384, 0, + 0, 19343, 19348, 3, 2308, 1154, 0, 19344, 19345, 5, 2369, 0, 0, 19345, + 19347, 3, 2308, 1154, 0, 19346, 19344, 1, 0, 0, 0, 19347, 19350, 1, 0, + 0, 0, 19348, 19346, 1, 0, 0, 0, 19348, 19349, 1, 0, 0, 0, 19349, 19353, + 1, 0, 0, 0, 19350, 19348, 1, 0, 0, 0, 19351, 19353, 3, 2234, 1117, 0, 19352, + 19342, 1, 0, 0, 0, 19352, 19351, 1, 0, 0, 0, 19352, 19353, 1, 0, 0, 0, + 19353, 19359, 1, 0, 0, 0, 19354, 19356, 3, 2314, 1157, 0, 19355, 19357, + 3, 2380, 1190, 0, 19356, 19355, 1, 0, 0, 0, 19356, 19357, 1, 0, 0, 0, 19357, + 19359, 1, 0, 0, 0, 19358, 19337, 1, 0, 0, 0, 19358, 19354, 1, 0, 0, 0, + 19359, 2313, 1, 0, 0, 0, 19360, 19361, 5, 2226, 0, 0, 19361, 19365, 5, + 2376, 0, 0, 19362, 19363, 3, 2208, 1104, 0, 19363, 19364, 5, 2382, 0, 0, + 19364, 19366, 1, 0, 0, 0, 19365, 19362, 1, 0, 0, 0, 19365, 19366, 1, 0, + 0, 0, 19366, 19367, 1, 0, 0, 0, 19367, 19369, 3, 2100, 1050, 0, 19368, + 19370, 3, 2204, 1102, 0, 19369, 19368, 1, 0, 0, 0, 19369, 19370, 1, 0, + 0, 0, 19370, 19380, 1, 0, 0, 0, 19371, 19372, 5, 223, 0, 0, 19372, 19377, + 3, 2210, 1105, 0, 19373, 19374, 5, 2382, 0, 0, 19374, 19376, 3, 2210, 1105, + 0, 19375, 19373, 1, 0, 0, 0, 19376, 19379, 1, 0, 0, 0, 19377, 19375, 1, + 0, 0, 0, 19377, 19378, 1, 0, 0, 0, 19378, 19381, 1, 0, 0, 0, 19379, 19377, + 1, 0, 0, 0, 19380, 19371, 1, 0, 0, 0, 19380, 19381, 1, 0, 0, 0, 19381, + 19382, 1, 0, 0, 0, 19382, 19385, 5, 2377, 0, 0, 19383, 19384, 5, 2369, + 0, 0, 19384, 19386, 3, 2354, 1177, 0, 19385, 19383, 1, 0, 0, 0, 19385, + 19386, 1, 0, 0, 0, 19386, 2315, 1, 0, 0, 0, 19387, 19392, 3, 2378, 1189, + 0, 19388, 19389, 5, 2369, 0, 0, 19389, 19391, 3, 2378, 1189, 0, 19390, + 19388, 1, 0, 0, 0, 19391, 19394, 1, 0, 0, 0, 19392, 19390, 1, 0, 0, 0, + 19392, 19393, 1, 0, 0, 0, 19393, 2317, 1, 0, 0, 0, 19394, 19392, 1, 0, + 0, 0, 19395, 19396, 3, 2376, 1188, 0, 19396, 2319, 1, 0, 0, 0, 19397, 19398, + 3, 2378, 1189, 0, 19398, 2321, 1, 0, 0, 0, 19399, 19400, 3, 2378, 1189, + 0, 19400, 2323, 1, 0, 0, 0, 19401, 19402, 3, 2378, 1189, 0, 19402, 2325, + 1, 0, 0, 0, 19403, 19428, 3, 2312, 1156, 0, 19404, 19405, 5, 2121, 0, 0, + 19405, 19410, 3, 2324, 1162, 0, 19406, 19407, 5, 2382, 0, 0, 19407, 19409, + 3, 2324, 1162, 0, 19408, 19406, 1, 0, 0, 0, 19409, 19412, 1, 0, 0, 0, 19410, + 19408, 1, 0, 0, 0, 19410, 19411, 1, 0, 0, 0, 19411, 19428, 1, 0, 0, 0, + 19412, 19410, 1, 0, 0, 0, 19413, 19414, 5, 395, 0, 0, 19414, 19428, 3, + 2322, 1161, 0, 19415, 19416, 5, 438, 0, 0, 19416, 19428, 3, 2320, 1160, + 0, 19417, 19418, 5, 884, 0, 0, 19418, 19419, 5, 900, 0, 0, 19419, 19428, + 3, 2320, 1160, 0, 19420, 19421, 5, 729, 0, 0, 19421, 19422, 7, 77, 0, 0, + 19422, 19428, 3, 2320, 1160, 0, 19423, 19424, 5, 1617, 0, 0, 19424, 19425, + 5, 2041, 0, 0, 19425, 19426, 5, 1367, 0, 0, 19426, 19428, 3, 2320, 1160, + 0, 19427, 19403, 1, 0, 0, 0, 19427, 19404, 1, 0, 0, 0, 19427, 19413, 1, + 0, 0, 0, 19427, 19415, 1, 0, 0, 0, 19427, 19417, 1, 0, 0, 0, 19427, 19420, + 1, 0, 0, 0, 19427, 19423, 1, 0, 0, 0, 19428, 2327, 1, 0, 0, 0, 19429, 19434, + 3, 2310, 1155, 0, 19430, 19431, 5, 2382, 0, 0, 19431, 19433, 3, 2310, 1155, + 0, 19432, 19430, 1, 0, 0, 0, 19433, 19436, 1, 0, 0, 0, 19434, 19432, 1, + 0, 0, 0, 19434, 19435, 1, 0, 0, 0, 19435, 2329, 1, 0, 0, 0, 19436, 19434, + 1, 0, 0, 0, 19437, 19438, 5, 2376, 0, 0, 19438, 19439, 3, 2328, 1164, 0, + 19439, 19440, 5, 2377, 0, 0, 19440, 2331, 1, 0, 0, 0, 19441, 19442, 5, + 751, 0, 0, 19442, 19443, 5, 2376, 0, 0, 19443, 19444, 5, 2267, 0, 0, 19444, + 19445, 7, 49, 0, 0, 19445, 19446, 3, 1992, 996, 0, 19446, 19448, 5, 2377, + 0, 0, 19447, 19449, 3, 2186, 1093, 0, 19448, 19447, 1, 0, 0, 0, 19448, + 19449, 1, 0, 0, 0, 19449, 2333, 1, 0, 0, 0, 19450, 19459, 5, 2376, 0, 0, + 19451, 19456, 3, 2342, 1171, 0, 19452, 19453, 5, 2382, 0, 0, 19453, 19455, + 3, 2342, 1171, 0, 19454, 19452, 1, 0, 0, 0, 19455, 19458, 1, 0, 0, 0, 19456, + 19454, 1, 0, 0, 0, 19456, 19457, 1, 0, 0, 0, 19457, 19460, 1, 0, 0, 0, + 19458, 19456, 1, 0, 0, 0, 19459, 19451, 1, 0, 0, 0, 19459, 19460, 1, 0, + 0, 0, 19460, 19461, 1, 0, 0, 0, 19461, 19463, 5, 2377, 0, 0, 19462, 19464, + 3, 2332, 1166, 0, 19463, 19462, 1, 0, 0, 0, 19463, 19464, 1, 0, 0, 0, 19464, + 2335, 1, 0, 0, 0, 19465, 19480, 5, 2376, 0, 0, 19466, 19468, 3, 2342, 1171, + 0, 19467, 19469, 3, 2340, 1170, 0, 19468, 19467, 1, 0, 0, 0, 19468, 19469, + 1, 0, 0, 0, 19469, 19477, 1, 0, 0, 0, 19470, 19471, 5, 2382, 0, 0, 19471, + 19473, 3, 2342, 1171, 0, 19472, 19474, 3, 2340, 1170, 0, 19473, 19472, + 1, 0, 0, 0, 19473, 19474, 1, 0, 0, 0, 19474, 19476, 1, 0, 0, 0, 19475, + 19470, 1, 0, 0, 0, 19476, 19479, 1, 0, 0, 0, 19477, 19475, 1, 0, 0, 0, + 19477, 19478, 1, 0, 0, 0, 19478, 19481, 1, 0, 0, 0, 19479, 19477, 1, 0, + 0, 0, 19480, 19466, 1, 0, 0, 0, 19480, 19481, 1, 0, 0, 0, 19481, 19482, + 1, 0, 0, 0, 19482, 19484, 5, 2377, 0, 0, 19483, 19485, 3, 2332, 1166, 0, + 19484, 19483, 1, 0, 0, 0, 19484, 19485, 1, 0, 0, 0, 19485, 2337, 1, 0, + 0, 0, 19486, 19487, 5, 2376, 0, 0, 19487, 19500, 3, 2310, 1155, 0, 19488, + 19491, 5, 2382, 0, 0, 19489, 19492, 3, 2368, 1184, 0, 19490, 19492, 5, + 1145, 0, 0, 19491, 19489, 1, 0, 0, 0, 19491, 19490, 1, 0, 0, 0, 19492, + 19498, 1, 0, 0, 0, 19493, 19496, 5, 2382, 0, 0, 19494, 19497, 3, 2368, + 1184, 0, 19495, 19497, 5, 1145, 0, 0, 19496, 19494, 1, 0, 0, 0, 19496, + 19495, 1, 0, 0, 0, 19497, 19499, 1, 0, 0, 0, 19498, 19493, 1, 0, 0, 0, + 19498, 19499, 1, 0, 0, 0, 19499, 19501, 1, 0, 0, 0, 19500, 19488, 1, 0, + 0, 0, 19500, 19501, 1, 0, 0, 0, 19501, 19502, 1, 0, 0, 0, 19502, 19522, + 5, 2129, 0, 0, 19503, 19504, 3, 2312, 1156, 0, 19504, 19505, 5, 2369, 0, + 0, 19505, 19506, 5, 2379, 0, 0, 19506, 19523, 1, 0, 0, 0, 19507, 19523, + 5, 2379, 0, 0, 19508, 19510, 3, 2078, 1039, 0, 19509, 19511, 3, 2236, 1118, + 0, 19510, 19509, 1, 0, 0, 0, 19510, 19511, 1, 0, 0, 0, 19511, 19519, 1, + 0, 0, 0, 19512, 19513, 5, 2382, 0, 0, 19513, 19515, 3, 2078, 1039, 0, 19514, + 19516, 3, 2236, 1118, 0, 19515, 19514, 1, 0, 0, 0, 19515, 19516, 1, 0, + 0, 0, 19516, 19518, 1, 0, 0, 0, 19517, 19512, 1, 0, 0, 0, 19518, 19521, + 1, 0, 0, 0, 19519, 19517, 1, 0, 0, 0, 19519, 19520, 1, 0, 0, 0, 19520, + 19523, 1, 0, 0, 0, 19521, 19519, 1, 0, 0, 0, 19522, 19503, 1, 0, 0, 0, + 19522, 19507, 1, 0, 0, 0, 19522, 19508, 1, 0, 0, 0, 19523, 19524, 1, 0, + 0, 0, 19524, 19526, 5, 2377, 0, 0, 19525, 19527, 3, 2332, 1166, 0, 19526, + 19525, 1, 0, 0, 0, 19526, 19527, 1, 0, 0, 0, 19527, 2339, 1, 0, 0, 0, 19528, + 19529, 7, 253, 0, 0, 19529, 19530, 5, 1146, 0, 0, 19530, 2341, 1, 0, 0, + 0, 19531, 19532, 3, 2376, 1188, 0, 19532, 19533, 5, 2398, 0, 0, 19533, + 19534, 5, 2393, 0, 0, 19534, 19536, 1, 0, 0, 0, 19535, 19531, 1, 0, 0, + 0, 19535, 19536, 1, 0, 0, 0, 19536, 19537, 1, 0, 0, 0, 19537, 19538, 3, + 2078, 1039, 0, 19538, 2343, 1, 0, 0, 0, 19539, 19548, 3, 2346, 1173, 0, + 19540, 19542, 5, 1431, 0, 0, 19541, 19540, 1, 0, 0, 0, 19541, 19542, 1, + 0, 0, 0, 19542, 19543, 1, 0, 0, 0, 19543, 19545, 3, 2286, 1143, 0, 19544, + 19546, 7, 254, 0, 0, 19545, 19544, 1, 0, 0, 0, 19545, 19546, 1, 0, 0, 0, + 19546, 19548, 1, 0, 0, 0, 19547, 19539, 1, 0, 0, 0, 19547, 19541, 1, 0, + 0, 0, 19548, 2345, 1, 0, 0, 0, 19549, 19551, 3, 2350, 1175, 0, 19550, 19552, + 3, 2348, 1174, 0, 19551, 19550, 1, 0, 0, 0, 19551, 19552, 1, 0, 0, 0, 19552, + 19562, 1, 0, 0, 0, 19553, 19555, 5, 2188, 0, 0, 19554, 19556, 5, 804, 0, + 0, 19555, 19554, 1, 0, 0, 0, 19555, 19556, 1, 0, 0, 0, 19556, 19557, 1, + 0, 0, 0, 19557, 19558, 5, 2001, 0, 0, 19558, 19563, 5, 2239, 0, 0, 19559, + 19560, 5, 181, 0, 0, 19560, 19561, 5, 1568, 0, 0, 19561, 19563, 3, 2316, + 1158, 0, 19562, 19553, 1, 0, 0, 0, 19562, 19559, 1, 0, 0, 0, 19562, 19563, + 1, 0, 0, 0, 19563, 19581, 1, 0, 0, 0, 19564, 19565, 5, 717, 0, 0, 19565, + 19570, 7, 255, 0, 0, 19566, 19567, 5, 2376, 0, 0, 19567, 19568, 3, 2078, + 1039, 0, 19568, 19569, 5, 2377, 0, 0, 19569, 19571, 1, 0, 0, 0, 19570, + 19566, 1, 0, 0, 0, 19570, 19571, 1, 0, 0, 0, 19571, 19572, 1, 0, 0, 0, + 19572, 19573, 5, 2029, 0, 0, 19573, 19578, 7, 256, 0, 0, 19574, 19575, + 5, 2376, 0, 0, 19575, 19576, 3, 2078, 1039, 0, 19576, 19577, 5, 2377, 0, + 0, 19577, 19579, 1, 0, 0, 0, 19578, 19574, 1, 0, 0, 0, 19578, 19579, 1, + 0, 0, 0, 19579, 19581, 1, 0, 0, 0, 19580, 19549, 1, 0, 0, 0, 19580, 19564, + 1, 0, 0, 0, 19581, 2347, 1, 0, 0, 0, 19582, 19585, 5, 2376, 0, 0, 19583, + 19586, 3, 2368, 1184, 0, 19584, 19586, 5, 2379, 0, 0, 19585, 19583, 1, + 0, 0, 0, 19585, 19584, 1, 0, 0, 0, 19586, 19592, 1, 0, 0, 0, 19587, 19590, + 5, 2382, 0, 0, 19588, 19591, 3, 2368, 1184, 0, 19589, 19591, 3, 2370, 1185, + 0, 19590, 19588, 1, 0, 0, 0, 19590, 19589, 1, 0, 0, 0, 19591, 19593, 1, + 0, 0, 0, 19592, 19587, 1, 0, 0, 0, 19592, 19593, 1, 0, 0, 0, 19593, 19595, + 1, 0, 0, 0, 19594, 19596, 7, 216, 0, 0, 19595, 19594, 1, 0, 0, 0, 19595, + 19596, 1, 0, 0, 0, 19596, 19597, 1, 0, 0, 0, 19597, 19598, 5, 2377, 0, + 0, 19598, 2349, 1, 0, 0, 0, 19599, 19660, 5, 123, 0, 0, 19600, 19660, 5, + 1309, 0, 0, 19601, 19660, 5, 933, 0, 0, 19602, 19660, 5, 120, 0, 0, 19603, + 19660, 5, 117, 0, 0, 19604, 19660, 5, 934, 0, 0, 19605, 19660, 5, 1325, + 0, 0, 19606, 19660, 5, 1324, 0, 0, 19607, 19660, 5, 1588, 0, 0, 19608, + 19660, 5, 1589, 0, 0, 19609, 19660, 5, 1152, 0, 0, 19610, 19660, 5, 354, + 0, 0, 19611, 19660, 5, 710, 0, 0, 19612, 19660, 5, 718, 0, 0, 19613, 19660, + 5, 1148, 0, 0, 19614, 19660, 5, 1601, 0, 0, 19615, 19660, 5, 1147, 0, 0, + 19616, 19660, 5, 355, 0, 0, 19617, 19619, 5, 421, 0, 0, 19618, 19620, 5, + 1342, 0, 0, 19619, 19618, 1, 0, 0, 0, 19619, 19620, 1, 0, 0, 0, 19620, + 19660, 1, 0, 0, 0, 19621, 19660, 5, 551, 0, 0, 19622, 19660, 5, 1411, 0, + 0, 19623, 19660, 5, 937, 0, 0, 19624, 19626, 5, 824, 0, 0, 19625, 19627, + 5, 1402, 0, 0, 19626, 19625, 1, 0, 0, 0, 19626, 19627, 1, 0, 0, 0, 19627, + 19660, 1, 0, 0, 0, 19628, 19660, 5, 182, 0, 0, 19629, 19660, 5, 181, 0, + 0, 19630, 19660, 5, 2142, 0, 0, 19631, 19660, 5, 2143, 0, 0, 19632, 19660, + 5, 1660, 0, 0, 19633, 19660, 5, 1402, 0, 0, 19634, 19660, 5, 139, 0, 0, + 19635, 19660, 5, 339, 0, 0, 19636, 19660, 5, 1502, 0, 0, 19637, 19660, + 5, 2098, 0, 0, 19638, 19660, 5, 2235, 0, 0, 19639, 19660, 5, 914, 0, 0, + 19640, 19660, 5, 341, 0, 0, 19641, 19660, 5, 622, 0, 0, 19642, 19660, 5, + 887, 0, 0, 19643, 19660, 5, 1537, 0, 0, 19644, 19660, 5, 2004, 0, 0, 19645, + 19660, 5, 2005, 0, 0, 19646, 19660, 5, 2007, 0, 0, 19647, 19660, 5, 2003, + 0, 0, 19648, 19660, 5, 1997, 0, 0, 19649, 19660, 5, 1999, 0, 0, 19650, + 19660, 5, 1998, 0, 0, 19651, 19660, 5, 1996, 0, 0, 19652, 19660, 5, 2237, + 0, 0, 19653, 19660, 5, 427, 0, 0, 19654, 19660, 5, 113, 0, 0, 19655, 19660, + 5, 133, 0, 0, 19656, 19660, 5, 201, 0, 0, 19657, 19660, 5, 939, 0, 0, 19658, + 19660, 5, 895, 0, 0, 19659, 19599, 1, 0, 0, 0, 19659, 19600, 1, 0, 0, 0, + 19659, 19601, 1, 0, 0, 0, 19659, 19602, 1, 0, 0, 0, 19659, 19603, 1, 0, + 0, 0, 19659, 19604, 1, 0, 0, 0, 19659, 19605, 1, 0, 0, 0, 19659, 19606, + 1, 0, 0, 0, 19659, 19607, 1, 0, 0, 0, 19659, 19608, 1, 0, 0, 0, 19659, + 19609, 1, 0, 0, 0, 19659, 19610, 1, 0, 0, 0, 19659, 19611, 1, 0, 0, 0, + 19659, 19612, 1, 0, 0, 0, 19659, 19613, 1, 0, 0, 0, 19659, 19614, 1, 0, + 0, 0, 19659, 19615, 1, 0, 0, 0, 19659, 19616, 1, 0, 0, 0, 19659, 19617, + 1, 0, 0, 0, 19659, 19621, 1, 0, 0, 0, 19659, 19622, 1, 0, 0, 0, 19659, + 19623, 1, 0, 0, 0, 19659, 19624, 1, 0, 0, 0, 19659, 19628, 1, 0, 0, 0, + 19659, 19629, 1, 0, 0, 0, 19659, 19630, 1, 0, 0, 0, 19659, 19631, 1, 0, + 0, 0, 19659, 19632, 1, 0, 0, 0, 19659, 19633, 1, 0, 0, 0, 19659, 19634, + 1, 0, 0, 0, 19659, 19635, 1, 0, 0, 0, 19659, 19636, 1, 0, 0, 0, 19659, + 19637, 1, 0, 0, 0, 19659, 19638, 1, 0, 0, 0, 19659, 19639, 1, 0, 0, 0, + 19659, 19640, 1, 0, 0, 0, 19659, 19641, 1, 0, 0, 0, 19659, 19642, 1, 0, + 0, 0, 19659, 19643, 1, 0, 0, 0, 19659, 19644, 1, 0, 0, 0, 19659, 19645, + 1, 0, 0, 0, 19659, 19646, 1, 0, 0, 0, 19659, 19647, 1, 0, 0, 0, 19659, + 19648, 1, 0, 0, 0, 19659, 19649, 1, 0, 0, 0, 19659, 19650, 1, 0, 0, 0, + 19659, 19651, 1, 0, 0, 0, 19659, 19652, 1, 0, 0, 0, 19659, 19653, 1, 0, + 0, 0, 19659, 19654, 1, 0, 0, 0, 19659, 19655, 1, 0, 0, 0, 19659, 19656, + 1, 0, 0, 0, 19659, 19657, 1, 0, 0, 0, 19659, 19658, 1, 0, 0, 0, 19660, + 2351, 1, 0, 0, 0, 19661, 19665, 5, 2388, 0, 0, 19662, 19663, 5, 2395, 0, + 0, 19663, 19665, 5, 2370, 0, 0, 19664, 19661, 1, 0, 0, 0, 19664, 19662, + 1, 0, 0, 0, 19665, 19674, 1, 0, 0, 0, 19666, 19668, 5, 675, 0, 0, 19667, + 19666, 1, 0, 0, 0, 19667, 19668, 1, 0, 0, 0, 19668, 19672, 1, 0, 0, 0, + 19669, 19673, 5, 2388, 0, 0, 19670, 19671, 5, 2395, 0, 0, 19671, 19673, + 5, 2370, 0, 0, 19672, 19669, 1, 0, 0, 0, 19672, 19670, 1, 0, 0, 0, 19673, + 19675, 1, 0, 0, 0, 19674, 19667, 1, 0, 0, 0, 19674, 19675, 1, 0, 0, 0, + 19675, 19678, 1, 0, 0, 0, 19676, 19677, 5, 2369, 0, 0, 19677, 19679, 3, + 2354, 1177, 0, 19678, 19676, 1, 0, 0, 0, 19678, 19679, 1, 0, 0, 0, 19679, + 2353, 1, 0, 0, 0, 19680, 19685, 3, 2356, 1178, 0, 19681, 19682, 5, 2369, + 0, 0, 19682, 19684, 3, 2356, 1178, 0, 19683, 19681, 1, 0, 0, 0, 19684, + 19687, 1, 0, 0, 0, 19685, 19683, 1, 0, 0, 0, 19685, 19686, 1, 0, 0, 0, + 19686, 2355, 1, 0, 0, 0, 19687, 19685, 1, 0, 0, 0, 19688, 19689, 5, 2401, + 0, 0, 19689, 19691, 3, 2316, 1158, 0, 19690, 19688, 1, 0, 0, 0, 19690, + 19691, 1, 0, 0, 0, 19691, 19692, 1, 0, 0, 0, 19692, 19695, 3, 2378, 1189, + 0, 19693, 19694, 5, 2384, 0, 0, 19694, 19696, 3, 2308, 1154, 0, 19695, + 19693, 1, 0, 0, 0, 19695, 19696, 1, 0, 0, 0, 19696, 19698, 1, 0, 0, 0, + 19697, 19699, 3, 2334, 1167, 0, 19698, 19697, 1, 0, 0, 0, 19698, 19699, + 1, 0, 0, 0, 19699, 2357, 1, 0, 0, 0, 19700, 19701, 5, 2401, 0, 0, 19701, + 19703, 3, 2316, 1158, 0, 19702, 19700, 1, 0, 0, 0, 19702, 19703, 1, 0, + 0, 0, 19703, 19704, 1, 0, 0, 0, 19704, 19709, 3, 2378, 1189, 0, 19705, + 19706, 5, 2369, 0, 0, 19706, 19708, 3, 2378, 1189, 0, 19707, 19705, 1, + 0, 0, 0, 19708, 19711, 1, 0, 0, 0, 19709, 19707, 1, 0, 0, 0, 19709, 19710, + 1, 0, 0, 0, 19710, 2359, 1, 0, 0, 0, 19711, 19709, 1, 0, 0, 0, 19712, 19714, + 5, 37, 0, 0, 19713, 19715, 5, 1363, 0, 0, 19714, 19713, 1, 0, 0, 0, 19714, + 19715, 1, 0, 0, 0, 19715, 19745, 1, 0, 0, 0, 19716, 19745, 5, 41, 0, 0, + 19717, 19745, 5, 352, 0, 0, 19718, 19745, 5, 376, 0, 0, 19719, 19745, 5, + 489, 0, 0, 19720, 19721, 5, 549, 0, 0, 19721, 19745, 5, 62, 0, 0, 19722, + 19745, 5, 659, 0, 0, 19723, 19724, 5, 679, 0, 0, 19724, 19745, 5, 1363, + 0, 0, 19725, 19745, 5, 697, 0, 0, 19726, 19727, 5, 751, 0, 0, 19727, 19745, + 5, 1554, 0, 0, 19728, 19729, 5, 875, 0, 0, 19729, 19745, 5, 2166, 0, 0, + 19730, 19731, 5, 1175, 0, 0, 19731, 19732, 5, 227, 0, 0, 19732, 19745, + 5, 1432, 0, 0, 19733, 19734, 5, 1388, 0, 0, 19734, 19745, 5, 1492, 0, 0, + 19735, 19745, 5, 1408, 0, 0, 19736, 19745, 5, 1429, 0, 0, 19737, 19745, + 5, 1548, 0, 0, 19738, 19739, 5, 2040, 0, 0, 19739, 19745, 5, 1617, 0, 0, + 19740, 19745, 5, 2063, 0, 0, 19741, 19745, 5, 2091, 0, 0, 19742, 19745, + 5, 2125, 0, 0, 19743, 19745, 5, 2192, 0, 0, 19744, 19712, 1, 0, 0, 0, 19744, + 19716, 1, 0, 0, 0, 19744, 19717, 1, 0, 0, 0, 19744, 19718, 1, 0, 0, 0, + 19744, 19719, 1, 0, 0, 0, 19744, 19720, 1, 0, 0, 0, 19744, 19722, 1, 0, + 0, 0, 19744, 19723, 1, 0, 0, 0, 19744, 19725, 1, 0, 0, 0, 19744, 19726, + 1, 0, 0, 0, 19744, 19728, 1, 0, 0, 0, 19744, 19730, 1, 0, 0, 0, 19744, + 19733, 1, 0, 0, 0, 19744, 19735, 1, 0, 0, 0, 19744, 19736, 1, 0, 0, 0, + 19744, 19737, 1, 0, 0, 0, 19744, 19738, 1, 0, 0, 0, 19744, 19740, 1, 0, + 0, 0, 19744, 19741, 1, 0, 0, 0, 19744, 19742, 1, 0, 0, 0, 19744, 19743, + 1, 0, 0, 0, 19745, 2361, 1, 0, 0, 0, 19746, 19747, 5, 37, 0, 0, 19747, + 20073, 5, 1363, 0, 0, 19748, 20073, 5, 30, 0, 0, 19749, 19751, 5, 26, 0, + 0, 19750, 19752, 5, 53, 0, 0, 19751, 19750, 1, 0, 0, 0, 19751, 19752, 1, + 0, 0, 0, 19752, 19753, 1, 0, 0, 0, 19753, 19754, 5, 1617, 0, 0, 19754, + 19755, 5, 2050, 0, 0, 19755, 20073, 5, 1568, 0, 0, 19756, 19757, 7, 52, + 0, 0, 19757, 19758, 5, 53, 0, 0, 19758, 19759, 5, 1617, 0, 0, 19759, 20073, + 5, 1367, 0, 0, 19760, 19761, 5, 26, 0, 0, 19761, 19762, 5, 1617, 0, 0, + 19762, 19763, 5, 836, 0, 0, 19763, 20073, 5, 1155, 0, 0, 19764, 19766, + 5, 301, 0, 0, 19765, 19767, 5, 53, 0, 0, 19766, 19765, 1, 0, 0, 0, 19766, + 19767, 1, 0, 0, 0, 19767, 19768, 1, 0, 0, 0, 19768, 20073, 5, 206, 0, 0, + 19769, 19770, 7, 257, 0, 0, 19770, 19771, 5, 53, 0, 0, 19771, 20073, 5, + 206, 0, 0, 19772, 19773, 7, 258, 0, 0, 19773, 19774, 5, 53, 0, 0, 19774, + 20073, 5, 277, 0, 0, 19775, 19776, 5, 490, 0, 0, 19776, 19777, 5, 1421, + 0, 0, 19777, 20073, 5, 1318, 0, 0, 19778, 19779, 5, 41, 0, 0, 19779, 20073, + 5, 329, 0, 0, 19780, 19782, 7, 259, 0, 0, 19781, 19783, 5, 1377, 0, 0, + 19782, 19781, 1, 0, 0, 0, 19782, 19783, 1, 0, 0, 0, 19783, 19784, 1, 0, + 0, 0, 19784, 19785, 5, 329, 0, 0, 19785, 20073, 5, 795, 0, 0, 19786, 19787, + 5, 425, 0, 0, 19787, 19788, 5, 1377, 0, 0, 19788, 19789, 5, 329, 0, 0, + 19789, 20073, 5, 795, 0, 0, 19790, 19791, 5, 352, 0, 0, 19791, 19792, 5, + 261, 0, 0, 19792, 20073, 5, 1564, 0, 0, 19793, 19794, 5, 352, 0, 0, 19794, + 19795, 5, 53, 0, 0, 19795, 20073, 5, 1365, 0, 0, 19796, 19797, 5, 45, 0, + 0, 19797, 19798, 5, 53, 0, 0, 19798, 20073, 5, 391, 0, 0, 19799, 19801, + 5, 301, 0, 0, 19800, 19802, 5, 53, 0, 0, 19801, 19800, 1, 0, 0, 0, 19801, + 19802, 1, 0, 0, 0, 19802, 19803, 1, 0, 0, 0, 19803, 20073, 5, 392, 0, 0, + 19804, 19805, 7, 257, 0, 0, 19805, 19806, 5, 53, 0, 0, 19806, 20073, 5, + 392, 0, 0, 19807, 19808, 7, 258, 0, 0, 19808, 19809, 5, 53, 0, 0, 19809, + 20073, 5, 395, 0, 0, 19810, 19811, 7, 258, 0, 0, 19811, 19812, 5, 53, 0, + 0, 19812, 20073, 5, 438, 0, 0, 19813, 19818, 5, 549, 0, 0, 19814, 19815, + 5, 62, 0, 0, 19815, 19819, 5, 26, 0, 0, 19816, 19817, 5, 53, 0, 0, 19817, + 19819, 5, 1976, 0, 0, 19818, 19814, 1, 0, 0, 0, 19818, 19816, 1, 0, 0, + 0, 19819, 20073, 1, 0, 0, 0, 19820, 19821, 7, 52, 0, 0, 19821, 19822, 5, + 53, 0, 0, 19822, 20073, 5, 659, 0, 0, 19823, 19825, 5, 301, 0, 0, 19824, + 19826, 5, 53, 0, 0, 19825, 19824, 1, 0, 0, 0, 19825, 19826, 1, 0, 0, 0, + 19826, 19827, 1, 0, 0, 0, 19827, 20073, 5, 673, 0, 0, 19828, 19829, 7, + 260, 0, 0, 19829, 19830, 5, 53, 0, 0, 19830, 20073, 5, 673, 0, 0, 19831, + 19833, 5, 301, 0, 0, 19832, 19834, 7, 261, 0, 0, 19833, 19832, 1, 0, 0, + 0, 19833, 19834, 1, 0, 0, 0, 19834, 19835, 1, 0, 0, 0, 19835, 20073, 5, + 730, 0, 0, 19836, 19837, 5, 489, 0, 0, 19837, 19838, 5, 53, 0, 0, 19838, + 20073, 7, 262, 0, 0, 19839, 19840, 5, 835, 0, 0, 19840, 20073, 5, 1524, + 0, 0, 19841, 19842, 5, 26, 0, 0, 19842, 19843, 5, 753, 0, 0, 19843, 20073, + 5, 836, 0, 0, 19844, 19846, 5, 301, 0, 0, 19845, 19847, 5, 53, 0, 0, 19846, + 19845, 1, 0, 0, 0, 19846, 19847, 1, 0, 0, 0, 19847, 19848, 1, 0, 0, 0, + 19848, 20073, 5, 784, 0, 0, 19849, 19850, 7, 260, 0, 0, 19850, 19851, 5, + 53, 0, 0, 19851, 20073, 5, 784, 0, 0, 19852, 20073, 5, 820, 0, 0, 19853, + 19855, 5, 301, 0, 0, 19854, 19856, 5, 53, 0, 0, 19855, 19854, 1, 0, 0, + 0, 19855, 19856, 1, 0, 0, 0, 19856, 19857, 1, 0, 0, 0, 19857, 19858, 5, + 848, 0, 0, 19858, 20073, 5, 2166, 0, 0, 19859, 19860, 7, 257, 0, 0, 19860, + 19861, 5, 53, 0, 0, 19861, 19862, 5, 848, 0, 0, 19862, 20073, 5, 2166, + 0, 0, 19863, 19865, 5, 586, 0, 0, 19864, 19863, 1, 0, 0, 0, 19864, 19865, + 1, 0, 0, 0, 19865, 19866, 1, 0, 0, 0, 19866, 19867, 5, 1388, 0, 0, 19867, + 20073, 5, 1492, 0, 0, 19868, 19869, 5, 1175, 0, 0, 19869, 19870, 5, 227, + 0, 0, 19870, 20073, 5, 1432, 0, 0, 19871, 19873, 5, 301, 0, 0, 19872, 19874, + 5, 53, 0, 0, 19873, 19872, 1, 0, 0, 0, 19873, 19874, 1, 0, 0, 0, 19874, + 19875, 1, 0, 0, 0, 19875, 19876, 5, 884, 0, 0, 19876, 20073, 5, 900, 0, + 0, 19877, 19878, 7, 263, 0, 0, 19878, 19879, 5, 53, 0, 0, 19879, 19880, + 5, 884, 0, 0, 19880, 20073, 5, 900, 0, 0, 19881, 19883, 5, 301, 0, 0, 19882, + 19884, 5, 53, 0, 0, 19883, 19882, 1, 0, 0, 0, 19883, 19884, 1, 0, 0, 0, + 19884, 19885, 1, 0, 0, 0, 19885, 20073, 5, 311, 0, 0, 19886, 19887, 7, + 264, 0, 0, 19887, 19888, 5, 53, 0, 0, 19888, 20073, 5, 311, 0, 0, 19889, + 19891, 5, 301, 0, 0, 19890, 19892, 5, 53, 0, 0, 19891, 19890, 1, 0, 0, + 0, 19891, 19892, 1, 0, 0, 0, 19892, 19893, 1, 0, 0, 0, 19893, 19894, 5, + 862, 0, 0, 19894, 20073, 5, 556, 0, 0, 19895, 19896, 7, 265, 0, 0, 19896, + 19897, 5, 53, 0, 0, 19897, 19898, 5, 862, 0, 0, 19898, 20073, 5, 556, 0, + 0, 19899, 19901, 5, 301, 0, 0, 19900, 19902, 5, 53, 0, 0, 19901, 19900, + 1, 0, 0, 0, 19901, 19902, 1, 0, 0, 0, 19902, 19903, 1, 0, 0, 0, 19903, + 19904, 5, 311, 0, 0, 19904, 20073, 5, 392, 0, 0, 19905, 19906, 7, 266, + 0, 0, 19906, 19907, 5, 53, 0, 0, 19907, 19908, 5, 311, 0, 0, 19908, 20073, + 5, 392, 0, 0, 19909, 19911, 5, 301, 0, 0, 19910, 19912, 5, 53, 0, 0, 19911, + 19910, 1, 0, 0, 0, 19911, 19912, 1, 0, 0, 0, 19912, 19913, 1, 0, 0, 0, + 19913, 19914, 5, 311, 0, 0, 19914, 19915, 5, 149, 0, 0, 19915, 20073, 5, + 1366, 0, 0, 19916, 19917, 7, 267, 0, 0, 19917, 19918, 5, 53, 0, 0, 19918, + 19919, 5, 311, 0, 0, 19919, 19920, 5, 149, 0, 0, 19920, 20073, 5, 1366, + 0, 0, 19921, 19923, 5, 301, 0, 0, 19922, 19924, 5, 53, 0, 0, 19923, 19922, + 1, 0, 0, 0, 19923, 19924, 1, 0, 0, 0, 19924, 19925, 1, 0, 0, 0, 19925, + 20073, 5, 1182, 0, 0, 19926, 19927, 7, 260, 0, 0, 19927, 19928, 5, 53, + 0, 0, 19928, 20073, 5, 1182, 0, 0, 19929, 19930, 7, 52, 0, 0, 19930, 19931, + 5, 53, 0, 0, 19931, 20073, 5, 1227, 0, 0, 19932, 19933, 5, 301, 0, 0, 19933, + 19934, 5, 1315, 0, 0, 19934, 20073, 5, 329, 0, 0, 19935, 19936, 5, 1568, + 0, 0, 19936, 20073, 5, 270, 0, 0, 19937, 19939, 5, 301, 0, 0, 19938, 19940, + 5, 53, 0, 0, 19939, 19938, 1, 0, 0, 0, 19939, 19940, 1, 0, 0, 0, 19940, + 19941, 1, 0, 0, 0, 19941, 20073, 5, 1365, 0, 0, 19942, 19943, 7, 260, 0, + 0, 19943, 19944, 5, 53, 0, 0, 19944, 20073, 5, 1365, 0, 0, 19945, 19946, + 7, 52, 0, 0, 19946, 20073, 5, 1367, 0, 0, 19947, 19948, 5, 301, 0, 0, 19948, + 20073, 5, 1494, 0, 0, 19949, 19950, 7, 268, 0, 0, 19950, 19951, 5, 53, + 0, 0, 19951, 20073, 5, 1494, 0, 0, 19952, 19953, 7, 52, 0, 0, 19953, 19954, + 5, 1497, 0, 0, 19954, 20073, 5, 1546, 0, 0, 19955, 19957, 5, 301, 0, 0, + 19956, 19958, 5, 53, 0, 0, 19957, 19956, 1, 0, 0, 0, 19957, 19958, 1, 0, + 0, 0, 19958, 19959, 1, 0, 0, 0, 19959, 20073, 5, 1554, 0, 0, 19960, 19961, + 7, 269, 0, 0, 19961, 19962, 5, 53, 0, 0, 19962, 20073, 5, 1554, 0, 0, 19963, + 19964, 7, 270, 0, 0, 19964, 20073, 5, 1564, 0, 0, 19965, 19966, 5, 41, + 0, 0, 19966, 19967, 5, 1471, 0, 0, 19967, 20073, 5, 292, 0, 0, 19968, 19970, + 5, 301, 0, 0, 19969, 19971, 5, 53, 0, 0, 19970, 19969, 1, 0, 0, 0, 19970, + 19971, 1, 0, 0, 0, 19971, 19972, 1, 0, 0, 0, 19972, 19973, 5, 1617, 0, + 0, 19973, 19974, 5, 2041, 0, 0, 19974, 20073, 5, 1367, 0, 0, 19975, 19976, + 7, 271, 0, 0, 19976, 19977, 5, 53, 0, 0, 19977, 19978, 5, 1617, 0, 0, 19978, + 19979, 5, 2041, 0, 0, 19979, 20073, 5, 1367, 0, 0, 19980, 19981, 5, 2040, + 0, 0, 19981, 19982, 5, 53, 0, 0, 19982, 20073, 5, 1617, 0, 0, 19983, 19985, + 5, 301, 0, 0, 19984, 19986, 5, 53, 0, 0, 19985, 19984, 1, 0, 0, 0, 19985, + 19986, 1, 0, 0, 0, 19986, 19987, 1, 0, 0, 0, 19987, 20073, 5, 1689, 0, + 0, 19988, 19989, 5, 425, 0, 0, 19989, 19990, 5, 53, 0, 0, 19990, 20073, + 5, 1689, 0, 0, 19991, 19992, 7, 258, 0, 0, 19992, 19993, 5, 1377, 0, 0, + 19993, 20073, 5, 1689, 0, 0, 19994, 19996, 5, 301, 0, 0, 19995, 19997, + 5, 53, 0, 0, 19996, 19995, 1, 0, 0, 0, 19996, 19997, 1, 0, 0, 0, 19997, + 19998, 1, 0, 0, 0, 19998, 20073, 5, 1976, 0, 0, 19999, 20000, 7, 272, 0, + 0, 20000, 20001, 5, 53, 0, 0, 20001, 20073, 5, 1976, 0, 0, 20002, 20003, + 7, 273, 0, 0, 20003, 20073, 5, 1973, 0, 0, 20004, 20006, 5, 301, 0, 0, + 20005, 20007, 5, 53, 0, 0, 20006, 20005, 1, 0, 0, 0, 20006, 20007, 1, 0, + 0, 0, 20007, 20008, 1, 0, 0, 0, 20008, 20073, 5, 2044, 0, 0, 20009, 20010, + 7, 257, 0, 0, 20010, 20011, 5, 53, 0, 0, 20011, 20073, 5, 2044, 0, 0, 20012, + 20013, 5, 26, 0, 0, 20013, 20014, 5, 329, 0, 0, 20014, 20073, 5, 2044, + 0, 0, 20015, 20017, 5, 301, 0, 0, 20016, 20018, 5, 53, 0, 0, 20017, 20016, + 1, 0, 0, 0, 20017, 20018, 1, 0, 0, 0, 20018, 20019, 1, 0, 0, 0, 20019, + 20073, 5, 2053, 0, 0, 20020, 20021, 7, 274, 0, 0, 20021, 20022, 5, 53, + 0, 0, 20022, 20073, 5, 2053, 0, 0, 20023, 20024, 7, 52, 0, 0, 20024, 20073, + 5, 2121, 0, 0, 20025, 20027, 5, 301, 0, 0, 20026, 20028, 5, 53, 0, 0, 20027, + 20026, 1, 0, 0, 0, 20027, 20028, 1, 0, 0, 0, 20028, 20029, 1, 0, 0, 0, + 20029, 20073, 5, 2166, 0, 0, 20030, 20031, 7, 275, 0, 0, 20031, 20032, + 5, 53, 0, 0, 20032, 20073, 5, 2166, 0, 0, 20033, 20034, 7, 276, 0, 0, 20034, + 20073, 5, 53, 0, 0, 20035, 20036, 5, 105, 0, 0, 20036, 20073, 5, 2121, + 0, 0, 20037, 20038, 5, 179, 0, 0, 20038, 20073, 5, 1120, 0, 0, 20039, 20040, + 5, 490, 0, 0, 20040, 20041, 5, 4, 0, 0, 20041, 20073, 5, 1318, 0, 0, 20042, + 20044, 5, 560, 0, 0, 20043, 20045, 5, 53, 0, 0, 20044, 20043, 1, 0, 0, + 0, 20044, 20045, 1, 0, 0, 0, 20045, 20046, 1, 0, 0, 0, 20046, 20073, 5, + 2035, 0, 0, 20047, 20048, 5, 591, 0, 0, 20048, 20050, 5, 53, 0, 0, 20049, + 20051, 5, 1155, 0, 0, 20050, 20049, 1, 0, 0, 0, 20050, 20051, 1, 0, 0, + 0, 20051, 20052, 1, 0, 0, 0, 20052, 20073, 5, 1362, 0, 0, 20053, 20054, + 5, 679, 0, 0, 20054, 20055, 5, 53, 0, 0, 20055, 20073, 5, 1363, 0, 0, 20056, + 20057, 5, 751, 0, 0, 20057, 20058, 5, 339, 0, 0, 20058, 20073, 5, 2001, + 0, 0, 20059, 20060, 5, 751, 0, 0, 20060, 20073, 5, 1725, 0, 0, 20061, 20062, + 5, 1379, 0, 0, 20062, 20073, 5, 344, 0, 0, 20063, 20073, 5, 1482, 0, 0, + 20064, 20065, 5, 1548, 0, 0, 20065, 20066, 5, 53, 0, 0, 20066, 20073, 7, + 277, 0, 0, 20067, 20073, 5, 1694, 0, 0, 20068, 20073, 5, 1700, 0, 0, 20069, + 20073, 5, 1702, 0, 0, 20070, 20073, 5, 1726, 0, 0, 20071, 20073, 5, 1761, + 0, 0, 20072, 19746, 1, 0, 0, 0, 20072, 19748, 1, 0, 0, 0, 20072, 19749, + 1, 0, 0, 0, 20072, 19756, 1, 0, 0, 0, 20072, 19760, 1, 0, 0, 0, 20072, + 19764, 1, 0, 0, 0, 20072, 19769, 1, 0, 0, 0, 20072, 19772, 1, 0, 0, 0, + 20072, 19775, 1, 0, 0, 0, 20072, 19778, 1, 0, 0, 0, 20072, 19780, 1, 0, + 0, 0, 20072, 19786, 1, 0, 0, 0, 20072, 19790, 1, 0, 0, 0, 20072, 19793, + 1, 0, 0, 0, 20072, 19796, 1, 0, 0, 0, 20072, 19799, 1, 0, 0, 0, 20072, + 19804, 1, 0, 0, 0, 20072, 19807, 1, 0, 0, 0, 20072, 19810, 1, 0, 0, 0, + 20072, 19813, 1, 0, 0, 0, 20072, 19820, 1, 0, 0, 0, 20072, 19823, 1, 0, + 0, 0, 20072, 19828, 1, 0, 0, 0, 20072, 19831, 1, 0, 0, 0, 20072, 19836, + 1, 0, 0, 0, 20072, 19839, 1, 0, 0, 0, 20072, 19841, 1, 0, 0, 0, 20072, + 19844, 1, 0, 0, 0, 20072, 19849, 1, 0, 0, 0, 20072, 19852, 1, 0, 0, 0, + 20072, 19853, 1, 0, 0, 0, 20072, 19859, 1, 0, 0, 0, 20072, 19864, 1, 0, + 0, 0, 20072, 19868, 1, 0, 0, 0, 20072, 19871, 1, 0, 0, 0, 20072, 19877, + 1, 0, 0, 0, 20072, 19881, 1, 0, 0, 0, 20072, 19886, 1, 0, 0, 0, 20072, + 19889, 1, 0, 0, 0, 20072, 19895, 1, 0, 0, 0, 20072, 19899, 1, 0, 0, 0, + 20072, 19905, 1, 0, 0, 0, 20072, 19909, 1, 0, 0, 0, 20072, 19916, 1, 0, + 0, 0, 20072, 19921, 1, 0, 0, 0, 20072, 19926, 1, 0, 0, 0, 20072, 19929, + 1, 0, 0, 0, 20072, 19932, 1, 0, 0, 0, 20072, 19935, 1, 0, 0, 0, 20072, + 19937, 1, 0, 0, 0, 20072, 19942, 1, 0, 0, 0, 20072, 19945, 1, 0, 0, 0, + 20072, 19947, 1, 0, 0, 0, 20072, 19949, 1, 0, 0, 0, 20072, 19952, 1, 0, + 0, 0, 20072, 19955, 1, 0, 0, 0, 20072, 19960, 1, 0, 0, 0, 20072, 19963, + 1, 0, 0, 0, 20072, 19965, 1, 0, 0, 0, 20072, 19968, 1, 0, 0, 0, 20072, + 19975, 1, 0, 0, 0, 20072, 19980, 1, 0, 0, 0, 20072, 19983, 1, 0, 0, 0, + 20072, 19988, 1, 0, 0, 0, 20072, 19991, 1, 0, 0, 0, 20072, 19994, 1, 0, + 0, 0, 20072, 19999, 1, 0, 0, 0, 20072, 20002, 1, 0, 0, 0, 20072, 20004, + 1, 0, 0, 0, 20072, 20009, 1, 0, 0, 0, 20072, 20012, 1, 0, 0, 0, 20072, + 20015, 1, 0, 0, 0, 20072, 20020, 1, 0, 0, 0, 20072, 20023, 1, 0, 0, 0, + 20072, 20025, 1, 0, 0, 0, 20072, 20030, 1, 0, 0, 0, 20072, 20033, 1, 0, + 0, 0, 20072, 20035, 1, 0, 0, 0, 20072, 20037, 1, 0, 0, 0, 20072, 20039, + 1, 0, 0, 0, 20072, 20042, 1, 0, 0, 0, 20072, 20047, 1, 0, 0, 0, 20072, + 20053, 1, 0, 0, 0, 20072, 20056, 1, 0, 0, 0, 20072, 20059, 1, 0, 0, 0, + 20072, 20061, 1, 0, 0, 0, 20072, 20063, 1, 0, 0, 0, 20072, 20064, 1, 0, + 0, 0, 20072, 20067, 1, 0, 0, 0, 20072, 20068, 1, 0, 0, 0, 20072, 20069, + 1, 0, 0, 0, 20072, 20070, 1, 0, 0, 0, 20072, 20071, 1, 0, 0, 0, 20073, + 2363, 1, 0, 0, 0, 20074, 20077, 5, 1997, 0, 0, 20075, 20078, 3, 2372, 1186, + 0, 20076, 20078, 3, 2352, 1176, 0, 20077, 20075, 1, 0, 0, 0, 20077, 20076, + 1, 0, 0, 0, 20078, 20083, 1, 0, 0, 0, 20079, 20080, 5, 79, 0, 0, 20080, + 20081, 5, 2001, 0, 0, 20081, 20082, 5, 2239, 0, 0, 20082, 20084, 3, 2372, + 1186, 0, 20083, 20079, 1, 0, 0, 0, 20083, 20084, 1, 0, 0, 0, 20084, 20137, + 1, 0, 0, 0, 20085, 20089, 5, 717, 0, 0, 20086, 20090, 3, 2372, 1186, 0, + 20087, 20090, 3, 2352, 1176, 0, 20088, 20090, 3, 2354, 1177, 0, 20089, + 20086, 1, 0, 0, 0, 20089, 20087, 1, 0, 0, 0, 20089, 20088, 1, 0, 0, 0, + 20090, 20091, 1, 0, 0, 0, 20091, 20105, 7, 278, 0, 0, 20092, 20095, 5, + 2376, 0, 0, 20093, 20096, 5, 2370, 0, 0, 20094, 20096, 3, 2352, 1176, 0, + 20095, 20093, 1, 0, 0, 0, 20095, 20094, 1, 0, 0, 0, 20096, 20102, 1, 0, + 0, 0, 20097, 20100, 5, 2382, 0, 0, 20098, 20101, 5, 2370, 0, 0, 20099, + 20101, 3, 2352, 1176, 0, 20100, 20098, 1, 0, 0, 0, 20100, 20099, 1, 0, + 0, 0, 20101, 20103, 1, 0, 0, 0, 20102, 20097, 1, 0, 0, 0, 20102, 20103, + 1, 0, 0, 0, 20103, 20104, 1, 0, 0, 0, 20104, 20106, 5, 2377, 0, 0, 20105, + 20092, 1, 0, 0, 0, 20105, 20106, 1, 0, 0, 0, 20106, 20122, 1, 0, 0, 0, + 20107, 20120, 5, 2029, 0, 0, 20108, 20121, 5, 341, 0, 0, 20109, 20121, + 5, 622, 0, 0, 20110, 20121, 5, 887, 0, 0, 20111, 20118, 5, 1537, 0, 0, + 20112, 20115, 5, 2376, 0, 0, 20113, 20116, 5, 2370, 0, 0, 20114, 20116, + 3, 2352, 1176, 0, 20115, 20113, 1, 0, 0, 0, 20115, 20114, 1, 0, 0, 0, 20116, + 20117, 1, 0, 0, 0, 20117, 20119, 5, 2377, 0, 0, 20118, 20112, 1, 0, 0, + 0, 20118, 20119, 1, 0, 0, 0, 20119, 20121, 1, 0, 0, 0, 20120, 20108, 1, + 0, 0, 0, 20120, 20109, 1, 0, 0, 0, 20120, 20110, 1, 0, 0, 0, 20120, 20111, + 1, 0, 0, 0, 20121, 20123, 1, 0, 0, 0, 20122, 20107, 1, 0, 0, 0, 20122, + 20123, 1, 0, 0, 0, 20123, 20137, 1, 0, 0, 0, 20124, 20137, 3, 2368, 1184, + 0, 20125, 20126, 5, 339, 0, 0, 20126, 20137, 3, 2372, 1186, 0, 20127, 20137, + 3, 2372, 1186, 0, 20128, 20137, 5, 1145, 0, 0, 20129, 20137, 5, 2045, 0, + 0, 20130, 20137, 5, 522, 0, 0, 20131, 20137, 5, 347, 0, 0, 20132, 20137, + 5, 1566, 0, 0, 20133, 20137, 5, 889, 0, 0, 20134, 20137, 5, 861, 0, 0, + 20135, 20137, 5, 363, 0, 0, 20136, 20074, 1, 0, 0, 0, 20136, 20085, 1, + 0, 0, 0, 20136, 20124, 1, 0, 0, 0, 20136, 20125, 1, 0, 0, 0, 20136, 20127, + 1, 0, 0, 0, 20136, 20128, 1, 0, 0, 0, 20136, 20129, 1, 0, 0, 0, 20136, + 20130, 1, 0, 0, 0, 20136, 20131, 1, 0, 0, 0, 20136, 20132, 1, 0, 0, 0, + 20136, 20133, 1, 0, 0, 0, 20136, 20134, 1, 0, 0, 0, 20136, 20135, 1, 0, + 0, 0, 20137, 2365, 1, 0, 0, 0, 20138, 20141, 5, 1997, 0, 0, 20139, 20142, + 3, 2372, 1186, 0, 20140, 20142, 3, 2352, 1176, 0, 20141, 20139, 1, 0, 0, + 0, 20141, 20140, 1, 0, 0, 0, 20142, 20147, 1, 0, 0, 0, 20143, 20144, 5, + 79, 0, 0, 20144, 20145, 5, 2001, 0, 0, 20145, 20146, 5, 2239, 0, 0, 20146, + 20148, 3, 2372, 1186, 0, 20147, 20143, 1, 0, 0, 0, 20147, 20148, 1, 0, + 0, 0, 20148, 20201, 1, 0, 0, 0, 20149, 20153, 5, 717, 0, 0, 20150, 20154, + 3, 2372, 1186, 0, 20151, 20154, 3, 2352, 1176, 0, 20152, 20154, 3, 2354, + 1177, 0, 20153, 20150, 1, 0, 0, 0, 20153, 20151, 1, 0, 0, 0, 20153, 20152, + 1, 0, 0, 0, 20154, 20155, 1, 0, 0, 0, 20155, 20169, 7, 278, 0, 0, 20156, + 20159, 5, 2376, 0, 0, 20157, 20160, 5, 2370, 0, 0, 20158, 20160, 3, 2352, + 1176, 0, 20159, 20157, 1, 0, 0, 0, 20159, 20158, 1, 0, 0, 0, 20160, 20166, + 1, 0, 0, 0, 20161, 20164, 5, 2382, 0, 0, 20162, 20165, 5, 2370, 0, 0, 20163, + 20165, 3, 2352, 1176, 0, 20164, 20162, 1, 0, 0, 0, 20164, 20163, 1, 0, + 0, 0, 20165, 20167, 1, 0, 0, 0, 20166, 20161, 1, 0, 0, 0, 20166, 20167, + 1, 0, 0, 0, 20167, 20168, 1, 0, 0, 0, 20168, 20170, 5, 2377, 0, 0, 20169, + 20156, 1, 0, 0, 0, 20169, 20170, 1, 0, 0, 0, 20170, 20186, 1, 0, 0, 0, + 20171, 20184, 5, 2029, 0, 0, 20172, 20185, 5, 341, 0, 0, 20173, 20185, + 5, 622, 0, 0, 20174, 20185, 5, 887, 0, 0, 20175, 20182, 5, 1537, 0, 0, + 20176, 20179, 5, 2376, 0, 0, 20177, 20180, 5, 2370, 0, 0, 20178, 20180, + 3, 2352, 1176, 0, 20179, 20177, 1, 0, 0, 0, 20179, 20178, 1, 0, 0, 0, 20180, + 20181, 1, 0, 0, 0, 20181, 20183, 5, 2377, 0, 0, 20182, 20176, 1, 0, 0, + 0, 20182, 20183, 1, 0, 0, 0, 20183, 20185, 1, 0, 0, 0, 20184, 20172, 1, + 0, 0, 0, 20184, 20173, 1, 0, 0, 0, 20184, 20174, 1, 0, 0, 0, 20184, 20175, + 1, 0, 0, 0, 20185, 20187, 1, 0, 0, 0, 20186, 20171, 1, 0, 0, 0, 20186, + 20187, 1, 0, 0, 0, 20187, 20201, 1, 0, 0, 0, 20188, 20201, 3, 2368, 1184, + 0, 20189, 20190, 5, 339, 0, 0, 20190, 20201, 3, 2372, 1186, 0, 20191, 20201, + 3, 2374, 1187, 0, 20192, 20201, 5, 1145, 0, 0, 20193, 20201, 5, 2045, 0, + 0, 20194, 20201, 5, 522, 0, 0, 20195, 20201, 5, 347, 0, 0, 20196, 20201, + 5, 1566, 0, 0, 20197, 20201, 5, 889, 0, 0, 20198, 20201, 5, 861, 0, 0, + 20199, 20201, 5, 363, 0, 0, 20200, 20138, 1, 0, 0, 0, 20200, 20149, 1, + 0, 0, 0, 20200, 20188, 1, 0, 0, 0, 20200, 20189, 1, 0, 0, 0, 20200, 20191, + 1, 0, 0, 0, 20200, 20192, 1, 0, 0, 0, 20200, 20193, 1, 0, 0, 0, 20200, + 20194, 1, 0, 0, 0, 20200, 20195, 1, 0, 0, 0, 20200, 20196, 1, 0, 0, 0, + 20200, 20197, 1, 0, 0, 0, 20200, 20198, 1, 0, 0, 0, 20200, 20199, 1, 0, + 0, 0, 20201, 2367, 1, 0, 0, 0, 20202, 20203, 7, 279, 0, 0, 20203, 2369, + 1, 0, 0, 0, 20204, 20205, 5, 2381, 0, 0, 20205, 20206, 3, 2368, 1184, 0, + 20206, 2371, 1, 0, 0, 0, 20207, 20211, 3, 2298, 1149, 0, 20208, 20211, + 5, 2372, 0, 0, 20209, 20211, 5, 2365, 0, 0, 20210, 20207, 1, 0, 0, 0, 20210, + 20208, 1, 0, 0, 0, 20210, 20209, 1, 0, 0, 0, 20211, 2373, 1, 0, 0, 0, 20212, + 20213, 7, 280, 0, 0, 20213, 2375, 1, 0, 0, 0, 20214, 20215, 5, 2401, 0, + 0, 20215, 20217, 3, 2316, 1158, 0, 20216, 20214, 1, 0, 0, 0, 20216, 20217, + 1, 0, 0, 0, 20217, 20218, 1, 0, 0, 0, 20218, 20219, 3, 2378, 1189, 0, 20219, + 2377, 1, 0, 0, 0, 20220, 20223, 3, 2382, 1191, 0, 20221, 20223, 5, 2373, + 0, 0, 20222, 20220, 1, 0, 0, 0, 20222, 20221, 1, 0, 0, 0, 20223, 2379, + 1, 0, 0, 0, 20224, 20225, 5, 2376, 0, 0, 20225, 20226, 5, 2380, 0, 0, 20226, + 20227, 5, 2377, 0, 0, 20227, 2381, 1, 0, 0, 0, 20228, 20323, 3, 2386, 1193, + 0, 20229, 20323, 3, 2384, 1192, 0, 20230, 20323, 5, 2407, 0, 0, 20231, + 20323, 5, 3, 0, 0, 20232, 20323, 5, 35, 0, 0, 20233, 20323, 5, 33, 0, 0, + 20234, 20323, 5, 34, 0, 0, 20235, 20323, 5, 45, 0, 0, 20236, 20323, 5, + 92, 0, 0, 20237, 20323, 5, 97, 0, 0, 20238, 20323, 5, 102, 0, 0, 20239, + 20323, 5, 123, 0, 0, 20240, 20323, 5, 139, 0, 0, 20241, 20323, 5, 199, + 0, 0, 20242, 20323, 5, 182, 0, 0, 20243, 20323, 5, 206, 0, 0, 20244, 20323, + 5, 269, 0, 0, 20245, 20323, 5, 325, 0, 0, 20246, 20323, 5, 171, 0, 0, 20247, + 20323, 5, 355, 0, 0, 20248, 20323, 5, 376, 0, 0, 20249, 20323, 5, 390, + 0, 0, 20250, 20323, 5, 427, 0, 0, 20251, 20323, 5, 435, 0, 0, 20252, 20323, + 5, 468, 0, 0, 20253, 20323, 5, 482, 0, 0, 20254, 20323, 5, 483, 0, 0, 20255, + 20323, 5, 484, 0, 0, 20256, 20323, 5, 492, 0, 0, 20257, 20323, 5, 494, + 0, 0, 20258, 20323, 5, 537, 0, 0, 20259, 20323, 5, 551, 0, 0, 20260, 20323, + 5, 559, 0, 0, 20261, 20323, 5, 579, 0, 0, 20262, 20323, 5, 676, 0, 0, 20263, + 20323, 5, 692, 0, 0, 20264, 20323, 5, 710, 0, 0, 20265, 20323, 5, 747, + 0, 0, 20266, 20323, 5, 749, 0, 0, 20267, 20323, 5, 760, 0, 0, 20268, 20323, + 5, 824, 0, 0, 20269, 20323, 5, 825, 0, 0, 20270, 20323, 5, 919, 0, 0, 20271, + 20323, 5, 831, 0, 0, 20272, 20323, 5, 893, 0, 0, 20273, 20323, 5, 894, + 0, 0, 20274, 20323, 5, 1147, 0, 0, 20275, 20323, 5, 1194, 0, 0, 20276, + 20323, 5, 1221, 0, 0, 20277, 20323, 5, 1229, 0, 0, 20278, 20323, 5, 1234, + 0, 0, 20279, 20323, 5, 1238, 0, 0, 20280, 20323, 5, 1241, 0, 0, 20281, + 20323, 5, 1300, 0, 0, 20282, 20323, 5, 1309, 0, 0, 20283, 20323, 5, 1316, + 0, 0, 20284, 20323, 5, 1325, 0, 0, 20285, 20323, 5, 1324, 0, 0, 20286, + 20323, 5, 1338, 0, 0, 20287, 20323, 5, 1377, 0, 0, 20288, 20323, 5, 1396, + 0, 0, 20289, 20323, 5, 1402, 0, 0, 20290, 20323, 5, 1414, 0, 0, 20291, + 20323, 5, 1431, 0, 0, 20292, 20323, 5, 1460, 0, 0, 20293, 20323, 5, 1478, + 0, 0, 20294, 20323, 5, 1481, 0, 0, 20295, 20323, 5, 1534, 0, 0, 20296, + 20323, 5, 1549, 0, 0, 20297, 20323, 5, 1557, 0, 0, 20298, 20323, 5, 1568, + 0, 0, 20299, 20323, 5, 1573, 0, 0, 20300, 20323, 5, 1588, 0, 0, 20301, + 20323, 5, 1589, 0, 0, 20302, 20323, 5, 1601, 0, 0, 20303, 20323, 5, 1614, + 0, 0, 20304, 20323, 5, 1615, 0, 0, 20305, 20323, 5, 1678, 0, 0, 20306, + 20323, 5, 1970, 0, 0, 20307, 20323, 5, 1996, 0, 0, 20308, 20323, 5, 1998, + 0, 0, 20309, 20323, 5, 1999, 0, 0, 20310, 20323, 5, 2044, 0, 0, 20311, + 20323, 5, 2143, 0, 0, 20312, 20323, 5, 2142, 0, 0, 20313, 20323, 5, 2144, + 0, 0, 20314, 20323, 5, 2175, 0, 0, 20315, 20323, 5, 2182, 0, 0, 20316, + 20323, 5, 2198, 0, 0, 20317, 20323, 5, 2237, 0, 0, 20318, 20323, 5, 2288, + 0, 0, 20319, 20323, 5, 2296, 0, 0, 20320, 20323, 5, 2141, 0, 0, 20321, + 20323, 5, 2275, 0, 0, 20322, 20228, 1, 0, 0, 0, 20322, 20229, 1, 0, 0, + 0, 20322, 20230, 1, 0, 0, 0, 20322, 20231, 1, 0, 0, 0, 20322, 20232, 1, + 0, 0, 0, 20322, 20233, 1, 0, 0, 0, 20322, 20234, 1, 0, 0, 0, 20322, 20235, + 1, 0, 0, 0, 20322, 20236, 1, 0, 0, 0, 20322, 20237, 1, 0, 0, 0, 20322, + 20238, 1, 0, 0, 0, 20322, 20239, 1, 0, 0, 0, 20322, 20240, 1, 0, 0, 0, + 20322, 20241, 1, 0, 0, 0, 20322, 20242, 1, 0, 0, 0, 20322, 20243, 1, 0, + 0, 0, 20322, 20244, 1, 0, 0, 0, 20322, 20245, 1, 0, 0, 0, 20322, 20246, + 1, 0, 0, 0, 20322, 20247, 1, 0, 0, 0, 20322, 20248, 1, 0, 0, 0, 20322, + 20249, 1, 0, 0, 0, 20322, 20250, 1, 0, 0, 0, 20322, 20251, 1, 0, 0, 0, + 20322, 20252, 1, 0, 0, 0, 20322, 20253, 1, 0, 0, 0, 20322, 20254, 1, 0, + 0, 0, 20322, 20255, 1, 0, 0, 0, 20322, 20256, 1, 0, 0, 0, 20322, 20257, + 1, 0, 0, 0, 20322, 20258, 1, 0, 0, 0, 20322, 20259, 1, 0, 0, 0, 20322, + 20260, 1, 0, 0, 0, 20322, 20261, 1, 0, 0, 0, 20322, 20262, 1, 0, 0, 0, + 20322, 20263, 1, 0, 0, 0, 20322, 20264, 1, 0, 0, 0, 20322, 20265, 1, 0, + 0, 0, 20322, 20266, 1, 0, 0, 0, 20322, 20267, 1, 0, 0, 0, 20322, 20268, + 1, 0, 0, 0, 20322, 20269, 1, 0, 0, 0, 20322, 20270, 1, 0, 0, 0, 20322, + 20271, 1, 0, 0, 0, 20322, 20272, 1, 0, 0, 0, 20322, 20273, 1, 0, 0, 0, + 20322, 20274, 1, 0, 0, 0, 20322, 20275, 1, 0, 0, 0, 20322, 20276, 1, 0, + 0, 0, 20322, 20277, 1, 0, 0, 0, 20322, 20278, 1, 0, 0, 0, 20322, 20279, + 1, 0, 0, 0, 20322, 20280, 1, 0, 0, 0, 20322, 20281, 1, 0, 0, 0, 20322, + 20282, 1, 0, 0, 0, 20322, 20283, 1, 0, 0, 0, 20322, 20284, 1, 0, 0, 0, + 20322, 20285, 1, 0, 0, 0, 20322, 20286, 1, 0, 0, 0, 20322, 20287, 1, 0, + 0, 0, 20322, 20288, 1, 0, 0, 0, 20322, 20289, 1, 0, 0, 0, 20322, 20290, + 1, 0, 0, 0, 20322, 20291, 1, 0, 0, 0, 20322, 20292, 1, 0, 0, 0, 20322, + 20293, 1, 0, 0, 0, 20322, 20294, 1, 0, 0, 0, 20322, 20295, 1, 0, 0, 0, + 20322, 20296, 1, 0, 0, 0, 20322, 20297, 1, 0, 0, 0, 20322, 20298, 1, 0, + 0, 0, 20322, 20299, 1, 0, 0, 0, 20322, 20300, 1, 0, 0, 0, 20322, 20301, + 1, 0, 0, 0, 20322, 20302, 1, 0, 0, 0, 20322, 20303, 1, 0, 0, 0, 20322, + 20304, 1, 0, 0, 0, 20322, 20305, 1, 0, 0, 0, 20322, 20306, 1, 0, 0, 0, + 20322, 20307, 1, 0, 0, 0, 20322, 20308, 1, 0, 0, 0, 20322, 20309, 1, 0, + 0, 0, 20322, 20310, 1, 0, 0, 0, 20322, 20311, 1, 0, 0, 0, 20322, 20312, + 1, 0, 0, 0, 20322, 20313, 1, 0, 0, 0, 20322, 20314, 1, 0, 0, 0, 20322, + 20315, 1, 0, 0, 0, 20322, 20316, 1, 0, 0, 0, 20322, 20317, 1, 0, 0, 0, + 20322, 20318, 1, 0, 0, 0, 20322, 20319, 1, 0, 0, 0, 20322, 20320, 1, 0, + 0, 0, 20322, 20321, 1, 0, 0, 0, 20323, 2383, 1, 0, 0, 0, 20324, 20325, + 7, 281, 0, 0, 20325, 2385, 1, 0, 0, 0, 20326, 20327, 7, 282, 0, 0, 20327, + 2387, 1, 0, 0, 0, 20328, 20329, 7, 283, 0, 0, 20329, 2389, 1, 0, 0, 0, + 20330, 20331, 7, 284, 0, 0, 20331, 2391, 1, 0, 0, 0, 2827, 2394, 2397, + 2400, 2402, 2546, 2553, 2555, 2558, 2561, 2583, 2585, 2592, 2596, 2601, + 2603, 2608, 2611, 2615, 2623, 2628, 2632, 2637, 2642, 2646, 2652, 2657, + 2662, 2666, 2669, 2675, 2683, 2690, 2694, 2699, 2702, 2718, 2723, 2727, + 2735, 2741, 2749, 2752, 2754, 2757, 2761, 2764, 2768, 2776, 2782, 2790, + 2793, 2796, 2808, 2810, 2816, 2821, 2823, 2829, 2832, 2844, 2854, 2857, + 2862, 2865, 2882, 2889, 2894, 2898, 2913, 2916, 2931, 2941, 2955, 2958, + 2971, 2979, 2985, 2989, 2996, 3000, 3024, 3036, 3054, 3067, 3073, 3082, + 3092, 3096, 3109, 3112, 3121, 3129, 3133, 3143, 3157, 3167, 3175, 3178, + 3182, 3185, 3188, 3191, 3201, 3220, 3230, 3238, 3243, 3249, 3270, 3279, + 3282, 3286, 3288, 3297, 3301, 3318, 3332, 3334, 3337, 3341, 3348, 3355, + 3362, 3367, 3372, 3382, 3390, 3394, 3400, 3404, 3409, 3416, 3426, 3431, + 3439, 3441, 3445, 3449, 3452, 3456, 3462, 3476, 3485, 3488, 3494, 3503, + 3516, 3522, 3534, 3543, 3548, 3564, 3566, 3582, 3584, 3605, 3607, 3627, + 3629, 3644, 3653, 3655, 3666, 3673, 3686, 3691, 3701, 3704, 3709, 3714, + 3721, 3727, 3731, 3737, 3742, 3749, 3756, 3763, 3768, 3772, 3784, 3794, + 3799, 3811, 3816, 3821, 3824, 3827, 3840, 3852, 3856, 3859, 3862, 3869, + 3873, 3876, 3888, 3893, 3898, 3910, 3915, 3923, 3925, 3929, 3932, 3936, + 3939, 3943, 3948, 3960, 3965, 3969, 3972, 3977, 3984, 3994, 3999, 4002, + 4006, 4009, 4014, 4025, 4041, 4043, 4053, 4072, 4079, 4084, 4090, 4098, + 4100, 4117, 4122, 4127, 4129, 4136, 4143, 4146, 4149, 4152, 4163, 4175, + 4179, 4182, 4191, 4199, 4207, 4210, 4217, 4221, 4226, 4231, 4272, 4300, + 4307, 4312, 4319, 4330, 4338, 4342, 4355, 4358, 4364, 4367, 4372, 4377, + 4381, 4391, 4401, 4407, 4418, 4423, 4427, 4435, 4443, 4448, 4451, 4453, + 4456, 4465, 4470, 4477, 4480, 4483, 4486, 4490, 4493, 4501, 4506, 4511, + 4518, 4528, 4544, 4551, 4561, 4571, 4578, 4581, 4586, 4596, 4601, 4608, + 4611, 4616, 4619, 4622, 4639, 4644, 4653, 4656, 4661, 4664, 4671, 4674, + 4681, 4686, 4690, 4695, 4700, 4714, 4719, 4726, 4729, 4733, 4736, 4739, + 4742, 4752, 4758, 4768, 4773, 4780, 4786, 4790, 4793, 4796, 4813, 4818, + 4826, 4840, 4847, 4863, 4885, 4892, 4894, 4898, 4906, 4917, 4928, 4930, + 4937, 4939, 4960, 4969, 4972, 4980, 4985, 4989, 4992, 4995, 4998, 5001, + 5004, 5007, 5010, 5014, 5017, 5020, 5025, 5029, 5032, 5037, 5039, 5051, + 5055, 5059, 5065, 5069, 5072, 5075, 5085, 5094, 5102, 5109, 5114, 5122, + 5125, 5129, 5139, 5148, 5156, 5160, 5163, 5168, 5172, 5175, 5178, 5187, + 5195, 5200, 5226, 5238, 5247, 5250, 5259, 5269, 5274, 5285, 5288, 5290, + 5296, 5301, 5306, 5309, 5315, 5320, 5323, 5330, 5336, 5341, 5347, 5354, + 5357, 5365, 5371, 5377, 5381, 5384, 5387, 5400, 5406, 5413, 5424, 5432, + 5436, 5439, 5444, 5454, 5459, 5464, 5469, 5474, 5479, 5484, 5489, 5494, + 5499, 5502, 5511, 5516, 5526, 5531, 5538, 5542, 5551, 5558, 5562, 5569, + 5572, 5575, 5583, 5587, 5590, 5598, 5603, 5605, 5613, 5618, 5625, 5630, + 5633, 5637, 5639, 5650, 5661, 5675, 5680, 5690, 5696, 5699, 5704, 5713, + 5716, 5721, 5725, 5749, 5751, 5755, 5758, 5763, 5766, 5771, 5780, 5791, + 5794, 5797, 5800, 5804, 5812, 5817, 5829, 5832, 5837, 5841, 5844, 5853, + 5859, 5865, 5868, 5872, 5887, 5890, 5893, 5899, 5905, 5910, 5916, 5922, + 5930, 5934, 5948, 5955, 5963, 5966, 5973, 5978, 5984, 5992, 5997, 6003, + 6007, 6012, 6016, 6020, 6033, 6038, 6041, 6045, 6049, 6054, 6056, 6062, + 6064, 6068, 6071, 6078, 6089, 6099, 6103, 6108, 6112, 6116, 6119, 6130, + 6135, 6147, 6157, 6169, 6175, 6177, 6179, 6183, 6194, 6199, 6206, 6214, + 6225, 6232, 6236, 6238, 6242, 6252, 6263, 6268, 6272, 6276, 6279, 6282, + 6292, 6297, 6305, 6312, 6316, 6318, 6323, 6333, 6344, 6349, 6353, 6357, + 6360, 6363, 6370, 6379, 6389, 6391, 6414, 6427, 6441, 6443, 6454, 6462, + 6468, 6471, 6476, 6480, 6483, 6486, 6491, 6499, 6511, 6518, 6525, 6544, + 6555, 6558, 6564, 6566, 6573, 6576, 6578, 6586, 6601, 6609, 6629, 6631, + 6649, 6651, 6660, 6666, 6672, 6677, 6687, 6696, 6709, 6719, 6724, 6727, + 6733, 6751, 6754, 6757, 6765, 6778, 6780, 6784, 6792, 6794, 6796, 6798, + 6806, 6817, 6828, 6830, 6839, 6852, 6858, 6865, 6875, 6879, 6888, 6891, + 6897, 6900, 6905, 6911, 6919, 6925, 6931, 6943, 6951, 6954, 6965, 6969, + 6980, 6984, 6995, 6999, 7005, 7008, 7011, 7014, 7017, 7021, 7024, 7028, + 7034, 7037, 7040, 7043, 7046, 7050, 7053, 7061, 7066, 7069, 7073, 7081, + 7085, 7089, 7098, 7109, 7116, 7118, 7122, 7131, 7135, 7139, 7146, 7152, + 7156, 7163, 7172, 7184, 7198, 7202, 7204, 7207, 7214, 7228, 7237, 7240, + 7243, 7246, 7254, 7258, 7267, 7271, 7286, 7294, 7306, 7323, 7326, 7331, + 7338, 7342, 7345, 7361, 7366, 7380, 7385, 7387, 7396, 7404, 7407, 7410, + 7413, 7416, 7418, 7422, 7426, 7433, 7438, 7443, 7448, 7452, 7455, 7460, + 7468, 7473, 7476, 7482, 7487, 7492, 7499, 7502, 7517, 7528, 7537, 7546, + 7555, 7564, 7567, 7573, 7578, 7580, 7587, 7629, 7632, 7636, 7639, 7650, + 7659, 7662, 7664, 7676, 7681, 7685, 7689, 7692, 7695, 7711, 7713, 7719, + 7721, 7725, 7731, 7737, 7741, 7744, 7752, 7762, 7766, 7785, 7790, 7797, + 7804, 7878, 7892, 7901, 7909, 7916, 7923, 7928, 7935, 7942, 7947, 7954, + 7961, 7966, 7973, 7980, 7985, 7992, 7999, 8004, 8007, 8010, 8017, 8021, + 8030, 8041, 8050, 8054, 8061, 8063, 8070, 8078, 8083, 8087, 8092, 8099, + 8101, 8105, 8108, 8111, 8121, 8127, 8129, 8133, 8137, 8142, 8147, 8151, + 8157, 8162, 8167, 8170, 8181, 8184, 8187, 8193, 8200, 8205, 8209, 8215, + 8217, 8223, 8225, 8229, 8238, 8244, 8253, 8265, 8273, 8282, 8285, 8292, + 8296, 8304, 8311, 8321, 8326, 8328, 8333, 8340, 8357, 8364, 8374, 8383, + 8392, 8401, 8406, 8411, 8414, 8424, 8435, 8439, 8442, 8450, 8456, 8458, + 8463, 8466, 8473, 8477, 8482, 8485, 8498, 8502, 8507, 8510, 8520, 8524, + 8528, 8533, 8549, 8554, 8566, 8570, 8576, 8591, 8594, 8596, 8598, 8602, + 8605, 8625, 8630, 8635, 8646, 8649, 8661, 8670, 8681, 8690, 8695, 8719, + 8724, 8730, 8732, 8742, 8745, 8748, 8751, 8757, 8764, 8768, 8770, 8773, + 8778, 8782, 8787, 8790, 8795, 8798, 8803, 8807, 8813, 8817, 8821, 8829, + 8842, 8846, 8852, 8855, 8859, 8864, 8868, 8874, 8879, 8882, 8890, 8893, + 8902, 8906, 8908, 8927, 8933, 8938, 8943, 8945, 8949, 8958, 8971, 8982, + 8985, 8988, 8997, 8999, 9004, 9016, 9021, 9025, 9033, 9040, 9045, 9050, + 9061, 9064, 9076, 9091, 9098, 9104, 9108, 9114, 9118, 9127, 9136, 9141, + 9145, 9149, 9155, 9162, 9168, 9177, 9182, 9189, 9206, 9208, 9223, 9225, + 9236, 9239, 9242, 9248, 9251, 9254, 9266, 9277, 9280, 9285, 9289, 9297, + 9310, 9314, 9318, 9322, 9325, 9328, 9331, 9334, 9344, 9347, 9356, 9360, + 9368, 9381, 9384, 9386, 9390, 9394, 9400, 9405, 9409, 9412, 9415, 9424, + 9429, 9433, 9437, 9440, 9447, 9450, 9452, 9457, 9468, 9470, 9484, 9492, + 9501, 9504, 9509, 9512, 9521, 9543, 9549, 9554, 9556, 9566, 9575, 9587, + 9590, 9593, 9605, 9614, 9622, 9627, 9635, 9640, 9643, 9664, 9666, 9668, + 9671, 9675, 9685, 9689, 9694, 9699, 9703, 9705, 9708, 9712, 9722, 9732, + 9735, 9738, 9742, 9746, 9759, 9768, 9779, 9781, 9792, 9794, 9799, 9804, + 9811, 9829, 9835, 9840, 9850, 9856, 9864, 9870, 9874, 9877, 9889, 9896, + 9906, 9921, 9926, 9939, 9944, 9952, 9957, 9962, 9966, 9971, 9979, 9982, + 9985, 9988, 9991, 9993, 10000, 10002, 10006, 10012, 10015, 10019, 10024, + 10039, 10045, 10049, 10060, 10066, 10071, 10076, 10081, 10086, 10088, 10090, + 10098, 10105, 10113, 10120, 10133, 10139, 10143, 10155, 10162, 10164, 10166, + 10170, 10173, 10176, 10182, 10189, 10191, 10194, 10202, 10204, 10210, 10216, + 10221, 10223, 10231, 10242, 10245, 10249, 10253, 10256, 10261, 10265, 10269, + 10278, 10284, 10290, 10296, 10299, 10307, 10311, 10317, 10324, 10328, 10330, + 10335, 10340, 10345, 10349, 10359, 10363, 10366, 10369, 10375, 10378, 10381, + 10384, 10405, 10412, 10416, 10419, 10426, 10431, 10438, 10444, 10446, 10452, + 10456, 10463, 10468, 10474, 10478, 10486, 10491, 10497, 10500, 10503, 10506, + 10514, 10520, 10522, 10533, 10537, 10541, 10548, 10552, 10557, 10560, 10573, + 10578, 10582, 10587, 10593, 10599, 10602, 10607, 10610, 10619, 10624, 10632, + 10634, 10647, 10652, 10660, 10662, 10673, 10676, 10679, 10682, 10685, 10688, + 10691, 10694, 10697, 10702, 10706, 10709, 10712, 10715, 10719, 10730, 10733, + 10743, 10747, 10751, 10754, 10759, 10762, 10767, 10775, 10782, 10794, 10806, + 10811, 10819, 10833, 10838, 10849, 10852, 10854, 10864, 10874, 10885, 10901, + 10906, 10908, 10913, 10920, 10927, 10941, 10948, 10955, 10969, 10975, 10980, + 10983, 10988, 10991, 10995, 11010, 11015, 11019, 11030, 11035, 11048, 11064, + 11069, 11071, 11076, 11084, 11098, 11106, 11119, 11125, 11129, 11143, 11148, + 11152, 11166, 11169, 11173, 11183, 11191, 11199, 11202, 11207, 11209, 11213, + 11223, 11231, 11239, 11242, 11247, 11249, 11259, 11267, 11275, 11278, 11283, + 11296, 11301, 11310, 11321, 11335, 11340, 11343, 11349, 11353, 11357, 11361, + 11365, 11368, 11380, 11385, 11396, 11408, 11418, 11422, 11427, 11430, 11434, + 11438, 11440, 11445, 11447, 11455, 11465, 11470, 11472, 11481, 11489, 11496, + 11501, 11505, 11510, 11515, 11518, 11521, 11524, 11526, 11530, 11533, 11537, + 11545, 11547, 11549, 11552, 11557, 11561, 11565, 11570, 11573, 11577, 11580, + 11583, 11587, 11590, 11594, 11597, 11604, 11606, 11610, 11622, 11624, 11632, + 11634, 11638, 11642, 11646, 11650, 11668, 11670, 11692, 11701, 11703, 11715, + 11718, 11722, 11724, 11727, 11731, 11734, 11737, 11740, 11745, 11750, 11755, + 11763, 11765, 11775, 11780, 11792, 11797, 11809, 11818, 11824, 11828, 11833, + 11836, 11844, 11848, 11855, 11862, 11865, 11873, 11876, 11879, 11884, 11892, + 11894, 11897, 11904, 11918, 11920, 11934, 11939, 11942, 11945, 11948, 11956, + 11960, 11964, 11967, 11974, 11982, 12011, 12016, 12019, 12028, 12033, 12040, + 12043, 12050, 12053, 12060, 12063, 12065, 12073, 12076, 12081, 12087, 12110, + 12113, 12121, 12128, 12131, 12134, 12137, 12142, 12149, 12154, 12156, 12169, + 12173, 12178, 12181, 12188, 12191, 12194, 12199, 12203, 12208, 12211, 12216, + 12221, 12224, 12231, 12237, 12240, 12243, 12246, 12253, 12258, 12267, 12270, + 12277, 12283, 12286, 12293, 12295, 12297, 12303, 12316, 12333, 12345, 12350, + 12358, 12366, 12373, 12376, 12382, 12385, 12389, 12398, 12403, 12406, 12414, + 12419, 12428, 12435, 12439, 12448, 12456, 12460, 12463, 12471, 12477, 12481, + 12486, 12491, 12499, 12503, 12517, 12519, 12522, 12528, 12533, 12536, 12539, + 12545, 12556, 12565, 12568, 12577, 12579, 12582, 12589, 12595, 12599, 12606, + 12623, 12629, 12637, 12646, 12651, 12656, 12662, 12669, 12674, 12676, 12680, + 12686, 12690, 12696, 12702, 12706, 12709, 12736, 12745, 12754, 12764, 12772, + 12777, 12786, 12796, 12806, 12817, 12824, 12831, 12834, 12837, 12840, 12844, + 12846, 12849, 12852, 12855, 12858, 12862, 12864, 12872, 12874, 12885, 12887, + 12890, 12900, 12910, 12931, 12933, 12947, 12951, 12954, 12960, 12967, 12990, + 12995, 12999, 13004, 13009, 13012, 13015, 13020, 13031, 13037, 13041, 13047, + 13054, 13056, 13058, 13062, 13065, 13068, 13078, 13086, 13088, 13090, 13098, + 13107, 13109, 13113, 13123, 13132, 13134, 13137, 13142, 13156, 13165, 13167, + 13171, 13179, 13181, 13192, 13202, 13208, 13213, 13217, 13222, 13227, 13232, + 13236, 13243, 13250, 13255, 13260, 13264, 13275, 13281, 13286, 13290, 13295, + 13298, 13301, 13305, 13308, 13311, 13323, 13332, 13340, 13348, 13353, 13359, + 13363, 13370, 13375, 13380, 13385, 13389, 13398, 13401, 13405, 13411, 13419, + 13428, 13431, 13446, 13463, 13469, 13473, 13480, 13487, 13490, 13492, 13498, + 13500, 13503, 13512, 13515, 13519, 13525, 13537, 13547, 13551, 13554, 13557, + 13562, 13566, 13570, 13573, 13580, 13583, 13590, 13596, 13624, 13634, 13644, + 13646, 13654, 13685, 13690, 13704, 13728, 13731, 13743, 13746, 13750, 13772, + 13785, 13796, 13800, 13802, 13810, 13819, 13823, 13831, 13839, 13845, 13852, + 13856, 13860, 13862, 13865, 13875, 13881, 13886, 13892, 13894, 13905, 13908, + 13911, 13921, 13930, 13933, 13936, 13939, 13950, 13953, 13959, 13962, 13966, + 13969, 13982, 13984, 13987, 13989, 13994, 14001, 14006, 14010, 14033, 14049, + 14054, 14058, 14062, 14066, 14069, 14074, 14076, 14090, 14095, 14102, 14113, + 14119, 14121, 14123, 14131, 14140, 14148, 14150, 14152, 14154, 14159, 14176, + 14187, 14194, 14198, 14201, 14204, 14206, 14211, 14215, 14217, 14235, 14239, + 14242, 14247, 14249, 14252, 14256, 14258, 14270, 14278, 14281, 14288, 14292, + 14295, 14298, 14301, 14305, 14307, 14317, 14321, 14326, 14331, 14338, 14350, + 14357, 14364, 14368, 14370, 14376, 14384, 14391, 14398, 14402, 14404, 14424, + 14426, 14429, 14435, 14441, 14449, 14451, 14453, 14458, 14463, 14468, 14472, + 14476, 14480, 14492, 14498, 14505, 14510, 14516, 14521, 14525, 14531, 14536, + 14545, 14554, 14557, 14560, 14563, 14567, 14577, 14585, 14593, 14595, 14605, + 14608, 14611, 14614, 14618, 14620, 14624, 14630, 14632, 14635, 14638, 14643, + 14648, 14652, 14656, 14662, 14688, 14690, 14702, 14707, 14712, 14714, 14726, + 14731, 14736, 14738, 14743, 14750, 14754, 14763, 14778, 14785, 14789, 14794, + 14797, 14802, 14807, 14811, 14816, 14823, 14829, 14834, 14838, 14845, 14847, + 14850, 14862, 14866, 14871, 14875, 14882, 14888, 14894, 14897, 14906, 14917, + 14921, 14923, 14936, 14940, 14942, 14944, 14971, 14974, 14979, 14981, 15003, + 15006, 15008, 15010, 15017, 15019, 15027, 15031, 15036, 15039, 15042, 15045, + 15052, 15057, 15065, 15073, 15078, 15081, 15083, 15099, 15101, 15114, 15116, + 15118, 15130, 15139, 15143, 15145, 15148, 15151, 15156, 15160, 15164, 15169, + 15172, 15182, 15184, 15189, 15194, 15200, 15204, 15211, 15229, 15236, 15239, + 15242, 15245, 15248, 15256, 15258, 15267, 15269, 15274, 15283, 15285, 15292, + 15294, 15298, 15306, 15315, 15318, 15321, 15333, 15335, 15339, 15343, 15346, + 15351, 15356, 15363, 15369, 15373, 15379, 15392, 15396, 15403, 15407, 15421, + 15426, 15430, 15441, 15443, 15461, 15466, 15469, 15472, 15477, 15479, 15484, + 15490, 15495, 15501, 15508, 15527, 15532, 15539, 15541, 15548, 15553, 15559, + 15563, 15571, 15573, 15584, 15593, 15598, 15602, 15605, 15619, 15627, 15631, + 15634, 15642, 15654, 15658, 15663, 15666, 15679, 15683, 15695, 15700, 15704, + 15708, 15714, 15717, 15720, 15747, 15753, 15757, 15768, 15775, 15779, 15782, + 15788, 15797, 15805, 15809, 15813, 15821, 15830, 15836, 15838, 15862, 15867, + 15871, 15878, 15882, 15886, 15890, 15902, 15906, 15920, 15926, 15933, 15938, + 15949, 15952, 15958, 15960, 15969, 15979, 15984, 15999, 16003, 16006, 16010, + 16014, 16028, 16030, 16034, 16042, 16052, 16055, 16060, 16065, 16073, 16080, + 16084, 16087, 16099, 16105, 16114, 16117, 16127, 16138, 16144, 16146, 16148, + 16155, 16158, 16165, 16176, 16182, 16186, 16196, 16199, 16205, 16210, 16216, + 16221, 16223, 16227, 16230, 16234, 16238, 16243, 16254, 16258, 16266, 16275, + 16277, 16286, 16291, 16297, 16301, 16304, 16312, 16315, 16319, 16323, 16328, + 16331, 16335, 16339, 16343, 16362, 16370, 16374, 16378, 16383, 16387, 16391, + 16395, 16398, 16401, 16404, 16407, 16410, 16418, 16421, 16429, 16431, 16442, + 16449, 16454, 16460, 16465, 16470, 16477, 16483, 16490, 16493, 16496, 16500, + 16505, 16509, 16511, 16522, 16529, 16533, 16543, 16547, 16555, 16567, 16572, + 16582, 16590, 16593, 16599, 16604, 16607, 16612, 16617, 16630, 16637, 16647, + 16652, 16654, 16659, 16663, 16669, 16673, 16686, 16690, 16700, 16703, 16705, + 16710, 16719, 16732, 16740, 16744, 16753, 16757, 16762, 16773, 16775, 16791, + 16796, 16802, 16808, 16826, 16833, 16836, 16839, 16847, 16850, 16858, 16860, + 16864, 16867, 16872, 16874, 16878, 16890, 16899, 16907, 16912, 16916, 16926, + 16928, 16934, 16939, 16942, 16952, 16958, 16961, 16964, 16972, 16982, 16998, + 17002, 17006, 17009, 17012, 17017, 17022, 17025, 17028, 17034, 17037, 17043, + 17046, 17049, 17054, 17057, 17065, 17071, 17076, 17084, 17097, 17101, 17103, + 17106, 17118, 17122, 17125, 17140, 17144, 17151, 17154, 17163, 17170, 17175, + 17179, 17187, 17193, 17201, 17204, 17213, 17216, 17219, 17228, 17234, 17240, + 17245, 17247, 17258, 17260, 17269, 17271, 17275, 17281, 17285, 17294, 17299, + 17304, 17307, 17312, 17319, 17326, 17331, 17347, 17349, 17353, 17358, 17363, + 17375, 17379, 17386, 17391, 17396, 17399, 17410, 17415, 17425, 17427, 17429, + 17439, 17443, 17445, 17457, 17465, 17478, 17481, 17486, 17498, 17500, 17508, + 17516, 17523, 17530, 17537, 17541, 17546, 17550, 17558, 17562, 17569, 17574, + 17583, 17592, 17595, 17615, 17619, 17622, 17629, 17632, 17636, 17639, 17646, + 17649, 17655, 17658, 17662, 17665, 17672, 17677, 17691, 17698, 17709, 17718, + 17727, 17731, 17735, 17761, 17764, 17767, 17777, 17785, 17791, 17793, 17797, + 17803, 17812, 17816, 17819, 17822, 17831, 17834, 17837, 17840, 17843, 17855, + 17863, 17870, 17873, 17877, 17879, 17882, 17887, 17896, 17901, 17904, 17907, + 17910, 17919, 17922, 17925, 17928, 17934, 17938, 17950, 17960, 17964, 17967, + 17973, 17977, 17983, 17987, 17990, 17993, 17995, 18002, 18006, 18009, 18012, + 18015, 18020, 18023, 18027, 18036, 18039, 18046, 18050, 18055, 18060, 18063, + 18072, 18076, 18087, 18090, 18094, 18099, 18103, 18112, 18115, 18119, 18128, + 18131, 18135, 18140, 18149, 18152, 18156, 18164, 18169, 18174, 18177, 18181, + 18183, 18192, 18199, 18202, 18209, 18211, 18214, 18217, 18221, 18224, 18229, + 18236, 18242, 18250, 18254, 18257, 18260, 18266, 18269, 18273, 18277, 18282, + 18285, 18288, 18297, 18309, 18316, 18319, 18325, 18328, 18331, 18340, 18346, + 18353, 18355, 18368, 18374, 18379, 18384, 18393, 18396, 18398, 18402, 18409, + 18416, 18424, 18439, 18445, 18449, 18454, 18459, 18465, 18468, 18472, 18482, + 18492, 18498, 18500, 18510, 18512, 18519, 18523, 18532, 18537, 18542, 18545, + 18554, 18557, 18566, 18580, 18588, 18591, 18604, 18610, 18612, 18625, 18634, + 18640, 18650, 18658, 18661, 18664, 18678, 18680, 18688, 18693, 18702, 18708, + 18713, 18716, 18721, 18726, 18730, 18736, 18742, 18751, 18756, 18764, 18768, + 18773, 18779, 18786, 18791, 18798, 18802, 18807, 18815, 18818, 18821, 18824, + 18828, 18833, 18838, 18849, 18853, 18855, 18866, 18868, 18879, 18890, 18899, + 18902, 18906, 18909, 18924, 18929, 18937, 18944, 18948, 18953, 18957, 18962, + 18966, 18972, 18975, 18982, 18992, 19000, 19004, 19014, 19017, 19019, 19029, + 19031, 19037, 19043, 19045, 19059, 19061, 19072, 19082, 19085, 19089, 19091, + 19100, 19107, 19112, 19116, 19120, 19125, 19129, 19132, 19136, 19144, 19155, + 19162, 19167, 19172, 19176, 19181, 19200, 19205, 19212, 19223, 19230, 19237, + 19242, 19249, 19254, 19263, 19271, 19279, 19285, 19290, 19295, 19299, 19304, + 19307, 19312, 19316, 19320, 19325, 19334, 19340, 19348, 19352, 19356, 19358, + 19365, 19369, 19377, 19380, 19385, 19392, 19410, 19427, 19434, 19448, 19456, + 19459, 19463, 19468, 19473, 19477, 19480, 19484, 19491, 19496, 19498, 19500, + 19510, 19515, 19519, 19522, 19526, 19535, 19541, 19545, 19547, 19551, 19555, + 19562, 19570, 19578, 19580, 19585, 19590, 19592, 19595, 19619, 19626, 19659, + 19664, 19667, 19672, 19674, 19678, 19685, 19690, 19695, 19698, 19702, 19709, + 19714, 19744, 19751, 19766, 19782, 19801, 19818, 19825, 19833, 19846, 19855, + 19864, 19873, 19883, 19891, 19901, 19911, 19923, 19939, 19957, 19970, 19985, + 19996, 20006, 20017, 20027, 20044, 20050, 20072, 20077, 20083, 20089, 20095, + 20100, 20102, 20105, 20115, 20118, 20120, 20122, 20136, 20141, 20147, 20153, + 20159, 20164, 20166, 20169, 20179, 20182, 20184, 20186, 20200, 20210, 20216, + 20222, 20322, + } + 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) + } +} + +// PlSqlParserInit initializes any static state used to implement PlSqlParser. By default the +// static state used to implement the parser is lazily initialized during the first call to +// NewPlSqlParser(). You can call this function if you wish to initialize the static state ahead +// of time. +func PlSqlParserInit() { + staticData := &PlSqlParserParserStaticData + staticData.once.Do(plsqlparserParserInit) +} + +// NewPlSqlParser produces a new parser instance for the optional input antlr.TokenStream. +func NewPlSqlParser(input antlr.TokenStream) *PlSqlParser { + PlSqlParserInit() + this := new(PlSqlParser) + this.BaseParser = antlr.NewBaseParser(input) + staticData := &PlSqlParserParserStaticData + 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 = "PlSqlParser.g4" + + return this +} + +// PlSqlParser tokens. +const ( + PlSqlParserEOF = antlr.TokenEOF + PlSqlParserABORT = 1 + PlSqlParserABS = 2 + PlSqlParserABSENT = 3 + PlSqlParserACCESS = 4 + PlSqlParserACCESSED = 5 + PlSqlParserACCOUNT = 6 + PlSqlParserACL = 7 + PlSqlParserACOS = 8 + PlSqlParserACROSS = 9 + PlSqlParserACTION = 10 + PlSqlParserACTIONS = 11 + PlSqlParserACTIVATE = 12 + PlSqlParserACTIVE = 13 + PlSqlParserACTIVE_COMPONENT = 14 + PlSqlParserACTIVE_DATA = 15 + PlSqlParserACTIVE_FUNCTION = 16 + PlSqlParserACTIVE_TAG = 17 + PlSqlParserACTIVITY = 18 + PlSqlParserADAPTIVE_PLAN = 19 + PlSqlParserADD = 20 + PlSqlParserADD_COLUMN = 21 + PlSqlParserADD_GROUP = 22 + PlSqlParserADD_MONTHS = 23 + PlSqlParserADJ_DATE = 24 + PlSqlParserADMIN = 25 + PlSqlParserADMINISTER = 26 + PlSqlParserADMINISTRATOR = 27 + PlSqlParserADVANCED = 28 + PlSqlParserADVISE = 29 + PlSqlParserADVISOR = 30 + PlSqlParserAFD_DISKSTRING = 31 + PlSqlParserAFTER = 32 + PlSqlParserAGENT = 33 + PlSqlParserAGGREGATE = 34 + PlSqlParserA_LETTER = 35 + PlSqlParserALIAS = 36 + PlSqlParserALL = 37 + PlSqlParserALLOCATE = 38 + PlSqlParserALLOW = 39 + PlSqlParserALL_ROWS = 40 + PlSqlParserALTER = 41 + PlSqlParserALTERNATE = 42 + PlSqlParserALWAYS = 43 + PlSqlParserANALYTIC = 44 + PlSqlParserANALYZE = 45 + PlSqlParserANCESTOR = 46 + PlSqlParserANCILLARY = 47 + PlSqlParserAND = 48 + PlSqlParserAND_EQUAL = 49 + PlSqlParserANOMALY = 50 + PlSqlParserANSI_REARCH = 51 + PlSqlParserANTIJOIN = 52 + PlSqlParserANY = 53 + PlSqlParserANYSCHEMA = 54 + PlSqlParserAPPEND = 55 + PlSqlParserAPPENDCHILDXML = 56 + PlSqlParserAPPEND_VALUES = 57 + PlSqlParserAPPLICATION = 58 + PlSqlParserAPPLY = 59 + PlSqlParserAPPROX_COUNT_DISTINCT = 60 + PlSqlParserARCHIVAL = 61 + PlSqlParserARCHIVE = 62 + PlSqlParserARCHIVED = 63 + PlSqlParserARCHIVELOG = 64 + PlSqlParserARRAY = 65 + PlSqlParserAS = 66 + PlSqlParserASC = 67 + PlSqlParserASCII = 68 + PlSqlParserASCIISTR = 69 + PlSqlParserASIN = 70 + PlSqlParserASIS = 71 + PlSqlParserASSEMBLY = 72 + PlSqlParserASSIGN = 73 + PlSqlParserASSOCIATE = 74 + PlSqlParserASYNC = 75 + PlSqlParserASYNCHRONOUS = 76 + PlSqlParserATAN2 = 77 + PlSqlParserATAN = 78 + PlSqlParserAT = 79 + PlSqlParserATTRIBUTE = 80 + PlSqlParserATTRIBUTES = 81 + PlSqlParserAUDIT = 82 + PlSqlParserAUTHENTICATED = 83 + PlSqlParserAUTHENTICATION = 84 + PlSqlParserAUTHID = 85 + PlSqlParserAUTHORIZATION = 86 + PlSqlParserAUTOALLOCATE = 87 + PlSqlParserAUTO = 88 + PlSqlParserAUTOEXTEND = 89 + PlSqlParserAUTO_LOGIN = 90 + PlSqlParserAUTOMATIC = 91 + PlSqlParserAUTONOMOUS_TRANSACTION = 92 + PlSqlParserAUTO_REOPTIMIZE = 93 + PlSqlParserAVAILABILITY = 94 + PlSqlParserAVRO = 95 + PlSqlParserBACKGROUND = 96 + PlSqlParserBACKINGFILE = 97 + PlSqlParserBACKUP = 98 + PlSqlParserBACKUPS = 99 + PlSqlParserBASIC = 100 + PlSqlParserBASICFILE = 101 + PlSqlParserBATCH = 102 + PlSqlParserBATCHSIZE = 103 + PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID = 104 + PlSqlParserBECOME = 105 + PlSqlParserBEFORE = 106 + PlSqlParserBEGIN = 107 + PlSqlParserBEGINNING = 108 + PlSqlParserBEGIN_OUTLINE_DATA = 109 + PlSqlParserBEHALF = 110 + PlSqlParserBEQUEATH = 111 + PlSqlParserBETWEEN = 112 + PlSqlParserBFILE = 113 + PlSqlParserBFILENAME = 114 + PlSqlParserBIGFILE = 115 + PlSqlParserBINARY = 116 + PlSqlParserBINARY_DOUBLE = 117 + PlSqlParserBINARY_DOUBLE_INFINITY = 118 + PlSqlParserBINARY_DOUBLE_NAN = 119 + PlSqlParserBINARY_FLOAT = 120 + PlSqlParserBINARY_FLOAT_INFINITY = 121 + PlSqlParserBINARY_FLOAT_NAN = 122 + PlSqlParserBINARY_INTEGER = 123 + PlSqlParserBIND_AWARE = 124 + PlSqlParserBINDING = 125 + PlSqlParserBIN_TO_NUM = 126 + PlSqlParserBITAND = 127 + PlSqlParserBITMAP_AND = 128 + PlSqlParserBITMAP = 129 + PlSqlParserBITMAPS = 130 + PlSqlParserBITMAP_TREE = 131 + PlSqlParserBITS = 132 + PlSqlParserBLOB = 133 + PlSqlParserBLOCK = 134 + PlSqlParserBLOCK_RANGE = 135 + PlSqlParserBLOCKS = 136 + PlSqlParserBLOCKSIZE = 137 + PlSqlParserBODY = 138 + PlSqlParserBOOLEAN = 139 + PlSqlParserBOTH = 140 + PlSqlParserBOUND = 141 + PlSqlParserBRANCH = 142 + PlSqlParserBREADTH = 143 + PlSqlParserBROADCAST = 144 + PlSqlParserBSON = 145 + PlSqlParserBUFFER = 146 + PlSqlParserBUFFER_CACHE = 147 + PlSqlParserBUFFER_POOL = 148 + PlSqlParserBUILD = 149 + PlSqlParserBULK = 150 + PlSqlParserBY = 151 + PlSqlParserBYPASS_RECURSIVE_CHECK = 152 + PlSqlParserBYPASS_UJVC = 153 + PlSqlParserBYTE = 154 + PlSqlParserCACHE = 155 + PlSqlParserCACHE_CB = 156 + PlSqlParserCACHE_INSTANCES = 157 + PlSqlParserCACHE_TEMP_TABLE = 158 + PlSqlParserCACHING = 159 + PlSqlParserCALCULATED = 160 + PlSqlParserCALLBACK = 161 + PlSqlParserCALL = 162 + PlSqlParserCANCEL = 163 + PlSqlParserCANONICAL = 164 + PlSqlParserCAPACITY = 165 + PlSqlParserCAPTION = 166 + PlSqlParserCARDINALITY = 167 + PlSqlParserCASCADE = 168 + PlSqlParserCASE = 169 + PlSqlParserCAST = 170 + PlSqlParserCASESENSITIVE = 171 + PlSqlParserCATEGORY = 172 + PlSqlParserCDBDEFAULT = 173 + PlSqlParserCEIL = 174 + PlSqlParserCELL_FLASH_CACHE = 175 + PlSqlParserCERTIFICATE = 176 + PlSqlParserCFILE = 177 + PlSqlParserCHAINED = 178 + PlSqlParserCHANGE = 179 + PlSqlParserCHANGE_DUPKEY_ERROR_INDEX = 180 + PlSqlParserCHARACTER = 181 + PlSqlParserCHAR = 182 + PlSqlParserCHAR_CS = 183 + PlSqlParserCHARTOROWID = 184 + PlSqlParserCHECK_ACL_REWRITE = 185 + PlSqlParserCHECK = 186 + PlSqlParserCHECKPOINT = 187 + PlSqlParserCHILD = 188 + PlSqlParserCHOOSE = 189 + PlSqlParserCHR = 190 + PlSqlParserCHUNK = 191 + PlSqlParserCLASS = 192 + PlSqlParserCLASSIFICATION = 193 + PlSqlParserCLASSIFIER = 194 + PlSqlParserCLAUSE = 195 + PlSqlParserCLEAN = 196 + PlSqlParserCLEANUP = 197 + PlSqlParserCLEAR = 198 + PlSqlParserC_LETTER = 199 + PlSqlParserCLIENT = 200 + PlSqlParserCLOB = 201 + PlSqlParserCLONE = 202 + PlSqlParserCLOSE_CACHED_OPEN_CURSORS = 203 + PlSqlParserCLOSE = 204 + PlSqlParserCLUSTER_BY_ROWID = 205 + PlSqlParserCLUSTER = 206 + PlSqlParserCLUSTER_DETAILS = 207 + PlSqlParserCLUSTER_DISTANCE = 208 + PlSqlParserCLUSTER_ID = 209 + PlSqlParserCLUSTERING = 210 + PlSqlParserCLUSTERING_FACTOR = 211 + PlSqlParserCLUSTER_PROBABILITY = 212 + PlSqlParserCLUSTER_SET = 213 + PlSqlParserCOALESCE = 214 + PlSqlParserCOALESCE_SQ = 215 + PlSqlParserCOARSE = 216 + PlSqlParserCO_AUTH_IND = 217 + PlSqlParserCOLD = 218 + PlSqlParserCOLLECT = 219 + PlSqlParserCOLUMNAR = 220 + PlSqlParserCOLUMN_AUTH_INDICATOR = 221 + PlSqlParserCOLUMN = 222 + PlSqlParserCOLUMNS = 223 + PlSqlParserCOLUMN_STATS = 224 + PlSqlParserCOLUMN_VALUE = 225 + PlSqlParserCOMMENT = 226 + PlSqlParserCOMMIT = 227 + PlSqlParserCOMMITTED = 228 + PlSqlParserCOMMON = 229 + PlSqlParserCOMMON_DATA = 230 + PlSqlParserCOMPACT = 231 + PlSqlParserCOMPATIBILITY = 232 + PlSqlParserCOMPILE = 233 + PlSqlParserCOMPLETE = 234 + PlSqlParserCOMPLIANCE = 235 + PlSqlParserCOMPONENT = 236 + PlSqlParserCOMPONENTS = 237 + PlSqlParserCOMPOSE = 238 + PlSqlParserCOMPOSITE = 239 + PlSqlParserCOMPOSITE_LIMIT = 240 + PlSqlParserCOMPOUND = 241 + PlSqlParserCOMPRESS = 242 + PlSqlParserCOMPUTE = 243 + PlSqlParserCONCAT = 244 + PlSqlParserCON_DBID_TO_ID = 245 + PlSqlParserCONDITIONAL = 246 + PlSqlParserCONDITION = 247 + PlSqlParserCONFIRM = 248 + PlSqlParserCONFORMING = 249 + PlSqlParserCON_GUID_TO_ID = 250 + PlSqlParserCON_ID = 251 + PlSqlParserCON_NAME_TO_ID = 252 + PlSqlParserCONNECT_BY_CB_WHR_ONLY = 253 + PlSqlParserCONNECT_BY_COMBINE_SW = 254 + PlSqlParserCONNECT_BY_COST_BASED = 255 + PlSqlParserCONNECT_BY_ELIM_DUPS = 256 + PlSqlParserCONNECT_BY_FILTERING = 257 + PlSqlParserCONNECT_BY_ISCYCLE = 258 + PlSqlParserCONNECT_BY_ISLEAF = 259 + PlSqlParserCONNECT_BY_ROOT = 260 + PlSqlParserCONNECT = 261 + PlSqlParserCONNECT_TIME = 262 + PlSqlParserCONSIDER = 263 + PlSqlParserCONSISTENT = 264 + PlSqlParserCONSTANT = 265 + PlSqlParserCONST = 266 + PlSqlParserCONSTRAINT = 267 + PlSqlParserCONSTRAINTS = 268 + PlSqlParserCONSTRUCTOR = 269 + PlSqlParserCONTAINER = 270 + PlSqlParserCONTAINERS = 271 + PlSqlParserCONTAINERS_DEFAULT = 272 + PlSqlParserCONTAINER_DATA = 273 + PlSqlParserCONTAINER_MAP = 274 + PlSqlParserCONTENT = 275 + PlSqlParserCONTENTS = 276 + PlSqlParserCONTEXT = 277 + PlSqlParserCONTINUE = 278 + PlSqlParserCONTROLFILE = 279 + PlSqlParserCON_UID_TO_ID = 280 + PlSqlParserCONVERT = 281 + PlSqlParserCONVERSION = 282 + PlSqlParserCOOKIE = 283 + PlSqlParserCOPY = 284 + PlSqlParserCORR_K = 285 + PlSqlParserCORR_S = 286 + PlSqlParserCORRUPTION = 287 + PlSqlParserCORRUPT_XID_ALL = 288 + PlSqlParserCORRUPT_XID = 289 + PlSqlParserCOS = 290 + PlSqlParserCOSH = 291 + PlSqlParserCOST = 292 + PlSqlParserCOST_XML_QUERY_REWRITE = 293 + PlSqlParserCOUNT = 294 + PlSqlParserCOVAR_POP = 295 + PlSqlParserCOVAR_SAMP = 296 + PlSqlParserCPU_COSTING = 297 + PlSqlParserCPU_PER_CALL = 298 + PlSqlParserCPU_PER_SESSION = 299 + PlSqlParserCRASH = 300 + PlSqlParserCREATE = 301 + PlSqlParserCREATE_FILE_DEST = 302 + PlSqlParserCREATE_STORED_OUTLINES = 303 + PlSqlParserCREATION = 304 + PlSqlParserCREDENTIAL = 305 + PlSqlParserCRITICAL = 306 + PlSqlParserCROSS = 307 + PlSqlParserCROSSEDITION = 308 + PlSqlParserCSCONVERT = 309 + PlSqlParserCUBE_AJ = 310 + PlSqlParserCUBE = 311 + PlSqlParserCUBE_GB = 312 + PlSqlParserCUBE_SJ = 313 + PlSqlParserCUME_DISTM = 314 + PlSqlParserCURRENT = 315 + PlSqlParserCURRENT_DATE = 316 + PlSqlParserCURRENT_SCHEMA = 317 + PlSqlParserCURRENT_TIME = 318 + PlSqlParserCURRENT_TIMESTAMP = 319 + PlSqlParserCURRENT_USER = 320 + PlSqlParserCURRENTV = 321 + PlSqlParserCURSOR = 322 + PlSqlParserCURSOR_SHARING_EXACT = 323 + PlSqlParserCURSOR_SPECIFIC_SEGMENT = 324 + PlSqlParserCUSTOMDATUM = 325 + PlSqlParserCV = 326 + PlSqlParserCYCLE = 327 + PlSqlParserDANGLING = 328 + PlSqlParserDATABASE = 329 + PlSqlParserDATA = 330 + PlSqlParserDATAFILE = 331 + PlSqlParserDATAFILES = 332 + PlSqlParserDATAMOVEMENT = 333 + PlSqlParserDATAOBJNO = 334 + PlSqlParserDATAOBJ_TO_MAT_PARTITION = 335 + PlSqlParserDATAOBJ_TO_PARTITION = 336 + PlSqlParserDATAPUMP = 337 + PlSqlParserDATA_SECURITY_REWRITE_LIMIT = 338 + PlSqlParserDATE = 339 + PlSqlParserDATE_MODE = 340 + PlSqlParserDAY = 341 + PlSqlParserDAYS = 342 + PlSqlParserDBA = 343 + PlSqlParserDBA_RECYCLEBIN = 344 + PlSqlParserDBMS_STATS = 345 + PlSqlParserDB_ROLE_CHANGE = 346 + PlSqlParserDBTIMEZONE = 347 + PlSqlParserDB_UNIQUE_NAME = 348 + PlSqlParserDB_VERSION = 349 + PlSqlParserDDL = 350 + PlSqlParserDEALLOCATE = 351 + PlSqlParserDEBUG = 352 + PlSqlParserDEBUGGER = 353 + PlSqlParserDEC = 354 + PlSqlParserDECIMAL = 355 + PlSqlParserDECLARE = 356 + PlSqlParserDECOMPOSE = 357 + PlSqlParserDECORRELATE = 358 + PlSqlParserDECR = 359 + PlSqlParserDECREMENT = 360 + PlSqlParserDECRYPT = 361 + PlSqlParserDEDUPLICATE = 362 + PlSqlParserDEFAULT = 363 + PlSqlParserDEFAULTS = 364 + PlSqlParserDEFAULT_COLLATION = 365 + PlSqlParserDEFAULT_CREDENTIAL = 366 + PlSqlParserDEFERRABLE = 367 + PlSqlParserDEFERRED = 368 + PlSqlParserDEFINED = 369 + PlSqlParserDEFINE = 370 + PlSqlParserDEFINER = 371 + PlSqlParserDEGREE = 372 + PlSqlParserDELAY = 373 + PlSqlParserDELEGATE = 374 + PlSqlParserDELETE_ALL = 375 + PlSqlParserDELETE = 376 + PlSqlParserDELETEXML = 377 + PlSqlParserDEMAND = 378 + PlSqlParserDENSE_RANKM = 379 + PlSqlParserDEPENDENT = 380 + PlSqlParserDEPTH = 381 + PlSqlParserDEQUEUE = 382 + PlSqlParserDEREF = 383 + PlSqlParserDEREF_NO_REWRITE = 384 + PlSqlParserDESC = 385 + PlSqlParserDESCRIPTION = 386 + PlSqlParserDESTROY = 387 + PlSqlParserDETACHED = 388 + PlSqlParserDETERMINES = 389 + PlSqlParserDETERMINISTIC = 390 + PlSqlParserDICTIONARY = 391 + PlSqlParserDIMENSION = 392 + PlSqlParserDIMENSIONS = 393 + PlSqlParserDIRECT_LOAD = 394 + PlSqlParserDIRECTORY = 395 + PlSqlParserDIRECT_PATH = 396 + PlSqlParserDISABLE_ALL = 397 + PlSqlParserDISABLE = 398 + PlSqlParserDISABLE_PARALLEL_DML = 399 + PlSqlParserDISABLE_PRESET = 400 + PlSqlParserDISABLE_RPKE = 401 + PlSqlParserDISALLOW = 402 + PlSqlParserDISASSOCIATE = 403 + PlSqlParserDISCARD = 404 + PlSqlParserDISCONNECT = 405 + PlSqlParserDISK = 406 + PlSqlParserDISKGROUP = 407 + PlSqlParserDISKS = 408 + PlSqlParserDISMOUNT = 409 + PlSqlParserDISTINCT = 410 + PlSqlParserDISTINGUISHED = 411 + PlSqlParserDISTRIBUTED = 412 + PlSqlParserDISTRIBUTE = 413 + PlSqlParserDML = 414 + PlSqlParserDML_UPDATE = 415 + PlSqlParserDOCFIDELITY = 416 + PlSqlParserDOCUMENT = 417 + PlSqlParserDOMAIN_INDEX_FILTER = 418 + PlSqlParserDOMAIN_INDEX_NO_SORT = 419 + PlSqlParserDOMAIN_INDEX_SORT = 420 + PlSqlParserDOUBLE = 421 + PlSqlParserDOWNGRADE = 422 + PlSqlParserDRIVING_SITE = 423 + PlSqlParserDROP_COLUMN = 424 + PlSqlParserDROP = 425 + PlSqlParserDROP_GROUP = 426 + PlSqlParserDSINTERVAL_UNCONSTRAINED = 427 + PlSqlParserDST_UPGRADE_INSERT_CONV = 428 + PlSqlParserDUMP = 429 + PlSqlParserDUPLICATE = 430 + PlSqlParserDV = 431 + PlSqlParserDYNAMIC = 432 + PlSqlParserDYNAMIC_SAMPLING = 433 + PlSqlParserDYNAMIC_SAMPLING_EST_CDN = 434 + PlSqlParserE_LETTER = 435 + PlSqlParserEACH = 436 + PlSqlParserEDITIONABLE = 437 + PlSqlParserEDITION = 438 + PlSqlParserEDITIONING = 439 + PlSqlParserEDITIONS = 440 + PlSqlParserELEMENT = 441 + PlSqlParserELIM_GROUPBY = 442 + PlSqlParserELIMINATE_JOIN = 443 + PlSqlParserELIMINATE_OBY = 444 + PlSqlParserELIMINATE_OUTER_JOIN = 445 + PlSqlParserELSE = 446 + PlSqlParserELSIF = 447 + PlSqlParserEM = 448 + PlSqlParserEMPTY_BLOB = 449 + PlSqlParserEMPTY_CLOB = 450 + PlSqlParserEMPTY = 451 + PlSqlParserENABLE_ALL = 452 + PlSqlParserENABLE = 453 + PlSqlParserENABLE_PARALLEL_DML = 454 + PlSqlParserENABLE_PRESET = 455 + PlSqlParserENCODING = 456 + PlSqlParserENCRYPT = 457 + PlSqlParserENCRYPTION = 458 + PlSqlParserEND = 459 + PlSqlParserEND_OUTLINE_DATA = 460 + PlSqlParserENFORCED = 461 + PlSqlParserENFORCE = 462 + PlSqlParserENQUEUE = 463 + PlSqlParserENTERPRISE = 464 + PlSqlParserENTITYESCAPING = 465 + PlSqlParserENTRY = 466 + PlSqlParserEQUIPART = 467 + PlSqlParserERR = 468 + PlSqlParserERROR_ARGUMENT = 469 + PlSqlParserERROR = 470 + PlSqlParserERROR_ON_OVERLAP_TIME = 471 + PlSqlParserERRORS = 472 + PlSqlParserESCAPE = 473 + PlSqlParserESTIMATE = 474 + PlSqlParserEVAL = 475 + PlSqlParserEVALNAME = 476 + PlSqlParserEVALUATE = 477 + PlSqlParserEVALUATION = 478 + PlSqlParserEVENTS = 479 + PlSqlParserEVERY = 480 + PlSqlParserEXCEPT = 481 + PlSqlParserEXCEPTION = 482 + PlSqlParserEXCEPTION_INIT = 483 + PlSqlParserEXCEPTIONS = 484 + PlSqlParserEXCHANGE = 485 + PlSqlParserEXCLUDE = 486 + PlSqlParserEXCLUDING = 487 + PlSqlParserEXCLUSIVE = 488 + PlSqlParserEXECUTE = 489 + PlSqlParserEXEMPT = 490 + PlSqlParserEXISTING = 491 + PlSqlParserEXISTS = 492 + PlSqlParserEXISTSNODE = 493 + PlSqlParserEXIT = 494 + PlSqlParserEXPAND_GSET_TO_UNION = 495 + PlSqlParserEXPAND_TABLE = 496 + PlSqlParserEXP = 497 + PlSqlParserEXPIRE = 498 + PlSqlParserEXPLAIN = 499 + PlSqlParserEXPLOSION = 500 + PlSqlParserEXPORT = 501 + PlSqlParserEXPR_CORR_CHECK = 502 + PlSqlParserEXPRESS = 503 + PlSqlParserEXTENDS = 504 + PlSqlParserEXTENT = 505 + PlSqlParserEXTENTS = 506 + PlSqlParserEXTERNAL = 507 + PlSqlParserEXTERNALLY = 508 + PlSqlParserEXTRACTCLOBXML = 509 + PlSqlParserEXTRACT = 510 + PlSqlParserEXTRACTVALUE = 511 + PlSqlParserEXTRA = 512 + PlSqlParserFACILITY = 513 + PlSqlParserFACT = 514 + PlSqlParserFACTOR = 515 + PlSqlParserFACTORIZE_JOIN = 516 + PlSqlParserFAILED = 517 + PlSqlParserFAILED_LOGIN_ATTEMPTS = 518 + PlSqlParserFAILGROUP = 519 + PlSqlParserFAILOVER = 520 + PlSqlParserFAILURE = 521 + PlSqlParserFALSE = 522 + PlSqlParserFAMILY = 523 + PlSqlParserFAR = 524 + PlSqlParserFAST = 525 + PlSqlParserFASTSTART = 526 + PlSqlParserFBTSCAN = 527 + PlSqlParserFEATURE = 528 + PlSqlParserFEATURE_DETAILS = 529 + PlSqlParserFEATURE_ID = 530 + PlSqlParserFEATURE_SET = 531 + PlSqlParserFEATURE_VALUE = 532 + PlSqlParserFETCH = 533 + PlSqlParserFILE = 534 + PlSqlParserFILE_NAME_CONVERT = 535 + PlSqlParserFILEGROUP = 536 + PlSqlParserFILESTORE = 537 + PlSqlParserFILESYSTEM_LIKE_LOGGING = 538 + PlSqlParserFILTER = 539 + PlSqlParserFINAL = 540 + PlSqlParserFINE = 541 + PlSqlParserFINISH = 542 + PlSqlParserFIRST = 543 + PlSqlParserFIRSTM = 544 + PlSqlParserFIRST_ROWS = 545 + PlSqlParserFIRST_VALUE = 546 + PlSqlParserFIXED_VIEW_DATA = 547 + PlSqlParserFLAGGER = 548 + PlSqlParserFLASHBACK = 549 + PlSqlParserFLASH_CACHE = 550 + PlSqlParserFLOAT = 551 + PlSqlParserFLOB = 552 + PlSqlParserFLEX = 553 + PlSqlParserFLOOR = 554 + PlSqlParserFLUSH = 555 + PlSqlParserFOLDER = 556 + PlSqlParserFOLLOWING = 557 + PlSqlParserFOLLOWS = 558 + PlSqlParserFORALL = 559 + PlSqlParserFORCE = 560 + PlSqlParserFORCE_XML_QUERY_REWRITE = 561 + PlSqlParserFOREIGN = 562 + PlSqlParserFOREVER = 563 + PlSqlParserFOR = 564 + PlSqlParserFORMAT = 565 + PlSqlParserFORWARD = 566 + PlSqlParserFRAGMENT_NUMBER = 567 + PlSqlParserFREELIST = 568 + PlSqlParserFREELISTS = 569 + PlSqlParserFREEPOOLS = 570 + PlSqlParserFRESH = 571 + PlSqlParserFROM = 572 + PlSqlParserFROM_TZ = 573 + PlSqlParserFULL = 574 + PlSqlParserFULL_OUTER_JOIN_TO_OUTER = 575 + PlSqlParserFUNCTION = 576 + PlSqlParserFUNCTIONS = 577 + PlSqlParserFTP = 578 + PlSqlParserG_LETTER = 579 + PlSqlParserGATHER_OPTIMIZER_STATISTICS = 580 + PlSqlParserGATHER_PLAN_STATISTICS = 581 + PlSqlParserGBY_CONC_ROLLUP = 582 + PlSqlParserGBY_PUSHDOWN = 583 + PlSqlParserGENERATED = 584 + PlSqlParserGET = 585 + PlSqlParserGLOBAL = 586 + PlSqlParserGLOBALLY = 587 + PlSqlParserGLOBAL_NAME = 588 + PlSqlParserGLOBAL_TOPIC_ENABLED = 589 + PlSqlParserGOTO = 590 + PlSqlParserGRANT = 591 + PlSqlParserGROUP_BY = 592 + PlSqlParserGROUP = 593 + PlSqlParserGROUP_ID = 594 + PlSqlParserGROUPING = 595 + PlSqlParserGROUPING_ID = 596 + PlSqlParserGROUPS = 597 + PlSqlParserGUARANTEED = 598 + PlSqlParserGUARANTEE = 599 + PlSqlParserGUARD = 600 + PlSqlParserHALF_YEARS = 601 + PlSqlParserHASH_AJ = 602 + PlSqlParserHASH = 603 + PlSqlParserHASHKEYS = 604 + PlSqlParserHASH_SJ = 605 + PlSqlParserHAVING = 606 + PlSqlParserHEADER = 607 + PlSqlParserHEAP = 608 + PlSqlParserHELP = 609 + PlSqlParserHEXTORAW = 610 + PlSqlParserHEXTOREF = 611 + PlSqlParserHIDDEN_KEYWORD = 612 + PlSqlParserHIDE = 613 + PlSqlParserHIER_ORDER = 614 + PlSqlParserHIERARCHICAL = 615 + PlSqlParserHIERARCHIES = 616 + PlSqlParserHIERARCHY = 617 + PlSqlParserHIGH = 618 + PlSqlParserHINTSET_BEGIN = 619 + PlSqlParserHINTSET_END = 620 + PlSqlParserHOT = 621 + PlSqlParserHOUR = 622 + PlSqlParserHOURS = 623 + PlSqlParserHTTP = 624 + PlSqlParserHWM_BROKERED = 625 + PlSqlParserHYBRID = 626 + PlSqlParserH_LETTER = 627 + PlSqlParserIDENTIFIED = 628 + PlSqlParserIDENTIFIER = 629 + PlSqlParserIDENTITY = 630 + PlSqlParserIDGENERATORS = 631 + PlSqlParserID = 632 + PlSqlParserIDLE_TIME = 633 + PlSqlParserIF = 634 + PlSqlParserIGNORE = 635 + PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS = 636 + PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX = 637 + PlSqlParserIGNORE_WHERE_CLAUSE = 638 + PlSqlParserILM = 639 + PlSqlParserIMMEDIATE = 640 + PlSqlParserIMPACT = 641 + PlSqlParserIMPORT = 642 + PlSqlParserINACTIVE = 643 + PlSqlParserINACTIVE_ACCOUNT_TIME = 644 + PlSqlParserINCLUDE = 645 + PlSqlParserINCLUDE_VERSION = 646 + PlSqlParserINCLUDING = 647 + PlSqlParserINCREMENTAL = 648 + PlSqlParserINCREMENT = 649 + PlSqlParserINCR = 650 + PlSqlParserINDENT = 651 + PlSqlParserINDEX_ASC = 652 + PlSqlParserINDEX_COMBINE = 653 + PlSqlParserINDEX_DESC = 654 + PlSqlParserINDEXED = 655 + PlSqlParserINDEXES = 656 + PlSqlParserINDEX_FFS = 657 + PlSqlParserINDEX_FILTER = 658 + PlSqlParserINDEX = 659 + PlSqlParserINDEXING = 660 + PlSqlParserINDEX_JOIN = 661 + PlSqlParserINDEX_ROWS = 662 + PlSqlParserINDEX_RRS = 663 + PlSqlParserINDEX_RS_ASC = 664 + PlSqlParserINDEX_RS_DESC = 665 + PlSqlParserINDEX_RS = 666 + PlSqlParserINDEX_SCAN = 667 + PlSqlParserINDEX_SKIP_SCAN = 668 + PlSqlParserINDEX_SS_ASC = 669 + PlSqlParserINDEX_SS_DESC = 670 + PlSqlParserINDEX_SS = 671 + PlSqlParserINDEX_STATS = 672 + PlSqlParserINDEXTYPE = 673 + PlSqlParserINDEXTYPES = 674 + PlSqlParserINDICATOR = 675 + PlSqlParserINDICES = 676 + PlSqlParserINFINITE = 677 + PlSqlParserINFORMATIONAL = 678 + PlSqlParserINHERIT = 679 + PlSqlParserIN = 680 + PlSqlParserINITCAP = 681 + PlSqlParserINITIAL = 682 + PlSqlParserINITIALIZED = 683 + PlSqlParserINITIALLY = 684 + PlSqlParserINITRANS = 685 + PlSqlParserINLINE = 686 + PlSqlParserINLINE_XMLTYPE_NT = 687 + PlSqlParserINMEMORY = 688 + PlSqlParserIN_MEMORY_METADATA = 689 + PlSqlParserINMEMORY_PRUNING = 690 + PlSqlParserINNER = 691 + PlSqlParserINOUT = 692 + PlSqlParserINPLACE = 693 + PlSqlParserINSERTCHILDXMLAFTER = 694 + PlSqlParserINSERTCHILDXMLBEFORE = 695 + PlSqlParserINSERTCHILDXML = 696 + PlSqlParserINSERT = 697 + PlSqlParserINSERTXMLAFTER = 698 + PlSqlParserINSERTXMLBEFORE = 699 + PlSqlParserINSTANCE = 700 + PlSqlParserINSTANCES = 701 + PlSqlParserINSTANTIABLE = 702 + PlSqlParserINSTANTLY = 703 + PlSqlParserINSTEAD = 704 + PlSqlParserINSTR2 = 705 + PlSqlParserINSTR4 = 706 + PlSqlParserINSTRB = 707 + PlSqlParserINSTRC = 708 + PlSqlParserINSTR = 709 + PlSqlParserINTEGER = 710 + PlSqlParserINTERLEAVED = 711 + PlSqlParserINTERMEDIATE = 712 + PlSqlParserINTERNAL_CONVERT = 713 + PlSqlParserINTERNAL_USE = 714 + PlSqlParserINTERPRETED = 715 + PlSqlParserINTERSECT = 716 + PlSqlParserINTERVAL = 717 + PlSqlParserINT = 718 + PlSqlParserINTO = 719 + PlSqlParserINVALIDATE = 720 + PlSqlParserINVISIBLE = 721 + PlSqlParserIN_XQUERY = 722 + PlSqlParserIS = 723 + PlSqlParserIS_LEAF = 724 + PlSqlParserISOLATION = 725 + PlSqlParserISOLATION_LEVEL = 726 + PlSqlParserITERATE = 727 + PlSqlParserITERATION_NUMBER = 728 + PlSqlParserJAVA = 729 + PlSqlParserJOB = 730 + PlSqlParserJOIN = 731 + PlSqlParserJSON_ARRAYAGG = 732 + PlSqlParserJSON_ARRAY = 733 + PlSqlParserJSON_EQUAL = 734 + PlSqlParserJSON_EXISTS2 = 735 + PlSqlParserJSON_EXISTS = 736 + PlSqlParserJSONGET = 737 + PlSqlParserJSON = 738 + PlSqlParserJSON_OBJECTAGG = 739 + PlSqlParserJSON_OBJECT = 740 + PlSqlParserJSONPARSE = 741 + PlSqlParserJSON_QUERY = 742 + PlSqlParserJSON_SERIALIZE = 743 + PlSqlParserJSON_TABLE = 744 + PlSqlParserJSON_TEXTCONTAINS2 = 745 + PlSqlParserJSON_TEXTCONTAINS = 746 + PlSqlParserJSON_TRANSFORM = 747 + PlSqlParserJSON_VALUE = 748 + PlSqlParserK_LETTER = 749 + PlSqlParserKEEP_DUPLICATES = 750 + PlSqlParserKEEP = 751 + PlSqlParserKERBEROS = 752 + PlSqlParserKEY = 753 + PlSqlParserKEY_LENGTH = 754 + PlSqlParserKEYSIZE = 755 + PlSqlParserKEYS = 756 + PlSqlParserKEYSTORE = 757 + PlSqlParserKILL = 758 + PlSqlParserLABEL = 759 + PlSqlParserLANGUAGE = 760 + PlSqlParserLAST_DAY = 761 + PlSqlParserLAST = 762 + PlSqlParserLAST_VALUE = 763 + PlSqlParserLATERAL = 764 + PlSqlParserLAX = 765 + PlSqlParserLAYER = 766 + PlSqlParserLDAP_REGISTRATION_ENABLED = 767 + PlSqlParserLDAP_REGISTRATION = 768 + PlSqlParserLDAP_REG_SYNC_INTERVAL = 769 + PlSqlParserLEAF = 770 + PlSqlParserLEAD_CDB = 771 + PlSqlParserLEAD_CDB_URI = 772 + PlSqlParserLEADING = 773 + PlSqlParserLEFT = 774 + PlSqlParserLENGTH2 = 775 + PlSqlParserLENGTH4 = 776 + PlSqlParserLENGTHB = 777 + PlSqlParserLENGTHC = 778 + PlSqlParserLENGTH = 779 + PlSqlParserLESS = 780 + PlSqlParserLEVEL = 781 + PlSqlParserLEVEL_NAME = 782 + PlSqlParserLEVELS = 783 + PlSqlParserLIBRARY = 784 + PlSqlParserLIFECYCLE = 785 + PlSqlParserLIFE = 786 + PlSqlParserLIFETIME = 787 + PlSqlParserLIKE2 = 788 + PlSqlParserLIKE4 = 789 + PlSqlParserLIKEC = 790 + PlSqlParserLIKE_EXPAND = 791 + PlSqlParserLIKE = 792 + PlSqlParserLIMIT = 793 + PlSqlParserLINEAR = 794 + PlSqlParserLINK = 795 + PlSqlParserLIST = 796 + PlSqlParserLN = 797 + PlSqlParserLNNVL = 798 + PlSqlParserLOAD = 799 + PlSqlParserLOB = 800 + PlSqlParserLOBNVL = 801 + PlSqlParserLOBS = 802 + PlSqlParserLOCAL_INDEXES = 803 + PlSqlParserLOCAL = 804 + PlSqlParserLOCALTIME = 805 + PlSqlParserLOCALTIMESTAMP = 806 + PlSqlParserLOCATION = 807 + PlSqlParserLOCATOR = 808 + PlSqlParserLOCKDOWN = 809 + PlSqlParserLOCKED = 810 + PlSqlParserLOCKING = 811 + PlSqlParserLOCK = 812 + PlSqlParserLOGFILE = 813 + PlSqlParserLOGFILES = 814 + PlSqlParserLOGGING = 815 + PlSqlParserLOGICAL = 816 + PlSqlParserLOGICAL_READS_PER_CALL = 817 + PlSqlParserLOGICAL_READS_PER_SESSION = 818 + PlSqlParserLOG = 819 + PlSqlParserLOGMINING = 820 + PlSqlParserLOGOFF = 821 + PlSqlParserLOGON = 822 + PlSqlParserLOG_READ_ONLY_VIOLATIONS = 823 + PlSqlParserLONG = 824 + PlSqlParserLOOP = 825 + PlSqlParserLOST = 826 + PlSqlParserLOWER = 827 + PlSqlParserLOW = 828 + PlSqlParserLPAD = 829 + PlSqlParserLTRIM = 830 + PlSqlParserM_LETTER = 831 + PlSqlParserMAIN = 832 + PlSqlParserMAKE_REF = 833 + PlSqlParserMANAGED = 834 + PlSqlParserMANAGE = 835 + PlSqlParserMANAGEMENT = 836 + PlSqlParserMANAGER = 837 + PlSqlParserMANDATORY = 838 + PlSqlParserMANUAL = 839 + PlSqlParserMAP = 840 + PlSqlParserMAPPING = 841 + PlSqlParserMASTER = 842 + PlSqlParserMATCHED = 843 + PlSqlParserMATCHES = 844 + PlSqlParserMATCH = 845 + PlSqlParserMATCH_NUMBER = 846 + PlSqlParserMATCH_RECOGNIZE = 847 + PlSqlParserMATERIALIZED = 848 + PlSqlParserMATERIALIZE = 849 + PlSqlParserMAXARCHLOGS = 850 + PlSqlParserMAXDATAFILES = 851 + PlSqlParserMAXEXTENTS = 852 + PlSqlParserMAXIMIZE = 853 + PlSqlParserMAXINSTANCES = 854 + PlSqlParserMAXLOGFILES = 855 + PlSqlParserMAXLOGHISTORY = 856 + PlSqlParserMAXLOGMEMBERS = 857 + PlSqlParserMAX_SHARED_TEMP_SIZE = 858 + PlSqlParserMAXSIZE = 859 + PlSqlParserMAXTRANS = 860 + PlSqlParserMAXVALUE = 861 + PlSqlParserMEASURE = 862 + PlSqlParserMEASURES = 863 + PlSqlParserMEDIUM = 864 + PlSqlParserMEMBER = 865 + PlSqlParserMEMBER_CAPTION = 866 + PlSqlParserMEMBER_DESCRIPTION = 867 + PlSqlParserMEMBER_NAME = 868 + PlSqlParserMEMBER_UNIQUE_NAME = 869 + PlSqlParserMEMCOMPRESS = 870 + PlSqlParserMEMORY = 871 + PlSqlParserMERGEACTIONS = 872 + PlSqlParserMERGE_AJ = 873 + PlSqlParserMERGE_CONST_ON = 874 + PlSqlParserMERGE = 875 + PlSqlParserMERGE_SJ = 876 + PlSqlParserMETADATA = 877 + PlSqlParserMETHOD = 878 + PlSqlParserMIGRATE = 879 + PlSqlParserMIGRATION = 880 + PlSqlParserMINEXTENTS = 881 + PlSqlParserMINIMIZE = 882 + PlSqlParserMINIMUM = 883 + PlSqlParserMINING = 884 + PlSqlParserMINUS = 885 + PlSqlParserMINUS_NULL = 886 + PlSqlParserMINUTE = 887 + PlSqlParserMINUTES = 888 + PlSqlParserMINVALUE = 889 + PlSqlParserMIRRORCOLD = 890 + PlSqlParserMIRRORHOT = 891 + PlSqlParserMIRROR = 892 + PlSqlParserMISSING = 893 + PlSqlParserMISMATCH = 894 + PlSqlParserMLSLABEL = 895 + PlSqlParserMODEL_COMPILE_SUBQUERY = 896 + PlSqlParserMODEL_DONTVERIFY_UNIQUENESS = 897 + PlSqlParserMODEL_DYNAMIC_SUBQUERY = 898 + PlSqlParserMODEL_MIN_ANALYSIS = 899 + PlSqlParserMODEL = 900 + PlSqlParserMODEL_NB = 901 + PlSqlParserMODEL_NO_ANALYSIS = 902 + PlSqlParserMODEL_PBY = 903 + PlSqlParserMODEL_PUSH_REF = 904 + PlSqlParserMODEL_SV = 905 + PlSqlParserMODE = 906 + PlSqlParserMODIFICATION = 907 + PlSqlParserMODIFY_COLUMN_TYPE = 908 + PlSqlParserMODIFY = 909 + PlSqlParserMOD = 910 + PlSqlParserMODULE = 911 + PlSqlParserMONITORING = 912 + PlSqlParserMONITOR = 913 + PlSqlParserMONTH = 914 + PlSqlParserMONTHS_BETWEEN = 915 + PlSqlParserMONTHS = 916 + PlSqlParserMOUNT = 917 + PlSqlParserMOUNTPATH = 918 + PlSqlParserMOUNTPOINT = 919 + PlSqlParserMOVEMENT = 920 + PlSqlParserMOVE = 921 + PlSqlParserMULTIDIMENSIONAL = 922 + PlSqlParserMULTISET = 923 + PlSqlParserMV_MERGE = 924 + PlSqlParserNAMED = 925 + PlSqlParserNAME = 926 + PlSqlParserNAMESPACE = 927 + PlSqlParserNAN = 928 + PlSqlParserNANVL = 929 + PlSqlParserNATIONAL = 930 + PlSqlParserNATIVE_FULL_OUTER_JOIN = 931 + PlSqlParserNATIVE = 932 + PlSqlParserNATURAL = 933 + PlSqlParserNATURALN = 934 + PlSqlParserNAV = 935 + PlSqlParserNCHAR_CS = 936 + PlSqlParserNCHAR = 937 + PlSqlParserNCHR = 938 + PlSqlParserNCLOB = 939 + PlSqlParserNEEDED = 940 + PlSqlParserNEG = 941 + PlSqlParserNESTED = 942 + PlSqlParserNESTED_TABLE_FAST_INSERT = 943 + PlSqlParserNESTED_TABLE_GET_REFS = 944 + PlSqlParserNESTED_TABLE_ID = 945 + PlSqlParserNESTED_TABLE_SET_REFS = 946 + PlSqlParserNESTED_TABLE_SET_SETID = 947 + PlSqlParserNETWORK = 948 + PlSqlParserNEVER = 949 + PlSqlParserNEW = 950 + PlSqlParserNEW_TIME = 951 + PlSqlParserNEXT_DAY = 952 + PlSqlParserNEXT = 953 + PlSqlParserNL_AJ = 954 + PlSqlParserNLJ_BATCHING = 955 + PlSqlParserNLJ_INDEX_FILTER = 956 + PlSqlParserNLJ_INDEX_SCAN = 957 + PlSqlParserNLJ_PREFETCH = 958 + PlSqlParserNLS_CALENDAR = 959 + PlSqlParserNLS_CHARACTERSET = 960 + PlSqlParserNLS_CHARSET_DECL_LEN = 961 + PlSqlParserNLS_CHARSET_ID = 962 + PlSqlParserNLS_CHARSET_NAME = 963 + PlSqlParserNLS_COMP = 964 + PlSqlParserNLS_CURRENCY = 965 + PlSqlParserNLS_DATE_FORMAT = 966 + PlSqlParserNLS_DATE_LANGUAGE = 967 + PlSqlParserNLS_INITCAP = 968 + PlSqlParserNLS_ISO_CURRENCY = 969 + PlSqlParserNL_SJ = 970 + PlSqlParserNLS_LANG = 971 + PlSqlParserNLS_LANGUAGE = 972 + PlSqlParserNLS_LENGTH_SEMANTICS = 973 + PlSqlParserNLS_LOWER = 974 + PlSqlParserNLS_NCHAR_CONV_EXCP = 975 + PlSqlParserNLS_NUMERIC_CHARACTERS = 976 + PlSqlParserNLS_SORT = 977 + PlSqlParserNLSSORT = 978 + PlSqlParserNLS_SPECIAL_CHARS = 979 + PlSqlParserNLS_TERRITORY = 980 + PlSqlParserNLS_UPPER = 981 + PlSqlParserNO_ACCESS = 982 + PlSqlParserNO_ADAPTIVE_PLAN = 983 + PlSqlParserNO_ANSI_REARCH = 984 + PlSqlParserNOAPPEND = 985 + PlSqlParserNOARCHIVELOG = 986 + PlSqlParserNOAUDIT = 987 + PlSqlParserNO_AUTO_REOPTIMIZE = 988 + PlSqlParserNO_BASETABLE_MULTIMV_REWRITE = 989 + PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID = 990 + PlSqlParserNO_BIND_AWARE = 991 + PlSqlParserNO_BUFFER = 992 + PlSqlParserNOCACHE = 993 + PlSqlParserNO_CARTESIAN = 994 + PlSqlParserNO_CHECK_ACL_REWRITE = 995 + PlSqlParserNO_CLUSTER_BY_ROWID = 996 + PlSqlParserNO_CLUSTERING = 997 + PlSqlParserNO_COALESCE_SQ = 998 + PlSqlParserNO_COMMON_DATA = 999 + PlSqlParserNOCOMPRESS = 1000 + PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY = 1001 + PlSqlParserNO_CONNECT_BY_COMBINE_SW = 1002 + PlSqlParserNO_CONNECT_BY_COST_BASED = 1003 + PlSqlParserNO_CONNECT_BY_ELIM_DUPS = 1004 + PlSqlParserNO_CONNECT_BY_FILTERING = 1005 + PlSqlParserNOCOPY = 1006 + PlSqlParserNO_COST_XML_QUERY_REWRITE = 1007 + PlSqlParserNO_CPU_COSTING = 1008 + PlSqlParserNOCPU_COSTING = 1009 + PlSqlParserNOCYCLE = 1010 + PlSqlParserNO_DATA_SECURITY_REWRITE = 1011 + PlSqlParserNO_DECORRELATE = 1012 + PlSqlParserNODELAY = 1013 + PlSqlParserNO_DOMAIN_INDEX_FILTER = 1014 + PlSqlParserNO_DST_UPGRADE_INSERT_CONV = 1015 + PlSqlParserNO_ELIM_GROUPBY = 1016 + PlSqlParserNO_ELIMINATE_JOIN = 1017 + PlSqlParserNO_ELIMINATE_OBY = 1018 + PlSqlParserNO_ELIMINATE_OUTER_JOIN = 1019 + PlSqlParserNOENTITYESCAPING = 1020 + PlSqlParserNO_EXPAND_GSET_TO_UNION = 1021 + PlSqlParserNO_EXPAND = 1022 + PlSqlParserNO_EXPAND_TABLE = 1023 + PlSqlParserNO_FACT = 1024 + PlSqlParserNO_FACTORIZE_JOIN = 1025 + PlSqlParserNO_FILTERING = 1026 + PlSqlParserNOFORCE = 1027 + PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER = 1028 + PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS = 1029 + PlSqlParserNO_GBY_PUSHDOWN = 1030 + PlSqlParserNOGUARANTEE = 1031 + PlSqlParserNO_INDEX_FFS = 1032 + PlSqlParserNO_INDEX = 1033 + PlSqlParserNO_INDEX_SS = 1034 + PlSqlParserNO_INMEMORY = 1035 + PlSqlParserNO_INMEMORY_PRUNING = 1036 + PlSqlParserNOKEEP = 1037 + PlSqlParserNO_LOAD = 1038 + PlSqlParserNOLOCAL = 1039 + PlSqlParserNOLOGGING = 1040 + PlSqlParserNOMAPPING = 1041 + PlSqlParserNOMAXVALUE = 1042 + PlSqlParserNO_MERGE = 1043 + PlSqlParserNOMINIMIZE = 1044 + PlSqlParserNOMINVALUE = 1045 + PlSqlParserNO_MODEL_PUSH_REF = 1046 + PlSqlParserNO_MONITORING = 1047 + PlSqlParserNOMONITORING = 1048 + PlSqlParserNO_MONITOR = 1049 + PlSqlParserNO_MULTIMV_REWRITE = 1050 + PlSqlParserNO_NATIVE_FULL_OUTER_JOIN = 1051 + PlSqlParserNONBLOCKING = 1052 + PlSqlParserNONEDITIONABLE = 1053 + PlSqlParserNONE = 1054 + PlSqlParserNO_NLJ_BATCHING = 1055 + PlSqlParserNO_NLJ_PREFETCH = 1056 + PlSqlParserNO = 1057 + PlSqlParserNONSCHEMA = 1058 + PlSqlParserNO_OBJECT_LINK = 1059 + PlSqlParserNOORDER = 1060 + PlSqlParserNO_ORDER_ROLLUPS = 1061 + PlSqlParserNO_OUTER_JOIN_TO_ANTI = 1062 + PlSqlParserNO_OUTER_JOIN_TO_INNER = 1063 + PlSqlParserNOOVERRIDE = 1064 + PlSqlParserNO_PARALLEL_INDEX = 1065 + PlSqlParserNOPARALLEL_INDEX = 1066 + PlSqlParserNO_PARALLEL = 1067 + PlSqlParserNOPARALLEL = 1068 + PlSqlParserNO_PARTIAL_COMMIT = 1069 + PlSqlParserNO_PARTIAL_JOIN = 1070 + PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN = 1071 + PlSqlParserNOPARTITION = 1072 + PlSqlParserNO_PLACE_DISTINCT = 1073 + PlSqlParserNO_PLACE_GROUP_BY = 1074 + PlSqlParserNO_PQ_CONCURRENT_UNION = 1075 + PlSqlParserNO_PQ_MAP = 1076 + PlSqlParserNOPROMPT = 1077 + PlSqlParserNO_PQ_REPLICATE = 1078 + PlSqlParserNO_PQ_SKEW = 1079 + PlSqlParserNO_PRUNE_GSETS = 1080 + PlSqlParserNO_PULL_PRED = 1081 + PlSqlParserNO_PUSH_PRED = 1082 + PlSqlParserNO_PUSH_SUBQ = 1083 + PlSqlParserNO_PX_FAULT_TOLERANCE = 1084 + PlSqlParserNO_PX_JOIN_FILTER = 1085 + PlSqlParserNO_QKN_BUFF = 1086 + PlSqlParserNO_QUERY_TRANSFORMATION = 1087 + PlSqlParserNO_REF_CASCADE = 1088 + PlSqlParserNORELOCATE = 1089 + PlSqlParserNORELY = 1090 + PlSqlParserNOREPAIR = 1091 + PlSqlParserNOREPLAY = 1092 + PlSqlParserNORESETLOGS = 1093 + PlSqlParserNO_RESULT_CACHE = 1094 + PlSqlParserNOREVERSE = 1095 + PlSqlParserNO_REWRITE = 1096 + PlSqlParserNOREWRITE = 1097 + PlSqlParserNORMAL = 1098 + PlSqlParserNO_ROOT_SW_FOR_LOCAL = 1099 + PlSqlParserNOROWDEPENDENCIES = 1100 + PlSqlParserNOSCHEMACHECK = 1101 + PlSqlParserNOSEGMENT = 1102 + PlSqlParserNO_SEMIJOIN = 1103 + PlSqlParserNO_SEMI_TO_INNER = 1104 + PlSqlParserNO_SET_TO_JOIN = 1105 + PlSqlParserNOSORT = 1106 + PlSqlParserNO_SQL_TRANSLATION = 1107 + PlSqlParserNO_SQL_TUNE = 1108 + PlSqlParserNO_STAR_TRANSFORMATION = 1109 + PlSqlParserNO_STATEMENT_QUEUING = 1110 + PlSqlParserNO_STATS_GSETS = 1111 + PlSqlParserNOSTRICT = 1112 + PlSqlParserNO_SUBQUERY_PRUNING = 1113 + PlSqlParserNO_SUBSTRB_PAD = 1114 + PlSqlParserNO_SWAP_JOIN_INPUTS = 1115 + PlSqlParserNOSWITCH = 1116 + PlSqlParserNO_TABLE_LOOKUP_BY_NL = 1117 + PlSqlParserNO_TEMP_TABLE = 1118 + PlSqlParserNOTHING = 1119 + PlSqlParserNOTIFICATION = 1120 + PlSqlParserNOT = 1121 + PlSqlParserNO_TRANSFORM_DISTINCT_AGG = 1122 + PlSqlParserNO_UNNEST = 1123 + PlSqlParserNO_USE_CUBE = 1124 + PlSqlParserNO_USE_HASH_AGGREGATION = 1125 + PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN = 1126 + PlSqlParserNO_USE_HASH = 1127 + PlSqlParserNO_USE_INVISIBLE_INDEXES = 1128 + PlSqlParserNO_USE_MERGE = 1129 + PlSqlParserNO_USE_NL = 1130 + PlSqlParserNO_USE_VECTOR_AGGREGATION = 1131 + PlSqlParserNOVALIDATE = 1132 + PlSqlParserNO_VECTOR_TRANSFORM_DIMS = 1133 + PlSqlParserNO_VECTOR_TRANSFORM_FACT = 1134 + PlSqlParserNO_VECTOR_TRANSFORM = 1135 + PlSqlParserNOWAIT = 1136 + PlSqlParserNO_XDB_FASTPATH_INSERT = 1137 + PlSqlParserNO_XML_DML_REWRITE = 1138 + PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT = 1139 + PlSqlParserNO_XMLINDEX_REWRITE = 1140 + PlSqlParserNO_XML_QUERY_REWRITE = 1141 + PlSqlParserNO_ZONEMAP = 1142 + PlSqlParserNTH_VALUE = 1143 + PlSqlParserNULLIF = 1144 + PlSqlParserNULL_ = 1145 + PlSqlParserNULLS = 1146 + PlSqlParserNUMBER = 1147 + PlSqlParserNUMERIC = 1148 + PlSqlParserNUM_INDEX_KEYS = 1149 + PlSqlParserNUMTODSINTERVAL = 1150 + PlSqlParserNUMTOYMINTERVAL = 1151 + PlSqlParserNVARCHAR2 = 1152 + PlSqlParserNVL2 = 1153 + PlSqlParserOBJECT2XML = 1154 + PlSqlParserOBJECT = 1155 + PlSqlParserOBJ_ID = 1156 + PlSqlParserOBJNO = 1157 + PlSqlParserOBJNO_REUSE = 1158 + PlSqlParserOCCURENCES = 1159 + PlSqlParserOFFLINE = 1160 + PlSqlParserOFF = 1161 + PlSqlParserOFFSET = 1162 + PlSqlParserOF = 1163 + PlSqlParserOIDINDEX = 1164 + PlSqlParserOID = 1165 + PlSqlParserOLAP = 1166 + PlSqlParserOLD = 1167 + PlSqlParserOLD_PUSH_PRED = 1168 + PlSqlParserOLS = 1169 + PlSqlParserOLTP = 1170 + PlSqlParserOMIT = 1171 + PlSqlParserONE = 1172 + PlSqlParserONLINE = 1173 + PlSqlParserONLY = 1174 + PlSqlParserON = 1175 + PlSqlParserOPAQUE = 1176 + PlSqlParserOPAQUE_TRANSFORM = 1177 + PlSqlParserOPAQUE_XCANONICAL = 1178 + PlSqlParserOPCODE = 1179 + PlSqlParserOPEN = 1180 + PlSqlParserOPERATIONS = 1181 + PlSqlParserOPERATOR = 1182 + PlSqlParserOPT_ESTIMATE = 1183 + PlSqlParserOPTIMAL = 1184 + PlSqlParserOPTIMIZE = 1185 + PlSqlParserOPTIMIZER_FEATURES_ENABLE = 1186 + PlSqlParserOPTIMIZER_GOAL = 1187 + PlSqlParserOPTION = 1188 + PlSqlParserOPT_PARAM = 1189 + PlSqlParserORA_BRANCH = 1190 + PlSqlParserORA_CHECK_ACL = 1191 + PlSqlParserORA_CHECK_PRIVILEGE = 1192 + PlSqlParserORA_CLUSTERING = 1193 + PlSqlParserORADATA = 1194 + PlSqlParserORADEBUG = 1195 + PlSqlParserORA_DST_AFFECTED = 1196 + PlSqlParserORA_DST_CONVERT = 1197 + PlSqlParserORA_DST_ERROR = 1198 + PlSqlParserORA_GET_ACLIDS = 1199 + PlSqlParserORA_GET_PRIVILEGES = 1200 + PlSqlParserORA_HASH = 1201 + PlSqlParserORA_INVOKING_USERID = 1202 + PlSqlParserORA_INVOKING_USER = 1203 + PlSqlParserORA_INVOKING_XS_USER_GUID = 1204 + PlSqlParserORA_INVOKING_XS_USER = 1205 + PlSqlParserORA_RAWCOMPARE = 1206 + PlSqlParserORA_RAWCONCAT = 1207 + PlSqlParserORA_ROWSCN = 1208 + PlSqlParserORA_ROWSCN_RAW = 1209 + PlSqlParserORA_ROWVERSION = 1210 + PlSqlParserORA_TABVERSION = 1211 + PlSqlParserORA_WRITE_TIME = 1212 + PlSqlParserORDERED = 1213 + PlSqlParserORDERED_PREDICATES = 1214 + PlSqlParserORDER = 1215 + PlSqlParserORDINALITY = 1216 + PlSqlParserOR_EXPAND = 1217 + PlSqlParserORGANIZATION = 1218 + PlSqlParserOR = 1219 + PlSqlParserOR_PREDICATES = 1220 + PlSqlParserOSERROR = 1221 + PlSqlParserOTHER = 1222 + PlSqlParserOUTER_JOIN_TO_ANTI = 1223 + PlSqlParserOUTER_JOIN_TO_INNER = 1224 + PlSqlParserOUTER = 1225 + PlSqlParserOUTLINE_LEAF = 1226 + PlSqlParserOUTLINE = 1227 + PlSqlParserOUT_OF_LINE = 1228 + PlSqlParserOUT = 1229 + PlSqlParserOVERFLOW_NOMOVE = 1230 + PlSqlParserOVERFLOW = 1231 + PlSqlParserOVERLAPS = 1232 + PlSqlParserOVER = 1233 + PlSqlParserOVERRIDING = 1234 + PlSqlParserOWNER = 1235 + PlSqlParserOWNERSHIP = 1236 + PlSqlParserOWN = 1237 + PlSqlParserP_LETTER = 1238 + PlSqlParserPACKAGE = 1239 + PlSqlParserPACKAGES = 1240 + PlSqlParserPARALLEL_ENABLE = 1241 + PlSqlParserPARALLEL_INDEX = 1242 + PlSqlParserPARALLEL = 1243 + PlSqlParserPARAMETERS = 1244 + PlSqlParserPARAM = 1245 + PlSqlParserPARENT = 1246 + PlSqlParserPARENT_LEVEL_NAME = 1247 + PlSqlParserPARENT_UNIQUE_NAME = 1248 + PlSqlParserPARITY = 1249 + PlSqlParserPARTIAL_JOIN = 1250 + PlSqlParserPARTIALLY = 1251 + PlSqlParserPARTIAL = 1252 + PlSqlParserPARTIAL_ROLLUP_PUSHDOWN = 1253 + PlSqlParserPARTITION_HASH = 1254 + PlSqlParserPARTITION_LIST = 1255 + PlSqlParserPARTITION = 1256 + PlSqlParserPARTITION_RANGE = 1257 + PlSqlParserPARTITIONS = 1258 + PlSqlParserPARTNUMINST = 1259 + PlSqlParserPASSING = 1260 + PlSqlParserPASSWORD_GRACE_TIME = 1261 + PlSqlParserPASSWORD_LIFE_TIME = 1262 + PlSqlParserPASSWORD_LOCK_TIME = 1263 + PlSqlParserPASSWORD = 1264 + PlSqlParserPASSWORD_REUSE_MAX = 1265 + PlSqlParserPASSWORD_REUSE_TIME = 1266 + PlSqlParserPASSWORD_ROLLOVER_TIME = 1267 + PlSqlParserPASSWORD_VERIFY_FUNCTION = 1268 + PlSqlParserPAST = 1269 + PlSqlParserPATCH = 1270 + PlSqlParserPATH = 1271 + PlSqlParserPATH_PREFIX = 1272 + PlSqlParserPATHS = 1273 + PlSqlParserPATTERN = 1274 + PlSqlParserPBL_HS_BEGIN = 1275 + PlSqlParserPBL_HS_END = 1276 + PlSqlParserPCTFREE = 1277 + PlSqlParserPCTINCREASE = 1278 + PlSqlParserPCTTHRESHOLD = 1279 + PlSqlParserPCTUSED = 1280 + PlSqlParserPCTVERSION = 1281 + PlSqlParserPENDING = 1282 + PlSqlParserPERCENT_FOUND = 1283 + PlSqlParserPERCENT_ISOPEN = 1284 + PlSqlParserPERCENT_NOTFOUND = 1285 + PlSqlParserPERCENT_KEYWORD = 1286 + PlSqlParserPERCENT_RANKM = 1287 + PlSqlParserPERCENT_ROWCOUNT = 1288 + PlSqlParserPERCENT_ROWTYPE = 1289 + PlSqlParserPERCENT_TYPE = 1290 + PlSqlParserPERFORMANCE = 1291 + PlSqlParserPERIOD_KEYWORD = 1292 + PlSqlParserPERMANENT = 1293 + PlSqlParserPERMISSION = 1294 + PlSqlParserPERMUTE = 1295 + PlSqlParserPER = 1296 + PlSqlParserPFILE = 1297 + PlSqlParserPHYSICAL = 1298 + PlSqlParserPIKEY = 1299 + PlSqlParserPIPELINED = 1300 + PlSqlParserPIPE = 1301 + PlSqlParserPIV_GB = 1302 + PlSqlParserPIVOT = 1303 + PlSqlParserPIV_SSF = 1304 + PlSqlParserPLACE_DISTINCT = 1305 + PlSqlParserPLACE_GROUP_BY = 1306 + PlSqlParserPLAN = 1307 + PlSqlParserPLSCOPE_SETTINGS = 1308 + PlSqlParserPLS_INTEGER = 1309 + PlSqlParserPLSQL_CCFLAGS = 1310 + PlSqlParserPLSQL_CODE_TYPE = 1311 + PlSqlParserPLSQL_DEBUG = 1312 + PlSqlParserPLSQL_OPTIMIZE_LEVEL = 1313 + PlSqlParserPLSQL_WARNINGS = 1314 + PlSqlParserPLUGGABLE = 1315 + PlSqlParserPMEM = 1316 + PlSqlParserPOINT = 1317 + PlSqlParserPOLICY = 1318 + PlSqlParserPOOL_16K = 1319 + PlSqlParserPOOL_2K = 1320 + PlSqlParserPOOL_32K = 1321 + PlSqlParserPOOL_4K = 1322 + PlSqlParserPOOL_8K = 1323 + PlSqlParserPOSITIVEN = 1324 + PlSqlParserPOSITIVE = 1325 + PlSqlParserPOST_TRANSACTION = 1326 + PlSqlParserPOWERMULTISET_BY_CARDINALITY = 1327 + PlSqlParserPOWERMULTISET = 1328 + PlSqlParserPOWER = 1329 + PlSqlParserPQ_CONCURRENT_UNION = 1330 + PlSqlParserPQ_DISTRIBUTE = 1331 + PlSqlParserPQ_DISTRIBUTE_WINDOW = 1332 + PlSqlParserPQ_FILTER = 1333 + PlSqlParserPQ_MAP = 1334 + PlSqlParserPQ_NOMAP = 1335 + PlSqlParserPQ_REPLICATE = 1336 + PlSqlParserPQ_SKEW = 1337 + PlSqlParserPRAGMA = 1338 + PlSqlParserPREBUILT = 1339 + PlSqlParserPRECEDES = 1340 + PlSqlParserPRECEDING = 1341 + PlSqlParserPRECISION = 1342 + PlSqlParserPRECOMPUTE_SUBQUERY = 1343 + PlSqlParserPREDICATE_REORDERS = 1344 + PlSqlParserPRELOAD = 1345 + PlSqlParserPREPARE = 1346 + PlSqlParserPRESENTNNV = 1347 + PlSqlParserPRESENT = 1348 + PlSqlParserPRESENTV = 1349 + PlSqlParserPRESERVE_OID = 1350 + PlSqlParserPRESERVE = 1351 + PlSqlParserPRETTY = 1352 + PlSqlParserPREVIOUS = 1353 + PlSqlParserPREV = 1354 + PlSqlParserPRIMARY = 1355 + PlSqlParserPRINTBLOBTOCLOB = 1356 + PlSqlParserPRIORITY = 1357 + PlSqlParserPRIOR = 1358 + PlSqlParserPRIVATE = 1359 + PlSqlParserPRIVATE_SGA = 1360 + PlSqlParserPRIVILEGED = 1361 + PlSqlParserPRIVILEGE = 1362 + PlSqlParserPRIVILEGES = 1363 + PlSqlParserPROCEDURAL = 1364 + PlSqlParserPROCEDURE = 1365 + PlSqlParserPROCESS = 1366 + PlSqlParserPROFILE = 1367 + PlSqlParserPROGRAM = 1368 + PlSqlParserPROJECT = 1369 + PlSqlParserPROPAGATE = 1370 + PlSqlParserPROPERTY = 1371 + PlSqlParserPROTECTED = 1372 + PlSqlParserPROTECTION = 1373 + PlSqlParserPROTOCOL = 1374 + PlSqlParserPROXY = 1375 + PlSqlParserPRUNING = 1376 + PlSqlParserPUBLIC = 1377 + PlSqlParserPULL_PRED = 1378 + PlSqlParserPURGE = 1379 + PlSqlParserPUSH_PRED = 1380 + PlSqlParserPUSH_SUBQ = 1381 + PlSqlParserPX_FAULT_TOLERANCE = 1382 + PlSqlParserPX_GRANULE = 1383 + PlSqlParserPX_JOIN_FILTER = 1384 + PlSqlParserQB_NAME = 1385 + PlSqlParserQUARTERS = 1386 + PlSqlParserQUERY_BLOCK = 1387 + PlSqlParserQUERY = 1388 + PlSqlParserQUEUE_CURR = 1389 + PlSqlParserQUEUE = 1390 + PlSqlParserQUEUE_ROWP = 1391 + PlSqlParserQUIESCE = 1392 + PlSqlParserQUORUM = 1393 + PlSqlParserQUOTA = 1394 + PlSqlParserQUOTAGROUP = 1395 + PlSqlParserRAISE = 1396 + PlSqlParserRANDOM_LOCAL = 1397 + PlSqlParserRANDOM = 1398 + PlSqlParserRANGE = 1399 + PlSqlParserRANKM = 1400 + PlSqlParserRAPIDLY = 1401 + PlSqlParserRAW = 1402 + PlSqlParserRAWTOHEX = 1403 + PlSqlParserRAWTONHEX = 1404 + PlSqlParserRBA = 1405 + PlSqlParserRBO_OUTLINE = 1406 + PlSqlParserRDBA = 1407 + PlSqlParserREAD = 1408 + PlSqlParserREADS = 1409 + PlSqlParserREALM = 1410 + PlSqlParserREAL = 1411 + PlSqlParserREBALANCE = 1412 + PlSqlParserREBUILD = 1413 + PlSqlParserRECORD = 1414 + PlSqlParserRECORDS_PER_BLOCK = 1415 + PlSqlParserRECOVERABLE = 1416 + PlSqlParserRECOVER = 1417 + PlSqlParserRECOVERY = 1418 + PlSqlParserRECYCLEBIN = 1419 + PlSqlParserRECYCLE = 1420 + PlSqlParserREDACTION = 1421 + PlSqlParserREDEFINE = 1422 + PlSqlParserREDO = 1423 + PlSqlParserREDUCED = 1424 + PlSqlParserREDUNDANCY = 1425 + PlSqlParserREF_CASCADE_CURSOR = 1426 + PlSqlParserREFERENCED = 1427 + PlSqlParserREFERENCE = 1428 + PlSqlParserREFERENCES = 1429 + PlSqlParserREFERENCING = 1430 + PlSqlParserREF = 1431 + PlSqlParserREFRESH = 1432 + PlSqlParserREFTOHEX = 1433 + PlSqlParserREGEXP_COUNT = 1434 + PlSqlParserREGEXP_INSTR = 1435 + PlSqlParserREGEXP_LIKE = 1436 + PlSqlParserREGEXP_REPLACE = 1437 + PlSqlParserREGEXP_SUBSTR = 1438 + PlSqlParserREGISTER = 1439 + PlSqlParserREGR_AVGX = 1440 + PlSqlParserREGR_AVGY = 1441 + PlSqlParserREGR_COUNT = 1442 + PlSqlParserREGR_INTERCEPT = 1443 + PlSqlParserREGR_R2 = 1444 + PlSqlParserREGR_SLOPE = 1445 + PlSqlParserREGR_SXX = 1446 + PlSqlParserREGR_SXY = 1447 + PlSqlParserREGR_SYY = 1448 + PlSqlParserREGULAR = 1449 + PlSqlParserREJECT = 1450 + PlSqlParserREKEY = 1451 + PlSqlParserRELATIONAL = 1452 + PlSqlParserRELIES_ON = 1453 + PlSqlParserRELOCATE = 1454 + PlSqlParserRELY = 1455 + PlSqlParserREMAINDER = 1456 + PlSqlParserREMOTE = 1457 + PlSqlParserREMOTE_MAPPED = 1458 + PlSqlParserREMOVE = 1459 + PlSqlParserRENAME = 1460 + PlSqlParserREPAIR = 1461 + PlSqlParserREPEAT = 1462 + PlSqlParserREPLACE = 1463 + PlSqlParserREPLICATION = 1464 + PlSqlParserREQUIRED = 1465 + PlSqlParserRESETLOGS = 1466 + PlSqlParserRESET = 1467 + PlSqlParserRESIZE = 1468 + PlSqlParserRESOLVE = 1469 + PlSqlParserRESOLVER = 1470 + PlSqlParserRESOURCE = 1471 + PlSqlParserRESPECT = 1472 + PlSqlParserRESTART = 1473 + PlSqlParserRESTORE_AS_INTERVALS = 1474 + PlSqlParserRESTORE = 1475 + PlSqlParserRESTRICT_ALL_REF_CONS = 1476 + PlSqlParserRESTRICTED = 1477 + PlSqlParserRESTRICT_REFERENCES = 1478 + PlSqlParserRESTRICT = 1479 + PlSqlParserRESULT_CACHE = 1480 + PlSqlParserRESULT = 1481 + PlSqlParserRESUMABLE = 1482 + PlSqlParserRESUME = 1483 + PlSqlParserRETENTION = 1484 + PlSqlParserRETRY_ON_ROW_CHANGE = 1485 + PlSqlParserRETURNING = 1486 + PlSqlParserRETURN = 1487 + PlSqlParserREUSE = 1488 + PlSqlParserREVERSE = 1489 + PlSqlParserREVOKE = 1490 + PlSqlParserREWRITE_OR_ERROR = 1491 + PlSqlParserREWRITE = 1492 + PlSqlParserRIGHT = 1493 + PlSqlParserROLE = 1494 + PlSqlParserROLESET = 1495 + PlSqlParserROLES = 1496 + PlSqlParserROLLBACK = 1497 + PlSqlParserROLLING = 1498 + PlSqlParserROLLUP = 1499 + PlSqlParserROWDEPENDENCIES = 1500 + PlSqlParserROWID_MAPPING_TABLE = 1501 + PlSqlParserROWID = 1502 + PlSqlParserROWIDTOCHAR = 1503 + PlSqlParserROWIDTONCHAR = 1504 + PlSqlParserROW_LENGTH = 1505 + PlSqlParserROWNUM = 1506 + PlSqlParserROW = 1507 + PlSqlParserROWS = 1508 + PlSqlParserRPAD = 1509 + PlSqlParserRTRIM = 1510 + PlSqlParserRULE = 1511 + PlSqlParserRULES = 1512 + PlSqlParserRUNNING = 1513 + PlSqlParserSALT = 1514 + PlSqlParserSAMPLE = 1515 + PlSqlParserSAVE_AS_INTERVALS = 1516 + PlSqlParserSAVEPOINT = 1517 + PlSqlParserSAVE = 1518 + PlSqlParserSB4 = 1519 + PlSqlParserSCALE_ROWS = 1520 + PlSqlParserSCALE = 1521 + PlSqlParserSCAN_INSTANCES = 1522 + PlSqlParserSCAN = 1523 + PlSqlParserSCHEDULER = 1524 + PlSqlParserSCHEMACHECK = 1525 + PlSqlParserSCHEMA = 1526 + PlSqlParserSCN_ASCENDING = 1527 + PlSqlParserSCN = 1528 + PlSqlParserSCOPE = 1529 + PlSqlParserSCRUB = 1530 + PlSqlParserSD_ALL = 1531 + PlSqlParserSD_INHIBIT = 1532 + PlSqlParserSDO_GEOM_MBR = 1533 + PlSqlParserSDO_GEOMETRY = 1534 + PlSqlParserSD_SHOW = 1535 + PlSqlParserSEARCH = 1536 + PlSqlParserSECOND = 1537 + PlSqlParserSECONDS = 1538 + PlSqlParserSECRET = 1539 + PlSqlParserSECUREFILE_DBA = 1540 + PlSqlParserSECUREFILE = 1541 + PlSqlParserSECURITY = 1542 + PlSqlParserSEED = 1543 + PlSqlParserSEG_BLOCK = 1544 + PlSqlParserSEG_FILE = 1545 + PlSqlParserSEGMENT = 1546 + PlSqlParserSELECTIVITY = 1547 + PlSqlParserSELECT = 1548 + PlSqlParserSELF = 1549 + PlSqlParserSEMIJOIN_DRIVER = 1550 + PlSqlParserSEMIJOIN = 1551 + PlSqlParserSEMI_TO_INNER = 1552 + PlSqlParserSEQUENCED = 1553 + PlSqlParserSEQUENCE = 1554 + PlSqlParserSEQUENTIAL = 1555 + PlSqlParserSERIALIZABLE = 1556 + PlSqlParserSERIALLY_REUSABLE = 1557 + PlSqlParserSERIAL = 1558 + PlSqlParserSERVERERROR = 1559 + PlSqlParserSERVICE_NAME_CONVERT = 1560 + PlSqlParserSERVICE = 1561 + PlSqlParserSERVICES = 1562 + PlSqlParserSESSION_CACHED_CURSORS = 1563 + PlSqlParserSESSION = 1564 + PlSqlParserSESSIONS_PER_USER = 1565 + PlSqlParserSESSIONTIMEZONE = 1566 + PlSqlParserSESSIONTZNAME = 1567 + PlSqlParserSET = 1568 + PlSqlParserSETS = 1569 + PlSqlParserSETTINGS = 1570 + PlSqlParserSET_TO_JOIN = 1571 + PlSqlParserSEVERE = 1572 + PlSqlParserSHARDSPACE = 1573 + PlSqlParserSHARED_POOL = 1574 + PlSqlParserSHARED = 1575 + PlSqlParserSHARE = 1576 + PlSqlParserSHARING = 1577 + PlSqlParserSHELFLIFE = 1578 + PlSqlParserSHOW = 1579 + PlSqlParserSHRINK = 1580 + PlSqlParserSHUTDOWN = 1581 + PlSqlParserSIBLINGS = 1582 + PlSqlParserSID = 1583 + PlSqlParserSITE = 1584 + PlSqlParserSIGNAL_COMPONENT = 1585 + PlSqlParserSIGNAL_FUNCTION = 1586 + PlSqlParserSIGN = 1587 + PlSqlParserSIGNTYPE = 1588 + PlSqlParserSIMPLE_INTEGER = 1589 + PlSqlParserSIMPLE = 1590 + PlSqlParserSINGLE = 1591 + PlSqlParserSINGLETASK = 1592 + PlSqlParserSINH = 1593 + PlSqlParserSIN = 1594 + PlSqlParserSIZE = 1595 + PlSqlParserSKIP_EXT_OPTIMIZER = 1596 + PlSqlParserSKIP_ = 1597 + PlSqlParserSKIP_UNQ_UNUSABLE_IDX = 1598 + PlSqlParserSKIP_UNUSABLE_INDEXES = 1599 + PlSqlParserSMALLFILE = 1600 + PlSqlParserSMALLINT = 1601 + PlSqlParserSNAPSHOT = 1602 + PlSqlParserSOME = 1603 + PlSqlParserSORT = 1604 + PlSqlParserSOUNDEX = 1605 + PlSqlParserSOURCE_FILE_DIRECTORY = 1606 + PlSqlParserSOURCE_FILE_NAME_CONVERT = 1607 + PlSqlParserSOURCE = 1608 + PlSqlParserSPACE_KEYWORD = 1609 + PlSqlParserSPECIFICATION = 1610 + PlSqlParserSPFILE = 1611 + PlSqlParserSPLIT = 1612 + PlSqlParserSPREADSHEET = 1613 + PlSqlParserSQLDATA = 1614 + PlSqlParserSQLERROR = 1615 + PlSqlParserSQLLDR = 1616 + PlSqlParserSQL = 1617 + PlSqlParserSQL_MACRO = 1618 + PlSqlParserSQL_TRACE = 1619 + PlSqlParserSQL_TRANSLATION_PROFILE = 1620 + PlSqlParserSQRT = 1621 + PlSqlParserSTALE = 1622 + PlSqlParserSTANDALONE = 1623 + PlSqlParserSTANDARD = 1624 + PlSqlParserSTANDARD_HASH = 1625 + PlSqlParserSTANDBY_MAX_DATA_DELAY = 1626 + PlSqlParserSTANDBYS = 1627 + PlSqlParserSTANDBY = 1628 + PlSqlParserSTAR = 1629 + PlSqlParserSTAR_TRANSFORMATION = 1630 + PlSqlParserSTART = 1631 + PlSqlParserSTARTUP = 1632 + PlSqlParserSTATEMENT_ID = 1633 + PlSqlParserSTATEMENT_QUEUING = 1634 + PlSqlParserSTATEMENTS = 1635 + PlSqlParserSTATEMENT = 1636 + PlSqlParserSTATE = 1637 + PlSqlParserSTATIC = 1638 + PlSqlParserSTATISTICS = 1639 + PlSqlParserSTATS_BINOMIAL_TEST = 1640 + PlSqlParserSTATS_CROSSTAB = 1641 + PlSqlParserSTATS_F_TEST = 1642 + PlSqlParserSTATS_KS_TEST = 1643 + PlSqlParserSTATS_MODE = 1644 + PlSqlParserSTATS_MW_TEST = 1645 + PlSqlParserSTATS_ONE_WAY_ANOVA = 1646 + PlSqlParserSTATS_T_TEST_INDEP = 1647 + PlSqlParserSTATS_T_TEST_INDEPU = 1648 + PlSqlParserSTATS_T_TEST_ONE = 1649 + PlSqlParserSTATS_T_TEST_PAIRED = 1650 + PlSqlParserSTATS_WSR_TEST = 1651 + PlSqlParserSTDDEV_POP = 1652 + PlSqlParserSTDDEV_SAMP = 1653 + PlSqlParserSTOP = 1654 + PlSqlParserSTORAGE = 1655 + PlSqlParserSTORE = 1656 + PlSqlParserSTREAMS = 1657 + PlSqlParserSTREAM = 1658 + PlSqlParserSTRICT = 1659 + PlSqlParserSTRING = 1660 + PlSqlParserSTRIPE_COLUMNS = 1661 + PlSqlParserSTRIPE_WIDTH = 1662 + PlSqlParserSTRIP = 1663 + PlSqlParserSTRUCTURE = 1664 + PlSqlParserSUBMULTISET = 1665 + PlSqlParserSUBPARTITION_REL = 1666 + PlSqlParserSUBPARTITIONS = 1667 + PlSqlParserSUBPARTITION = 1668 + PlSqlParserSUBQUERIES = 1669 + PlSqlParserSUBQUERY_PRUNING = 1670 + PlSqlParserSUBSCRIBE = 1671 + PlSqlParserSUBSET = 1672 + PlSqlParserSUBSTITUTABLE = 1673 + PlSqlParserSUBSTR2 = 1674 + PlSqlParserSUBSTR4 = 1675 + PlSqlParserSUBSTRB = 1676 + PlSqlParserSUBSTRC = 1677 + PlSqlParserSUBTYPE = 1678 + PlSqlParserSUCCESSFUL = 1679 + PlSqlParserSUCCESS = 1680 + PlSqlParserSUMMARY = 1681 + PlSqlParserSUPPLEMENTAL = 1682 + PlSqlParserSUSPEND = 1683 + PlSqlParserSWAP_JOIN_INPUTS = 1684 + PlSqlParserSWITCHOVER = 1685 + PlSqlParserSWITCH = 1686 + PlSqlParserSYNCHRONOUS = 1687 + PlSqlParserSYNC = 1688 + PlSqlParserSYNONYM = 1689 + PlSqlParserSYS = 1690 + PlSqlParserSYSASM = 1691 + PlSqlParserSYS_AUDIT = 1692 + PlSqlParserSYSAUX = 1693 + PlSqlParserSYSBACKUP = 1694 + PlSqlParserSYS_CHECKACL = 1695 + PlSqlParserSYS_CHECK_PRIVILEGE = 1696 + PlSqlParserSYS_CONNECT_BY_PATH = 1697 + PlSqlParserSYS_CONTEXT = 1698 + PlSqlParserSYSDATE = 1699 + PlSqlParserSYSDBA = 1700 + PlSqlParserSYS_DBURIGEN = 1701 + PlSqlParserSYSDG = 1702 + PlSqlParserSYS_DL_CURSOR = 1703 + PlSqlParserSYS_DM_RXFORM_CHR = 1704 + PlSqlParserSYS_DM_RXFORM_NUM = 1705 + PlSqlParserSYS_DOM_COMPARE = 1706 + PlSqlParserSYS_DST_PRIM2SEC = 1707 + PlSqlParserSYS_DST_SEC2PRIM = 1708 + PlSqlParserSYS_ET_BFILE_TO_RAW = 1709 + PlSqlParserSYS_ET_BLOB_TO_IMAGE = 1710 + PlSqlParserSYS_ET_IMAGE_TO_BLOB = 1711 + PlSqlParserSYS_ET_RAW_TO_BFILE = 1712 + PlSqlParserSYS_EXTPDTXT = 1713 + PlSqlParserSYS_EXTRACT_UTC = 1714 + PlSqlParserSYS_FBT_INSDEL = 1715 + PlSqlParserSYS_FILTER_ACLS = 1716 + PlSqlParserSYS_FNMATCHES = 1717 + PlSqlParserSYS_FNREPLACE = 1718 + PlSqlParserSYS_GET_ACLIDS = 1719 + PlSqlParserSYS_GET_COL_ACLIDS = 1720 + PlSqlParserSYS_GET_PRIVILEGES = 1721 + PlSqlParserSYS_GETTOKENID = 1722 + PlSqlParserSYS_GETXTIVAL = 1723 + PlSqlParserSYS_GUID = 1724 + PlSqlParserSYSGUID = 1725 + PlSqlParserSYSKM = 1726 + PlSqlParserSYS_MAKE_XMLNODEID = 1727 + PlSqlParserSYS_MAKEXML = 1728 + PlSqlParserSYS_MKXMLATTR = 1729 + PlSqlParserSYS_MKXTI = 1730 + PlSqlParserSYSOBJ = 1731 + PlSqlParserSYS_OP_ADT2BIN = 1732 + PlSqlParserSYS_OP_ADTCONS = 1733 + PlSqlParserSYS_OP_ALSCRVAL = 1734 + PlSqlParserSYS_OP_ATG = 1735 + PlSqlParserSYS_OP_BIN2ADT = 1736 + PlSqlParserSYS_OP_BITVEC = 1737 + PlSqlParserSYS_OP_BL2R = 1738 + PlSqlParserSYS_OP_BLOOM_FILTER_LIST = 1739 + PlSqlParserSYS_OP_BLOOM_FILTER = 1740 + PlSqlParserSYS_OP_C2C = 1741 + PlSqlParserSYS_OP_CAST = 1742 + PlSqlParserSYS_OP_CEG = 1743 + PlSqlParserSYS_OP_CL2C = 1744 + PlSqlParserSYS_OP_COMBINED_HASH = 1745 + PlSqlParserSYS_OP_COMP = 1746 + PlSqlParserSYS_OP_CONVERT = 1747 + PlSqlParserSYS_OP_COUNTCHG = 1748 + PlSqlParserSYS_OP_CSCONV = 1749 + PlSqlParserSYS_OP_CSCONVTEST = 1750 + PlSqlParserSYS_OP_CSR = 1751 + PlSqlParserSYS_OP_CSX_PATCH = 1752 + PlSqlParserSYS_OP_CYCLED_SEQ = 1753 + PlSqlParserSYS_OP_DECOMP = 1754 + PlSqlParserSYS_OP_DESCEND = 1755 + PlSqlParserSYS_OP_DISTINCT = 1756 + PlSqlParserSYS_OP_DRA = 1757 + PlSqlParserSYS_OP_DUMP = 1758 + PlSqlParserSYS_OP_DV_CHECK = 1759 + PlSqlParserSYS_OP_ENFORCE_NOT_NULL = 1760 + PlSqlParserSYSOPER = 1761 + PlSqlParserSYS_OP_EXTRACT = 1762 + PlSqlParserSYS_OP_GROUPING = 1763 + PlSqlParserSYS_OP_GUID = 1764 + PlSqlParserSYS_OP_HASH = 1765 + PlSqlParserSYS_OP_IIX = 1766 + PlSqlParserSYS_OP_ITR = 1767 + PlSqlParserSYS_OP_KEY_VECTOR_CREATE = 1768 + PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST = 1769 + PlSqlParserSYS_OP_KEY_VECTOR_FILTER = 1770 + PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED = 1771 + PlSqlParserSYS_OP_KEY_VECTOR_USE = 1772 + PlSqlParserSYS_OP_LBID = 1773 + PlSqlParserSYS_OP_LOBLOC2BLOB = 1774 + PlSqlParserSYS_OP_LOBLOC2CLOB = 1775 + PlSqlParserSYS_OP_LOBLOC2ID = 1776 + PlSqlParserSYS_OP_LOBLOC2NCLOB = 1777 + PlSqlParserSYS_OP_LOBLOC2TYP = 1778 + PlSqlParserSYS_OP_LSVI = 1779 + PlSqlParserSYS_OP_LVL = 1780 + PlSqlParserSYS_OP_MAKEOID = 1781 + PlSqlParserSYS_OP_MAP_NONNULL = 1782 + PlSqlParserSYS_OP_MSR = 1783 + PlSqlParserSYS_OP_NICOMBINE = 1784 + PlSqlParserSYS_OP_NIEXTRACT = 1785 + PlSqlParserSYS_OP_NII = 1786 + PlSqlParserSYS_OP_NIX = 1787 + PlSqlParserSYS_OP_NOEXPAND = 1788 + PlSqlParserSYS_OP_NTCIMG = 1789 + PlSqlParserSYS_OP_NUMTORAW = 1790 + PlSqlParserSYS_OP_OIDVALUE = 1791 + PlSqlParserSYS_OP_OPNSIZE = 1792 + PlSqlParserSYS_OP_PAR_1 = 1793 + PlSqlParserSYS_OP_PARGID_1 = 1794 + PlSqlParserSYS_OP_PARGID = 1795 + PlSqlParserSYS_OP_PAR = 1796 + PlSqlParserSYS_OP_PART_ID = 1797 + PlSqlParserSYS_OP_PIVOT = 1798 + PlSqlParserSYS_OP_R2O = 1799 + PlSqlParserSYS_OP_RAWTONUM = 1800 + PlSqlParserSYS_OP_RDTM = 1801 + PlSqlParserSYS_OP_REF = 1802 + PlSqlParserSYS_OP_RMTD = 1803 + PlSqlParserSYS_OP_ROWIDTOOBJ = 1804 + PlSqlParserSYS_OP_RPB = 1805 + PlSqlParserSYS_OPTLOBPRBSC = 1806 + PlSqlParserSYS_OP_TOSETID = 1807 + PlSqlParserSYS_OP_TPR = 1808 + PlSqlParserSYS_OP_TRTB = 1809 + PlSqlParserSYS_OPTXICMP = 1810 + PlSqlParserSYS_OPTXQCASTASNQ = 1811 + PlSqlParserSYS_OP_UNDESCEND = 1812 + PlSqlParserSYS_OP_VECAND = 1813 + PlSqlParserSYS_OP_VECBIT = 1814 + PlSqlParserSYS_OP_VECOR = 1815 + PlSqlParserSYS_OP_VECXOR = 1816 + PlSqlParserSYS_OP_VERSION = 1817 + PlSqlParserSYS_OP_VREF = 1818 + PlSqlParserSYS_OP_VVD = 1819 + PlSqlParserSYS_OP_XMLCONS_FOR_CSX = 1820 + PlSqlParserSYS_OP_XPTHATG = 1821 + PlSqlParserSYS_OP_XPTHIDX = 1822 + PlSqlParserSYS_OP_XPTHOP = 1823 + PlSqlParserSYS_OP_XTXT2SQLT = 1824 + PlSqlParserSYS_OP_ZONE_ID = 1825 + PlSqlParserSYS_ORDERKEY_DEPTH = 1826 + PlSqlParserSYS_ORDERKEY_MAXCHILD = 1827 + PlSqlParserSYS_ORDERKEY_PARENT = 1828 + PlSqlParserSYS_PARALLEL_TXN = 1829 + PlSqlParserSYS_PATHID_IS_ATTR = 1830 + PlSqlParserSYS_PATHID_IS_NMSPC = 1831 + PlSqlParserSYS_PATHID_LASTNAME = 1832 + PlSqlParserSYS_PATHID_LASTNMSPC = 1833 + PlSqlParserSYS_PATH_REVERSE = 1834 + PlSqlParserSYS_PXQEXTRACT = 1835 + PlSqlParserSYS_RAW_TO_XSID = 1836 + PlSqlParserSYS_RID_ORDER = 1837 + PlSqlParserSYS_ROW_DELTA = 1838 + PlSqlParserSYS_SC_2_XMLT = 1839 + PlSqlParserSYS_SYNRCIREDO = 1840 + PlSqlParserSYSTEM_DEFINED = 1841 + PlSqlParserSYSTEM = 1842 + PlSqlParserSYSTIMESTAMP = 1843 + PlSqlParserSYS_TYPEID = 1844 + PlSqlParserSYS_UMAKEXML = 1845 + PlSqlParserSYS_XMLANALYZE = 1846 + PlSqlParserSYS_XMLCONTAINS = 1847 + PlSqlParserSYS_XMLCONV = 1848 + PlSqlParserSYS_XMLEXNSURI = 1849 + PlSqlParserSYS_XMLGEN = 1850 + PlSqlParserSYS_XMLI_LOC_ISNODE = 1851 + PlSqlParserSYS_XMLI_LOC_ISTEXT = 1852 + PlSqlParserSYS_XMLINSTR = 1853 + PlSqlParserSYS_XMLLOCATOR_GETSVAL = 1854 + PlSqlParserSYS_XMLNODEID_GETCID = 1855 + PlSqlParserSYS_XMLNODEID_GETLOCATOR = 1856 + PlSqlParserSYS_XMLNODEID_GETOKEY = 1857 + PlSqlParserSYS_XMLNODEID_GETPATHID = 1858 + PlSqlParserSYS_XMLNODEID_GETPTRID = 1859 + PlSqlParserSYS_XMLNODEID_GETRID = 1860 + PlSqlParserSYS_XMLNODEID_GETSVAL = 1861 + PlSqlParserSYS_XMLNODEID_GETTID = 1862 + PlSqlParserSYS_XMLNODEID = 1863 + PlSqlParserSYS_XMLT_2_SC = 1864 + PlSqlParserSYS_XMLTRANSLATE = 1865 + PlSqlParserSYS_XMLTYPE2SQL = 1866 + PlSqlParserSYS_XQ_ASQLCNV = 1867 + PlSqlParserSYS_XQ_ATOMCNVCHK = 1868 + PlSqlParserSYS_XQBASEURI = 1869 + PlSqlParserSYS_XQCASTABLEERRH = 1870 + PlSqlParserSYS_XQCODEP2STR = 1871 + PlSqlParserSYS_XQCODEPEQ = 1872 + PlSqlParserSYS_XQCON2SEQ = 1873 + PlSqlParserSYS_XQCONCAT = 1874 + PlSqlParserSYS_XQDELETE = 1875 + PlSqlParserSYS_XQDFLTCOLATION = 1876 + PlSqlParserSYS_XQDOC = 1877 + PlSqlParserSYS_XQDOCURI = 1878 + PlSqlParserSYS_XQDURDIV = 1879 + PlSqlParserSYS_XQED4URI = 1880 + PlSqlParserSYS_XQENDSWITH = 1881 + PlSqlParserSYS_XQERRH = 1882 + PlSqlParserSYS_XQERR = 1883 + PlSqlParserSYS_XQESHTMLURI = 1884 + PlSqlParserSYS_XQEXLOBVAL = 1885 + PlSqlParserSYS_XQEXSTWRP = 1886 + PlSqlParserSYS_XQEXTRACT = 1887 + PlSqlParserSYS_XQEXTRREF = 1888 + PlSqlParserSYS_XQEXVAL = 1889 + PlSqlParserSYS_XQFB2STR = 1890 + PlSqlParserSYS_XQFNBOOL = 1891 + PlSqlParserSYS_XQFNCMP = 1892 + PlSqlParserSYS_XQFNDATIM = 1893 + PlSqlParserSYS_XQFNLNAME = 1894 + PlSqlParserSYS_XQFNNM = 1895 + PlSqlParserSYS_XQFNNSURI = 1896 + PlSqlParserSYS_XQFNPREDTRUTH = 1897 + PlSqlParserSYS_XQFNQNM = 1898 + PlSqlParserSYS_XQFNROOT = 1899 + PlSqlParserSYS_XQFORMATNUM = 1900 + PlSqlParserSYS_XQFTCONTAIN = 1901 + PlSqlParserSYS_XQFUNCR = 1902 + PlSqlParserSYS_XQGETCONTENT = 1903 + PlSqlParserSYS_XQINDXOF = 1904 + PlSqlParserSYS_XQINSERT = 1905 + PlSqlParserSYS_XQINSPFX = 1906 + PlSqlParserSYS_XQIRI2URI = 1907 + PlSqlParserSYS_XQLANG = 1908 + PlSqlParserSYS_XQLLNMFRMQNM = 1909 + PlSqlParserSYS_XQMKNODEREF = 1910 + PlSqlParserSYS_XQNILLED = 1911 + PlSqlParserSYS_XQNODENAME = 1912 + PlSqlParserSYS_XQNORMSPACE = 1913 + PlSqlParserSYS_XQNORMUCODE = 1914 + PlSqlParserSYS_XQ_NRNG = 1915 + PlSqlParserSYS_XQNSP4PFX = 1916 + PlSqlParserSYS_XQNSPFRMQNM = 1917 + PlSqlParserSYS_XQPFXFRMQNM = 1918 + PlSqlParserSYS_XQ_PKSQL2XML = 1919 + PlSqlParserSYS_XQPOLYABS = 1920 + PlSqlParserSYS_XQPOLYADD = 1921 + PlSqlParserSYS_XQPOLYCEL = 1922 + PlSqlParserSYS_XQPOLYCSTBL = 1923 + PlSqlParserSYS_XQPOLYCST = 1924 + PlSqlParserSYS_XQPOLYDIV = 1925 + PlSqlParserSYS_XQPOLYFLR = 1926 + PlSqlParserSYS_XQPOLYMOD = 1927 + PlSqlParserSYS_XQPOLYMUL = 1928 + PlSqlParserSYS_XQPOLYRND = 1929 + PlSqlParserSYS_XQPOLYSQRT = 1930 + PlSqlParserSYS_XQPOLYSUB = 1931 + PlSqlParserSYS_XQPOLYUMUS = 1932 + PlSqlParserSYS_XQPOLYUPLS = 1933 + PlSqlParserSYS_XQPOLYVEQ = 1934 + PlSqlParserSYS_XQPOLYVGE = 1935 + PlSqlParserSYS_XQPOLYVGT = 1936 + PlSqlParserSYS_XQPOLYVLE = 1937 + PlSqlParserSYS_XQPOLYVLT = 1938 + PlSqlParserSYS_XQPOLYVNE = 1939 + PlSqlParserSYS_XQREF2VAL = 1940 + PlSqlParserSYS_XQRENAME = 1941 + PlSqlParserSYS_XQREPLACE = 1942 + PlSqlParserSYS_XQRESVURI = 1943 + PlSqlParserSYS_XQRNDHALF2EVN = 1944 + PlSqlParserSYS_XQRSLVQNM = 1945 + PlSqlParserSYS_XQRYENVPGET = 1946 + PlSqlParserSYS_XQRYVARGET = 1947 + PlSqlParserSYS_XQRYWRP = 1948 + PlSqlParserSYS_XQSEQ2CON4XC = 1949 + PlSqlParserSYS_XQSEQ2CON = 1950 + PlSqlParserSYS_XQSEQDEEPEQ = 1951 + PlSqlParserSYS_XQSEQINSB = 1952 + PlSqlParserSYS_XQSEQRM = 1953 + PlSqlParserSYS_XQSEQRVS = 1954 + PlSqlParserSYS_XQSEQSUB = 1955 + PlSqlParserSYS_XQSEQTYPMATCH = 1956 + PlSqlParserSYS_XQSTARTSWITH = 1957 + PlSqlParserSYS_XQSTATBURI = 1958 + PlSqlParserSYS_XQSTR2CODEP = 1959 + PlSqlParserSYS_XQSTRJOIN = 1960 + PlSqlParserSYS_XQSUBSTRAFT = 1961 + PlSqlParserSYS_XQSUBSTRBEF = 1962 + PlSqlParserSYS_XQTOKENIZE = 1963 + PlSqlParserSYS_XQTREATAS = 1964 + PlSqlParserSYS_XQ_UPKXML2SQL = 1965 + PlSqlParserSYS_XQXFORM = 1966 + PlSqlParserSYS_XSID_TO_RAW = 1967 + PlSqlParserSYS_ZMAP_FILTER = 1968 + PlSqlParserSYS_ZMAP_REFRESH = 1969 + PlSqlParserT_LETTER = 1970 + PlSqlParserTABLE_LOOKUP_BY_NL = 1971 + PlSqlParserTABLESPACE_NO = 1972 + PlSqlParserTABLESPACE = 1973 + PlSqlParserTABLES = 1974 + PlSqlParserTABLE_STATS = 1975 + PlSqlParserTABLE = 1976 + PlSqlParserTABNO = 1977 + PlSqlParserTAG = 1978 + PlSqlParserTANH = 1979 + PlSqlParserTAN = 1980 + PlSqlParserTBLORIDXPARTNUM = 1981 + PlSqlParserTEMPFILE = 1982 + PlSqlParserTEMPLATE = 1983 + PlSqlParserTEMPORARY = 1984 + PlSqlParserTEMP_TABLE = 1985 + PlSqlParserTEST = 1986 + PlSqlParserTEXT = 1987 + PlSqlParserTHAN = 1988 + PlSqlParserTHEN = 1989 + PlSqlParserTHE = 1990 + PlSqlParserTHREAD = 1991 + PlSqlParserTHROUGH = 1992 + PlSqlParserTIER = 1993 + PlSqlParserTIES = 1994 + PlSqlParserTIMEOUT = 1995 + PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED = 1996 + PlSqlParserTIMESTAMP = 1997 + PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED = 1998 + PlSqlParserTIMESTAMP_UNCONSTRAINED = 1999 + PlSqlParserTIMES = 2000 + PlSqlParserTIME = 2001 + PlSqlParserTIMEZONE = 2002 + PlSqlParserTIMEZONE_ABBR = 2003 + PlSqlParserTIMEZONE_HOUR = 2004 + PlSqlParserTIMEZONE_MINUTE = 2005 + PlSqlParserTIMEZONE_OFFSET = 2006 + PlSqlParserTIMEZONE_REGION = 2007 + PlSqlParserTIME_ZONE = 2008 + PlSqlParserTIMING = 2009 + PlSqlParserTIV_GB = 2010 + PlSqlParserTIV_SSF = 2011 + PlSqlParserTO_ACLID = 2012 + PlSqlParserTO_BINARY_DOUBLE = 2013 + PlSqlParserTO_BINARY_FLOAT = 2014 + PlSqlParserTO_BLOB = 2015 + PlSqlParserTO_CLOB = 2016 + PlSqlParserTO_DSINTERVAL = 2017 + PlSqlParserTO_LOB = 2018 + PlSqlParserTO_MULTI_BYTE = 2019 + PlSqlParserTO_NCHAR = 2020 + PlSqlParserTO_NCLOB = 2021 + PlSqlParserTO_NUMBER = 2022 + PlSqlParserTOPLEVEL = 2023 + PlSqlParserTO_SINGLE_BYTE = 2024 + PlSqlParserTO_TIMESTAMP = 2025 + PlSqlParserTO_TIMESTAMP_TZ = 2026 + PlSqlParserTO_TIME = 2027 + PlSqlParserTO_TIME_TZ = 2028 + PlSqlParserTO = 2029 + PlSqlParserTO_YMINTERVAL = 2030 + PlSqlParserTRACE = 2031 + PlSqlParserTRACING = 2032 + PlSqlParserTRACKING = 2033 + PlSqlParserTRAILING = 2034 + PlSqlParserTRANSACTION = 2035 + PlSqlParserTRANSFORM = 2036 + PlSqlParserTRANSFORM_DISTINCT_AGG = 2037 + PlSqlParserTRANSITIONAL = 2038 + PlSqlParserTRANSITION = 2039 + PlSqlParserTRANSLATE = 2040 + PlSqlParserTRANSLATION = 2041 + PlSqlParserTREAT = 2042 + PlSqlParserTRIGGERS = 2043 + PlSqlParserTRIGGER = 2044 + PlSqlParserTRUE = 2045 + PlSqlParserTRUNCATE = 2046 + PlSqlParserTRUNC = 2047 + PlSqlParserTRUSTED = 2048 + PlSqlParserTRUST = 2049 + PlSqlParserTUNING = 2050 + PlSqlParserTX = 2051 + PlSqlParserTYPES = 2052 + PlSqlParserTYPE = 2053 + PlSqlParserTZ_OFFSET = 2054 + PlSqlParserUB2 = 2055 + PlSqlParserUBA = 2056 + PlSqlParserUCS2 = 2057 + PlSqlParserUID = 2058 + PlSqlParserUNARCHIVED = 2059 + PlSqlParserUNBOUNDED = 2060 + PlSqlParserUNBOUND = 2061 + PlSqlParserUNCONDITIONAL = 2062 + PlSqlParserUNDER = 2063 + PlSqlParserUNDO = 2064 + PlSqlParserUNDROP = 2065 + PlSqlParserUNIFORM = 2066 + PlSqlParserUNION = 2067 + PlSqlParserUNIQUE = 2068 + PlSqlParserUNISTR = 2069 + PlSqlParserUNLIMITED = 2070 + PlSqlParserUNLOAD = 2071 + PlSqlParserUNLOCK = 2072 + PlSqlParserUNMATCHED = 2073 + PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW = 2074 + PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW = 2075 + PlSqlParserUNNEST_SEMIJ_VIEW = 2076 + PlSqlParserUNNEST = 2077 + PlSqlParserUNPACKED = 2078 + PlSqlParserUNPIVOT = 2079 + PlSqlParserUNPLUG = 2080 + PlSqlParserUNPROTECTED = 2081 + PlSqlParserUNQUIESCE = 2082 + PlSqlParserUNRECOVERABLE = 2083 + PlSqlParserUNRESTRICTED = 2084 + PlSqlParserUNSUBSCRIBE = 2085 + PlSqlParserUNTIL = 2086 + PlSqlParserUNUSABLE = 2087 + PlSqlParserUNUSED = 2088 + PlSqlParserUPDATABLE = 2089 + PlSqlParserUPDATED = 2090 + PlSqlParserUPDATE = 2091 + PlSqlParserUPDATEXML = 2092 + PlSqlParserUPD_INDEXES = 2093 + PlSqlParserUPD_JOININDEX = 2094 + PlSqlParserUPGRADE = 2095 + PlSqlParserUPPER = 2096 + PlSqlParserUPSERT = 2097 + PlSqlParserUROWID = 2098 + PlSqlParserUSABLE = 2099 + PlSqlParserUSAGE = 2100 + PlSqlParserUSE_ANTI = 2101 + PlSqlParserUSE_CONCAT = 2102 + PlSqlParserUSE_CUBE = 2103 + PlSqlParserUSE_HASH_AGGREGATION = 2104 + PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN = 2105 + PlSqlParserUSE_HASH = 2106 + PlSqlParserUSE_HIDDEN_PARTITIONS = 2107 + PlSqlParserUSE_INVISIBLE_INDEXES = 2108 + PlSqlParserUSE_MERGE_CARTESIAN = 2109 + PlSqlParserUSE_MERGE = 2110 + PlSqlParserUSE_NL = 2111 + PlSqlParserUSE_NL_WITH_INDEX = 2112 + PlSqlParserUSE_PRIVATE_OUTLINES = 2113 + PlSqlParserUSER_DATA = 2114 + PlSqlParserUSER_DEFINED = 2115 + PlSqlParserUSERENV = 2116 + PlSqlParserUSERGROUP = 2117 + PlSqlParserUSER_RECYCLEBIN = 2118 + PlSqlParserUSERS = 2119 + PlSqlParserUSER_TABLESPACES = 2120 + PlSqlParserUSER = 2121 + PlSqlParserUSE_SEMI = 2122 + PlSqlParserUSE_STORED_OUTLINES = 2123 + PlSqlParserUSE_TTT_FOR_GSETS = 2124 + PlSqlParserUSE = 2125 + PlSqlParserUSE_VECTOR_AGGREGATION = 2126 + PlSqlParserUSE_WEAK_NAME_RESL = 2127 + PlSqlParserUSING_NO_EXPAND = 2128 + PlSqlParserUSING = 2129 + PlSqlParserUTF16BE = 2130 + PlSqlParserUTF16LE = 2131 + PlSqlParserUTF32 = 2132 + PlSqlParserUTF8 = 2133 + PlSqlParserV1 = 2134 + PlSqlParserV2 = 2135 + PlSqlParserVALIDATE = 2136 + PlSqlParserVALIDATE_CONVERSION = 2137 + PlSqlParserVALIDATION = 2138 + PlSqlParserVALID_TIME_END = 2139 + PlSqlParserVALUES = 2140 + PlSqlParserVALUE = 2141 + PlSqlParserVARCHAR2 = 2142 + PlSqlParserVARCHAR = 2143 + PlSqlParserVARIABLE = 2144 + PlSqlParserVAR_POP = 2145 + PlSqlParserVARRAYS = 2146 + PlSqlParserVARRAY = 2147 + PlSqlParserVAR_SAMP = 2148 + PlSqlParserVARYING = 2149 + PlSqlParserVECTOR_READ_TRACE = 2150 + PlSqlParserVECTOR_READ = 2151 + PlSqlParserVECTOR_TRANSFORM_DIMS = 2152 + PlSqlParserVECTOR_TRANSFORM_FACT = 2153 + PlSqlParserVECTOR_TRANSFORM = 2154 + PlSqlParserVERIFIER = 2155 + PlSqlParserVERIFY = 2156 + PlSqlParserVERSIONING = 2157 + PlSqlParserVERSIONS_ENDSCN = 2158 + PlSqlParserVERSIONS_ENDTIME = 2159 + PlSqlParserVERSIONS_OPERATION = 2160 + PlSqlParserVERSIONS_STARTSCN = 2161 + PlSqlParserVERSIONS_STARTTIME = 2162 + PlSqlParserVERSIONS = 2163 + PlSqlParserVERSIONS_XID = 2164 + PlSqlParserVERSION = 2165 + PlSqlParserVIEW = 2166 + PlSqlParserVIOLATION = 2167 + PlSqlParserVIRTUAL = 2168 + PlSqlParserVISIBILITY = 2169 + PlSqlParserVISIBLE = 2170 + PlSqlParserVOLUME = 2171 + PlSqlParserVSIZE = 2172 + PlSqlParserWAIT = 2173 + PlSqlParserWALLET = 2174 + PlSqlParserWARNING = 2175 + PlSqlParserWEEKS = 2176 + PlSqlParserWEEK = 2177 + PlSqlParserWELLFORMED = 2178 + PlSqlParserWHENEVER = 2179 + PlSqlParserWHEN = 2180 + PlSqlParserWHERE = 2181 + PlSqlParserWHILE = 2182 + PlSqlParserWHITESPACE = 2183 + PlSqlParserWIDTH_BUCKET = 2184 + PlSqlParserWITHIN = 2185 + PlSqlParserWITHOUT = 2186 + PlSqlParserWITH_PLSQL = 2187 + PlSqlParserWITH = 2188 + PlSqlParserWORK = 2189 + PlSqlParserWRAPPED = 2190 + PlSqlParserWRAPPER = 2191 + PlSqlParserWRITE = 2192 + PlSqlParserXDB_FASTPATH_INSERT = 2193 + PlSqlParserXDB = 2194 + PlSqlParserX_DYN_PRUNE = 2195 + PlSqlParserXID = 2196 + PlSqlParserXML2OBJECT = 2197 + PlSqlParserXMLAGG = 2198 + PlSqlParserXMLATTRIBUTES = 2199 + PlSqlParserXMLCAST = 2200 + PlSqlParserXMLCDATA = 2201 + PlSqlParserXMLCOLATTVAL = 2202 + PlSqlParserXMLCOMMENT = 2203 + PlSqlParserXMLCONCAT = 2204 + PlSqlParserXMLDIFF = 2205 + PlSqlParserXML_DML_RWT_STMT = 2206 + PlSqlParserXMLELEMENT = 2207 + PlSqlParserXMLEXISTS2 = 2208 + PlSqlParserXMLEXISTS = 2209 + PlSqlParserXMLFOREST = 2210 + PlSqlParserXMLINDEX = 2211 + PlSqlParserXMLINDEX_REWRITE_IN_SELECT = 2212 + PlSqlParserXMLINDEX_REWRITE = 2213 + PlSqlParserXMLINDEX_SEL_IDX_TBL = 2214 + PlSqlParserXMLISNODE = 2215 + PlSqlParserXMLISVALID = 2216 + PlSqlParserXMLNAMESPACES = 2217 + PlSqlParserXMLPARSE = 2218 + PlSqlParserXMLPATCH = 2219 + PlSqlParserXMLPI = 2220 + PlSqlParserXMLQUERYVAL = 2221 + PlSqlParserXMLQUERY = 2222 + PlSqlParserXMLROOT = 2223 + PlSqlParserXMLSCHEMA = 2224 + PlSqlParserXMLSERIALIZE = 2225 + PlSqlParserXMLTABLE = 2226 + PlSqlParserXMLTRANSFORMBLOB = 2227 + PlSqlParserXMLTRANSFORM = 2228 + PlSqlParserXMLTYPE = 2229 + PlSqlParserXML = 2230 + PlSqlParserXPATHTABLE = 2231 + PlSqlParserXS_SYS_CONTEXT = 2232 + PlSqlParserXS = 2233 + PlSqlParserYEARS = 2234 + PlSqlParserYEAR = 2235 + PlSqlParserYES = 2236 + PlSqlParserYMINTERVAL_UNCONSTRAINED = 2237 + PlSqlParserZONEMAP = 2238 + PlSqlParserZONE = 2239 + PlSqlParserPREDICTION = 2240 + PlSqlParserPREDICTION_BOUNDS = 2241 + PlSqlParserPREDICTION_COST = 2242 + PlSqlParserPREDICTION_DETAILS = 2243 + PlSqlParserPREDICTION_PROBABILITY = 2244 + PlSqlParserPREDICTION_SET = 2245 + PlSqlParserBLOCKCHAIN = 2246 + PlSqlParserCOLLATE = 2247 + PlSqlParserCOLLATION = 2248 + PlSqlParserDEFINITION = 2249 + PlSqlParserDUPLICATED = 2250 + PlSqlParserEXTENDED = 2251 + PlSqlParserHASHING = 2252 + PlSqlParserIDLE = 2253 + PlSqlParserIMMUTABLE = 2254 + PlSqlParserORACLE_DATAPUMP = 2255 + PlSqlParserORACLE_HDFS = 2256 + PlSqlParserORACLE_HIVE = 2257 + PlSqlParserORACLE_LOADER = 2258 + PlSqlParserSHA2_512_Q = 2259 + PlSqlParserSHARDED = 2260 + PlSqlParserV1_Q = 2261 + PlSqlParserISOLATE = 2262 + PlSqlParserROOT = 2263 + PlSqlParserUNITE = 2264 + PlSqlParserALGORITHM = 2265 + PlSqlParserCUME_DIST = 2266 + PlSqlParserDENSE_RANK = 2267 + PlSqlParserLISTAGG = 2268 + PlSqlParserPERCENT_RANK = 2269 + PlSqlParserPERCENTILE_CONT = 2270 + PlSqlParserPERCENTILE_DISC = 2271 + PlSqlParserRANK = 2272 + PlSqlParserAVG = 2273 + PlSqlParserCORR = 2274 + PlSqlParserCOVAR_ = 2275 + PlSqlParserDECODE = 2276 + PlSqlParserLAG = 2277 + PlSqlParserLAG_DIFF = 2278 + PlSqlParserLAG_DIFF_PERCENT = 2279 + PlSqlParserLEAD = 2280 + PlSqlParserMAX = 2281 + PlSqlParserMEDIAN = 2282 + PlSqlParserMEMOPTIMIZE = 2283 + PlSqlParserMIN = 2284 + PlSqlParserNTILE = 2285 + PlSqlParserNVL = 2286 + PlSqlParserRATIO_TO_REPORT = 2287 + PlSqlParserREGR_ = 2288 + PlSqlParserROUND = 2289 + PlSqlParserROW_NUMBER = 2290 + PlSqlParserSUBSTR = 2291 + PlSqlParserTO_CHAR = 2292 + PlSqlParserTRIM = 2293 + PlSqlParserSUM = 2294 + PlSqlParserSTDDEV = 2295 + PlSqlParserVAR_ = 2296 + PlSqlParserVARIANCE = 2297 + PlSqlParserLEAST = 2298 + PlSqlParserGREATEST = 2299 + PlSqlParserTO_DATE = 2300 + PlSqlParserDEFAULTIF = 2301 + PlSqlParserLLS = 2302 + PlSqlParserENCLOSED = 2303 + PlSqlParserTERMINATED = 2304 + PlSqlParserOPTIONALLY = 2305 + PlSqlParserLRTRIM = 2306 + PlSqlParserNOTRIM = 2307 + PlSqlParserLDRTRIM = 2308 + PlSqlParserDATE_FORMAT = 2309 + PlSqlParserMASK = 2310 + PlSqlParserTRANSFORMS = 2311 + PlSqlParserLOBFILE = 2312 + PlSqlParserSTARTOF = 2313 + PlSqlParserCHARACTERSET = 2314 + PlSqlParserRECORDS = 2315 + PlSqlParserFIXED = 2316 + PlSqlParserDELIMITED = 2317 + PlSqlParserXMLTAG = 2318 + PlSqlParserPREPROCESSOR = 2319 + PlSqlParserTERRITORY = 2320 + PlSqlParserLITTLE = 2321 + PlSqlParserBIG = 2322 + PlSqlParserENDIAN = 2323 + PlSqlParserBYTEORDERMARK = 2324 + PlSqlParserNOCHECK = 2325 + PlSqlParserSIZES = 2326 + PlSqlParserARE = 2327 + PlSqlParserBYTES = 2328 + PlSqlParserCHARACTERS = 2329 + PlSqlParserREADSIZE = 2330 + PlSqlParserDISABLE_DIRECTORY_LINK_CHECK = 2331 + PlSqlParserDATE_CACHE = 2332 + PlSqlParserFIELD_NAMES = 2333 + PlSqlParserFILES = 2334 + PlSqlParserIO_OPTIONS = 2335 + PlSqlParserDIRECTIO = 2336 + PlSqlParserNODIRECTIO = 2337 + PlSqlParserDNFS_ENABLE = 2338 + PlSqlParserDNFS_DISABLE = 2339 + PlSqlParserDNFS_READBUFFERS = 2340 + PlSqlParserNOBADFILE = 2341 + PlSqlParserBADFILE = 2342 + PlSqlParserNODISCARDFILE = 2343 + PlSqlParserDISCARDFILE = 2344 + PlSqlParserNOLOGFILE = 2345 + PlSqlParserFIELDS = 2346 + PlSqlParserIGNORE_CHARS_AFTER_EOR = 2347 + PlSqlParserCSV = 2348 + PlSqlParserEMBEDDED = 2349 + PlSqlParserOVERRIDE = 2350 + PlSqlParserTHESE = 2351 + PlSqlParserFIELD = 2352 + PlSqlParserNONULLIF = 2353 + PlSqlParserPOSITION = 2354 + PlSqlParserNEWLINE_ = 2355 + PlSqlParserDETECTED = 2356 + PlSqlParserUNSIGNED = 2357 + PlSqlParserZONED = 2358 + PlSqlParserORACLE_DATE = 2359 + PlSqlParserORACLE_NUMBER = 2360 + PlSqlParserCOUNTED = 2361 + PlSqlParserVARRAW = 2362 + PlSqlParserVARCHARC = 2363 + PlSqlParserVARRAWC = 2364 + PlSqlParserNATIONAL_CHAR_STRING_LIT = 2365 + PlSqlParserBIT_STRING_LIT = 2366 + PlSqlParserHEX_STRING_LIT = 2367 + PlSqlParserDOUBLE_PERIOD = 2368 + PlSqlParserPERIOD = 2369 + PlSqlParserUNSIGNED_INTEGER = 2370 + PlSqlParserAPPROXIMATE_NUM_LIT = 2371 + PlSqlParserCHAR_STRING = 2372 + PlSqlParserDELIMITED_ID = 2373 + PlSqlParserPERCENT = 2374 + PlSqlParserAMPERSAND = 2375 + PlSqlParserLEFT_PAREN = 2376 + PlSqlParserRIGHT_PAREN = 2377 + PlSqlParserDOUBLE_ASTERISK = 2378 + PlSqlParserASTERISK = 2379 + PlSqlParserPLUS_SIGN = 2380 + PlSqlParserMINUS_SIGN = 2381 + PlSqlParserCOMMA = 2382 + PlSqlParserSOLIDUS = 2383 + PlSqlParserAT_SIGN = 2384 + PlSqlParserASSIGN_OP = 2385 + PlSqlParserHASH_OP = 2386 + PlSqlParserSQ = 2387 + PlSqlParserBINDVAR = 2388 + PlSqlParserNOT_EQUAL_OP = 2389 + PlSqlParserCARRET_OPERATOR_PART = 2390 + PlSqlParserTILDE_OPERATOR_PART = 2391 + PlSqlParserEXCLAMATION_OPERATOR_PART = 2392 + PlSqlParserGREATER_THAN_OP = 2393 + PlSqlParserLESS_THAN_OP = 2394 + PlSqlParserCOLON = 2395 + PlSqlParserSEMICOLON = 2396 + PlSqlParserBAR = 2397 + PlSqlParserEQUALS_OP = 2398 + PlSqlParserLEFT_BRACKET = 2399 + PlSqlParserRIGHT_BRACKET = 2400 + PlSqlParserINTRODUCER = 2401 + PlSqlParserSINGLE_LINE_COMMENT = 2402 + PlSqlParserMULTI_LINE_COMMENT = 2403 + PlSqlParserREMARK_COMMENT = 2404 + PlSqlParserPROMPT_MESSAGE = 2405 + PlSqlParserSTART_CMD = 2406 + PlSqlParserREGULAR_ID = 2407 + PlSqlParserSPACES = 2408 +) + +// PlSqlParser rules. +const ( + PlSqlParserRULE_sql_script = 0 + PlSqlParserRULE_unit_statement = 1 + PlSqlParserRULE_alter_diskgroup = 2 + PlSqlParserRULE_add_disk_clause = 3 + PlSqlParserRULE_drop_disk_clause = 4 + PlSqlParserRULE_resize_disk_clause = 5 + PlSqlParserRULE_replace_disk_clause = 6 + PlSqlParserRULE_wait_nowait = 7 + PlSqlParserRULE_rename_disk_clause = 8 + PlSqlParserRULE_disk_online_clause = 9 + PlSqlParserRULE_disk_offline_clause = 10 + PlSqlParserRULE_timeout_clause = 11 + PlSqlParserRULE_rebalance_diskgroup_clause = 12 + PlSqlParserRULE_phase = 13 + PlSqlParserRULE_check_diskgroup_clause = 14 + PlSqlParserRULE_diskgroup_template_clauses = 15 + PlSqlParserRULE_qualified_template_clause = 16 + PlSqlParserRULE_redundancy_clause = 17 + PlSqlParserRULE_striping_clause = 18 + PlSqlParserRULE_force_noforce = 19 + PlSqlParserRULE_diskgroup_directory_clauses = 20 + PlSqlParserRULE_dir_name = 21 + PlSqlParserRULE_diskgroup_alias_clauses = 22 + PlSqlParserRULE_diskgroup_volume_clauses = 23 + PlSqlParserRULE_add_volume_clause = 24 + PlSqlParserRULE_modify_volume_clause = 25 + PlSqlParserRULE_diskgroup_attributes = 26 + PlSqlParserRULE_modify_diskgroup_file = 27 + PlSqlParserRULE_disk_region_clause = 28 + PlSqlParserRULE_drop_diskgroup_file_clause = 29 + PlSqlParserRULE_convert_redundancy_clause = 30 + PlSqlParserRULE_usergroup_clauses = 31 + PlSqlParserRULE_user_clauses = 32 + PlSqlParserRULE_file_permissions_clause = 33 + PlSqlParserRULE_file_owner_clause = 34 + PlSqlParserRULE_scrub_clause = 35 + PlSqlParserRULE_quotagroup_clauses = 36 + PlSqlParserRULE_property_name = 37 + PlSqlParserRULE_property_value = 38 + PlSqlParserRULE_filegroup_clauses = 39 + PlSqlParserRULE_add_filegroup_clause = 40 + PlSqlParserRULE_modify_filegroup_clause = 41 + PlSqlParserRULE_move_to_filegroup_clause = 42 + PlSqlParserRULE_drop_filegroup_clause = 43 + PlSqlParserRULE_quorum_regular = 44 + PlSqlParserRULE_undrop_disk_clause = 45 + PlSqlParserRULE_diskgroup_availability = 46 + PlSqlParserRULE_enable_disable_volume = 47 + PlSqlParserRULE_drop_function = 48 + PlSqlParserRULE_alter_flashback_archive = 49 + PlSqlParserRULE_alter_hierarchy = 50 + PlSqlParserRULE_alter_function = 51 + PlSqlParserRULE_alter_java = 52 + PlSqlParserRULE_match_string = 53 + PlSqlParserRULE_create_function_body = 54 + PlSqlParserRULE_sql_macro_body = 55 + PlSqlParserRULE_parallel_enable_clause = 56 + PlSqlParserRULE_partition_by_clause = 57 + PlSqlParserRULE_result_cache_clause = 58 + PlSqlParserRULE_relies_on_part = 59 + PlSqlParserRULE_streaming_clause = 60 + PlSqlParserRULE_alter_outline = 61 + PlSqlParserRULE_outline_options = 62 + PlSqlParserRULE_alter_lockdown_profile = 63 + PlSqlParserRULE_lockdown_feature = 64 + PlSqlParserRULE_lockdown_options = 65 + PlSqlParserRULE_lockdown_statements = 66 + PlSqlParserRULE_statement_clauses = 67 + PlSqlParserRULE_clause_options = 68 + PlSqlParserRULE_option_values = 69 + PlSqlParserRULE_string_list = 70 + PlSqlParserRULE_disable_enable = 71 + PlSqlParserRULE_drop_lockdown_profile = 72 + PlSqlParserRULE_drop_package = 73 + PlSqlParserRULE_alter_package = 74 + PlSqlParserRULE_create_package = 75 + PlSqlParserRULE_create_package_body = 76 + PlSqlParserRULE_package_obj_spec = 77 + PlSqlParserRULE_procedure_spec = 78 + PlSqlParserRULE_function_spec = 79 + PlSqlParserRULE_package_obj_body = 80 + PlSqlParserRULE_alter_pmem_filestore = 81 + PlSqlParserRULE_drop_pmem_filestore = 82 + PlSqlParserRULE_drop_procedure = 83 + PlSqlParserRULE_alter_procedure = 84 + PlSqlParserRULE_function_body = 85 + PlSqlParserRULE_procedure_body = 86 + PlSqlParserRULE_create_procedure_body = 87 + PlSqlParserRULE_alter_resource_cost = 88 + PlSqlParserRULE_drop_outline = 89 + PlSqlParserRULE_alter_rollback_segment = 90 + PlSqlParserRULE_drop_restore_point = 91 + PlSqlParserRULE_drop_rollback_segment = 92 + PlSqlParserRULE_drop_role = 93 + PlSqlParserRULE_create_pmem_filestore = 94 + PlSqlParserRULE_pmem_filestore_options = 95 + PlSqlParserRULE_file_path = 96 + PlSqlParserRULE_create_rollback_segment = 97 + PlSqlParserRULE_drop_trigger = 98 + PlSqlParserRULE_alter_trigger = 99 + PlSqlParserRULE_create_trigger = 100 + PlSqlParserRULE_trigger_follows_clause = 101 + PlSqlParserRULE_trigger_when_clause = 102 + PlSqlParserRULE_simple_dml_trigger = 103 + PlSqlParserRULE_for_each_row = 104 + PlSqlParserRULE_compound_dml_trigger = 105 + PlSqlParserRULE_non_dml_trigger = 106 + PlSqlParserRULE_trigger_body = 107 + PlSqlParserRULE_routine_clause = 108 + PlSqlParserRULE_compound_trigger_block = 109 + PlSqlParserRULE_timing_point_section = 110 + PlSqlParserRULE_non_dml_event = 111 + PlSqlParserRULE_dml_event_clause = 112 + PlSqlParserRULE_dml_event_element = 113 + PlSqlParserRULE_dml_event_nested_clause = 114 + PlSqlParserRULE_referencing_clause = 115 + PlSqlParserRULE_referencing_element = 116 + PlSqlParserRULE_drop_type = 117 + PlSqlParserRULE_alter_type = 118 + PlSqlParserRULE_compile_type_clause = 119 + PlSqlParserRULE_replace_type_clause = 120 + PlSqlParserRULE_alter_method_spec = 121 + PlSqlParserRULE_alter_method_element = 122 + PlSqlParserRULE_alter_attribute_definition = 123 + PlSqlParserRULE_attribute_definition = 124 + PlSqlParserRULE_alter_collection_clauses = 125 + PlSqlParserRULE_dependent_handling_clause = 126 + PlSqlParserRULE_dependent_exceptions_part = 127 + PlSqlParserRULE_create_type = 128 + PlSqlParserRULE_type_definition = 129 + PlSqlParserRULE_object_type_def = 130 + PlSqlParserRULE_object_as_part = 131 + PlSqlParserRULE_object_under_part = 132 + PlSqlParserRULE_nested_table_type_def = 133 + PlSqlParserRULE_sqlj_object_type = 134 + PlSqlParserRULE_type_body = 135 + PlSqlParserRULE_type_body_elements = 136 + PlSqlParserRULE_map_order_func_declaration = 137 + PlSqlParserRULE_subprog_decl_in_type = 138 + PlSqlParserRULE_proc_decl_in_type = 139 + PlSqlParserRULE_func_decl_in_type = 140 + PlSqlParserRULE_constructor_declaration = 141 + PlSqlParserRULE_modifier_clause = 142 + PlSqlParserRULE_object_member_spec = 143 + PlSqlParserRULE_sqlj_object_type_attr = 144 + PlSqlParserRULE_element_spec = 145 + PlSqlParserRULE_element_spec_options = 146 + PlSqlParserRULE_subprogram_spec = 147 + PlSqlParserRULE_overriding_subprogram_spec = 148 + PlSqlParserRULE_overriding_function_spec = 149 + PlSqlParserRULE_type_procedure_spec = 150 + PlSqlParserRULE_type_function_spec = 151 + PlSqlParserRULE_constructor_spec = 152 + PlSqlParserRULE_map_order_function_spec = 153 + PlSqlParserRULE_pragma_clause = 154 + PlSqlParserRULE_pragma_elements = 155 + PlSqlParserRULE_type_elements_parameter = 156 + PlSqlParserRULE_drop_sequence = 157 + PlSqlParserRULE_alter_sequence = 158 + PlSqlParserRULE_alter_session = 159 + PlSqlParserRULE_alter_session_set_clause = 160 + PlSqlParserRULE_create_sequence = 161 + PlSqlParserRULE_sequence_spec = 162 + PlSqlParserRULE_sequence_start_clause = 163 + PlSqlParserRULE_create_analytic_view = 164 + PlSqlParserRULE_classification_clause = 165 + PlSqlParserRULE_caption_clause = 166 + PlSqlParserRULE_description_clause = 167 + PlSqlParserRULE_classification_item = 168 + PlSqlParserRULE_language = 169 + PlSqlParserRULE_cav_using_clause = 170 + PlSqlParserRULE_dim_by_clause = 171 + PlSqlParserRULE_dim_key = 172 + PlSqlParserRULE_dim_ref = 173 + PlSqlParserRULE_hier_ref = 174 + PlSqlParserRULE_measures_clause = 175 + PlSqlParserRULE_av_measure = 176 + PlSqlParserRULE_base_meas_clause = 177 + PlSqlParserRULE_meas_aggregate_clause = 178 + PlSqlParserRULE_calc_meas_clause = 179 + PlSqlParserRULE_default_measure_clause = 180 + PlSqlParserRULE_default_aggregate_clause = 181 + PlSqlParserRULE_cache_clause = 182 + PlSqlParserRULE_cache_specification = 183 + PlSqlParserRULE_levels_clause = 184 + PlSqlParserRULE_level_specification = 185 + PlSqlParserRULE_level_group_type = 186 + PlSqlParserRULE_fact_columns_clause = 187 + PlSqlParserRULE_qry_transform_clause = 188 + PlSqlParserRULE_create_attribute_dimension = 189 + PlSqlParserRULE_ad_using_clause = 190 + PlSqlParserRULE_source_clause = 191 + PlSqlParserRULE_join_path_clause = 192 + PlSqlParserRULE_join_condition = 193 + PlSqlParserRULE_join_condition_item = 194 + PlSqlParserRULE_attributes_clause = 195 + PlSqlParserRULE_ad_attributes_clause = 196 + PlSqlParserRULE_ad_level_clause = 197 + PlSqlParserRULE_key_clause = 198 + PlSqlParserRULE_alternate_key_clause = 199 + PlSqlParserRULE_dim_order_clause = 200 + PlSqlParserRULE_all_clause = 201 + PlSqlParserRULE_create_audit_policy = 202 + PlSqlParserRULE_privilege_audit_clause = 203 + PlSqlParserRULE_action_audit_clause = 204 + PlSqlParserRULE_standard_actions = 205 + PlSqlParserRULE_actions_clause = 206 + PlSqlParserRULE_object_action = 207 + PlSqlParserRULE_system_action = 208 + PlSqlParserRULE_component_actions = 209 + PlSqlParserRULE_component_action = 210 + PlSqlParserRULE_role_audit_clause = 211 + PlSqlParserRULE_create_controlfile = 212 + PlSqlParserRULE_controlfile_options = 213 + PlSqlParserRULE_logfile_clause = 214 + PlSqlParserRULE_character_set_clause = 215 + PlSqlParserRULE_file_specification = 216 + PlSqlParserRULE_create_diskgroup = 217 + PlSqlParserRULE_qualified_disk_clause = 218 + PlSqlParserRULE_create_edition = 219 + PlSqlParserRULE_create_flashback_archive = 220 + PlSqlParserRULE_flashback_archive_quota = 221 + PlSqlParserRULE_flashback_archive_retention = 222 + PlSqlParserRULE_create_hierarchy = 223 + PlSqlParserRULE_hier_using_clause = 224 + PlSqlParserRULE_level_hier_clause = 225 + PlSqlParserRULE_hier_attrs_clause = 226 + PlSqlParserRULE_hier_attr_clause = 227 + PlSqlParserRULE_hier_attr_name = 228 + PlSqlParserRULE_create_index = 229 + PlSqlParserRULE_cluster_index_clause = 230 + PlSqlParserRULE_cluster_name = 231 + PlSqlParserRULE_table_index_clause = 232 + PlSqlParserRULE_bitmap_join_index_clause = 233 + PlSqlParserRULE_index_expr_option = 234 + PlSqlParserRULE_index_expr = 235 + PlSqlParserRULE_index_properties = 236 + PlSqlParserRULE_domain_index_clause = 237 + PlSqlParserRULE_local_domain_index_clause = 238 + PlSqlParserRULE_xmlindex_clause = 239 + PlSqlParserRULE_local_xmlindex_clause = 240 + PlSqlParserRULE_global_partitioned_index = 241 + PlSqlParserRULE_index_partitioning_clause = 242 + PlSqlParserRULE_local_partitioned_index = 243 + PlSqlParserRULE_on_range_partitioned_table = 244 + PlSqlParserRULE_on_list_partitioned_table = 245 + PlSqlParserRULE_partitioned_table = 246 + PlSqlParserRULE_on_hash_partitioned_table = 247 + PlSqlParserRULE_on_hash_partitioned_clause = 248 + PlSqlParserRULE_on_comp_partitioned_table = 249 + PlSqlParserRULE_on_comp_partitioned_clause = 250 + PlSqlParserRULE_index_subpartition_clause = 251 + PlSqlParserRULE_index_subpartition_subclause = 252 + PlSqlParserRULE_odci_parameters = 253 + PlSqlParserRULE_indextype = 254 + PlSqlParserRULE_alter_index = 255 + PlSqlParserRULE_alter_index_ops_set1 = 256 + PlSqlParserRULE_alter_index_ops_set2 = 257 + PlSqlParserRULE_visible_or_invisible = 258 + PlSqlParserRULE_monitoring_nomonitoring = 259 + PlSqlParserRULE_rebuild_clause = 260 + PlSqlParserRULE_alter_index_partitioning = 261 + PlSqlParserRULE_modify_index_default_attrs = 262 + PlSqlParserRULE_add_hash_index_partition = 263 + PlSqlParserRULE_coalesce_index_partition = 264 + PlSqlParserRULE_modify_index_partition = 265 + PlSqlParserRULE_modify_index_partitions_ops = 266 + PlSqlParserRULE_rename_index_partition = 267 + PlSqlParserRULE_drop_index_partition = 268 + PlSqlParserRULE_split_index_partition = 269 + PlSqlParserRULE_index_partition_description = 270 + PlSqlParserRULE_modify_index_subpartition = 271 + PlSqlParserRULE_partition_name_old = 272 + PlSqlParserRULE_new_partition_name = 273 + PlSqlParserRULE_new_index_name = 274 + PlSqlParserRULE_alter_inmemory_join_group = 275 + PlSqlParserRULE_create_user = 276 + PlSqlParserRULE_alter_user = 277 + PlSqlParserRULE_drop_user = 278 + PlSqlParserRULE_alter_identified_by = 279 + PlSqlParserRULE_identified_by = 280 + PlSqlParserRULE_identified_other_clause = 281 + PlSqlParserRULE_user_tablespace_clause = 282 + PlSqlParserRULE_quota_clause = 283 + PlSqlParserRULE_profile_clause = 284 + PlSqlParserRULE_role_clause = 285 + PlSqlParserRULE_user_default_role_clause = 286 + PlSqlParserRULE_password_expire_clause = 287 + PlSqlParserRULE_user_lock_clause = 288 + PlSqlParserRULE_user_editions_clause = 289 + PlSqlParserRULE_alter_user_editions_clause = 290 + PlSqlParserRULE_proxy_clause = 291 + PlSqlParserRULE_container_names = 292 + PlSqlParserRULE_set_container_data = 293 + PlSqlParserRULE_add_rem_container_data = 294 + PlSqlParserRULE_container_data_clause = 295 + PlSqlParserRULE_administer_key_management = 296 + PlSqlParserRULE_keystore_management_clauses = 297 + PlSqlParserRULE_create_keystore = 298 + PlSqlParserRULE_open_keystore = 299 + PlSqlParserRULE_force_keystore = 300 + PlSqlParserRULE_close_keystore = 301 + PlSqlParserRULE_backup_keystore = 302 + PlSqlParserRULE_alter_keystore_password = 303 + PlSqlParserRULE_merge_into_new_keystore = 304 + PlSqlParserRULE_merge_into_existing_keystore = 305 + PlSqlParserRULE_isolate_keystore = 306 + PlSqlParserRULE_unite_keystore = 307 + PlSqlParserRULE_key_management_clauses = 308 + PlSqlParserRULE_set_key = 309 + PlSqlParserRULE_create_key = 310 + PlSqlParserRULE_mkid = 311 + PlSqlParserRULE_mk = 312 + PlSqlParserRULE_use_key = 313 + PlSqlParserRULE_set_key_tag = 314 + PlSqlParserRULE_export_keys = 315 + PlSqlParserRULE_import_keys = 316 + PlSqlParserRULE_migrate_keys = 317 + PlSqlParserRULE_reverse_migrate_keys = 318 + PlSqlParserRULE_move_keys = 319 + PlSqlParserRULE_identified_by_store = 320 + PlSqlParserRULE_using_algorithm_clause = 321 + PlSqlParserRULE_using_tag_clause = 322 + PlSqlParserRULE_secret_management_clauses = 323 + PlSqlParserRULE_add_update_secret = 324 + PlSqlParserRULE_delete_secret = 325 + PlSqlParserRULE_add_update_secret_seps = 326 + PlSqlParserRULE_delete_secret_seps = 327 + PlSqlParserRULE_zero_downtime_software_patching_clauses = 328 + PlSqlParserRULE_with_backup_clause = 329 + PlSqlParserRULE_identified_by_password_clause = 330 + PlSqlParserRULE_keystore_password = 331 + PlSqlParserRULE_path = 332 + PlSqlParserRULE_secret = 333 + PlSqlParserRULE_analyze = 334 + PlSqlParserRULE_partition_extention_clause = 335 + PlSqlParserRULE_validation_clauses = 336 + PlSqlParserRULE_compute_clauses = 337 + PlSqlParserRULE_for_clause = 338 + PlSqlParserRULE_online_or_offline = 339 + PlSqlParserRULE_into_clause1 = 340 + PlSqlParserRULE_partition_key_value = 341 + PlSqlParserRULE_subpartition_key_value = 342 + PlSqlParserRULE_associate_statistics = 343 + PlSqlParserRULE_column_association = 344 + PlSqlParserRULE_function_association = 345 + PlSqlParserRULE_indextype_name = 346 + PlSqlParserRULE_using_statistics_type = 347 + PlSqlParserRULE_statistics_type_name = 348 + PlSqlParserRULE_default_cost_clause = 349 + PlSqlParserRULE_cpu_cost = 350 + PlSqlParserRULE_io_cost = 351 + PlSqlParserRULE_network_cost = 352 + PlSqlParserRULE_default_selectivity_clause = 353 + PlSqlParserRULE_default_selectivity = 354 + PlSqlParserRULE_storage_table_clause = 355 + PlSqlParserRULE_unified_auditing = 356 + PlSqlParserRULE_policy_name = 357 + PlSqlParserRULE_audit_traditional = 358 + PlSqlParserRULE_audit_direct_path = 359 + PlSqlParserRULE_audit_container_clause = 360 + PlSqlParserRULE_audit_operation_clause = 361 + PlSqlParserRULE_auditing_by_clause = 362 + PlSqlParserRULE_audit_user = 363 + PlSqlParserRULE_audit_schema_object_clause = 364 + PlSqlParserRULE_sql_operation = 365 + PlSqlParserRULE_auditing_on_clause = 366 + PlSqlParserRULE_model_name = 367 + PlSqlParserRULE_object_name = 368 + PlSqlParserRULE_profile_name = 369 + PlSqlParserRULE_sql_statement_shortcut = 370 + PlSqlParserRULE_drop_index = 371 + PlSqlParserRULE_disassociate_statistics = 372 + PlSqlParserRULE_drop_indextype = 373 + PlSqlParserRULE_drop_inmemory_join_group = 374 + PlSqlParserRULE_flashback_table = 375 + PlSqlParserRULE_restore_point = 376 + PlSqlParserRULE_purge_statement = 377 + PlSqlParserRULE_noaudit_statement = 378 + PlSqlParserRULE_rename_object = 379 + PlSqlParserRULE_grant_statement = 380 + PlSqlParserRULE_container_clause = 381 + PlSqlParserRULE_revoke_statement = 382 + PlSqlParserRULE_revoke_system_privilege = 383 + PlSqlParserRULE_revokee_clause = 384 + PlSqlParserRULE_revoke_object_privileges = 385 + PlSqlParserRULE_on_object_clause = 386 + PlSqlParserRULE_revoke_roles_from_programs = 387 + PlSqlParserRULE_program_unit = 388 + PlSqlParserRULE_create_dimension = 389 + PlSqlParserRULE_create_directory = 390 + PlSqlParserRULE_directory_name = 391 + PlSqlParserRULE_directory_path = 392 + PlSqlParserRULE_create_inmemory_join_group = 393 + PlSqlParserRULE_drop_hierarchy = 394 + PlSqlParserRULE_alter_library = 395 + PlSqlParserRULE_drop_java = 396 + PlSqlParserRULE_drop_library = 397 + PlSqlParserRULE_create_java = 398 + PlSqlParserRULE_create_library = 399 + PlSqlParserRULE_plsql_library_source = 400 + PlSqlParserRULE_credential_name = 401 + PlSqlParserRULE_library_editionable = 402 + PlSqlParserRULE_library_debug = 403 + PlSqlParserRULE_compiler_parameters_clause = 404 + PlSqlParserRULE_parameter_value = 405 + PlSqlParserRULE_library_name = 406 + PlSqlParserRULE_alter_dimension = 407 + PlSqlParserRULE_level_clause = 408 + PlSqlParserRULE_hierarchy_clause = 409 + PlSqlParserRULE_dimension_join_clause = 410 + PlSqlParserRULE_attribute_clause = 411 + PlSqlParserRULE_extended_attribute_clause = 412 + PlSqlParserRULE_column_one_or_more_sub_clause = 413 + PlSqlParserRULE_alter_view = 414 + PlSqlParserRULE_alter_view_editionable = 415 + PlSqlParserRULE_create_view = 416 + PlSqlParserRULE_editioning_clause = 417 + PlSqlParserRULE_view_options = 418 + PlSqlParserRULE_view_alias_constraint = 419 + PlSqlParserRULE_object_view_clause = 420 + PlSqlParserRULE_inline_constraint = 421 + PlSqlParserRULE_inline_ref_constraint = 422 + PlSqlParserRULE_out_of_line_ref_constraint = 423 + PlSqlParserRULE_out_of_line_constraint = 424 + PlSqlParserRULE_constraint_state = 425 + PlSqlParserRULE_xmltype_view_clause = 426 + PlSqlParserRULE_xml_schema_spec = 427 + PlSqlParserRULE_xml_schema_url = 428 + PlSqlParserRULE_element = 429 + PlSqlParserRULE_alter_tablespace = 430 + PlSqlParserRULE_datafile_tempfile_clauses = 431 + PlSqlParserRULE_tablespace_logging_clauses = 432 + PlSqlParserRULE_tablespace_group_clause = 433 + PlSqlParserRULE_tablespace_group_name = 434 + PlSqlParserRULE_tablespace_state_clauses = 435 + PlSqlParserRULE_flashback_mode_clause = 436 + PlSqlParserRULE_new_tablespace_name = 437 + PlSqlParserRULE_create_tablespace = 438 + PlSqlParserRULE_permanent_tablespace_clause = 439 + PlSqlParserRULE_tablespace_encryption_spec = 440 + PlSqlParserRULE_logging_clause = 441 + PlSqlParserRULE_extent_management_clause = 442 + PlSqlParserRULE_segment_management_clause = 443 + PlSqlParserRULE_temporary_tablespace_clause = 444 + PlSqlParserRULE_undo_tablespace_clause = 445 + PlSqlParserRULE_tablespace_retention_clause = 446 + PlSqlParserRULE_create_tablespace_set = 447 + PlSqlParserRULE_permanent_tablespace_attrs = 448 + PlSqlParserRULE_tablespace_encryption_clause = 449 + PlSqlParserRULE_default_tablespace_params = 450 + PlSqlParserRULE_default_table_compression = 451 + PlSqlParserRULE_low_high = 452 + PlSqlParserRULE_default_index_compression = 453 + PlSqlParserRULE_inmmemory_clause = 454 + PlSqlParserRULE_datafile_specification = 455 + PlSqlParserRULE_tempfile_specification = 456 + PlSqlParserRULE_datafile_tempfile_spec = 457 + PlSqlParserRULE_redo_log_file_spec = 458 + PlSqlParserRULE_autoextend_clause = 459 + PlSqlParserRULE_maxsize_clause = 460 + PlSqlParserRULE_build_clause = 461 + PlSqlParserRULE_partial_index_clause = 462 + PlSqlParserRULE_parallel_clause = 463 + PlSqlParserRULE_alter_materialized_view = 464 + PlSqlParserRULE_alter_mv_option1 = 465 + PlSqlParserRULE_alter_mv_refresh = 466 + PlSqlParserRULE_rollback_segment = 467 + PlSqlParserRULE_modify_mv_column_clause = 468 + PlSqlParserRULE_alter_materialized_view_log = 469 + PlSqlParserRULE_add_mv_log_column_clause = 470 + PlSqlParserRULE_move_mv_log_clause = 471 + PlSqlParserRULE_mv_log_augmentation = 472 + PlSqlParserRULE_datetime_expr = 473 + PlSqlParserRULE_interval_expr = 474 + PlSqlParserRULE_synchronous_or_asynchronous = 475 + PlSqlParserRULE_including_or_excluding = 476 + PlSqlParserRULE_create_materialized_view_log = 477 + PlSqlParserRULE_new_values_clause = 478 + PlSqlParserRULE_mv_log_purge_clause = 479 + PlSqlParserRULE_create_materialized_zonemap = 480 + PlSqlParserRULE_alter_materialized_zonemap = 481 + PlSqlParserRULE_drop_materialized_zonemap = 482 + PlSqlParserRULE_zonemap_refresh_clause = 483 + PlSqlParserRULE_zonemap_attributes = 484 + PlSqlParserRULE_zonemap_name = 485 + PlSqlParserRULE_operator_name = 486 + PlSqlParserRULE_operator_function_name = 487 + PlSqlParserRULE_create_zonemap_on_table = 488 + PlSqlParserRULE_create_zonemap_as_subquery = 489 + PlSqlParserRULE_alter_operator = 490 + PlSqlParserRULE_drop_operator = 491 + PlSqlParserRULE_create_operator = 492 + PlSqlParserRULE_binding_clause = 493 + PlSqlParserRULE_add_binding_clause = 494 + PlSqlParserRULE_implementation_clause = 495 + PlSqlParserRULE_primary_operator_list = 496 + PlSqlParserRULE_primary_operator_item = 497 + PlSqlParserRULE_operator_context_clause = 498 + PlSqlParserRULE_using_function_clause = 499 + PlSqlParserRULE_drop_binding_clause = 500 + PlSqlParserRULE_create_materialized_view = 501 + PlSqlParserRULE_scoped_table_ref_constraint = 502 + PlSqlParserRULE_mv_column_alias = 503 + PlSqlParserRULE_create_mv_refresh = 504 + PlSqlParserRULE_drop_materialized_view = 505 + PlSqlParserRULE_create_context = 506 + PlSqlParserRULE_oracle_namespace = 507 + PlSqlParserRULE_create_cluster = 508 + PlSqlParserRULE_create_profile = 509 + PlSqlParserRULE_resource_parameters = 510 + PlSqlParserRULE_password_parameters = 511 + PlSqlParserRULE_create_lockdown_profile = 512 + PlSqlParserRULE_static_base_profile = 513 + PlSqlParserRULE_dynamic_base_profile = 514 + PlSqlParserRULE_create_outline = 515 + PlSqlParserRULE_create_restore_point = 516 + PlSqlParserRULE_create_role = 517 + PlSqlParserRULE_create_table = 518 + PlSqlParserRULE_xmltype_table = 519 + PlSqlParserRULE_xmltype_virtual_columns = 520 + PlSqlParserRULE_xmltype_column_properties = 521 + PlSqlParserRULE_xmltype_storage = 522 + PlSqlParserRULE_xmlschema_spec = 523 + PlSqlParserRULE_object_table = 524 + PlSqlParserRULE_object_type = 525 + PlSqlParserRULE_oid_index_clause = 526 + PlSqlParserRULE_oid_clause = 527 + PlSqlParserRULE_object_properties = 528 + PlSqlParserRULE_object_table_substitution = 529 + PlSqlParserRULE_relational_table = 530 + PlSqlParserRULE_immutable_table_clauses = 531 + PlSqlParserRULE_immutable_table_no_drop_clause = 532 + PlSqlParserRULE_immutable_table_no_delete_clause = 533 + PlSqlParserRULE_blockchain_table_clauses = 534 + PlSqlParserRULE_blockchain_drop_table_clause = 535 + PlSqlParserRULE_blockchain_row_retention_clause = 536 + PlSqlParserRULE_blockchain_hash_and_data_format_clause = 537 + PlSqlParserRULE_collation_name = 538 + PlSqlParserRULE_table_properties = 539 + PlSqlParserRULE_read_only_clause = 540 + PlSqlParserRULE_indexing_clause = 541 + PlSqlParserRULE_attribute_clustering_clause = 542 + PlSqlParserRULE_clustering_join = 543 + PlSqlParserRULE_clustering_join_item = 544 + PlSqlParserRULE_equijoin_condition = 545 + PlSqlParserRULE_cluster_clause = 546 + PlSqlParserRULE_clustering_columns = 547 + PlSqlParserRULE_clustering_column_group = 548 + PlSqlParserRULE_yes_no = 549 + PlSqlParserRULE_zonemap_clause = 550 + PlSqlParserRULE_logical_replication_clause = 551 + PlSqlParserRULE_table_name = 552 + PlSqlParserRULE_relational_property = 553 + PlSqlParserRULE_table_partitioning_clauses = 554 + PlSqlParserRULE_range_partitions = 555 + PlSqlParserRULE_list_partitions = 556 + PlSqlParserRULE_hash_partitions = 557 + PlSqlParserRULE_individual_hash_partitions = 558 + PlSqlParserRULE_hash_partitions_by_quantity = 559 + PlSqlParserRULE_hash_partition_quantity = 560 + PlSqlParserRULE_composite_range_partitions = 561 + PlSqlParserRULE_composite_list_partitions = 562 + PlSqlParserRULE_composite_hash_partitions = 563 + PlSqlParserRULE_reference_partitioning = 564 + PlSqlParserRULE_reference_partition_desc = 565 + PlSqlParserRULE_system_partitioning = 566 + PlSqlParserRULE_range_partition_desc = 567 + PlSqlParserRULE_list_partition_desc = 568 + PlSqlParserRULE_subpartition_template = 569 + PlSqlParserRULE_hash_subpartition_quantity = 570 + PlSqlParserRULE_subpartition_by_range = 571 + PlSqlParserRULE_subpartition_by_list = 572 + PlSqlParserRULE_subpartition_by_hash = 573 + PlSqlParserRULE_subpartition_name = 574 + PlSqlParserRULE_range_subpartition_desc = 575 + PlSqlParserRULE_list_subpartition_desc = 576 + PlSqlParserRULE_individual_hash_subparts = 577 + PlSqlParserRULE_hash_subparts_by_quantity = 578 + PlSqlParserRULE_range_values_clause = 579 + PlSqlParserRULE_list_values_clause = 580 + PlSqlParserRULE_table_partition_description = 581 + PlSqlParserRULE_partitioning_storage_clause = 582 + PlSqlParserRULE_lob_partitioning_storage = 583 + PlSqlParserRULE_datatype_null_enable = 584 + PlSqlParserRULE_size_clause = 585 + PlSqlParserRULE_table_compression = 586 + PlSqlParserRULE_inmemory_table_clause = 587 + PlSqlParserRULE_inmemory_attributes = 588 + PlSqlParserRULE_inmemory_memcompress = 589 + PlSqlParserRULE_inmemory_priority = 590 + PlSqlParserRULE_inmemory_distribute = 591 + PlSqlParserRULE_inmemory_duplicate = 592 + PlSqlParserRULE_inmemory_column_clause = 593 + PlSqlParserRULE_physical_attributes_clause = 594 + PlSqlParserRULE_storage_clause = 595 + PlSqlParserRULE_deferred_segment_creation = 596 + PlSqlParserRULE_segment_attributes_clause = 597 + PlSqlParserRULE_physical_properties = 598 + PlSqlParserRULE_ilm_clause = 599 + PlSqlParserRULE_ilm_policy_clause = 600 + PlSqlParserRULE_ilm_compression_policy = 601 + PlSqlParserRULE_ilm_tiering_policy = 602 + PlSqlParserRULE_ilm_after_on = 603 + PlSqlParserRULE_segment_group = 604 + PlSqlParserRULE_ilm_inmemory_policy = 605 + PlSqlParserRULE_ilm_time_period = 606 + PlSqlParserRULE_heap_org_table_clause = 607 + PlSqlParserRULE_external_table_clause = 608 + PlSqlParserRULE_access_driver_type = 609 + PlSqlParserRULE_external_table_data_props = 610 + PlSqlParserRULE_opaque_format_spec = 611 + PlSqlParserRULE_record_format_info = 612 + PlSqlParserRULE_et_string = 613 + PlSqlParserRULE_et_record_spec_options = 614 + PlSqlParserRULE_et_record_spec_option = 615 + PlSqlParserRULE_et_output_files = 616 + PlSqlParserRULE_et_output_file = 617 + PlSqlParserRULE_directory_spec = 618 + PlSqlParserRULE_file_spec = 619 + PlSqlParserRULE_field_definitions = 620 + PlSqlParserRULE_field_options = 621 + PlSqlParserRULE_field_option = 622 + PlSqlParserRULE_field_list = 623 + PlSqlParserRULE_field_item = 624 + PlSqlParserRULE_field_name = 625 + PlSqlParserRULE_pos_spec = 626 + PlSqlParserRULE_pos_start = 627 + PlSqlParserRULE_pos_increment = 628 + PlSqlParserRULE_pos_end = 629 + PlSqlParserRULE_pos_length = 630 + PlSqlParserRULE_datatype_spec = 631 + PlSqlParserRULE_init_spec = 632 + PlSqlParserRULE_lls_clause = 633 + PlSqlParserRULE_delim_spec = 634 + PlSqlParserRULE_trim_spec = 635 + PlSqlParserRULE_field_date_format = 636 + PlSqlParserRULE_column_transforms = 637 + PlSqlParserRULE_transform = 638 + PlSqlParserRULE_source_field = 639 + PlSqlParserRULE_lobfile_item = 640 + PlSqlParserRULE_lobfile_attr_list = 641 + PlSqlParserRULE_concat_item = 642 + PlSqlParserRULE_row_movement_clause = 643 + PlSqlParserRULE_flashback_archive_clause = 644 + PlSqlParserRULE_log_grp = 645 + PlSqlParserRULE_supplemental_table_logging = 646 + PlSqlParserRULE_supplemental_log_grp_clause = 647 + PlSqlParserRULE_supplemental_id_key_clause = 648 + PlSqlParserRULE_allocate_extent_clause = 649 + PlSqlParserRULE_deallocate_unused_clause = 650 + PlSqlParserRULE_shrink_clause = 651 + PlSqlParserRULE_records_per_block_clause = 652 + PlSqlParserRULE_upgrade_table_clause = 653 + PlSqlParserRULE_truncate_table = 654 + PlSqlParserRULE_drop_table = 655 + PlSqlParserRULE_drop_tablespace = 656 + PlSqlParserRULE_drop_tablespace_set = 657 + PlSqlParserRULE_including_contents_clause = 658 + PlSqlParserRULE_drop_view = 659 + PlSqlParserRULE_comment_on_column = 660 + PlSqlParserRULE_enable_or_disable = 661 + PlSqlParserRULE_allow_or_disallow = 662 + PlSqlParserRULE_alter_synonym = 663 + PlSqlParserRULE_create_synonym = 664 + PlSqlParserRULE_drop_synonym = 665 + PlSqlParserRULE_create_spfile = 666 + PlSqlParserRULE_spfile_name = 667 + PlSqlParserRULE_pfile_name = 668 + PlSqlParserRULE_comment_on_table = 669 + PlSqlParserRULE_comment_on_materialized = 670 + PlSqlParserRULE_alter_analytic_view = 671 + PlSqlParserRULE_alter_add_cache_clause = 672 + PlSqlParserRULE_levels_item = 673 + PlSqlParserRULE_measure_list = 674 + PlSqlParserRULE_alter_drop_cache_clause = 675 + PlSqlParserRULE_alter_attribute_dimension = 676 + PlSqlParserRULE_alter_audit_policy = 677 + PlSqlParserRULE_alter_cluster = 678 + PlSqlParserRULE_drop_analytic_view = 679 + PlSqlParserRULE_drop_attribute_dimension = 680 + PlSqlParserRULE_drop_audit_policy = 681 + PlSqlParserRULE_drop_flashback_archive = 682 + PlSqlParserRULE_drop_cluster = 683 + PlSqlParserRULE_drop_context = 684 + PlSqlParserRULE_drop_directory = 685 + PlSqlParserRULE_drop_diskgroup = 686 + PlSqlParserRULE_drop_edition = 687 + PlSqlParserRULE_truncate_cluster = 688 + PlSqlParserRULE_cache_or_nocache = 689 + PlSqlParserRULE_database_name = 690 + PlSqlParserRULE_alter_database = 691 + PlSqlParserRULE_database_clause = 692 + PlSqlParserRULE_startup_clauses = 693 + PlSqlParserRULE_resetlogs_or_noresetlogs = 694 + PlSqlParserRULE_upgrade_or_downgrade = 695 + PlSqlParserRULE_recovery_clauses = 696 + PlSqlParserRULE_begin_or_end = 697 + PlSqlParserRULE_general_recovery = 698 + PlSqlParserRULE_full_database_recovery = 699 + PlSqlParserRULE_partial_database_recovery = 700 + PlSqlParserRULE_partial_database_recovery_10g = 701 + PlSqlParserRULE_managed_standby_recovery = 702 + PlSqlParserRULE_db_name = 703 + PlSqlParserRULE_database_file_clauses = 704 + PlSqlParserRULE_create_datafile_clause = 705 + PlSqlParserRULE_alter_datafile_clause = 706 + PlSqlParserRULE_alter_tempfile_clause = 707 + PlSqlParserRULE_move_datafile_clause = 708 + PlSqlParserRULE_logfile_clauses = 709 + PlSqlParserRULE_add_logfile_clauses = 710 + PlSqlParserRULE_group_redo_logfile = 711 + PlSqlParserRULE_drop_logfile_clauses = 712 + PlSqlParserRULE_switch_logfile_clause = 713 + PlSqlParserRULE_supplemental_db_logging = 714 + PlSqlParserRULE_add_or_drop = 715 + PlSqlParserRULE_supplemental_plsql_clause = 716 + PlSqlParserRULE_logfile_descriptor = 717 + PlSqlParserRULE_controlfile_clauses = 718 + PlSqlParserRULE_trace_file_clause = 719 + PlSqlParserRULE_standby_database_clauses = 720 + PlSqlParserRULE_activate_standby_db_clause = 721 + PlSqlParserRULE_maximize_standby_db_clause = 722 + PlSqlParserRULE_register_logfile_clause = 723 + PlSqlParserRULE_commit_switchover_clause = 724 + PlSqlParserRULE_start_standby_clause = 725 + PlSqlParserRULE_stop_standby_clause = 726 + PlSqlParserRULE_convert_database_clause = 727 + PlSqlParserRULE_default_settings_clause = 728 + PlSqlParserRULE_set_time_zone_clause = 729 + PlSqlParserRULE_instance_clauses = 730 + PlSqlParserRULE_security_clause = 731 + PlSqlParserRULE_domain = 732 + PlSqlParserRULE_database = 733 + PlSqlParserRULE_edition_name = 734 + PlSqlParserRULE_filenumber = 735 + PlSqlParserRULE_filename = 736 + PlSqlParserRULE_prepare_clause = 737 + PlSqlParserRULE_drop_mirror_clause = 738 + PlSqlParserRULE_lost_write_protection = 739 + PlSqlParserRULE_cdb_fleet_clauses = 740 + PlSqlParserRULE_lead_cdb_clause = 741 + PlSqlParserRULE_lead_cdb_uri_clause = 742 + PlSqlParserRULE_property_clauses = 743 + PlSqlParserRULE_replay_upgrade_clauses = 744 + PlSqlParserRULE_alter_database_link = 745 + PlSqlParserRULE_password_value = 746 + PlSqlParserRULE_link_authentication = 747 + PlSqlParserRULE_create_database = 748 + PlSqlParserRULE_database_logging_clauses = 749 + PlSqlParserRULE_database_logging_sub_clause = 750 + PlSqlParserRULE_tablespace_clauses = 751 + PlSqlParserRULE_enable_pluggable_database = 752 + PlSqlParserRULE_file_name_convert = 753 + PlSqlParserRULE_filename_convert_sub_clause = 754 + PlSqlParserRULE_tablespace_datafile_clauses = 755 + PlSqlParserRULE_undo_mode_clause = 756 + PlSqlParserRULE_default_tablespace = 757 + PlSqlParserRULE_default_temp_tablespace = 758 + PlSqlParserRULE_undo_tablespace = 759 + PlSqlParserRULE_drop_database = 760 + PlSqlParserRULE_create_database_link = 761 + PlSqlParserRULE_dblink = 762 + PlSqlParserRULE_drop_database_link = 763 + PlSqlParserRULE_alter_tablespace_set = 764 + PlSqlParserRULE_alter_tablespace_attrs = 765 + PlSqlParserRULE_alter_tablespace_encryption = 766 + PlSqlParserRULE_ts_file_name_convert = 767 + PlSqlParserRULE_alter_role = 768 + PlSqlParserRULE_role_identified_clause = 769 + PlSqlParserRULE_alter_table = 770 + PlSqlParserRULE_memoptimize_read_write_clause = 771 + PlSqlParserRULE_alter_table_properties = 772 + PlSqlParserRULE_alter_table_partitioning = 773 + PlSqlParserRULE_add_table_partition = 774 + PlSqlParserRULE_drop_table_partition = 775 + PlSqlParserRULE_merge_table_partition = 776 + PlSqlParserRULE_modify_table_partition = 777 + PlSqlParserRULE_split_table_partition = 778 + PlSqlParserRULE_truncate_table_partition = 779 + PlSqlParserRULE_exchange_table_partition = 780 + PlSqlParserRULE_coalesce_table_partition = 781 + PlSqlParserRULE_alter_interval_partition = 782 + PlSqlParserRULE_partition_extended_names = 783 + PlSqlParserRULE_subpartition_extended_names = 784 + PlSqlParserRULE_alter_table_properties_1 = 785 + PlSqlParserRULE_alter_iot_clauses = 786 + PlSqlParserRULE_alter_mapping_table_clause = 787 + PlSqlParserRULE_alter_overflow_clause = 788 + PlSqlParserRULE_add_overflow_clause = 789 + PlSqlParserRULE_update_index_clauses = 790 + PlSqlParserRULE_update_global_index_clause = 791 + PlSqlParserRULE_update_all_indexes_clause = 792 + PlSqlParserRULE_update_all_indexes_index_clause = 793 + PlSqlParserRULE_update_index_partition = 794 + PlSqlParserRULE_update_index_subpartition = 795 + PlSqlParserRULE_enable_disable_clause = 796 + PlSqlParserRULE_using_index_clause = 797 + PlSqlParserRULE_index_attributes = 798 + PlSqlParserRULE_sort_or_nosort = 799 + PlSqlParserRULE_exceptions_clause = 800 + PlSqlParserRULE_move_table_clause = 801 + PlSqlParserRULE_index_org_table_clause = 802 + PlSqlParserRULE_mapping_table_clause = 803 + PlSqlParserRULE_key_compression = 804 + PlSqlParserRULE_index_org_overflow_clause = 805 + PlSqlParserRULE_column_clauses = 806 + PlSqlParserRULE_modify_collection_retrieval = 807 + PlSqlParserRULE_collection_item = 808 + PlSqlParserRULE_rename_column_clause = 809 + PlSqlParserRULE_old_column_name = 810 + PlSqlParserRULE_new_column_name = 811 + PlSqlParserRULE_add_modify_drop_column_clauses = 812 + PlSqlParserRULE_drop_column_clause = 813 + PlSqlParserRULE_modify_column_clauses = 814 + PlSqlParserRULE_modify_col_visibility = 815 + PlSqlParserRULE_modify_col_properties = 816 + PlSqlParserRULE_modify_col_substitutable = 817 + PlSqlParserRULE_add_column_clause = 818 + PlSqlParserRULE_alter_varray_col_properties = 819 + PlSqlParserRULE_varray_col_properties = 820 + PlSqlParserRULE_varray_storage_clause = 821 + PlSqlParserRULE_lob_segname = 822 + PlSqlParserRULE_lob_item = 823 + PlSqlParserRULE_lob_storage_parameters = 824 + PlSqlParserRULE_lob_storage_clause = 825 + PlSqlParserRULE_modify_lob_storage_clause = 826 + PlSqlParserRULE_modify_lob_parameters = 827 + PlSqlParserRULE_lob_parameters = 828 + PlSqlParserRULE_lob_deduplicate_clause = 829 + PlSqlParserRULE_lob_compression_clause = 830 + PlSqlParserRULE_lob_retention_clause = 831 + PlSqlParserRULE_encryption_spec = 832 + PlSqlParserRULE_tablespace = 833 + PlSqlParserRULE_varray_item = 834 + PlSqlParserRULE_column_properties = 835 + PlSqlParserRULE_lob_partition_storage = 836 + PlSqlParserRULE_period_definition = 837 + PlSqlParserRULE_start_time_column = 838 + PlSqlParserRULE_end_time_column = 839 + PlSqlParserRULE_column_definition = 840 + PlSqlParserRULE_column_collation_name = 841 + PlSqlParserRULE_identity_clause = 842 + PlSqlParserRULE_identity_options_parentheses = 843 + PlSqlParserRULE_identity_options = 844 + PlSqlParserRULE_virtual_column_definition = 845 + PlSqlParserRULE_autogenerated_sequence_definition = 846 + PlSqlParserRULE_evaluation_edition_clause = 847 + PlSqlParserRULE_out_of_line_part_storage = 848 + PlSqlParserRULE_nested_table_col_properties = 849 + PlSqlParserRULE_nested_item = 850 + PlSqlParserRULE_substitutable_column_clause = 851 + PlSqlParserRULE_partition_name = 852 + PlSqlParserRULE_supplemental_logging_props = 853 + PlSqlParserRULE_column_or_attribute = 854 + PlSqlParserRULE_object_type_col_properties = 855 + PlSqlParserRULE_constraint_clauses = 856 + PlSqlParserRULE_old_constraint_name = 857 + PlSqlParserRULE_new_constraint_name = 858 + PlSqlParserRULE_drop_constraint_clause = 859 + PlSqlParserRULE_drop_primary_key_or_unique_or_generic_clause = 860 + PlSqlParserRULE_add_constraint = 861 + PlSqlParserRULE_add_constraint_clause = 862 + PlSqlParserRULE_check_constraint = 863 + PlSqlParserRULE_drop_constraint = 864 + PlSqlParserRULE_enable_constraint = 865 + PlSqlParserRULE_disable_constraint = 866 + PlSqlParserRULE_foreign_key_clause = 867 + PlSqlParserRULE_references_clause = 868 + PlSqlParserRULE_on_delete_clause = 869 + PlSqlParserRULE_unique_key_clause = 870 + PlSqlParserRULE_primary_key_clause = 871 + PlSqlParserRULE_anonymous_block = 872 + PlSqlParserRULE_invoker_rights_clause = 873 + PlSqlParserRULE_call_spec = 874 + PlSqlParserRULE_java_spec = 875 + PlSqlParserRULE_c_spec = 876 + PlSqlParserRULE_c_agent_in_clause = 877 + PlSqlParserRULE_c_parameters_clause = 878 + PlSqlParserRULE_parameter = 879 + PlSqlParserRULE_default_value_part = 880 + PlSqlParserRULE_seq_of_declare_specs = 881 + PlSqlParserRULE_declare_spec = 882 + PlSqlParserRULE_variable_declaration = 883 + PlSqlParserRULE_subtype_declaration = 884 + PlSqlParserRULE_cursor_declaration = 885 + PlSqlParserRULE_parameter_spec = 886 + PlSqlParserRULE_exception_declaration = 887 + PlSqlParserRULE_pragma_declaration = 888 + PlSqlParserRULE_record_type_def = 889 + PlSqlParserRULE_field_spec = 890 + PlSqlParserRULE_ref_cursor_type_def = 891 + PlSqlParserRULE_type_declaration = 892 + PlSqlParserRULE_table_type_def = 893 + PlSqlParserRULE_table_indexed_by_part = 894 + PlSqlParserRULE_varray_type_def = 895 + PlSqlParserRULE_seq_of_statements = 896 + PlSqlParserRULE_label_declaration = 897 + PlSqlParserRULE_statement = 898 + PlSqlParserRULE_swallow_to_semi = 899 + PlSqlParserRULE_assignment_statement = 900 + PlSqlParserRULE_continue_statement = 901 + PlSqlParserRULE_exit_statement = 902 + PlSqlParserRULE_goto_statement = 903 + PlSqlParserRULE_if_statement = 904 + PlSqlParserRULE_elsif_part = 905 + PlSqlParserRULE_else_part = 906 + PlSqlParserRULE_loop_statement = 907 + PlSqlParserRULE_cursor_loop_param = 908 + PlSqlParserRULE_forall_statement = 909 + PlSqlParserRULE_bounds_clause = 910 + PlSqlParserRULE_between_bound = 911 + PlSqlParserRULE_lower_bound = 912 + PlSqlParserRULE_upper_bound = 913 + PlSqlParserRULE_null_statement = 914 + PlSqlParserRULE_raise_statement = 915 + PlSqlParserRULE_return_statement = 916 + PlSqlParserRULE_call_statement = 917 + PlSqlParserRULE_pipe_row_statement = 918 + PlSqlParserRULE_body = 919 + PlSqlParserRULE_exception_handler = 920 + PlSqlParserRULE_trigger_block = 921 + PlSqlParserRULE_block = 922 + PlSqlParserRULE_sql_statement = 923 + PlSqlParserRULE_execute_immediate = 924 + PlSqlParserRULE_dynamic_returning_clause = 925 + PlSqlParserRULE_data_manipulation_language_statements = 926 + PlSqlParserRULE_cursor_manipulation_statements = 927 + PlSqlParserRULE_close_statement = 928 + PlSqlParserRULE_open_statement = 929 + PlSqlParserRULE_fetch_statement = 930 + PlSqlParserRULE_open_for_statement = 931 + PlSqlParserRULE_transaction_control_statements = 932 + PlSqlParserRULE_set_transaction_command = 933 + PlSqlParserRULE_set_constraint_command = 934 + PlSqlParserRULE_commit_statement = 935 + PlSqlParserRULE_write_clause = 936 + PlSqlParserRULE_rollback_statement = 937 + PlSqlParserRULE_savepoint_statement = 938 + PlSqlParserRULE_explain_statement = 939 + PlSqlParserRULE_select_only_statement = 940 + PlSqlParserRULE_select_statement = 941 + PlSqlParserRULE_subquery_factoring_clause = 942 + PlSqlParserRULE_factoring_element = 943 + PlSqlParserRULE_search_clause = 944 + PlSqlParserRULE_cycle_clause = 945 + PlSqlParserRULE_subquery = 946 + PlSqlParserRULE_subquery_basic_elements = 947 + PlSqlParserRULE_subquery_operation_part = 948 + PlSqlParserRULE_query_block = 949 + PlSqlParserRULE_selected_list = 950 + PlSqlParserRULE_from_clause = 951 + PlSqlParserRULE_select_list_elements = 952 + PlSqlParserRULE_table_wild = 953 + PlSqlParserRULE_table_ref_list = 954 + PlSqlParserRULE_table_ref = 955 + PlSqlParserRULE_table_ref_aux = 956 + PlSqlParserRULE_table_ref_aux_internal = 957 + PlSqlParserRULE_join_clause = 958 + PlSqlParserRULE_join_on_part = 959 + PlSqlParserRULE_join_using_part = 960 + PlSqlParserRULE_outer_join_type = 961 + PlSqlParserRULE_query_partition_clause = 962 + PlSqlParserRULE_flashback_query_clause = 963 + PlSqlParserRULE_pivot_clause = 964 + PlSqlParserRULE_pivot_element = 965 + PlSqlParserRULE_pivot_for_clause = 966 + PlSqlParserRULE_pivot_in_clause = 967 + PlSqlParserRULE_pivot_in_clause_element = 968 + PlSqlParserRULE_pivot_in_clause_elements = 969 + PlSqlParserRULE_unpivot_clause = 970 + PlSqlParserRULE_unpivot_in_clause = 971 + PlSqlParserRULE_unpivot_in_elements = 972 + PlSqlParserRULE_hierarchical_query_clause = 973 + PlSqlParserRULE_start_part = 974 + PlSqlParserRULE_group_by_clause = 975 + PlSqlParserRULE_group_by_elements = 976 + PlSqlParserRULE_rollup_cube_clause = 977 + PlSqlParserRULE_grouping_sets_clause = 978 + PlSqlParserRULE_grouping_sets_elements = 979 + PlSqlParserRULE_having_clause = 980 + PlSqlParserRULE_model_clause = 981 + PlSqlParserRULE_cell_reference_options = 982 + PlSqlParserRULE_return_rows_clause = 983 + PlSqlParserRULE_reference_model = 984 + PlSqlParserRULE_main_model = 985 + PlSqlParserRULE_model_column_clauses = 986 + PlSqlParserRULE_model_column_partition_part = 987 + PlSqlParserRULE_model_column_list = 988 + PlSqlParserRULE_model_column = 989 + PlSqlParserRULE_model_rules_clause = 990 + PlSqlParserRULE_model_rules_part = 991 + PlSqlParserRULE_model_rules_element = 992 + PlSqlParserRULE_cell_assignment = 993 + PlSqlParserRULE_model_iterate_clause = 994 + PlSqlParserRULE_until_part = 995 + PlSqlParserRULE_order_by_clause = 996 + PlSqlParserRULE_order_by_elements = 997 + PlSqlParserRULE_offset_clause = 998 + PlSqlParserRULE_fetch_clause = 999 + PlSqlParserRULE_for_update_clause = 1000 + PlSqlParserRULE_for_update_of_part = 1001 + PlSqlParserRULE_for_update_options = 1002 + PlSqlParserRULE_update_statement = 1003 + PlSqlParserRULE_update_set_clause = 1004 + PlSqlParserRULE_column_based_update_set_clause = 1005 + PlSqlParserRULE_delete_statement = 1006 + PlSqlParserRULE_insert_statement = 1007 + PlSqlParserRULE_single_table_insert = 1008 + PlSqlParserRULE_multi_table_insert = 1009 + PlSqlParserRULE_multi_table_element = 1010 + PlSqlParserRULE_conditional_insert_clause = 1011 + PlSqlParserRULE_conditional_insert_when_part = 1012 + PlSqlParserRULE_conditional_insert_else_part = 1013 + PlSqlParserRULE_insert_into_clause = 1014 + PlSqlParserRULE_values_clause = 1015 + PlSqlParserRULE_merge_statement = 1016 + PlSqlParserRULE_merge_update_clause = 1017 + PlSqlParserRULE_merge_element = 1018 + PlSqlParserRULE_merge_update_delete_part = 1019 + PlSqlParserRULE_merge_insert_clause = 1020 + PlSqlParserRULE_selected_tableview = 1021 + PlSqlParserRULE_lock_table_statement = 1022 + PlSqlParserRULE_wait_nowait_part = 1023 + PlSqlParserRULE_lock_table_element = 1024 + PlSqlParserRULE_lock_mode = 1025 + PlSqlParserRULE_general_table_ref = 1026 + PlSqlParserRULE_static_returning_clause = 1027 + PlSqlParserRULE_error_logging_clause = 1028 + PlSqlParserRULE_error_logging_into_part = 1029 + PlSqlParserRULE_error_logging_reject_part = 1030 + PlSqlParserRULE_dml_table_expression_clause = 1031 + PlSqlParserRULE_table_collection_expression = 1032 + PlSqlParserRULE_subquery_restriction_clause = 1033 + PlSqlParserRULE_sample_clause = 1034 + PlSqlParserRULE_seed_part = 1035 + PlSqlParserRULE_condition = 1036 + PlSqlParserRULE_json_condition = 1037 + PlSqlParserRULE_expressions = 1038 + PlSqlParserRULE_expression = 1039 + PlSqlParserRULE_cursor_expression = 1040 + PlSqlParserRULE_logical_expression = 1041 + PlSqlParserRULE_unary_logical_expression = 1042 + PlSqlParserRULE_logical_operation = 1043 + PlSqlParserRULE_multiset_expression = 1044 + PlSqlParserRULE_relational_expression = 1045 + PlSqlParserRULE_compound_expression = 1046 + PlSqlParserRULE_relational_operator = 1047 + PlSqlParserRULE_in_elements = 1048 + PlSqlParserRULE_between_elements = 1049 + PlSqlParserRULE_concatenation = 1050 + PlSqlParserRULE_interval_expression = 1051 + PlSqlParserRULE_model_expression = 1052 + PlSqlParserRULE_model_expression_element = 1053 + PlSqlParserRULE_single_column_for_loop = 1054 + PlSqlParserRULE_multi_column_for_loop = 1055 + PlSqlParserRULE_unary_expression = 1056 + PlSqlParserRULE_case_statement = 1057 + PlSqlParserRULE_simple_case_statement = 1058 + PlSqlParserRULE_simple_case_when_part = 1059 + PlSqlParserRULE_searched_case_statement = 1060 + PlSqlParserRULE_searched_case_when_part = 1061 + PlSqlParserRULE_case_else_part = 1062 + PlSqlParserRULE_atom = 1063 + PlSqlParserRULE_quantified_expression = 1064 + PlSqlParserRULE_string_function = 1065 + PlSqlParserRULE_standard_function = 1066 + PlSqlParserRULE_json_function = 1067 + PlSqlParserRULE_json_object_content = 1068 + PlSqlParserRULE_json_object_entry = 1069 + PlSqlParserRULE_json_table_clause = 1070 + PlSqlParserRULE_json_array_element = 1071 + PlSqlParserRULE_json_on_null_clause = 1072 + PlSqlParserRULE_json_return_clause = 1073 + PlSqlParserRULE_json_transform_op = 1074 + PlSqlParserRULE_json_column_clause = 1075 + PlSqlParserRULE_json_column_definition = 1076 + PlSqlParserRULE_json_query_returning_clause = 1077 + PlSqlParserRULE_json_query_return_type = 1078 + PlSqlParserRULE_json_query_wrapper_clause = 1079 + PlSqlParserRULE_json_query_on_error_clause = 1080 + PlSqlParserRULE_json_query_on_empty_clause = 1081 + PlSqlParserRULE_json_value_return_clause = 1082 + PlSqlParserRULE_json_value_return_type = 1083 + PlSqlParserRULE_json_value_on_mismatch_clause = 1084 + PlSqlParserRULE_literal = 1085 + PlSqlParserRULE_numeric_function_wrapper = 1086 + PlSqlParserRULE_numeric_function = 1087 + PlSqlParserRULE_listagg_overflow_clause = 1088 + PlSqlParserRULE_other_function = 1089 + PlSqlParserRULE_over_clause_keyword = 1090 + PlSqlParserRULE_within_or_over_clause_keyword = 1091 + PlSqlParserRULE_standard_prediction_function_keyword = 1092 + PlSqlParserRULE_over_clause = 1093 + PlSqlParserRULE_windowing_clause = 1094 + PlSqlParserRULE_windowing_type = 1095 + PlSqlParserRULE_windowing_elements = 1096 + PlSqlParserRULE_using_clause = 1097 + PlSqlParserRULE_using_element = 1098 + PlSqlParserRULE_collect_order_by_part = 1099 + PlSqlParserRULE_within_or_over_part = 1100 + PlSqlParserRULE_cost_matrix_clause = 1101 + PlSqlParserRULE_xml_passing_clause = 1102 + PlSqlParserRULE_xml_attributes_clause = 1103 + PlSqlParserRULE_xml_namespaces_clause = 1104 + PlSqlParserRULE_xml_table_column = 1105 + PlSqlParserRULE_xml_general_default_part = 1106 + PlSqlParserRULE_xml_multiuse_expression_element = 1107 + PlSqlParserRULE_xmlroot_param_version_part = 1108 + PlSqlParserRULE_xmlroot_param_standalone_part = 1109 + PlSqlParserRULE_xmlserialize_param_enconding_part = 1110 + PlSqlParserRULE_xmlserialize_param_version_part = 1111 + PlSqlParserRULE_xmlserialize_param_ident_part = 1112 + PlSqlParserRULE_sql_plus_command = 1113 + PlSqlParserRULE_whenever_command = 1114 + PlSqlParserRULE_set_command = 1115 + PlSqlParserRULE_timing_command = 1116 + PlSqlParserRULE_partition_extension_clause = 1117 + PlSqlParserRULE_column_alias = 1118 + PlSqlParserRULE_table_alias = 1119 + PlSqlParserRULE_where_clause = 1120 + PlSqlParserRULE_quantitative_where_stmt = 1121 + PlSqlParserRULE_into_clause = 1122 + PlSqlParserRULE_xml_column_name = 1123 + PlSqlParserRULE_cost_class_name = 1124 + PlSqlParserRULE_attribute_name = 1125 + PlSqlParserRULE_savepoint_name = 1126 + PlSqlParserRULE_rollback_segment_name = 1127 + PlSqlParserRULE_table_var_name = 1128 + PlSqlParserRULE_schema_name = 1129 + PlSqlParserRULE_routine_name = 1130 + PlSqlParserRULE_package_name = 1131 + PlSqlParserRULE_implementation_type_name = 1132 + PlSqlParserRULE_parameter_name = 1133 + PlSqlParserRULE_reference_model_name = 1134 + PlSqlParserRULE_main_model_name = 1135 + PlSqlParserRULE_container_tableview_name = 1136 + PlSqlParserRULE_aggregate_function_name = 1137 + PlSqlParserRULE_query_name = 1138 + PlSqlParserRULE_grantee_name = 1139 + PlSqlParserRULE_role_name = 1140 + PlSqlParserRULE_constraint_name = 1141 + PlSqlParserRULE_label_name = 1142 + PlSqlParserRULE_type_name = 1143 + PlSqlParserRULE_sequence_name = 1144 + PlSqlParserRULE_exception_name = 1145 + PlSqlParserRULE_function_name = 1146 + PlSqlParserRULE_procedure_name = 1147 + PlSqlParserRULE_trigger_name = 1148 + PlSqlParserRULE_variable_name = 1149 + PlSqlParserRULE_index_name = 1150 + PlSqlParserRULE_cursor_name = 1151 + PlSqlParserRULE_record_name = 1152 + PlSqlParserRULE_collection_name = 1153 + PlSqlParserRULE_link_name = 1154 + PlSqlParserRULE_column_name = 1155 + PlSqlParserRULE_tableview_name = 1156 + PlSqlParserRULE_xmltable = 1157 + PlSqlParserRULE_char_set_name = 1158 + PlSqlParserRULE_synonym_name = 1159 + PlSqlParserRULE_schema_object_name = 1160 + PlSqlParserRULE_dir_object_name = 1161 + PlSqlParserRULE_user_object_name = 1162 + PlSqlParserRULE_grant_object_name = 1163 + PlSqlParserRULE_column_list = 1164 + PlSqlParserRULE_paren_column_list = 1165 + PlSqlParserRULE_keep_clause = 1166 + PlSqlParserRULE_function_argument = 1167 + PlSqlParserRULE_function_argument_analytic = 1168 + PlSqlParserRULE_function_argument_modeling = 1169 + PlSqlParserRULE_respect_or_ignore_nulls = 1170 + PlSqlParserRULE_argument = 1171 + PlSqlParserRULE_type_spec = 1172 + PlSqlParserRULE_datatype = 1173 + PlSqlParserRULE_precision_part = 1174 + PlSqlParserRULE_native_datatype_element = 1175 + PlSqlParserRULE_bind_variable = 1176 + PlSqlParserRULE_general_element = 1177 + PlSqlParserRULE_general_element_part = 1178 + PlSqlParserRULE_table_element = 1179 + PlSqlParserRULE_object_privilege = 1180 + PlSqlParserRULE_system_privilege = 1181 + PlSqlParserRULE_constant = 1182 + PlSqlParserRULE_constant_without_variable = 1183 + PlSqlParserRULE_numeric = 1184 + PlSqlParserRULE_numeric_negative = 1185 + PlSqlParserRULE_quoted_string = 1186 + PlSqlParserRULE_char_str = 1187 + PlSqlParserRULE_identifier = 1188 + PlSqlParserRULE_id_expression = 1189 + PlSqlParserRULE_outer_join_sign = 1190 + PlSqlParserRULE_regular_id = 1191 + PlSqlParserRULE_non_reserved_keywords_in_12c = 1192 + PlSqlParserRULE_non_reserved_keywords_pre12c = 1193 + PlSqlParserRULE_string_function_name = 1194 + PlSqlParserRULE_numeric_function_name = 1195 +) + +// ISql_scriptContext is an interface to support dynamic dispatch. +type ISql_scriptContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EOF() antlr.TerminalNode + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllSql_plus_command() []ISql_plus_commandContext + Sql_plus_command(i int) ISql_plus_commandContext + AllUnit_statement() []IUnit_statementContext + Unit_statement(i int) IUnit_statementContext + + // IsSql_scriptContext differentiates from other interfaces. + IsSql_scriptContext() +} + +type Sql_scriptContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_scriptContext() *Sql_scriptContext { + var p = new(Sql_scriptContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_script + return p +} + +func InitEmptySql_scriptContext(p *Sql_scriptContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_script +} + +func (*Sql_scriptContext) IsSql_scriptContext() {} + +func NewSql_scriptContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_scriptContext { + var p = new(Sql_scriptContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_script + + return p +} + +func (s *Sql_scriptContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_scriptContext) EOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserEOF, 0) +} + +func (s *Sql_scriptContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Sql_scriptContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Sql_scriptContext) AllSql_plus_command() []ISql_plus_commandContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_plus_commandContext); ok { + len++ + } + } + + tst := make([]ISql_plus_commandContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_plus_commandContext); ok { + tst[i] = t.(ISql_plus_commandContext) + i++ + } + } + + return tst +} + +func (s *Sql_scriptContext) Sql_plus_command(i int) ISql_plus_commandContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_plus_commandContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_plus_commandContext) +} + +func (s *Sql_scriptContext) AllUnit_statement() []IUnit_statementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnit_statementContext); ok { + len++ + } + } + + tst := make([]IUnit_statementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnit_statementContext); ok { + tst[i] = t.(IUnit_statementContext) + i++ + } + } + + return tst +} + +func (s *Sql_scriptContext) Unit_statement(i int) IUnit_statementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnit_statementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnit_statementContext) +} + +func (s *Sql_scriptContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_scriptContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_scriptContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_script(s) + } +} + +func (s *Sql_scriptContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_script(s) + } +} + +func (s *Sql_scriptContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_script(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_script() (localctx ISql_scriptContext) { + localctx = NewSql_scriptContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 0, PlSqlParserRULE_sql_script) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(2402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(2400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2, p.GetParserRuleContext()) { + case 1: + p.SetState(2394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 0, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2392) + p.Sql_plus_command() + } + + case 2: + { + p.SetState(2393) + p.Unit_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(2397) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1, p.GetParserRuleContext()) == 1 { + { + p.SetState(2396) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(2399) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(2404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 3, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(2405) + p.Match(PlSqlParserEOF) + 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 +} + +// IUnit_statementContext is an interface to support dynamic dispatch. +type IUnit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_analytic_view() IAlter_analytic_viewContext + Alter_attribute_dimension() IAlter_attribute_dimensionContext + Alter_audit_policy() IAlter_audit_policyContext + Alter_cluster() IAlter_clusterContext + Alter_database() IAlter_databaseContext + Alter_database_link() IAlter_database_linkContext + Alter_dimension() IAlter_dimensionContext + Alter_diskgroup() IAlter_diskgroupContext + Alter_flashback_archive() IAlter_flashback_archiveContext + Alter_function() IAlter_functionContext + Alter_hierarchy() IAlter_hierarchyContext + Alter_index() IAlter_indexContext + Alter_inmemory_join_group() IAlter_inmemory_join_groupContext + Alter_java() IAlter_javaContext + Alter_library() IAlter_libraryContext + Alter_lockdown_profile() IAlter_lockdown_profileContext + Alter_materialized_view() IAlter_materialized_viewContext + Alter_materialized_view_log() IAlter_materialized_view_logContext + Alter_materialized_zonemap() IAlter_materialized_zonemapContext + Alter_operator() IAlter_operatorContext + Alter_outline() IAlter_outlineContext + Alter_package() IAlter_packageContext + Alter_pmem_filestore() IAlter_pmem_filestoreContext + Alter_procedure() IAlter_procedureContext + Alter_resource_cost() IAlter_resource_costContext + Alter_role() IAlter_roleContext + Alter_rollback_segment() IAlter_rollback_segmentContext + Alter_sequence() IAlter_sequenceContext + Alter_session() IAlter_sessionContext + Alter_synonym() IAlter_synonymContext + Alter_table() IAlter_tableContext + Alter_tablespace() IAlter_tablespaceContext + Alter_tablespace_set() IAlter_tablespace_setContext + Alter_trigger() IAlter_triggerContext + Alter_type() IAlter_typeContext + Alter_user() IAlter_userContext + Alter_view() IAlter_viewContext + Create_analytic_view() ICreate_analytic_viewContext + Create_attribute_dimension() ICreate_attribute_dimensionContext + Create_audit_policy() ICreate_audit_policyContext + Create_cluster() ICreate_clusterContext + Create_context() ICreate_contextContext + Create_controlfile() ICreate_controlfileContext + Create_database() ICreate_databaseContext + Create_database_link() ICreate_database_linkContext + Create_dimension() ICreate_dimensionContext + Create_directory() ICreate_directoryContext + Create_diskgroup() ICreate_diskgroupContext + Create_edition() ICreate_editionContext + Create_flashback_archive() ICreate_flashback_archiveContext + Create_function_body() ICreate_function_bodyContext + Create_hierarchy() ICreate_hierarchyContext + Create_index() ICreate_indexContext + Create_inmemory_join_group() ICreate_inmemory_join_groupContext + Create_java() ICreate_javaContext + Create_library() ICreate_libraryContext + Create_lockdown_profile() ICreate_lockdown_profileContext + Create_materialized_view() ICreate_materialized_viewContext + Create_materialized_view_log() ICreate_materialized_view_logContext + Create_materialized_zonemap() ICreate_materialized_zonemapContext + Create_operator() ICreate_operatorContext + Create_outline() ICreate_outlineContext + Create_package() ICreate_packageContext + Create_package_body() ICreate_package_bodyContext + Create_pmem_filestore() ICreate_pmem_filestoreContext + Create_procedure_body() ICreate_procedure_bodyContext + Create_profile() ICreate_profileContext + Create_restore_point() ICreate_restore_pointContext + Create_role() ICreate_roleContext + Create_rollback_segment() ICreate_rollback_segmentContext + Create_sequence() ICreate_sequenceContext + Create_spfile() ICreate_spfileContext + Create_synonym() ICreate_synonymContext + Create_table() ICreate_tableContext + Create_tablespace() ICreate_tablespaceContext + Create_tablespace_set() ICreate_tablespace_setContext + Create_trigger() ICreate_triggerContext + Create_type() ICreate_typeContext + Create_user() ICreate_userContext + Create_view() ICreate_viewContext + Drop_analytic_view() IDrop_analytic_viewContext + Drop_attribute_dimension() IDrop_attribute_dimensionContext + Drop_audit_policy() IDrop_audit_policyContext + Drop_cluster() IDrop_clusterContext + Drop_context() IDrop_contextContext + Drop_database() IDrop_databaseContext + Drop_database_link() IDrop_database_linkContext + Drop_directory() IDrop_directoryContext + Drop_diskgroup() IDrop_diskgroupContext + Drop_edition() IDrop_editionContext + Drop_flashback_archive() IDrop_flashback_archiveContext + Drop_function() IDrop_functionContext + Drop_hierarchy() IDrop_hierarchyContext + Drop_index() IDrop_indexContext + Drop_indextype() IDrop_indextypeContext + Drop_inmemory_join_group() IDrop_inmemory_join_groupContext + Drop_java() IDrop_javaContext + Drop_library() IDrop_libraryContext + Drop_lockdown_profile() IDrop_lockdown_profileContext + Drop_materialized_view() IDrop_materialized_viewContext + Drop_materialized_zonemap() IDrop_materialized_zonemapContext + Drop_operator() IDrop_operatorContext + Drop_outline() IDrop_outlineContext + Drop_package() IDrop_packageContext + Drop_pmem_filestore() IDrop_pmem_filestoreContext + Drop_procedure() IDrop_procedureContext + Drop_restore_point() IDrop_restore_pointContext + Drop_role() IDrop_roleContext + Drop_rollback_segment() IDrop_rollback_segmentContext + Drop_sequence() IDrop_sequenceContext + Drop_synonym() IDrop_synonymContext + Drop_table() IDrop_tableContext + Drop_tablespace() IDrop_tablespaceContext + Drop_tablespace_set() IDrop_tablespace_setContext + Drop_trigger() IDrop_triggerContext + Drop_type() IDrop_typeContext + Drop_user() IDrop_userContext + Drop_view() IDrop_viewContext + Administer_key_management() IAdminister_key_managementContext + Analyze() IAnalyzeContext + Anonymous_block() IAnonymous_blockContext + Associate_statistics() IAssociate_statisticsContext + Audit_traditional() IAudit_traditionalContext + Comment_on_column() IComment_on_columnContext + Comment_on_materialized() IComment_on_materializedContext + Comment_on_table() IComment_on_tableContext + Data_manipulation_language_statements() IData_manipulation_language_statementsContext + Disassociate_statistics() IDisassociate_statisticsContext + Flashback_table() IFlashback_tableContext + Grant_statement() IGrant_statementContext + Noaudit_statement() INoaudit_statementContext + Purge_statement() IPurge_statementContext + Rename_object() IRename_objectContext + Revoke_statement() IRevoke_statementContext + Transaction_control_statements() ITransaction_control_statementsContext + Truncate_cluster() ITruncate_clusterContext + Truncate_table() ITruncate_tableContext + Unified_auditing() IUnified_auditingContext + Call_statement() ICall_statementContext + + // IsUnit_statementContext differentiates from other interfaces. + IsUnit_statementContext() +} + +type Unit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnit_statementContext() *Unit_statementContext { + var p = new(Unit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unit_statement + return p +} + +func InitEmptyUnit_statementContext(p *Unit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unit_statement +} + +func (*Unit_statementContext) IsUnit_statementContext() {} + +func NewUnit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unit_statementContext { + var p = new(Unit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unit_statement + + return p +} + +func (s *Unit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unit_statementContext) Alter_analytic_view() IAlter_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_analytic_viewContext) +} + +func (s *Unit_statementContext) Alter_attribute_dimension() IAlter_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Alter_audit_policy() IAlter_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_audit_policyContext) +} + +func (s *Unit_statementContext) Alter_cluster() IAlter_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_clusterContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_database_link() IAlter_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_database_linkContext) +} + +func (s *Unit_statementContext) Alter_dimension() IAlter_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_dimensionContext) +} + +func (s *Unit_statementContext) Alter_diskgroup() IAlter_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_diskgroupContext) +} + +func (s *Unit_statementContext) Alter_flashback_archive() IAlter_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_flashback_archiveContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_hierarchy() IAlter_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_hierarchyContext) +} + +func (s *Unit_statementContext) Alter_index() IAlter_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_indexContext) +} + +func (s *Unit_statementContext) Alter_inmemory_join_group() IAlter_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Alter_java() IAlter_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_javaContext) +} + +func (s *Unit_statementContext) Alter_library() IAlter_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_libraryContext) +} + +func (s *Unit_statementContext) Alter_lockdown_profile() IAlter_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_lockdown_profileContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_materialized_view_log() IAlter_materialized_view_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_view_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_view_logContext) +} + +func (s *Unit_statementContext) Alter_materialized_zonemap() IAlter_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Alter_operator() IAlter_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_operatorContext) +} + +func (s *Unit_statementContext) Alter_outline() IAlter_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_outlineContext) +} + +func (s *Unit_statementContext) Alter_package() IAlter_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_packageContext) +} + +func (s *Unit_statementContext) Alter_pmem_filestore() IAlter_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_pmem_filestoreContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_resource_cost() IAlter_resource_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_resource_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_resource_costContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_rollback_segment() IAlter_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_rollback_segmentContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) 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 *Unit_statementContext) Alter_synonym() IAlter_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_synonymContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Alter_tablespace() IAlter_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespaceContext) +} + +func (s *Unit_statementContext) Alter_tablespace_set() IAlter_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_setContext) +} + +func (s *Unit_statementContext) Alter_trigger() IAlter_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_triggerContext) +} + +func (s *Unit_statementContext) Alter_type() IAlter_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_typeContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) 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 *Unit_statementContext) Create_analytic_view() ICreate_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_analytic_viewContext) +} + +func (s *Unit_statementContext) Create_attribute_dimension() ICreate_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Create_audit_policy() ICreate_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_audit_policyContext) +} + +func (s *Unit_statementContext) Create_cluster() ICreate_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_clusterContext) +} + +func (s *Unit_statementContext) Create_context() ICreate_contextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_contextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_contextContext) +} + +func (s *Unit_statementContext) Create_controlfile() ICreate_controlfileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_controlfileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_controlfileContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Create_database_link() ICreate_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_database_linkContext) +} + +func (s *Unit_statementContext) Create_dimension() ICreate_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_dimensionContext) +} + +func (s *Unit_statementContext) Create_directory() ICreate_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_directoryContext) +} + +func (s *Unit_statementContext) Create_diskgroup() ICreate_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_diskgroupContext) +} + +func (s *Unit_statementContext) Create_edition() ICreate_editionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_editionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_editionContext) +} + +func (s *Unit_statementContext) Create_flashback_archive() ICreate_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_flashback_archiveContext) +} + +func (s *Unit_statementContext) Create_function_body() ICreate_function_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_function_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_function_bodyContext) +} + +func (s *Unit_statementContext) Create_hierarchy() ICreate_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_hierarchyContext) +} + +func (s *Unit_statementContext) Create_index() ICreate_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_indexContext) +} + +func (s *Unit_statementContext) Create_inmemory_join_group() ICreate_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Create_java() ICreate_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_javaContext) +} + +func (s *Unit_statementContext) Create_library() ICreate_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_libraryContext) +} + +func (s *Unit_statementContext) Create_lockdown_profile() ICreate_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_lockdown_profileContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Create_materialized_view_log() ICreate_materialized_view_logContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_view_logContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_view_logContext) +} + +func (s *Unit_statementContext) Create_materialized_zonemap() ICreate_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Create_operator() ICreate_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_operatorContext) +} + +func (s *Unit_statementContext) Create_outline() ICreate_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_outlineContext) +} + +func (s *Unit_statementContext) Create_package() ICreate_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_packageContext) +} + +func (s *Unit_statementContext) Create_package_body() ICreate_package_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_package_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_package_bodyContext) +} + +func (s *Unit_statementContext) Create_pmem_filestore() ICreate_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_pmem_filestoreContext) +} + +func (s *Unit_statementContext) Create_procedure_body() ICreate_procedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_procedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_procedure_bodyContext) +} + +func (s *Unit_statementContext) Create_profile() ICreate_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_profileContext) +} + +func (s *Unit_statementContext) Create_restore_point() ICreate_restore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_restore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_restore_pointContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Create_rollback_segment() ICreate_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_rollback_segmentContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Create_spfile() ICreate_spfileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_spfileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_spfileContext) +} + +func (s *Unit_statementContext) Create_synonym() ICreate_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_synonymContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Create_tablespace() ICreate_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tablespaceContext) +} + +func (s *Unit_statementContext) Create_tablespace_set() ICreate_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_tablespace_setContext) +} + +func (s *Unit_statementContext) Create_trigger() ICreate_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_triggerContext) +} + +func (s *Unit_statementContext) Create_type() ICreate_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_typeContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) 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 *Unit_statementContext) Drop_analytic_view() IDrop_analytic_viewContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_analytic_viewContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_analytic_viewContext) +} + +func (s *Unit_statementContext) Drop_attribute_dimension() IDrop_attribute_dimensionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_attribute_dimensionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_attribute_dimensionContext) +} + +func (s *Unit_statementContext) Drop_audit_policy() IDrop_audit_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_audit_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_audit_policyContext) +} + +func (s *Unit_statementContext) Drop_cluster() IDrop_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_clusterContext) +} + +func (s *Unit_statementContext) Drop_context() IDrop_contextContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_contextContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_contextContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_database_link() IDrop_database_linkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_database_linkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_database_linkContext) +} + +func (s *Unit_statementContext) Drop_directory() IDrop_directoryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_directoryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_directoryContext) +} + +func (s *Unit_statementContext) Drop_diskgroup() IDrop_diskgroupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_diskgroupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_diskgroupContext) +} + +func (s *Unit_statementContext) Drop_edition() IDrop_editionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_editionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_editionContext) +} + +func (s *Unit_statementContext) Drop_flashback_archive() IDrop_flashback_archiveContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_flashback_archiveContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_flashback_archiveContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_hierarchy() IDrop_hierarchyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_hierarchyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_hierarchyContext) +} + +func (s *Unit_statementContext) Drop_index() IDrop_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_indexContext) +} + +func (s *Unit_statementContext) Drop_indextype() IDrop_indextypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_indextypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_indextypeContext) +} + +func (s *Unit_statementContext) Drop_inmemory_join_group() IDrop_inmemory_join_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_inmemory_join_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_inmemory_join_groupContext) +} + +func (s *Unit_statementContext) Drop_java() IDrop_javaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_javaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_javaContext) +} + +func (s *Unit_statementContext) Drop_library() IDrop_libraryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_libraryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_libraryContext) +} + +func (s *Unit_statementContext) Drop_lockdown_profile() IDrop_lockdown_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_lockdown_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_lockdown_profileContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_materialized_zonemap() IDrop_materialized_zonemapContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_materialized_zonemapContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_materialized_zonemapContext) +} + +func (s *Unit_statementContext) Drop_operator() IDrop_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_operatorContext) +} + +func (s *Unit_statementContext) Drop_outline() IDrop_outlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_outlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_outlineContext) +} + +func (s *Unit_statementContext) Drop_package() IDrop_packageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_packageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_packageContext) +} + +func (s *Unit_statementContext) Drop_pmem_filestore() IDrop_pmem_filestoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_pmem_filestoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_pmem_filestoreContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_restore_point() IDrop_restore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_restore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_restore_pointContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_rollback_segment() IDrop_rollback_segmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_rollback_segmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_rollback_segmentContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_synonym() IDrop_synonymContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_synonymContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_synonymContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Drop_tablespace() IDrop_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tablespaceContext) +} + +func (s *Unit_statementContext) Drop_tablespace_set() IDrop_tablespace_setContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_tablespace_setContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_tablespace_setContext) +} + +func (s *Unit_statementContext) Drop_trigger() IDrop_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_triggerContext) +} + +func (s *Unit_statementContext) Drop_type() IDrop_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_typeContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) 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 *Unit_statementContext) Administer_key_management() IAdminister_key_managementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdminister_key_managementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdminister_key_managementContext) +} + +func (s *Unit_statementContext) Analyze() IAnalyzeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnalyzeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnalyzeContext) +} + +func (s *Unit_statementContext) Anonymous_block() IAnonymous_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAnonymous_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAnonymous_blockContext) +} + +func (s *Unit_statementContext) Associate_statistics() IAssociate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssociate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssociate_statisticsContext) +} + +func (s *Unit_statementContext) Audit_traditional() IAudit_traditionalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_traditionalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_traditionalContext) +} + +func (s *Unit_statementContext) Comment_on_column() IComment_on_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_columnContext) +} + +func (s *Unit_statementContext) Comment_on_materialized() IComment_on_materializedContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_materializedContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_materializedContext) +} + +func (s *Unit_statementContext) Comment_on_table() IComment_on_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComment_on_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComment_on_tableContext) +} + +func (s *Unit_statementContext) Data_manipulation_language_statements() IData_manipulation_language_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_manipulation_language_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_manipulation_language_statementsContext) +} + +func (s *Unit_statementContext) Disassociate_statistics() IDisassociate_statisticsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisassociate_statisticsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisassociate_statisticsContext) +} + +func (s *Unit_statementContext) Flashback_table() IFlashback_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_tableContext) +} + +func (s *Unit_statementContext) Grant_statement() IGrant_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_statementContext) +} + +func (s *Unit_statementContext) Noaudit_statement() INoaudit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INoaudit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INoaudit_statementContext) +} + +func (s *Unit_statementContext) Purge_statement() IPurge_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPurge_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPurge_statementContext) +} + +func (s *Unit_statementContext) Rename_object() IRename_objectContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_objectContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_objectContext) +} + +func (s *Unit_statementContext) Revoke_statement() IRevoke_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_statementContext) +} + +func (s *Unit_statementContext) Transaction_control_statements() ITransaction_control_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_control_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_control_statementsContext) +} + +func (s *Unit_statementContext) Truncate_cluster() ITruncate_clusterContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_clusterContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_clusterContext) +} + +func (s *Unit_statementContext) 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 *Unit_statementContext) Unified_auditing() IUnified_auditingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnified_auditingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnified_auditingContext) +} + +func (s *Unit_statementContext) Call_statement() ICall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_statementContext) +} + +func (s *Unit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnit_statement(s) + } +} + +func (s *Unit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnit_statement(s) + } +} + +func (s *Unit_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnit_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unit_statement() (localctx IUnit_statementContext) { + localctx = NewUnit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2, PlSqlParserRULE_unit_statement) + p.SetState(2546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 4, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2407) + p.Alter_analytic_view() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2408) + p.Alter_attribute_dimension() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2409) + p.Alter_audit_policy() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2410) + p.Alter_cluster() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(2411) + p.Alter_database() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(2412) + p.Alter_database_link() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(2413) + p.Alter_dimension() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(2414) + p.Alter_diskgroup() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(2415) + p.Alter_flashback_archive() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(2416) + p.Alter_function() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(2417) + p.Alter_hierarchy() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(2418) + p.Alter_index() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(2419) + p.Alter_inmemory_join_group() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(2420) + p.Alter_java() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(2421) + p.Alter_library() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(2422) + p.Alter_lockdown_profile() + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(2423) + p.Alter_materialized_view() + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(2424) + p.Alter_materialized_view_log() + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(2425) + p.Alter_materialized_zonemap() + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(2426) + p.Alter_operator() + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(2427) + p.Alter_outline() + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(2428) + p.Alter_package() + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(2429) + p.Alter_pmem_filestore() + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(2430) + p.Alter_procedure() + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(2431) + p.Alter_resource_cost() + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(2432) + p.Alter_role() + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(2433) + p.Alter_rollback_segment() + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(2434) + p.Alter_sequence() + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(2435) + p.Alter_session() + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(2436) + p.Alter_synonym() + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(2437) + p.Alter_table() + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(2438) + p.Alter_tablespace() + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(2439) + p.Alter_tablespace_set() + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(2440) + p.Alter_trigger() + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(2441) + p.Alter_type() + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(2442) + p.Alter_user() + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(2443) + p.Alter_view() + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(2444) + p.Create_analytic_view() + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(2445) + p.Create_attribute_dimension() + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(2446) + p.Create_audit_policy() + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(2447) + p.Create_cluster() + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(2448) + p.Create_context() + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(2449) + p.Create_controlfile() + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(2450) + p.Create_database() + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(2451) + p.Create_database_link() + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(2452) + p.Create_dimension() + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(2453) + p.Create_directory() + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(2454) + p.Create_diskgroup() + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(2455) + p.Create_edition() + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(2456) + p.Create_flashback_archive() + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(2457) + p.Create_function_body() + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(2458) + p.Create_hierarchy() + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(2459) + p.Create_index() + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(2460) + p.Create_inmemory_join_group() + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(2461) + p.Create_java() + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(2462) + p.Create_library() + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(2463) + p.Create_lockdown_profile() + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(2464) + p.Create_materialized_view() + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(2465) + p.Create_materialized_view_log() + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(2466) + p.Create_materialized_zonemap() + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(2467) + p.Create_operator() + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(2468) + p.Create_outline() + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(2469) + p.Create_package() + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(2470) + p.Create_package_body() + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(2471) + p.Create_pmem_filestore() + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(2472) + p.Create_procedure_body() + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(2473) + p.Create_profile() + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(2474) + p.Create_restore_point() + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(2475) + p.Create_role() + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(2476) + p.Create_rollback_segment() + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(2477) + p.Create_sequence() + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(2478) + p.Create_spfile() + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(2479) + p.Create_synonym() + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(2480) + p.Create_table() + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(2481) + p.Create_tablespace() + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(2482) + p.Create_tablespace_set() + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(2483) + p.Create_trigger() + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(2484) + p.Create_type() + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(2485) + p.Create_user() + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(2486) + p.Create_view() + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(2487) + p.Drop_analytic_view() + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(2488) + p.Drop_attribute_dimension() + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(2489) + p.Drop_audit_policy() + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(2490) + p.Drop_cluster() + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(2491) + p.Drop_context() + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(2492) + p.Drop_database() + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(2493) + p.Drop_database_link() + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(2494) + p.Drop_directory() + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(2495) + p.Drop_diskgroup() + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(2496) + p.Drop_edition() + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(2497) + p.Drop_flashback_archive() + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(2498) + p.Drop_function() + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(2499) + p.Drop_hierarchy() + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(2500) + p.Drop_index() + } + + case 95: + p.EnterOuterAlt(localctx, 95) + { + p.SetState(2501) + p.Drop_indextype() + } + + case 96: + p.EnterOuterAlt(localctx, 96) + { + p.SetState(2502) + p.Drop_inmemory_join_group() + } + + case 97: + p.EnterOuterAlt(localctx, 97) + { + p.SetState(2503) + p.Drop_java() + } + + case 98: + p.EnterOuterAlt(localctx, 98) + { + p.SetState(2504) + p.Drop_library() + } + + case 99: + p.EnterOuterAlt(localctx, 99) + { + p.SetState(2505) + p.Drop_lockdown_profile() + } + + case 100: + p.EnterOuterAlt(localctx, 100) + { + p.SetState(2506) + p.Drop_materialized_view() + } + + case 101: + p.EnterOuterAlt(localctx, 101) + { + p.SetState(2507) + p.Drop_materialized_zonemap() + } + + case 102: + p.EnterOuterAlt(localctx, 102) + { + p.SetState(2508) + p.Drop_operator() + } + + case 103: + p.EnterOuterAlt(localctx, 103) + { + p.SetState(2509) + p.Drop_outline() + } + + case 104: + p.EnterOuterAlt(localctx, 104) + { + p.SetState(2510) + p.Drop_package() + } + + case 105: + p.EnterOuterAlt(localctx, 105) + { + p.SetState(2511) + p.Drop_pmem_filestore() + } + + case 106: + p.EnterOuterAlt(localctx, 106) + { + p.SetState(2512) + p.Drop_procedure() + } + + case 107: + p.EnterOuterAlt(localctx, 107) + { + p.SetState(2513) + p.Drop_restore_point() + } + + case 108: + p.EnterOuterAlt(localctx, 108) + { + p.SetState(2514) + p.Drop_role() + } + + case 109: + p.EnterOuterAlt(localctx, 109) + { + p.SetState(2515) + p.Drop_rollback_segment() + } + + case 110: + p.EnterOuterAlt(localctx, 110) + { + p.SetState(2516) + p.Drop_sequence() + } + + case 111: + p.EnterOuterAlt(localctx, 111) + { + p.SetState(2517) + p.Drop_synonym() + } + + case 112: + p.EnterOuterAlt(localctx, 112) + { + p.SetState(2518) + p.Drop_table() + } + + case 113: + p.EnterOuterAlt(localctx, 113) + { + p.SetState(2519) + p.Drop_tablespace() + } + + case 114: + p.EnterOuterAlt(localctx, 114) + { + p.SetState(2520) + p.Drop_tablespace_set() + } + + case 115: + p.EnterOuterAlt(localctx, 115) + { + p.SetState(2521) + p.Drop_trigger() + } + + case 116: + p.EnterOuterAlt(localctx, 116) + { + p.SetState(2522) + p.Drop_type() + } + + case 117: + p.EnterOuterAlt(localctx, 117) + { + p.SetState(2523) + p.Drop_user() + } + + case 118: + p.EnterOuterAlt(localctx, 118) + { + p.SetState(2524) + p.Drop_view() + } + + case 119: + p.EnterOuterAlt(localctx, 119) + { + p.SetState(2525) + p.Administer_key_management() + } + + case 120: + p.EnterOuterAlt(localctx, 120) + { + p.SetState(2526) + p.Analyze() + } + + case 121: + p.EnterOuterAlt(localctx, 121) + { + p.SetState(2527) + p.Anonymous_block() + } + + case 122: + p.EnterOuterAlt(localctx, 122) + { + p.SetState(2528) + p.Associate_statistics() + } + + case 123: + p.EnterOuterAlt(localctx, 123) + { + p.SetState(2529) + p.Audit_traditional() + } + + case 124: + p.EnterOuterAlt(localctx, 124) + { + p.SetState(2530) + p.Comment_on_column() + } + + case 125: + p.EnterOuterAlt(localctx, 125) + { + p.SetState(2531) + p.Comment_on_materialized() + } + + case 126: + p.EnterOuterAlt(localctx, 126) + { + p.SetState(2532) + p.Comment_on_table() + } + + case 127: + p.EnterOuterAlt(localctx, 127) + { + p.SetState(2533) + p.Data_manipulation_language_statements() + } + + case 128: + p.EnterOuterAlt(localctx, 128) + { + p.SetState(2534) + p.Disassociate_statistics() + } + + case 129: + p.EnterOuterAlt(localctx, 129) + { + p.SetState(2535) + p.Flashback_table() + } + + case 130: + p.EnterOuterAlt(localctx, 130) + { + p.SetState(2536) + p.Grant_statement() + } + + case 131: + p.EnterOuterAlt(localctx, 131) + { + p.SetState(2537) + p.Noaudit_statement() + } + + case 132: + p.EnterOuterAlt(localctx, 132) + { + p.SetState(2538) + p.Purge_statement() + } + + case 133: + p.EnterOuterAlt(localctx, 133) + { + p.SetState(2539) + p.Rename_object() + } + + case 134: + p.EnterOuterAlt(localctx, 134) + { + p.SetState(2540) + p.Revoke_statement() + } + + case 135: + p.EnterOuterAlt(localctx, 135) + { + p.SetState(2541) + p.Transaction_control_statements() + } + + case 136: + p.EnterOuterAlt(localctx, 136) + { + p.SetState(2542) + p.Truncate_cluster() + } + + case 137: + p.EnterOuterAlt(localctx, 137) + { + p.SetState(2543) + p.Truncate_table() + } + + case 138: + p.EnterOuterAlt(localctx, 138) + { + p.SetState(2544) + p.Unified_auditing() + } + + case 139: + p.EnterOuterAlt(localctx, 139) + { + p.SetState(2545) + p.Call_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 +} + +// IAlter_diskgroupContext is an interface to support dynamic dispatch. +type IAlter_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ALL() antlr.TerminalNode + Undrop_disk_clause() IUndrop_disk_clauseContext + Diskgroup_availability() IDiskgroup_availabilityContext + Enable_disable_volume() IEnable_disable_volumeContext + Resize_disk_clause() IResize_disk_clauseContext + Replace_disk_clause() IReplace_disk_clauseContext + Rename_disk_clause() IRename_disk_clauseContext + Disk_online_clause() IDisk_online_clauseContext + Disk_offline_clause() IDisk_offline_clauseContext + Rebalance_diskgroup_clause() IRebalance_diskgroup_clauseContext + Check_diskgroup_clause() ICheck_diskgroup_clauseContext + Diskgroup_template_clauses() IDiskgroup_template_clausesContext + Diskgroup_directory_clauses() IDiskgroup_directory_clausesContext + Diskgroup_alias_clauses() IDiskgroup_alias_clausesContext + Diskgroup_volume_clauses() IDiskgroup_volume_clausesContext + Diskgroup_attributes() IDiskgroup_attributesContext + Drop_diskgroup_file_clause() IDrop_diskgroup_file_clauseContext + Convert_redundancy_clause() IConvert_redundancy_clauseContext + Usergroup_clauses() IUsergroup_clausesContext + User_clauses() IUser_clausesContext + File_permissions_clause() IFile_permissions_clauseContext + File_owner_clause() IFile_owner_clauseContext + Scrub_clause() IScrub_clauseContext + Quotagroup_clauses() IQuotagroup_clausesContext + Filegroup_clauses() IFilegroup_clausesContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllAdd_disk_clause() []IAdd_disk_clauseContext + Add_disk_clause(i int) IAdd_disk_clauseContext + AllDrop_disk_clause() []IDrop_disk_clauseContext + Drop_disk_clause(i int) IDrop_disk_clauseContext + + // IsAlter_diskgroupContext differentiates from other interfaces. + IsAlter_diskgroupContext() +} + +type Alter_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_diskgroupContext() *Alter_diskgroupContext { + var p = new(Alter_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_diskgroup + return p +} + +func InitEmptyAlter_diskgroupContext(p *Alter_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_diskgroup +} + +func (*Alter_diskgroupContext) IsAlter_diskgroupContext() {} + +func NewAlter_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_diskgroupContext { + var p = new(Alter_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_diskgroup + + return p +} + +func (s *Alter_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_diskgroupContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Alter_diskgroupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_diskgroupContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_diskgroupContext) Undrop_disk_clause() IUndrop_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndrop_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndrop_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_availability() IDiskgroup_availabilityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_availabilityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_availabilityContext) +} + +func (s *Alter_diskgroupContext) Enable_disable_volume() IEnable_disable_volumeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_volumeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_volumeContext) +} + +func (s *Alter_diskgroupContext) Resize_disk_clause() IResize_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResize_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResize_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Replace_disk_clause() IReplace_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Rename_disk_clause() IRename_disk_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_disk_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) Disk_online_clause() IDisk_online_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisk_online_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisk_online_clauseContext) +} + +func (s *Alter_diskgroupContext) Disk_offline_clause() IDisk_offline_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisk_offline_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisk_offline_clauseContext) +} + +func (s *Alter_diskgroupContext) Rebalance_diskgroup_clause() IRebalance_diskgroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebalance_diskgroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebalance_diskgroup_clauseContext) +} + +func (s *Alter_diskgroupContext) Check_diskgroup_clause() ICheck_diskgroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_diskgroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_diskgroup_clauseContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_template_clauses() IDiskgroup_template_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_template_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_template_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_directory_clauses() IDiskgroup_directory_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_directory_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_directory_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_alias_clauses() IDiskgroup_alias_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_alias_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_alias_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_volume_clauses() IDiskgroup_volume_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_volume_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_volume_clausesContext) +} + +func (s *Alter_diskgroupContext) Diskgroup_attributes() IDiskgroup_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDiskgroup_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDiskgroup_attributesContext) +} + +func (s *Alter_diskgroupContext) Drop_diskgroup_file_clause() IDrop_diskgroup_file_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_diskgroup_file_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_diskgroup_file_clauseContext) +} + +func (s *Alter_diskgroupContext) Convert_redundancy_clause() IConvert_redundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvert_redundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvert_redundancy_clauseContext) +} + +func (s *Alter_diskgroupContext) Usergroup_clauses() IUsergroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsergroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsergroup_clausesContext) +} + +func (s *Alter_diskgroupContext) User_clauses() IUser_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_clausesContext) +} + +func (s *Alter_diskgroupContext) File_permissions_clause() IFile_permissions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_permissions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_permissions_clauseContext) +} + +func (s *Alter_diskgroupContext) File_owner_clause() IFile_owner_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_owner_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_owner_clauseContext) +} + +func (s *Alter_diskgroupContext) Scrub_clause() IScrub_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScrub_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IScrub_clauseContext) +} + +func (s *Alter_diskgroupContext) Quotagroup_clauses() IQuotagroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuotagroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuotagroup_clausesContext) +} + +func (s *Alter_diskgroupContext) Filegroup_clauses() IFilegroup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilegroup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilegroup_clausesContext) +} + +func (s *Alter_diskgroupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_diskgroupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_diskgroupContext) AllAdd_disk_clause() []IAdd_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_disk_clauseContext); ok { + tst[i] = t.(IAdd_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Add_disk_clause(i int) IAdd_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) AllDrop_disk_clause() []IDrop_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_disk_clauseContext); ok { + tst[i] = t.(IDrop_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_diskgroupContext) Drop_disk_clause(i int) IDrop_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_disk_clauseContext) +} + +func (s *Alter_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_diskgroup(s) + } +} + +func (s *Alter_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_diskgroup(s) + } +} + +func (s *Alter_diskgroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_diskgroup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_diskgroup() (localctx IAlter_diskgroupContext) { + localctx = NewAlter_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 4, PlSqlParserRULE_alter_diskgroup) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2548) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2549) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 14, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2550) + p.Id_expression() + } + p.SetState(2585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 10, p.GetParserRuleContext()) { + case 1: + p.SetState(2558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD, PlSqlParserDROP: + p.SetState(2553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(2553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(2551) + p.Add_disk_clause() + } + + case PlSqlParserDROP: + { + p.SetState(2552) + p.Drop_disk_clause() + } + + 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 + } + + p.SetState(2555) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 6, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserRESIZE: + { + p.SetState(2557) + p.Resize_disk_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2561) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 8, p.GetParserRuleContext()) == 1 { + { + p.SetState(2560) + p.Rebalance_diskgroup_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(2583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 9, p.GetParserRuleContext()) { + case 1: + { + p.SetState(2563) + p.Replace_disk_clause() + } + + case 2: + { + p.SetState(2564) + p.Rename_disk_clause() + } + + case 3: + { + p.SetState(2565) + p.Disk_online_clause() + } + + case 4: + { + p.SetState(2566) + p.Disk_offline_clause() + } + + case 5: + { + p.SetState(2567) + p.Rebalance_diskgroup_clause() + } + + case 6: + { + p.SetState(2568) + p.Check_diskgroup_clause() + } + + case 7: + { + p.SetState(2569) + p.Diskgroup_template_clauses() + } + + case 8: + { + p.SetState(2570) + p.Diskgroup_directory_clauses() + } + + case 9: + { + p.SetState(2571) + p.Diskgroup_alias_clauses() + } + + case 10: + { + p.SetState(2572) + p.Diskgroup_volume_clauses() + } + + case 11: + { + p.SetState(2573) + p.Diskgroup_attributes() + } + + case 12: + { + p.SetState(2574) + p.Drop_diskgroup_file_clause() + } + + case 13: + { + p.SetState(2575) + p.Convert_redundancy_clause() + } + + case 14: + { + p.SetState(2576) + p.Usergroup_clauses() + } + + case 15: + { + p.SetState(2577) + p.User_clauses() + } + + case 16: + { + p.SetState(2578) + p.File_permissions_clause() + } + + case 17: + { + p.SetState(2579) + p.File_owner_clause() + } + + case 18: + { + p.SetState(2580) + p.Scrub_clause() + } + + case 19: + { + p.SetState(2581) + p.Quotagroup_clauses() + } + + case 20: + { + p.SetState(2582) + p.Filegroup_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.SetState(2596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(2587) + p.Id_expression() + } + p.SetState(2592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(2588) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2589) + p.Id_expression() + } + + p.SetState(2594) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(2595) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNDROP: + { + p.SetState(2598) + p.Undrop_disk_clause() + } + + case PlSqlParserDISMOUNT, PlSqlParserMOUNT: + { + p.SetState(2599) + p.Diskgroup_availability() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(2600) + p.Enable_disable_volume() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + 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 +} + +// IAdd_disk_clauseContext is an interface to support dynamic dispatch. +type IAdd_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetFgn returns the fgn rule contexts. + GetFgn() IId_expressionContext + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetFgn sets the fgn rule contexts. + SetFgn(IId_expressionContext) + + // Getter signatures + ADD() antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllQualified_disk_clause() []IQualified_disk_clauseContext + Qualified_disk_clause(i int) IQualified_disk_clauseContext + AllSITE() []antlr.TerminalNode + SITE(i int) antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsAdd_disk_clauseContext differentiates from other interfaces. + IsAdd_disk_clauseContext() +} + +type Add_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + sn IId_expressionContext + fgn IId_expressionContext +} + +func NewEmptyAdd_disk_clauseContext() *Add_disk_clauseContext { + var p = new(Add_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_disk_clause + return p +} + +func InitEmptyAdd_disk_clauseContext(p *Add_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_disk_clause +} + +func (*Add_disk_clauseContext) IsAdd_disk_clauseContext() {} + +func NewAdd_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_disk_clauseContext { + var p = new(Add_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_disk_clause + + return p +} + +func (s *Add_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_disk_clauseContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Add_disk_clauseContext) GetFgn() IId_expressionContext { return s.fgn } + +func (s *Add_disk_clauseContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Add_disk_clauseContext) SetFgn(v IId_expressionContext) { s.fgn = v } + +func (s *Add_disk_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_disk_clauseContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Add_disk_clauseContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Add_disk_clauseContext) AllQualified_disk_clause() []IQualified_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_disk_clauseContext); ok { + tst[i] = t.(IQualified_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Qualified_disk_clause(i int) IQualified_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_disk_clauseContext) +} + +func (s *Add_disk_clauseContext) AllSITE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSITE) +} + +func (s *Add_disk_clauseContext) SITE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, i) +} + +func (s *Add_disk_clauseContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Add_disk_clauseContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Add_disk_clauseContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Add_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Add_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_disk_clause(s) + } +} + +func (s *Add_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_disk_clause(s) + } +} + +func (s *Add_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_disk_clause() (localctx IAdd_disk_clauseContext) { + localctx = NewAdd_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 6, PlSqlParserRULE_add_disk_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2605) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(2608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSITE { + { + p.SetState(2606) + p.Match(PlSqlParserSITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2607) + + var _x = p.Id_expression() + + localctx.(*Add_disk_clauseContext).sn = _x + } + + } + p.SetState(2611) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2610) + p.Quorum_regular() + } + + } + p.SetState(2615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFAILGROUP { + { + p.SetState(2613) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2614) + + var _x = p.Id_expression() + + localctx.(*Add_disk_clauseContext).fgn = _x + } + + } + { + p.SetState(2617) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2618) + p.Qualified_disk_clause() + } + p.SetState(2623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2619) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2620) + p.Qualified_disk_clause() + } + + } + p.SetState(2625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 18, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2628) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 19, 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 +} + +// IDrop_disk_clauseContext is an interface to support dynamic dispatch. +type IDrop_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DISKS() antlr.TerminalNode + IN() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + Quorum_regular() IQuorum_regularContext + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_disk_clauseContext differentiates from other interfaces. + IsDrop_disk_clauseContext() +} + +type Drop_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_disk_clauseContext() *Drop_disk_clauseContext { + var p = new(Drop_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_disk_clause + return p +} + +func InitEmptyDrop_disk_clauseContext(p *Drop_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_disk_clause +} + +func (*Drop_disk_clauseContext) IsDrop_disk_clauseContext() {} + +func NewDrop_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_disk_clauseContext { + var p = new(Drop_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_disk_clause + + return p +} + +func (s *Drop_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_disk_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Drop_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Drop_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Drop_disk_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Drop_disk_clauseContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Drop_disk_clauseContext) Quorum_regular() IQuorum_regularContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Drop_disk_clauseContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Drop_disk_clauseContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Drop_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_disk_clause(s) + } +} + +func (s *Drop_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_disk_clause(s) + } +} + +func (s *Drop_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_disk_clause() (localctx IDrop_disk_clauseContext) { + localctx = NewDrop_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 8, PlSqlParserRULE_drop_disk_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2630) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2669) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2631) + p.Quorum_regular() + } + + } + { + p.SetState(2634) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2635) + p.Id_expression() + } + p.SetState(2637) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 21, p.GetParserRuleContext()) == 1 { + { + p.SetState(2636) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2639) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2640) + p.Id_expression() + } + p.SetState(2642) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 22, p.GetParserRuleContext()) == 1 { + { + p.SetState(2641) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(2648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 23, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDISKS: + { + p.SetState(2649) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2650) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2651) + p.Quorum_regular() + } + + } + { + p.SetState(2654) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2655) + p.Id_expression() + } + p.SetState(2657) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 25, p.GetParserRuleContext()) == 1 { + { + p.SetState(2656) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2659) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2660) + p.Id_expression() + } + p.SetState(2662) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 26, p.GetParserRuleContext()) == 1 { + { + p.SetState(2661) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(2668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 27, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IResize_disk_clauseContext is an interface to support dynamic dispatch. +type IResize_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESIZE() antlr.TerminalNode + ALL() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsResize_disk_clauseContext differentiates from other interfaces. + IsResize_disk_clauseContext() +} + +type Resize_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResize_disk_clauseContext() *Resize_disk_clauseContext { + var p = new(Resize_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resize_disk_clause + return p +} + +func InitEmptyResize_disk_clauseContext(p *Resize_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resize_disk_clause +} + +func (*Resize_disk_clauseContext) IsResize_disk_clauseContext() {} + +func NewResize_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resize_disk_clauseContext { + var p = new(Resize_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resize_disk_clause + + return p +} + +func (s *Resize_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resize_disk_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Resize_disk_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Resize_disk_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Resize_disk_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Resize_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resize_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resize_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResize_disk_clause(s) + } +} + +func (s *Resize_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResize_disk_clause(s) + } +} + +func (s *Resize_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitResize_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Resize_disk_clause() (localctx IResize_disk_clauseContext) { + localctx = NewResize_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 10, PlSqlParserRULE_resize_disk_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2671) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2672) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2675) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 29, p.GetParserRuleContext()) == 1 { + { + p.SetState(2673) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2674) + p.Size_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 +} + +// IReplace_disk_clauseContext is an interface to support dynamic dispatch. +type IReplace_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + Wait_nowait() IWait_nowaitContext + + // IsReplace_disk_clauseContext differentiates from other interfaces. + IsReplace_disk_clauseContext() +} + +type Replace_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_disk_clauseContext() *Replace_disk_clauseContext { + var p = new(Replace_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_disk_clause + return p +} + +func InitEmptyReplace_disk_clauseContext(p *Replace_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_disk_clause +} + +func (*Replace_disk_clauseContext) IsReplace_disk_clauseContext() {} + +func NewReplace_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_disk_clauseContext { + var p = new(Replace_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replace_disk_clause + + return p +} + +func (s *Replace_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_disk_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Replace_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Replace_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Replace_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Replace_disk_clauseContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Replace_disk_clauseContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Replace_disk_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Replace_disk_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Replace_disk_clauseContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Replace_disk_clauseContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Replace_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Replace_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Replace_disk_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Replace_disk_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Replace_disk_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Replace_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplace_disk_clause(s) + } +} + +func (s *Replace_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplace_disk_clause(s) + } +} + +func (s *Replace_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReplace_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Replace_disk_clause() (localctx IReplace_disk_clauseContext) { + localctx = NewReplace_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 12, PlSqlParserRULE_replace_disk_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2677) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2678) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2679) + p.Id_expression() + } + { + p.SetState(2680) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2681) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2683) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 30, p.GetParserRuleContext()) == 1 { + { + p.SetState(2682) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 32, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2685) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2686) + p.Id_expression() + } + { + p.SetState(2687) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2688) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 31, p.GetParserRuleContext()) == 1 { + { + p.SetState(2689) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(2696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 32, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(2699) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 33, p.GetParserRuleContext()) == 1 { + { + p.SetState(2697) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2698) + p.Numeric() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2702) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 34, p.GetParserRuleContext()) == 1 { + { + p.SetState(2701) + p.Wait_nowait() + } + + } 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 +} + +// IWait_nowaitContext is an interface to support dynamic dispatch. +type IWait_nowaitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + + // IsWait_nowaitContext differentiates from other interfaces. + IsWait_nowaitContext() +} + +type Wait_nowaitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWait_nowaitContext() *Wait_nowaitContext { + var p = new(Wait_nowaitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait + return p +} + +func InitEmptyWait_nowaitContext(p *Wait_nowaitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait +} + +func (*Wait_nowaitContext) IsWait_nowaitContext() {} + +func NewWait_nowaitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wait_nowaitContext { + var p = new(Wait_nowaitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_wait_nowait + + return p +} + +func (s *Wait_nowaitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wait_nowaitContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Wait_nowaitContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Wait_nowaitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wait_nowaitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wait_nowaitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWait_nowait(s) + } +} + +func (s *Wait_nowaitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWait_nowait(s) + } +} + +func (s *Wait_nowaitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWait_nowait(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Wait_nowait() (localctx IWait_nowaitContext) { + localctx = NewWait_nowaitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 14, PlSqlParserRULE_wait_nowait) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2704) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + 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 +} + +// IRename_disk_clauseContext is an interface to support dynamic dispatch. +type IRename_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + DISKS() antlr.TerminalNode + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRename_disk_clauseContext differentiates from other interfaces. + IsRename_disk_clauseContext() +} + +type Rename_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_disk_clauseContext() *Rename_disk_clauseContext { + var p = new(Rename_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_disk_clause + return p +} + +func InitEmptyRename_disk_clauseContext(p *Rename_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_disk_clause +} + +func (*Rename_disk_clauseContext) IsRename_disk_clauseContext() {} + +func NewRename_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_disk_clauseContext { + var p = new(Rename_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_disk_clause + + return p +} + +func (s *Rename_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_disk_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_disk_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Rename_disk_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Rename_disk_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Rename_disk_clauseContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Rename_disk_clauseContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Rename_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Rename_disk_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Rename_disk_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Rename_disk_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Rename_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_disk_clause(s) + } +} + +func (s *Rename_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_disk_clause(s) + } +} + +func (s *Rename_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRename_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rename_disk_clause() (localctx IRename_disk_clauseContext) { + localctx = NewRename_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 16, PlSqlParserRULE_rename_disk_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2706) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK: + { + p.SetState(2707) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2708) + p.Id_expression() + } + { + p.SetState(2709) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2710) + p.Id_expression() + } + p.SetState(2718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2711) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2712) + p.Id_expression() + } + { + p.SetState(2713) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2714) + p.Id_expression() + } + + } + p.SetState(2720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 35, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDISKS: + { + p.SetState(2721) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2722) + p.Match(PlSqlParserALL) + 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 +} + +// IDisk_online_clauseContext is an interface to support dynamic dispatch. +type IDisk_online_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONLINE() antlr.TerminalNode + ALL() antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + Wait_nowait() IWait_nowaitContext + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllDISKS() []antlr.TerminalNode + DISKS(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisk_online_clauseContext differentiates from other interfaces. + IsDisk_online_clauseContext() +} + +type Disk_online_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisk_online_clauseContext() *Disk_online_clauseContext { + var p = new(Disk_online_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_online_clause + return p +} + +func InitEmptyDisk_online_clauseContext(p *Disk_online_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_online_clause +} + +func (*Disk_online_clauseContext) IsDisk_online_clauseContext() {} + +func NewDisk_online_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disk_online_clauseContext { + var p = new(Disk_online_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disk_online_clause + + return p +} + +func (s *Disk_online_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disk_online_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Disk_online_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Disk_online_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Disk_online_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Disk_online_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Disk_online_clauseContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Disk_online_clauseContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Disk_online_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disk_online_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disk_online_clauseContext) AllDISKS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISKS) +} + +func (s *Disk_online_clauseContext) DISKS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, i) +} + +func (s *Disk_online_clauseContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Disk_online_clauseContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Disk_online_clauseContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Disk_online_clauseContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Disk_online_clauseContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Disk_online_clauseContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Disk_online_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disk_online_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disk_online_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disk_online_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disk_online_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisk_online_clause(s) + } +} + +func (s *Disk_online_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisk_online_clause(s) + } +} + +func (s *Disk_online_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisk_online_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disk_online_clause() (localctx IDisk_online_clauseContext) { + localctx = NewDisk_online_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 18, PlSqlParserRULE_disk_online_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2725) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserDISKS, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(2752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2726) + p.Quorum_regular() + } + + } + { + p.SetState(2729) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2730) + p.Id_expression() + } + p.SetState(2735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2731) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2732) + p.Id_expression() + } + + } + p.SetState(2737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 38, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDISKS: + { + p.SetState(2738) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2739) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2740) + p.Quorum_regular() + } + + } + { + p.SetState(2743) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2744) + p.Id_expression() + } + p.SetState(2749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2745) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2746) + p.Id_expression() + } + + } + p.SetState(2751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 40, p.GetParserRuleContext()) + if p.HasError() { + 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 + } + + p.SetState(2754) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 42, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(2756) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 44, p.GetParserRuleContext()) == 1 { + { + p.SetState(2759) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2760) + p.Numeric() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2764) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 45, p.GetParserRuleContext()) == 1 { + { + p.SetState(2763) + p.Wait_nowait() + } + + } 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 +} + +// IDisk_offline_clauseContext is an interface to support dynamic dispatch. +type IDisk_offline_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFLINE() antlr.TerminalNode + DISK() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DISKS() antlr.TerminalNode + IN() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + Timeout_clause() ITimeout_clauseContext + Quorum_regular() IQuorum_regularContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisk_offline_clauseContext differentiates from other interfaces. + IsDisk_offline_clauseContext() +} + +type Disk_offline_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisk_offline_clauseContext() *Disk_offline_clauseContext { + var p = new(Disk_offline_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_offline_clause + return p +} + +func InitEmptyDisk_offline_clauseContext(p *Disk_offline_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_offline_clause +} + +func (*Disk_offline_clauseContext) IsDisk_offline_clauseContext() {} + +func NewDisk_offline_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disk_offline_clauseContext { + var p = new(Disk_offline_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disk_offline_clause + + return p +} + +func (s *Disk_offline_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disk_offline_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Disk_offline_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Disk_offline_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disk_offline_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disk_offline_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Disk_offline_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Disk_offline_clauseContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Disk_offline_clauseContext) Timeout_clause() ITimeout_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITimeout_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITimeout_clauseContext) +} + +func (s *Disk_offline_clauseContext) Quorum_regular() IQuorum_regularContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Disk_offline_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disk_offline_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disk_offline_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disk_offline_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disk_offline_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisk_offline_clause(s) + } +} + +func (s *Disk_offline_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisk_offline_clause(s) + } +} + +func (s *Disk_offline_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisk_offline_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disk_offline_clause() (localctx IDisk_offline_clauseContext) { + localctx = NewDisk_offline_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 20, PlSqlParserRULE_disk_offline_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2766) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISK, PlSqlParserQUORUM, PlSqlParserREGULAR: + p.SetState(2768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2767) + p.Quorum_regular() + } + + } + { + p.SetState(2770) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2771) + p.Id_expression() + } + p.SetState(2776) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 47, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2772) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2773) + p.Id_expression() + } + + } + p.SetState(2778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 47, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDISKS: + { + p.SetState(2779) + p.Match(PlSqlParserDISKS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2780) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(2781) + p.Quorum_regular() + } + + } + { + p.SetState(2784) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2785) + p.Id_expression() + } + p.SetState(2790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2786) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2787) + p.Id_expression() + } + + } + p.SetState(2792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 49, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(2796) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 51, p.GetParserRuleContext()) == 1 { + { + p.SetState(2795) + p.Timeout_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 +} + +// ITimeout_clauseContext is an interface to support dynamic dispatch. +type ITimeout_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + AFTER() antlr.TerminalNode + Numeric() INumericContext + M_LETTER() antlr.TerminalNode + H_LETTER() antlr.TerminalNode + + // IsTimeout_clauseContext differentiates from other interfaces. + IsTimeout_clauseContext() +} + +type Timeout_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTimeout_clauseContext() *Timeout_clauseContext { + var p = new(Timeout_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timeout_clause + return p +} + +func InitEmptyTimeout_clauseContext(p *Timeout_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timeout_clause +} + +func (*Timeout_clauseContext) IsTimeout_clauseContext() {} + +func NewTimeout_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timeout_clauseContext { + var p = new(Timeout_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timeout_clause + + return p +} + +func (s *Timeout_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timeout_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Timeout_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Timeout_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Timeout_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Timeout_clauseContext) H_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserH_LETTER, 0) +} + +func (s *Timeout_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timeout_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timeout_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTimeout_clause(s) + } +} + +func (s *Timeout_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTimeout_clause(s) + } +} + +func (s *Timeout_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTimeout_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Timeout_clause() (localctx ITimeout_clauseContext) { + localctx = NewTimeout_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 22, PlSqlParserRULE_timeout_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2798) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2799) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2800) + p.Numeric() + } + { + p.SetState(2801) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserH_LETTER || _la == PlSqlParserM_LETTER) { + 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 +} + +// IRebalance_diskgroup_clauseContext is an interface to support dynamic dispatch. +type IRebalance_diskgroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBALANCE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + POWER() antlr.TerminalNode + Numeric() INumericContext + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + AllPhase() []IPhaseContext + Phase(i int) IPhaseContext + + // IsRebalance_diskgroup_clauseContext differentiates from other interfaces. + IsRebalance_diskgroup_clauseContext() +} + +type Rebalance_diskgroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebalance_diskgroup_clauseContext() *Rebalance_diskgroup_clauseContext { + var p = new(Rebalance_diskgroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause + return p +} + +func InitEmptyRebalance_diskgroup_clauseContext(p *Rebalance_diskgroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause +} + +func (*Rebalance_diskgroup_clauseContext) IsRebalance_diskgroup_clauseContext() {} + +func NewRebalance_diskgroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebalance_diskgroup_clauseContext { + var p = new(Rebalance_diskgroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rebalance_diskgroup_clause + + return p +} + +func (s *Rebalance_diskgroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebalance_diskgroup_clauseContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBALANCE, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Rebalance_diskgroup_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Rebalance_diskgroup_clauseContext) AllPhase() []IPhaseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhaseContext); ok { + len++ + } + } + + tst := make([]IPhaseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhaseContext); ok { + tst[i] = t.(IPhaseContext) + i++ + } + } + + return tst +} + +func (s *Rebalance_diskgroup_clauseContext) Phase(i int) IPhaseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhaseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhaseContext) +} + +func (s *Rebalance_diskgroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebalance_diskgroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebalance_diskgroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRebalance_diskgroup_clause(s) + } +} + +func (s *Rebalance_diskgroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRebalance_diskgroup_clause(s) + } +} + +func (s *Rebalance_diskgroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRebalance_diskgroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rebalance_diskgroup_clause() (localctx IRebalance_diskgroup_clauseContext) { + localctx = NewRebalance_diskgroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 24, PlSqlParserRULE_rebalance_diskgroup_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2803) + p.Match(PlSqlParserREBALANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPOWER, PlSqlParserWITHOUT, PlSqlParserWITH: + p.SetState(2810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(2804) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(2806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(2805) + p.Phase() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(2808) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 52, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + + { + p.SetState(2812) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2813) + p.Numeric() + } + + p.SetState(2816) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 54, p.GetParserRuleContext()) == 1 { + { + p.SetState(2815) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserMODIFY: + { + p.SetState(2818) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2819) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2821) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 55, p.GetParserRuleContext()) == 1 { + { + p.SetState(2820) + p.Numeric() + } + + } 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 +} + +// IPhaseContext is an interface to support dynamic dispatch. +type IPhaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsPhaseContext differentiates from other interfaces. + IsPhaseContext() +} + +type PhaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPhaseContext() *PhaseContext { + var p = new(PhaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_phase + return p +} + +func InitEmptyPhaseContext(p *PhaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_phase +} + +func (*PhaseContext) IsPhaseContext() {} + +func NewPhaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PhaseContext { + var p = new(PhaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_phase + + return p +} + +func (s *PhaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *PhaseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *PhaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PhaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PhaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhase(s) + } +} + +func (s *PhaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhase(s) + } +} + +func (s *PhaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPhase(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Phase() (localctx IPhaseContext) { + localctx = NewPhaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 26, PlSqlParserRULE_phase) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2825) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheck_diskgroup_clauseContext is an interface to support dynamic dispatch. +type ICheck_diskgroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + ALL() antlr.TerminalNode + REPAIR() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + + // IsCheck_diskgroup_clauseContext differentiates from other interfaces. + IsCheck_diskgroup_clauseContext() +} + +type Check_diskgroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheck_diskgroup_clauseContext() *Check_diskgroup_clauseContext { + var p = new(Check_diskgroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause + return p +} + +func InitEmptyCheck_diskgroup_clauseContext(p *Check_diskgroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause +} + +func (*Check_diskgroup_clauseContext) IsCheck_diskgroup_clauseContext() {} + +func NewCheck_diskgroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Check_diskgroup_clauseContext { + var p = new(Check_diskgroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_check_diskgroup_clause + + return p +} + +func (s *Check_diskgroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Check_diskgroup_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Check_diskgroup_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Check_diskgroup_clauseContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Check_diskgroup_clauseContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Check_diskgroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Check_diskgroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Check_diskgroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCheck_diskgroup_clause(s) + } +} + +func (s *Check_diskgroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCheck_diskgroup_clause(s) + } +} + +func (s *Check_diskgroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCheck_diskgroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Check_diskgroup_clause() (localctx ICheck_diskgroup_clauseContext) { + localctx = NewCheck_diskgroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 28, PlSqlParserRULE_check_diskgroup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2827) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 57, p.GetParserRuleContext()) == 1 { + { + p.SetState(2828) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2832) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 58, p.GetParserRuleContext()) == 1 { + { + p.SetState(2831) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR) { + 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 +} + +// IDiskgroup_template_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_template_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPLATE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllQualified_template_clause() []IQualified_template_clauseContext + Qualified_template_clause(i int) IQualified_template_clauseContext + ADD() antlr.TerminalNode + MODIFY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsDiskgroup_template_clausesContext differentiates from other interfaces. + IsDiskgroup_template_clausesContext() +} + +type Diskgroup_template_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_template_clausesContext() *Diskgroup_template_clausesContext { + var p = new(Diskgroup_template_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses + return p +} + +func InitEmptyDiskgroup_template_clausesContext(p *Diskgroup_template_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses +} + +func (*Diskgroup_template_clausesContext) IsDiskgroup_template_clausesContext() {} + +func NewDiskgroup_template_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_template_clausesContext { + var p = new(Diskgroup_template_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_template_clauses + + return p +} + +func (s *Diskgroup_template_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_template_clausesContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Diskgroup_template_clausesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_template_clausesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Diskgroup_template_clausesContext) AllQualified_template_clause() []IQualified_template_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_template_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_template_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_template_clauseContext); ok { + tst[i] = t.(IQualified_template_clauseContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_template_clausesContext) Qualified_template_clause(i int) IQualified_template_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_template_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_template_clauseContext) +} + +func (s *Diskgroup_template_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_template_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Diskgroup_template_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_template_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_template_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_template_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_template_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_template_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_template_clauses(s) + } +} + +func (s *Diskgroup_template_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_template_clauses(s) + } +} + +func (s *Diskgroup_template_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_template_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_template_clauses() (localctx IDiskgroup_template_clausesContext) { + localctx = NewDiskgroup_template_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 30, PlSqlParserRULE_diskgroup_template_clauses) + var _la int + + var _alt int + + p.SetState(2857) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD, PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2834) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserMODIFY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(2835) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2836) + p.Id_expression() + } + { + p.SetState(2837) + p.Qualified_template_clause() + } + p.SetState(2844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2838) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2839) + p.Id_expression() + } + { + p.SetState(2840) + p.Qualified_template_clause() + } + + } + p.SetState(2846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 59, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2847) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2848) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2849) + p.Id_expression() + } + p.SetState(2854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2850) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2851) + p.Id_expression() + } + + } + p.SetState(2856) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 60, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualified_template_clauseContext is an interface to support dynamic dispatch. +type IQualified_template_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Redundancy_clause() IRedundancy_clauseContext + Striping_clause() IStriping_clauseContext + + // IsQualified_template_clauseContext differentiates from other interfaces. + IsQualified_template_clauseContext() +} + +type Qualified_template_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQualified_template_clauseContext() *Qualified_template_clauseContext { + var p = new(Qualified_template_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_template_clause + return p +} + +func InitEmptyQualified_template_clauseContext(p *Qualified_template_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_template_clause +} + +func (*Qualified_template_clauseContext) IsQualified_template_clauseContext() {} + +func NewQualified_template_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_template_clauseContext { + var p = new(Qualified_template_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qualified_template_clause + + return p +} + +func (s *Qualified_template_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_template_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Qualified_template_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Qualified_template_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Qualified_template_clauseContext) Redundancy_clause() IRedundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedundancy_clauseContext) +} + +func (s *Qualified_template_clauseContext) Striping_clause() IStriping_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStriping_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStriping_clauseContext) +} + +func (s *Qualified_template_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_template_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_template_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQualified_template_clause(s) + } +} + +func (s *Qualified_template_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQualified_template_clause(s) + } +} + +func (s *Qualified_template_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQualified_template_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Qualified_template_clause() (localctx IQualified_template_clauseContext) { + localctx = NewQualified_template_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 32, PlSqlParserRULE_qualified_template_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2859) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2860) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOUBLE || _la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserPARITY || _la == PlSqlParserUNPROTECTED { + { + p.SetState(2861) + p.Redundancy_clause() + } + + } + p.SetState(2865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOARSE || _la == PlSqlParserFINE { + { + p.SetState(2864) + p.Striping_clause() + } + + } + { + p.SetState(2867) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRedundancy_clauseContext is an interface to support dynamic dispatch. +type IRedundancy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MIRROR() antlr.TerminalNode + HIGH() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + PARITY() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + + // IsRedundancy_clauseContext differentiates from other interfaces. + IsRedundancy_clauseContext() +} + +type Redundancy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedundancy_clauseContext() *Redundancy_clauseContext { + var p = new(Redundancy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redundancy_clause + return p +} + +func InitEmptyRedundancy_clauseContext(p *Redundancy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redundancy_clause +} + +func (*Redundancy_clauseContext) IsRedundancy_clauseContext() {} + +func NewRedundancy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redundancy_clauseContext { + var p = new(Redundancy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_redundancy_clause + + return p +} + +func (s *Redundancy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redundancy_clauseContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Redundancy_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Redundancy_clauseContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Redundancy_clauseContext) PARITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARITY, 0) +} + +func (s *Redundancy_clauseContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Redundancy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redundancy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redundancy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRedundancy_clause(s) + } +} + +func (s *Redundancy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRedundancy_clause(s) + } +} + +func (s *Redundancy_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRedundancy_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Redundancy_clause() (localctx IRedundancy_clauseContext) { + localctx = NewRedundancy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 34, PlSqlParserRULE_redundancy_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2869) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDOUBLE || _la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserPARITY || _la == PlSqlParserUNPROTECTED) { + 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 +} + +// IStriping_clauseContext is an interface to support dynamic dispatch. +type IStriping_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FINE() antlr.TerminalNode + COARSE() antlr.TerminalNode + + // IsStriping_clauseContext differentiates from other interfaces. + IsStriping_clauseContext() +} + +type Striping_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStriping_clauseContext() *Striping_clauseContext { + var p = new(Striping_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_striping_clause + return p +} + +func InitEmptyStriping_clauseContext(p *Striping_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_striping_clause +} + +func (*Striping_clauseContext) IsStriping_clauseContext() {} + +func NewStriping_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Striping_clauseContext { + var p = new(Striping_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_striping_clause + + return p +} + +func (s *Striping_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Striping_clauseContext) FINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINE, 0) +} + +func (s *Striping_clauseContext) COARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOARSE, 0) +} + +func (s *Striping_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Striping_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Striping_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStriping_clause(s) + } +} + +func (s *Striping_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStriping_clause(s) + } +} + +func (s *Striping_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStriping_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Striping_clause() (localctx IStriping_clauseContext) { + localctx = NewStriping_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 36, PlSqlParserRULE_striping_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2871) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOARSE || _la == PlSqlParserFINE) { + 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 +} + +// IForce_noforceContext is an interface to support dynamic dispatch. +type IForce_noforceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORCE() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + + // IsForce_noforceContext differentiates from other interfaces. + IsForce_noforceContext() +} + +type Force_noforceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForce_noforceContext() *Force_noforceContext { + var p = new(Force_noforceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_noforce + return p +} + +func InitEmptyForce_noforceContext(p *Force_noforceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_noforce +} + +func (*Force_noforceContext) IsForce_noforceContext() {} + +func NewForce_noforceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Force_noforceContext { + var p = new(Force_noforceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_force_noforce + + return p +} + +func (s *Force_noforceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Force_noforceContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Force_noforceContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Force_noforceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Force_noforceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Force_noforceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForce_noforce(s) + } +} + +func (s *Force_noforceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForce_noforce(s) + } +} + +func (s *Force_noforceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitForce_noforce(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Force_noforce() (localctx IForce_noforceContext) { + localctx = NewForce_noforceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 38, PlSqlParserRULE_force_noforce) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2873) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + 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 +} + +// IDiskgroup_directory_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_directory_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + AllForce_noforce() []IForce_noforceContext + Force_noforce(i int) IForce_noforceContext + RENAME() antlr.TerminalNode + AllDir_name() []IDir_nameContext + Dir_name(i int) IDir_nameContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsDiskgroup_directory_clausesContext differentiates from other interfaces. + IsDiskgroup_directory_clausesContext() +} + +type Diskgroup_directory_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_directory_clausesContext() *Diskgroup_directory_clausesContext { + var p = new(Diskgroup_directory_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses + return p +} + +func InitEmptyDiskgroup_directory_clausesContext(p *Diskgroup_directory_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses +} + +func (*Diskgroup_directory_clausesContext) IsDiskgroup_directory_clausesContext() {} + +func NewDiskgroup_directory_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_directory_clausesContext { + var p = new(Diskgroup_directory_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_directory_clauses + + return p +} + +func (s *Diskgroup_directory_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_directory_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_directory_clausesContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Diskgroup_directory_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_directory_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_directory_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllForce_noforce() []IForce_noforceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IForce_noforceContext); ok { + len++ + } + } + + tst := make([]IForce_noforceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IForce_noforceContext); ok { + tst[i] = t.(IForce_noforceContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Force_noforce(i int) IForce_noforceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Diskgroup_directory_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Diskgroup_directory_clausesContext) AllDir_name() []IDir_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDir_nameContext); ok { + len++ + } + } + + tst := make([]IDir_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDir_nameContext); ok { + tst[i] = t.(IDir_nameContext) + i++ + } + } + + return tst +} + +func (s *Diskgroup_directory_clausesContext) Dir_name(i int) IDir_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDir_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDir_nameContext) +} + +func (s *Diskgroup_directory_clausesContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Diskgroup_directory_clausesContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Diskgroup_directory_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_directory_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_directory_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_directory_clauses(s) + } +} + +func (s *Diskgroup_directory_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_directory_clauses(s) + } +} + +func (s *Diskgroup_directory_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_directory_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_directory_clauses() (localctx IDiskgroup_directory_clausesContext) { + localctx = NewDiskgroup_directory_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 40, PlSqlParserRULE_diskgroup_directory_clauses) + var _alt int + + p.SetState(2916) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2875) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2876) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2877) + p.Filename() + } + p.SetState(2882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2878) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2879) + p.Filename() + } + + } + p.SetState(2884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 64, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2885) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2886) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2887) + p.Filename() + } + p.SetState(2889) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 65, p.GetParserRuleContext()) == 1 { + { + p.SetState(2888) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 67, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2891) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2892) + p.Filename() + } + p.SetState(2894) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 66, p.GetParserRuleContext()) == 1 { + { + p.SetState(2893) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(2900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 67, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2901) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2902) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2903) + p.Dir_name() + } + { + p.SetState(2904) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2905) + p.Dir_name() + } + p.SetState(2913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2906) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2907) + p.Dir_name() + } + { + p.SetState(2908) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2909) + p.Dir_name() + } + + } + p.SetState(2915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 68, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IDir_nameContext is an interface to support dynamic dispatch. +type IDir_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsDir_nameContext differentiates from other interfaces. + IsDir_nameContext() +} + +type Dir_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDir_nameContext() *Dir_nameContext { + var p = new(Dir_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_name + return p +} + +func InitEmptyDir_nameContext(p *Dir_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_name +} + +func (*Dir_nameContext) IsDir_nameContext() {} + +func NewDir_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dir_nameContext { + var p = new(Dir_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dir_name + + return p +} + +func (s *Dir_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dir_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Dir_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dir_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dir_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDir_name(s) + } +} + +func (s *Dir_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDir_name(s) + } +} + +func (s *Dir_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDir_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dir_name() (localctx IDir_nameContext) { + localctx = NewDir_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 42, PlSqlParserRULE_dir_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2918) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IDiskgroup_alias_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_alias_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + ALIAS() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + RENAME() antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + + // IsDiskgroup_alias_clausesContext differentiates from other interfaces. + IsDiskgroup_alias_clausesContext() +} + +type Diskgroup_alias_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_alias_clausesContext() *Diskgroup_alias_clausesContext { + var p = new(Diskgroup_alias_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses + return p +} + +func InitEmptyDiskgroup_alias_clausesContext(p *Diskgroup_alias_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses +} + +func (*Diskgroup_alias_clausesContext) IsDiskgroup_alias_clausesContext() {} + +func NewDiskgroup_alias_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_alias_clausesContext { + var p = new(Diskgroup_alias_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_alias_clauses + + return p +} + +func (s *Diskgroup_alias_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_alias_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Diskgroup_alias_clausesContext) ALIAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALIAS, 0) +} + +func (s *Diskgroup_alias_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Diskgroup_alias_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Diskgroup_alias_clausesContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFOR) +} + +func (s *Diskgroup_alias_clausesContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, i) +} + +func (s *Diskgroup_alias_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Diskgroup_alias_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Diskgroup_alias_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_alias_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Diskgroup_alias_clausesContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Diskgroup_alias_clausesContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Diskgroup_alias_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_alias_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_alias_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_alias_clauses(s) + } +} + +func (s *Diskgroup_alias_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_alias_clauses(s) + } +} + +func (s *Diskgroup_alias_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_alias_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_alias_clauses() (localctx IDiskgroup_alias_clausesContext) { + localctx = NewDiskgroup_alias_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 44, PlSqlParserRULE_diskgroup_alias_clauses) + var _alt int + + p.SetState(2958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2920) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2921) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2922) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2923) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2924) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 70, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2925) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2926) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2927) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2928) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 70, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2934) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2935) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2936) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 71, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2937) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2938) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 71, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2944) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2945) + p.Match(PlSqlParserALIAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2946) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2947) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2948) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(2955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(2949) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2950) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2951) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2952) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(2957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 72, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IDiskgroup_volume_clausesContext is an interface to support dynamic dispatch. +type IDiskgroup_volume_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_volume_clause() IAdd_volume_clauseContext + Modify_volume_clause() IModify_volume_clauseContext + RESIZE() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + DROP() antlr.TerminalNode + + // IsDiskgroup_volume_clausesContext differentiates from other interfaces. + IsDiskgroup_volume_clausesContext() +} + +type Diskgroup_volume_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_volume_clausesContext() *Diskgroup_volume_clausesContext { + var p = new(Diskgroup_volume_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses + return p +} + +func InitEmptyDiskgroup_volume_clausesContext(p *Diskgroup_volume_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses +} + +func (*Diskgroup_volume_clausesContext) IsDiskgroup_volume_clausesContext() {} + +func NewDiskgroup_volume_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_volume_clausesContext { + var p = new(Diskgroup_volume_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_volume_clauses + + return p +} + +func (s *Diskgroup_volume_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_volume_clausesContext) Add_volume_clause() IAdd_volume_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_volume_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_volume_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) Modify_volume_clause() IModify_volume_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_volume_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_volume_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Diskgroup_volume_clausesContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Diskgroup_volume_clausesContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Diskgroup_volume_clausesContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Diskgroup_volume_clausesContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Diskgroup_volume_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Diskgroup_volume_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_volume_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_volume_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_volume_clauses(s) + } +} + +func (s *Diskgroup_volume_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_volume_clauses(s) + } +} + +func (s *Diskgroup_volume_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_volume_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_volume_clauses() (localctx IDiskgroup_volume_clausesContext) { + localctx = NewDiskgroup_volume_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 46, PlSqlParserRULE_diskgroup_volume_clauses) + p.SetState(2971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2960) + p.Add_volume_clause() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(2961) + p.Modify_volume_clause() + } + + case PlSqlParserRESIZE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(2962) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2963) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2964) + p.Id_expression() + } + { + p.SetState(2965) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2966) + p.Size_clause() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(2968) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2969) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2970) + p.Id_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_volume_clauseContext is an interface to support dynamic dispatch. +type IAdd_volume_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Redundancy_clause() IRedundancy_clauseContext + STRIPE_WIDTH() antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + STRIPE_COLUMNS() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + + // IsAdd_volume_clauseContext differentiates from other interfaces. + IsAdd_volume_clauseContext() +} + +type Add_volume_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_volume_clauseContext() *Add_volume_clauseContext { + var p = new(Add_volume_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_volume_clause + return p +} + +func InitEmptyAdd_volume_clauseContext(p *Add_volume_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_volume_clause +} + +func (*Add_volume_clauseContext) IsAdd_volume_clauseContext() {} + +func NewAdd_volume_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_volume_clauseContext { + var p = new(Add_volume_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_volume_clause + + return p +} + +func (s *Add_volume_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_volume_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_volume_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Add_volume_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_volume_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Add_volume_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Add_volume_clauseContext) Redundancy_clause() IRedundancy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedundancy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedundancy_clauseContext) +} + +func (s *Add_volume_clauseContext) STRIPE_WIDTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_WIDTH, 0) +} + +func (s *Add_volume_clauseContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Add_volume_clauseContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Add_volume_clauseContext) STRIPE_COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_COLUMNS, 0) +} + +func (s *Add_volume_clauseContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Add_volume_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Add_volume_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_volume_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_volume_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_volume_clause(s) + } +} + +func (s *Add_volume_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_volume_clause(s) + } +} + +func (s *Add_volume_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_volume_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_volume_clause() (localctx IAdd_volume_clauseContext) { + localctx = NewAdd_volume_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 48, PlSqlParserRULE_add_volume_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2973) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2974) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2975) + p.Id_expression() + } + { + p.SetState(2976) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2977) + p.Size_clause() + } + p.SetState(2979) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 75, p.GetParserRuleContext()) == 1 { + { + p.SetState(2978) + p.Redundancy_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2985) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 76, p.GetParserRuleContext()) == 1 { + { + p.SetState(2981) + p.Match(PlSqlParserSTRIPE_WIDTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2982) + p.Numeric() + } + { + p.SetState(2983) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserK_LETTER || _la == PlSqlParserM_LETTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(2989) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 77, p.GetParserRuleContext()) == 1 { + { + p.SetState(2987) + p.Match(PlSqlParserSTRIPE_COLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2988) + p.Numeric() + } + + } 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 +} + +// IModify_volume_clauseContext is an interface to support dynamic dispatch. +type IModify_volume_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + VOLUME() antlr.TerminalNode + Id_expression() IId_expressionContext + MOUNTPATH() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + USAGE() antlr.TerminalNode + + // IsModify_volume_clauseContext differentiates from other interfaces. + IsModify_volume_clauseContext() +} + +type Modify_volume_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_volume_clauseContext() *Modify_volume_clauseContext { + var p = new(Modify_volume_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_volume_clause + return p +} + +func InitEmptyModify_volume_clauseContext(p *Modify_volume_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_volume_clause +} + +func (*Modify_volume_clauseContext) IsModify_volume_clauseContext() {} + +func NewModify_volume_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_volume_clauseContext { + var p = new(Modify_volume_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_volume_clause + + return p +} + +func (s *Modify_volume_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_volume_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_volume_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Modify_volume_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Modify_volume_clauseContext) MOUNTPATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPATH, 0) +} + +func (s *Modify_volume_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Modify_volume_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Modify_volume_clauseContext) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Modify_volume_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_volume_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_volume_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_volume_clause(s) + } +} + +func (s *Modify_volume_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_volume_clause(s) + } +} + +func (s *Modify_volume_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_volume_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_volume_clause() (localctx IModify_volume_clauseContext) { + localctx = NewModify_volume_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 50, PlSqlParserRULE_modify_volume_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(2991) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2992) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2993) + p.Id_expression() + } + p.SetState(2996) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 78, p.GetParserRuleContext()) == 1 { + { + p.SetState(2994) + p.Match(PlSqlParserMOUNTPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2995) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3000) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 79, p.GetParserRuleContext()) == 1 { + { + p.SetState(2998) + p.Match(PlSqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(2999) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDiskgroup_attributesContext is an interface to support dynamic dispatch. +type IDiskgroup_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsDiskgroup_attributesContext differentiates from other interfaces. + IsDiskgroup_attributesContext() +} + +type Diskgroup_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_attributesContext() *Diskgroup_attributesContext { + var p = new(Diskgroup_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes + return p +} + +func InitEmptyDiskgroup_attributesContext(p *Diskgroup_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes +} + +func (*Diskgroup_attributesContext) IsDiskgroup_attributesContext() {} + +func NewDiskgroup_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_attributesContext { + var p = new(Diskgroup_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_attributes + + return p +} + +func (s *Diskgroup_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_attributesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Diskgroup_attributesContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Diskgroup_attributesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Diskgroup_attributesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Diskgroup_attributesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Diskgroup_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_attributes(s) + } +} + +func (s *Diskgroup_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_attributes(s) + } +} + +func (s *Diskgroup_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_attributes() (localctx IDiskgroup_attributesContext) { + localctx = NewDiskgroup_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 52, PlSqlParserRULE_diskgroup_attributes) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3002) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3003) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3004) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3005) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3006) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IModify_diskgroup_fileContext is an interface to support dynamic dispatch. +type IModify_diskgroup_fileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + FILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllATTRIBUTE() []antlr.TerminalNode + ATTRIBUTE(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllDisk_region_clause() []IDisk_region_clauseContext + Disk_region_clause(i int) IDisk_region_clauseContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModify_diskgroup_fileContext differentiates from other interfaces. + IsModify_diskgroup_fileContext() +} + +type Modify_diskgroup_fileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_diskgroup_fileContext() *Modify_diskgroup_fileContext { + var p = new(Modify_diskgroup_fileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_diskgroup_file + return p +} + +func InitEmptyModify_diskgroup_fileContext(p *Modify_diskgroup_fileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_diskgroup_file +} + +func (*Modify_diskgroup_fileContext) IsModify_diskgroup_fileContext() {} + +func NewModify_diskgroup_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_diskgroup_fileContext { + var p = new(Modify_diskgroup_fileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_diskgroup_file + + return p +} + +func (s *Modify_diskgroup_fileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_diskgroup_fileContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_diskgroup_fileContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Modify_diskgroup_fileContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Modify_diskgroup_fileContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Modify_diskgroup_fileContext) AllATTRIBUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserATTRIBUTE) +} + +func (s *Modify_diskgroup_fileContext) ATTRIBUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, i) +} + +func (s *Modify_diskgroup_fileContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Modify_diskgroup_fileContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Modify_diskgroup_fileContext) AllDisk_region_clause() []IDisk_region_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDisk_region_clauseContext); ok { + len++ + } + } + + tst := make([]IDisk_region_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDisk_region_clauseContext); ok { + tst[i] = t.(IDisk_region_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_diskgroup_fileContext) Disk_region_clause(i int) IDisk_region_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisk_region_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDisk_region_clauseContext) +} + +func (s *Modify_diskgroup_fileContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Modify_diskgroup_fileContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Modify_diskgroup_fileContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Modify_diskgroup_fileContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Modify_diskgroup_fileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_diskgroup_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_diskgroup_fileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_diskgroup_file(s) + } +} + +func (s *Modify_diskgroup_fileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_diskgroup_file(s) + } +} + +func (s *Modify_diskgroup_fileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_diskgroup_file(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_diskgroup_file() (localctx IModify_diskgroup_fileContext) { + localctx = NewModify_diskgroup_fileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 54, PlSqlParserRULE_modify_diskgroup_file) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3008) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3009) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3010) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3011) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3012) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3013) + p.Disk_region_clause() + } + { + p.SetState(3014) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3015) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3016) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3017) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3018) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3019) + p.Disk_region_clause() + } + { + p.SetState(3020) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3026) + 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 +} + +// IDisk_region_clauseContext is an interface to support dynamic dispatch. +type IDisk_region_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsDisk_region_clauseContext differentiates from other interfaces. + IsDisk_region_clauseContext() +} + +type Disk_region_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisk_region_clauseContext() *Disk_region_clauseContext { + var p = new(Disk_region_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_region_clause + return p +} + +func InitEmptyDisk_region_clauseContext(p *Disk_region_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disk_region_clause +} + +func (*Disk_region_clauseContext) IsDisk_region_clauseContext() {} + +func NewDisk_region_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disk_region_clauseContext { + var p = new(Disk_region_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disk_region_clause + + return p +} + +func (s *Disk_region_clauseContext) GetParser() antlr.Parser { return s.parser } +func (s *Disk_region_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disk_region_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disk_region_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisk_region_clause(s) + } +} + +func (s *Disk_region_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisk_region_clause(s) + } +} + +func (s *Disk_region_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisk_region_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disk_region_clause() (localctx IDisk_region_clauseContext) { + localctx = NewDisk_region_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 56, PlSqlParserRULE_disk_region_clause) + p.EnterOuterAlt(localctx, 1) + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_diskgroup_file_clauseContext is an interface to support dynamic dispatch. +type IDrop_diskgroup_file_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_diskgroup_file_clauseContext differentiates from other interfaces. + IsDrop_diskgroup_file_clauseContext() +} + +type Drop_diskgroup_file_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_diskgroup_file_clauseContext() *Drop_diskgroup_file_clauseContext { + var p = new(Drop_diskgroup_file_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause + return p +} + +func InitEmptyDrop_diskgroup_file_clauseContext(p *Drop_diskgroup_file_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause +} + +func (*Drop_diskgroup_file_clauseContext) IsDrop_diskgroup_file_clauseContext() {} + +func NewDrop_diskgroup_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_diskgroup_file_clauseContext { + var p = new(Drop_diskgroup_file_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_diskgroup_file_clause + + return p +} + +func (s *Drop_diskgroup_file_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_diskgroup_file_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_diskgroup_file_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Drop_diskgroup_file_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Drop_diskgroup_file_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Drop_diskgroup_file_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_diskgroup_file_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_diskgroup_file_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_diskgroup_file_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_diskgroup_file_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_diskgroup_file_clause(s) + } +} + +func (s *Drop_diskgroup_file_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_diskgroup_file_clause(s) + } +} + +func (s *Drop_diskgroup_file_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_diskgroup_file_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_diskgroup_file_clause() (localctx IDrop_diskgroup_file_clauseContext) { + localctx = NewDrop_diskgroup_file_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 58, PlSqlParserRULE_drop_diskgroup_file_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3029) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3030) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3031) + p.Filename() + } + p.SetState(3036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 81, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3032) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3033) + p.Filename() + } + + } + p.SetState(3038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 81, 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 +} + +// IConvert_redundancy_clauseContext is an interface to support dynamic dispatch. +type IConvert_redundancy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONVERT() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + TO() antlr.TerminalNode + FLEX() antlr.TerminalNode + + // IsConvert_redundancy_clauseContext differentiates from other interfaces. + IsConvert_redundancy_clauseContext() +} + +type Convert_redundancy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConvert_redundancy_clauseContext() *Convert_redundancy_clauseContext { + var p = new(Convert_redundancy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause + return p +} + +func InitEmptyConvert_redundancy_clauseContext(p *Convert_redundancy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause +} + +func (*Convert_redundancy_clauseContext) IsConvert_redundancy_clauseContext() {} + +func NewConvert_redundancy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Convert_redundancy_clauseContext { + var p = new(Convert_redundancy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_convert_redundancy_clause + + return p +} + +func (s *Convert_redundancy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Convert_redundancy_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Convert_redundancy_clauseContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Convert_redundancy_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Convert_redundancy_clauseContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Convert_redundancy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Convert_redundancy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Convert_redundancy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConvert_redundancy_clause(s) + } +} + +func (s *Convert_redundancy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConvert_redundancy_clause(s) + } +} + +func (s *Convert_redundancy_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConvert_redundancy_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Convert_redundancy_clause() (localctx IConvert_redundancy_clauseContext) { + localctx = NewConvert_redundancy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 60, PlSqlParserRULE_convert_redundancy_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3039) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3040) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3041) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3042) + p.Match(PlSqlParserFLEX) + 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 +} + +// IUsergroup_clausesContext is an interface to support dynamic dispatch. +type IUsergroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + USERGROUP() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + MEMBER() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + MODIFY() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsUsergroup_clausesContext differentiates from other interfaces. + IsUsergroup_clausesContext() +} + +type Usergroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsergroup_clausesContext() *Usergroup_clausesContext { + var p = new(Usergroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_usergroup_clauses + return p +} + +func InitEmptyUsergroup_clausesContext(p *Usergroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_usergroup_clauses +} + +func (*Usergroup_clausesContext) IsUsergroup_clausesContext() {} + +func NewUsergroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Usergroup_clausesContext { + var p = new(Usergroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_usergroup_clauses + + return p +} + +func (s *Usergroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Usergroup_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Usergroup_clausesContext) USERGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERGROUP, 0) +} + +func (s *Usergroup_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Usergroup_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Usergroup_clausesContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Usergroup_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Usergroup_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Usergroup_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Usergroup_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Usergroup_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Usergroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Usergroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Usergroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsergroup_clauses(s) + } +} + +func (s *Usergroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsergroup_clauses(s) + } +} + +func (s *Usergroup_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsergroup_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Usergroup_clauses() (localctx IUsergroup_clausesContext) { + localctx = NewUsergroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 62, PlSqlParserRULE_usergroup_clauses) + var _la int + + var _alt int + + p.SetState(3073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3044) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3045) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3046) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3047) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3048) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3049) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 82, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3050) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3051) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 82, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3057) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3058) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3059) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3060) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3061) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3062) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3067) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 83, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3063) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3064) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 83, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3070) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3071) + p.Match(PlSqlParserUSERGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3072) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IUser_clausesContext is an interface to support dynamic dispatch. +type IUser_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + USER() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + CASCADE() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + + // IsUser_clausesContext differentiates from other interfaces. + IsUser_clausesContext() +} + +type User_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_clausesContext() *User_clausesContext { + var p = new(User_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_clauses + return p +} + +func InitEmptyUser_clausesContext(p *User_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_clauses +} + +func (*User_clausesContext) IsUser_clausesContext() {} + +func NewUser_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_clausesContext { + var p = new(User_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_clauses + + return p +} + +func (s *User_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *User_clausesContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *User_clausesContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *User_clausesContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *User_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *User_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *User_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *User_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *User_clausesContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *User_clausesContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *User_clausesContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *User_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_clauses(s) + } +} + +func (s *User_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_clauses(s) + } +} + +func (s *User_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_clauses() (localctx IUser_clausesContext) { + localctx = NewUser_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 64, PlSqlParserRULE_user_clauses) + var _alt int + + p.SetState(3112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3075) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3076) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3077) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 85, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3078) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3079) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 85, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3085) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3086) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3087) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 86, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3088) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3089) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 86, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3096) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 87, p.GetParserRuleContext()) == 1 { + { + p.SetState(3095) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserREPLACE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3098) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3099) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3100) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3101) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3102) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3103) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3104) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3105) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3106) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 88, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IFile_permissions_clauseContext is an interface to support dynamic dispatch. +type IFile_permissions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + PERMISSION() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + FILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllOWNER() []antlr.TerminalNode + OWNER(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllOTHER() []antlr.TerminalNode + OTHER(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllREAD() []antlr.TerminalNode + READ(i int) antlr.TerminalNode + AllONLY() []antlr.TerminalNode + ONLY(i int) antlr.TerminalNode + AllWRITE() []antlr.TerminalNode + WRITE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_permissions_clauseContext differentiates from other interfaces. + IsFile_permissions_clauseContext() +} + +type File_permissions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_permissions_clauseContext() *File_permissions_clauseContext { + var p = new(File_permissions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_permissions_clause + return p +} + +func InitEmptyFile_permissions_clauseContext(p *File_permissions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_permissions_clause +} + +func (*File_permissions_clauseContext) IsFile_permissions_clauseContext() {} + +func NewFile_permissions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_permissions_clauseContext { + var p = new(File_permissions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_permissions_clause + + return p +} + +func (s *File_permissions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_permissions_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *File_permissions_clauseContext) PERMISSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMISSION, 0) +} + +func (s *File_permissions_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *File_permissions_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *File_permissions_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *File_permissions_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *File_permissions_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *File_permissions_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *File_permissions_clauseContext) AllOWNER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOWNER) +} + +func (s *File_permissions_clauseContext) OWNER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, i) +} + +func (s *File_permissions_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *File_permissions_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *File_permissions_clauseContext) AllOTHER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOTHER) +} + +func (s *File_permissions_clauseContext) OTHER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOTHER, i) +} + +func (s *File_permissions_clauseContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNONE) +} + +func (s *File_permissions_clauseContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, i) +} + +func (s *File_permissions_clauseContext) AllREAD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREAD) +} + +func (s *File_permissions_clauseContext) READ(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, i) +} + +func (s *File_permissions_clauseContext) AllONLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLY) +} + +func (s *File_permissions_clauseContext) ONLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, i) +} + +func (s *File_permissions_clauseContext) AllWRITE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWRITE) +} + +func (s *File_permissions_clauseContext) WRITE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, i) +} + +func (s *File_permissions_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_permissions_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_permissions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_permissions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_permissions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_permissions_clause(s) + } +} + +func (s *File_permissions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_permissions_clause(s) + } +} + +func (s *File_permissions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_permissions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_permissions_clause() (localctx IFile_permissions_clauseContext) { + localctx = NewFile_permissions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 66, PlSqlParserRULE_file_permissions_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3114) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3115) + p.Match(PlSqlParserPERMISSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3116) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOTHER || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3117) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNONE: + { + p.SetState(3118) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(3119) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3120) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3123) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3124) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOTHER || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3125) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNONE: + { + p.SetState(3126) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(3127) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3128) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3136) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3137) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3138) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 93, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3139) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3140) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 93, 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 +} + +// IFile_owner_clauseContext is an interface to support dynamic dispatch. +type IFile_owner_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + FILE() antlr.TerminalNode + AllOWNER() []antlr.TerminalNode + OWNER(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_owner_clauseContext differentiates from other interfaces. + IsFile_owner_clauseContext() +} + +type File_owner_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_owner_clauseContext() *File_owner_clauseContext { + var p = new(File_owner_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_owner_clause + return p +} + +func InitEmptyFile_owner_clauseContext(p *File_owner_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_owner_clause +} + +func (*File_owner_clauseContext) IsFile_owner_clauseContext() {} + +func NewFile_owner_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_owner_clauseContext { + var p = new(File_owner_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_owner_clause + + return p +} + +func (s *File_owner_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_owner_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *File_owner_clauseContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNERSHIP, 0) +} + +func (s *File_owner_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *File_owner_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *File_owner_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *File_owner_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *File_owner_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *File_owner_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *File_owner_clauseContext) AllOWNER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOWNER) +} + +func (s *File_owner_clauseContext) OWNER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, i) +} + +func (s *File_owner_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *File_owner_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *File_owner_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_owner_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_owner_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_owner_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_owner_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_owner_clause(s) + } +} + +func (s *File_owner_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_owner_clause(s) + } +} + +func (s *File_owner_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_owner_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_owner_clause() (localctx IFile_owner_clauseContext) { + localctx = NewFile_owner_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 68, PlSqlParserRULE_file_owner_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3146) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3147) + p.Match(PlSqlParserOWNERSHIP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3148) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3149) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3150) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3151) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3152) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserOWNER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3153) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3154) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3160) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3161) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3162) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 95, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3163) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3164) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 95, 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 +} + +// IScrub_clauseContext is an interface to support dynamic dispatch. +type IScrub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCRUB() antlr.TerminalNode + FILE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + DISK() antlr.TerminalNode + Id_expression() IId_expressionContext + POWER() antlr.TerminalNode + Wait_nowait() IWait_nowaitContext + Force_noforce() IForce_noforceContext + STOP() antlr.TerminalNode + REPAIR() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + AUTO() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + MAX() antlr.TerminalNode + + // IsScrub_clauseContext differentiates from other interfaces. + IsScrub_clauseContext() +} + +type Scrub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyScrub_clauseContext() *Scrub_clauseContext { + var p = new(Scrub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scrub_clause + return p +} + +func InitEmptyScrub_clauseContext(p *Scrub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scrub_clause +} + +func (*Scrub_clauseContext) IsScrub_clauseContext() {} + +func NewScrub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scrub_clauseContext { + var p = new(Scrub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_scrub_clause + + return p +} + +func (s *Scrub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Scrub_clauseContext) SCRUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCRUB, 0) +} + +func (s *Scrub_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Scrub_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Scrub_clauseContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Scrub_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Scrub_clauseContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Scrub_clauseContext) Wait_nowait() IWait_nowaitContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowaitContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowaitContext) +} + +func (s *Scrub_clauseContext) Force_noforce() IForce_noforceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Scrub_clauseContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Scrub_clauseContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Scrub_clauseContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Scrub_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Scrub_clauseContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Scrub_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Scrub_clauseContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Scrub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Scrub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Scrub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterScrub_clause(s) + } +} + +func (s *Scrub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitScrub_clause(s) + } +} + +func (s *Scrub_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitScrub_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Scrub_clause() (localctx IScrub_clauseContext) { + localctx = NewScrub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 70, PlSqlParserRULE_scrub_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3170) + p.Match(PlSqlParserSCRUB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3175) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 96, p.GetParserRuleContext()) == 1 { + { + p.SetState(3171) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3172) + p.Match(PlSqlParserCHAR_STRING) + 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(), 96, p.GetParserRuleContext()) == 2 { + { + p.SetState(3173) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3174) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3178) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 97, p.GetParserRuleContext()) == 1 { + { + p.SetState(3177) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOREPAIR || _la == PlSqlParserREPAIR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3182) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 98, p.GetParserRuleContext()) == 1 { + { + p.SetState(3180) + p.Match(PlSqlParserPOWER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3181) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTO || _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMAX) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3185) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 99, p.GetParserRuleContext()) == 1 { + { + p.SetState(3184) + p.Wait_nowait() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3188) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 100, p.GetParserRuleContext()) == 1 { + { + p.SetState(3187) + p.Force_noforce() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3191) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 101, p.GetParserRuleContext()) == 1 { + { + p.SetState(3190) + p.Match(PlSqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuotagroup_clausesContext is an interface to support dynamic dispatch. +type IQuotagroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + QUOTAGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SET() antlr.TerminalNode + Property_name() IProperty_nameContext + EQUALS_OP() antlr.TerminalNode + Property_value() IProperty_valueContext + MODIFY() antlr.TerminalNode + MOVE() antlr.TerminalNode + TO() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsQuotagroup_clausesContext differentiates from other interfaces. + IsQuotagroup_clausesContext() +} + +type Quotagroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuotagroup_clausesContext() *Quotagroup_clausesContext { + var p = new(Quotagroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses + return p +} + +func InitEmptyQuotagroup_clausesContext(p *Quotagroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses +} + +func (*Quotagroup_clausesContext) IsQuotagroup_clausesContext() {} + +func NewQuotagroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quotagroup_clausesContext { + var p = new(Quotagroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quotagroup_clauses + + return p +} + +func (s *Quotagroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quotagroup_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Quotagroup_clausesContext) QUOTAGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTAGROUP, 0) +} + +func (s *Quotagroup_clausesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Quotagroup_clausesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Quotagroup_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Quotagroup_clausesContext) Property_name() IProperty_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_nameContext) +} + +func (s *Quotagroup_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Quotagroup_clausesContext) Property_value() IProperty_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_valueContext) +} + +func (s *Quotagroup_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Quotagroup_clausesContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Quotagroup_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Quotagroup_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Quotagroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quotagroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quotagroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuotagroup_clauses(s) + } +} + +func (s *Quotagroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuotagroup_clauses(s) + } +} + +func (s *Quotagroup_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuotagroup_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quotagroup_clauses() (localctx IQuotagroup_clausesContext) { + localctx = NewQuotagroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 72, PlSqlParserRULE_quotagroup_clauses) + p.SetState(3220) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3193) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3194) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3195) + p.Id_expression() + } + p.SetState(3201) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 102, p.GetParserRuleContext()) == 1 { + { + p.SetState(3196) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3197) + p.Property_name() + } + { + p.SetState(3198) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3199) + p.Property_value() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3203) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3204) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3205) + p.Id_expression() + } + { + p.SetState(3206) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3207) + p.Property_name() + } + { + p.SetState(3208) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3209) + p.Property_value() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3211) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3212) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3213) + p.Id_expression() + } + { + p.SetState(3214) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3215) + p.Id_expression() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3217) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3218) + p.Match(PlSqlParserQUOTAGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3219) + p.Id_expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperty_nameContext is an interface to support dynamic dispatch. +type IProperty_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsProperty_nameContext differentiates from other interfaces. + IsProperty_nameContext() +} + +type Property_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperty_nameContext() *Property_nameContext { + var p = new(Property_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_name + return p +} + +func InitEmptyProperty_nameContext(p *Property_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_name +} + +func (*Property_nameContext) IsProperty_nameContext() {} + +func NewProperty_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_nameContext { + var p = new(Property_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_name + + return p +} + +func (s *Property_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_name(s) + } +} + +func (s *Property_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_name(s) + } +} + +func (s *Property_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProperty_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Property_name() (localctx IProperty_nameContext) { + localctx = NewProperty_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 74, PlSqlParserRULE_property_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3222) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProperty_valueContext is an interface to support dynamic dispatch. +type IProperty_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsProperty_valueContext differentiates from other interfaces. + IsProperty_valueContext() +} + +type Property_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProperty_valueContext() *Property_valueContext { + var p = new(Property_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_value + return p +} + +func InitEmptyProperty_valueContext(p *Property_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_value +} + +func (*Property_valueContext) IsProperty_valueContext() {} + +func NewProperty_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_valueContext { + var p = new(Property_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_value + + return p +} + +func (s *Property_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_valueContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_value(s) + } +} + +func (s *Property_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_value(s) + } +} + +func (s *Property_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProperty_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Property_value() (localctx IProperty_valueContext) { + localctx = NewProperty_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 76, PlSqlParserRULE_property_value) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3224) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFilegroup_clausesContext is an interface to support dynamic dispatch. +type IFilegroup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_filegroup_clause() IAdd_filegroup_clauseContext + Modify_filegroup_clause() IModify_filegroup_clauseContext + Move_to_filegroup_clause() IMove_to_filegroup_clauseContext + Drop_filegroup_clause() IDrop_filegroup_clauseContext + + // IsFilegroup_clausesContext differentiates from other interfaces. + IsFilegroup_clausesContext() +} + +type Filegroup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilegroup_clausesContext() *Filegroup_clausesContext { + var p = new(Filegroup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filegroup_clauses + return p +} + +func InitEmptyFilegroup_clausesContext(p *Filegroup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filegroup_clauses +} + +func (*Filegroup_clausesContext) IsFilegroup_clausesContext() {} + +func NewFilegroup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filegroup_clausesContext { + var p = new(Filegroup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filegroup_clauses + + return p +} + +func (s *Filegroup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filegroup_clausesContext) Add_filegroup_clause() IAdd_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Modify_filegroup_clause() IModify_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Move_to_filegroup_clause() IMove_to_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_to_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_to_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) Drop_filegroup_clause() IDrop_filegroup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_filegroup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_filegroup_clauseContext) +} + +func (s *Filegroup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filegroup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filegroup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilegroup_clauses(s) + } +} + +func (s *Filegroup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilegroup_clauses(s) + } +} + +func (s *Filegroup_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFilegroup_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Filegroup_clauses() (localctx IFilegroup_clausesContext) { + localctx = NewFilegroup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 78, PlSqlParserRULE_filegroup_clauses) + p.SetState(3230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3226) + p.Add_filegroup_clause() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3227) + p.Modify_filegroup_clause() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3228) + p.Move_to_filegroup_clause() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3229) + p.Drop_filegroup_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 +} + +// IAdd_filegroup_clauseContext is an interface to support dynamic dispatch. +type IAdd_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllTEMPLATE() []antlr.TerminalNode + TEMPLATE(i int) antlr.TerminalNode + DATABASE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + VOLUME() antlr.TerminalNode + FROM() antlr.TerminalNode + SET() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsAdd_filegroup_clauseContext differentiates from other interfaces. + IsAdd_filegroup_clauseContext() +} + +type Add_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_filegroup_clauseContext() *Add_filegroup_clauseContext { + var p = new(Add_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause + return p +} + +func InitEmptyAdd_filegroup_clauseContext(p *Add_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause +} + +func (*Add_filegroup_clauseContext) IsAdd_filegroup_clauseContext() {} + +func NewAdd_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_filegroup_clauseContext { + var p = new(Add_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_filegroup_clause + + return p +} + +func (s *Add_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_filegroup_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Add_filegroup_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Add_filegroup_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Add_filegroup_clauseContext) AllTEMPLATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTEMPLATE) +} + +func (s *Add_filegroup_clauseContext) TEMPLATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, i) +} + +func (s *Add_filegroup_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Add_filegroup_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Add_filegroup_clauseContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Add_filegroup_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Add_filegroup_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Add_filegroup_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_filegroup_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_filegroup_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Add_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_filegroup_clause(s) + } +} + +func (s *Add_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_filegroup_clause(s) + } +} + +func (s *Add_filegroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_filegroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_filegroup_clause() (localctx IAdd_filegroup_clauseContext) { + localctx = NewAdd_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 80, PlSqlParserRULE_add_filegroup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3232) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3233) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3234) + p.Id_expression() + } + p.SetState(3238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCLUSTER, PlSqlParserDATABASE, PlSqlParserVOLUME: + { + p.SetState(3235) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLUSTER || _la == PlSqlParserDATABASE || _la == PlSqlParserVOLUME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3236) + p.Id_expression() + } + + case PlSqlParserTEMPLATE: + { + p.SetState(3237) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3243) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 106, p.GetParserRuleContext()) == 1 { + { + p.SetState(3240) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3241) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3242) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3249) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 107, p.GetParserRuleContext()) == 1 { + { + p.SetState(3245) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3246) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3247) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3248) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_filegroup_clauseContext is an interface to support dynamic dispatch. +type IModify_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + SET() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + + // IsModify_filegroup_clauseContext differentiates from other interfaces. + IsModify_filegroup_clauseContext() +} + +type Modify_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_filegroup_clauseContext() *Modify_filegroup_clauseContext { + var p = new(Modify_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause + return p +} + +func InitEmptyModify_filegroup_clauseContext(p *Modify_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause +} + +func (*Modify_filegroup_clauseContext) IsModify_filegroup_clauseContext() {} + +func NewModify_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_filegroup_clauseContext { + var p = new(Modify_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_filegroup_clause + + return p +} + +func (s *Modify_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_filegroup_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Modify_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Modify_filegroup_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Modify_filegroup_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Modify_filegroup_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Modify_filegroup_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Modify_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_filegroup_clause(s) + } +} + +func (s *Modify_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_filegroup_clause(s) + } +} + +func (s *Modify_filegroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_filegroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_filegroup_clause() (localctx IModify_filegroup_clauseContext) { + localctx = NewModify_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 82, PlSqlParserRULE_modify_filegroup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3251) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3252) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3253) + p.Id_expression() + } + { + p.SetState(3254) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3255) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3256) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3257) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IMove_to_filegroup_clauseContext is an interface to support dynamic dispatch. +type IMove_to_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + FILE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + TO() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsMove_to_filegroup_clauseContext differentiates from other interfaces. + IsMove_to_filegroup_clauseContext() +} + +type Move_to_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_to_filegroup_clauseContext() *Move_to_filegroup_clauseContext { + var p = new(Move_to_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause + return p +} + +func InitEmptyMove_to_filegroup_clauseContext(p *Move_to_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause +} + +func (*Move_to_filegroup_clauseContext) IsMove_to_filegroup_clauseContext() {} + +func NewMove_to_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_to_filegroup_clauseContext { + var p = new(Move_to_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_to_filegroup_clause + + return p +} + +func (s *Move_to_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_to_filegroup_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_to_filegroup_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Move_to_filegroup_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Move_to_filegroup_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_to_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Move_to_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Move_to_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_to_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_to_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_to_filegroup_clause(s) + } +} + +func (s *Move_to_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_to_filegroup_clause(s) + } +} + +func (s *Move_to_filegroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMove_to_filegroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Move_to_filegroup_clause() (localctx IMove_to_filegroup_clauseContext) { + localctx = NewMove_to_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 84, PlSqlParserRULE_move_to_filegroup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3259) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3260) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3261) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3262) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3263) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3264) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_filegroup_clauseContext is an interface to support dynamic dispatch. +type IDrop_filegroup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + CASCADE() antlr.TerminalNode + + // IsDrop_filegroup_clauseContext differentiates from other interfaces. + IsDrop_filegroup_clauseContext() +} + +type Drop_filegroup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_filegroup_clauseContext() *Drop_filegroup_clauseContext { + var p = new(Drop_filegroup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause + return p +} + +func InitEmptyDrop_filegroup_clauseContext(p *Drop_filegroup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause +} + +func (*Drop_filegroup_clauseContext) IsDrop_filegroup_clauseContext() {} + +func NewDrop_filegroup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_filegroup_clauseContext { + var p = new(Drop_filegroup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_filegroup_clause + + return p +} + +func (s *Drop_filegroup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_filegroup_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_filegroup_clauseContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Drop_filegroup_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_filegroup_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_filegroup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_filegroup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_filegroup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_filegroup_clause(s) + } +} + +func (s *Drop_filegroup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_filegroup_clause(s) + } +} + +func (s *Drop_filegroup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_filegroup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_filegroup_clause() (localctx IDrop_filegroup_clauseContext) { + localctx = NewDrop_filegroup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 86, PlSqlParserRULE_drop_filegroup_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3266) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3267) + p.Match(PlSqlParserFILEGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3268) + p.Id_expression() + } + p.SetState(3270) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 108, p.GetParserRuleContext()) == 1 { + { + p.SetState(3269) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuorum_regularContext is an interface to support dynamic dispatch. +type IQuorum_regularContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUORUM() antlr.TerminalNode + REGULAR() antlr.TerminalNode + + // IsQuorum_regularContext differentiates from other interfaces. + IsQuorum_regularContext() +} + +type Quorum_regularContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuorum_regularContext() *Quorum_regularContext { + var p = new(Quorum_regularContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quorum_regular + return p +} + +func InitEmptyQuorum_regularContext(p *Quorum_regularContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quorum_regular +} + +func (*Quorum_regularContext) IsQuorum_regularContext() {} + +func NewQuorum_regularContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quorum_regularContext { + var p = new(Quorum_regularContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quorum_regular + + return p +} + +func (s *Quorum_regularContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quorum_regularContext) QUORUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUORUM, 0) +} + +func (s *Quorum_regularContext) REGULAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR, 0) +} + +func (s *Quorum_regularContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quorum_regularContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quorum_regularContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuorum_regular(s) + } +} + +func (s *Quorum_regularContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuorum_regular(s) + } +} + +func (s *Quorum_regularContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuorum_regular(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quorum_regular() (localctx IQuorum_regularContext) { + localctx = NewQuorum_regularContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 88, PlSqlParserRULE_quorum_regular) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3272) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR) { + 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 +} + +// IUndrop_disk_clauseContext is an interface to support dynamic dispatch. +type IUndrop_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDROP() antlr.TerminalNode + DISKS() antlr.TerminalNode + + // IsUndrop_disk_clauseContext differentiates from other interfaces. + IsUndrop_disk_clauseContext() +} + +type Undrop_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndrop_disk_clauseContext() *Undrop_disk_clauseContext { + var p = new(Undrop_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause + return p +} + +func InitEmptyUndrop_disk_clauseContext(p *Undrop_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause +} + +func (*Undrop_disk_clauseContext) IsUndrop_disk_clauseContext() {} + +func NewUndrop_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undrop_disk_clauseContext { + var p = new(Undrop_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undrop_disk_clause + + return p +} + +func (s *Undrop_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undrop_disk_clauseContext) UNDROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDROP, 0) +} + +func (s *Undrop_disk_clauseContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Undrop_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undrop_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undrop_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndrop_disk_clause(s) + } +} + +func (s *Undrop_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndrop_disk_clause(s) + } +} + +func (s *Undrop_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUndrop_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Undrop_disk_clause() (localctx IUndrop_disk_clauseContext) { + localctx = NewUndrop_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 90, PlSqlParserRULE_undrop_disk_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3274) + p.Match(PlSqlParserUNDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3275) + p.Match(PlSqlParserDISKS) + 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 +} + +// IDiskgroup_availabilityContext is an interface to support dynamic dispatch. +type IDiskgroup_availabilityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNT() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + NORMAL() antlr.TerminalNode + FORCE() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + + // IsDiskgroup_availabilityContext differentiates from other interfaces. + IsDiskgroup_availabilityContext() +} + +type Diskgroup_availabilityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDiskgroup_availabilityContext() *Diskgroup_availabilityContext { + var p = new(Diskgroup_availabilityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_availability + return p +} + +func InitEmptyDiskgroup_availabilityContext(p *Diskgroup_availabilityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_diskgroup_availability +} + +func (*Diskgroup_availabilityContext) IsDiskgroup_availabilityContext() {} + +func NewDiskgroup_availabilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Diskgroup_availabilityContext { + var p = new(Diskgroup_availabilityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_diskgroup_availability + + return p +} + +func (s *Diskgroup_availabilityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Diskgroup_availabilityContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Diskgroup_availabilityContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *Diskgroup_availabilityContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Diskgroup_availabilityContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Diskgroup_availabilityContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Diskgroup_availabilityContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Diskgroup_availabilityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Diskgroup_availabilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Diskgroup_availabilityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDiskgroup_availability(s) + } +} + +func (s *Diskgroup_availabilityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDiskgroup_availability(s) + } +} + +func (s *Diskgroup_availabilityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDiskgroup_availability(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Diskgroup_availability() (localctx IDiskgroup_availabilityContext) { + localctx = NewDiskgroup_availabilityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 92, PlSqlParserRULE_diskgroup_availability) + var _la int + + p.SetState(3288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMOUNT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3277) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3279) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 109, p.GetParserRuleContext()) == 1 { + { + p.SetState(3278) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORMAL || _la == PlSqlParserRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3282) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 110, p.GetParserRuleContext()) == 1 { + { + p.SetState(3281) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserDISMOUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3284) + p.Match(PlSqlParserDISMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3286) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 111, p.GetParserRuleContext()) == 1 { + { + p.SetState(3285) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } 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 +} + +// IEnable_disable_volumeContext is an interface to support dynamic dispatch. +type IEnable_disable_volumeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VOLUME() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnable_disable_volumeContext differentiates from other interfaces. + IsEnable_disable_volumeContext() +} + +type Enable_disable_volumeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_disable_volumeContext() *Enable_disable_volumeContext { + var p = new(Enable_disable_volumeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_volume + return p +} + +func InitEmptyEnable_disable_volumeContext(p *Enable_disable_volumeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_volume +} + +func (*Enable_disable_volumeContext) IsEnable_disable_volumeContext() {} + +func NewEnable_disable_volumeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_disable_volumeContext { + var p = new(Enable_disable_volumeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_disable_volume + + return p +} + +func (s *Enable_disable_volumeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_disable_volumeContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Enable_disable_volumeContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_disable_volumeContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_disable_volumeContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Enable_disable_volumeContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Enable_disable_volumeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Enable_disable_volumeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Enable_disable_volumeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Enable_disable_volumeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_disable_volumeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_disable_volumeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_disable_volume(s) + } +} + +func (s *Enable_disable_volumeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_disable_volume(s) + } +} + +func (s *Enable_disable_volumeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnable_disable_volume(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Enable_disable_volume() (localctx IEnable_disable_volumeContext) { + localctx = NewEnable_disable_volumeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 94, PlSqlParserRULE_enable_disable_volume) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3290) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3291) + p.Match(PlSqlParserVOLUME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(3292) + p.Id_expression() + } + p.SetState(3297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3293) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3294) + p.Id_expression() + } + + } + p.SetState(3299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 113, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(3300) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_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 + Function_name() IFunction_nameContext + SEMICOLON() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_function + return p +} + +func InitEmptyDrop_functionContext(p *Drop_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_function + + return p +} + +func (s *Drop_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_functionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Drop_functionContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Drop_functionContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_function(s) + } +} + +func (s *Drop_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_function(s) + } +} + +func (s *Drop_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_function() (localctx IDrop_functionContext) { + localctx = NewDrop_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 96, PlSqlParserRULE_drop_function) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3303) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3304) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3305) + p.Function_name() + } + { + p.SetState(3306) + p.Match(PlSqlParserSEMICOLON) + 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_flashback_archiveContext is an interface to support dynamic dispatch. +type IAlter_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // GetRts returns the rts rule contexts. + GetRts() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // SetRts sets the rts rule contexts. + SetRts(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SET() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + REMOVE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + Flashback_archive_retention() IFlashback_archive_retentionContext + PURGE() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + DATA() antlr.TerminalNode + ADD() antlr.TerminalNode + ALL() antlr.TerminalNode + BEFORE() antlr.TerminalNode + Flashback_archive_quota() IFlashback_archive_quotaContext + NO() antlr.TerminalNode + SCN() antlr.TerminalNode + Expression() IExpressionContext + TIMESTAMP() antlr.TerminalNode + + // IsAlter_flashback_archiveContext differentiates from other interfaces. + IsAlter_flashback_archiveContext() +} + +type Alter_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext + ts IId_expressionContext + rts IId_expressionContext +} + +func NewEmptyAlter_flashback_archiveContext() *Alter_flashback_archiveContext { + var p = new(Alter_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive + return p +} + +func InitEmptyAlter_flashback_archiveContext(p *Alter_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive +} + +func (*Alter_flashback_archiveContext) IsAlter_flashback_archiveContext() {} + +func NewAlter_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_flashback_archiveContext { + var p = new(Alter_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_flashback_archive + + return p +} + +func (s *Alter_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Alter_flashback_archiveContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Alter_flashback_archiveContext) GetRts() IId_expressionContext { return s.rts } + +func (s *Alter_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Alter_flashback_archiveContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Alter_flashback_archiveContext) SetRts(v IId_expressionContext) { s.rts = v } + +func (s *Alter_flashback_archiveContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Alter_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Alter_flashback_archiveContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_flashback_archiveContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_flashback_archiveContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_flashback_archiveContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Alter_flashback_archiveContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_flashback_archiveContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Alter_flashback_archiveContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_flashback_archiveContext) Flashback_archive_retention() IFlashback_archive_retentionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_retentionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_retentionContext) +} + +func (s *Alter_flashback_archiveContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Alter_flashback_archiveContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Alter_flashback_archiveContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Alter_flashback_archiveContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_flashback_archiveContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_flashback_archiveContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Alter_flashback_archiveContext) Flashback_archive_quota() IFlashback_archive_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_quotaContext) +} + +func (s *Alter_flashback_archiveContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Alter_flashback_archiveContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Alter_flashback_archiveContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_flashback_archiveContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Alter_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_flashback_archive(s) + } +} + +func (s *Alter_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_flashback_archive(s) + } +} + +func (s *Alter_flashback_archiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_flashback_archive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_flashback_archive() (localctx IAlter_flashback_archiveContext) { + localctx = NewAlter_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 98, PlSqlParserRULE_alter_flashback_archive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3308) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3309) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3310) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3311) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).fa = _x + } + p.SetState(3341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 119, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3312) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3313) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3314) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserMODIFY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3315) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3316) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).ts = _x + } + p.SetState(3318) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 115, p.GetParserRuleContext()) == 1 { + { + p.SetState(3317) + p.Flashback_archive_quota() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(3320) + p.Match(PlSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3321) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3322) + + var _x = p.Id_expression() + + localctx.(*Alter_flashback_archiveContext).rts = _x + } + + case 4: + { + p.SetState(3323) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3324) + p.Flashback_archive_retention() + } + + case 5: + { + p.SetState(3325) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(3326) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBEFORE: + { + p.SetState(3327) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCN: + { + p.SetState(3328) + p.Match(PlSqlParserSCN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3329) + p.Expression() + } + + case PlSqlParserTIMESTAMP: + { + p.SetState(3330) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3331) + p.Expression() + } + + 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(3337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(3336) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3339) + p.Match(PlSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3340) + p.Match(PlSqlParserDATA) + 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_hierarchyContext is an interface to support dynamic dispatch. +type IAlter_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHn returns the hn rule contexts. + GetHn() IId_expressionContext + + // GetNhn returns the nhn rule contexts. + GetNhn() IId_expressionContext + + // SetHn sets the hn rule contexts. + SetHn(IId_expressionContext) + + // SetNhn sets the nhn rule contexts. + SetNhn(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_hierarchyContext differentiates from other interfaces. + IsAlter_hierarchyContext() +} + +type Alter_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hn IId_expressionContext + nhn IId_expressionContext +} + +func NewEmptyAlter_hierarchyContext() *Alter_hierarchyContext { + var p = new(Alter_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_hierarchy + return p +} + +func InitEmptyAlter_hierarchyContext(p *Alter_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_hierarchy +} + +func (*Alter_hierarchyContext) IsAlter_hierarchyContext() {} + +func NewAlter_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_hierarchyContext { + var p = new(Alter_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_hierarchy + + return p +} + +func (s *Alter_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_hierarchyContext) GetHn() IId_expressionContext { return s.hn } + +func (s *Alter_hierarchyContext) GetNhn() IId_expressionContext { return s.nhn } + +func (s *Alter_hierarchyContext) SetHn(v IId_expressionContext) { s.hn = v } + +func (s *Alter_hierarchyContext) SetNhn(v IId_expressionContext) { s.nhn = v } + +func (s *Alter_hierarchyContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Alter_hierarchyContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_hierarchyContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_hierarchyContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_hierarchyContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_hierarchyContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_hierarchyContext) 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 *Alter_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_hierarchy(s) + } +} + +func (s *Alter_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_hierarchy(s) + } +} + +func (s *Alter_hierarchyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_hierarchy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_hierarchy() (localctx IAlter_hierarchyContext) { + localctx = NewAlter_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 100, PlSqlParserRULE_alter_hierarchy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3343) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3344) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3348) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 120, p.GetParserRuleContext()) == 1 { + { + p.SetState(3345) + p.Schema_name() + } + { + p.SetState(3346) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3350) + + var _x = p.Id_expression() + + localctx.(*Alter_hierarchyContext).hn = _x + } + p.SetState(3355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(3351) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3352) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3353) + + var _x = p.Id_expression() + + localctx.(*Alter_hierarchyContext).nhn = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(3354) + p.Match(PlSqlParserCOMPILE) + 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_functionContext is an interface to support dynamic dispatch. +type IAlter_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + COMPILE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() 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 = PlSqlParserRULE_alter_function + return p +} + +func InitEmptyAlter_functionContext(p *Alter_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_function + + return p +} + +func (s *Alter_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_functionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_functionContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Alter_functionContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Alter_functionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_functionContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_functionContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_functionContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_functionContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_functionContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_functionContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 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.(PlSqlParserListener); ok { + listenerT.EnterAlter_function(s) + } +} + +func (s *Alter_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_function(s) + } +} + +func (s *Alter_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_function() (localctx IAlter_functionContext) { + localctx = NewAlter_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 102, PlSqlParserRULE_alter_function) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3357) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3358) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3359) + p.Function_name() + } + { + p.SetState(3360) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3362) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 122, p.GetParserRuleContext()) == 1 { + { + p.SetState(3361) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3364) + p.Compiler_parameters_clause() + } + + } + p.SetState(3369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 123, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3370) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3371) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3374) + p.Match(PlSqlParserSEMICOLON) + 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_javaContext is an interface to support dynamic dispatch. +type IAlter_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + JAVA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + CLASS() antlr.TerminalNode + Id_expression() IId_expressionContext + COMPILE() antlr.TerminalNode + RESOLVE() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + PERIOD() antlr.TerminalNode + RESOLVER() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllMatch_string() []IMatch_stringContext + Match_string(i int) IMatch_stringContext + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_javaContext differentiates from other interfaces. + IsAlter_javaContext() +} + +type Alter_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyAlter_javaContext() *Alter_javaContext { + var p = new(Alter_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_java + return p +} + +func InitEmptyAlter_javaContext(p *Alter_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_java +} + +func (*Alter_javaContext) IsAlter_javaContext() {} + +func NewAlter_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_javaContext { + var p = new(Alter_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_java + + return p +} + +func (s *Alter_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_javaContext) GetO() IId_expressionContext { return s.o } + +func (s *Alter_javaContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Alter_javaContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Alter_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Alter_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Alter_javaContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_javaContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_javaContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Alter_javaContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Alter_javaContext) 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_javaContext) 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_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_javaContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Alter_javaContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_javaContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_javaContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_javaContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_javaContext) AllMatch_string() []IMatch_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMatch_stringContext); ok { + len++ + } + } + + tst := make([]IMatch_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMatch_stringContext); ok { + tst[i] = t.(IMatch_stringContext) + i++ + } + } + + return tst +} + +func (s *Alter_javaContext) Match_string(i int) IMatch_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMatch_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMatch_stringContext) +} + +func (s *Alter_javaContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *Alter_javaContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *Alter_javaContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_javaContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_java(s) + } +} + +func (s *Alter_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_java(s) + } +} + +func (s *Alter_javaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_java(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_java() (localctx IAlter_javaContext) { + localctx = NewAlter_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 104, PlSqlParserRULE_alter_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3376) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3377) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3378) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3382) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 125, p.GetParserRuleContext()) == 1 { + { + p.SetState(3379) + p.Schema_name() + } + { + p.SetState(3380) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3384) + + var _x = p.Id_expression() + + localctx.(*Alter_javaContext).o = _x + } + p.SetState(3404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESOLVER { + { + p.SetState(3385) + p.Match(PlSqlParserRESOLVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3386) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3387) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3388) + p.Match_string() + } + p.SetState(3390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(3389) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(3392) + p.Schema_name() + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(3393) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3396) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3402) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPILE: + { + p.SetState(3406) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRESOLVE: + { + p.SetState(3407) + p.Match(PlSqlParserRESOLVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTHID: + { + p.SetState(3408) + p.Invoker_rights_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 +} + +// IMatch_stringContext is an interface to support dynamic dispatch. +type IMatch_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + + // IsMatch_stringContext differentiates from other interfaces. + IsMatch_stringContext() +} + +type Match_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMatch_stringContext() *Match_stringContext { + var p = new(Match_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_match_string + return p +} + +func InitEmptyMatch_stringContext(p *Match_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_match_string +} + +func (*Match_stringContext) IsMatch_stringContext() {} + +func NewMatch_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Match_stringContext { + var p = new(Match_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_match_string + + return p +} + +func (s *Match_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Match_stringContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Match_stringContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Match_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Match_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Match_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMatch_string(s) + } +} + +func (s *Match_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMatch_string(s) + } +} + +func (s *Match_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMatch_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Match_string() (localctx IMatch_stringContext) { + localctx = NewMatch_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 106, PlSqlParserRULE_match_string) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3411) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELIMITED_ID || _la == PlSqlParserASTERISK) { + 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_function_bodyContext is an interface to support dynamic dispatch. +type ICreate_function_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + USING() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + Sql_macro_body() ISql_macro_bodyContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllInvoker_rights_clause() []IInvoker_rights_clauseContext + Invoker_rights_clause(i int) IInvoker_rights_clauseContext + AllParallel_enable_clause() []IParallel_enable_clauseContext + Parallel_enable_clause(i int) IParallel_enable_clauseContext + AllResult_cache_clause() []IResult_cache_clauseContext + Result_cache_clause(i int) IResult_cache_clauseContext + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + PIPELINED() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsCreate_function_bodyContext differentiates from other interfaces. + IsCreate_function_bodyContext() +} + +type Create_function_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_function_bodyContext() *Create_function_bodyContext { + var p = new(Create_function_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_function_body + return p +} + +func InitEmptyCreate_function_bodyContext(p *Create_function_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_function_body +} + +func (*Create_function_bodyContext) IsCreate_function_bodyContext() {} + +func NewCreate_function_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_function_bodyContext { + var p = new(Create_function_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_function_body + + return p +} + +func (s *Create_function_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_function_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_function_bodyContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Create_function_bodyContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Create_function_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Create_function_bodyContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Create_function_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_function_bodyContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_function_bodyContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Create_function_bodyContext) Sql_macro_body() ISql_macro_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_macro_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_macro_bodyContext) +} + +func (s *Create_function_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_function_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_function_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_function_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Create_function_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_function_bodyContext) AllInvoker_rights_clause() []IInvoker_rights_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + len++ + } + } + + tst := make([]IInvoker_rights_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInvoker_rights_clauseContext); ok { + tst[i] = t.(IInvoker_rights_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Invoker_rights_clause(i int) IInvoker_rights_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_function_bodyContext) AllParallel_enable_clause() []IParallel_enable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_enable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_enable_clauseContext); ok { + tst[i] = t.(IParallel_enable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Parallel_enable_clause(i int) IParallel_enable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_enable_clauseContext) +} + +func (s *Create_function_bodyContext) AllResult_cache_clause() []IResult_cache_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + len++ + } + } + + tst := make([]IResult_cache_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResult_cache_clauseContext); ok { + tst[i] = t.(IResult_cache_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_function_bodyContext) Result_cache_clause(i int) IResult_cache_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Create_function_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Create_function_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Create_function_bodyContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Create_function_bodyContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Create_function_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_function_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_function_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_function_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_function_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Create_function_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Create_function_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Create_function_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Create_function_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_function_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_function_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_function_body(s) + } +} + +func (s *Create_function_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_function_body(s) + } +} + +func (s *Create_function_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_function_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_function_body() (localctx ICreate_function_bodyContext) { + localctx = NewCreate_function_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 108, PlSqlParserRULE_create_function_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3413) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3414) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3415) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3418) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3419) + p.Function_name() + } + p.SetState(3431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3420) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3421) + p.Parameter() + } + p.SetState(3426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3422) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3423) + p.Parameter() + } + + p.SetState(3428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3429) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3433) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3434) + p.Type_spec() + } + p.SetState(3441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserAUTHID || _la == PlSqlParserDETERMINISTIC || _la == PlSqlParserPARALLEL_ENABLE || _la == PlSqlParserRESULT_CACHE { + p.SetState(3439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAUTHID: + { + p.SetState(3435) + p.Invoker_rights_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(3436) + p.Parallel_enable_clause() + } + + case PlSqlParserRESULT_CACHE: + { + p.SetState(3437) + p.Result_cache_clause() + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(3438) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(3462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 140, p.GetParserRuleContext()) { + case 1: + p.SetState(3445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPIPELINED { + { + p.SetState(3444) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3447) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 139, p.GetParserRuleContext()) { + case 1: + p.SetState(3449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(3448) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3452) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 138, p.GetParserRuleContext()) == 1 { + { + p.SetState(3451) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3454) + p.Body() + } + + case 2: + { + p.SetState(3455) + p.Call_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + { + p.SetState(3458) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAGGREGATE || _la == PlSqlParserPIPELINED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3459) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3460) + p.Implementation_type_name() + } + + case 3: + { + p.SetState(3461) + p.Sql_macro_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3464) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ISql_macro_bodyContext is an interface to support dynamic dispatch. +type ISql_macro_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SQL_MACRO() antlr.TerminalNode + IS() antlr.TerminalNode + BEGIN() antlr.TerminalNode + RETURN() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + SEMICOLON() antlr.TerminalNode + END() antlr.TerminalNode + + // IsSql_macro_bodyContext differentiates from other interfaces. + IsSql_macro_bodyContext() +} + +type Sql_macro_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_macro_bodyContext() *Sql_macro_bodyContext { + var p = new(Sql_macro_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_macro_body + return p +} + +func InitEmptySql_macro_bodyContext(p *Sql_macro_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_macro_body +} + +func (*Sql_macro_bodyContext) IsSql_macro_bodyContext() {} + +func NewSql_macro_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_macro_bodyContext { + var p = new(Sql_macro_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_macro_body + + return p +} + +func (s *Sql_macro_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_macro_bodyContext) SQL_MACRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_MACRO, 0) +} + +func (s *Sql_macro_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Sql_macro_bodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Sql_macro_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Sql_macro_bodyContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Sql_macro_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Sql_macro_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Sql_macro_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_macro_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_macro_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_macro_body(s) + } +} + +func (s *Sql_macro_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_macro_body(s) + } +} + +func (s *Sql_macro_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_macro_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_macro_body() (localctx ISql_macro_bodyContext) { + localctx = NewSql_macro_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 110, PlSqlParserRULE_sql_macro_body) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3466) + p.Match(PlSqlParserSQL_MACRO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3467) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3468) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3469) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3470) + p.Quoted_string() + } + { + p.SetState(3471) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3472) + p.Match(PlSqlParserEND) + 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 +} + +// IParallel_enable_clauseContext is an interface to support dynamic dispatch. +type IParallel_enable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARALLEL_ENABLE() antlr.TerminalNode + Partition_by_clause() IPartition_by_clauseContext + + // IsParallel_enable_clauseContext differentiates from other interfaces. + IsParallel_enable_clauseContext() +} + +type Parallel_enable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParallel_enable_clauseContext() *Parallel_enable_clauseContext { + var p = new(Parallel_enable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause + return p +} + +func InitEmptyParallel_enable_clauseContext(p *Parallel_enable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause +} + +func (*Parallel_enable_clauseContext) IsParallel_enable_clauseContext() {} + +func NewParallel_enable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parallel_enable_clauseContext { + var p = new(Parallel_enable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parallel_enable_clause + + return p +} + +func (s *Parallel_enable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parallel_enable_clauseContext) PARALLEL_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, 0) +} + +func (s *Parallel_enable_clauseContext) Partition_by_clause() IPartition_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_by_clauseContext) +} + +func (s *Parallel_enable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parallel_enable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parallel_enable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParallel_enable_clause(s) + } +} + +func (s *Parallel_enable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParallel_enable_clause(s) + } +} + +func (s *Parallel_enable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParallel_enable_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parallel_enable_clause() (localctx IParallel_enable_clauseContext) { + localctx = NewParallel_enable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 112, PlSqlParserRULE_parallel_enable_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3474) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3475) + p.Partition_by_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 +} + +// IPartition_by_clauseContext is an interface to support dynamic dispatch. +type IPartition_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Expression() IExpressionContext + BY() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + ANY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + HASH() antlr.TerminalNode + RANGE() antlr.TerminalNode + LIST() antlr.TerminalNode + Streaming_clause() IStreaming_clauseContext + + // IsPartition_by_clauseContext differentiates from other interfaces. + IsPartition_by_clauseContext() +} + +type Partition_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_by_clauseContext() *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_by_clause + return p +} + +func InitEmptyPartition_by_clauseContext(p *Partition_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_by_clause +} + +func (*Partition_by_clauseContext) IsPartition_by_clauseContext() {} + +func NewPartition_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_by_clauseContext { + var p = new(Partition_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_by_clause + + return p +} + +func (s *Partition_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_by_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_by_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_by_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Partition_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Partition_by_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_by_clauseContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *Partition_by_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Partition_by_clauseContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Partition_by_clauseContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Partition_by_clauseContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Partition_by_clauseContext) Streaming_clause() IStreaming_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStreaming_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStreaming_clauseContext) +} + +func (s *Partition_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_by_clause(s) + } +} + +func (s *Partition_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_by_clause(s) + } +} + +func (s *Partition_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_by_clause() (localctx IPartition_by_clauseContext) { + localctx = NewPartition_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 114, PlSqlParserRULE_partition_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3478) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3479) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3480) + p.Expression() + } + { + p.SetState(3481) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserANY: + { + p.SetState(3482) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASH, PlSqlParserLIST, PlSqlParserRANGE: + { + p.SetState(3483) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHASH || _la == PlSqlParserLIST || _la == PlSqlParserRANGE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3484) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(3488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLUSTER || _la == PlSqlParserORDER { + { + p.SetState(3487) + p.Streaming_clause() + } + + } + { + p.SetState(3490) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IResult_cache_clauseContext is an interface to support dynamic dispatch. +type IResult_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESULT_CACHE() antlr.TerminalNode + Relies_on_part() IRelies_on_partContext + + // IsResult_cache_clauseContext differentiates from other interfaces. + IsResult_cache_clauseContext() +} + +type Result_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResult_cache_clauseContext() *Result_cache_clauseContext { + var p = new(Result_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_result_cache_clause + return p +} + +func InitEmptyResult_cache_clauseContext(p *Result_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_result_cache_clause +} + +func (*Result_cache_clauseContext) IsResult_cache_clauseContext() {} + +func NewResult_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Result_cache_clauseContext { + var p = new(Result_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_result_cache_clause + + return p +} + +func (s *Result_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Result_cache_clauseContext) RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, 0) +} + +func (s *Result_cache_clauseContext) Relies_on_part() IRelies_on_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelies_on_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelies_on_partContext) +} + +func (s *Result_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Result_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Result_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResult_cache_clause(s) + } +} + +func (s *Result_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResult_cache_clause(s) + } +} + +func (s *Result_cache_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitResult_cache_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Result_cache_clause() (localctx IResult_cache_clauseContext) { + localctx = NewResult_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 116, PlSqlParserRULE_result_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3492) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRELIES_ON { + { + p.SetState(3493) + p.Relies_on_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelies_on_partContext is an interface to support dynamic dispatch. +type IRelies_on_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RELIES_ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelies_on_partContext differentiates from other interfaces. + IsRelies_on_partContext() +} + +type Relies_on_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelies_on_partContext() *Relies_on_partContext { + var p = new(Relies_on_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relies_on_part + return p +} + +func InitEmptyRelies_on_partContext(p *Relies_on_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relies_on_part +} + +func (*Relies_on_partContext) IsRelies_on_partContext() {} + +func NewRelies_on_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relies_on_partContext { + var p = new(Relies_on_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relies_on_part + + return p +} + +func (s *Relies_on_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relies_on_partContext) RELIES_ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELIES_ON, 0) +} + +func (s *Relies_on_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Relies_on_partContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Relies_on_partContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Relies_on_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Relies_on_partContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Relies_on_partContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Relies_on_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relies_on_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relies_on_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelies_on_part(s) + } +} + +func (s *Relies_on_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelies_on_part(s) + } +} + +func (s *Relies_on_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRelies_on_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Relies_on_part() (localctx IRelies_on_partContext) { + localctx = NewRelies_on_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 118, PlSqlParserRULE_relies_on_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3496) + p.Match(PlSqlParserRELIES_ON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3497) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3498) + p.Tableview_name() + } + p.SetState(3503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3499) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3500) + p.Tableview_name() + } + + p.SetState(3505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3506) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStreaming_clauseContext is an interface to support dynamic dispatch. +type IStreaming_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + BY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + ORDER() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + + // IsStreaming_clauseContext differentiates from other interfaces. + IsStreaming_clauseContext() +} + +type Streaming_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStreaming_clauseContext() *Streaming_clauseContext { + var p = new(Streaming_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_streaming_clause + return p +} + +func InitEmptyStreaming_clauseContext(p *Streaming_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_streaming_clause +} + +func (*Streaming_clauseContext) IsStreaming_clauseContext() {} + +func NewStreaming_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Streaming_clauseContext { + var p = new(Streaming_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_streaming_clause + + return p +} + +func (s *Streaming_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Streaming_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Streaming_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Streaming_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Streaming_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Streaming_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Streaming_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Streaming_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Streaming_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStreaming_clause(s) + } +} + +func (s *Streaming_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStreaming_clause(s) + } +} + +func (s *Streaming_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStreaming_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Streaming_clause() (localctx IStreaming_clauseContext) { + localctx = NewStreaming_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 120, PlSqlParserRULE_streaming_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3508) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLUSTER || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3509) + p.Expression() + } + { + p.SetState(3510) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3511) + p.Paren_column_list() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_outlineContext is an interface to support dynamic dispatch. +type IAlter_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + Id_expression() IId_expressionContext + AllOutline_options() []IOutline_optionsContext + Outline_options(i int) IOutline_optionsContext + PUBLIC() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + + // IsAlter_outlineContext differentiates from other interfaces. + IsAlter_outlineContext() +} + +type Alter_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyAlter_outlineContext() *Alter_outlineContext { + var p = new(Alter_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_outline + return p +} + +func InitEmptyAlter_outlineContext(p *Alter_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_outline +} + +func (*Alter_outlineContext) IsAlter_outlineContext() {} + +func NewAlter_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_outlineContext { + var p = new(Alter_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_outline + + return p +} + +func (s *Alter_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Alter_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Alter_outlineContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Alter_outlineContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_outlineContext) AllOutline_options() []IOutline_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOutline_optionsContext); ok { + len++ + } + } + + tst := make([]IOutline_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOutline_optionsContext); ok { + tst[i] = t.(IOutline_optionsContext) + i++ + } + } + + return tst +} + +func (s *Alter_outlineContext) Outline_options(i int) IOutline_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOutline_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOutline_optionsContext) +} + +func (s *Alter_outlineContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_outlineContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Alter_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_outline(s) + } +} + +func (s *Alter_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_outline(s) + } +} + +func (s *Alter_outlineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_outline(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_outline() (localctx IAlter_outlineContext) { + localctx = NewAlter_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 122, PlSqlParserRULE_alter_outline) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3513) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3514) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3516) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 146, p.GetParserRuleContext()) == 1 { + { + p.SetState(3515) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3518) + + var _x = p.Id_expression() + + localctx.(*Alter_outlineContext).o = _x + } + p.SetState(3520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3519) + p.Outline_options() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3522) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 147, 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 +} + +// IOutline_optionsContext is an interface to support dynamic dispatch. +type IOutline_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNon returns the non rule contexts. + GetNon() IId_expressionContext + + // GetNcn returns the ncn rule contexts. + GetNcn() IId_expressionContext + + // SetNon sets the non rule contexts. + SetNon(IId_expressionContext) + + // SetNcn sets the ncn rule contexts. + SetNcn(IId_expressionContext) + + // Getter signatures + REBUILD() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Id_expression() IId_expressionContext + CHANGE() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsOutline_optionsContext differentiates from other interfaces. + IsOutline_optionsContext() +} + +type Outline_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + non IId_expressionContext + ncn IId_expressionContext +} + +func NewEmptyOutline_optionsContext() *Outline_optionsContext { + var p = new(Outline_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outline_options + return p +} + +func InitEmptyOutline_optionsContext(p *Outline_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outline_options +} + +func (*Outline_optionsContext) IsOutline_optionsContext() {} + +func NewOutline_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outline_optionsContext { + var p = new(Outline_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outline_options + + return p +} + +func (s *Outline_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outline_optionsContext) GetNon() IId_expressionContext { return s.non } + +func (s *Outline_optionsContext) GetNcn() IId_expressionContext { return s.ncn } + +func (s *Outline_optionsContext) SetNon(v IId_expressionContext) { s.non = v } + +func (s *Outline_optionsContext) SetNcn(v IId_expressionContext) { s.ncn = v } + +func (s *Outline_optionsContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Outline_optionsContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Outline_optionsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Outline_optionsContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Outline_optionsContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Outline_optionsContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Outline_optionsContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Outline_optionsContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Outline_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outline_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outline_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOutline_options(s) + } +} + +func (s *Outline_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOutline_options(s) + } +} + +func (s *Outline_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOutline_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Outline_options() (localctx IOutline_optionsContext) { + localctx = NewOutline_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 124, PlSqlParserRULE_outline_options) + p.SetState(3534) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREBUILD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3524) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3525) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3526) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3527) + + var _x = p.Id_expression() + + localctx.(*Outline_optionsContext).non = _x + } + + case PlSqlParserCHANGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3528) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3529) + p.Match(PlSqlParserCATEGORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3530) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3531) + + var _x = p.Id_expression() + + localctx.(*Outline_optionsContext).ncn = _x + } + + case PlSqlParserENABLE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3532) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3533) + p.Match(PlSqlParserDISABLE) + 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_lockdown_profileContext is an interface to support dynamic dispatch. +type IAlter_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + Lockdown_feature() ILockdown_featureContext + Lockdown_options() ILockdown_optionsContext + Lockdown_statements() ILockdown_statementsContext + USERS() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + ALL() antlr.TerminalNode + COMMON() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsAlter_lockdown_profileContext differentiates from other interfaces. + IsAlter_lockdown_profileContext() +} + +type Alter_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_lockdown_profileContext() *Alter_lockdown_profileContext { + var p = new(Alter_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile + return p +} + +func InitEmptyAlter_lockdown_profileContext(p *Alter_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile +} + +func (*Alter_lockdown_profileContext) IsAlter_lockdown_profileContext() {} + +func NewAlter_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_lockdown_profileContext { + var p = new(Alter_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_lockdown_profile + + return p +} + +func (s *Alter_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_lockdown_profileContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Alter_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Alter_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_feature() ILockdown_featureContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_featureContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_featureContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_options() ILockdown_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_optionsContext) +} + +func (s *Alter_lockdown_profileContext) Lockdown_statements() ILockdown_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILockdown_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILockdown_statementsContext) +} + +func (s *Alter_lockdown_profileContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Alter_lockdown_profileContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Alter_lockdown_profileContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_lockdown_profileContext) COMMON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON, 0) +} + +func (s *Alter_lockdown_profileContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Alter_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_lockdown_profile(s) + } +} + +func (s *Alter_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_lockdown_profile(s) + } +} + +func (s *Alter_lockdown_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_lockdown_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_lockdown_profile() (localctx IAlter_lockdown_profileContext) { + localctx = NewAlter_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 126, PlSqlParserRULE_alter_lockdown_profile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3536) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3537) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3538) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3539) + p.Id_expression() + } + p.SetState(3543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 149, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3540) + p.Lockdown_feature() + } + + case 2: + { + p.SetState(3541) + p.Lockdown_options() + } + + case 3: + { + p.SetState(3542) + p.Lockdown_statements() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(3548) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 150, p.GetParserRuleContext()) == 1 { + { + p.SetState(3545) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3546) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3547) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCOMMON || _la == PlSqlParserLOCAL) { + 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 +} + +// ILockdown_featureContext is an interface to support dynamic dispatch. +type ILockdown_featureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + FEATURE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_featureContext differentiates from other interfaces. + IsLockdown_featureContext() +} + +type Lockdown_featureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_featureContext() *Lockdown_featureContext { + var p = new(Lockdown_featureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_feature + return p +} + +func InitEmptyLockdown_featureContext(p *Lockdown_featureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_feature +} + +func (*Lockdown_featureContext) IsLockdown_featureContext() {} + +func NewLockdown_featureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_featureContext { + var p = new(Lockdown_featureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_feature + + return p +} + +func (s *Lockdown_featureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_featureContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_featureContext) FEATURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE, 0) +} + +func (s *Lockdown_featureContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_featureContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_featureContext) 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 *Lockdown_featureContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_featureContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_featureContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_featureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_featureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_featureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_feature(s) + } +} + +func (s *Lockdown_featureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_feature(s) + } +} + +func (s *Lockdown_featureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLockdown_feature(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lockdown_feature() (localctx ILockdown_featureContext) { + localctx = NewLockdown_featureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 128, PlSqlParserRULE_lockdown_feature) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3550) + p.Disable_enable() + } + { + p.SetState(3551) + p.Match(PlSqlParserFEATURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEQUALS_OP: + { + p.SetState(3552) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3553) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3554) + p.String_list() + } + { + p.SetState(3555) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(3557) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3564) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 151, p.GetParserRuleContext()) == 1 { + { + p.SetState(3558) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3559) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3560) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3561) + p.String_list() + } + { + p.SetState(3562) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// ILockdown_optionsContext is an interface to support dynamic dispatch. +type ILockdown_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + OPTION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_optionsContext differentiates from other interfaces. + IsLockdown_optionsContext() +} + +type Lockdown_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_optionsContext() *Lockdown_optionsContext { + var p = new(Lockdown_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_options + return p +} + +func InitEmptyLockdown_optionsContext(p *Lockdown_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_options +} + +func (*Lockdown_optionsContext) IsLockdown_optionsContext() {} + +func NewLockdown_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_optionsContext { + var p = new(Lockdown_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_options + + return p +} + +func (s *Lockdown_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_optionsContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_optionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Lockdown_optionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_optionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_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 *Lockdown_optionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_optionsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_optionsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_options(s) + } +} + +func (s *Lockdown_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_options(s) + } +} + +func (s *Lockdown_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLockdown_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lockdown_options() (localctx ILockdown_optionsContext) { + localctx = NewLockdown_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 130, PlSqlParserRULE_lockdown_options) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3568) + p.Disable_enable() + } + { + p.SetState(3569) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEQUALS_OP: + { + p.SetState(3570) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3571) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3572) + p.String_list() + } + { + p.SetState(3573) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(3575) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 153, p.GetParserRuleContext()) == 1 { + { + p.SetState(3576) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3577) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3578) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3579) + p.String_list() + } + { + p.SetState(3580) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// ILockdown_statementsContext is an interface to support dynamic dispatch. +type ILockdown_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Disable_enable() IDisable_enableContext + STATEMENT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Statement_clauses() IStatement_clausesContext + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsLockdown_statementsContext differentiates from other interfaces. + IsLockdown_statementsContext() +} + +type Lockdown_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLockdown_statementsContext() *Lockdown_statementsContext { + var p = new(Lockdown_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_statements + return p +} + +func InitEmptyLockdown_statementsContext(p *Lockdown_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lockdown_statements +} + +func (*Lockdown_statementsContext) IsLockdown_statementsContext() {} + +func NewLockdown_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lockdown_statementsContext { + var p = new(Lockdown_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lockdown_statements + + return p +} + +func (s *Lockdown_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lockdown_statementsContext) Disable_enable() IDisable_enableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDisable_enableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDisable_enableContext) +} + +func (s *Lockdown_statementsContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Lockdown_statementsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lockdown_statementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lockdown_statementsContext) 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 *Lockdown_statementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lockdown_statementsContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Lockdown_statementsContext) Statement_clauses() IStatement_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatement_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatement_clausesContext) +} + +func (s *Lockdown_statementsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Lockdown_statementsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Lockdown_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lockdown_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lockdown_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLockdown_statements(s) + } +} + +func (s *Lockdown_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLockdown_statements(s) + } +} + +func (s *Lockdown_statementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLockdown_statements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lockdown_statements() (localctx ILockdown_statementsContext) { + localctx = NewLockdown_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 132, PlSqlParserRULE_lockdown_statements) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3586) + p.Disable_enable() + } + { + p.SetState(3587) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 156, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3588) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3589) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3590) + p.String_list() + } + { + p.SetState(3591) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3593) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3594) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3595) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3596) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3597) + p.Statement_clauses() + } + + case 3: + { + p.SetState(3598) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3605) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 155, p.GetParserRuleContext()) == 1 { + { + p.SetState(3599) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3600) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3601) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3602) + p.String_list() + } + { + p.SetState(3603) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// IStatement_clausesContext is an interface to support dynamic dispatch. +type IStatement_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLAUSE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Clause_options() IClause_optionsContext + ALL() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + + // IsStatement_clausesContext differentiates from other interfaces. + IsStatement_clausesContext() +} + +type Statement_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatement_clausesContext() *Statement_clausesContext { + var p = new(Statement_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement_clauses + return p +} + +func InitEmptyStatement_clausesContext(p *Statement_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement_clauses +} + +func (*Statement_clausesContext) IsStatement_clausesContext() {} + +func NewStatement_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statement_clausesContext { + var p = new(Statement_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statement_clauses + + return p +} + +func (s *Statement_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statement_clausesContext) CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLAUSE, 0) +} + +func (s *Statement_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Statement_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Statement_clausesContext) 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 *Statement_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Statement_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Statement_clausesContext) Clause_options() IClause_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClause_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClause_optionsContext) +} + +func (s *Statement_clausesContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Statement_clausesContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Statement_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statement_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statement_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatement_clauses(s) + } +} + +func (s *Statement_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatement_clauses(s) + } +} + +func (s *Statement_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStatement_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Statement_clauses() (localctx IStatement_clausesContext) { + localctx = NewStatement_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 134, PlSqlParserRULE_statement_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3609) + p.Match(PlSqlParserCLAUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 158, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3610) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3611) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3612) + p.String_list() + } + { + p.SetState(3613) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3615) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3616) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3617) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3618) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3619) + p.Clause_options() + } + + case 3: + { + p.SetState(3620) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3627) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 157, p.GetParserRuleContext()) == 1 { + { + p.SetState(3621) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3622) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3623) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3624) + p.String_list() + } + { + p.SetState(3625) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// IClause_optionsContext is an interface to support dynamic dispatch. +type IClause_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPTION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + ALL() antlr.TerminalNode + AllOption_values() []IOption_valuesContext + Option_values(i int) IOption_valuesContext + EXCEPT() antlr.TerminalNode + + // IsClause_optionsContext differentiates from other interfaces. + IsClause_optionsContext() +} + +type Clause_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClause_optionsContext() *Clause_optionsContext { + var p = new(Clause_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clause_options + return p +} + +func InitEmptyClause_optionsContext(p *Clause_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clause_options +} + +func (*Clause_optionsContext) IsClause_optionsContext() {} + +func NewClause_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clause_optionsContext { + var p = new(Clause_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clause_options + + return p +} + +func (s *Clause_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clause_optionsContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Clause_optionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Clause_optionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clause_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 *Clause_optionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clause_optionsContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Clause_optionsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Clause_optionsContext) AllOption_values() []IOption_valuesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOption_valuesContext); ok { + len++ + } + } + + tst := make([]IOption_valuesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOption_valuesContext); ok { + tst[i] = t.(IOption_valuesContext) + i++ + } + } + + return tst +} + +func (s *Clause_optionsContext) Option_values(i int) IOption_valuesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOption_valuesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOption_valuesContext) +} + +func (s *Clause_optionsContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Clause_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clause_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clause_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClause_options(s) + } +} + +func (s *Clause_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClause_options(s) + } +} + +func (s *Clause_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClause_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Clause_options() (localctx IClause_optionsContext) { + localctx = NewClause_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 136, PlSqlParserRULE_clause_options) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3631) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 161, p.GetParserRuleContext()) { + case 1: + { + p.SetState(3632) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3633) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3634) + p.String_list() + } + { + p.SetState(3635) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(3637) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3638) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3639) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3640) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(3641) + p.Option_values() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(3644) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 159, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 3: + { + p.SetState(3646) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3653) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 160, p.GetParserRuleContext()) == 1 { + { + p.SetState(3647) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3648) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3649) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3650) + p.String_list() + } + { + p.SetState(3651) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// IOption_valuesContext is an interface to support dynamic dispatch. +type IOption_valuesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + String_list() IString_listContext + RIGHT_PAREN() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + + // IsOption_valuesContext differentiates from other interfaces. + IsOption_valuesContext() +} + +type Option_valuesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOption_valuesContext() *Option_valuesContext { + var p = new(Option_valuesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_option_values + return p +} + +func InitEmptyOption_valuesContext(p *Option_valuesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_option_values +} + +func (*Option_valuesContext) IsOption_valuesContext() {} + +func NewOption_valuesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Option_valuesContext { + var p = new(Option_valuesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_option_values + + return p +} + +func (s *Option_valuesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Option_valuesContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Option_valuesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Option_valuesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Option_valuesContext) 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 *Option_valuesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Option_valuesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Option_valuesContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Option_valuesContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Option_valuesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Option_valuesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Option_valuesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOption_values(s) + } +} + +func (s *Option_valuesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOption_values(s) + } +} + +func (s *Option_valuesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOption_values(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Option_values() (localctx IOption_valuesContext) { + localctx = NewOption_valuesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 138, PlSqlParserRULE_option_values) + var _la int + + p.SetState(3666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALUE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3657) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3658) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3659) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3660) + p.String_list() + } + { + p.SetState(3661) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXVALUE, PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3663) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3664) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3665) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IString_listContext is an interface to support dynamic dispatch. +type IString_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + 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 = PlSqlParserRULE_string_list + return p +} + +func InitEmptyString_listContext(p *String_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_string_list + + return p +} + +func (s *String_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_listContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *String_listContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *String_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *String_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 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.(PlSqlParserListener); ok { + listenerT.EnterString_list(s) + } +} + +func (s *String_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_list(s) + } +} + +func (s *String_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitString_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) String_list() (localctx IString_listContext) { + localctx = NewString_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 140, PlSqlParserRULE_string_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3668) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3669) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3670) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(3675) + 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 +} + +// IDisable_enableContext is an interface to support dynamic dispatch. +type IDisable_enableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + + // IsDisable_enableContext differentiates from other interfaces. + IsDisable_enableContext() +} + +type Disable_enableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisable_enableContext() *Disable_enableContext { + var p = new(Disable_enableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_enable + return p +} + +func InitEmptyDisable_enableContext(p *Disable_enableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_enable +} + +func (*Disable_enableContext) IsDisable_enableContext() {} + +func NewDisable_enableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disable_enableContext { + var p = new(Disable_enableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disable_enable + + return p +} + +func (s *Disable_enableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disable_enableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Disable_enableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Disable_enableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disable_enableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disable_enableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisable_enable(s) + } +} + +func (s *Disable_enableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisable_enable(s) + } +} + +func (s *Disable_enableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisable_enable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disable_enable() (localctx IDisable_enableContext) { + localctx = NewDisable_enableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 142, PlSqlParserRULE_disable_enable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3676) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + 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_lockdown_profileContext is an interface to support dynamic dispatch. +type IDrop_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_lockdown_profileContext differentiates from other interfaces. + IsDrop_lockdown_profileContext() +} + +type Drop_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyDrop_lockdown_profileContext() *Drop_lockdown_profileContext { + var p = new(Drop_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile + return p +} + +func InitEmptyDrop_lockdown_profileContext(p *Drop_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile +} + +func (*Drop_lockdown_profileContext) IsDrop_lockdown_profileContext() {} + +func NewDrop_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_lockdown_profileContext { + var p = new(Drop_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_lockdown_profile + + return p +} + +func (s *Drop_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_lockdown_profileContext) GetP() IId_expressionContext { return s.p } + +func (s *Drop_lockdown_profileContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Drop_lockdown_profileContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Drop_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Drop_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_lockdown_profile(s) + } +} + +func (s *Drop_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_lockdown_profile(s) + } +} + +func (s *Drop_lockdown_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_lockdown_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_lockdown_profile() (localctx IDrop_lockdown_profileContext) { + localctx = NewDrop_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 144, PlSqlParserRULE_drop_lockdown_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3678) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3679) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3680) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3681) + + var _x = p.Id_expression() + + localctx.(*Drop_lockdown_profileContext).p = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_packageContext is an interface to support dynamic dispatch. +type IDrop_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + Package_name() IPackage_nameContext + SEMICOLON() antlr.TerminalNode + BODY() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_packageContext differentiates from other interfaces. + IsDrop_packageContext() +} + +type Drop_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_packageContext() *Drop_packageContext { + var p = new(Drop_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_package + return p +} + +func InitEmptyDrop_packageContext(p *Drop_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_package +} + +func (*Drop_packageContext) IsDrop_packageContext() {} + +func NewDrop_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_packageContext { + var p = new(Drop_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_package + + return p +} + +func (s *Drop_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_packageContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_packageContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Drop_packageContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Drop_packageContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_packageContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Drop_packageContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Drop_packageContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_package(s) + } +} + +func (s *Drop_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_package(s) + } +} + +func (s *Drop_packageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_package(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_package() (localctx IDrop_packageContext) { + localctx = NewDrop_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 146, PlSqlParserRULE_drop_package) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3683) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3684) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 164, p.GetParserRuleContext()) == 1 { + { + p.SetState(3685) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3691) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 165, p.GetParserRuleContext()) == 1 { + { + p.SetState(3688) + p.Schema_object_name() + } + { + p.SetState(3689) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3693) + p.Package_name() + } + { + p.SetState(3694) + p.Match(PlSqlParserSEMICOLON) + 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_packageContext is an interface to support dynamic dispatch. +type IAlter_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AllPACKAGE() []antlr.TerminalNode + PACKAGE(i int) antlr.TerminalNode + Package_name() IPackage_nameContext + COMPILE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + BODY() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + + // IsAlter_packageContext differentiates from other interfaces. + IsAlter_packageContext() +} + +type Alter_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_packageContext() *Alter_packageContext { + var p = new(Alter_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_package + return p +} + +func InitEmptyAlter_packageContext(p *Alter_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_package +} + +func (*Alter_packageContext) IsAlter_packageContext() {} + +func NewAlter_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_packageContext { + var p = new(Alter_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_package + + return p +} + +func (s *Alter_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_packageContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_packageContext) AllPACKAGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPACKAGE) +} + +func (s *Alter_packageContext) PACKAGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, i) +} + +func (s *Alter_packageContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Alter_packageContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_packageContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_packageContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_packageContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_packageContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_packageContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_packageContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_packageContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Alter_packageContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Alter_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_package(s) + } +} + +func (s *Alter_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_package(s) + } +} + +func (s *Alter_packageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_package(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_package() (localctx IAlter_packageContext) { + localctx = NewAlter_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 148, PlSqlParserRULE_alter_package) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3696) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3697) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3698) + p.Package_name() + } + { + p.SetState(3699) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3701) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 166, p.GetParserRuleContext()) == 1 { + { + p.SetState(3700) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3704) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 167, p.GetParserRuleContext()) == 1 { + { + p.SetState(3703) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBODY || _la == PlSqlParserPACKAGE || _la == PlSqlParserSPECIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 168, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3706) + p.Compiler_parameters_clause() + } + + } + p.SetState(3711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 168, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3712) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3713) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3716) + p.Match(PlSqlParserSEMICOLON) + 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_packageContext is an interface to support dynamic dispatch. +type ICreate_packageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + END() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllPackage_obj_spec() []IPackage_obj_specContext + Package_obj_spec(i int) IPackage_obj_specContext + + // IsCreate_packageContext differentiates from other interfaces. + IsCreate_packageContext() +} + +type Create_packageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_packageContext() *Create_packageContext { + var p = new(Create_packageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package + return p +} + +func InitEmptyCreate_packageContext(p *Create_packageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package +} + +func (*Create_packageContext) IsCreate_packageContext() {} + +func NewCreate_packageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_packageContext { + var p = new(Create_packageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_package + + return p +} + +func (s *Create_packageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_packageContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_packageContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Create_packageContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_packageContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_packageContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Create_packageContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_packageContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_packageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_packageContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_packageContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_packageContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_packageContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_packageContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_packageContext) AllPackage_obj_spec() []IPackage_obj_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_obj_specContext); ok { + len++ + } + } + + tst := make([]IPackage_obj_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_obj_specContext); ok { + tst[i] = t.(IPackage_obj_specContext) + i++ + } + } + + return tst +} + +func (s *Create_packageContext) Package_obj_spec(i int) IPackage_obj_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_obj_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_obj_specContext) +} + +func (s *Create_packageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_packageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_packageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_package(s) + } +} + +func (s *Create_packageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_package(s) + } +} + +func (s *Create_packageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_package(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_package() (localctx ICreate_packageContext) { + localctx = NewCreate_packageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 150, PlSqlParserRULE_create_package) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3718) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3719) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3720) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3723) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3727) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 171, p.GetParserRuleContext()) == 1 { + { + p.SetState(3724) + p.Schema_object_name() + } + { + p.SetState(3725) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3729) + p.Package_name() + } + p.SetState(3731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(3730) + p.Invoker_rights_clause() + } + + } + { + p.SetState(3733) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(3734) + p.Package_obj_spec() + } + + p.SetState(3739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3740) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(3741) + p.Package_name() + } + + } + { + p.SetState(3744) + p.Match(PlSqlParserSEMICOLON) + 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_package_bodyContext is an interface to support dynamic dispatch. +type ICreate_package_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + BODY() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + END() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + AllPackage_obj_body() []IPackage_obj_bodyContext + Package_obj_body(i int) IPackage_obj_bodyContext + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsCreate_package_bodyContext differentiates from other interfaces. + IsCreate_package_bodyContext() +} + +type Create_package_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_package_bodyContext() *Create_package_bodyContext { + var p = new(Create_package_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package_body + return p +} + +func InitEmptyCreate_package_bodyContext(p *Create_package_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_package_body +} + +func (*Create_package_bodyContext) IsCreate_package_bodyContext() {} + +func NewCreate_package_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_package_bodyContext { + var p = new(Create_package_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_package_body + + return p +} + +func (s *Create_package_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_package_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_package_bodyContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Create_package_bodyContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Create_package_bodyContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_package_bodyContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_package_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Create_package_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_package_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_package_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_package_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_package_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_package_bodyContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_package_bodyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_package_bodyContext) AllPackage_obj_body() []IPackage_obj_bodyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_obj_bodyContext); ok { + len++ + } + } + + tst := make([]IPackage_obj_bodyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_obj_bodyContext); ok { + tst[i] = t.(IPackage_obj_bodyContext) + i++ + } + } + + return tst +} + +func (s *Create_package_bodyContext) Package_obj_body(i int) IPackage_obj_bodyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_obj_bodyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_obj_bodyContext) +} + +func (s *Create_package_bodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Create_package_bodyContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Create_package_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_package_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_package_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_package_body(s) + } +} + +func (s *Create_package_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_package_body(s) + } +} + +func (s *Create_package_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_package_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_package_body() (localctx ICreate_package_bodyContext) { + localctx = NewCreate_package_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 152, PlSqlParserRULE_create_package_body) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3746) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3747) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3748) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3751) + p.Match(PlSqlParserPACKAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3752) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 176, p.GetParserRuleContext()) == 1 { + { + p.SetState(3753) + p.Schema_object_name() + } + { + p.SetState(3754) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3758) + p.Package_name() + } + { + p.SetState(3759) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 177, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3760) + p.Package_obj_body() + } + + } + p.SetState(3765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 177, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBEGIN { + { + p.SetState(3766) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3767) + p.Seq_of_statements() + } + + } + { + p.SetState(3770) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(3771) + p.Package_name() + } + + } + { + p.SetState(3774) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPackage_obj_specContext is an interface to support dynamic dispatch. +type IPackage_obj_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pragma_declaration() IPragma_declarationContext + Exception_declaration() IException_declarationContext + Variable_declaration() IVariable_declarationContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Type_declaration() IType_declarationContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + + // IsPackage_obj_specContext differentiates from other interfaces. + IsPackage_obj_specContext() +} + +type Package_obj_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_obj_specContext() *Package_obj_specContext { + var p = new(Package_obj_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_spec + return p +} + +func InitEmptyPackage_obj_specContext(p *Package_obj_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_spec +} + +func (*Package_obj_specContext) IsPackage_obj_specContext() {} + +func NewPackage_obj_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_obj_specContext { + var p = new(Package_obj_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_obj_spec + + return p +} + +func (s *Package_obj_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_obj_specContext) Pragma_declaration() IPragma_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Package_obj_specContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Package_obj_specContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Package_obj_specContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Package_obj_specContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Package_obj_specContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Package_obj_specContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Package_obj_specContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Package_obj_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_obj_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_obj_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_obj_spec(s) + } +} + +func (s *Package_obj_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_obj_spec(s) + } +} + +func (s *Package_obj_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPackage_obj_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Package_obj_spec() (localctx IPackage_obj_specContext) { + localctx = NewPackage_obj_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 154, PlSqlParserRULE_package_obj_spec) + p.SetState(3784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 180, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3776) + p.Pragma_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3777) + p.Exception_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3778) + p.Variable_declaration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3779) + p.Subtype_declaration() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3780) + p.Cursor_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3781) + p.Type_declaration() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3782) + p.Procedure_spec() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3783) + p.Function_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_specContext is an interface to support dynamic dispatch. +type IProcedure_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsProcedure_specContext differentiates from other interfaces. + IsProcedure_specContext() +} + +type Procedure_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_specContext() *Procedure_specContext { + var p = new(Procedure_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_spec + return p +} + +func InitEmptyProcedure_specContext(p *Procedure_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_spec +} + +func (*Procedure_specContext) IsProcedure_specContext() {} + +func NewProcedure_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_specContext { + var p = new(Procedure_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_spec + + return p +} + +func (s *Procedure_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_specContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Procedure_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Procedure_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Procedure_specContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Procedure_specContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Procedure_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Procedure_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Procedure_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Procedure_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_spec(s) + } +} + +func (s *Procedure_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_spec(s) + } +} + +func (s *Procedure_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProcedure_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Procedure_spec() (localctx IProcedure_specContext) { + localctx = NewProcedure_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 156, PlSqlParserRULE_procedure_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3786) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3787) + p.Identifier() + } + p.SetState(3799) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3788) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3789) + p.Parameter() + } + p.SetState(3794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3790) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3791) + p.Parameter() + } + + p.SetState(3796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3797) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3801) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IFunction_specContext is an interface to support dynamic dispatch. +type IFunction_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Identifier() IIdentifierContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + PIPELINED() antlr.TerminalNode + DETERMINISTIC() antlr.TerminalNode + RESULT_CACHE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_specContext differentiates from other interfaces. + IsFunction_specContext() +} + +type Function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_specContext() *Function_specContext { + var p = new(Function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_spec + return p +} + +func InitEmptyFunction_specContext(p *Function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_spec +} + +func (*Function_specContext) IsFunction_specContext() {} + +func NewFunction_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_specContext { + var p = new(Function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_spec + + return p +} + +func (s *Function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Function_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Function_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_specContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Function_specContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_specContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Function_specContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, 0) +} + +func (s *Function_specContext) RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, 0) +} + +func (s *Function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_spec(s) + } +} + +func (s *Function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_spec(s) + } +} + +func (s *Function_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_spec() (localctx IFunction_specContext) { + localctx = NewFunction_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 158, PlSqlParserRULE_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3803) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3804) + p.Identifier() + } + p.SetState(3816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3805) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3806) + p.Parameter() + } + p.SetState(3811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3807) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3808) + p.Parameter() + } + + p.SetState(3813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3814) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3818) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3819) + p.Type_spec() + } + p.SetState(3821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPIPELINED { + { + p.SetState(3820) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDETERMINISTIC { + { + p.SetState(3823) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3827) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESULT_CACHE { + { + p.SetState(3826) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3829) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPackage_obj_bodyContext is an interface to support dynamic dispatch. +type IPackage_obj_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Exception_declaration() IException_declarationContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Variable_declaration() IVariable_declarationContext + Type_declaration() IType_declarationContext + Procedure_body() IProcedure_bodyContext + Function_body() IFunction_bodyContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + + // IsPackage_obj_bodyContext differentiates from other interfaces. + IsPackage_obj_bodyContext() +} + +type Package_obj_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_obj_bodyContext() *Package_obj_bodyContext { + var p = new(Package_obj_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_body + return p +} + +func InitEmptyPackage_obj_bodyContext(p *Package_obj_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_obj_body +} + +func (*Package_obj_bodyContext) IsPackage_obj_bodyContext() {} + +func NewPackage_obj_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_obj_bodyContext { + var p = new(Package_obj_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_obj_body + + return p +} + +func (s *Package_obj_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_obj_bodyContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Package_obj_bodyContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Package_obj_bodyContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Package_obj_bodyContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Package_obj_bodyContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Package_obj_bodyContext) Procedure_body() IProcedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *Package_obj_bodyContext) Function_body() IFunction_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *Package_obj_bodyContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Package_obj_bodyContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Package_obj_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_obj_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_obj_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_obj_body(s) + } +} + +func (s *Package_obj_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_obj_body(s) + } +} + +func (s *Package_obj_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPackage_obj_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Package_obj_body() (localctx IPackage_obj_bodyContext) { + localctx = NewPackage_obj_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 160, PlSqlParserRULE_package_obj_body) + p.SetState(3840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 188, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3831) + p.Exception_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(3832) + p.Subtype_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(3833) + p.Cursor_declaration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(3834) + p.Variable_declaration() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(3835) + p.Type_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(3836) + p.Procedure_body() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(3837) + p.Function_body() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(3838) + p.Procedure_spec() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(3839) + p.Function_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_pmem_filestoreContext is an interface to support dynamic dispatch. +type IAlter_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + MOUNT() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + MOUNTPOINT() antlr.TerminalNode + File_path() IFile_pathContext + BACKINGFILE() antlr.TerminalNode + Filename() IFilenameContext + FORCE() antlr.TerminalNode + + // IsAlter_pmem_filestoreContext differentiates from other interfaces. + IsAlter_pmem_filestoreContext() +} + +type Alter_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyAlter_pmem_filestoreContext() *Alter_pmem_filestoreContext { + var p = new(Alter_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore + return p +} + +func InitEmptyAlter_pmem_filestoreContext(p *Alter_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore +} + +func (*Alter_pmem_filestoreContext) IsAlter_pmem_filestoreContext() {} + +func NewAlter_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_pmem_filestoreContext { + var p = new(Alter_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_pmem_filestore + + return p +} + +func (s *Alter_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Alter_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Alter_pmem_filestoreContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Alter_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Alter_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_pmem_filestoreContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_pmem_filestoreContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_pmem_filestoreContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_pmem_filestoreContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Alter_pmem_filestoreContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Alter_pmem_filestoreContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Alter_pmem_filestoreContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Alter_pmem_filestoreContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Alter_pmem_filestoreContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_pmem_filestoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_pmem_filestore(s) + } +} + +func (s *Alter_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_pmem_filestore(s) + } +} + +func (s *Alter_pmem_filestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_pmem_filestore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_pmem_filestore() (localctx IAlter_pmem_filestoreContext) { + localctx = NewAlter_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 162, PlSqlParserRULE_alter_pmem_filestore) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3842) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3843) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3844) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3845) + + var _x = p.Id_expression() + + localctx.(*Alter_pmem_filestoreContext).fsn = _x + } + p.SetState(3862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESIZE: + { + p.SetState(3846) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3847) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(3848) + p.Autoextend_clause() + } + + case PlSqlParserMOUNT: + { + p.SetState(3849) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 189, p.GetParserRuleContext()) == 1 { + { + p.SetState(3850) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3851) + p.File_path() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3856) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 190, p.GetParserRuleContext()) == 1 { + { + p.SetState(3854) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3855) + p.Filename() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3859) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 191, p.GetParserRuleContext()) == 1 { + { + p.SetState(3858) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserDISMOUNT: + { + p.SetState(3861) + p.Match(PlSqlParserDISMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_pmem_filestoreContext is an interface to support dynamic dispatch. +type IDrop_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + CONTENTS() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_pmem_filestoreContext differentiates from other interfaces. + IsDrop_pmem_filestoreContext() +} + +type Drop_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyDrop_pmem_filestoreContext() *Drop_pmem_filestoreContext { + var p = new(Drop_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore + return p +} + +func InitEmptyDrop_pmem_filestoreContext(p *Drop_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore +} + +func (*Drop_pmem_filestoreContext) IsDrop_pmem_filestoreContext() {} + +func NewDrop_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_pmem_filestoreContext { + var p = new(Drop_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_pmem_filestore + + return p +} + +func (s *Drop_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Drop_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Drop_pmem_filestoreContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Drop_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Drop_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_pmem_filestoreContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Drop_pmem_filestoreContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_pmem_filestoreContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Drop_pmem_filestoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_pmem_filestore(s) + } +} + +func (s *Drop_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_pmem_filestore(s) + } +} + +func (s *Drop_pmem_filestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_pmem_filestore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_pmem_filestore() (localctx IDrop_pmem_filestoreContext) { + localctx = NewDrop_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 164, PlSqlParserRULE_drop_pmem_filestore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3864) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3865) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3866) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3867) + + var _x = p.Id_expression() + + localctx.(*Drop_pmem_filestoreContext).fsn = _x + } + p.SetState(3876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 195, p.GetParserRuleContext()) == 1 { + p.SetState(3873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFORCE, PlSqlParserINCLUDING: + p.SetState(3869) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(3868) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3871) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLUDING: + { + p.SetState(3872) + p.Match(PlSqlParserEXCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(3875) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_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 + Procedure_name() IProcedure_nameContext + SEMICOLON() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_procedure + return p +} + +func InitEmptyDrop_procedureContext(p *Drop_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_procedure + + return p +} + +func (s *Drop_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_procedureContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Drop_procedureContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Drop_procedureContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_procedure(s) + } +} + +func (s *Drop_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_procedure() (localctx IDrop_procedureContext) { + localctx = NewDrop_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 166, PlSqlParserRULE_drop_procedure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3878) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3879) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3880) + p.Procedure_name() + } + { + p.SetState(3881) + p.Match(PlSqlParserSEMICOLON) + 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_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 + Procedure_name() IProcedure_nameContext + COMPILE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // 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 = PlSqlParserRULE_alter_procedure + return p +} + +func InitEmptyAlter_procedureContext(p *Alter_procedureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_procedure + + return p +} + +func (s *Alter_procedureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_procedureContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_procedureContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Alter_procedureContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Alter_procedureContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_procedureContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_procedureContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_procedureContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_procedureContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_procedureContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_procedureContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_procedure(s) + } +} + +func (s *Alter_procedureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_procedure(s) + } +} + +func (s *Alter_procedureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_procedure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_procedure() (localctx IAlter_procedureContext) { + localctx = NewAlter_procedureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 168, PlSqlParserRULE_alter_procedure) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3883) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3884) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3885) + p.Procedure_name() + } + { + p.SetState(3886) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3888) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 196, p.GetParserRuleContext()) == 1 { + { + p.SetState(3887) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(3893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 197, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(3890) + p.Compiler_parameters_clause() + } + + } + p.SetState(3895) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 197, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(3896) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3897) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3900) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IFunction_bodyContext is an interface to support dynamic dispatch. +type IFunction_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Identifier() IIdentifierContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + USING() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + AllInvoker_rights_clause() []IInvoker_rights_clauseContext + Invoker_rights_clause(i int) IInvoker_rights_clauseContext + AllParallel_enable_clause() []IParallel_enable_clauseContext + Parallel_enable_clause(i int) IParallel_enable_clauseContext + AllResult_cache_clause() []IResult_cache_clauseContext + Result_cache_clause(i int) IResult_cache_clauseContext + AllDETERMINISTIC() []antlr.TerminalNode + DETERMINISTIC(i int) antlr.TerminalNode + PIPELINED() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsFunction_bodyContext differentiates from other interfaces. + IsFunction_bodyContext() +} + +type Function_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_bodyContext() *Function_bodyContext { + var p = new(Function_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_body + return p +} + +func InitEmptyFunction_bodyContext(p *Function_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_body +} + +func (*Function_bodyContext) IsFunction_bodyContext() {} + +func NewFunction_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_bodyContext { + var p = new(Function_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_body + + return p +} + +func (s *Function_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_bodyContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Function_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_bodyContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Function_bodyContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Function_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Function_bodyContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Function_bodyContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Function_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Function_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_bodyContext) AllInvoker_rights_clause() []IInvoker_rights_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + len++ + } + } + + tst := make([]IInvoker_rights_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInvoker_rights_clauseContext); ok { + tst[i] = t.(IInvoker_rights_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Invoker_rights_clause(i int) IInvoker_rights_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Function_bodyContext) AllParallel_enable_clause() []IParallel_enable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_enable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_enable_clauseContext); ok { + tst[i] = t.(IParallel_enable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Parallel_enable_clause(i int) IParallel_enable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_enable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_enable_clauseContext) +} + +func (s *Function_bodyContext) AllResult_cache_clause() []IResult_cache_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + len++ + } + } + + tst := make([]IResult_cache_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResult_cache_clauseContext); ok { + tst[i] = t.(IResult_cache_clauseContext) + i++ + } + } + + return tst +} + +func (s *Function_bodyContext) Result_cache_clause(i int) IResult_cache_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Function_bodyContext) AllDETERMINISTIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINISTIC) +} + +func (s *Function_bodyContext) DETERMINISTIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, i) +} + +func (s *Function_bodyContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Function_bodyContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Function_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Function_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Function_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Function_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Function_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Function_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Function_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_body(s) + } +} + +func (s *Function_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_body(s) + } +} + +func (s *Function_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_body() (localctx IFunction_bodyContext) { + localctx = NewFunction_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 170, PlSqlParserRULE_function_body) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3902) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3903) + p.Identifier() + } + p.SetState(3915) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3904) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3905) + p.Parameter() + } + p.SetState(3910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3906) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3907) + p.Parameter() + } + + p.SetState(3912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3913) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3917) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3918) + p.Type_spec() + } + p.SetState(3925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 202, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(3923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAUTHID: + { + p.SetState(3919) + p.Invoker_rights_clause() + } + + case PlSqlParserPARALLEL_ENABLE: + { + p.SetState(3920) + p.Parallel_enable_clause() + } + + case PlSqlParserRESULT_CACHE: + { + p.SetState(3921) + p.Result_cache_clause() + } + + case PlSqlParserDETERMINISTIC: + { + p.SetState(3922) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(3927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 202, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(3948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 208, p.GetParserRuleContext()) { + case 1: + p.SetState(3929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPIPELINED { + { + p.SetState(3928) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDETERMINISTIC { + { + p.SetState(3931) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3934) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 207, p.GetParserRuleContext()) { + case 1: + p.SetState(3936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(3935) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3939) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 206, p.GetParserRuleContext()) == 1 { + { + p.SetState(3938) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3941) + p.Body() + } + + case 2: + { + p.SetState(3942) + p.Call_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + { + p.SetState(3945) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAGGREGATE || _la == PlSqlParserPIPELINED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(3946) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3947) + p.Implementation_type_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3950) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IProcedure_bodyContext is an interface to support dynamic dispatch. +type IProcedure_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsProcedure_bodyContext differentiates from other interfaces. + IsProcedure_bodyContext() +} + +type Procedure_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_bodyContext() *Procedure_bodyContext { + var p = new(Procedure_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_body + return p +} + +func InitEmptyProcedure_bodyContext(p *Procedure_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_body +} + +func (*Procedure_bodyContext) IsProcedure_bodyContext() {} + +func NewProcedure_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_bodyContext { + var p = new(Procedure_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_body + + return p +} + +func (s *Procedure_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_bodyContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Procedure_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Procedure_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Procedure_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Procedure_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Procedure_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Procedure_bodyContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Procedure_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Procedure_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Procedure_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Procedure_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Procedure_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Procedure_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Procedure_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Procedure_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Procedure_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_body(s) + } +} + +func (s *Procedure_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_body(s) + } +} + +func (s *Procedure_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProcedure_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Procedure_body() (localctx IProcedure_bodyContext) { + localctx = NewProcedure_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 172, PlSqlParserRULE_procedure_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3952) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3953) + p.Identifier() + } + p.SetState(3965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3954) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3955) + p.Parameter() + } + p.SetState(3960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3956) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3957) + p.Parameter() + } + + p.SetState(3962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3963) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3967) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(3977) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 213, p.GetParserRuleContext()) { + case 1: + p.SetState(3969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(3968) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(3972) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 212, p.GetParserRuleContext()) == 1 { + { + p.SetState(3971) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(3974) + p.Body() + } + + case 2: + { + p.SetState(3975) + p.Call_spec() + } + + case 3: + { + p.SetState(3976) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(3979) + p.Match(PlSqlParserSEMICOLON) + 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_procedure_bodyContext is an interface to support dynamic dispatch. +type ICreate_procedure_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Body() IBodyContext + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter() []IParameterContext + Parameter(i int) IParameterContext + RIGHT_PAREN() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_procedure_bodyContext differentiates from other interfaces. + IsCreate_procedure_bodyContext() +} + +type Create_procedure_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_procedure_bodyContext() *Create_procedure_bodyContext { + var p = new(Create_procedure_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_procedure_body + return p +} + +func InitEmptyCreate_procedure_bodyContext(p *Create_procedure_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_procedure_body +} + +func (*Create_procedure_bodyContext) IsCreate_procedure_bodyContext() {} + +func NewCreate_procedure_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_procedure_bodyContext { + var p = new(Create_procedure_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_procedure_body + + return p +} + +func (s *Create_procedure_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_procedure_bodyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_procedure_bodyContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Create_procedure_bodyContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Create_procedure_bodyContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_procedure_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Create_procedure_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_procedure_bodyContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Create_procedure_bodyContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Create_procedure_bodyContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Create_procedure_bodyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_procedure_bodyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_procedure_bodyContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_procedure_bodyContext) AllParameter() []IParameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameterContext); ok { + len++ + } + } + + tst := make([]IParameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameterContext); ok { + tst[i] = t.(IParameterContext) + i++ + } + } + + return tst +} + +func (s *Create_procedure_bodyContext) Parameter(i int) IParameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameterContext) +} + +func (s *Create_procedure_bodyContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_procedure_bodyContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_procedure_bodyContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Create_procedure_bodyContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Create_procedure_bodyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_procedure_bodyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_procedure_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_procedure_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_procedure_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_procedure_body(s) + } +} + +func (s *Create_procedure_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_procedure_body(s) + } +} + +func (s *Create_procedure_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_procedure_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_procedure_body() (localctx ICreate_procedure_bodyContext) { + localctx = NewCreate_procedure_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 174, PlSqlParserRULE_create_procedure_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(3981) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(3984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(3982) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3983) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(3986) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3987) + p.Procedure_name() + } + p.SetState(3999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(3988) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3989) + p.Parameter() + } + p.SetState(3994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(3990) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(3991) + p.Parameter() + } + + p.SetState(3996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(3997) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4001) + p.Invoker_rights_clause() + } + + } + { + p.SetState(4004) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 220, p.GetParserRuleContext()) { + case 1: + p.SetState(4006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(4005) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4009) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 219, p.GetParserRuleContext()) == 1 { + { + p.SetState(4008) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4011) + p.Body() + } + + case 2: + { + p.SetState(4012) + p.Call_spec() + } + + case 3: + { + p.SetState(4013) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4016) + p.Match(PlSqlParserSEMICOLON) + 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_resource_costContext is an interface to support dynamic dispatch. +type IAlter_resource_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + COST() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCPU_PER_SESSION() []antlr.TerminalNode + CPU_PER_SESSION(i int) antlr.TerminalNode + AllCONNECT_TIME() []antlr.TerminalNode + CONNECT_TIME(i int) antlr.TerminalNode + AllLOGICAL_READS_PER_SESSION() []antlr.TerminalNode + LOGICAL_READS_PER_SESSION(i int) antlr.TerminalNode + AllPRIVATE_SGA() []antlr.TerminalNode + PRIVATE_SGA(i int) antlr.TerminalNode + + // IsAlter_resource_costContext differentiates from other interfaces. + IsAlter_resource_costContext() +} + +type Alter_resource_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_resource_costContext() *Alter_resource_costContext { + var p = new(Alter_resource_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_resource_cost + return p +} + +func InitEmptyAlter_resource_costContext(p *Alter_resource_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_resource_cost +} + +func (*Alter_resource_costContext) IsAlter_resource_costContext() {} + +func NewAlter_resource_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_resource_costContext { + var p = new(Alter_resource_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_resource_cost + + return p +} + +func (s *Alter_resource_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_resource_costContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_resource_costContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Alter_resource_costContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Alter_resource_costContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Alter_resource_costContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Alter_resource_costContext) AllCPU_PER_SESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCPU_PER_SESSION) +} + +func (s *Alter_resource_costContext) CPU_PER_SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, i) +} + +func (s *Alter_resource_costContext) AllCONNECT_TIME() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONNECT_TIME) +} + +func (s *Alter_resource_costContext) CONNECT_TIME(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, i) +} + +func (s *Alter_resource_costContext) AllLOGICAL_READS_PER_SESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGICAL_READS_PER_SESSION) +} + +func (s *Alter_resource_costContext) LOGICAL_READS_PER_SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, i) +} + +func (s *Alter_resource_costContext) AllPRIVATE_SGA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVATE_SGA) +} + +func (s *Alter_resource_costContext) PRIVATE_SGA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, i) +} + +func (s *Alter_resource_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_resource_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_resource_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_resource_cost(s) + } +} + +func (s *Alter_resource_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_resource_cost(s) + } +} + +func (s *Alter_resource_costContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_resource_cost(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_resource_cost() (localctx IAlter_resource_costContext) { + localctx = NewAlter_resource_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 176, PlSqlParserRULE_alter_resource_cost) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4018) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4019) + p.Match(PlSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4020) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4023) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4021) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONNECT_TIME || _la == PlSqlParserCPU_PER_SESSION || _la == PlSqlParserLOGICAL_READS_PER_SESSION || _la == PlSqlParserPRIVATE_SGA) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4022) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4025) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 221, 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 +} + +// IDrop_outlineContext is an interface to support dynamic dispatch. +type IDrop_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_outlineContext differentiates from other interfaces. + IsDrop_outlineContext() +} + +type Drop_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext +} + +func NewEmptyDrop_outlineContext() *Drop_outlineContext { + var p = new(Drop_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_outline + return p +} + +func InitEmptyDrop_outlineContext(p *Drop_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_outline +} + +func (*Drop_outlineContext) IsDrop_outlineContext() {} + +func NewDrop_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_outlineContext { + var p = new(Drop_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_outline + + return p +} + +func (s *Drop_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Drop_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Drop_outlineContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Drop_outlineContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_outline(s) + } +} + +func (s *Drop_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_outline(s) + } +} + +func (s *Drop_outlineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_outline(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_outline() (localctx IDrop_outlineContext) { + localctx = NewDrop_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 178, PlSqlParserRULE_drop_outline) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4027) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4028) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4029) + + var _x = p.Id_expression() + + localctx.(*Drop_outlineContext).o = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_rollback_segmentContext is an interface to support dynamic dispatch. +type IAlter_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + Storage_clause() IStorage_clauseContext + SHRINK() antlr.TerminalNode + TO() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsAlter_rollback_segmentContext differentiates from other interfaces. + IsAlter_rollback_segmentContext() +} + +type Alter_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_rollback_segmentContext() *Alter_rollback_segmentContext { + var p = new(Alter_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment + return p +} + +func InitEmptyAlter_rollback_segmentContext(p *Alter_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment +} + +func (*Alter_rollback_segmentContext) IsAlter_rollback_segmentContext() {} + +func NewAlter_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_rollback_segmentContext { + var p = new(Alter_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_rollback_segment + + return p +} + +func (s *Alter_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_rollback_segmentContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Alter_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Alter_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Alter_rollback_segmentContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_rollback_segmentContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_rollback_segmentContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Alter_rollback_segmentContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_rollback_segmentContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_rollback_segmentContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_rollback_segment(s) + } +} + +func (s *Alter_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_rollback_segment(s) + } +} + +func (s *Alter_rollback_segmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_rollback_segment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_rollback_segment() (localctx IAlter_rollback_segmentContext) { + localctx = NewAlter_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 180, PlSqlParserRULE_alter_rollback_segment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4031) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4032) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4033) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4034) + p.Rollback_segment_name() + } + p.SetState(4043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + { + p.SetState(4035) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(4036) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTORAGE: + { + p.SetState(4037) + p.Storage_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(4038) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4041) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 222, p.GetParserRuleContext()) == 1 { + { + p.SetState(4039) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4040) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_restore_pointContext is an interface to support dynamic dispatch. +type IDrop_restore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRp returns the rp rule contexts. + GetRp() IId_expressionContext + + // GetPdb returns the pdb rule contexts. + GetPdb() IId_expressionContext + + // SetRp sets the rp rule contexts. + SetRp(IId_expressionContext) + + // SetPdb sets the pdb rule contexts. + SetPdb(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + FOR() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + + // IsDrop_restore_pointContext differentiates from other interfaces. + IsDrop_restore_pointContext() +} + +type Drop_restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rp IId_expressionContext + pdb IId_expressionContext +} + +func NewEmptyDrop_restore_pointContext() *Drop_restore_pointContext { + var p = new(Drop_restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_restore_point + return p +} + +func InitEmptyDrop_restore_pointContext(p *Drop_restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_restore_point +} + +func (*Drop_restore_pointContext) IsDrop_restore_pointContext() {} + +func NewDrop_restore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_restore_pointContext { + var p = new(Drop_restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_restore_point + + return p +} + +func (s *Drop_restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_restore_pointContext) GetRp() IId_expressionContext { return s.rp } + +func (s *Drop_restore_pointContext) GetPdb() IId_expressionContext { return s.pdb } + +func (s *Drop_restore_pointContext) SetRp(v IId_expressionContext) { s.rp = v } + +func (s *Drop_restore_pointContext) SetPdb(v IId_expressionContext) { s.pdb = v } + +func (s *Drop_restore_pointContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_restore_pointContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Drop_restore_pointContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Drop_restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Drop_restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_restore_pointContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Drop_restore_pointContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Drop_restore_pointContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_restore_point(s) + } +} + +func (s *Drop_restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_restore_point(s) + } +} + +func (s *Drop_restore_pointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_restore_point(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_restore_point() (localctx IDrop_restore_pointContext) { + localctx = NewDrop_restore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 182, PlSqlParserRULE_drop_restore_point) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4045) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4046) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4047) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4048) + + var _x = p.Id_expression() + + localctx.(*Drop_restore_pointContext).rp = _x + } + p.SetState(4053) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 224, p.GetParserRuleContext()) == 1 { + { + p.SetState(4049) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4050) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4051) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4052) + + var _x = p.Id_expression() + + localctx.(*Drop_restore_pointContext).pdb = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_rollback_segmentContext is an interface to support dynamic dispatch. +type IDrop_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + + // IsDrop_rollback_segmentContext differentiates from other interfaces. + IsDrop_rollback_segmentContext() +} + +type Drop_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_rollback_segmentContext() *Drop_rollback_segmentContext { + var p = new(Drop_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment + return p +} + +func InitEmptyDrop_rollback_segmentContext(p *Drop_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment +} + +func (*Drop_rollback_segmentContext) IsDrop_rollback_segmentContext() {} + +func NewDrop_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_rollback_segmentContext { + var p = new(Drop_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_rollback_segment + + return p +} + +func (s *Drop_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_rollback_segmentContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Drop_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Drop_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Drop_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_rollback_segment(s) + } +} + +func (s *Drop_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_rollback_segment(s) + } +} + +func (s *Drop_rollback_segmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_rollback_segment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_rollback_segment() (localctx IDrop_rollback_segmentContext) { + localctx = NewDrop_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 184, PlSqlParserRULE_drop_rollback_segment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4055) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4056) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4057) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4058) + p.Rollback_segment_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_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 + Role_name() IRole_nameContext + SEMICOLON() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_role + return p +} + +func InitEmptyDrop_roleContext(p *Drop_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_role + + return p +} + +func (s *Drop_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_roleContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Drop_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Drop_roleContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_role(s) + } +} + +func (s *Drop_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_role(s) + } +} + +func (s *Drop_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_role() (localctx IDrop_roleContext) { + localctx = NewDrop_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 186, PlSqlParserRULE_drop_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4060) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4061) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4062) + p.Role_name() + } + { + p.SetState(4063) + p.Match(PlSqlParserSEMICOLON) + 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_pmem_filestoreContext is an interface to support dynamic dispatch. +type ICreate_pmem_filestoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFsn returns the fsn rule contexts. + GetFsn() IId_expressionContext + + // SetFsn sets the fsn rule contexts. + SetFsn(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + PMEM() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + Id_expression() IId_expressionContext + AllPmem_filestore_options() []IPmem_filestore_optionsContext + Pmem_filestore_options(i int) IPmem_filestore_optionsContext + + // IsCreate_pmem_filestoreContext differentiates from other interfaces. + IsCreate_pmem_filestoreContext() +} + +type Create_pmem_filestoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fsn IId_expressionContext +} + +func NewEmptyCreate_pmem_filestoreContext() *Create_pmem_filestoreContext { + var p = new(Create_pmem_filestoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore + return p +} + +func InitEmptyCreate_pmem_filestoreContext(p *Create_pmem_filestoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore +} + +func (*Create_pmem_filestoreContext) IsCreate_pmem_filestoreContext() {} + +func NewCreate_pmem_filestoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_pmem_filestoreContext { + var p = new(Create_pmem_filestoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_pmem_filestore + + return p +} + +func (s *Create_pmem_filestoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_pmem_filestoreContext) GetFsn() IId_expressionContext { return s.fsn } + +func (s *Create_pmem_filestoreContext) SetFsn(v IId_expressionContext) { s.fsn = v } + +func (s *Create_pmem_filestoreContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_pmem_filestoreContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Create_pmem_filestoreContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Create_pmem_filestoreContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_pmem_filestoreContext) AllPmem_filestore_options() []IPmem_filestore_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPmem_filestore_optionsContext); ok { + len++ + } + } + + tst := make([]IPmem_filestore_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPmem_filestore_optionsContext); ok { + tst[i] = t.(IPmem_filestore_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_pmem_filestoreContext) Pmem_filestore_options(i int) IPmem_filestore_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPmem_filestore_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPmem_filestore_optionsContext) +} + +func (s *Create_pmem_filestoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_pmem_filestoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_pmem_filestoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_pmem_filestore(s) + } +} + +func (s *Create_pmem_filestoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_pmem_filestore(s) + } +} + +func (s *Create_pmem_filestoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_pmem_filestore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_pmem_filestore() (localctx ICreate_pmem_filestoreContext) { + localctx = NewCreate_pmem_filestoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 188, PlSqlParserRULE_create_pmem_filestore) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4065) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4066) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4067) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4068) + + var _x = p.Id_expression() + + localctx.(*Create_pmem_filestoreContext).fsn = _x + } + p.SetState(4070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4069) + p.Pmem_filestore_options() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4072) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 225, 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 +} + +// IPmem_filestore_optionsContext is an interface to support dynamic dispatch. +type IPmem_filestore_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNTPOINT() antlr.TerminalNode + File_path() IFile_pathContext + BACKINGFILE() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + Size_clause() ISize_clauseContext + SIZE() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + Autoextend_clause() IAutoextend_clauseContext + + // IsPmem_filestore_optionsContext differentiates from other interfaces. + IsPmem_filestore_optionsContext() +} + +type Pmem_filestore_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPmem_filestore_optionsContext() *Pmem_filestore_optionsContext { + var p = new(Pmem_filestore_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options + return p +} + +func InitEmptyPmem_filestore_optionsContext(p *Pmem_filestore_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options +} + +func (*Pmem_filestore_optionsContext) IsPmem_filestore_optionsContext() {} + +func NewPmem_filestore_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pmem_filestore_optionsContext { + var p = new(Pmem_filestore_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pmem_filestore_options + + return p +} + +func (s *Pmem_filestore_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pmem_filestore_optionsContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Pmem_filestore_optionsContext) File_path() IFile_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_pathContext) +} + +func (s *Pmem_filestore_optionsContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Pmem_filestore_optionsContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Pmem_filestore_optionsContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Pmem_filestore_optionsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Pmem_filestore_optionsContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Pmem_filestore_optionsContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Pmem_filestore_optionsContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Pmem_filestore_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pmem_filestore_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pmem_filestore_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPmem_filestore_options(s) + } +} + +func (s *Pmem_filestore_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPmem_filestore_options(s) + } +} + +func (s *Pmem_filestore_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPmem_filestore_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pmem_filestore_options() (localctx IPmem_filestore_optionsContext) { + localctx = NewPmem_filestore_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 190, PlSqlParserRULE_pmem_filestore_options) + var _la int + + p.SetState(4084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMOUNTPOINT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4074) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4075) + p.File_path() + } + + case PlSqlParserBACKINGFILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4076) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4077) + p.Filename() + } + p.SetState(4079) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 226, p.GetParserRuleContext()) == 1 { + { + p.SetState(4078) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserBLOCKSIZE, PlSqlParserSIZE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4081) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBLOCKSIZE || _la == PlSqlParserSIZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4082) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4083) + p.Autoextend_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 +} + +// IFile_pathContext is an interface to support dynamic dispatch. +type IFile_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsFile_pathContext differentiates from other interfaces. + IsFile_pathContext() +} + +type File_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_pathContext() *File_pathContext { + var p = new(File_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_path + return p +} + +func InitEmptyFile_pathContext(p *File_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_path +} + +func (*File_pathContext) IsFile_pathContext() {} + +func NewFile_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_pathContext { + var p = new(File_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_path + + return p +} + +func (s *File_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_pathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *File_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_path(s) + } +} + +func (s *File_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_path(s) + } +} + +func (s *File_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_path() (localctx IFile_pathContext) { + localctx = NewFile_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 192, PlSqlParserRULE_file_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4086) + p.Match(PlSqlParserCHAR_STRING) + 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_rollback_segmentContext is an interface to support dynamic dispatch. +type ICreate_rollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + PUBLIC() antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + + // IsCreate_rollback_segmentContext differentiates from other interfaces. + IsCreate_rollback_segmentContext() +} + +type Create_rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_rollback_segmentContext() *Create_rollback_segmentContext { + var p = new(Create_rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_rollback_segment + return p +} + +func InitEmptyCreate_rollback_segmentContext(p *Create_rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_rollback_segment +} + +func (*Create_rollback_segmentContext) IsCreate_rollback_segmentContext() {} + +func NewCreate_rollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_rollback_segmentContext { + var p = new(Create_rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_rollback_segment + + return p +} + +func (s *Create_rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_rollback_segmentContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_rollback_segmentContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Create_rollback_segmentContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Create_rollback_segmentContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Create_rollback_segmentContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_rollback_segmentContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_rollback_segmentContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_rollback_segmentContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Create_rollback_segmentContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Create_rollback_segmentContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_rollback_segmentContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Create_rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_rollback_segment(s) + } +} + +func (s *Create_rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_rollback_segment(s) + } +} + +func (s *Create_rollback_segmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_rollback_segment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_rollback_segment() (localctx ICreate_rollback_segmentContext) { + localctx = NewCreate_rollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 194, PlSqlParserRULE_create_rollback_segment) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4088) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(4089) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4092) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4093) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4094) + p.Rollback_segment_name() + } + p.SetState(4100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 230, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(4098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(4095) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4096) + p.Tablespace() + } + + case PlSqlParserSTORAGE: + { + p.SetState(4097) + p.Storage_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(4102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 230, 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 +} + +// IDrop_triggerContext is an interface to support dynamic dispatch. +type IDrop_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Trigger_name() ITrigger_nameContext + SEMICOLON() antlr.TerminalNode + + // IsDrop_triggerContext differentiates from other interfaces. + IsDrop_triggerContext() +} + +type Drop_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_triggerContext() *Drop_triggerContext { + var p = new(Drop_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_trigger + return p +} + +func InitEmptyDrop_triggerContext(p *Drop_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_trigger +} + +func (*Drop_triggerContext) IsDrop_triggerContext() {} + +func NewDrop_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_triggerContext { + var p = new(Drop_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_trigger + + return p +} + +func (s *Drop_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_triggerContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Drop_triggerContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Drop_triggerContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_trigger(s) + } +} + +func (s *Drop_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_trigger(s) + } +} + +func (s *Drop_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_trigger() (localctx IDrop_triggerContext) { + localctx = NewDrop_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 196, PlSqlParserRULE_drop_trigger) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4103) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4104) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4105) + p.Trigger_name() + } + { + p.SetState(4106) + p.Match(PlSqlParserSEMICOLON) + 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_triggerContext is an interface to support dynamic dispatch. +type IAlter_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAlter_trigger_name returns the alter_trigger_name rule contexts. + GetAlter_trigger_name() ITrigger_nameContext + + // GetRename_trigger_name returns the rename_trigger_name rule contexts. + GetRename_trigger_name() ITrigger_nameContext + + // SetAlter_trigger_name sets the alter_trigger_name rule contexts. + SetAlter_trigger_name(ITrigger_nameContext) + + // SetRename_trigger_name sets the rename_trigger_name rule contexts. + SetRename_trigger_name(ITrigger_nameContext) + + // Getter signatures + ALTER() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + AllTrigger_name() []ITrigger_nameContext + Trigger_name(i int) ITrigger_nameContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_triggerContext differentiates from other interfaces. + IsAlter_triggerContext() +} + +type Alter_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + alter_trigger_name ITrigger_nameContext + rename_trigger_name ITrigger_nameContext +} + +func NewEmptyAlter_triggerContext() *Alter_triggerContext { + var p = new(Alter_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_trigger + return p +} + +func InitEmptyAlter_triggerContext(p *Alter_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_trigger +} + +func (*Alter_triggerContext) IsAlter_triggerContext() {} + +func NewAlter_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_triggerContext { + var p = new(Alter_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_trigger + + return p +} + +func (s *Alter_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_triggerContext) GetAlter_trigger_name() ITrigger_nameContext { + return s.alter_trigger_name +} + +func (s *Alter_triggerContext) GetRename_trigger_name() ITrigger_nameContext { + return s.rename_trigger_name +} + +func (s *Alter_triggerContext) SetAlter_trigger_name(v ITrigger_nameContext) { + s.alter_trigger_name = v +} + +func (s *Alter_triggerContext) SetRename_trigger_name(v ITrigger_nameContext) { + s.rename_trigger_name = v +} + +func (s *Alter_triggerContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Alter_triggerContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_triggerContext) AllTrigger_name() []ITrigger_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrigger_nameContext); ok { + len++ + } + } + + tst := make([]ITrigger_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrigger_nameContext); ok { + tst[i] = t.(ITrigger_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_triggerContext) Trigger_name(i int) ITrigger_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Alter_triggerContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_triggerContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_triggerContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_triggerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Alter_triggerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Alter_triggerContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Alter_triggerContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_triggerContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_triggerContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_triggerContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_trigger(s) + } +} + +func (s *Alter_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_trigger(s) + } +} + +func (s *Alter_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_trigger() (localctx IAlter_triggerContext) { + localctx = NewAlter_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 198, PlSqlParserRULE_alter_trigger) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4108) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4109) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4110) + + var _x = p.Trigger_name() + + localctx.(*Alter_triggerContext).alter_trigger_name = _x + } + p.SetState(4129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(4111) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserRENAME: + { + p.SetState(4112) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4113) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4114) + + var _x = p.Trigger_name() + + localctx.(*Alter_triggerContext).rename_trigger_name = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(4115) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4117) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 231, p.GetParserRuleContext()) == 1 { + { + p.SetState(4116) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 232, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4119) + p.Compiler_parameters_clause() + } + + } + p.SetState(4124) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 232, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(4125) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4126) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4131) + p.Match(PlSqlParserSEMICOLON) + 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_triggerContext is an interface to support dynamic dispatch. +type ICreate_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + Trigger_name() ITrigger_nameContext + Trigger_body() ITrigger_bodyContext + SEMICOLON() antlr.TerminalNode + Simple_dml_trigger() ISimple_dml_triggerContext + Compound_dml_trigger() ICompound_dml_triggerContext + Non_dml_trigger() INon_dml_triggerContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Trigger_follows_clause() ITrigger_follows_clauseContext + Trigger_when_clause() ITrigger_when_clauseContext + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCreate_triggerContext differentiates from other interfaces. + IsCreate_triggerContext() +} + +type Create_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_triggerContext() *Create_triggerContext { + var p = new(Create_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_trigger + return p +} + +func InitEmptyCreate_triggerContext(p *Create_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_trigger +} + +func (*Create_triggerContext) IsCreate_triggerContext() {} + +func NewCreate_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_triggerContext { + var p = new(Create_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_trigger + + return p +} + +func (s *Create_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_triggerContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_triggerContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Create_triggerContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Create_triggerContext) Trigger_body() ITrigger_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_bodyContext) +} + +func (s *Create_triggerContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_triggerContext) Simple_dml_trigger() ISimple_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_dml_triggerContext) +} + +func (s *Create_triggerContext) Compound_dml_trigger() ICompound_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompound_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompound_dml_triggerContext) +} + +func (s *Create_triggerContext) Non_dml_trigger() INon_dml_triggerContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_dml_triggerContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_dml_triggerContext) +} + +func (s *Create_triggerContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_triggerContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_triggerContext) Trigger_follows_clause() ITrigger_follows_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_follows_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_follows_clauseContext) +} + +func (s *Create_triggerContext) Trigger_when_clause() ITrigger_when_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_when_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_when_clauseContext) +} + +func (s *Create_triggerContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Create_triggerContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Create_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_trigger(s) + } +} + +func (s *Create_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_trigger(s) + } +} + +func (s *Create_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_trigger() (localctx ICreate_triggerContext) { + localctx = NewCreate_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 200, PlSqlParserRULE_create_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4133) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4134) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4135) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4138) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4139) + p.Trigger_name() + } + p.SetState(4143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 236, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4140) + p.Simple_dml_trigger() + } + + case 2: + { + p.SetState(4141) + p.Compound_dml_trigger() + } + + case 3: + { + p.SetState(4142) + p.Non_dml_trigger() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOLLOWS { + { + p.SetState(4145) + p.Trigger_follows_clause() + } + + } + p.SetState(4149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(4148) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(4152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHEN { + { + p.SetState(4151) + p.Trigger_when_clause() + } + + } + { + p.SetState(4154) + p.Trigger_body() + } + { + p.SetState(4155) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ITrigger_follows_clauseContext is an interface to support dynamic dispatch. +type ITrigger_follows_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOLLOWS() antlr.TerminalNode + AllTrigger_name() []ITrigger_nameContext + Trigger_name(i int) ITrigger_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTrigger_follows_clauseContext differentiates from other interfaces. + IsTrigger_follows_clauseContext() +} + +type Trigger_follows_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_follows_clauseContext() *Trigger_follows_clauseContext { + var p = new(Trigger_follows_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause + return p +} + +func InitEmptyTrigger_follows_clauseContext(p *Trigger_follows_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause +} + +func (*Trigger_follows_clauseContext) IsTrigger_follows_clauseContext() {} + +func NewTrigger_follows_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_follows_clauseContext { + var p = new(Trigger_follows_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_follows_clause + + return p +} + +func (s *Trigger_follows_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_follows_clauseContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Trigger_follows_clauseContext) AllTrigger_name() []ITrigger_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITrigger_nameContext); ok { + len++ + } + } + + tst := make([]ITrigger_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITrigger_nameContext); ok { + tst[i] = t.(ITrigger_nameContext) + i++ + } + } + + return tst +} + +func (s *Trigger_follows_clauseContext) Trigger_name(i int) ITrigger_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Trigger_follows_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Trigger_follows_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Trigger_follows_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_follows_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_follows_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_follows_clause(s) + } +} + +func (s *Trigger_follows_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_follows_clause(s) + } +} + +func (s *Trigger_follows_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrigger_follows_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trigger_follows_clause() (localctx ITrigger_follows_clauseContext) { + localctx = NewTrigger_follows_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 202, PlSqlParserRULE_trigger_follows_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4157) + p.Match(PlSqlParserFOLLOWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4158) + p.Trigger_name() + } + p.SetState(4163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4159) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4160) + p.Trigger_name() + } + + p.SetState(4165) + 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 +} + +// ITrigger_when_clauseContext is an interface to support dynamic dispatch. +type ITrigger_when_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsTrigger_when_clauseContext differentiates from other interfaces. + IsTrigger_when_clauseContext() +} + +type Trigger_when_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_when_clauseContext() *Trigger_when_clauseContext { + var p = new(Trigger_when_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_when_clause + return p +} + +func InitEmptyTrigger_when_clauseContext(p *Trigger_when_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_when_clause +} + +func (*Trigger_when_clauseContext) IsTrigger_when_clauseContext() {} + +func NewTrigger_when_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_when_clauseContext { + var p = new(Trigger_when_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_when_clause + + return p +} + +func (s *Trigger_when_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_when_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Trigger_when_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Trigger_when_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Trigger_when_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Trigger_when_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_when_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_when_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_when_clause(s) + } +} + +func (s *Trigger_when_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_when_clause(s) + } +} + +func (s *Trigger_when_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrigger_when_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trigger_when_clause() (localctx ITrigger_when_clauseContext) { + localctx = NewTrigger_when_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 204, PlSqlParserRULE_trigger_when_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4166) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4167) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4168) + p.Condition() + } + { + p.SetState(4169) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISimple_dml_triggerContext is an interface to support dynamic dispatch. +type ISimple_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dml_event_clause() IDml_event_clauseContext + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + OF() antlr.TerminalNode + Referencing_clause() IReferencing_clauseContext + For_each_row() IFor_each_rowContext + + // IsSimple_dml_triggerContext differentiates from other interfaces. + IsSimple_dml_triggerContext() +} + +type Simple_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_dml_triggerContext() *Simple_dml_triggerContext { + var p = new(Simple_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger + return p +} + +func InitEmptySimple_dml_triggerContext(p *Simple_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger +} + +func (*Simple_dml_triggerContext) IsSimple_dml_triggerContext() {} + +func NewSimple_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_dml_triggerContext { + var p = new(Simple_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_dml_trigger + + return p +} + +func (s *Simple_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_dml_triggerContext) Dml_event_clause() IDml_event_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_clauseContext) +} + +func (s *Simple_dml_triggerContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Simple_dml_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Simple_dml_triggerContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTEAD, 0) +} + +func (s *Simple_dml_triggerContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Simple_dml_triggerContext) Referencing_clause() IReferencing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_clauseContext) +} + +func (s *Simple_dml_triggerContext) For_each_row() IFor_each_rowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_each_rowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_each_rowContext) +} + +func (s *Simple_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_dml_trigger(s) + } +} + +func (s *Simple_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_dml_trigger(s) + } +} + +func (s *Simple_dml_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSimple_dml_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Simple_dml_trigger() (localctx ISimple_dml_triggerContext) { + localctx = NewSimple_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 206, PlSqlParserRULE_simple_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBEFORE: + { + p.SetState(4171) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAFTER: + { + p.SetState(4172) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINSTEAD: + { + p.SetState(4173) + p.Match(PlSqlParserINSTEAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4174) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4177) + p.Dml_event_clause() + } + p.SetState(4179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFERENCING { + { + p.SetState(4178) + p.Referencing_clause() + } + + } + p.SetState(4182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(4181) + p.For_each_row() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFor_each_rowContext is an interface to support dynamic dispatch. +type IFor_each_rowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + EACH() antlr.TerminalNode + ROW() antlr.TerminalNode + + // IsFor_each_rowContext differentiates from other interfaces. + IsFor_each_rowContext() +} + +type For_each_rowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_each_rowContext() *For_each_rowContext { + var p = new(For_each_rowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_each_row + return p +} + +func InitEmptyFor_each_rowContext(p *For_each_rowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_each_row +} + +func (*For_each_rowContext) IsFor_each_rowContext() {} + +func NewFor_each_rowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_each_rowContext { + var p = new(For_each_rowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_each_row + + return p +} + +func (s *For_each_rowContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_each_rowContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_each_rowContext) EACH() antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, 0) +} + +func (s *For_each_rowContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *For_each_rowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_each_rowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_each_rowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_each_row(s) + } +} + +func (s *For_each_rowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_each_row(s) + } +} + +func (s *For_each_rowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFor_each_row(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) For_each_row() (localctx IFor_each_rowContext) { + localctx = NewFor_each_rowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 208, PlSqlParserRULE_for_each_row) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4184) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4185) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4186) + p.Match(PlSqlParserROW) + 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 +} + +// ICompound_dml_triggerContext is an interface to support dynamic dispatch. +type ICompound_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Dml_event_clause() IDml_event_clauseContext + Referencing_clause() IReferencing_clauseContext + + // IsCompound_dml_triggerContext differentiates from other interfaces. + IsCompound_dml_triggerContext() +} + +type Compound_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompound_dml_triggerContext() *Compound_dml_triggerContext { + var p = new(Compound_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger + return p +} + +func InitEmptyCompound_dml_triggerContext(p *Compound_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger +} + +func (*Compound_dml_triggerContext) IsCompound_dml_triggerContext() {} + +func NewCompound_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_dml_triggerContext { + var p = new(Compound_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_dml_trigger + + return p +} + +func (s *Compound_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_dml_triggerContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Compound_dml_triggerContext) Dml_event_clause() IDml_event_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_clauseContext) +} + +func (s *Compound_dml_triggerContext) Referencing_clause() IReferencing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_clauseContext) +} + +func (s *Compound_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_dml_trigger(s) + } +} + +func (s *Compound_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_dml_trigger(s) + } +} + +func (s *Compound_dml_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompound_dml_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compound_dml_trigger() (localctx ICompound_dml_triggerContext) { + localctx = NewCompound_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 210, PlSqlParserRULE_compound_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4188) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4189) + p.Dml_event_clause() + } + p.SetState(4191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFERENCING { + { + p.SetState(4190) + p.Referencing_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 +} + +// INon_dml_triggerContext is an interface to support dynamic dispatch. +type INon_dml_triggerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllNon_dml_event() []INon_dml_eventContext + Non_dml_event(i int) INon_dml_eventContext + ON() antlr.TerminalNode + BEFORE() antlr.TerminalNode + AFTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsNon_dml_triggerContext differentiates from other interfaces. + IsNon_dml_triggerContext() +} + +type Non_dml_triggerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_dml_triggerContext() *Non_dml_triggerContext { + var p = new(Non_dml_triggerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_trigger + return p +} + +func InitEmptyNon_dml_triggerContext(p *Non_dml_triggerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_trigger +} + +func (*Non_dml_triggerContext) IsNon_dml_triggerContext() {} + +func NewNon_dml_triggerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_dml_triggerContext { + var p = new(Non_dml_triggerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_dml_trigger + + return p +} + +func (s *Non_dml_triggerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_dml_triggerContext) AllNon_dml_event() []INon_dml_eventContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INon_dml_eventContext); ok { + len++ + } + } + + tst := make([]INon_dml_eventContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INon_dml_eventContext); ok { + tst[i] = t.(INon_dml_eventContext) + i++ + } + } + + return tst +} + +func (s *Non_dml_triggerContext) Non_dml_event(i int) INon_dml_eventContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_dml_eventContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INon_dml_eventContext) +} + +func (s *Non_dml_triggerContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Non_dml_triggerContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Non_dml_triggerContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Non_dml_triggerContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_dml_triggerContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_dml_triggerContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Non_dml_triggerContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Non_dml_triggerContext) 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 *Non_dml_triggerContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Non_dml_triggerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_dml_triggerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_dml_triggerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_dml_trigger(s) + } +} + +func (s *Non_dml_triggerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_dml_trigger(s) + } +} + +func (s *Non_dml_triggerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNon_dml_trigger(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Non_dml_trigger() (localctx INon_dml_triggerContext) { + localctx = NewNon_dml_triggerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 212, PlSqlParserRULE_non_dml_trigger) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4193) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAFTER || _la == PlSqlParserBEFORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4194) + p.Non_dml_event() + } + p.SetState(4199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(4195) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4196) + p.Non_dml_event() + } + + p.SetState(4201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4202) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 247, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4203) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(4207) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 246, p.GetParserRuleContext()) == 1 { + { + p.SetState(4204) + p.Schema_name() + } + { + p.SetState(4205) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4209) + p.Match(PlSqlParserSCHEMA) + 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 +} + +// ITrigger_bodyContext is an interface to support dynamic dispatch. +type ITrigger_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPOUND() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + CALL() antlr.TerminalNode + Identifier() IIdentifierContext + Trigger_block() ITrigger_blockContext + + // IsTrigger_bodyContext differentiates from other interfaces. + IsTrigger_bodyContext() +} + +type Trigger_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_bodyContext() *Trigger_bodyContext { + var p = new(Trigger_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_body + return p +} + +func InitEmptyTrigger_bodyContext(p *Trigger_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_body +} + +func (*Trigger_bodyContext) IsTrigger_bodyContext() {} + +func NewTrigger_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_bodyContext { + var p = new(Trigger_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_body + + return p +} + +func (s *Trigger_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_bodyContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOUND, 0) +} + +func (s *Trigger_bodyContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Trigger_bodyContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Trigger_bodyContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Trigger_bodyContext) Trigger_block() ITrigger_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_blockContext) +} + +func (s *Trigger_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_body(s) + } +} + +func (s *Trigger_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_body(s) + } +} + +func (s *Trigger_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrigger_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trigger_body() (localctx ITrigger_bodyContext) { + localctx = NewTrigger_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 214, PlSqlParserRULE_trigger_body) + p.SetState(4217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOUND: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4212) + p.Match(PlSqlParserCOMPOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4213) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4214) + p.Match(PlSqlParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4215) + p.Identifier() + } + + case PlSqlParserBEGIN, PlSqlParserDECLARE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4216) + p.Trigger_block() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoutine_clauseContext is an interface to support dynamic dispatch. +type IRoutine_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Routine_name() IRoutine_nameContext + Function_argument() IFunction_argumentContext + + // IsRoutine_clauseContext differentiates from other interfaces. + IsRoutine_clauseContext() +} + +type Routine_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoutine_clauseContext() *Routine_clauseContext { + var p = new(Routine_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_clause + return p +} + +func InitEmptyRoutine_clauseContext(p *Routine_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_clause +} + +func (*Routine_clauseContext) IsRoutine_clauseContext() {} + +func NewRoutine_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Routine_clauseContext { + var p = new(Routine_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_routine_clause + + return p +} + +func (s *Routine_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Routine_clauseContext) Routine_name() IRoutine_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutine_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutine_nameContext) +} + +func (s *Routine_clauseContext) Function_argument() IFunction_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *Routine_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Routine_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Routine_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRoutine_clause(s) + } +} + +func (s *Routine_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRoutine_clause(s) + } +} + +func (s *Routine_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRoutine_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Routine_clause() (localctx IRoutine_clauseContext) { + localctx = NewRoutine_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 216, PlSqlParserRULE_routine_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4219) + p.Routine_name() + } + p.SetState(4221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4220) + p.Function_argument() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICompound_trigger_blockContext is an interface to support dynamic dispatch. +type ICompound_trigger_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPOUND() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + END() antlr.TerminalNode + Trigger_name() ITrigger_nameContext + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllTiming_point_section() []ITiming_point_sectionContext + Timing_point_section(i int) ITiming_point_sectionContext + + // IsCompound_trigger_blockContext differentiates from other interfaces. + IsCompound_trigger_blockContext() +} + +type Compound_trigger_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompound_trigger_blockContext() *Compound_trigger_blockContext { + var p = new(Compound_trigger_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_trigger_block + return p +} + +func InitEmptyCompound_trigger_blockContext(p *Compound_trigger_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_trigger_block +} + +func (*Compound_trigger_blockContext) IsCompound_trigger_blockContext() {} + +func NewCompound_trigger_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_trigger_blockContext { + var p = new(Compound_trigger_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_trigger_block + + return p +} + +func (s *Compound_trigger_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_trigger_blockContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOUND, 0) +} + +func (s *Compound_trigger_blockContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Compound_trigger_blockContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Compound_trigger_blockContext) Trigger_name() ITrigger_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_nameContext) +} + +func (s *Compound_trigger_blockContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Compound_trigger_blockContext) AllTiming_point_section() []ITiming_point_sectionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITiming_point_sectionContext); ok { + len++ + } + } + + tst := make([]ITiming_point_sectionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITiming_point_sectionContext); ok { + tst[i] = t.(ITiming_point_sectionContext) + i++ + } + } + + return tst +} + +func (s *Compound_trigger_blockContext) Timing_point_section(i int) ITiming_point_sectionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITiming_point_sectionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITiming_point_sectionContext) +} + +func (s *Compound_trigger_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_trigger_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_trigger_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_trigger_block(s) + } +} + +func (s *Compound_trigger_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_trigger_block(s) + } +} + +func (s *Compound_trigger_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompound_trigger_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compound_trigger_block() (localctx ICompound_trigger_blockContext) { + localctx = NewCompound_trigger_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 218, PlSqlParserRULE_compound_trigger_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4223) + p.Match(PlSqlParserCOMPOUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4224) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4226) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 250, p.GetParserRuleContext()) == 1 { + { + p.SetState(4225) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserAFTER || _la == PlSqlParserBEFORE { + { + p.SetState(4228) + p.Timing_point_section() + } + + p.SetState(4231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4233) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4234) + p.Trigger_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 +} + +// ITiming_point_sectionContext is an interface to support dynamic dispatch. +type ITiming_point_sectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBk returns the bk token. + GetBk() antlr.Token + + // GetAk returns the ak token. + GetAk() antlr.Token + + // SetBk sets the bk token. + SetBk(antlr.Token) + + // SetAk sets the ak token. + SetAk(antlr.Token) + + // Getter signatures + AllSTATEMENT() []antlr.TerminalNode + STATEMENT(i int) antlr.TerminalNode + IS() antlr.TerminalNode + Trigger_block() ITrigger_blockContext + AllBEFORE() []antlr.TerminalNode + BEFORE(i int) antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + AllEACH() []antlr.TerminalNode + EACH(i int) antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllAFTER() []antlr.TerminalNode + AFTER(i int) antlr.TerminalNode + + // IsTiming_point_sectionContext differentiates from other interfaces. + IsTiming_point_sectionContext() +} + +type Timing_point_sectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bk antlr.Token + ak antlr.Token +} + +func NewEmptyTiming_point_sectionContext() *Timing_point_sectionContext { + var p = new(Timing_point_sectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_point_section + return p +} + +func InitEmptyTiming_point_sectionContext(p *Timing_point_sectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_point_section +} + +func (*Timing_point_sectionContext) IsTiming_point_sectionContext() {} + +func NewTiming_point_sectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timing_point_sectionContext { + var p = new(Timing_point_sectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timing_point_section + + return p +} + +func (s *Timing_point_sectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timing_point_sectionContext) GetBk() antlr.Token { return s.bk } + +func (s *Timing_point_sectionContext) GetAk() antlr.Token { return s.ak } + +func (s *Timing_point_sectionContext) SetBk(v antlr.Token) { s.bk = v } + +func (s *Timing_point_sectionContext) SetAk(v antlr.Token) { s.ak = v } + +func (s *Timing_point_sectionContext) AllSTATEMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATEMENT) +} + +func (s *Timing_point_sectionContext) STATEMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, i) +} + +func (s *Timing_point_sectionContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Timing_point_sectionContext) Trigger_block() ITrigger_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrigger_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrigger_blockContext) +} + +func (s *Timing_point_sectionContext) AllBEFORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBEFORE) +} + +func (s *Timing_point_sectionContext) BEFORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, i) +} + +func (s *Timing_point_sectionContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Timing_point_sectionContext) AllEACH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEACH) +} + +func (s *Timing_point_sectionContext) EACH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, i) +} + +func (s *Timing_point_sectionContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Timing_point_sectionContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Timing_point_sectionContext) AllAFTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAFTER) +} + +func (s *Timing_point_sectionContext) AFTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, i) +} + +func (s *Timing_point_sectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timing_point_sectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timing_point_sectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTiming_point_section(s) + } +} + +func (s *Timing_point_sectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTiming_point_section(s) + } +} + +func (s *Timing_point_sectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTiming_point_section(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Timing_point_section() (localctx ITiming_point_sectionContext) { + localctx = NewTiming_point_sectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 220, PlSqlParserRULE_timing_point_section) + p.SetState(4272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 252, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4236) + + var _m = p.Match(PlSqlParserBEFORE) + + localctx.(*Timing_point_sectionContext).bk = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4237) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4238) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4239) + p.Trigger_block() + } + { + p.SetState(4240) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4241) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4242) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4244) + + var _m = p.Match(PlSqlParserBEFORE) + + localctx.(*Timing_point_sectionContext).bk = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4245) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4246) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4247) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4248) + p.Trigger_block() + } + { + p.SetState(4249) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4250) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4251) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4252) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4254) + + var _m = p.Match(PlSqlParserAFTER) + + localctx.(*Timing_point_sectionContext).ak = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4255) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4256) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4257) + p.Trigger_block() + } + { + p.SetState(4258) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4259) + p.Match(PlSqlParserSTATEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4260) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4262) + + var _m = p.Match(PlSqlParserAFTER) + + localctx.(*Timing_point_sectionContext).ak = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4263) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4264) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4265) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4266) + p.Trigger_block() + } + { + p.SetState(4267) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4268) + p.Match(PlSqlParserEACH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4269) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4270) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// INon_dml_eventContext is an interface to support dynamic dispatch. +type INon_dml_eventContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + ASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + CREATE() antlr.TerminalNode + DISASSOCIATE() antlr.TerminalNode + DROP() antlr.TerminalNode + GRANT() antlr.TerminalNode + NOAUDIT() antlr.TerminalNode + RENAME() antlr.TerminalNode + REVOKE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + DDL() antlr.TerminalNode + STARTUP() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + DB_ROLE_CHANGE() antlr.TerminalNode + LOGON() antlr.TerminalNode + LOGOFF() antlr.TerminalNode + SERVERERROR() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + FOLLOWS() antlr.TerminalNode + + // IsNon_dml_eventContext differentiates from other interfaces. + IsNon_dml_eventContext() +} + +type Non_dml_eventContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_dml_eventContext() *Non_dml_eventContext { + var p = new(Non_dml_eventContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_event + return p +} + +func InitEmptyNon_dml_eventContext(p *Non_dml_eventContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_dml_event +} + +func (*Non_dml_eventContext) IsNon_dml_eventContext() {} + +func NewNon_dml_eventContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_dml_eventContext { + var p = new(Non_dml_eventContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_dml_event + + return p +} + +func (s *Non_dml_eventContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_dml_eventContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Non_dml_eventContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Non_dml_eventContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Non_dml_eventContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Non_dml_eventContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Non_dml_eventContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Non_dml_eventContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Non_dml_eventContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Non_dml_eventContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Non_dml_eventContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Non_dml_eventContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Non_dml_eventContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Non_dml_eventContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Non_dml_eventContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Non_dml_eventContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Non_dml_eventContext) STARTUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTUP, 0) +} + +func (s *Non_dml_eventContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Non_dml_eventContext) DB_ROLE_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_ROLE_CHANGE, 0) +} + +func (s *Non_dml_eventContext) LOGON() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGON, 0) +} + +func (s *Non_dml_eventContext) LOGOFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGOFF, 0) +} + +func (s *Non_dml_eventContext) SERVERERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVERERROR, 0) +} + +func (s *Non_dml_eventContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Non_dml_eventContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_dml_eventContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_dml_eventContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Non_dml_eventContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_dml_eventContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_dml_eventContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_dml_event(s) + } +} + +func (s *Non_dml_eventContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_dml_event(s) + } +} + +func (s *Non_dml_eventContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNon_dml_event(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Non_dml_event() (localctx INon_dml_eventContext) { + localctx = NewNon_dml_eventContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 222, PlSqlParserRULE_non_dml_event) + p.SetState(4300) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4274) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserANALYZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4275) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserASSOCIATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4276) + p.Match(PlSqlParserASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4277) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUDIT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4278) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMMENT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4279) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4280) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISASSOCIATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4281) + p.Match(PlSqlParserDISASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4282) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4283) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGRANT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4284) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOAUDIT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4285) + p.Match(PlSqlParserNOAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4286) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREVOKE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(4287) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUNCATE: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(4288) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDDL: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(4289) + p.Match(PlSqlParserDDL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTARTUP: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(4290) + p.Match(PlSqlParserSTARTUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSHUTDOWN: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(4291) + p.Match(PlSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDB_ROLE_CHANGE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(4292) + p.Match(PlSqlParserDB_ROLE_CHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGON: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(4293) + p.Match(PlSqlParserLOGON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGOFF: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(4294) + p.Match(PlSqlParserLOGOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSERVERERROR: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(4295) + p.Match(PlSqlParserSERVERERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUSPEND: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(4296) + p.Match(PlSqlParserSUSPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATABASE: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(4297) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSCHEMA: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(4298) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOLLOWS: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(4299) + p.Match(PlSqlParserFOLLOWS) + 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 +} + +// IDml_event_clauseContext is an interface to support dynamic dispatch. +type IDml_event_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDml_event_element() []IDml_event_elementContext + Dml_event_element(i int) IDml_event_elementContext + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + Dml_event_nested_clause() IDml_event_nested_clauseContext + + // IsDml_event_clauseContext differentiates from other interfaces. + IsDml_event_clauseContext() +} + +type Dml_event_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_clauseContext() *Dml_event_clauseContext { + var p = new(Dml_event_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_clause + return p +} + +func InitEmptyDml_event_clauseContext(p *Dml_event_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_clause +} + +func (*Dml_event_clauseContext) IsDml_event_clauseContext() {} + +func NewDml_event_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_clauseContext { + var p = new(Dml_event_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_clause + + return p +} + +func (s *Dml_event_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_clauseContext) AllDml_event_element() []IDml_event_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDml_event_elementContext); ok { + len++ + } + } + + tst := make([]IDml_event_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDml_event_elementContext); ok { + tst[i] = t.(IDml_event_elementContext) + i++ + } + } + + return tst +} + +func (s *Dml_event_clauseContext) Dml_event_element(i int) IDml_event_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_elementContext) +} + +func (s *Dml_event_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Dml_event_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_event_clauseContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Dml_event_clauseContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Dml_event_clauseContext) Dml_event_nested_clause() IDml_event_nested_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_event_nested_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_event_nested_clauseContext) +} + +func (s *Dml_event_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_clause(s) + } +} + +func (s *Dml_event_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_clause(s) + } +} + +func (s *Dml_event_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDml_event_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dml_event_clause() (localctx IDml_event_clauseContext) { + localctx = NewDml_event_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 224, PlSqlParserRULE_dml_event_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4302) + p.Dml_event_element() + } + p.SetState(4307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(4303) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4304) + p.Dml_event_element() + } + + p.SetState(4309) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4310) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 255, p.GetParserRuleContext()) == 1 { + { + p.SetState(4311) + p.Dml_event_nested_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4314) + p.Tableview_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 +} + +// IDml_event_elementContext is an interface to support dynamic dispatch. +type IDml_event_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + INSERT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + OF() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsDml_event_elementContext differentiates from other interfaces. + IsDml_event_elementContext() +} + +type Dml_event_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_elementContext() *Dml_event_elementContext { + var p = new(Dml_event_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_element + return p +} + +func InitEmptyDml_event_elementContext(p *Dml_event_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_element +} + +func (*Dml_event_elementContext) IsDml_event_elementContext() {} + +func NewDml_event_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_elementContext { + var p = new(Dml_event_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_element + + return p +} + +func (s *Dml_event_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_elementContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Dml_event_elementContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Dml_event_elementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Dml_event_elementContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Dml_event_elementContext) 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 *Dml_event_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_element(s) + } +} + +func (s *Dml_event_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_element(s) + } +} + +func (s *Dml_event_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDml_event_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dml_event_element() (localctx IDml_event_elementContext) { + localctx = NewDml_event_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 226, PlSqlParserRULE_dml_event_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4316) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserINSERT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(4317) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4318) + p.Column_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 +} + +// IDml_event_nested_clauseContext is an interface to support dynamic dispatch. +type IDml_event_nested_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + OF() antlr.TerminalNode + + // IsDml_event_nested_clauseContext differentiates from other interfaces. + IsDml_event_nested_clauseContext() +} + +type Dml_event_nested_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_event_nested_clauseContext() *Dml_event_nested_clauseContext { + var p = new(Dml_event_nested_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause + return p +} + +func InitEmptyDml_event_nested_clauseContext(p *Dml_event_nested_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause +} + +func (*Dml_event_nested_clauseContext) IsDml_event_nested_clauseContext() {} + +func NewDml_event_nested_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_event_nested_clauseContext { + var p = new(Dml_event_nested_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_event_nested_clause + + return p +} + +func (s *Dml_event_nested_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_event_nested_clauseContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Dml_event_nested_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Dml_event_nested_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_event_nested_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Dml_event_nested_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_event_nested_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_event_nested_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_event_nested_clause(s) + } +} + +func (s *Dml_event_nested_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_event_nested_clause(s) + } +} + +func (s *Dml_event_nested_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDml_event_nested_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dml_event_nested_clause() (localctx IDml_event_nested_clauseContext) { + localctx = NewDml_event_nested_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 228, PlSqlParserRULE_dml_event_nested_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4321) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4322) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4323) + p.Tableview_name() + } + { + p.SetState(4324) + p.Match(PlSqlParserOF) + 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 +} + +// IReferencing_clauseContext is an interface to support dynamic dispatch. +type IReferencing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCING() antlr.TerminalNode + AllReferencing_element() []IReferencing_elementContext + Referencing_element(i int) IReferencing_elementContext + + // IsReferencing_clauseContext differentiates from other interfaces. + IsReferencing_clauseContext() +} + +type Referencing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferencing_clauseContext() *Referencing_clauseContext { + var p = new(Referencing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_clause + return p +} + +func InitEmptyReferencing_clauseContext(p *Referencing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_clause +} + +func (*Referencing_clauseContext) IsReferencing_clauseContext() {} + +func NewReferencing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Referencing_clauseContext { + var p = new(Referencing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_referencing_clause + + return p +} + +func (s *Referencing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Referencing_clauseContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCING, 0) +} + +func (s *Referencing_clauseContext) AllReferencing_element() []IReferencing_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReferencing_elementContext); ok { + len++ + } + } + + tst := make([]IReferencing_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReferencing_elementContext); ok { + tst[i] = t.(IReferencing_elementContext) + i++ + } + } + + return tst +} + +func (s *Referencing_clauseContext) Referencing_element(i int) IReferencing_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferencing_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReferencing_elementContext) +} + +func (s *Referencing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Referencing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Referencing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferencing_clause(s) + } +} + +func (s *Referencing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferencing_clause(s) + } +} + +func (s *Referencing_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReferencing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Referencing_clause() (localctx IReferencing_clauseContext) { + localctx = NewReferencing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 230, PlSqlParserRULE_referencing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4326) + p.Match(PlSqlParserREFERENCING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserNEW || _la == PlSqlParserOLD || _la == PlSqlParserPARENT { + { + p.SetState(4327) + p.Referencing_element() + } + + p.SetState(4330) + 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 +} + +// IReferencing_elementContext is an interface to support dynamic dispatch. +type IReferencing_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_alias() IColumn_aliasContext + NEW() antlr.TerminalNode + OLD() antlr.TerminalNode + PARENT() antlr.TerminalNode + + // IsReferencing_elementContext differentiates from other interfaces. + IsReferencing_elementContext() +} + +type Referencing_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferencing_elementContext() *Referencing_elementContext { + var p = new(Referencing_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_element + return p +} + +func InitEmptyReferencing_elementContext(p *Referencing_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_referencing_element +} + +func (*Referencing_elementContext) IsReferencing_elementContext() {} + +func NewReferencing_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Referencing_elementContext { + var p = new(Referencing_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_referencing_element + + return p +} + +func (s *Referencing_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Referencing_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Referencing_elementContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Referencing_elementContext) OLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD, 0) +} + +func (s *Referencing_elementContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Referencing_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Referencing_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Referencing_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferencing_element(s) + } +} + +func (s *Referencing_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferencing_element(s) + } +} + +func (s *Referencing_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReferencing_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Referencing_element() (localctx IReferencing_elementContext) { + localctx = NewReferencing_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 232, PlSqlParserRULE_referencing_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4332) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNEW || _la == PlSqlParserOLD || _la == PlSqlParserPARENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4333) + p.Column_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 +} + +// IDrop_typeContext is an interface to support dynamic dispatch. +type IDrop_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_name() IType_nameContext + SEMICOLON() antlr.TerminalNode + BODY() antlr.TerminalNode + FORCE() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + + // IsDrop_typeContext differentiates from other interfaces. + IsDrop_typeContext() +} + +type Drop_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_typeContext() *Drop_typeContext { + var p = new(Drop_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_type + return p +} + +func InitEmptyDrop_typeContext(p *Drop_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_type +} + +func (*Drop_typeContext) IsDrop_typeContext() {} + +func NewDrop_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_typeContext { + var p = new(Drop_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_type + + return p +} + +func (s *Drop_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_typeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Drop_typeContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Drop_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_typeContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Drop_typeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_typeContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Drop_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_type(s) + } +} + +func (s *Drop_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_type(s) + } +} + +func (s *Drop_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_type() (localctx IDrop_typeContext) { + localctx = NewDrop_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 234, PlSqlParserRULE_drop_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4335) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4336) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4338) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 258, p.GetParserRuleContext()) == 1 { + { + p.SetState(4337) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4340) + p.Type_name() + } + p.SetState(4342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserVALIDATE { + { + p.SetState(4341) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4344) + p.Match(PlSqlParserSEMICOLON) + 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_typeContext is an interface to support dynamic dispatch. +type IAlter_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_name() IType_nameContext + SEMICOLON() antlr.TerminalNode + Compile_type_clause() ICompile_type_clauseContext + Replace_type_clause() IReplace_type_clauseContext + Alter_method_spec() IAlter_method_specContext + Alter_collection_clauses() IAlter_collection_clausesContext + Modifier_clause() IModifier_clauseContext + Overriding_subprogram_spec() IOverriding_subprogram_specContext + Dependent_handling_clause() IDependent_handling_clauseContext + + // IsAlter_typeContext differentiates from other interfaces. + IsAlter_typeContext() +} + +type Alter_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_typeContext() *Alter_typeContext { + var p = new(Alter_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_type + return p +} + +func InitEmptyAlter_typeContext(p *Alter_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_type +} + +func (*Alter_typeContext) IsAlter_typeContext() {} + +func NewAlter_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_typeContext { + var p = new(Alter_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_type + + return p +} + +func (s *Alter_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_typeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Alter_typeContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Alter_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_typeContext) Compile_type_clause() ICompile_type_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompile_type_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompile_type_clauseContext) +} + +func (s *Alter_typeContext) Replace_type_clause() IReplace_type_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplace_type_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplace_type_clauseContext) +} + +func (s *Alter_typeContext) Alter_method_spec() IAlter_method_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_method_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_method_specContext) +} + +func (s *Alter_typeContext) Alter_collection_clauses() IAlter_collection_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_collection_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_collection_clausesContext) +} + +func (s *Alter_typeContext) Modifier_clause() IModifier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Alter_typeContext) Overriding_subprogram_spec() IOverriding_subprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_subprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_subprogram_specContext) +} + +func (s *Alter_typeContext) Dependent_handling_clause() IDependent_handling_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDependent_handling_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDependent_handling_clauseContext) +} + +func (s *Alter_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_type(s) + } +} + +func (s *Alter_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_type(s) + } +} + +func (s *Alter_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_type() (localctx IAlter_typeContext) { + localctx = NewAlter_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 236, PlSqlParserRULE_alter_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4346) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4347) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4348) + p.Type_name() + } + p.SetState(4355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 260, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4349) + p.Compile_type_clause() + } + + case 2: + { + p.SetState(4350) + p.Replace_type_clause() + } + + case 3: + { + p.SetState(4351) + p.Alter_method_spec() + } + + case 4: + { + p.SetState(4352) + p.Alter_collection_clauses() + } + + case 5: + { + p.SetState(4353) + p.Modifier_clause() + } + + case 6: + { + p.SetState(4354) + p.Overriding_subprogram_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + { + p.SetState(4357) + p.Dependent_handling_clause() + } + + } + { + p.SetState(4360) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ICompile_type_clauseContext is an interface to support dynamic dispatch. +type ICompile_type_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPILE() antlr.TerminalNode + DEBUG() antlr.TerminalNode + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + BODY() antlr.TerminalNode + + // IsCompile_type_clauseContext differentiates from other interfaces. + IsCompile_type_clauseContext() +} + +type Compile_type_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompile_type_clauseContext() *Compile_type_clauseContext { + var p = new(Compile_type_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compile_type_clause + return p +} + +func InitEmptyCompile_type_clauseContext(p *Compile_type_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compile_type_clause +} + +func (*Compile_type_clauseContext) IsCompile_type_clauseContext() {} + +func NewCompile_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compile_type_clauseContext { + var p = new(Compile_type_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compile_type_clause + + return p +} + +func (s *Compile_type_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compile_type_clauseContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Compile_type_clauseContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Compile_type_clauseContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Compile_type_clauseContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Compile_type_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Compile_type_clauseContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Compile_type_clauseContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Compile_type_clauseContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Compile_type_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compile_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compile_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompile_type_clause(s) + } +} + +func (s *Compile_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompile_type_clause(s) + } +} + +func (s *Compile_type_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompile_type_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compile_type_clause() (localctx ICompile_type_clauseContext) { + localctx = NewCompile_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 238, PlSqlParserRULE_compile_type_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4362) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4364) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 262, p.GetParserRuleContext()) == 1 { + { + p.SetState(4363) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4367) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 263, p.GetParserRuleContext()) == 1 { + { + p.SetState(4366) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBODY || _la == PlSqlParserSPECIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4372) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4369) + p.Compiler_parameters_clause() + } + + } + p.SetState(4374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 264, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(4375) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4376) + p.Match(PlSqlParserSETTINGS) + 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 +} + +// IReplace_type_clauseContext is an interface to support dynamic dispatch. +type IReplace_type_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REPLACE() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllObject_member_spec() []IObject_member_specContext + Object_member_spec(i int) IObject_member_specContext + RIGHT_PAREN() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReplace_type_clauseContext differentiates from other interfaces. + IsReplace_type_clauseContext() +} + +type Replace_type_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplace_type_clauseContext() *Replace_type_clauseContext { + var p = new(Replace_type_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_type_clause + return p +} + +func InitEmptyReplace_type_clauseContext(p *Replace_type_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replace_type_clause +} + +func (*Replace_type_clauseContext) IsReplace_type_clauseContext() {} + +func NewReplace_type_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replace_type_clauseContext { + var p = new(Replace_type_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replace_type_clause + + return p +} + +func (s *Replace_type_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replace_type_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Replace_type_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Replace_type_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Replace_type_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Replace_type_clauseContext) AllObject_member_spec() []IObject_member_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_member_specContext); ok { + len++ + } + } + + tst := make([]IObject_member_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_member_specContext); ok { + tst[i] = t.(IObject_member_specContext) + i++ + } + } + + return tst +} + +func (s *Replace_type_clauseContext) Object_member_spec(i int) IObject_member_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_member_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_member_specContext) +} + +func (s *Replace_type_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Replace_type_clauseContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Replace_type_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Replace_type_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Replace_type_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replace_type_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replace_type_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplace_type_clause(s) + } +} + +func (s *Replace_type_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplace_type_clause(s) + } +} + +func (s *Replace_type_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReplace_type_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Replace_type_clause() (localctx IReplace_type_clauseContext) { + localctx = NewReplace_type_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 240, PlSqlParserRULE_replace_type_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4379) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4380) + p.Invoker_rights_clause() + } + + } + { + p.SetState(4383) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4384) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4385) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4386) + p.Object_member_spec() + } + p.SetState(4391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4387) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4388) + p.Object_member_spec() + } + + p.SetState(4393) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4394) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_method_specContext is an interface to support dynamic dispatch. +type IAlter_method_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllAlter_method_element() []IAlter_method_elementContext + Alter_method_element(i int) IAlter_method_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_method_specContext differentiates from other interfaces. + IsAlter_method_specContext() +} + +type Alter_method_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_method_specContext() *Alter_method_specContext { + var p = new(Alter_method_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_spec + return p +} + +func InitEmptyAlter_method_specContext(p *Alter_method_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_spec +} + +func (*Alter_method_specContext) IsAlter_method_specContext() {} + +func NewAlter_method_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_method_specContext { + var p = new(Alter_method_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_method_spec + + return p +} + +func (s *Alter_method_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_method_specContext) AllAlter_method_element() []IAlter_method_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_method_elementContext); ok { + len++ + } + } + + tst := make([]IAlter_method_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_method_elementContext); ok { + tst[i] = t.(IAlter_method_elementContext) + i++ + } + } + + return tst +} + +func (s *Alter_method_specContext) Alter_method_element(i int) IAlter_method_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_method_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_method_elementContext) +} + +func (s *Alter_method_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_method_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_method_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_method_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_method_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_method_spec(s) + } +} + +func (s *Alter_method_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_method_spec(s) + } +} + +func (s *Alter_method_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_method_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_method_spec() (localctx IAlter_method_specContext) { + localctx = NewAlter_method_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 242, PlSqlParserRULE_alter_method_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4396) + p.Alter_method_element() + } + p.SetState(4401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4397) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4398) + p.Alter_method_element() + } + + p.SetState(4403) + 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_method_elementContext is an interface to support dynamic dispatch. +type IAlter_method_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + Map_order_function_spec() IMap_order_function_specContext + Subprogram_spec() ISubprogram_specContext + + // IsAlter_method_elementContext differentiates from other interfaces. + IsAlter_method_elementContext() +} + +type Alter_method_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_method_elementContext() *Alter_method_elementContext { + var p = new(Alter_method_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_element + return p +} + +func InitEmptyAlter_method_elementContext(p *Alter_method_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_method_element +} + +func (*Alter_method_elementContext) IsAlter_method_elementContext() {} + +func NewAlter_method_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_method_elementContext { + var p = new(Alter_method_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_method_element + + return p +} + +func (s *Alter_method_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_method_elementContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_method_elementContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_method_elementContext) Map_order_function_spec() IMap_order_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_function_specContext) +} + +func (s *Alter_method_elementContext) Subprogram_spec() ISubprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprogram_specContext) +} + +func (s *Alter_method_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_method_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_method_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_method_element(s) + } +} + +func (s *Alter_method_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_method_element(s) + } +} + +func (s *Alter_method_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_method_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_method_element() (localctx IAlter_method_elementContext) { + localctx = NewAlter_method_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 244, PlSqlParserRULE_alter_method_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4404) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAP, PlSqlParserORDER: + { + p.SetState(4405) + p.Map_order_function_spec() + } + + case PlSqlParserMEMBER, PlSqlParserSTATIC: + { + p.SetState(4406) + p.Subprogram_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_attribute_definitionContext is an interface to support dynamic dispatch. +type IAlter_attribute_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTE() antlr.TerminalNode + ADD() antlr.TerminalNode + MODIFY() antlr.TerminalNode + DROP() antlr.TerminalNode + AllAttribute_definition() []IAttribute_definitionContext + Attribute_definition(i int) IAttribute_definitionContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_attribute_definitionContext differentiates from other interfaces. + IsAlter_attribute_definitionContext() +} + +type Alter_attribute_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_attribute_definitionContext() *Alter_attribute_definitionContext { + var p = new(Alter_attribute_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_definition + return p +} + +func InitEmptyAlter_attribute_definitionContext(p *Alter_attribute_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_definition +} + +func (*Alter_attribute_definitionContext) IsAlter_attribute_definitionContext() {} + +func NewAlter_attribute_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_attribute_definitionContext { + var p = new(Alter_attribute_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_attribute_definition + + return p +} + +func (s *Alter_attribute_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_attribute_definitionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Alter_attribute_definitionContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_attribute_definitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_attribute_definitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_attribute_definitionContext) AllAttribute_definition() []IAttribute_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_definitionContext); ok { + len++ + } + } + + tst := make([]IAttribute_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_definitionContext); ok { + tst[i] = t.(IAttribute_definitionContext) + i++ + } + } + + return tst +} + +func (s *Alter_attribute_definitionContext) Attribute_definition(i int) IAttribute_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_definitionContext) +} + +func (s *Alter_attribute_definitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_attribute_definitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_attribute_definitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_attribute_definitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_attribute_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_attribute_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_attribute_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_attribute_definition(s) + } +} + +func (s *Alter_attribute_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_attribute_definition(s) + } +} + +func (s *Alter_attribute_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_attribute_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_attribute_definition() (localctx IAlter_attribute_definitionContext) { + localctx = NewAlter_attribute_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 246, PlSqlParserRULE_alter_attribute_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4409) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP || _la == PlSqlParserMODIFY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4410) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(4411) + p.Attribute_definition() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(4412) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4413) + p.Attribute_definition() + } + p.SetState(4418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4414) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4415) + p.Attribute_definition() + } + + p.SetState(4420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4421) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttribute_definitionContext is an interface to support dynamic dispatch. +type IAttribute_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Attribute_name() IAttribute_nameContext + Type_spec() IType_specContext + + // IsAttribute_definitionContext differentiates from other interfaces. + IsAttribute_definitionContext() +} + +type Attribute_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_definitionContext() *Attribute_definitionContext { + var p = new(Attribute_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_definition + return p +} + +func InitEmptyAttribute_definitionContext(p *Attribute_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_definition +} + +func (*Attribute_definitionContext) IsAttribute_definitionContext() {} + +func NewAttribute_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_definitionContext { + var p = new(Attribute_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_definition + + return p +} + +func (s *Attribute_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_definitionContext) Attribute_name() IAttribute_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Attribute_definitionContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Attribute_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_definition(s) + } +} + +func (s *Attribute_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_definition(s) + } +} + +func (s *Attribute_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAttribute_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Attribute_definition() (localctx IAttribute_definitionContext) { + localctx = NewAttribute_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 248, PlSqlParserRULE_attribute_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4425) + p.Attribute_name() + } + p.SetState(4427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864812498945) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1025) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(4426) + p.Type_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_collection_clausesContext is an interface to support dynamic dispatch. +type IAlter_collection_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Expression() IExpressionContext + ELEMENT() antlr.TerminalNode + TYPE() antlr.TerminalNode + Type_spec() IType_specContext + + // IsAlter_collection_clausesContext differentiates from other interfaces. + IsAlter_collection_clausesContext() +} + +type Alter_collection_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_collection_clausesContext() *Alter_collection_clausesContext { + var p = new(Alter_collection_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses + return p +} + +func InitEmptyAlter_collection_clausesContext(p *Alter_collection_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses +} + +func (*Alter_collection_clausesContext) IsAlter_collection_clausesContext() {} + +func NewAlter_collection_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_collection_clausesContext { + var p = new(Alter_collection_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_collection_clauses + + return p +} + +func (s *Alter_collection_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_collection_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_collection_clausesContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Alter_collection_clausesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_collection_clausesContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Alter_collection_clausesContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Alter_collection_clausesContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Alter_collection_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_collection_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_collection_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_collection_clauses(s) + } +} + +func (s *Alter_collection_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_collection_clauses(s) + } +} + +func (s *Alter_collection_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_collection_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_collection_clauses() (localctx IAlter_collection_clausesContext) { + localctx = NewAlter_collection_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 250, PlSqlParserRULE_alter_collection_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4429) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLIMIT: + { + p.SetState(4430) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4431) + p.Expression() + } + + case PlSqlParserELEMENT: + { + p.SetState(4432) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4433) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4434) + p.Type_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDependent_handling_clauseContext is an interface to support dynamic dispatch. +type IDependent_handling_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INVALIDATE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONVERT() antlr.TerminalNode + TO() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + TABLE() antlr.TerminalNode + DATA() antlr.TerminalNode + Dependent_exceptions_part() IDependent_exceptions_partContext + NOT() antlr.TerminalNode + + // IsDependent_handling_clauseContext differentiates from other interfaces. + IsDependent_handling_clauseContext() +} + +type Dependent_handling_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDependent_handling_clauseContext() *Dependent_handling_clauseContext { + var p = new(Dependent_handling_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause + return p +} + +func InitEmptyDependent_handling_clauseContext(p *Dependent_handling_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause +} + +func (*Dependent_handling_clauseContext) IsDependent_handling_clauseContext() {} + +func NewDependent_handling_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dependent_handling_clauseContext { + var p = new(Dependent_handling_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dependent_handling_clause + + return p +} + +func (s *Dependent_handling_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dependent_handling_clauseContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Dependent_handling_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Dependent_handling_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Dependent_handling_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Dependent_handling_clauseContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Dependent_handling_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Dependent_handling_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Dependent_handling_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Dependent_handling_clauseContext) Dependent_exceptions_part() IDependent_exceptions_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDependent_exceptions_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDependent_exceptions_partContext) +} + +func (s *Dependent_handling_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Dependent_handling_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dependent_handling_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dependent_handling_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDependent_handling_clause(s) + } +} + +func (s *Dependent_handling_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDependent_handling_clause(s) + } +} + +func (s *Dependent_handling_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDependent_handling_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dependent_handling_clause() (localctx IDependent_handling_clauseContext) { + localctx = NewDependent_handling_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 252, PlSqlParserRULE_dependent_handling_clause) + var _la int + + p.SetState(4453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINVALIDATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4437) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCASCADE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4438) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONVERT: + { + p.SetState(4439) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4440) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4441) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINCLUDING, PlSqlParserNOT: + p.SetState(4443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(4442) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4445) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4446) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4447) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCEPTIONS, PlSqlParserFORCE, PlSqlParserSEMICOLON: + + default: + } + p.SetState(4451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTIONS || _la == PlSqlParserFORCE { + { + p.SetState(4450) + p.Dependent_exceptions_part() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDependent_exceptions_partContext is an interface to support dynamic dispatch. +type IDependent_exceptions_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTIONS() antlr.TerminalNode + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + FORCE() antlr.TerminalNode + + // IsDependent_exceptions_partContext differentiates from other interfaces. + IsDependent_exceptions_partContext() +} + +type Dependent_exceptions_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDependent_exceptions_partContext() *Dependent_exceptions_partContext { + var p = new(Dependent_exceptions_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part + return p +} + +func InitEmptyDependent_exceptions_partContext(p *Dependent_exceptions_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part +} + +func (*Dependent_exceptions_partContext) IsDependent_exceptions_partContext() {} + +func NewDependent_exceptions_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dependent_exceptions_partContext { + var p = new(Dependent_exceptions_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dependent_exceptions_part + + return p +} + +func (s *Dependent_exceptions_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dependent_exceptions_partContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Dependent_exceptions_partContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Dependent_exceptions_partContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dependent_exceptions_partContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Dependent_exceptions_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dependent_exceptions_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dependent_exceptions_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDependent_exceptions_part(s) + } +} + +func (s *Dependent_exceptions_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDependent_exceptions_part(s) + } +} + +func (s *Dependent_exceptions_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDependent_exceptions_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dependent_exceptions_part() (localctx IDependent_exceptions_partContext) { + localctx = NewDependent_exceptions_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 254, PlSqlParserRULE_dependent_exceptions_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(4455) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4458) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4459) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4460) + p.Tableview_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 +} + +// ICreate_typeContext is an interface to support dynamic dispatch. +type ICreate_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + TYPE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Type_definition() IType_definitionContext + Type_body() IType_bodyContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsCreate_typeContext differentiates from other interfaces. + IsCreate_typeContext() +} + +type Create_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_typeContext() *Create_typeContext { + var p = new(Create_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_type + return p +} + +func InitEmptyCreate_typeContext(p *Create_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_type +} + +func (*Create_typeContext) IsCreate_typeContext() {} + +func NewCreate_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_typeContext { + var p = new(Create_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_type + + return p +} + +func (s *Create_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_typeContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_typeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Create_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_typeContext) Type_definition() IType_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_definitionContext) +} + +func (s *Create_typeContext) Type_body() IType_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_bodyContext) +} + +func (s *Create_typeContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_typeContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_type(s) + } +} + +func (s *Create_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_type(s) + } +} + +func (s *Create_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_type() (localctx ICreate_typeContext) { + localctx = NewCreate_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 256, PlSqlParserRULE_create_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4462) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4463) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4464) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4467) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 280, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4468) + p.Type_definition() + } + + case 2: + { + p.SetState(4469) + p.Type_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(4472) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IType_definitionContext is an interface to support dynamic dispatch. +type IType_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Type_name() IType_nameContext + OID() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + FORCE() antlr.TerminalNode + Object_type_def() IObject_type_defContext + + // IsType_definitionContext differentiates from other interfaces. + IsType_definitionContext() +} + +type Type_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_definitionContext() *Type_definitionContext { + var p = new(Type_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_definition + return p +} + +func InitEmptyType_definitionContext(p *Type_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_definition +} + +func (*Type_definitionContext) IsType_definitionContext() {} + +func NewType_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_definitionContext { + var p = new(Type_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_definition + + return p +} + +func (s *Type_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_definitionContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_definitionContext) OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOID, 0) +} + +func (s *Type_definitionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Type_definitionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Type_definitionContext) Object_type_def() IObject_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_defContext) +} + +func (s *Type_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_definition(s) + } +} + +func (s *Type_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_definition(s) + } +} + +func (s *Type_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_definition() (localctx IType_definitionContext) { + localctx = NewType_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 258, PlSqlParserRULE_type_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4474) + p.Type_name() + } + p.SetState(4477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOID { + { + p.SetState(4475) + p.Match(PlSqlParserOID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4476) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(4479) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserAUTHID || _la == PlSqlParserIS || _la == PlSqlParserUNDER { + { + p.SetState(4482) + p.Object_type_def() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_defContext is an interface to support dynamic dispatch. +type IObject_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Object_as_part() IObject_as_partContext + Object_under_part() IObject_under_partContext + Invoker_rights_clause() IInvoker_rights_clauseContext + Sqlj_object_type() ISqlj_object_typeContext + LEFT_PAREN() antlr.TerminalNode + AllObject_member_spec() []IObject_member_specContext + Object_member_spec(i int) IObject_member_specContext + RIGHT_PAREN() antlr.TerminalNode + AllModifier_clause() []IModifier_clauseContext + Modifier_clause(i int) IModifier_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsObject_type_defContext differentiates from other interfaces. + IsObject_type_defContext() +} + +type Object_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_type_defContext() *Object_type_defContext { + var p = new(Object_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_def + return p +} + +func InitEmptyObject_type_defContext(p *Object_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_def +} + +func (*Object_type_defContext) IsObject_type_defContext() {} + +func NewObject_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_defContext { + var p = new(Object_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_type_def + + return p +} + +func (s *Object_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_defContext) Object_as_part() IObject_as_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_as_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_as_partContext) +} + +func (s *Object_type_defContext) Object_under_part() IObject_under_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_under_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_under_partContext) +} + +func (s *Object_type_defContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Object_type_defContext) Sqlj_object_type() ISqlj_object_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlj_object_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlj_object_typeContext) +} + +func (s *Object_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Object_type_defContext) AllObject_member_spec() []IObject_member_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_member_specContext); ok { + len++ + } + } + + tst := make([]IObject_member_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_member_specContext); ok { + tst[i] = t.(IObject_member_specContext) + i++ + } + } + + return tst +} + +func (s *Object_type_defContext) Object_member_spec(i int) IObject_member_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_member_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_member_specContext) +} + +func (s *Object_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Object_type_defContext) AllModifier_clause() []IModifier_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModifier_clauseContext); ok { + len++ + } + } + + tst := make([]IModifier_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModifier_clauseContext); ok { + tst[i] = t.(IModifier_clauseContext) + i++ + } + } + + return tst +} + +func (s *Object_type_defContext) Modifier_clause(i int) IModifier_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Object_type_defContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_type_defContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_type_def(s) + } +} + +func (s *Object_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type_def(s) + } +} + +func (s *Object_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_type_def() (localctx IObject_type_defContext) { + localctx = NewObject_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 260, PlSqlParserRULE_object_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(4485) + p.Invoker_rights_clause() + } + + } + p.SetState(4490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(4488) + p.Object_as_part() + } + + case PlSqlParserUNDER: + { + p.SetState(4489) + p.Object_under_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(4493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(4492) + p.Sqlj_object_type() + } + + } + p.SetState(4506) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4495) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4496) + p.Object_member_spec() + } + p.SetState(4501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4497) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4498) + p.Object_member_spec() + } + + p.SetState(4503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4504) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserNOT || _la == PlSqlParserOVERRIDING { + { + p.SetState(4508) + p.Modifier_clause() + } + + p.SetState(4513) + 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_as_partContext is an interface to support dynamic dispatch. +type IObject_as_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + Varray_type_def() IVarray_type_defContext + Nested_table_type_def() INested_table_type_defContext + + // IsObject_as_partContext differentiates from other interfaces. + IsObject_as_partContext() +} + +type Object_as_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_as_partContext() *Object_as_partContext { + var p = new(Object_as_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_as_part + return p +} + +func InitEmptyObject_as_partContext(p *Object_as_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_as_part +} + +func (*Object_as_partContext) IsObject_as_partContext() {} + +func NewObject_as_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_as_partContext { + var p = new(Object_as_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_as_part + + return p +} + +func (s *Object_as_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_as_partContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Object_as_partContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Object_as_partContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Object_as_partContext) Varray_type_def() IVarray_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_type_defContext) +} + +func (s *Object_as_partContext) Nested_table_type_def() INested_table_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INested_table_type_defContext) +} + +func (s *Object_as_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_as_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_as_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_as_part(s) + } +} + +func (s *Object_as_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_as_part(s) + } +} + +func (s *Object_as_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_as_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_as_part() (localctx IObject_as_partContext) { + localctx = NewObject_as_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 262, PlSqlParserRULE_object_as_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4514) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(4515) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARRAY, PlSqlParserVARYING: + { + p.SetState(4516) + p.Varray_type_def() + } + + case PlSqlParserTABLE: + { + p.SetState(4517) + p.Nested_table_type_def() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_under_partContext is an interface to support dynamic dispatch. +type IObject_under_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDER() antlr.TerminalNode + Type_spec() IType_specContext + + // IsObject_under_partContext differentiates from other interfaces. + IsObject_under_partContext() +} + +type Object_under_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_under_partContext() *Object_under_partContext { + var p = new(Object_under_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_under_part + return p +} + +func InitEmptyObject_under_partContext(p *Object_under_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_under_part +} + +func (*Object_under_partContext) IsObject_under_partContext() {} + +func NewObject_under_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_under_partContext { + var p = new(Object_under_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_under_part + + return p +} + +func (s *Object_under_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_under_partContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_under_partContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Object_under_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_under_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_under_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_under_part(s) + } +} + +func (s *Object_under_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_under_part(s) + } +} + +func (s *Object_under_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_under_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_under_part() (localctx IObject_under_partContext) { + localctx = NewObject_under_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 264, PlSqlParserRULE_object_under_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4520) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4521) + p.Type_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INested_table_type_defContext is an interface to support dynamic dispatch. +type INested_table_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsNested_table_type_defContext differentiates from other interfaces. + IsNested_table_type_defContext() +} + +type Nested_table_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_table_type_defContext() *Nested_table_type_defContext { + var p = new(Nested_table_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_type_def + return p +} + +func InitEmptyNested_table_type_defContext(p *Nested_table_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_type_def +} + +func (*Nested_table_type_defContext) IsNested_table_type_defContext() {} + +func NewNested_table_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_table_type_defContext { + var p = new(Nested_table_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_table_type_def + + return p +} + +func (s *Nested_table_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_table_type_defContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Nested_table_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Nested_table_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Nested_table_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Nested_table_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Nested_table_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_table_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_table_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_table_type_def(s) + } +} + +func (s *Nested_table_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_table_type_def(s) + } +} + +func (s *Nested_table_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNested_table_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Nested_table_type_def() (localctx INested_table_type_defContext) { + localctx = NewNested_table_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 266, PlSqlParserRULE_nested_table_type_def) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4523) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4524) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4525) + p.Type_spec() + } + p.SetState(4528) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 291, p.GetParserRuleContext()) == 1 { + { + p.SetState(4526) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4527) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlj_object_typeContext is an interface to support dynamic dispatch. +type ISqlj_object_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + LANGUAGE() antlr.TerminalNode + JAVA() antlr.TerminalNode + USING() antlr.TerminalNode + SQLDATA() antlr.TerminalNode + CUSTOMDATUM() antlr.TerminalNode + ORADATA() antlr.TerminalNode + + // IsSqlj_object_typeContext differentiates from other interfaces. + IsSqlj_object_typeContext() +} + +type Sqlj_object_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlj_object_typeContext() *Sqlj_object_typeContext { + var p = new(Sqlj_object_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type + return p +} + +func InitEmptySqlj_object_typeContext(p *Sqlj_object_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type +} + +func (*Sqlj_object_typeContext) IsSqlj_object_typeContext() {} + +func NewSqlj_object_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sqlj_object_typeContext { + var p = new(Sqlj_object_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sqlj_object_type + + return p +} + +func (s *Sqlj_object_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sqlj_object_typeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Sqlj_object_typeContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Sqlj_object_typeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sqlj_object_typeContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Sqlj_object_typeContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Sqlj_object_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Sqlj_object_typeContext) SQLDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLDATA, 0) +} + +func (s *Sqlj_object_typeContext) CUSTOMDATUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUSTOMDATUM, 0) +} + +func (s *Sqlj_object_typeContext) ORADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADATA, 0) +} + +func (s *Sqlj_object_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sqlj_object_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sqlj_object_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSqlj_object_type(s) + } +} + +func (s *Sqlj_object_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSqlj_object_type(s) + } +} + +func (s *Sqlj_object_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSqlj_object_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sqlj_object_type() (localctx ISqlj_object_typeContext) { + localctx = NewSqlj_object_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 268, PlSqlParserRULE_sqlj_object_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4530) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4531) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4532) + p.Expression() + } + { + p.SetState(4533) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4534) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4535) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4536) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCUSTOMDATUM || _la == PlSqlParserORADATA || _la == PlSqlParserSQLDATA) { + 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 +} + +// IType_bodyContext is an interface to support dynamic dispatch. +type IType_bodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BODY() antlr.TerminalNode + Type_name() IType_nameContext + END() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + AllType_body_elements() []IType_body_elementsContext + Type_body_elements(i int) IType_body_elementsContext + + // IsType_bodyContext differentiates from other interfaces. + IsType_bodyContext() +} + +type Type_bodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_bodyContext() *Type_bodyContext { + var p = new(Type_bodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body + return p +} + +func InitEmptyType_bodyContext(p *Type_bodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body +} + +func (*Type_bodyContext) IsType_bodyContext() {} + +func NewType_bodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_bodyContext { + var p = new(Type_bodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_body + + return p +} + +func (s *Type_bodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_bodyContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Type_bodyContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_bodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Type_bodyContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_bodyContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Type_bodyContext) AllType_body_elements() []IType_body_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_body_elementsContext); ok { + len++ + } + } + + tst := make([]IType_body_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_body_elementsContext); ok { + tst[i] = t.(IType_body_elementsContext) + i++ + } + } + + return tst +} + +func (s *Type_bodyContext) Type_body_elements(i int) IType_body_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_body_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_body_elementsContext) +} + +func (s *Type_bodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_bodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_bodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_body(s) + } +} + +func (s *Type_bodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_body(s) + } +} + +func (s *Type_bodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_body(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_body() (localctx IType_bodyContext) { + localctx = NewType_bodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 270, PlSqlParserRULE_type_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4538) + p.Match(PlSqlParserBODY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4539) + p.Type_name() + } + { + p.SetState(4540) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserMAP || _la == PlSqlParserMEMBER || _la == PlSqlParserORDER || _la == PlSqlParserOVERRIDING || _la == PlSqlParserSTATIC { + { + p.SetState(4541) + p.Type_body_elements() + } + + p.SetState(4544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4546) + p.Match(PlSqlParserEND) + 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 +} + +// IType_body_elementsContext is an interface to support dynamic dispatch. +type IType_body_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Map_order_func_declaration() IMap_order_func_declarationContext + Subprog_decl_in_type() ISubprog_decl_in_typeContext + Overriding_subprogram_spec() IOverriding_subprogram_specContext + + // IsType_body_elementsContext differentiates from other interfaces. + IsType_body_elementsContext() +} + +type Type_body_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_body_elementsContext() *Type_body_elementsContext { + var p = new(Type_body_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body_elements + return p +} + +func InitEmptyType_body_elementsContext(p *Type_body_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_body_elements +} + +func (*Type_body_elementsContext) IsType_body_elementsContext() {} + +func NewType_body_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_body_elementsContext { + var p = new(Type_body_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_body_elements + + return p +} + +func (s *Type_body_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_body_elementsContext) Map_order_func_declaration() IMap_order_func_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_func_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_func_declarationContext) +} + +func (s *Type_body_elementsContext) Subprog_decl_in_type() ISubprog_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprog_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprog_decl_in_typeContext) +} + +func (s *Type_body_elementsContext) Overriding_subprogram_spec() IOverriding_subprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_subprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_subprogram_specContext) +} + +func (s *Type_body_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_body_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_body_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_body_elements(s) + } +} + +func (s *Type_body_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_body_elements(s) + } +} + +func (s *Type_body_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_body_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_body_elements() (localctx IType_body_elementsContext) { + localctx = NewType_body_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 272, PlSqlParserRULE_type_body_elements) + p.SetState(4551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAP, PlSqlParserORDER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4548) + p.Map_order_func_declaration() + } + + case PlSqlParserMEMBER, PlSqlParserSTATIC: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4549) + p.Subprog_decl_in_type() + } + + case PlSqlParserOVERRIDING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4550) + p.Overriding_subprogram_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMap_order_func_declarationContext is an interface to support dynamic dispatch. +type IMap_order_func_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + Func_decl_in_type() IFunc_decl_in_typeContext + MAP() antlr.TerminalNode + ORDER() antlr.TerminalNode + + // IsMap_order_func_declarationContext differentiates from other interfaces. + IsMap_order_func_declarationContext() +} + +type Map_order_func_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMap_order_func_declarationContext() *Map_order_func_declarationContext { + var p = new(Map_order_func_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration + return p +} + +func InitEmptyMap_order_func_declarationContext(p *Map_order_func_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration +} + +func (*Map_order_func_declarationContext) IsMap_order_func_declarationContext() {} + +func NewMap_order_func_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_order_func_declarationContext { + var p = new(Map_order_func_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_map_order_func_declaration + + return p +} + +func (s *Map_order_func_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Map_order_func_declarationContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Map_order_func_declarationContext) Func_decl_in_type() IFunc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_decl_in_typeContext) +} + +func (s *Map_order_func_declarationContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Map_order_func_declarationContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Map_order_func_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Map_order_func_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Map_order_func_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMap_order_func_declaration(s) + } +} + +func (s *Map_order_func_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMap_order_func_declaration(s) + } +} + +func (s *Map_order_func_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMap_order_func_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Map_order_func_declaration() (localctx IMap_order_func_declarationContext) { + localctx = NewMap_order_func_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 274, PlSqlParserRULE_map_order_func_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4553) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAP || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4554) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4555) + p.Func_decl_in_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 +} + +// ISubprog_decl_in_typeContext is an interface to support dynamic dispatch. +type ISubprog_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + STATIC() antlr.TerminalNode + Proc_decl_in_type() IProc_decl_in_typeContext + Func_decl_in_type() IFunc_decl_in_typeContext + Constructor_declaration() IConstructor_declarationContext + + // IsSubprog_decl_in_typeContext differentiates from other interfaces. + IsSubprog_decl_in_typeContext() +} + +type Subprog_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubprog_decl_in_typeContext() *Subprog_decl_in_typeContext { + var p = new(Subprog_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type + return p +} + +func InitEmptySubprog_decl_in_typeContext(p *Subprog_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type +} + +func (*Subprog_decl_in_typeContext) IsSubprog_decl_in_typeContext() {} + +func NewSubprog_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subprog_decl_in_typeContext { + var p = new(Subprog_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subprog_decl_in_type + + return p +} + +func (s *Subprog_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subprog_decl_in_typeContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Subprog_decl_in_typeContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Subprog_decl_in_typeContext) Proc_decl_in_type() IProc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProc_decl_in_typeContext) +} + +func (s *Subprog_decl_in_typeContext) Func_decl_in_type() IFunc_decl_in_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunc_decl_in_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunc_decl_in_typeContext) +} + +func (s *Subprog_decl_in_typeContext) Constructor_declaration() IConstructor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructor_declarationContext) +} + +func (s *Subprog_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subprog_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subprog_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubprog_decl_in_type(s) + } +} + +func (s *Subprog_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubprog_decl_in_type(s) + } +} + +func (s *Subprog_decl_in_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubprog_decl_in_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subprog_decl_in_type() (localctx ISubprog_decl_in_typeContext) { + localctx = NewSubprog_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 276, PlSqlParserRULE_subprog_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4557) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSTATIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4561) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPROCEDURE: + { + p.SetState(4558) + p.Proc_decl_in_type() + } + + case PlSqlParserFUNCTION: + { + p.SetState(4559) + p.Func_decl_in_type() + } + + case PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE: + { + p.SetState(4560) + p.Constructor_declaration() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProc_decl_in_typeContext is an interface to support dynamic dispatch. +type IProc_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsProc_decl_in_typeContext differentiates from other interfaces. + IsProc_decl_in_typeContext() +} + +type Proc_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProc_decl_in_typeContext() *Proc_decl_in_typeContext { + var p = new(Proc_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type + return p +} + +func InitEmptyProc_decl_in_typeContext(p *Proc_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type +} + +func (*Proc_decl_in_typeContext) IsProc_decl_in_typeContext() {} + +func NewProc_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proc_decl_in_typeContext { + var p = new(Proc_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_proc_decl_in_type + + return p +} + +func (s *Proc_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proc_decl_in_typeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Proc_decl_in_typeContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Proc_decl_in_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Proc_decl_in_typeContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Proc_decl_in_typeContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Proc_decl_in_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Proc_decl_in_typeContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Proc_decl_in_typeContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Proc_decl_in_typeContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Proc_decl_in_typeContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Proc_decl_in_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Proc_decl_in_typeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Proc_decl_in_typeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Proc_decl_in_typeContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Proc_decl_in_typeContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Proc_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proc_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proc_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProc_decl_in_type(s) + } +} + +func (s *Proc_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProc_decl_in_type(s) + } +} + +func (s *Proc_decl_in_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProc_decl_in_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Proc_decl_in_type() (localctx IProc_decl_in_typeContext) { + localctx = NewProc_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 278, PlSqlParserRULE_proc_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4563) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4564) + p.Procedure_name() + } + { + p.SetState(4565) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4566) + p.Type_elements_parameter() + } + p.SetState(4571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4567) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4568) + p.Type_elements_parameter() + } + + p.SetState(4573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4574) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4575) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 298, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4576) + p.Call_spec() + } + + case 2: + p.SetState(4578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(4577) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4581) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 297, p.GetParserRuleContext()) == 1 { + { + p.SetState(4580) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4583) + p.Body() + } + { + p.SetState(4584) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFunc_decl_in_typeContext is an interface to support dynamic dispatch. +type IFunc_decl_in_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunc_decl_in_typeContext differentiates from other interfaces. + IsFunc_decl_in_typeContext() +} + +type Func_decl_in_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunc_decl_in_typeContext() *Func_decl_in_typeContext { + var p = new(Func_decl_in_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_func_decl_in_type + return p +} + +func InitEmptyFunc_decl_in_typeContext(p *Func_decl_in_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_func_decl_in_type +} + +func (*Func_decl_in_typeContext) IsFunc_decl_in_typeContext() {} + +func NewFunc_decl_in_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Func_decl_in_typeContext { + var p = new(Func_decl_in_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_func_decl_in_type + + return p +} + +func (s *Func_decl_in_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Func_decl_in_typeContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Func_decl_in_typeContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Func_decl_in_typeContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Func_decl_in_typeContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Func_decl_in_typeContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Func_decl_in_typeContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Func_decl_in_typeContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Func_decl_in_typeContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Func_decl_in_typeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Func_decl_in_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Func_decl_in_typeContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Func_decl_in_typeContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Func_decl_in_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Func_decl_in_typeContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Func_decl_in_typeContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Func_decl_in_typeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Func_decl_in_typeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Func_decl_in_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Func_decl_in_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Func_decl_in_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunc_decl_in_type(s) + } +} + +func (s *Func_decl_in_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunc_decl_in_type(s) + } +} + +func (s *Func_decl_in_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunc_decl_in_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Func_decl_in_type() (localctx IFunc_decl_in_typeContext) { + localctx = NewFunc_decl_in_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 280, PlSqlParserRULE_func_decl_in_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4588) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4589) + p.Function_name() + } + p.SetState(4601) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4590) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4591) + p.Type_elements_parameter() + } + p.SetState(4596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4592) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4593) + p.Type_elements_parameter() + } + + p.SetState(4598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4599) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4603) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4604) + p.Type_spec() + } + { + p.SetState(4605) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4616) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 303, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4606) + p.Call_spec() + } + + case 2: + p.SetState(4608) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(4607) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4611) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 302, p.GetParserRuleContext()) == 1 { + { + p.SetState(4610) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4613) + p.Body() + } + { + p.SetState(4614) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IConstructor_declarationContext is an interface to support dynamic dispatch. +type IConstructor_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRUCTOR() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllType_spec() []IType_specContext + Type_spec(i int) IType_specContext + RETURN() antlr.TerminalNode + AllSELF() []antlr.TerminalNode + SELF(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + IS() antlr.TerminalNode + Call_spec() ICall_specContext + Body() IBodyContext + SEMICOLON() antlr.TerminalNode + FINAL() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsConstructor_declarationContext differentiates from other interfaces. + IsConstructor_declarationContext() +} + +type Constructor_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructor_declarationContext() *Constructor_declarationContext { + var p = new(Constructor_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_declaration + return p +} + +func InitEmptyConstructor_declarationContext(p *Constructor_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_declaration +} + +func (*Constructor_declarationContext) IsConstructor_declarationContext() {} + +func NewConstructor_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constructor_declarationContext { + var p = new(Constructor_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constructor_declaration + + return p +} + +func (s *Constructor_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constructor_declarationContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Constructor_declarationContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Constructor_declarationContext) AllType_spec() []IType_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_specContext); ok { + len++ + } + } + + tst := make([]IType_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_specContext); ok { + tst[i] = t.(IType_specContext) + i++ + } + } + + return tst +} + +func (s *Constructor_declarationContext) Type_spec(i int) IType_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Constructor_declarationContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Constructor_declarationContext) AllSELF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSELF) +} + +func (s *Constructor_declarationContext) SELF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, i) +} + +func (s *Constructor_declarationContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Constructor_declarationContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Constructor_declarationContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Constructor_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Constructor_declarationContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Constructor_declarationContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Constructor_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Constructor_declarationContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Constructor_declarationContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Constructor_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constructor_declarationContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Constructor_declarationContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Constructor_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constructor_declarationContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Constructor_declarationContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Constructor_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constructor_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constructor_declarationContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Constructor_declarationContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Constructor_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constructor_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constructor_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstructor_declaration(s) + } +} + +func (s *Constructor_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstructor_declaration(s) + } +} + +func (s *Constructor_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstructor_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constructor_declaration() (localctx IConstructor_declarationContext) { + localctx = NewConstructor_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 282, PlSqlParserRULE_constructor_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINAL { + { + p.SetState(4618) + p.Match(PlSqlParserFINAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINSTANTIABLE { + { + p.SetState(4621) + p.Match(PlSqlParserINSTANTIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4624) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4625) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4626) + p.Type_spec() + } + p.SetState(4644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4627) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4628) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4629) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4630) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4631) + p.Type_spec() + } + { + p.SetState(4632) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4634) + p.Type_elements_parameter() + } + p.SetState(4639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4635) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4636) + p.Type_elements_parameter() + } + + p.SetState(4641) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4642) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4646) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4647) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4648) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4649) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4650) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 310, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4651) + p.Call_spec() + } + + case 2: + p.SetState(4653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(4652) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4656) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 309, p.GetParserRuleContext()) == 1 { + { + p.SetState(4655) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4658) + p.Body() + } + { + p.SetState(4659) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IModifier_clauseContext is an interface to support dynamic dispatch. +type IModifier_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INSTANTIABLE() antlr.TerminalNode + FINAL() antlr.TerminalNode + OVERRIDING() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsModifier_clauseContext differentiates from other interfaces. + IsModifier_clauseContext() +} + +type Modifier_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModifier_clauseContext() *Modifier_clauseContext { + var p = new(Modifier_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modifier_clause + return p +} + +func InitEmptyModifier_clauseContext(p *Modifier_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modifier_clause +} + +func (*Modifier_clauseContext) IsModifier_clauseContext() {} + +func NewModifier_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modifier_clauseContext { + var p = new(Modifier_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modifier_clause + + return p +} + +func (s *Modifier_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modifier_clauseContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Modifier_clauseContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Modifier_clauseContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Modifier_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Modifier_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modifier_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modifier_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModifier_clause(s) + } +} + +func (s *Modifier_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModifier_clause(s) + } +} + +func (s *Modifier_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModifier_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modifier_clause() (localctx IModifier_clauseContext) { + localctx = NewModifier_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 284, PlSqlParserRULE_modifier_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(4663) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4666) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserOVERRIDING) { + 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_member_specContext is an interface to support dynamic dispatch. +type IObject_member_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_spec() IType_specContext + Sqlj_object_type_attr() ISqlj_object_type_attrContext + Element_spec() IElement_specContext + + // IsObject_member_specContext differentiates from other interfaces. + IsObject_member_specContext() +} + +type Object_member_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_member_specContext() *Object_member_specContext { + var p = new(Object_member_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_member_spec + return p +} + +func InitEmptyObject_member_specContext(p *Object_member_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_member_spec +} + +func (*Object_member_specContext) IsObject_member_specContext() {} + +func NewObject_member_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_member_specContext { + var p = new(Object_member_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_member_spec + + return p +} + +func (s *Object_member_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_member_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Object_member_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Object_member_specContext) Sqlj_object_type_attr() ISqlj_object_type_attrContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISqlj_object_type_attrContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISqlj_object_type_attrContext) +} + +func (s *Object_member_specContext) Element_spec() IElement_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElement_specContext) +} + +func (s *Object_member_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_member_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_member_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_member_spec(s) + } +} + +func (s *Object_member_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_member_spec(s) + } +} + +func (s *Object_member_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_member_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_member_spec() (localctx IObject_member_specContext) { + localctx = NewObject_member_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 286, PlSqlParserRULE_object_member_spec) + var _la int + + p.SetState(4674) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 313, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4668) + p.Identifier() + } + { + p.SetState(4669) + p.Type_spec() + } + p.SetState(4671) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(4670) + p.Sqlj_object_type_attr() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4673) + p.Element_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISqlj_object_type_attrContext is an interface to support dynamic dispatch. +type ISqlj_object_type_attrContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + + // IsSqlj_object_type_attrContext differentiates from other interfaces. + IsSqlj_object_type_attrContext() +} + +type Sqlj_object_type_attrContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySqlj_object_type_attrContext() *Sqlj_object_type_attrContext { + var p = new(Sqlj_object_type_attrContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr + return p +} + +func InitEmptySqlj_object_type_attrContext(p *Sqlj_object_type_attrContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr +} + +func (*Sqlj_object_type_attrContext) IsSqlj_object_type_attrContext() {} + +func NewSqlj_object_type_attrContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sqlj_object_type_attrContext { + var p = new(Sqlj_object_type_attrContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sqlj_object_type_attr + + return p +} + +func (s *Sqlj_object_type_attrContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sqlj_object_type_attrContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Sqlj_object_type_attrContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Sqlj_object_type_attrContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sqlj_object_type_attrContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sqlj_object_type_attrContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sqlj_object_type_attrContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSqlj_object_type_attr(s) + } +} + +func (s *Sqlj_object_type_attrContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSqlj_object_type_attr(s) + } +} + +func (s *Sqlj_object_type_attrContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSqlj_object_type_attr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sqlj_object_type_attr() (localctx ISqlj_object_type_attrContext) { + localctx = NewSqlj_object_type_attrContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 288, PlSqlParserRULE_sqlj_object_type_attr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4676) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4677) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4678) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElement_specContext is an interface to support dynamic dispatch. +type IElement_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Modifier_clause() IModifier_clauseContext + AllElement_spec_options() []IElement_spec_optionsContext + Element_spec_options(i int) IElement_spec_optionsContext + COMMA() antlr.TerminalNode + Pragma_clause() IPragma_clauseContext + + // IsElement_specContext differentiates from other interfaces. + IsElement_specContext() +} + +type Element_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_specContext() *Element_specContext { + var p = new(Element_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec + return p +} + +func InitEmptyElement_specContext(p *Element_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec +} + +func (*Element_specContext) IsElement_specContext() {} + +func NewElement_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_specContext { + var p = new(Element_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element_spec + + return p +} + +func (s *Element_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_specContext) Modifier_clause() IModifier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModifier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModifier_clauseContext) +} + +func (s *Element_specContext) AllElement_spec_options() []IElement_spec_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElement_spec_optionsContext); ok { + len++ + } + } + + tst := make([]IElement_spec_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElement_spec_optionsContext); ok { + tst[i] = t.(IElement_spec_optionsContext) + i++ + } + } + + return tst +} + +func (s *Element_specContext) Element_spec_options(i int) IElement_spec_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElement_spec_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElement_spec_optionsContext) +} + +func (s *Element_specContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Element_specContext) Pragma_clause() IPragma_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_clauseContext) +} + +func (s *Element_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement_spec(s) + } +} + +func (s *Element_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement_spec(s) + } +} + +func (s *Element_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitElement_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Element_spec() (localctx IElement_specContext) { + localctx = NewElement_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 290, PlSqlParserRULE_element_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4681) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 314, p.GetParserRuleContext()) == 1 { + { + p.SetState(4680) + p.Modifier_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4684) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCONSTRUCTOR || _la == PlSqlParserFINAL || _la == PlSqlParserINSTANTIABLE || _la == PlSqlParserMAP || _la == PlSqlParserMEMBER || _la == PlSqlParserORDER || _la == PlSqlParserSTATIC { + { + p.SetState(4683) + p.Element_spec_options() + } + + p.SetState(4686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(4690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 316, p.GetParserRuleContext()) == 1 { + { + p.SetState(4688) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4689) + p.Pragma_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 +} + +// IElement_spec_optionsContext is an interface to support dynamic dispatch. +type IElement_spec_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subprogram_spec() ISubprogram_specContext + Constructor_spec() IConstructor_specContext + Map_order_function_spec() IMap_order_function_specContext + + // IsElement_spec_optionsContext differentiates from other interfaces. + IsElement_spec_optionsContext() +} + +type Element_spec_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElement_spec_optionsContext() *Element_spec_optionsContext { + var p = new(Element_spec_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec_options + return p +} + +func InitEmptyElement_spec_optionsContext(p *Element_spec_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element_spec_options +} + +func (*Element_spec_optionsContext) IsElement_spec_optionsContext() {} + +func NewElement_spec_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Element_spec_optionsContext { + var p = new(Element_spec_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element_spec_options + + return p +} + +func (s *Element_spec_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Element_spec_optionsContext) Subprogram_spec() ISubprogram_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubprogram_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubprogram_specContext) +} + +func (s *Element_spec_optionsContext) Constructor_spec() IConstructor_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstructor_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstructor_specContext) +} + +func (s *Element_spec_optionsContext) Map_order_function_spec() IMap_order_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMap_order_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMap_order_function_specContext) +} + +func (s *Element_spec_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Element_spec_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Element_spec_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement_spec_options(s) + } +} + +func (s *Element_spec_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement_spec_options(s) + } +} + +func (s *Element_spec_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitElement_spec_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Element_spec_options() (localctx IElement_spec_optionsContext) { + localctx = NewElement_spec_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 292, PlSqlParserRULE_element_spec_options) + p.SetState(4695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMEMBER, PlSqlParserSTATIC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4692) + p.Subprogram_spec() + } + + case PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4693) + p.Constructor_spec() + } + + case PlSqlParserMAP, PlSqlParserORDER: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4694) + p.Map_order_function_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubprogram_specContext is an interface to support dynamic dispatch. +type ISubprogram_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + STATIC() antlr.TerminalNode + Type_procedure_spec() IType_procedure_specContext + Type_function_spec() IType_function_specContext + + // IsSubprogram_specContext differentiates from other interfaces. + IsSubprogram_specContext() +} + +type Subprogram_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubprogram_specContext() *Subprogram_specContext { + var p = new(Subprogram_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprogram_spec + return p +} + +func InitEmptySubprogram_specContext(p *Subprogram_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subprogram_spec +} + +func (*Subprogram_specContext) IsSubprogram_specContext() {} + +func NewSubprogram_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subprogram_specContext { + var p = new(Subprogram_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subprogram_spec + + return p +} + +func (s *Subprogram_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subprogram_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Subprogram_specContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Subprogram_specContext) Type_procedure_spec() IType_procedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_procedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_procedure_specContext) +} + +func (s *Subprogram_specContext) Type_function_spec() IType_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_specContext) +} + +func (s *Subprogram_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subprogram_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subprogram_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubprogram_spec(s) + } +} + +func (s *Subprogram_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubprogram_spec(s) + } +} + +func (s *Subprogram_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubprogram_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subprogram_spec() (localctx ISubprogram_specContext) { + localctx = NewSubprogram_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 294, PlSqlParserRULE_subprogram_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4697) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSTATIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPROCEDURE: + { + p.SetState(4698) + p.Type_procedure_spec() + } + + case PlSqlParserFUNCTION: + { + p.SetState(4699) + p.Type_function_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverriding_subprogram_specContext is an interface to support dynamic dispatch. +type IOverriding_subprogram_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVERRIDING() antlr.TerminalNode + MEMBER() antlr.TerminalNode + Overriding_function_spec() IOverriding_function_specContext + + // IsOverriding_subprogram_specContext differentiates from other interfaces. + IsOverriding_subprogram_specContext() +} + +type Overriding_subprogram_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverriding_subprogram_specContext() *Overriding_subprogram_specContext { + var p = new(Overriding_subprogram_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec + return p +} + +func InitEmptyOverriding_subprogram_specContext(p *Overriding_subprogram_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec +} + +func (*Overriding_subprogram_specContext) IsOverriding_subprogram_specContext() {} + +func NewOverriding_subprogram_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overriding_subprogram_specContext { + var p = new(Overriding_subprogram_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_overriding_subprogram_spec + + return p +} + +func (s *Overriding_subprogram_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overriding_subprogram_specContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Overriding_subprogram_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Overriding_subprogram_specContext) Overriding_function_spec() IOverriding_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOverriding_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOverriding_function_specContext) +} + +func (s *Overriding_subprogram_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overriding_subprogram_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overriding_subprogram_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOverriding_subprogram_spec(s) + } +} + +func (s *Overriding_subprogram_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOverriding_subprogram_spec(s) + } +} + +func (s *Overriding_subprogram_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOverriding_subprogram_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Overriding_subprogram_spec() (localctx IOverriding_subprogram_specContext) { + localctx = NewOverriding_subprogram_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 296, PlSqlParserRULE_overriding_subprogram_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4702) + p.Match(PlSqlParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4703) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4704) + p.Overriding_function_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOverriding_function_specContext is an interface to support dynamic dispatch. +type IOverriding_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SELF() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + IS() antlr.TerminalNode + Body() IBodyContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + PIPELINED() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + + // IsOverriding_function_specContext differentiates from other interfaces. + IsOverriding_function_specContext() +} + +type Overriding_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOverriding_function_specContext() *Overriding_function_specContext { + var p = new(Overriding_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_function_spec + return p +} + +func InitEmptyOverriding_function_specContext(p *Overriding_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_overriding_function_spec +} + +func (*Overriding_function_specContext) IsOverriding_function_specContext() {} + +func NewOverriding_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Overriding_function_specContext { + var p = new(Overriding_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_overriding_function_spec + + return p +} + +func (s *Overriding_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Overriding_function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Overriding_function_specContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Overriding_function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Overriding_function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Overriding_function_specContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Overriding_function_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Overriding_function_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Overriding_function_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Overriding_function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Overriding_function_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Overriding_function_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Overriding_function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Overriding_function_specContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Overriding_function_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Overriding_function_specContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Overriding_function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Overriding_function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Overriding_function_specContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Overriding_function_specContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Overriding_function_specContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Overriding_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Overriding_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Overriding_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOverriding_function_spec(s) + } +} + +func (s *Overriding_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOverriding_function_spec(s) + } +} + +func (s *Overriding_function_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOverriding_function_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Overriding_function_spec() (localctx IOverriding_function_specContext) { + localctx = NewOverriding_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 298, PlSqlParserRULE_overriding_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4706) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4707) + p.Function_name() + } + p.SetState(4719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4708) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4709) + p.Type_elements_parameter() + } + p.SetState(4714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4710) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4711) + p.Type_elements_parameter() + } + + p.SetState(4716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4717) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4721) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 321, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4722) + p.Type_spec() + } + + case 2: + { + p.SetState(4723) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4724) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4725) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4739) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS || _la == PlSqlParserPIPELINED { + p.SetState(4729) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPIPELINED { + { + p.SetState(4728) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4731) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(4733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(4732) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4736) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 324, p.GetParserRuleContext()) == 1 { + { + p.SetState(4735) + p.Seq_of_declare_specs() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(4738) + p.Body() + } + + } + p.SetState(4742) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 326, p.GetParserRuleContext()) == 1 { + { + p.SetState(4741) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_procedure_specContext is an interface to support dynamic dispatch. +type IType_procedure_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROCEDURE() antlr.TerminalNode + Procedure_name() IProcedure_nameContext + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Call_spec() ICall_specContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsType_procedure_specContext differentiates from other interfaces. + IsType_procedure_specContext() +} + +type Type_procedure_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_procedure_specContext() *Type_procedure_specContext { + var p = new(Type_procedure_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_procedure_spec + return p +} + +func InitEmptyType_procedure_specContext(p *Type_procedure_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_procedure_spec +} + +func (*Type_procedure_specContext) IsType_procedure_specContext() {} + +func NewType_procedure_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_procedure_specContext { + var p = new(Type_procedure_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_procedure_spec + + return p +} + +func (s *Type_procedure_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_procedure_specContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Type_procedure_specContext) Procedure_name() IProcedure_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_nameContext) +} + +func (s *Type_procedure_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Type_procedure_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Type_procedure_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Type_procedure_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Type_procedure_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Type_procedure_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Type_procedure_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Type_procedure_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_procedure_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Type_procedure_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_procedure_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_procedure_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_procedure_spec(s) + } +} + +func (s *Type_procedure_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_procedure_spec(s) + } +} + +func (s *Type_procedure_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_procedure_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_procedure_spec() (localctx IType_procedure_specContext) { + localctx = NewType_procedure_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 300, PlSqlParserRULE_type_procedure_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4744) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4745) + p.Procedure_name() + } + { + p.SetState(4746) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4747) + p.Type_elements_parameter() + } + p.SetState(4752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4748) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4749) + p.Type_elements_parameter() + } + + p.SetState(4754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4755) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4758) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS { + { + p.SetState(4756) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4757) + p.Call_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_function_specContext is an interface to support dynamic dispatch. +type IType_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + SELF() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + Call_spec() ICall_specContext + EXTERNAL() antlr.TerminalNode + NAME() antlr.TerminalNode + Expression() IExpressionContext + IS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + VARIABLE() antlr.TerminalNode + + // IsType_function_specContext differentiates from other interfaces. + IsType_function_specContext() +} + +type Type_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_function_specContext() *Type_function_specContext { + var p = new(Type_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_function_spec + return p +} + +func InitEmptyType_function_specContext(p *Type_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_function_spec +} + +func (*Type_function_specContext) IsType_function_specContext() {} + +func NewType_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_function_specContext { + var p = new(Type_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_function_spec + + return p +} + +func (s *Type_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_function_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Type_function_specContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Type_function_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Type_function_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Type_function_specContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Type_function_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Type_function_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Type_function_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Type_function_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Type_function_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Type_function_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Type_function_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Type_function_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Type_function_specContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Type_function_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Type_function_specContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Type_function_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_function_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Type_function_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Type_function_specContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *Type_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_function_spec(s) + } +} + +func (s *Type_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_function_spec(s) + } +} + +func (s *Type_function_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_function_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_function_spec() (localctx IType_function_specContext) { + localctx = NewType_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 302, PlSqlParserRULE_type_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4760) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4761) + p.Function_name() + } + p.SetState(4773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4762) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4763) + p.Type_elements_parameter() + } + p.SetState(4768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4764) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4765) + p.Type_elements_parameter() + } + + p.SetState(4770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4771) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4775) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 331, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4776) + p.Type_spec() + } + + case 2: + { + p.SetState(4777) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4778) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4779) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(4790) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserIS: + { + p.SetState(4782) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4783) + p.Call_spec() + } + + case PlSqlParserEXTERNAL: + { + p.SetState(4784) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVARIABLE { + { + p.SetState(4785) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4788) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4789) + p.Expression() + } + + case PlSqlParserCASCADE, PlSqlParserCONSTRUCTOR, PlSqlParserFINAL, PlSqlParserINSTANTIABLE, PlSqlParserINVALIDATE, PlSqlParserMAP, PlSqlParserMEMBER, PlSqlParserORDER, PlSqlParserSTATIC, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConstructor_specContext is an interface to support dynamic dispatch. +type IConstructor_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONSTRUCTOR() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + AllType_spec() []IType_specContext + Type_spec(i int) IType_specContext + RETURN() antlr.TerminalNode + AllSELF() []antlr.TerminalNode + SELF(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + RESULT() antlr.TerminalNode + FINAL() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_elements_parameter() []IType_elements_parameterContext + Type_elements_parameter(i int) IType_elements_parameterContext + RIGHT_PAREN() antlr.TerminalNode + Call_spec() ICall_specContext + IS() antlr.TerminalNode + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsConstructor_specContext differentiates from other interfaces. + IsConstructor_specContext() +} + +type Constructor_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstructor_specContext() *Constructor_specContext { + var p = new(Constructor_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_spec + return p +} + +func InitEmptyConstructor_specContext(p *Constructor_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constructor_spec +} + +func (*Constructor_specContext) IsConstructor_specContext() {} + +func NewConstructor_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constructor_specContext { + var p = new(Constructor_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constructor_spec + + return p +} + +func (s *Constructor_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constructor_specContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Constructor_specContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Constructor_specContext) AllType_spec() []IType_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_specContext); ok { + len++ + } + } + + tst := make([]IType_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_specContext); ok { + tst[i] = t.(IType_specContext) + i++ + } + } + + return tst +} + +func (s *Constructor_specContext) Type_spec(i int) IType_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Constructor_specContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Constructor_specContext) AllSELF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSELF) +} + +func (s *Constructor_specContext) SELF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, i) +} + +func (s *Constructor_specContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Constructor_specContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Constructor_specContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Constructor_specContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Constructor_specContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Constructor_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constructor_specContext) AllType_elements_parameter() []IType_elements_parameterContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_elements_parameterContext); ok { + len++ + } + } + + tst := make([]IType_elements_parameterContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_elements_parameterContext); ok { + tst[i] = t.(IType_elements_parameterContext) + i++ + } + } + + return tst +} + +func (s *Constructor_specContext) Type_elements_parameter(i int) IType_elements_parameterContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_elements_parameterContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_elements_parameterContext) +} + +func (s *Constructor_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constructor_specContext) Call_spec() ICall_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_specContext) +} + +func (s *Constructor_specContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Constructor_specContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Constructor_specContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Constructor_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constructor_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constructor_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constructor_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constructor_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstructor_spec(s) + } +} + +func (s *Constructor_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstructor_spec(s) + } +} + +func (s *Constructor_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstructor_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constructor_spec() (localctx IConstructor_specContext) { + localctx = NewConstructor_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 304, PlSqlParserRULE_constructor_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(4793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINAL { + { + p.SetState(4792) + p.Match(PlSqlParserFINAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(4796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINSTANTIABLE { + { + p.SetState(4795) + p.Match(PlSqlParserINSTANTIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4798) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4799) + p.Match(PlSqlParserFUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4800) + p.Type_spec() + } + p.SetState(4818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(4801) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4802) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4803) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4804) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4805) + p.Type_spec() + } + { + p.SetState(4806) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(4808) + p.Type_elements_parameter() + } + p.SetState(4813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4809) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4810) + p.Type_elements_parameter() + } + + p.SetState(4815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4816) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(4820) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4821) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4822) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4823) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS || _la == PlSqlParserIS { + { + p.SetState(4824) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4825) + p.Call_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMap_order_function_specContext is an interface to support dynamic dispatch. +type IMap_order_function_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER() antlr.TerminalNode + Type_function_spec() IType_function_specContext + MAP() antlr.TerminalNode + ORDER() antlr.TerminalNode + + // IsMap_order_function_specContext differentiates from other interfaces. + IsMap_order_function_specContext() +} + +type Map_order_function_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMap_order_function_specContext() *Map_order_function_specContext { + var p = new(Map_order_function_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_function_spec + return p +} + +func InitEmptyMap_order_function_specContext(p *Map_order_function_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_map_order_function_spec +} + +func (*Map_order_function_specContext) IsMap_order_function_specContext() {} + +func NewMap_order_function_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Map_order_function_specContext { + var p = new(Map_order_function_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_map_order_function_spec + + return p +} + +func (s *Map_order_function_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Map_order_function_specContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Map_order_function_specContext) Type_function_spec() IType_function_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_function_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_function_specContext) +} + +func (s *Map_order_function_specContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Map_order_function_specContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Map_order_function_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Map_order_function_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Map_order_function_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMap_order_function_spec(s) + } +} + +func (s *Map_order_function_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMap_order_function_spec(s) + } +} + +func (s *Map_order_function_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMap_order_function_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Map_order_function_spec() (localctx IMap_order_function_specContext) { + localctx = NewMap_order_function_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 306, PlSqlParserRULE_map_order_function_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4828) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAP || _la == PlSqlParserORDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(4829) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4830) + p.Type_function_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPragma_clauseContext is an interface to support dynamic dispatch. +type IPragma_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRAGMA() antlr.TerminalNode + RESTRICT_REFERENCES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPragma_elements() []IPragma_elementsContext + Pragma_elements(i int) IPragma_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPragma_clauseContext differentiates from other interfaces. + IsPragma_clauseContext() +} + +type Pragma_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPragma_clauseContext() *Pragma_clauseContext { + var p = new(Pragma_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_clause + return p +} + +func InitEmptyPragma_clauseContext(p *Pragma_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_clause +} + +func (*Pragma_clauseContext) IsPragma_clauseContext() {} + +func NewPragma_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_clauseContext { + var p = new(Pragma_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_clause + + return p +} + +func (s *Pragma_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_clauseContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Pragma_clauseContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Pragma_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pragma_clauseContext) AllPragma_elements() []IPragma_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPragma_elementsContext); ok { + len++ + } + } + + tst := make([]IPragma_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPragma_elementsContext); ok { + tst[i] = t.(IPragma_elementsContext) + i++ + } + } + + return tst +} + +func (s *Pragma_clauseContext) Pragma_elements(i int) IPragma_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPragma_elementsContext) +} + +func (s *Pragma_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pragma_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pragma_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pragma_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_clause(s) + } +} + +func (s *Pragma_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_clause(s) + } +} + +func (s *Pragma_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPragma_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pragma_clause() (localctx IPragma_clauseContext) { + localctx = NewPragma_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 308, PlSqlParserRULE_pragma_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4832) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4833) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4834) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4835) + p.Pragma_elements() + } + p.SetState(4840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(4836) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4837) + p.Pragma_elements() + } + + p.SetState(4842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4843) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPragma_elementsContext is an interface to support dynamic dispatch. +type IPragma_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + DEFAULT() antlr.TerminalNode + + // IsPragma_elementsContext differentiates from other interfaces. + IsPragma_elementsContext() +} + +type Pragma_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPragma_elementsContext() *Pragma_elementsContext { + var p = new(Pragma_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_elements + return p +} + +func InitEmptyPragma_elementsContext(p *Pragma_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_elements +} + +func (*Pragma_elementsContext) IsPragma_elementsContext() {} + +func NewPragma_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_elementsContext { + var p = new(Pragma_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_elements + + return p +} + +func (s *Pragma_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_elementsContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Pragma_elementsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Pragma_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_elements(s) + } +} + +func (s *Pragma_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_elements(s) + } +} + +func (s *Pragma_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPragma_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pragma_elements() (localctx IPragma_elementsContext) { + localctx = NewPragma_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 310, PlSqlParserRULE_pragma_elements) + p.SetState(4847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4845) + p.Identifier() + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4846) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// IType_elements_parameterContext is an interface to support dynamic dispatch. +type IType_elements_parameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + + // IsType_elements_parameterContext differentiates from other interfaces. + IsType_elements_parameterContext() +} + +type Type_elements_parameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_elements_parameterContext() *Type_elements_parameterContext { + var p = new(Type_elements_parameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_elements_parameter + return p +} + +func InitEmptyType_elements_parameterContext(p *Type_elements_parameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_elements_parameter +} + +func (*Type_elements_parameterContext) IsType_elements_parameterContext() {} + +func NewType_elements_parameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_elements_parameterContext { + var p = new(Type_elements_parameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_elements_parameter + + return p +} + +func (s *Type_elements_parameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_elements_parameterContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Type_elements_parameterContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Type_elements_parameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_elements_parameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_elements_parameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_elements_parameter(s) + } +} + +func (s *Type_elements_parameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_elements_parameter(s) + } +} + +func (s *Type_elements_parameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_elements_parameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_elements_parameter() (localctx IType_elements_parameterContext) { + localctx = NewType_elements_parameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 312, PlSqlParserRULE_type_elements_parameter) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4849) + p.Parameter_name() + } + { + p.SetState(4850) + p.Type_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + Sequence_name() ISequence_nameContext + SEMICOLON() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_sequence + return p +} + +func InitEmptyDrop_sequenceContext(p *Drop_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_sequence + + return p +} + +func (s *Drop_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_sequenceContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Drop_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Drop_sequenceContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_sequence(s) + } +} + +func (s *Drop_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_sequence() (localctx IDrop_sequenceContext) { + localctx = NewDrop_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 314, PlSqlParserRULE_drop_sequence) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4852) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4853) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4854) + p.Sequence_name() + } + { + p.SetState(4855) + p.Match(PlSqlParserSEMICOLON) + 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_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 + Sequence_name() ISequence_nameContext + SEMICOLON() antlr.TerminalNode + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + + // 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 = PlSqlParserRULE_alter_sequence + return p +} + +func InitEmptyAlter_sequenceContext(p *Alter_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_sequence + + return p +} + +func (s *Alter_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sequenceContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Alter_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Alter_sequenceContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_sequenceContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Alter_sequenceContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_sequence(s) + } +} + +func (s *Alter_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_sequence() (localctx IAlter_sequenceContext) { + localctx = NewAlter_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 316, PlSqlParserRULE_alter_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4857) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4858) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4859) + p.Sequence_name() + } + p.SetState(4861) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER { + { + p.SetState(4860) + p.Sequence_spec() + } + + p.SetState(4863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4865) + p.Match(PlSqlParserSEMICOLON) + 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_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 + ADVISE() antlr.TerminalNode + CLOSE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Parameter_name() IParameter_nameContext + Enable_or_disable() IEnable_or_disableContext + COMMIT() antlr.TerminalNode + IN() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + GUARD() antlr.TerminalNode + AllPARALLEL() []antlr.TerminalNode + PARALLEL(i int) antlr.TerminalNode + SET() antlr.TerminalNode + Alter_session_set_clause() IAlter_session_set_clauseContext + ROLLBACK() antlr.TerminalNode + NOTHING() antlr.TerminalNode + DML() antlr.TerminalNode + DDL() antlr.TerminalNode + QUERY() antlr.TerminalNode + FORCE() antlr.TerminalNode + Literal() ILiteralContext + + // 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 = PlSqlParserRULE_alter_session + return p +} + +func InitEmptyAlter_sessionContext(p *Alter_sessionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_session + + return p +} + +func (s *Alter_sessionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_sessionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_sessionContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Alter_sessionContext) ADVISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISE, 0) +} + +func (s *Alter_sessionContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Alter_sessionContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Alter_sessionContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Alter_sessionContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Alter_sessionContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_sessionContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Alter_sessionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Alter_sessionContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Alter_sessionContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Alter_sessionContext) AllPARALLEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARALLEL) +} + +func (s *Alter_sessionContext) PARALLEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, i) +} + +func (s *Alter_sessionContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_sessionContext) Alter_session_set_clause() IAlter_session_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_session_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_session_set_clauseContext) +} + +func (s *Alter_sessionContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Alter_sessionContext) NOTHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTHING, 0) +} + +func (s *Alter_sessionContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Alter_sessionContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Alter_sessionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Alter_sessionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_sessionContext) 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 *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.(PlSqlParserListener); ok { + listenerT.EnterAlter_session(s) + } +} + +func (s *Alter_sessionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_session(s) + } +} + +func (s *Alter_sessionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_session(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_session() (localctx IAlter_sessionContext) { + localctx = NewAlter_sessionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 318, PlSqlParserRULE_alter_session) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4867) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4868) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4898) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 345, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4869) + p.Match(PlSqlParserADVISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4870) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserNOTHING || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(4871) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4872) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4873) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4874) + p.Parameter_name() + } + + case 3: + { + p.SetState(4875) + p.Enable_or_disable() + } + { + p.SetState(4876) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4877) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4878) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(4880) + p.Enable_or_disable() + } + { + p.SetState(4881) + p.Match(PlSqlParserGUARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.SetState(4885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(4883) + p.Enable_or_disable() + } + + case PlSqlParserFORCE: + { + p.SetState(4884) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(4887) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4888) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDDL || _la == PlSqlParserDML || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(4894) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 344, p.GetParserRuleContext()) == 1 { + { + p.SetState(4889) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 343, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4890) + p.Literal() + } + + case 2: + { + p.SetState(4891) + p.Parameter_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + { + p.SetState(4896) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4897) + p.Alter_session_set_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_session_set_clauseContext is an interface to support dynamic dispatch. +type IAlter_session_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEn returns the en rule contexts. + GetEn() IId_expressionContext + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetEn sets the en rule contexts. + SetEn(IId_expressionContext) + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + AllParameter_name() []IParameter_nameContext + Parameter_name(i int) IParameter_nameContext + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllParameter_value() []IParameter_valueContext + Parameter_value(i int) IParameter_valueContext + EDITION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + CONTAINER() antlr.TerminalNode + SERVICE() antlr.TerminalNode + ROW() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ALL() antlr.TerminalNode + DEFAULT_COLLATION() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsAlter_session_set_clauseContext differentiates from other interfaces. + IsAlter_session_set_clauseContext() +} + +type Alter_session_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + en IId_expressionContext + cn IId_expressionContext + sn IId_expressionContext + c IId_expressionContext +} + +func NewEmptyAlter_session_set_clauseContext() *Alter_session_set_clauseContext { + var p = new(Alter_session_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause + return p +} + +func InitEmptyAlter_session_set_clauseContext(p *Alter_session_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause +} + +func (*Alter_session_set_clauseContext) IsAlter_session_set_clauseContext() {} + +func NewAlter_session_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_session_set_clauseContext { + var p = new(Alter_session_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_session_set_clause + + return p +} + +func (s *Alter_session_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_session_set_clauseContext) GetEn() IId_expressionContext { return s.en } + +func (s *Alter_session_set_clauseContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Alter_session_set_clauseContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Alter_session_set_clauseContext) GetC() IId_expressionContext { return s.c } + +func (s *Alter_session_set_clauseContext) SetEn(v IId_expressionContext) { s.en = v } + +func (s *Alter_session_set_clauseContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Alter_session_set_clauseContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Alter_session_set_clauseContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Alter_session_set_clauseContext) AllParameter_name() []IParameter_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_nameContext); ok { + len++ + } + } + + tst := make([]IParameter_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_nameContext); ok { + tst[i] = t.(IParameter_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Parameter_name(i int) IParameter_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Alter_session_set_clauseContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Alter_session_set_clauseContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Alter_session_set_clauseContext) AllParameter_value() []IParameter_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_valueContext); ok { + len++ + } + } + + tst := make([]IParameter_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_valueContext); ok { + tst[i] = t.(IParameter_valueContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Parameter_value(i int) IParameter_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_valueContext) +} + +func (s *Alter_session_set_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Alter_session_set_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_session_set_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_session_set_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Alter_session_set_clauseContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Alter_session_set_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Alter_session_set_clauseContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Alter_session_set_clauseContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBILITY, 0) +} + +func (s *Alter_session_set_clauseContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE, 0) +} + +func (s *Alter_session_set_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_session_set_clauseContext) DEFAULT_COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_COLLATION, 0) +} + +func (s *Alter_session_set_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Alter_session_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_session_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_session_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_session_set_clause(s) + } +} + +func (s *Alter_session_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_session_set_clause(s) + } +} + +func (s *Alter_session_set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_session_set_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_session_set_clause() (localctx IAlter_session_set_clauseContext) { + localctx = NewAlter_session_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 320, PlSqlParserRULE_alter_session_set_clause) + var _la int + + var _alt int + + p.SetState(4930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 349, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(4904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(4900) + p.Parameter_name() + } + { + p.SetState(4901) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4902) + p.Parameter_value() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4906) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 346, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4908) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4909) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4910) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).en = _x + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4911) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4912) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4913) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).cn = _x + } + p.SetState(4917) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 347, p.GetParserRuleContext()) == 1 { + { + p.SetState(4914) + p.Match(PlSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4915) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4916) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).sn = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4919) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4920) + p.Match(PlSqlParserARCHIVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4921) + p.Match(PlSqlParserVISIBILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4922) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4923) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACTIVE || _la == PlSqlParserALL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4924) + p.Match(PlSqlParserDEFAULT_COLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4925) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 348, p.GetParserRuleContext()) { + case 1: + { + p.SetState(4926) + + var _x = p.Id_expression() + + localctx.(*Alter_session_set_clauseContext).c = _x + } + + case 2: + { + p.SetState(4927) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Sequence_name() ISequence_nameContext + SEMICOLON() antlr.TerminalNode + AllSequence_start_clause() []ISequence_start_clauseContext + Sequence_start_clause(i int) ISequence_start_clauseContext + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + + // 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 = PlSqlParserRULE_create_sequence + return p +} + +func InitEmptyCreate_sequenceContext(p *Create_sequenceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_sequence + + return p +} + +func (s *Create_sequenceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_sequenceContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_sequenceContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Create_sequenceContext) Sequence_name() ISequence_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISequence_nameContext) +} + +func (s *Create_sequenceContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_sequenceContext) AllSequence_start_clause() []ISequence_start_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + len++ + } + } + + tst := make([]ISequence_start_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_start_clauseContext); ok { + tst[i] = t.(ISequence_start_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_sequenceContext) Sequence_start_clause(i int) ISequence_start_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_start_clauseContext) +} + +func (s *Create_sequenceContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Create_sequenceContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_sequence(s) + } +} + +func (s *Create_sequenceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_sequence(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_sequence() (localctx ICreate_sequenceContext) { + localctx = NewCreate_sequenceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 322, PlSqlParserRULE_create_sequence) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4932) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4933) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4934) + p.Sequence_name() + } + p.SetState(4939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER || _la == PlSqlParserSTART { + p.SetState(4937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + { + p.SetState(4935) + p.Sequence_start_clause() + } + + case PlSqlParserCACHE, PlSqlParserCYCLE, PlSqlParserINCREMENT, PlSqlParserMAXVALUE, PlSqlParserMINVALUE, PlSqlParserNOCACHE, PlSqlParserNOCYCLE, PlSqlParserNOMAXVALUE, PlSqlParserNOMINVALUE, PlSqlParserNOORDER, PlSqlParserORDER: + { + p.SetState(4936) + p.Sequence_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(4941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(4942) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ISequence_specContext is an interface to support dynamic dispatch. +type ISequence_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + ORDER() antlr.TerminalNode + NOORDER() antlr.TerminalNode + + // IsSequence_specContext differentiates from other interfaces. + IsSequence_specContext() +} + +type Sequence_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_specContext() *Sequence_specContext { + var p = new(Sequence_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_spec + return p +} + +func InitEmptySequence_specContext(p *Sequence_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_spec +} + +func (*Sequence_specContext) IsSequence_specContext() {} + +func NewSequence_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_specContext { + var p = new(Sequence_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_spec + + return p +} + +func (s *Sequence_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_specContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Sequence_specContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Sequence_specContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Sequence_specContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Sequence_specContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Sequence_specContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Sequence_specContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Sequence_specContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Sequence_specContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Sequence_specContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Sequence_specContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Sequence_specContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Sequence_specContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Sequence_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_spec(s) + } +} + +func (s *Sequence_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_spec(s) + } +} + +func (s *Sequence_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSequence_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sequence_spec() (localctx ISequence_specContext) { + localctx = NewSequence_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 324, PlSqlParserRULE_sequence_spec) + p.SetState(4960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINCREMENT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4944) + p.Match(PlSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4945) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4946) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(4947) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4948) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMAXVALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(4949) + p.Match(PlSqlParserNOMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(4950) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4951) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMINVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(4952) + p.Match(PlSqlParserNOMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCYCLE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(4953) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCYCLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(4954) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(4955) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4956) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCACHE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(4957) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORDER: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(4958) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOORDER: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(4959) + p.Match(PlSqlParserNOORDER) + 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 +} + +// ISequence_start_clauseContext is an interface to support dynamic dispatch. +type ISequence_start_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsSequence_start_clauseContext differentiates from other interfaces. + IsSequence_start_clauseContext() +} + +type Sequence_start_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_start_clauseContext() *Sequence_start_clauseContext { + var p = new(Sequence_start_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_start_clause + return p +} + +func InitEmptySequence_start_clauseContext(p *Sequence_start_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_start_clause +} + +func (*Sequence_start_clauseContext) IsSequence_start_clauseContext() {} + +func NewSequence_start_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_start_clauseContext { + var p = new(Sequence_start_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_start_clause + + return p +} + +func (s *Sequence_start_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_start_clauseContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Sequence_start_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Sequence_start_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Sequence_start_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_start_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_start_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_start_clause(s) + } +} + +func (s *Sequence_start_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_start_clause(s) + } +} + +func (s *Sequence_start_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSequence_start_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sequence_start_clause() (localctx ISequence_start_clauseContext) { + localctx = NewSequence_start_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 326, PlSqlParserRULE_sequence_start_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4962) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4963) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4964) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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_analytic_viewContext is an interface to support dynamic dispatch. +type ICreate_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Cav_using_clause() ICav_using_clauseContext + Dim_by_clause() IDim_by_clauseContext + Measures_clause() IMeasures_clauseContext + Default_measure_clause() IDefault_measure_clauseContext + Default_aggregate_clause() IDefault_aggregate_clauseContext + Cache_clause() ICache_clauseContext + Fact_columns_clause() IFact_columns_clauseContext + Qry_transform_clause() IQry_transform_clauseContext + NOFORCE() antlr.TerminalNode + FORCE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_analytic_viewContext differentiates from other interfaces. + IsCreate_analytic_viewContext() +} + +type Create_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyCreate_analytic_viewContext() *Create_analytic_viewContext { + var p = new(Create_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_analytic_view + return p +} + +func InitEmptyCreate_analytic_viewContext(p *Create_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_analytic_view +} + +func (*Create_analytic_viewContext) IsCreate_analytic_viewContext() {} + +func NewCreate_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_analytic_viewContext { + var p = new(Create_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_analytic_view + + return p +} + +func (s *Create_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Create_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Create_analytic_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Create_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_analytic_viewContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_analytic_viewContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_analytic_viewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_analytic_viewContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_analytic_viewContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_analytic_viewContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_analytic_viewContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_analytic_viewContext) Cav_using_clause() ICav_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICav_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICav_using_clauseContext) +} + +func (s *Create_analytic_viewContext) Dim_by_clause() IDim_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDim_by_clauseContext) +} + +func (s *Create_analytic_viewContext) Measures_clause() IMeasures_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasures_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasures_clauseContext) +} + +func (s *Create_analytic_viewContext) Default_measure_clause() IDefault_measure_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_measure_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_measure_clauseContext) +} + +func (s *Create_analytic_viewContext) Default_aggregate_clause() IDefault_aggregate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_aggregate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_aggregate_clauseContext) +} + +func (s *Create_analytic_viewContext) Cache_clause() ICache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_clauseContext) +} + +func (s *Create_analytic_viewContext) Fact_columns_clause() IFact_columns_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFact_columns_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFact_columns_clauseContext) +} + +func (s *Create_analytic_viewContext) Qry_transform_clause() IQry_transform_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQry_transform_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQry_transform_clauseContext) +} + +func (s *Create_analytic_viewContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_analytic_viewContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_analytic_viewContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_analytic_viewContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_analytic_view(s) + } +} + +func (s *Create_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_analytic_view(s) + } +} + +func (s *Create_analytic_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_analytic_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_analytic_view() (localctx ICreate_analytic_viewContext) { + localctx = NewCreate_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 328, PlSqlParserRULE_create_analytic_view) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(4966) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(4969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(4967) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4968) + p.Match(PlSqlParserREPLACE) + 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 == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(4971) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(4974) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4975) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4976) + + var _x = p.Id_expression() + + localctx.(*Create_analytic_viewContext).av = _x + } + p.SetState(4980) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 355, p.GetParserRuleContext()) == 1 { + { + p.SetState(4977) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4978) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(4979) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 356, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(4982) + p.Classification_clause() + } + + } + p.SetState(4987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 356, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(4989) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 357, p.GetParserRuleContext()) == 1 { + { + p.SetState(4988) + p.Cav_using_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 358, p.GetParserRuleContext()) == 1 { + { + p.SetState(4991) + p.Dim_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4995) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 359, p.GetParserRuleContext()) == 1 { + { + p.SetState(4994) + p.Measures_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(4998) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 360, p.GetParserRuleContext()) == 1 { + { + p.SetState(4997) + p.Default_measure_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5001) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 361, p.GetParserRuleContext()) == 1 { + { + p.SetState(5000) + p.Default_aggregate_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5004) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 362, p.GetParserRuleContext()) == 1 { + { + p.SetState(5003) + p.Cache_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5007) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 363, p.GetParserRuleContext()) == 1 { + { + p.SetState(5006) + p.Fact_columns_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5010) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 364, p.GetParserRuleContext()) == 1 { + { + p.SetState(5009) + p.Qry_transform_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 +} + +// IClassification_clauseContext is an interface to support dynamic dispatch. +type IClassification_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Caption_clause() ICaption_clauseContext + Description_clause() IDescription_clauseContext + AllClassification_item() []IClassification_itemContext + Classification_item(i int) IClassification_itemContext + + // IsClassification_clauseContext differentiates from other interfaces. + IsClassification_clauseContext() +} + +type Classification_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClassification_clauseContext() *Classification_clauseContext { + var p = new(Classification_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_clause + return p +} + +func InitEmptyClassification_clauseContext(p *Classification_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_clause +} + +func (*Classification_clauseContext) IsClassification_clauseContext() {} + +func NewClassification_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Classification_clauseContext { + var p = new(Classification_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_classification_clause + + return p +} + +func (s *Classification_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Classification_clauseContext) Caption_clause() ICaption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICaption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICaption_clauseContext) +} + +func (s *Classification_clauseContext) Description_clause() IDescription_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDescription_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDescription_clauseContext) +} + +func (s *Classification_clauseContext) AllClassification_item() []IClassification_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_itemContext); ok { + len++ + } + } + + tst := make([]IClassification_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_itemContext); ok { + tst[i] = t.(IClassification_itemContext) + i++ + } + } + + return tst +} + +func (s *Classification_clauseContext) Classification_item(i int) IClassification_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_itemContext) +} + +func (s *Classification_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Classification_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Classification_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClassification_clause(s) + } +} + +func (s *Classification_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClassification_clause(s) + } +} + +func (s *Classification_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClassification_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Classification_clause() (localctx IClassification_clauseContext) { + localctx = NewClassification_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 330, PlSqlParserRULE_classification_clause) + var _la int + + var _alt int + + p.SetState(5039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 372, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 367, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5012) + p.Caption_clause() + } + p.SetState(5014) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 365, p.GetParserRuleContext()) == 1 { + { + p.SetState(5013) + p.Description_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(5017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCAPTION { + { + p.SetState(5016) + p.Caption_clause() + } + + } + { + p.SetState(5019) + p.Description_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 368, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5022) + p.Classification_item() + } + + } + p.SetState(5027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 368, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCAPTION { + { + p.SetState(5028) + p.Caption_clause() + } + + } + p.SetState(5032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESCRIPTION { + { + p.SetState(5031) + p.Description_clause() + } + + } + p.SetState(5035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(5034) + p.Classification_item() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5037) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 371, 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 +} + +// ICaption_clauseContext is an interface to support dynamic dispatch. +type ICaption_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetC returns the c rule contexts. + GetC() IQuoted_stringContext + + // SetC sets the c rule contexts. + SetC(IQuoted_stringContext) + + // Getter signatures + CAPTION() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsCaption_clauseContext differentiates from other interfaces. + IsCaption_clauseContext() +} + +type Caption_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + c IQuoted_stringContext +} + +func NewEmptyCaption_clauseContext() *Caption_clauseContext { + var p = new(Caption_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_caption_clause + return p +} + +func InitEmptyCaption_clauseContext(p *Caption_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_caption_clause +} + +func (*Caption_clauseContext) IsCaption_clauseContext() {} + +func NewCaption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Caption_clauseContext { + var p = new(Caption_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_caption_clause + + return p +} + +func (s *Caption_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Caption_clauseContext) GetC() IQuoted_stringContext { return s.c } + +func (s *Caption_clauseContext) SetC(v IQuoted_stringContext) { s.c = v } + +func (s *Caption_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Caption_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Caption_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Caption_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Caption_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCaption_clause(s) + } +} + +func (s *Caption_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCaption_clause(s) + } +} + +func (s *Caption_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCaption_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Caption_clause() (localctx ICaption_clauseContext) { + localctx = NewCaption_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 332, PlSqlParserRULE_caption_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5041) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5042) + + var _x = p.Quoted_string() + + localctx.(*Caption_clauseContext).c = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDescription_clauseContext is an interface to support dynamic dispatch. +type IDescription_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IQuoted_stringContext + + // SetD sets the d rule contexts. + SetD(IQuoted_stringContext) + + // Getter signatures + DESCRIPTION() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsDescription_clauseContext differentiates from other interfaces. + IsDescription_clauseContext() +} + +type Description_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IQuoted_stringContext +} + +func NewEmptyDescription_clauseContext() *Description_clauseContext { + var p = new(Description_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_description_clause + return p +} + +func InitEmptyDescription_clauseContext(p *Description_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_description_clause +} + +func (*Description_clauseContext) IsDescription_clauseContext() {} + +func NewDescription_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Description_clauseContext { + var p = new(Description_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_description_clause + + return p +} + +func (s *Description_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Description_clauseContext) GetD() IQuoted_stringContext { return s.d } + +func (s *Description_clauseContext) SetD(v IQuoted_stringContext) { s.d = v } + +func (s *Description_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Description_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Description_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Description_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Description_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDescription_clause(s) + } +} + +func (s *Description_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDescription_clause(s) + } +} + +func (s *Description_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDescription_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Description_clause() (localctx IDescription_clauseContext) { + localctx = NewDescription_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 334, PlSqlParserRULE_description_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5044) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5045) + + var _x = p.Quoted_string() + + localctx.(*Description_clauseContext).d = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClassification_itemContext is an interface to support dynamic dispatch. +type IClassification_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // GetCv returns the cv rule contexts. + GetCv() IQuoted_stringContext + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // SetCv sets the cv rule contexts. + SetCv(IQuoted_stringContext) + + // Getter signatures + CLASSIFICATION() antlr.TerminalNode + Id_expression() IId_expressionContext + VALUE() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + Language() ILanguageContext + Quoted_string() IQuoted_stringContext + + // IsClassification_itemContext differentiates from other interfaces. + IsClassification_itemContext() +} + +type Classification_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cn IId_expressionContext + cv IQuoted_stringContext +} + +func NewEmptyClassification_itemContext() *Classification_itemContext { + var p = new(Classification_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_item + return p +} + +func InitEmptyClassification_itemContext(p *Classification_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_classification_item +} + +func (*Classification_itemContext) IsClassification_itemContext() {} + +func NewClassification_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Classification_itemContext { + var p = new(Classification_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_classification_item + + return p +} + +func (s *Classification_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Classification_itemContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Classification_itemContext) GetCv() IQuoted_stringContext { return s.cv } + +func (s *Classification_itemContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Classification_itemContext) SetCv(v IQuoted_stringContext) { s.cv = v } + +func (s *Classification_itemContext) CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFICATION, 0) +} + +func (s *Classification_itemContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Classification_itemContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Classification_itemContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Classification_itemContext) Language() ILanguageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILanguageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILanguageContext) +} + +func (s *Classification_itemContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Classification_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Classification_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Classification_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClassification_item(s) + } +} + +func (s *Classification_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClassification_item(s) + } +} + +func (s *Classification_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClassification_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Classification_item() (localctx IClassification_itemContext) { + localctx = NewClassification_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 336, PlSqlParserRULE_classification_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5047) + p.Match(PlSqlParserCLASSIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5048) + + var _x = p.Id_expression() + + localctx.(*Classification_itemContext).cn = _x + } + p.SetState(5051) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 373, p.GetParserRuleContext()) == 1 { + { + p.SetState(5049) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5050) + + var _x = p.Quoted_string() + + localctx.(*Classification_itemContext).cv = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5055) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 374, p.GetParserRuleContext()) == 1 { + { + p.SetState(5053) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5054) + p.Language() + } + + } 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 +} + +// ILanguageContext is an interface to support dynamic dispatch. +type ILanguageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNls returns the nls rule contexts. + GetNls() IId_expressionContext + + // SetNls sets the nls rule contexts. + SetNls(IId_expressionContext) + + // Getter signatures + NULL_() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsLanguageContext differentiates from other interfaces. + IsLanguageContext() +} + +type LanguageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nls IId_expressionContext +} + +func NewEmptyLanguageContext() *LanguageContext { + var p = new(LanguageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_language + return p +} + +func InitEmptyLanguageContext(p *LanguageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_language +} + +func (*LanguageContext) IsLanguageContext() {} + +func NewLanguageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *LanguageContext { + var p = new(LanguageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_language + + return p +} + +func (s *LanguageContext) GetParser() antlr.Parser { return s.parser } + +func (s *LanguageContext) GetNls() IId_expressionContext { return s.nls } + +func (s *LanguageContext) SetNls(v IId_expressionContext) { s.nls = v } + +func (s *LanguageContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *LanguageContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *LanguageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *LanguageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *LanguageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLanguage(s) + } +} + +func (s *LanguageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLanguage(s) + } +} + +func (s *LanguageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLanguage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Language() (localctx ILanguageContext) { + localctx = NewLanguageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 338, PlSqlParserRULE_language) + p.SetState(5059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5057) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5058) + + var _x = p.Id_expression() + + localctx.(*LanguageContext).nls = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICav_using_clauseContext is an interface to support dynamic dispatch. +type ICav_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetTa returns the ta rule contexts. + GetTa() IId_expressionContext + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetTa sets the ta rule contexts. + SetTa(IId_expressionContext) + + // Getter signatures + USING() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + REMOTE() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsCav_using_clauseContext differentiates from other interfaces. + IsCav_using_clauseContext() +} + +type Cav_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t IId_expressionContext + ta IId_expressionContext +} + +func NewEmptyCav_using_clauseContext() *Cav_using_clauseContext { + var p = new(Cav_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cav_using_clause + return p +} + +func InitEmptyCav_using_clauseContext(p *Cav_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cav_using_clause +} + +func (*Cav_using_clauseContext) IsCav_using_clauseContext() {} + +func NewCav_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cav_using_clauseContext { + var p = new(Cav_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cav_using_clause + + return p +} + +func (s *Cav_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cav_using_clauseContext) GetT() IId_expressionContext { return s.t } + +func (s *Cav_using_clauseContext) GetTa() IId_expressionContext { return s.ta } + +func (s *Cav_using_clauseContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Cav_using_clauseContext) SetTa(v IId_expressionContext) { s.ta = v } + +func (s *Cav_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Cav_using_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cav_using_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cav_using_clauseContext) 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 *Cav_using_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Cav_using_clauseContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Cav_using_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Cav_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cav_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cav_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCav_using_clause(s) + } +} + +func (s *Cav_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCav_using_clause(s) + } +} + +func (s *Cav_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCav_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cav_using_clause() (localctx ICav_using_clauseContext) { + localctx = NewCav_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 340, PlSqlParserRULE_cav_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5061) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5065) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 376, p.GetParserRuleContext()) == 1 { + { + p.SetState(5062) + p.Schema_name() + } + { + p.SetState(5063) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5067) + + var _x = p.Id_expression() + + localctx.(*Cav_using_clauseContext).t = _x + } + p.SetState(5069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 377, p.GetParserRuleContext()) == 1 { + { + p.SetState(5068) + p.Match(PlSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5075) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 379, p.GetParserRuleContext()) == 1 { + p.SetState(5072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5071) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5074) + + var _x = p.Id_expression() + + localctx.(*Cav_using_clauseContext).ta = _x + } + + } 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 +} + +// IDim_by_clauseContext is an interface to support dynamic dispatch. +type IDim_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIMENSION() antlr.TerminalNode + BY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllDim_key() []IDim_keyContext + Dim_key(i int) IDim_keyContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDim_by_clauseContext differentiates from other interfaces. + IsDim_by_clauseContext() +} + +type Dim_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDim_by_clauseContext() *Dim_by_clauseContext { + var p = new(Dim_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_by_clause + return p +} + +func InitEmptyDim_by_clauseContext(p *Dim_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_by_clause +} + +func (*Dim_by_clauseContext) IsDim_by_clauseContext() {} + +func NewDim_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_by_clauseContext { + var p = new(Dim_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_by_clause + + return p +} + +func (s *Dim_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_by_clauseContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Dim_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Dim_by_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Dim_by_clauseContext) AllDim_key() []IDim_keyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDim_keyContext); ok { + len++ + } + } + + tst := make([]IDim_keyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDim_keyContext); ok { + tst[i] = t.(IDim_keyContext) + i++ + } + } + + return tst +} + +func (s *Dim_by_clauseContext) Dim_key(i int) IDim_keyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_keyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDim_keyContext) +} + +func (s *Dim_by_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Dim_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Dim_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Dim_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_by_clause(s) + } +} + +func (s *Dim_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_by_clause(s) + } +} + +func (s *Dim_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDim_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dim_by_clause() (localctx IDim_by_clauseContext) { + localctx = NewDim_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 342, PlSqlParserRULE_dim_by_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5077) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5078) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5079) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5080) + p.Dim_key() + } + p.SetState(5085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5081) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5082) + p.Dim_key() + } + + p.SetState(5087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5088) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_keyContext is an interface to support dynamic dispatch. +type IDim_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetF returns the f rule contexts. + GetF() IColumn_nameContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetF sets the f rule contexts. + SetF(IColumn_nameContext) + + // Getter signatures + Dim_ref() IDim_refContext + KEY() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + HIERARCHIES() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllHier_ref() []IHier_refContext + Hier_ref(i int) IHier_refContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllAttribute_name() []IAttribute_nameContext + Attribute_name(i int) IAttribute_nameContext + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + DISTINCT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsDim_keyContext differentiates from other interfaces. + IsDim_keyContext() +} + +type Dim_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + f IColumn_nameContext +} + +func NewEmptyDim_keyContext() *Dim_keyContext { + var p = new(Dim_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_key + return p +} + +func InitEmptyDim_keyContext(p *Dim_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_key +} + +func (*Dim_keyContext) IsDim_keyContext() {} + +func NewDim_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_keyContext { + var p = new(Dim_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_key + + return p +} + +func (s *Dim_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_keyContext) GetA() IId_expressionContext { return s.a } + +func (s *Dim_keyContext) GetF() IColumn_nameContext { return s.f } + +func (s *Dim_keyContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Dim_keyContext) SetF(v IColumn_nameContext) { s.f = v } + +func (s *Dim_keyContext) Dim_ref() IDim_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDim_refContext) +} + +func (s *Dim_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Dim_keyContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Dim_keyContext) HIERARCHIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHIES, 0) +} + +func (s *Dim_keyContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Dim_keyContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Dim_keyContext) AllHier_ref() []IHier_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHier_refContext); ok { + len++ + } + } + + tst := make([]IHier_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHier_refContext); ok { + tst[i] = t.(IHier_refContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Hier_ref(i int) IHier_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHier_refContext) +} + +func (s *Dim_keyContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Dim_keyContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Dim_keyContext) AllAttribute_name() []IAttribute_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_nameContext); ok { + len++ + } + } + + tst := make([]IAttribute_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_nameContext); ok { + tst[i] = t.(IAttribute_nameContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Attribute_name(i int) IAttribute_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Dim_keyContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Dim_keyContext) 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 *Dim_keyContext) 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 *Dim_keyContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Dim_keyContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Dim_keyContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Dim_keyContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Dim_keyContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Dim_keyContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Dim_keyContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_key(s) + } +} + +func (s *Dim_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_key(s) + } +} + +func (s *Dim_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDim_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dim_key() (localctx IDim_keyContext) { + localctx = NewDim_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 344, PlSqlParserRULE_dim_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5090) + p.Dim_ref() + } + p.SetState(5094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5091) + p.Classification_clause() + } + + p.SetState(5096) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5097) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(5098) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5102) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 382, p.GetParserRuleContext()) == 1 { + { + p.SetState(5099) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5100) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5104) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + p.SetState(5114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5105) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5109) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 383, p.GetParserRuleContext()) == 1 { + { + p.SetState(5106) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5107) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5111) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + + p.SetState(5116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5117) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(5122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 385, p.GetParserRuleContext()) == 1 { + { + p.SetState(5119) + + var _x = p.Id_expression() + + localctx.(*Dim_keyContext).a = _x + } + { + p.SetState(5120) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5124) + + var _x = p.Column_name() + + localctx.(*Dim_keyContext).f = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5127) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISTINCT { + { + p.SetState(5128) + p.Match(PlSqlParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(5131) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5132) + p.Attribute_name() + } + + { + p.SetState(5133) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5134) + p.Attribute_name() + } + + { + p.SetState(5136) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(5138) + p.Attribute_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5141) + p.Match(PlSqlParserHIERARCHIES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5142) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5143) + p.Hier_ref() + } + p.SetState(5148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5144) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5145) + p.Hier_ref() + } + + p.SetState(5150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5151) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDim_refContext is an interface to support dynamic dispatch. +type IDim_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // GetDa returns the da rule contexts. + GetDa() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // SetDa sets the da rule contexts. + SetDa(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsDim_refContext differentiates from other interfaces. + IsDim_refContext() +} + +type Dim_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext + da IId_expressionContext +} + +func NewEmptyDim_refContext() *Dim_refContext { + var p = new(Dim_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_ref + return p +} + +func InitEmptyDim_refContext(p *Dim_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_ref +} + +func (*Dim_refContext) IsDim_refContext() {} + +func NewDim_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_refContext { + var p = new(Dim_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_ref + + return p +} + +func (s *Dim_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_refContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Dim_refContext) GetDa() IId_expressionContext { return s.da } + +func (s *Dim_refContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Dim_refContext) SetDa(v IId_expressionContext) { s.da = v } + +func (s *Dim_refContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Dim_refContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_refContext) 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 *Dim_refContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Dim_refContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Dim_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_ref(s) + } +} + +func (s *Dim_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_ref(s) + } +} + +func (s *Dim_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDim_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dim_ref() (localctx IDim_refContext) { + localctx = NewDim_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 346, PlSqlParserRULE_dim_ref) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5156) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 390, p.GetParserRuleContext()) == 1 { + { + p.SetState(5153) + p.Schema_name() + } + { + p.SetState(5154) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5158) + + var _x = p.Id_expression() + + localctx.(*Dim_refContext).ad = _x + } + p.SetState(5163) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 392, p.GetParserRuleContext()) == 1 { + p.SetState(5160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5159) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5162) + + var _x = p.Id_expression() + + localctx.(*Dim_refContext).da = _x + } + + } 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 +} + +// IHier_refContext is an interface to support dynamic dispatch. +type IHier_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetHa returns the ha rule contexts. + GetHa() IId_expressionContext + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetHa sets the ha rule contexts. + SetHa(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsHier_refContext differentiates from other interfaces. + IsHier_refContext() +} + +type Hier_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + h IId_expressionContext + ha IId_expressionContext +} + +func NewEmptyHier_refContext() *Hier_refContext { + var p = new(Hier_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_ref + return p +} + +func InitEmptyHier_refContext(p *Hier_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_ref +} + +func (*Hier_refContext) IsHier_refContext() {} + +func NewHier_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_refContext { + var p = new(Hier_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_ref + + return p +} + +func (s *Hier_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_refContext) GetH() IId_expressionContext { return s.h } + +func (s *Hier_refContext) GetHa() IId_expressionContext { return s.ha } + +func (s *Hier_refContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Hier_refContext) SetHa(v IId_expressionContext) { s.ha = v } + +func (s *Hier_refContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Hier_refContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Hier_refContext) 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 *Hier_refContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Hier_refContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Hier_refContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Hier_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_ref(s) + } +} + +func (s *Hier_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_ref(s) + } +} + +func (s *Hier_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHier_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hier_ref() (localctx IHier_refContext) { + localctx = NewHier_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 348, PlSqlParserRULE_hier_ref) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5168) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 393, p.GetParserRuleContext()) == 1 { + { + p.SetState(5165) + p.Schema_name() + } + { + p.SetState(5166) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5170) + + var _x = p.Id_expression() + + localctx.(*Hier_refContext).h = _x + } + p.SetState(5175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + p.SetState(5172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5171) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5174) + + var _x = p.Id_expression() + + localctx.(*Hier_refContext).ha = _x + } + + } + p.SetState(5178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(5177) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// IMeasures_clauseContext is an interface to support dynamic dispatch. +type IMeasures_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEASURES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAv_measure() []IAv_measureContext + Av_measure(i int) IAv_measureContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMeasures_clauseContext differentiates from other interfaces. + IsMeasures_clauseContext() +} + +type Measures_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeasures_clauseContext() *Measures_clauseContext { + var p = new(Measures_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measures_clause + return p +} + +func InitEmptyMeasures_clauseContext(p *Measures_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measures_clause +} + +func (*Measures_clauseContext) IsMeasures_clauseContext() {} + +func NewMeasures_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Measures_clauseContext { + var p = new(Measures_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_measures_clause + + return p +} + +func (s *Measures_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Measures_clauseContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Measures_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Measures_clauseContext) AllAv_measure() []IAv_measureContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAv_measureContext); ok { + len++ + } + } + + tst := make([]IAv_measureContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAv_measureContext); ok { + tst[i] = t.(IAv_measureContext) + i++ + } + } + + return tst +} + +func (s *Measures_clauseContext) Av_measure(i int) IAv_measureContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAv_measureContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAv_measureContext) +} + +func (s *Measures_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Measures_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Measures_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Measures_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Measures_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Measures_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeasures_clause(s) + } +} + +func (s *Measures_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeasures_clause(s) + } +} + +func (s *Measures_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMeasures_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Measures_clause() (localctx IMeasures_clauseContext) { + localctx = NewMeasures_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 350, PlSqlParserRULE_measures_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5180) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5181) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5182) + p.Av_measure() + } + p.SetState(5187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5183) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5184) + p.Av_measure() + } + + p.SetState(5189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5190) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAv_measureContext is an interface to support dynamic dispatch. +type IAv_measureContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMn returns the mn rule contexts. + GetMn() IId_expressionContext + + // SetMn sets the mn rule contexts. + SetMn(IId_expressionContext) + + // Getter signatures + Id_expression() IId_expressionContext + Base_meas_clause() IBase_meas_clauseContext + Calc_meas_clause() ICalc_meas_clauseContext + + // IsAv_measureContext differentiates from other interfaces. + IsAv_measureContext() +} + +type Av_measureContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mn IId_expressionContext +} + +func NewEmptyAv_measureContext() *Av_measureContext { + var p = new(Av_measureContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_av_measure + return p +} + +func InitEmptyAv_measureContext(p *Av_measureContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_av_measure +} + +func (*Av_measureContext) IsAv_measureContext() {} + +func NewAv_measureContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Av_measureContext { + var p = new(Av_measureContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_av_measure + + return p +} + +func (s *Av_measureContext) GetParser() antlr.Parser { return s.parser } + +func (s *Av_measureContext) GetMn() IId_expressionContext { return s.mn } + +func (s *Av_measureContext) SetMn(v IId_expressionContext) { s.mn = v } + +func (s *Av_measureContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Av_measureContext) Base_meas_clause() IBase_meas_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBase_meas_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBase_meas_clauseContext) +} + +func (s *Av_measureContext) Calc_meas_clause() ICalc_meas_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICalc_meas_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICalc_meas_clauseContext) +} + +func (s *Av_measureContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Av_measureContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Av_measureContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAv_measure(s) + } +} + +func (s *Av_measureContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAv_measure(s) + } +} + +func (s *Av_measureContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAv_measure(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Av_measure() (localctx IAv_measureContext) { + localctx = NewAv_measureContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 352, PlSqlParserRULE_av_measure) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5192) + + var _x = p.Id_expression() + + localctx.(*Av_measureContext).mn = _x + } + p.SetState(5195) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserFACT: + { + p.SetState(5193) + p.Base_meas_clause() + } + + case PlSqlParserAS: + { + p.SetState(5194) + p.Calc_meas_clause() + } + + case PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBase_meas_clauseContext is an interface to support dynamic dispatch. +type IBase_meas_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBm returns the bm rule contexts. + GetBm() IId_expressionContext + + // SetBm sets the bm rule contexts. + SetBm(IId_expressionContext) + + // Getter signatures + FACT() antlr.TerminalNode + Id_expression() IId_expressionContext + Meas_aggregate_clause() IMeas_aggregate_clauseContext + + // IsBase_meas_clauseContext differentiates from other interfaces. + IsBase_meas_clauseContext() +} + +type Base_meas_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bm IId_expressionContext +} + +func NewEmptyBase_meas_clauseContext() *Base_meas_clauseContext { + var p = new(Base_meas_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_base_meas_clause + return p +} + +func InitEmptyBase_meas_clauseContext(p *Base_meas_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_base_meas_clause +} + +func (*Base_meas_clauseContext) IsBase_meas_clauseContext() {} + +func NewBase_meas_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Base_meas_clauseContext { + var p = new(Base_meas_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_base_meas_clause + + return p +} + +func (s *Base_meas_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Base_meas_clauseContext) GetBm() IId_expressionContext { return s.bm } + +func (s *Base_meas_clauseContext) SetBm(v IId_expressionContext) { s.bm = v } + +func (s *Base_meas_clauseContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Base_meas_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Base_meas_clauseContext) Meas_aggregate_clause() IMeas_aggregate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeas_aggregate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeas_aggregate_clauseContext) +} + +func (s *Base_meas_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Base_meas_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Base_meas_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBase_meas_clause(s) + } +} + +func (s *Base_meas_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBase_meas_clause(s) + } +} + +func (s *Base_meas_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBase_meas_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Base_meas_clause() (localctx IBase_meas_clauseContext) { + localctx = NewBase_meas_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 354, PlSqlParserRULE_base_meas_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5197) + p.Match(PlSqlParserFACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5198) + + var _x = p.Id_expression() + + localctx.(*Base_meas_clauseContext).bm = _x + } + p.SetState(5200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAGGREGATE { + { + p.SetState(5199) + p.Meas_aggregate_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 +} + +// IMeas_aggregate_clauseContext is an interface to support dynamic dispatch. +type IMeas_aggregate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGGREGATE() antlr.TerminalNode + BY() antlr.TerminalNode + Aggregate_function_name() IAggregate_function_nameContext + + // IsMeas_aggregate_clauseContext differentiates from other interfaces. + IsMeas_aggregate_clauseContext() +} + +type Meas_aggregate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeas_aggregate_clauseContext() *Meas_aggregate_clauseContext { + var p = new(Meas_aggregate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause + return p +} + +func InitEmptyMeas_aggregate_clauseContext(p *Meas_aggregate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause +} + +func (*Meas_aggregate_clauseContext) IsMeas_aggregate_clauseContext() {} + +func NewMeas_aggregate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Meas_aggregate_clauseContext { + var p = new(Meas_aggregate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_meas_aggregate_clause + + return p +} + +func (s *Meas_aggregate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Meas_aggregate_clauseContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Meas_aggregate_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Meas_aggregate_clauseContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Meas_aggregate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Meas_aggregate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Meas_aggregate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeas_aggregate_clause(s) + } +} + +func (s *Meas_aggregate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeas_aggregate_clause(s) + } +} + +func (s *Meas_aggregate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMeas_aggregate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Meas_aggregate_clause() (localctx IMeas_aggregate_clauseContext) { + localctx = NewMeas_aggregate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 356, PlSqlParserRULE_meas_aggregate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5202) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5203) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5204) + p.Aggregate_function_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 +} + +// ICalc_meas_clauseContext is an interface to support dynamic dispatch. +type ICalc_meas_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCalc_meas_clauseContext differentiates from other interfaces. + IsCalc_meas_clauseContext() +} + +type Calc_meas_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCalc_meas_clauseContext() *Calc_meas_clauseContext { + var p = new(Calc_meas_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_calc_meas_clause + return p +} + +func InitEmptyCalc_meas_clauseContext(p *Calc_meas_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_calc_meas_clause +} + +func (*Calc_meas_clauseContext) IsCalc_meas_clauseContext() {} + +func NewCalc_meas_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Calc_meas_clauseContext { + var p = new(Calc_meas_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_calc_meas_clause + + return p +} + +func (s *Calc_meas_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Calc_meas_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Calc_meas_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Calc_meas_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Calc_meas_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Calc_meas_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Calc_meas_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Calc_meas_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCalc_meas_clause(s) + } +} + +func (s *Calc_meas_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCalc_meas_clause(s) + } +} + +func (s *Calc_meas_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCalc_meas_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Calc_meas_clause() (localctx ICalc_meas_clauseContext) { + localctx = NewCalc_meas_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 358, PlSqlParserRULE_calc_meas_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5206) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5207) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5208) + p.Expression() + } + { + p.SetState(5209) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDefault_measure_clauseContext is an interface to support dynamic dispatch. +type IDefault_measure_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetM returns the m rule contexts. + GetM() IId_expressionContext + + // SetM sets the m rule contexts. + SetM(IId_expressionContext) + + // Getter signatures + DEFAULT() antlr.TerminalNode + MEASURE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDefault_measure_clauseContext differentiates from other interfaces. + IsDefault_measure_clauseContext() +} + +type Default_measure_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + m IId_expressionContext +} + +func NewEmptyDefault_measure_clauseContext() *Default_measure_clauseContext { + var p = new(Default_measure_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_measure_clause + return p +} + +func InitEmptyDefault_measure_clauseContext(p *Default_measure_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_measure_clause +} + +func (*Default_measure_clauseContext) IsDefault_measure_clauseContext() {} + +func NewDefault_measure_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_measure_clauseContext { + var p = new(Default_measure_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_measure_clause + + return p +} + +func (s *Default_measure_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_measure_clauseContext) GetM() IId_expressionContext { return s.m } + +func (s *Default_measure_clauseContext) SetM(v IId_expressionContext) { s.m = v } + +func (s *Default_measure_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_measure_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Default_measure_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Default_measure_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_measure_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_measure_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_measure_clause(s) + } +} + +func (s *Default_measure_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_measure_clause(s) + } +} + +func (s *Default_measure_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_measure_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_measure_clause() (localctx IDefault_measure_clauseContext) { + localctx = NewDefault_measure_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 360, PlSqlParserRULE_default_measure_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5211) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5212) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5213) + + var _x = p.Id_expression() + + localctx.(*Default_measure_clauseContext).m = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_aggregate_clauseContext is an interface to support dynamic dispatch. +type IDefault_aggregate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + BY() antlr.TerminalNode + Aggregate_function_name() IAggregate_function_nameContext + + // IsDefault_aggregate_clauseContext differentiates from other interfaces. + IsDefault_aggregate_clauseContext() +} + +type Default_aggregate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_aggregate_clauseContext() *Default_aggregate_clauseContext { + var p = new(Default_aggregate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause + return p +} + +func InitEmptyDefault_aggregate_clauseContext(p *Default_aggregate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause +} + +func (*Default_aggregate_clauseContext) IsDefault_aggregate_clauseContext() {} + +func NewDefault_aggregate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_aggregate_clauseContext { + var p = new(Default_aggregate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_aggregate_clause + + return p +} + +func (s *Default_aggregate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_aggregate_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_aggregate_clauseContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Default_aggregate_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Default_aggregate_clauseContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Default_aggregate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_aggregate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_aggregate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_aggregate_clause(s) + } +} + +func (s *Default_aggregate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_aggregate_clause(s) + } +} + +func (s *Default_aggregate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_aggregate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_aggregate_clause() (localctx IDefault_aggregate_clauseContext) { + localctx = NewDefault_aggregate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 362, PlSqlParserRULE_default_aggregate_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5215) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5216) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5217) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5218) + p.Aggregate_function_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 +} + +// ICache_clauseContext is an interface to support dynamic dispatch. +type ICache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CACHE() antlr.TerminalNode + AllCache_specification() []ICache_specificationContext + Cache_specification(i int) ICache_specificationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCache_clauseContext differentiates from other interfaces. + IsCache_clauseContext() +} + +type Cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_clauseContext() *Cache_clauseContext { + var p = new(Cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_clause + return p +} + +func InitEmptyCache_clauseContext(p *Cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_clause +} + +func (*Cache_clauseContext) IsCache_clauseContext() {} + +func NewCache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_clauseContext { + var p = new(Cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_clause + + return p +} + +func (s *Cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Cache_clauseContext) AllCache_specification() []ICache_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICache_specificationContext); ok { + len++ + } + } + + tst := make([]ICache_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICache_specificationContext); ok { + tst[i] = t.(ICache_specificationContext) + i++ + } + } + + return tst +} + +func (s *Cache_clauseContext) Cache_specification(i int) ICache_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICache_specificationContext) +} + +func (s *Cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_clause(s) + } +} + +func (s *Cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_clause(s) + } +} + +func (s *Cache_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCache_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cache_clause() (localctx ICache_clauseContext) { + localctx = NewCache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 364, PlSqlParserRULE_cache_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5220) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5221) + p.Cache_specification() + } + p.SetState(5226) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 400, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5222) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5223) + p.Cache_specification() + } + + } + p.SetState(5228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 400, 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 +} + +// ICache_specificationContext is an interface to support dynamic dispatch. +type ICache_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + ALL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllLevels_clause() []ILevels_clauseContext + Levels_clause(i int) ILevels_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCache_specificationContext differentiates from other interfaces. + IsCache_specificationContext() +} + +type Cache_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_specificationContext() *Cache_specificationContext { + var p = new(Cache_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_specification + return p +} + +func InitEmptyCache_specificationContext(p *Cache_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_specification +} + +func (*Cache_specificationContext) IsCache_specificationContext() {} + +func NewCache_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_specificationContext { + var p = new(Cache_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_specification + + return p +} + +func (s *Cache_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_specificationContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Cache_specificationContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Cache_specificationContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Cache_specificationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cache_specificationContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cache_specificationContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cache_specificationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cache_specificationContext) AllLevels_clause() []ILevels_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_clauseContext); ok { + len++ + } + } + + tst := make([]ILevels_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_clauseContext); ok { + tst[i] = t.(ILevels_clauseContext) + i++ + } + } + + return tst +} + +func (s *Cache_specificationContext) Levels_clause(i int) ILevels_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_clauseContext) +} + +func (s *Cache_specificationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cache_specificationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cache_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_specification(s) + } +} + +func (s *Cache_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_specification(s) + } +} + +func (s *Cache_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCache_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cache_specification() (localctx ICache_specificationContext) { + localctx = NewCache_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 366, PlSqlParserRULE_cache_specification) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5229) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5230) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(5231) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(5232) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5233) + p.Id_expression() + } + p.SetState(5238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5234) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5235) + p.Id_expression() + } + + p.SetState(5240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5241) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5242) + p.Levels_clause() + } + p.SetState(5247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5243) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5244) + p.Levels_clause() + } + + } + p.SetState(5249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 402, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// ILevels_clauseContext is an interface to support dynamic dispatch. +type ILevels_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEVELS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllLevel_specification() []ILevel_specificationContext + Level_specification(i int) ILevel_specificationContext + RIGHT_PAREN() antlr.TerminalNode + Level_group_type() ILevel_group_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLevels_clauseContext differentiates from other interfaces. + IsLevels_clauseContext() +} + +type Levels_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLevels_clauseContext() *Levels_clauseContext { + var p = new(Levels_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_clause + return p +} + +func InitEmptyLevels_clauseContext(p *Levels_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_clause +} + +func (*Levels_clauseContext) IsLevels_clauseContext() {} + +func NewLevels_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Levels_clauseContext { + var p = new(Levels_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_levels_clause + + return p +} + +func (s *Levels_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Levels_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Levels_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Levels_clauseContext) AllLevel_specification() []ILevel_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_specificationContext); ok { + len++ + } + } + + tst := make([]ILevel_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_specificationContext); ok { + tst[i] = t.(ILevel_specificationContext) + i++ + } + } + + return tst +} + +func (s *Levels_clauseContext) Level_specification(i int) ILevel_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_specificationContext) +} + +func (s *Levels_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Levels_clauseContext) Level_group_type() ILevel_group_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_group_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILevel_group_typeContext) +} + +func (s *Levels_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Levels_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Levels_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Levels_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Levels_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevels_clause(s) + } +} + +func (s *Levels_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevels_clause(s) + } +} + +func (s *Levels_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevels_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Levels_clause() (localctx ILevels_clauseContext) { + localctx = NewLevels_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 368, PlSqlParserRULE_levels_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5252) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5253) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5254) + p.Level_specification() + } + p.SetState(5259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5255) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5256) + p.Level_specification() + } + + p.SetState(5261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5262) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5263) + p.Level_group_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 +} + +// ILevel_specificationContext is an interface to support dynamic dispatch. +type ILevel_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsLevel_specificationContext differentiates from other interfaces. + IsLevel_specificationContext() +} + +type Level_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext + h IId_expressionContext + l IId_expressionContext +} + +func NewEmptyLevel_specificationContext() *Level_specificationContext { + var p = new(Level_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_specification + return p +} + +func InitEmptyLevel_specificationContext(p *Level_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_specification +} + +func (*Level_specificationContext) IsLevel_specificationContext() {} + +func NewLevel_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_specificationContext { + var p = new(Level_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_specification + + return p +} + +func (s *Level_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_specificationContext) GetD() IId_expressionContext { return s.d } + +func (s *Level_specificationContext) GetH() IId_expressionContext { return s.h } + +func (s *Level_specificationContext) GetL() IId_expressionContext { return s.l } + +func (s *Level_specificationContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Level_specificationContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Level_specificationContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Level_specificationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_specificationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_specificationContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Level_specificationContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_specificationContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Level_specificationContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Level_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_specification(s) + } +} + +func (s *Level_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_specification(s) + } +} + +func (s *Level_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevel_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Level_specification() (localctx ILevel_specificationContext) { + localctx = NewLevel_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 370, PlSqlParserRULE_level_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5265) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5274) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 406, p.GetParserRuleContext()) == 1 { + p.SetState(5269) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 405, p.GetParserRuleContext()) == 1 { + { + p.SetState(5266) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).d = _x + } + { + p.SetState(5267) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5271) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).h = _x + } + { + p.SetState(5272) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5276) + + var _x = p.Id_expression() + + localctx.(*Level_specificationContext).l = _x + } + { + p.SetState(5277) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_group_typeContext is an interface to support dynamic dispatch. +type ILevel_group_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // Getter signatures + DYNAMIC() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + USING() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsLevel_group_typeContext differentiates from other interfaces. + IsLevel_group_typeContext() +} + +type Level_group_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t IId_expressionContext +} + +func NewEmptyLevel_group_typeContext() *Level_group_typeContext { + var p = new(Level_group_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_group_type + return p +} + +func InitEmptyLevel_group_typeContext(p *Level_group_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_group_type +} + +func (*Level_group_typeContext) IsLevel_group_typeContext() {} + +func NewLevel_group_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_group_typeContext { + var p = new(Level_group_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_group_type + + return p +} + +func (s *Level_group_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_group_typeContext) GetT() IId_expressionContext { return s.t } + +func (s *Level_group_typeContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Level_group_typeContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC, 0) +} + +func (s *Level_group_typeContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Level_group_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Level_group_typeContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_group_typeContext) 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 *Level_group_typeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Level_group_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_group_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_group_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_group_type(s) + } +} + +func (s *Level_group_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_group_type(s) + } +} + +func (s *Level_group_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevel_group_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Level_group_type() (localctx ILevel_group_typeContext) { + localctx = NewLevel_group_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 372, PlSqlParserRULE_level_group_type) + p.SetState(5290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDYNAMIC: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5279) + p.Match(PlSqlParserDYNAMIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMATERIALIZED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5280) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5288) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 408, p.GetParserRuleContext()) == 1 { + { + p.SetState(5281) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5285) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 407, p.GetParserRuleContext()) == 1 { + { + p.SetState(5282) + p.Schema_name() + } + { + p.SetState(5283) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5287) + + var _x = p.Id_expression() + + localctx.(*Level_group_typeContext).t = _x + } + + } 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 +} + +// IFact_columns_clauseContext is an interface to support dynamic dispatch. +type IFact_columns_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetF returns the f rule contexts. + GetF() IColumn_nameContext + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetF sets the f rule contexts. + SetF(IColumn_nameContext) + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + FACT() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFact_columns_clauseContext differentiates from other interfaces. + IsFact_columns_clauseContext() +} + +type Fact_columns_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + f IColumn_nameContext + fa IId_expressionContext +} + +func NewEmptyFact_columns_clauseContext() *Fact_columns_clauseContext { + var p = new(Fact_columns_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fact_columns_clause + return p +} + +func InitEmptyFact_columns_clauseContext(p *Fact_columns_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fact_columns_clause +} + +func (*Fact_columns_clauseContext) IsFact_columns_clauseContext() {} + +func NewFact_columns_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fact_columns_clauseContext { + var p = new(Fact_columns_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fact_columns_clause + + return p +} + +func (s *Fact_columns_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fact_columns_clauseContext) GetF() IColumn_nameContext { return s.f } + +func (s *Fact_columns_clauseContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Fact_columns_clauseContext) SetF(v IColumn_nameContext) { s.f = v } + +func (s *Fact_columns_clauseContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Fact_columns_clauseContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Fact_columns_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Fact_columns_clauseContext) 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 *Fact_columns_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Fact_columns_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Fact_columns_clauseContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Fact_columns_clauseContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Fact_columns_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Fact_columns_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Fact_columns_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fact_columns_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fact_columns_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFact_columns_clause(s) + } +} + +func (s *Fact_columns_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFact_columns_clause(s) + } +} + +func (s *Fact_columns_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFact_columns_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Fact_columns_clause() (localctx IFact_columns_clauseContext) { + localctx = NewFact_columns_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 374, PlSqlParserRULE_fact_columns_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5292) + p.Match(PlSqlParserFACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5293) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5294) + + var _x = p.Column_name() + + localctx.(*Fact_columns_clauseContext).f = _x + } + p.SetState(5309) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 413, p.GetParserRuleContext()) == 1 { + p.SetState(5296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5295) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5298) + + var _x = p.Id_expression() + + localctx.(*Fact_columns_clauseContext).fa = _x + } + p.SetState(5306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5299) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5300) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5303) + + var _x = p.Id_expression() + + localctx.(*Fact_columns_clauseContext).fa = _x + } + + } + p.SetState(5308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 412, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQry_transform_clauseContext is an interface to support dynamic dispatch. +type IQry_transform_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + QUERY() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + + // IsQry_transform_clauseContext differentiates from other interfaces. + IsQry_transform_clauseContext() +} + +type Qry_transform_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQry_transform_clauseContext() *Qry_transform_clauseContext { + var p = new(Qry_transform_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qry_transform_clause + return p +} + +func InitEmptyQry_transform_clauseContext(p *Qry_transform_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qry_transform_clause +} + +func (*Qry_transform_clauseContext) IsQry_transform_clauseContext() {} + +func NewQry_transform_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qry_transform_clauseContext { + var p = new(Qry_transform_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qry_transform_clause + + return p +} + +func (s *Qry_transform_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qry_transform_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Qry_transform_clauseContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Qry_transform_clauseContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM, 0) +} + +func (s *Qry_transform_clauseContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Qry_transform_clauseContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Qry_transform_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qry_transform_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qry_transform_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQry_transform_clause(s) + } +} + +func (s *Qry_transform_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQry_transform_clause(s) + } +} + +func (s *Qry_transform_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQry_transform_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Qry_transform_clause() (localctx IQry_transform_clauseContext) { + localctx = NewQry_transform_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 376, PlSqlParserRULE_qry_transform_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5311) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5312) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5313) + p.Match(PlSqlParserTRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5315) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 414, p.GetParserRuleContext()) == 1 { + { + p.SetState(5314) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + 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 +} + +// ICreate_attribute_dimensionContext is an interface to support dynamic dispatch. +type ICreate_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + AllDIMENSION() []antlr.TerminalNode + DIMENSION(i int) antlr.TerminalNode + Ad_using_clause() IAd_using_clauseContext + Attributes_clause() IAttributes_clauseContext + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + TYPE() antlr.TerminalNode + AllAd_level_clause() []IAd_level_clauseContext + Ad_level_clause(i int) IAd_level_clauseContext + All_clause() IAll_clauseContext + NOFORCE() antlr.TerminalNode + FORCE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + STANDARD() antlr.TerminalNode + TIME() antlr.TerminalNode + + // IsCreate_attribute_dimensionContext differentiates from other interfaces. + IsCreate_attribute_dimensionContext() +} + +type Create_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyCreate_attribute_dimensionContext() *Create_attribute_dimensionContext { + var p = new(Create_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension + return p +} + +func InitEmptyCreate_attribute_dimensionContext(p *Create_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension +} + +func (*Create_attribute_dimensionContext) IsCreate_attribute_dimensionContext() {} + +func NewCreate_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_attribute_dimensionContext { + var p = new(Create_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_attribute_dimension + + return p +} + +func (s *Create_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Create_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Create_attribute_dimensionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Create_attribute_dimensionContext) AllDIMENSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDIMENSION) +} + +func (s *Create_attribute_dimensionContext) DIMENSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, i) +} + +func (s *Create_attribute_dimensionContext) Ad_using_clause() IAd_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAd_using_clauseContext) +} + +func (s *Create_attribute_dimensionContext) Attributes_clause() IAttributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttributes_clauseContext) +} + +func (s *Create_attribute_dimensionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_attribute_dimensionContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_attribute_dimensionContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_attribute_dimensionContext) 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_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_attribute_dimensionContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_attribute_dimensionContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_attribute_dimensionContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_attribute_dimensionContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_attribute_dimensionContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Create_attribute_dimensionContext) AllAd_level_clause() []IAd_level_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAd_level_clauseContext); ok { + len++ + } + } + + tst := make([]IAd_level_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAd_level_clauseContext); ok { + tst[i] = t.(IAd_level_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_attribute_dimensionContext) Ad_level_clause(i int) IAd_level_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_level_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAd_level_clauseContext) +} + +func (s *Create_attribute_dimensionContext) All_clause() IAll_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAll_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAll_clauseContext) +} + +func (s *Create_attribute_dimensionContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_attribute_dimensionContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_attribute_dimensionContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_attribute_dimensionContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_attribute_dimensionContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Create_attribute_dimensionContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Create_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_attribute_dimension(s) + } +} + +func (s *Create_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_attribute_dimension(s) + } +} + +func (s *Create_attribute_dimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_attribute_dimension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_attribute_dimension() (localctx ICreate_attribute_dimensionContext) { + localctx = NewCreate_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 378, PlSqlParserRULE_create_attribute_dimension) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5317) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(5318) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5319) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE { + { + p.SetState(5322) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFORCE || _la == PlSqlParserNOFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5325) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5326) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5330) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 417, p.GetParserRuleContext()) == 1 { + { + p.SetState(5327) + p.Schema_name() + } + { + p.SetState(5328) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5332) + + var _x = p.Id_expression() + + localctx.(*Create_attribute_dimensionContext).ad = _x + } + p.SetState(5336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(5333) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5334) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5335) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5341) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5338) + p.Classification_clause() + } + + p.SetState(5343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDIMENSION { + { + p.SetState(5344) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5345) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5346) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSTANDARD || _la == PlSqlParserTIME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5349) + p.Ad_using_clause() + } + { + p.SetState(5350) + p.Attributes_clause() + } + p.SetState(5352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(5351) + p.Ad_level_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5354) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 421, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5357) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 422, p.GetParserRuleContext()) == 1 { + { + p.SetState(5356) + p.All_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 +} + +// IAd_using_clauseContext is an interface to support dynamic dispatch. +type IAd_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + AllSource_clause() []ISource_clauseContext + Source_clause(i int) ISource_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllJoin_path_clause() []IJoin_path_clauseContext + Join_path_clause(i int) IJoin_path_clauseContext + + // IsAd_using_clauseContext differentiates from other interfaces. + IsAd_using_clauseContext() +} + +type Ad_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAd_using_clauseContext() *Ad_using_clauseContext { + var p = new(Ad_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_using_clause + return p +} + +func InitEmptyAd_using_clauseContext(p *Ad_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_using_clause +} + +func (*Ad_using_clauseContext) IsAd_using_clauseContext() {} + +func NewAd_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_using_clauseContext { + var p = new(Ad_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_using_clause + + return p +} + +func (s *Ad_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Ad_using_clauseContext) AllSource_clause() []ISource_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISource_clauseContext); ok { + len++ + } + } + + tst := make([]ISource_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISource_clauseContext); ok { + tst[i] = t.(ISource_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_using_clauseContext) Source_clause(i int) ISource_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISource_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISource_clauseContext) +} + +func (s *Ad_using_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ad_using_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ad_using_clauseContext) AllJoin_path_clause() []IJoin_path_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_path_clauseContext); ok { + len++ + } + } + + tst := make([]IJoin_path_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_path_clauseContext); ok { + tst[i] = t.(IJoin_path_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_using_clauseContext) Join_path_clause(i int) IJoin_path_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_path_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_path_clauseContext) +} + +func (s *Ad_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_using_clause(s) + } +} + +func (s *Ad_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_using_clause(s) + } +} + +func (s *Ad_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAd_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ad_using_clause() (localctx IAd_using_clauseContext) { + localctx = NewAd_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 380, PlSqlParserRULE_ad_using_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5359) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5360) + p.Source_clause() + } + p.SetState(5365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5361) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5362) + p.Source_clause() + } + + p.SetState(5367) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(5371) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserJOIN { + { + p.SetState(5368) + p.Join_path_clause() + } + + p.SetState(5373) + 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 +} + +// ISource_clauseContext is an interface to support dynamic dispatch. +type ISource_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFtov returns the ftov rule contexts. + GetFtov() IId_expressionContext + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetFtov sets the ftov rule contexts. + SetFtov(IId_expressionContext) + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + REMOTE() antlr.TerminalNode + AS() antlr.TerminalNode + + // IsSource_clauseContext differentiates from other interfaces. + IsSource_clauseContext() +} + +type Source_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ftov IId_expressionContext + a IId_expressionContext +} + +func NewEmptySource_clauseContext() *Source_clauseContext { + var p = new(Source_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_clause + return p +} + +func InitEmptySource_clauseContext(p *Source_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_clause +} + +func (*Source_clauseContext) IsSource_clauseContext() {} + +func NewSource_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Source_clauseContext { + var p = new(Source_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_source_clause + + return p +} + +func (s *Source_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Source_clauseContext) GetFtov() IId_expressionContext { return s.ftov } + +func (s *Source_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Source_clauseContext) SetFtov(v IId_expressionContext) { s.ftov = v } + +func (s *Source_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Source_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Source_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Source_clauseContext) 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 *Source_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Source_clauseContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Source_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Source_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Source_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Source_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSource_clause(s) + } +} + +func (s *Source_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSource_clause(s) + } +} + +func (s *Source_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSource_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Source_clause() (localctx ISource_clauseContext) { + localctx = NewSource_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 382, PlSqlParserRULE_source_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5377) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 425, p.GetParserRuleContext()) == 1 { + { + p.SetState(5374) + p.Schema_name() + } + { + p.SetState(5375) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5379) + + var _x = p.Id_expression() + + localctx.(*Source_clauseContext).ftov = _x + } + p.SetState(5381) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 426, p.GetParserRuleContext()) == 1 { + { + p.SetState(5380) + p.Match(PlSqlParserREMOTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5387) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 428, p.GetParserRuleContext()) == 1 { + p.SetState(5384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5383) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5386) + + var _x = p.Id_expression() + + localctx.(*Source_clauseContext).a = _x + } + + } 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 +} + +// IJoin_path_clauseContext is an interface to support dynamic dispatch. +type IJoin_path_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJpn returns the jpn rule contexts. + GetJpn() IId_expressionContext + + // SetJpn sets the jpn rule contexts. + SetJpn(IId_expressionContext) + + // Getter signatures + JOIN() antlr.TerminalNode + PATH() antlr.TerminalNode + ON() antlr.TerminalNode + Join_condition() IJoin_conditionContext + Id_expression() IId_expressionContext + + // IsJoin_path_clauseContext differentiates from other interfaces. + IsJoin_path_clauseContext() +} + +type Join_path_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jpn IId_expressionContext +} + +func NewEmptyJoin_path_clauseContext() *Join_path_clauseContext { + var p = new(Join_path_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_path_clause + return p +} + +func InitEmptyJoin_path_clauseContext(p *Join_path_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_path_clause +} + +func (*Join_path_clauseContext) IsJoin_path_clauseContext() {} + +func NewJoin_path_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_path_clauseContext { + var p = new(Join_path_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_path_clause + + return p +} + +func (s *Join_path_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_path_clauseContext) GetJpn() IId_expressionContext { return s.jpn } + +func (s *Join_path_clauseContext) SetJpn(v IId_expressionContext) { s.jpn = v } + +func (s *Join_path_clauseContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Join_path_clauseContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Join_path_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Join_path_clauseContext) Join_condition() IJoin_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJoin_conditionContext) +} + +func (s *Join_path_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Join_path_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_path_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_path_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_path_clause(s) + } +} + +func (s *Join_path_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_path_clause(s) + } +} + +func (s *Join_path_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_path_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_path_clause() (localctx IJoin_path_clauseContext) { + localctx = NewJoin_path_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 384, PlSqlParserRULE_join_path_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5389) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5390) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5391) + + var _x = p.Id_expression() + + localctx.(*Join_path_clauseContext).jpn = _x + } + { + p.SetState(5392) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5393) + p.Join_condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_conditionContext is an interface to support dynamic dispatch. +type IJoin_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJoin_condition_item() []IJoin_condition_itemContext + Join_condition_item(i int) IJoin_condition_itemContext + AllAND() []antlr.TerminalNode + AND(i int) antlr.TerminalNode + + // IsJoin_conditionContext differentiates from other interfaces. + IsJoin_conditionContext() +} + +type Join_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_conditionContext() *Join_conditionContext { + var p = new(Join_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition + return p +} + +func InitEmptyJoin_conditionContext(p *Join_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition +} + +func (*Join_conditionContext) IsJoin_conditionContext() {} + +func NewJoin_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_conditionContext { + var p = new(Join_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_condition + + return p +} + +func (s *Join_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_conditionContext) AllJoin_condition_item() []IJoin_condition_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_condition_itemContext); ok { + len++ + } + } + + tst := make([]IJoin_condition_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_condition_itemContext); ok { + tst[i] = t.(IJoin_condition_itemContext) + i++ + } + } + + return tst +} + +func (s *Join_conditionContext) Join_condition_item(i int) IJoin_condition_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_condition_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_condition_itemContext) +} + +func (s *Join_conditionContext) AllAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAND) +} + +func (s *Join_conditionContext) AND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, i) +} + +func (s *Join_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_condition(s) + } +} + +func (s *Join_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_condition(s) + } +} + +func (s *Join_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_condition() (localctx IJoin_conditionContext) { + localctx = NewJoin_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 386, PlSqlParserRULE_join_condition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5395) + p.Join_condition_item() + } + p.SetState(5400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserAND { + { + p.SetState(5396) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5397) + p.Join_condition_item() + } + + p.SetState(5402) + 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 +} + +// IJoin_condition_itemContext is an interface to support dynamic dispatch. +type IJoin_condition_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetB returns the b rule contexts. + GetB() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetB sets the b rule contexts. + SetB(IId_expressionContext) + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsJoin_condition_itemContext differentiates from other interfaces. + IsJoin_condition_itemContext() +} + +type Join_condition_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + b IId_expressionContext +} + +func NewEmptyJoin_condition_itemContext() *Join_condition_itemContext { + var p = new(Join_condition_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition_item + return p +} + +func InitEmptyJoin_condition_itemContext(p *Join_condition_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_condition_item +} + +func (*Join_condition_itemContext) IsJoin_condition_itemContext() {} + +func NewJoin_condition_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_condition_itemContext { + var p = new(Join_condition_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_condition_item + + return p +} + +func (s *Join_condition_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_condition_itemContext) GetA() IId_expressionContext { return s.a } + +func (s *Join_condition_itemContext) GetB() IId_expressionContext { return s.b } + +func (s *Join_condition_itemContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Join_condition_itemContext) SetB(v IId_expressionContext) { s.b = v } + +func (s *Join_condition_itemContext) 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 *Join_condition_itemContext) 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 *Join_condition_itemContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Join_condition_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Join_condition_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Join_condition_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Join_condition_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Join_condition_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_condition_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_condition_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_condition_item(s) + } +} + +func (s *Join_condition_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_condition_item(s) + } +} + +func (s *Join_condition_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_condition_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_condition_item() (localctx IJoin_condition_itemContext) { + localctx = NewJoin_condition_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 388, PlSqlParserRULE_join_condition_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(5406) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 430, p.GetParserRuleContext()) == 1 { + { + p.SetState(5403) + + var _x = p.Id_expression() + + localctx.(*Join_condition_itemContext).a = _x + } + { + p.SetState(5404) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5408) + p.Column_name() + } + { + p.SetState(5409) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5413) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 431, p.GetParserRuleContext()) == 1 { + { + p.SetState(5410) + + var _x = p.Id_expression() + + localctx.(*Join_condition_itemContext).b = _x + } + { + p.SetState(5411) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5415) + p.Column_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 +} + +// IAttributes_clauseContext is an interface to support dynamic dispatch. +type IAttributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllAd_attributes_clause() []IAd_attributes_clauseContext + Ad_attributes_clause(i int) IAd_attributes_clauseContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAttributes_clauseContext differentiates from other interfaces. + IsAttributes_clauseContext() +} + +type Attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttributes_clauseContext() *Attributes_clauseContext { + var p = new(Attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attributes_clause + return p +} + +func InitEmptyAttributes_clauseContext(p *Attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attributes_clause +} + +func (*Attributes_clauseContext) IsAttributes_clauseContext() {} + +func NewAttributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attributes_clauseContext { + var p = new(Attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attributes_clause + + return p +} + +func (s *Attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attributes_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Attributes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Attributes_clauseContext) AllAd_attributes_clause() []IAd_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAd_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IAd_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAd_attributes_clauseContext); ok { + tst[i] = t.(IAd_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Attributes_clauseContext) Ad_attributes_clause(i int) IAd_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAd_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAd_attributes_clauseContext) +} + +func (s *Attributes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Attributes_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Attributes_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttributes_clause(s) + } +} + +func (s *Attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttributes_clause(s) + } +} + +func (s *Attributes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAttributes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Attributes_clause() (localctx IAttributes_clauseContext) { + localctx = NewAttributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 390, PlSqlParserRULE_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5417) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5418) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5419) + p.Ad_attributes_clause() + } + p.SetState(5424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5420) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5421) + p.Ad_attributes_clause() + } + + p.SetState(5426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5427) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAd_attributes_clauseContext is an interface to support dynamic dispatch. +type IAd_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // GetAn returns the an rule contexts. + GetAn() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // SetAn sets the an rule contexts. + SetAn(IId_expressionContext) + + // Getter signatures + Column_name() IColumn_nameContext + PERIOD() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AS() antlr.TerminalNode + + // IsAd_attributes_clauseContext differentiates from other interfaces. + IsAd_attributes_clauseContext() +} + +type Ad_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext + an IId_expressionContext +} + +func NewEmptyAd_attributes_clauseContext() *Ad_attributes_clauseContext { + var p = new(Ad_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause + return p +} + +func InitEmptyAd_attributes_clauseContext(p *Ad_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause +} + +func (*Ad_attributes_clauseContext) IsAd_attributes_clauseContext() {} + +func NewAd_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_attributes_clauseContext { + var p = new(Ad_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_attributes_clause + + return p +} + +func (s *Ad_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_attributes_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Ad_attributes_clauseContext) GetAn() IId_expressionContext { return s.an } + +func (s *Ad_attributes_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Ad_attributes_clauseContext) SetAn(v IId_expressionContext) { s.an = v } + +func (s *Ad_attributes_clauseContext) 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 *Ad_attributes_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Ad_attributes_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_attributes_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Ad_attributes_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_attributes_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Ad_attributes_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Ad_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_attributes_clause(s) + } +} + +func (s *Ad_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_attributes_clause(s) + } +} + +func (s *Ad_attributes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAd_attributes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ad_attributes_clause() (localctx IAd_attributes_clauseContext) { + localctx = NewAd_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 392, PlSqlParserRULE_ad_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5432) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 433, p.GetParserRuleContext()) == 1 { + { + p.SetState(5429) + + var _x = p.Id_expression() + + localctx.(*Ad_attributes_clauseContext).a = _x + } + { + p.SetState(5430) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5434) + p.Column_name() + } + p.SetState(5439) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 435, p.GetParserRuleContext()) == 1 { + p.SetState(5436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(5435) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5438) + + var _x = p.Id_expression() + + localctx.(*Ad_attributes_clauseContext).an = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5441) + p.Classification_clause() + } + + p.SetState(5446) + 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 +} + +// IAd_level_clauseContext is an interface to support dynamic dispatch. +type IAd_level_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + Key_clause() IKey_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + SKIP_() antlr.TerminalNode + WHEN() antlr.TerminalNode + TYPE() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Alternate_key_clause() IAlternate_key_clauseContext + AllMEMBER() []antlr.TerminalNode + MEMBER(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + CAPTION() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + AllDim_order_clause() []IDim_order_clauseContext + Dim_order_clause(i int) IDim_order_clauseContext + DETERMINES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + STANDARD() antlr.TerminalNode + YEARS() antlr.TerminalNode + HALF_YEARS() antlr.TerminalNode + QUARTERS() antlr.TerminalNode + MONTHS() antlr.TerminalNode + WEEKS() antlr.TerminalNode + DAYS() antlr.TerminalNode + HOURS() antlr.TerminalNode + MINUTES() antlr.TerminalNode + SECONDS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllMIN() []antlr.TerminalNode + MIN(i int) antlr.TerminalNode + AllMAX() []antlr.TerminalNode + MAX(i int) antlr.TerminalNode + + // IsAd_level_clauseContext differentiates from other interfaces. + IsAd_level_clauseContext() +} + +type Ad_level_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + l IId_expressionContext +} + +func NewEmptyAd_level_clauseContext() *Ad_level_clauseContext { + var p = new(Ad_level_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_level_clause + return p +} + +func InitEmptyAd_level_clauseContext(p *Ad_level_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ad_level_clause +} + +func (*Ad_level_clauseContext) IsAd_level_clauseContext() {} + +func NewAd_level_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ad_level_clauseContext { + var p = new(Ad_level_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ad_level_clause + + return p +} + +func (s *Ad_level_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ad_level_clauseContext) GetL() IId_expressionContext { return s.l } + +func (s *Ad_level_clauseContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Ad_level_clauseContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Ad_level_clauseContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Ad_level_clauseContext) Key_clause() IKey_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_clauseContext) +} + +func (s *Ad_level_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Ad_level_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Ad_level_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Ad_level_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Ad_level_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Ad_level_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Ad_level_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Ad_level_clauseContext) Alternate_key_clause() IAlternate_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlternate_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlternate_key_clauseContext) +} + +func (s *Ad_level_clauseContext) AllMEMBER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMEMBER) +} + +func (s *Ad_level_clauseContext) MEMBER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, i) +} + +func (s *Ad_level_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Ad_level_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Ad_level_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Ad_level_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Ad_level_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Ad_level_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Ad_level_clauseContext) AllDim_order_clause() []IDim_order_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDim_order_clauseContext); ok { + len++ + } + } + + tst := make([]IDim_order_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDim_order_clauseContext); ok { + tst[i] = t.(IDim_order_clauseContext) + i++ + } + } + + return tst +} + +func (s *Ad_level_clauseContext) Dim_order_clause(i int) IDim_order_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDim_order_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDim_order_clauseContext) +} + +func (s *Ad_level_clauseContext) DETERMINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, 0) +} + +func (s *Ad_level_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Ad_level_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Ad_level_clauseContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Ad_level_clauseContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Ad_level_clauseContext) HALF_YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHALF_YEARS, 0) +} + +func (s *Ad_level_clauseContext) QUARTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUARTERS, 0) +} + +func (s *Ad_level_clauseContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Ad_level_clauseContext) WEEKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEKS, 0) +} + +func (s *Ad_level_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Ad_level_clauseContext) HOURS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOURS, 0) +} + +func (s *Ad_level_clauseContext) MINUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTES, 0) +} + +func (s *Ad_level_clauseContext) SECONDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECONDS, 0) +} + +func (s *Ad_level_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ad_level_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ad_level_clauseContext) AllMIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMIN) +} + +func (s *Ad_level_clauseContext) MIN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, i) +} + +func (s *Ad_level_clauseContext) AllMAX() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAX) +} + +func (s *Ad_level_clauseContext) MAX(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, i) +} + +func (s *Ad_level_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ad_level_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ad_level_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAd_level_clause(s) + } +} + +func (s *Ad_level_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAd_level_clause(s) + } +} + +func (s *Ad_level_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAd_level_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ad_level_clause() (localctx IAd_level_clauseContext) { + localctx = NewAd_level_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 394, PlSqlParserRULE_ad_level_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5447) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5448) + + var _x = p.Id_expression() + + localctx.(*Ad_level_clauseContext).l = _x + } + p.SetState(5454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT: + { + p.SetState(5449) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5450) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSKIP_: + { + p.SetState(5451) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5452) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5453) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCAPTION, PlSqlParserCLASSIFICATION, PlSqlParserDESCRIPTION, PlSqlParserKEY, PlSqlParserLEVEL: + + default: + } + p.SetState(5459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEVEL { + { + p.SetState(5456) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5457) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5458) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAYS || _la == PlSqlParserHALF_YEARS || _la == PlSqlParserHOURS || _la == PlSqlParserMINUTES || _la == PlSqlParserMONTHS || _la == PlSqlParserQUARTERS || _la == PlSqlParserSECONDS || _la == PlSqlParserSTANDARD || _la == PlSqlParserWEEKS || _la == PlSqlParserYEARS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5464) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5461) + p.Classification_clause() + } + + p.SetState(5466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5467) + p.Key_clause() + } + p.SetState(5469) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 440, p.GetParserRuleContext()) == 1 { + { + p.SetState(5468) + p.Alternate_key_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5474) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 441, p.GetParserRuleContext()) == 1 { + { + p.SetState(5471) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5472) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5473) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5479) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 442, p.GetParserRuleContext()) == 1 { + { + p.SetState(5476) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5477) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5478) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5484) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 443, p.GetParserRuleContext()) == 1 { + { + p.SetState(5481) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5482) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5483) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5502) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 447, p.GetParserRuleContext()) == 1 { + { + p.SetState(5486) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5487) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5489) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 444, p.GetParserRuleContext()) == 1 { + { + p.SetState(5488) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAX || _la == PlSqlParserMIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5491) + p.Dim_order_clause() + } + p.SetState(5499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 446, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5492) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5494) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 445, p.GetParserRuleContext()) == 1 { + { + p.SetState(5493) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAX || _la == PlSqlParserMIN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5496) + p.Dim_order_clause() + } + + } + p.SetState(5501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 446, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5516) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 449, p.GetParserRuleContext()) == 1 { + { + p.SetState(5504) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5505) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5506) + p.Id_expression() + } + p.SetState(5511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5507) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5508) + p.Id_expression() + } + + p.SetState(5513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5514) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKey_clauseContext is an interface to support dynamic dispatch. +type IKey_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + KEY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsKey_clauseContext differentiates from other interfaces. + IsKey_clauseContext() +} + +type Key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext +} + +func NewEmptyKey_clauseContext() *Key_clauseContext { + var p = new(Key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_clause + return p +} + +func InitEmptyKey_clauseContext(p *Key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_clause +} + +func (*Key_clauseContext) IsKey_clauseContext() {} + +func NewKey_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_clauseContext { + var p = new(Key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_clause + + return p +} + +func (s *Key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Key_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Key_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Key_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Key_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Key_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Key_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Key_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Key_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_clause(s) + } +} + +func (s *Key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_clause(s) + } +} + +func (s *Key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKey_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Key_clause() (localctx IKey_clauseContext) { + localctx = NewKey_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 396, PlSqlParserRULE_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5518) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(5519) + + var _x = p.Id_expression() + + localctx.(*Key_clauseContext).a = _x + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(5520) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5521) + p.Id_expression() + } + p.SetState(5526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5522) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5523) + p.Id_expression() + } + + p.SetState(5528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5529) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlternate_key_clauseContext is an interface to support dynamic dispatch. +type IAlternate_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTERNATE() antlr.TerminalNode + Key_clause() IKey_clauseContext + + // IsAlternate_key_clauseContext differentiates from other interfaces. + IsAlternate_key_clauseContext() +} + +type Alternate_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlternate_key_clauseContext() *Alternate_key_clauseContext { + var p = new(Alternate_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alternate_key_clause + return p +} + +func InitEmptyAlternate_key_clauseContext(p *Alternate_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alternate_key_clause +} + +func (*Alternate_key_clauseContext) IsAlternate_key_clauseContext() {} + +func NewAlternate_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alternate_key_clauseContext { + var p = new(Alternate_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alternate_key_clause + + return p +} + +func (s *Alternate_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alternate_key_clauseContext) ALTERNATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTERNATE, 0) +} + +func (s *Alternate_key_clauseContext) Key_clause() IKey_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_clauseContext) +} + +func (s *Alternate_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alternate_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alternate_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlternate_key_clause(s) + } +} + +func (s *Alternate_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlternate_key_clause(s) + } +} + +func (s *Alternate_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlternate_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alternate_key_clause() (localctx IAlternate_key_clauseContext) { + localctx = NewAlternate_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 398, PlSqlParserRULE_alternate_key_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5533) + p.Match(PlSqlParserALTERNATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5534) + p.Key_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 +} + +// IDim_order_clauseContext is an interface to support dynamic dispatch. +type IDim_order_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetA returns the a rule contexts. + GetA() IId_expressionContext + + // SetA sets the a rule contexts. + SetA(IId_expressionContext) + + // Getter signatures + Id_expression() IId_expressionContext + NULLS() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsDim_order_clauseContext differentiates from other interfaces. + IsDim_order_clauseContext() +} + +type Dim_order_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + a IId_expressionContext +} + +func NewEmptyDim_order_clauseContext() *Dim_order_clauseContext { + var p = new(Dim_order_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_order_clause + return p +} + +func InitEmptyDim_order_clauseContext(p *Dim_order_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dim_order_clause +} + +func (*Dim_order_clauseContext) IsDim_order_clauseContext() {} + +func NewDim_order_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dim_order_clauseContext { + var p = new(Dim_order_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dim_order_clause + + return p +} + +func (s *Dim_order_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dim_order_clauseContext) GetA() IId_expressionContext { return s.a } + +func (s *Dim_order_clauseContext) SetA(v IId_expressionContext) { s.a = v } + +func (s *Dim_order_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dim_order_clauseContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Dim_order_clauseContext) ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, 0) +} + +func (s *Dim_order_clauseContext) DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, 0) +} + +func (s *Dim_order_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Dim_order_clauseContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Dim_order_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dim_order_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dim_order_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDim_order_clause(s) + } +} + +func (s *Dim_order_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDim_order_clause(s) + } +} + +func (s *Dim_order_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDim_order_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dim_order_clause() (localctx IDim_order_clauseContext) { + localctx = NewDim_order_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 400, PlSqlParserRULE_dim_order_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5536) + + var _x = p.Id_expression() + + localctx.(*Dim_order_clauseContext).a = _x + } + p.SetState(5538) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 452, p.GetParserRuleContext()) == 1 { + { + p.SetState(5537) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5542) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 453, p.GetParserRuleContext()) == 1 { + { + p.SetState(5540) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5541) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + 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 +} + +// IAll_clauseContext is an interface to support dynamic dispatch. +type IAll_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + AllMEMBER() []antlr.TerminalNode + MEMBER(i int) antlr.TerminalNode + NAME() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + CAPTION() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + + // IsAll_clauseContext differentiates from other interfaces. + IsAll_clauseContext() +} + +type All_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAll_clauseContext() *All_clauseContext { + var p = new(All_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_all_clause + return p +} + +func InitEmptyAll_clauseContext(p *All_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_all_clause +} + +func (*All_clauseContext) IsAll_clauseContext() {} + +func NewAll_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *All_clauseContext { + var p = new(All_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_all_clause + + return p +} + +func (s *All_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *All_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *All_clauseContext) AllMEMBER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMEMBER) +} + +func (s *All_clauseContext) MEMBER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, i) +} + +func (s *All_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *All_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *All_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *All_clauseContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *All_clauseContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *All_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *All_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *All_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAll_clause(s) + } +} + +func (s *All_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAll_clause(s) + } +} + +func (s *All_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAll_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) All_clause() (localctx IAll_clauseContext) { + localctx = NewAll_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 402, PlSqlParserRULE_all_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5544) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5545) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNAME: + { + p.SetState(5546) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5547) + p.Expression() + } + p.SetState(5551) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 454, p.GetParserRuleContext()) == 1 { + { + p.SetState(5548) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5549) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5550) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCAPTION: + { + p.SetState(5553) + p.Match(PlSqlParserCAPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5554) + p.Expression() + } + p.SetState(5558) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 455, p.GetParserRuleContext()) == 1 { + { + p.SetState(5555) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5556) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5557) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserDESCRIPTION: + { + p.SetState(5560) + p.Match(PlSqlParserDESCRIPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5561) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_audit_policyContext is an interface to support dynamic dispatch. +type ICreate_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + Privilege_audit_clause() IPrivilege_audit_clauseContext + Action_audit_clause() IAction_audit_clauseContext + Role_audit_clause() IRole_audit_clauseContext + WHEN() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + EVALUATE() antlr.TerminalNode + PER() antlr.TerminalNode + ONLY() antlr.TerminalNode + TOPLEVEL() antlr.TerminalNode + Container_clause() IContainer_clauseContext + STATEMENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + + // IsCreate_audit_policyContext differentiates from other interfaces. + IsCreate_audit_policyContext() +} + +type Create_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyCreate_audit_policyContext() *Create_audit_policyContext { + var p = new(Create_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_audit_policy + return p +} + +func InitEmptyCreate_audit_policyContext(p *Create_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_audit_policy +} + +func (*Create_audit_policyContext) IsCreate_audit_policyContext() {} + +func NewCreate_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_audit_policyContext { + var p = new(Create_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_audit_policy + + return p +} + +func (s *Create_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Create_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Create_audit_policyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Create_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Create_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_audit_policyContext) Privilege_audit_clause() IPrivilege_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_audit_clauseContext) +} + +func (s *Create_audit_policyContext) Action_audit_clause() IAction_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAction_audit_clauseContext) +} + +func (s *Create_audit_policyContext) Role_audit_clause() IRole_audit_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_audit_clauseContext) +} + +func (s *Create_audit_policyContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Create_audit_policyContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Create_audit_policyContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Create_audit_policyContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Create_audit_policyContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Create_audit_policyContext) TOPLEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, 0) +} + +func (s *Create_audit_policyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_audit_policyContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Create_audit_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Create_audit_policyContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Create_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_audit_policy(s) + } +} + +func (s *Create_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_audit_policy(s) + } +} + +func (s *Create_audit_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_audit_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_audit_policy() (localctx ICreate_audit_policyContext) { + localctx = NewCreate_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 404, PlSqlParserRULE_create_audit_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5564) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5565) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5566) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5567) + + var _x = p.Id_expression() + + localctx.(*Create_audit_policyContext).p = _x + } + p.SetState(5569) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 457, p.GetParserRuleContext()) == 1 { + { + p.SetState(5568) + p.Privilege_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5572) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 458, p.GetParserRuleContext()) == 1 { + { + p.SetState(5571) + p.Action_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5575) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 459, p.GetParserRuleContext()) == 1 { + { + p.SetState(5574) + p.Role_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5583) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 460, p.GetParserRuleContext()) == 1 { + { + p.SetState(5577) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5578) + p.Quoted_string() + } + { + p.SetState(5579) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5580) + p.Match(PlSqlParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5581) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINSTANCE || _la == PlSqlParserSESSION || _la == PlSqlParserSTATEMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 461, p.GetParserRuleContext()) == 1 { + { + p.SetState(5585) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5586) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 462, p.GetParserRuleContext()) == 1 { + { + p.SetState(5589) + p.Container_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 +} + +// IPrivilege_audit_clauseContext is an interface to support dynamic dispatch. +type IPrivilege_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIVILEGES() antlr.TerminalNode + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrivilege_audit_clauseContext differentiates from other interfaces. + IsPrivilege_audit_clauseContext() +} + +type Privilege_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrivilege_audit_clauseContext() *Privilege_audit_clauseContext { + var p = new(Privilege_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause + return p +} + +func InitEmptyPrivilege_audit_clauseContext(p *Privilege_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause +} + +func (*Privilege_audit_clauseContext) IsPrivilege_audit_clauseContext() {} + +func NewPrivilege_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Privilege_audit_clauseContext { + var p = new(Privilege_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_privilege_audit_clause + + return p +} + +func (s *Privilege_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Privilege_audit_clauseContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Privilege_audit_clauseContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Privilege_audit_clauseContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Privilege_audit_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Privilege_audit_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Privilege_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Privilege_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Privilege_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrivilege_audit_clause(s) + } +} + +func (s *Privilege_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrivilege_audit_clause(s) + } +} + +func (s *Privilege_audit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrivilege_audit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Privilege_audit_clause() (localctx IPrivilege_audit_clauseContext) { + localctx = NewPrivilege_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 406, PlSqlParserRULE_privilege_audit_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5592) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5593) + p.System_privilege() + } + p.SetState(5598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 463, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5594) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5595) + p.System_privilege() + } + + } + p.SetState(5600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 463, 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 +} + +// IAction_audit_clauseContext is an interface to support dynamic dispatch. +type IAction_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStandard_actions() []IStandard_actionsContext + Standard_actions(i int) IStandard_actionsContext + AllComponent_actions() []IComponent_actionsContext + Component_actions(i int) IComponent_actionsContext + + // IsAction_audit_clauseContext differentiates from other interfaces. + IsAction_audit_clauseContext() +} + +type Action_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAction_audit_clauseContext() *Action_audit_clauseContext { + var p = new(Action_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_action_audit_clause + return p +} + +func InitEmptyAction_audit_clauseContext(p *Action_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_action_audit_clause +} + +func (*Action_audit_clauseContext) IsAction_audit_clauseContext() {} + +func NewAction_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Action_audit_clauseContext { + var p = new(Action_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_action_audit_clause + + return p +} + +func (s *Action_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Action_audit_clauseContext) AllStandard_actions() []IStandard_actionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStandard_actionsContext); ok { + len++ + } + } + + tst := make([]IStandard_actionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStandard_actionsContext); ok { + tst[i] = t.(IStandard_actionsContext) + i++ + } + } + + return tst +} + +func (s *Action_audit_clauseContext) Standard_actions(i int) IStandard_actionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_actionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStandard_actionsContext) +} + +func (s *Action_audit_clauseContext) AllComponent_actions() []IComponent_actionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComponent_actionsContext); ok { + len++ + } + } + + tst := make([]IComponent_actionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComponent_actionsContext); ok { + tst[i] = t.(IComponent_actionsContext) + i++ + } + } + + return tst +} + +func (s *Action_audit_clauseContext) Component_actions(i int) IComponent_actionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComponent_actionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComponent_actionsContext) +} + +func (s *Action_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Action_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Action_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAction_audit_clause(s) + } +} + +func (s *Action_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAction_audit_clause(s) + } +} + +func (s *Action_audit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAction_audit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Action_audit_clause() (localctx IAction_audit_clauseContext) { + localctx = NewAction_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 408, PlSqlParserRULE_action_audit_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(5603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(5603) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 464, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5601) + p.Standard_actions() + } + + case 2: + { + p.SetState(5602) + p.Component_actions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5605) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 465, 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 +} + +// IStandard_actionsContext is an interface to support dynamic dispatch. +type IStandard_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + AllActions_clause() []IActions_clauseContext + Actions_clause(i int) IActions_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsStandard_actionsContext differentiates from other interfaces. + IsStandard_actionsContext() +} + +type Standard_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_actionsContext() *Standard_actionsContext { + var p = new(Standard_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_actions + return p +} + +func InitEmptyStandard_actionsContext(p *Standard_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_actions +} + +func (*Standard_actionsContext) IsStandard_actionsContext() {} + +func NewStandard_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_actionsContext { + var p = new(Standard_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_actions + + return p +} + +func (s *Standard_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_actionsContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Standard_actionsContext) AllActions_clause() []IActions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IActions_clauseContext); ok { + len++ + } + } + + tst := make([]IActions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IActions_clauseContext); ok { + tst[i] = t.(IActions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Standard_actionsContext) Actions_clause(i int) IActions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IActions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IActions_clauseContext) +} + +func (s *Standard_actionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Standard_actionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Standard_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_actions(s) + } +} + +func (s *Standard_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_actions(s) + } +} + +func (s *Standard_actionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStandard_actions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Standard_actions() (localctx IStandard_actionsContext) { + localctx = NewStandard_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 410, PlSqlParserRULE_standard_actions) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5607) + p.Match(PlSqlParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5608) + p.Actions_clause() + } + p.SetState(5613) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5609) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5610) + p.Actions_clause() + } + + } + p.SetState(5615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 466, 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 +} + +// IActions_clauseContext is an interface to support dynamic dispatch. +type IActions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Object_action() IObject_actionContext + ALL() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + Id_expression() IId_expressionContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + System_action() ISystem_actionContext + + // IsActions_clauseContext differentiates from other interfaces. + IsActions_clauseContext() +} + +type Actions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyActions_clauseContext() *Actions_clauseContext { + var p = new(Actions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_actions_clause + return p +} + +func InitEmptyActions_clauseContext(p *Actions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_actions_clause +} + +func (*Actions_clauseContext) IsActions_clauseContext() {} + +func NewActions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Actions_clauseContext { + var p = new(Actions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_actions_clause + + return p +} + +func (s *Actions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Actions_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Actions_clauseContext) Object_action() IObject_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_actionContext) +} + +func (s *Actions_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Actions_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Actions_clauseContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Actions_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Actions_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Actions_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Actions_clauseContext) 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 *Actions_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Actions_clauseContext) System_action() ISystem_actionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_actionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_actionContext) +} + +func (s *Actions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Actions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Actions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterActions_clause(s) + } +} + +func (s *Actions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitActions_clause(s) + } +} + +func (s *Actions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitActions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Actions_clause() (localctx IActions_clauseContext) { + localctx = NewActions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 412, PlSqlParserRULE_actions_clause) + p.SetState(5639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 472, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(5618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER, PlSqlParserAUDIT, PlSqlParserCOMMENT, PlSqlParserDELETE, PlSqlParserEXECUTE, PlSqlParserFLASHBACK, PlSqlParserGRANT, PlSqlParserINDEX, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserREAD, PlSqlParserRENAME, PlSqlParserSELECT, PlSqlParserUPDATE: + { + p.SetState(5616) + p.Object_action() + } + + case PlSqlParserALL: + { + p.SetState(5617) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5620) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5633) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 470, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5621) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5622) + p.Directory_name() + } + + case 2: + p.SetState(5625) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 468, p.GetParserRuleContext()) == 1 { + { + p.SetState(5623) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5624) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5630) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 469, p.GetParserRuleContext()) == 1 { + { + p.SetState(5627) + p.Schema_name() + } + { + p.SetState(5628) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5632) + p.Id_expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(5637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTER, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOCK, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(5635) + p.System_action() + } + + case PlSqlParserALL: + { + p.SetState(5636) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_actionContext is an interface to support dynamic dispatch. +type IObject_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + GRANT() antlr.TerminalNode + READ() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + RENAME() antlr.TerminalNode + + // IsObject_actionContext differentiates from other interfaces. + IsObject_actionContext() +} + +type Object_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_actionContext() *Object_actionContext { + var p = new(Object_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_action + return p +} + +func InitEmptyObject_actionContext(p *Object_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_action +} + +func (*Object_actionContext) IsObject_actionContext() {} + +func NewObject_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_actionContext { + var p = new(Object_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_action + + return p +} + +func (s *Object_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_actionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Object_actionContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Object_actionContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Object_actionContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Object_actionContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Object_actionContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Object_actionContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_actionContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Object_actionContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Object_actionContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Object_actionContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Object_actionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Object_actionContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Object_actionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Object_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_action(s) + } +} + +func (s *Object_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_action(s) + } +} + +func (s *Object_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_action() (localctx IObject_actionContext) { + localctx = NewObject_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 414, PlSqlParserRULE_object_action) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5641) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserAUDIT || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserEXECUTE || _la == PlSqlParserFLASHBACK || _la == PlSqlParserGRANT || _la == PlSqlParserINDEX || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserRENAME || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + 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 +} + +// ISystem_actionContext is an interface to support dynamic dispatch. +type ISystem_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + JAVA() antlr.TerminalNode + CREATE() antlr.TerminalNode + ALTER() antlr.TerminalNode + DROP() antlr.TerminalNode + LOCK() antlr.TerminalNode + TABLE() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + + // IsSystem_actionContext differentiates from other interfaces. + IsSystem_actionContext() +} + +type System_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_actionContext() *System_actionContext { + var p = new(System_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_action + return p +} + +func InitEmptySystem_actionContext(p *System_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_action +} + +func (*System_actionContext) IsSystem_actionContext() {} + +func NewSystem_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_actionContext { + var p = new(System_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_action + + return p +} + +func (s *System_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_actionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *System_actionContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *System_actionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *System_actionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *System_actionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *System_actionContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *System_actionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *System_actionContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *System_actionContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *System_actionContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *System_actionContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *System_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_action(s) + } +} + +func (s *System_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_action(s) + } +} + +func (s *System_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSystem_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) System_action() (localctx ISystem_actionContext) { + localctx = NewSystem_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 416, PlSqlParserRULE_system_action) + var _la int + + p.SetState(5650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 473, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5643) + p.Id_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5644) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5645) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5646) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5647) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5648) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXECUTE || _la == PlSqlParserREAD || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5649) + p.Match(PlSqlParserDIRECTORY) + 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 +} + +// IComponent_actionsContext is an interface to support dynamic dispatch. +type IComponent_actionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIONS() antlr.TerminalNode + COMPONENT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllComponent_action() []IComponent_actionContext + Component_action(i int) IComponent_actionContext + DV() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PROTOCOL() antlr.TerminalNode + DATAPUMP() antlr.TerminalNode + DIRECT_LOAD() antlr.TerminalNode + OLS() antlr.TerminalNode + XS() antlr.TerminalNode + FTP() antlr.TerminalNode + HTTP() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsComponent_actionsContext differentiates from other interfaces. + IsComponent_actionsContext() +} + +type Component_actionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComponent_actionsContext() *Component_actionsContext { + var p = new(Component_actionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_actions + return p +} + +func InitEmptyComponent_actionsContext(p *Component_actionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_actions +} + +func (*Component_actionsContext) IsComponent_actionsContext() {} + +func NewComponent_actionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Component_actionsContext { + var p = new(Component_actionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_component_actions + + return p +} + +func (s *Component_actionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Component_actionsContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Component_actionsContext) COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENT, 0) +} + +func (s *Component_actionsContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Component_actionsContext) AllComponent_action() []IComponent_actionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IComponent_actionContext); ok { + len++ + } + } + + tst := make([]IComponent_actionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IComponent_actionContext); ok { + tst[i] = t.(IComponent_actionContext) + i++ + } + } + + return tst +} + +func (s *Component_actionsContext) Component_action(i int) IComponent_actionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComponent_actionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IComponent_actionContext) +} + +func (s *Component_actionsContext) DV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDV, 0) +} + +func (s *Component_actionsContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Component_actionsContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Component_actionsContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Component_actionsContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Component_actionsContext) PROTOCOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTOCOL, 0) +} + +func (s *Component_actionsContext) DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAPUMP, 0) +} + +func (s *Component_actionsContext) DIRECT_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_LOAD, 0) +} + +func (s *Component_actionsContext) OLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLS, 0) +} + +func (s *Component_actionsContext) XS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS, 0) +} + +func (s *Component_actionsContext) FTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFTP, 0) +} + +func (s *Component_actionsContext) HTTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHTTP, 0) +} + +func (s *Component_actionsContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Component_actionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Component_actionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Component_actionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Component_actionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Component_actionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComponent_actions(s) + } +} + +func (s *Component_actionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComponent_actions(s) + } +} + +func (s *Component_actionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComponent_actions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Component_actions() (localctx IComponent_actionsContext) { + localctx = NewComponent_actionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 418, PlSqlParserRULE_component_actions) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5652) + p.Match(PlSqlParserACTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5653) + p.Match(PlSqlParserCOMPONENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5654) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATAPUMP, PlSqlParserDIRECT_LOAD, PlSqlParserOLS, PlSqlParserXS: + { + p.SetState(5655) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAPUMP || _la == PlSqlParserDIRECT_LOAD || _la == PlSqlParserOLS || _la == PlSqlParserXS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(5656) + p.Component_action() + } + p.SetState(5661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5657) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5658) + p.Component_action() + } + + } + p.SetState(5663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 474, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDV: + { + p.SetState(5664) + p.Match(PlSqlParserDV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5665) + p.Component_action() + } + { + p.SetState(5666) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5667) + p.Id_expression() + } + p.SetState(5675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5668) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5669) + p.Component_action() + } + { + p.SetState(5670) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5671) + p.Id_expression() + } + + } + p.SetState(5677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 475, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserPROTOCOL: + { + p.SetState(5678) + p.Match(PlSqlParserPROTOCOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5679) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTHENTICATION || _la == PlSqlParserFTP || _la == PlSqlParserHTTP) { + 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 +} + +// IComponent_actionContext is an interface to support dynamic dispatch. +type IComponent_actionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsComponent_actionContext differentiates from other interfaces. + IsComponent_actionContext() +} + +type Component_actionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComponent_actionContext() *Component_actionContext { + var p = new(Component_actionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_action + return p +} + +func InitEmptyComponent_actionContext(p *Component_actionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_component_action +} + +func (*Component_actionContext) IsComponent_actionContext() {} + +func NewComponent_actionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Component_actionContext { + var p = new(Component_actionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_component_action + + return p +} + +func (s *Component_actionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Component_actionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Component_actionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Component_actionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Component_actionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComponent_action(s) + } +} + +func (s *Component_actionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComponent_action(s) + } +} + +func (s *Component_actionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComponent_action(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Component_action() (localctx IComponent_actionContext) { + localctx = NewComponent_actionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 420, PlSqlParserRULE_component_action) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5682) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_audit_clauseContext is an interface to support dynamic dispatch. +type IRole_audit_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLES() antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRole_audit_clauseContext differentiates from other interfaces. + IsRole_audit_clauseContext() +} + +type Role_audit_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_audit_clauseContext() *Role_audit_clauseContext { + var p = new(Role_audit_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_audit_clause + return p +} + +func InitEmptyRole_audit_clauseContext(p *Role_audit_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_audit_clause +} + +func (*Role_audit_clauseContext) IsRole_audit_clauseContext() {} + +func NewRole_audit_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_audit_clauseContext { + var p = new(Role_audit_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_audit_clause + + return p +} + +func (s *Role_audit_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_audit_clauseContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Role_audit_clauseContext) 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 *Role_audit_clauseContext) 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 *Role_audit_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Role_audit_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Role_audit_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_audit_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_audit_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_audit_clause(s) + } +} + +func (s *Role_audit_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_audit_clause(s) + } +} + +func (s *Role_audit_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRole_audit_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Role_audit_clause() (localctx IRole_audit_clauseContext) { + localctx = NewRole_audit_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 422, PlSqlParserRULE_role_audit_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5684) + p.Match(PlSqlParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5685) + p.Role_name() + } + p.SetState(5690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 477, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5686) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5687) + p.Role_name() + } + + } + p.SetState(5692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 477, 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_controlfileContext is an interface to support dynamic dispatch. +type ICreate_controlfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + Id_expression() IId_expressionContext + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + REUSE() antlr.TerminalNode + SET() antlr.TerminalNode + Logfile_clause() ILogfile_clauseContext + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllControlfile_options() []IControlfile_optionsContext + Controlfile_options(i int) IControlfile_optionsContext + Character_set_clause() ICharacter_set_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_controlfileContext differentiates from other interfaces. + IsCreate_controlfileContext() +} + +type Create_controlfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext +} + +func NewEmptyCreate_controlfileContext() *Create_controlfileContext { + var p = new(Create_controlfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_controlfile + return p +} + +func InitEmptyCreate_controlfileContext(p *Create_controlfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_controlfile +} + +func (*Create_controlfileContext) IsCreate_controlfileContext() {} + +func NewCreate_controlfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_controlfileContext { + var p = new(Create_controlfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_controlfile + + return p +} + +func (s *Create_controlfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_controlfileContext) GetD() IId_expressionContext { return s.d } + +func (s *Create_controlfileContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Create_controlfileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_controlfileContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Create_controlfileContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_controlfileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_controlfileContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Create_controlfileContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Create_controlfileContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Create_controlfileContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Create_controlfileContext) Logfile_clause() ILogfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_clauseContext) +} + +func (s *Create_controlfileContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_controlfileContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Create_controlfileContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Create_controlfileContext) AllControlfile_options() []IControlfile_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IControlfile_optionsContext); ok { + len++ + } + } + + tst := make([]IControlfile_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IControlfile_optionsContext); ok { + tst[i] = t.(IControlfile_optionsContext) + i++ + } + } + + return tst +} + +func (s *Create_controlfileContext) Controlfile_options(i int) IControlfile_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlfile_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IControlfile_optionsContext) +} + +func (s *Create_controlfileContext) Character_set_clause() ICharacter_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICharacter_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICharacter_set_clauseContext) +} + +func (s *Create_controlfileContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_controlfileContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_controlfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_controlfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_controlfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_controlfile(s) + } +} + +func (s *Create_controlfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_controlfile(s) + } +} + +func (s *Create_controlfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_controlfile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_controlfile() (localctx ICreate_controlfileContext) { + localctx = NewCreate_controlfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 424, PlSqlParserRULE_create_controlfile) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5693) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5694) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(5695) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(5698) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5701) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5702) + + var _x = p.Id_expression() + + localctx.(*Create_controlfileContext).d = _x + } + p.SetState(5704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGFILE { + { + p.SetState(5703) + p.Logfile_clause() + } + + } + { + p.SetState(5706) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(5716) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 482, p.GetParserRuleContext()) == 1 { + { + p.SetState(5707) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5708) + p.File_specification() + } + p.SetState(5713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5709) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5710) + p.File_specification() + } + + } + p.SetState(5715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 481, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 483, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5718) + p.Controlfile_options() + } + + } + p.SetState(5723) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 483, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5725) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 484, p.GetParserRuleContext()) == 1 { + { + p.SetState(5724) + p.Character_set_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 +} + +// IControlfile_optionsContext is an interface to support dynamic dispatch. +type IControlfile_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXLOGFILES() antlr.TerminalNode + Numeric() INumericContext + MAXLOGMEMBERS() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + MAXDATAFILES() antlr.TerminalNode + MAXINSTANCES() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FOR() antlr.TerminalNode + DATA() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + LOAD() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + + // IsControlfile_optionsContext differentiates from other interfaces. + IsControlfile_optionsContext() +} + +type Controlfile_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyControlfile_optionsContext() *Controlfile_optionsContext { + var p = new(Controlfile_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_options + return p +} + +func InitEmptyControlfile_optionsContext(p *Controlfile_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_options +} + +func (*Controlfile_optionsContext) IsControlfile_optionsContext() {} + +func NewControlfile_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Controlfile_optionsContext { + var p = new(Controlfile_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_controlfile_options + + return p +} + +func (s *Controlfile_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Controlfile_optionsContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Controlfile_optionsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Controlfile_optionsContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Controlfile_optionsContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Controlfile_optionsContext) MAXDATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, 0) +} + +func (s *Controlfile_optionsContext) MAXINSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, 0) +} + +func (s *Controlfile_optionsContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Controlfile_optionsContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Controlfile_optionsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Controlfile_optionsContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Controlfile_optionsContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Controlfile_optionsContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Controlfile_optionsContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Controlfile_optionsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Controlfile_optionsContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Controlfile_optionsContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Controlfile_optionsContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Controlfile_optionsContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Controlfile_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Controlfile_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Controlfile_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterControlfile_options(s) + } +} + +func (s *Controlfile_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitControlfile_options(s) + } +} + +func (s *Controlfile_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitControlfile_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Controlfile_options() (localctx IControlfile_optionsContext) { + localctx = NewControlfile_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 426, PlSqlParserRULE_controlfile_options) + p.SetState(5751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAXLOGFILES: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5727) + p.Match(PlSqlParserMAXLOGFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5728) + p.Numeric() + } + + case PlSqlParserMAXLOGMEMBERS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5729) + p.Match(PlSqlParserMAXLOGMEMBERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5730) + p.Numeric() + } + + case PlSqlParserMAXLOGHISTORY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(5731) + p.Match(PlSqlParserMAXLOGHISTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5732) + p.Numeric() + } + + case PlSqlParserMAXDATAFILES: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(5733) + p.Match(PlSqlParserMAXDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5734) + p.Numeric() + } + + case PlSqlParserMAXINSTANCES: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(5735) + p.Match(PlSqlParserMAXINSTANCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5736) + p.Numeric() + } + + case PlSqlParserARCHIVELOG: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(5737) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOARCHIVELOG: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(5738) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(5739) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5740) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(5741) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5742) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5743) + p.Match(PlSqlParserNOLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5744) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5749) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(5745) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5746) + p.Match(PlSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOAD: + { + p.SetState(5747) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5748) + p.Match(PlSqlParserPERFORMANCE) + 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 +} + +// ILogfile_clauseContext is an interface to support dynamic dispatch. +type ILogfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + + // IsLogfile_clauseContext differentiates from other interfaces. + IsLogfile_clauseContext() +} + +type Logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_clauseContext() *Logfile_clauseContext { + var p = new(Logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clause + return p +} + +func InitEmptyLogfile_clauseContext(p *Logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clause +} + +func (*Logfile_clauseContext) IsLogfile_clauseContext() {} + +func NewLogfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_clauseContext { + var p = new(Logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_clause + + return p +} + +func (s *Logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_clauseContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Logfile_clauseContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clauseContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Logfile_clauseContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clauseContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Logfile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_clauseContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *Logfile_clauseContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *Logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_clause(s) + } +} + +func (s *Logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_clause(s) + } +} + +func (s *Logfile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogfile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logfile_clause() (localctx ILogfile_clauseContext) { + localctx = NewLogfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 428, PlSqlParserRULE_logfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5753) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5758) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT { + p.SetState(5755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(5754) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5757) + p.Numeric() + } + + } + { + p.SetState(5760) + p.File_specification() + } + p.SetState(5771) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5761) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT { + p.SetState(5763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(5762) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5765) + p.Numeric() + } + + } + { + p.SetState(5768) + p.File_specification() + } + + p.SetState(5773) + 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 +} + +// ICharacter_set_clauseContext is an interface to support dynamic dispatch. +type ICharacter_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCs returns the cs rule contexts. + GetCs() IId_expressionContext + + // SetCs sets the cs rule contexts. + SetCs(IId_expressionContext) + + // Getter signatures + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsCharacter_set_clauseContext differentiates from other interfaces. + IsCharacter_set_clauseContext() +} + +type Character_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + cs IId_expressionContext +} + +func NewEmptyCharacter_set_clauseContext() *Character_set_clauseContext { + var p = new(Character_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_character_set_clause + return p +} + +func InitEmptyCharacter_set_clauseContext(p *Character_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_character_set_clause +} + +func (*Character_set_clauseContext) IsCharacter_set_clauseContext() {} + +func NewCharacter_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Character_set_clauseContext { + var p = new(Character_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_character_set_clause + + return p +} + +func (s *Character_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Character_set_clauseContext) GetCs() IId_expressionContext { return s.cs } + +func (s *Character_set_clauseContext) SetCs(v IId_expressionContext) { s.cs = v } + +func (s *Character_set_clauseContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Character_set_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Character_set_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Character_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Character_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Character_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCharacter_set_clause(s) + } +} + +func (s *Character_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCharacter_set_clause(s) + } +} + +func (s *Character_set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCharacter_set_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Character_set_clause() (localctx ICharacter_set_clauseContext) { + localctx = NewCharacter_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 430, PlSqlParserRULE_character_set_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5774) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5775) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5776) + + var _x = p.Id_expression() + + localctx.(*Character_set_clauseContext).cs = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_specificationContext is an interface to support dynamic dispatch. +type IFile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datafile_tempfile_spec() IDatafile_tempfile_specContext + Redo_log_file_spec() IRedo_log_file_specContext + + // IsFile_specificationContext differentiates from other interfaces. + IsFile_specificationContext() +} + +type File_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_specificationContext() *File_specificationContext { + var p = new(File_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_specification + return p +} + +func InitEmptyFile_specificationContext(p *File_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_specification +} + +func (*File_specificationContext) IsFile_specificationContext() {} + +func NewFile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_specificationContext { + var p = new(File_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_specification + + return p +} + +func (s *File_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *File_specificationContext) Redo_log_file_spec() IRedo_log_file_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedo_log_file_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedo_log_file_specContext) +} + +func (s *File_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_specification(s) + } +} + +func (s *File_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_specification(s) + } +} + +func (s *File_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_specification() (localctx IFile_specificationContext) { + localctx = NewFile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 432, PlSqlParserRULE_file_specification) + p.SetState(5780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 492, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5778) + p.Datafile_tempfile_spec() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(5779) + p.Redo_log_file_spec() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_diskgroupContext is an interface to support dynamic dispatch. +type ICreate_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAn returns the an token. + GetAn() antlr.Token + + // GetAv returns the av token. + GetAv() antlr.Token + + // SetAn sets the an token. + SetAn(antlr.Token) + + // SetAv sets the av token. + SetAv(antlr.Token) + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetFg returns the fg rule contexts. + GetFg() IId_expressionContext + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetFg sets the fg rule contexts. + SetFg(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + REDUNDANCY() antlr.TerminalNode + AllDISK() []antlr.TerminalNode + DISK(i int) antlr.TerminalNode + AllQualified_disk_clause() []IQualified_disk_clauseContext + Qualified_disk_clause(i int) IQualified_disk_clauseContext + ATTRIBUTE() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + HIGH() antlr.TerminalNode + NORMAL() antlr.TerminalNode + FLEX() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + AllQuorum_regular() []IQuorum_regularContext + Quorum_regular(i int) IQuorum_regularContext + AllFAILGROUP() []antlr.TerminalNode + FAILGROUP(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SITE() antlr.TerminalNode + + // IsCreate_diskgroupContext differentiates from other interfaces. + IsCreate_diskgroupContext() +} + +type Create_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + sn IId_expressionContext + fg IId_expressionContext + an antlr.Token + av antlr.Token +} + +func NewEmptyCreate_diskgroupContext() *Create_diskgroupContext { + var p = new(Create_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_diskgroup + return p +} + +func InitEmptyCreate_diskgroupContext(p *Create_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_diskgroup +} + +func (*Create_diskgroupContext) IsCreate_diskgroupContext() {} + +func NewCreate_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_diskgroupContext { + var p = new(Create_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_diskgroup + + return p +} + +func (s *Create_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_diskgroupContext) GetAn() antlr.Token { return s.an } + +func (s *Create_diskgroupContext) GetAv() antlr.Token { return s.av } + +func (s *Create_diskgroupContext) SetAn(v antlr.Token) { s.an = v } + +func (s *Create_diskgroupContext) SetAv(v antlr.Token) { s.av = v } + +func (s *Create_diskgroupContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Create_diskgroupContext) GetFg() IId_expressionContext { return s.fg } + +func (s *Create_diskgroupContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Create_diskgroupContext) SetFg(v IId_expressionContext) { s.fg = v } + +func (s *Create_diskgroupContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Create_diskgroupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_diskgroupContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Create_diskgroupContext) AllDISK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISK) +} + +func (s *Create_diskgroupContext) DISK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, i) +} + +func (s *Create_diskgroupContext) AllQualified_disk_clause() []IQualified_disk_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + len++ + } + } + + tst := make([]IQualified_disk_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQualified_disk_clauseContext); ok { + tst[i] = t.(IQualified_disk_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Qualified_disk_clause(i int) IQualified_disk_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQualified_disk_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQualified_disk_clauseContext) +} + +func (s *Create_diskgroupContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Create_diskgroupContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Create_diskgroupContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Create_diskgroupContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Create_diskgroupContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Create_diskgroupContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Create_diskgroupContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Create_diskgroupContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Create_diskgroupContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Create_diskgroupContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Create_diskgroupContext) AllQuorum_regular() []IQuorum_regularContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuorum_regularContext); ok { + len++ + } + } + + tst := make([]IQuorum_regularContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuorum_regularContext); ok { + tst[i] = t.(IQuorum_regularContext) + i++ + } + } + + return tst +} + +func (s *Create_diskgroupContext) Quorum_regular(i int) IQuorum_regularContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuorum_regularContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuorum_regularContext) +} + +func (s *Create_diskgroupContext) AllFAILGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAILGROUP) +} + +func (s *Create_diskgroupContext) FAILGROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, i) +} + +func (s *Create_diskgroupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_diskgroupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_diskgroupContext) SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, 0) +} + +func (s *Create_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_diskgroup(s) + } +} + +func (s *Create_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_diskgroup(s) + } +} + +func (s *Create_diskgroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_diskgroup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_diskgroup() (localctx ICreate_diskgroupContext) { + localctx = NewCreate_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 434, PlSqlParserRULE_create_diskgroup) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5782) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5783) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5784) + p.Id_expression() + } + p.SetState(5797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL || _la == PlSqlParserFLEX || _la == PlSqlParserHIGH || _la == PlSqlParserNORMAL || _la == PlSqlParserEXTENDED { + p.SetState(5794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserHIGH: + { + p.SetState(5785) + p.Match(PlSqlParserHIGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNORMAL: + { + p.SetState(5786) + p.Match(PlSqlParserNORMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFLEX: + { + p.SetState(5787) + p.Match(PlSqlParserFLEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENDED: + { + p.SetState(5788) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSITE { + { + p.SetState(5789) + p.Match(PlSqlParserSITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5790) + + var _x = p.Id_expression() + + localctx.(*Create_diskgroupContext).sn = _x + } + + } + + case PlSqlParserEXTERNAL: + { + p.SetState(5793) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(5796) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(5800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUORUM || _la == PlSqlParserREGULAR { + { + p.SetState(5799) + p.Quorum_regular() + } + + } + p.SetState(5804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFAILGROUP { + { + p.SetState(5802) + p.Match(PlSqlParserFAILGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5803) + + var _x = p.Id_expression() + + localctx.(*Create_diskgroupContext).fg = _x + } + + } + { + p.SetState(5806) + p.Match(PlSqlParserDISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5807) + p.Qualified_disk_clause() + } + p.SetState(5812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 498, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5808) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5809) + p.Qualified_disk_clause() + } + + } + p.SetState(5814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 498, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(5817) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 499, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(5832) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 501, p.GetParserRuleContext()) == 1 { + { + p.SetState(5819) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5820) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_diskgroupContext).an = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5821) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5822) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_diskgroupContext).av = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(5823) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5824) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5825) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5826) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 500, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQualified_disk_clauseContext is an interface to support dynamic dispatch. +type IQualified_disk_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetSs returns the ss token. + GetSs() antlr.Token + + // SetSs sets the ss token. + SetSs(antlr.Token) + + // GetDn returns the dn rule contexts. + GetDn() IId_expressionContext + + // SetDn sets the dn rule contexts. + SetDn(IId_expressionContext) + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + NAME() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Force_noforce() IForce_noforceContext + Id_expression() IId_expressionContext + + // IsQualified_disk_clauseContext differentiates from other interfaces. + IsQualified_disk_clauseContext() +} + +type Qualified_disk_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ss antlr.Token + dn IId_expressionContext +} + +func NewEmptyQualified_disk_clauseContext() *Qualified_disk_clauseContext { + var p = new(Qualified_disk_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause + return p +} + +func InitEmptyQualified_disk_clauseContext(p *Qualified_disk_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause +} + +func (*Qualified_disk_clauseContext) IsQualified_disk_clauseContext() {} + +func NewQualified_disk_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Qualified_disk_clauseContext { + var p = new(Qualified_disk_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_qualified_disk_clause + + return p +} + +func (s *Qualified_disk_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Qualified_disk_clauseContext) GetSs() antlr.Token { return s.ss } + +func (s *Qualified_disk_clauseContext) SetSs(v antlr.Token) { s.ss = v } + +func (s *Qualified_disk_clauseContext) GetDn() IId_expressionContext { return s.dn } + +func (s *Qualified_disk_clauseContext) SetDn(v IId_expressionContext) { s.dn = v } + +func (s *Qualified_disk_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Qualified_disk_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Qualified_disk_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Qualified_disk_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Qualified_disk_clauseContext) Force_noforce() IForce_noforceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_noforceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_noforceContext) +} + +func (s *Qualified_disk_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Qualified_disk_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Qualified_disk_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Qualified_disk_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQualified_disk_clause(s) + } +} + +func (s *Qualified_disk_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQualified_disk_clause(s) + } +} + +func (s *Qualified_disk_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQualified_disk_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Qualified_disk_clause() (localctx IQualified_disk_clauseContext) { + localctx = NewQualified_disk_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 436, PlSqlParserRULE_qualified_disk_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5834) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Qualified_disk_clauseContext).ss = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5837) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 502, p.GetParserRuleContext()) == 1 { + { + p.SetState(5835) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5836) + + var _x = p.Id_expression() + + localctx.(*Qualified_disk_clauseContext).dn = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5841) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 503, p.GetParserRuleContext()) == 1 { + { + p.SetState(5839) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5840) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(5844) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 504, p.GetParserRuleContext()) == 1 { + { + p.SetState(5843) + p.Force_noforce() + } + + } 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 +} + +// ICreate_editionContext is an interface to support dynamic dispatch. +type ICreate_editionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetE returns the e rule contexts. + GetE() IId_expressionContext + + // GetPe returns the pe rule contexts. + GetPe() IId_expressionContext + + // SetE sets the e rule contexts. + SetE(IId_expressionContext) + + // SetPe sets the pe rule contexts. + SetPe(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + EDITION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AS() antlr.TerminalNode + CHILD() antlr.TerminalNode + OF() antlr.TerminalNode + + // IsCreate_editionContext differentiates from other interfaces. + IsCreate_editionContext() +} + +type Create_editionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + e IId_expressionContext + pe IId_expressionContext +} + +func NewEmptyCreate_editionContext() *Create_editionContext { + var p = new(Create_editionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_edition + return p +} + +func InitEmptyCreate_editionContext(p *Create_editionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_edition +} + +func (*Create_editionContext) IsCreate_editionContext() {} + +func NewCreate_editionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_editionContext { + var p = new(Create_editionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_edition + + return p +} + +func (s *Create_editionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_editionContext) GetE() IId_expressionContext { return s.e } + +func (s *Create_editionContext) GetPe() IId_expressionContext { return s.pe } + +func (s *Create_editionContext) SetE(v IId_expressionContext) { s.e = v } + +func (s *Create_editionContext) SetPe(v IId_expressionContext) { s.pe = v } + +func (s *Create_editionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_editionContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Create_editionContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_editionContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_editionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_editionContext) CHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, 0) +} + +func (s *Create_editionContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_editionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_editionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_editionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_edition(s) + } +} + +func (s *Create_editionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_edition(s) + } +} + +func (s *Create_editionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_edition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_edition() (localctx ICreate_editionContext) { + localctx = NewCreate_editionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 438, PlSqlParserRULE_create_edition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5846) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5847) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5848) + + var _x = p.Id_expression() + + localctx.(*Create_editionContext).e = _x + } + p.SetState(5853) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 505, p.GetParserRuleContext()) == 1 { + { + p.SetState(5849) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5850) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5851) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5852) + + var _x = p.Id_expression() + + localctx.(*Create_editionContext).pe = _x + } + + } 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 +} + +// ICreate_flashback_archiveContext is an interface to support dynamic dispatch. +type ICreate_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Flashback_archive_retention() IFlashback_archive_retentionContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DEFAULT() antlr.TerminalNode + Flashback_archive_quota() IFlashback_archive_quotaContext + OPTIMIZE() antlr.TerminalNode + DATA() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsCreate_flashback_archiveContext differentiates from other interfaces. + IsCreate_flashback_archiveContext() +} + +type Create_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext + ts IId_expressionContext +} + +func NewEmptyCreate_flashback_archiveContext() *Create_flashback_archiveContext { + var p = new(Create_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_flashback_archive + return p +} + +func InitEmptyCreate_flashback_archiveContext(p *Create_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_flashback_archive +} + +func (*Create_flashback_archiveContext) IsCreate_flashback_archiveContext() {} + +func NewCreate_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_flashback_archiveContext { + var p = new(Create_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_flashback_archive + + return p +} + +func (s *Create_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Create_flashback_archiveContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Create_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Create_flashback_archiveContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Create_flashback_archiveContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Create_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Create_flashback_archiveContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Create_flashback_archiveContext) Flashback_archive_retention() IFlashback_archive_retentionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_retentionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_retentionContext) +} + +func (s *Create_flashback_archiveContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_flashback_archiveContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_flashback_archiveContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Create_flashback_archiveContext) Flashback_archive_quota() IFlashback_archive_quotaContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_quotaContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_quotaContext) +} + +func (s *Create_flashback_archiveContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Create_flashback_archiveContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_flashback_archiveContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_flashback_archive(s) + } +} + +func (s *Create_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_flashback_archive(s) + } +} + +func (s *Create_flashback_archiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_flashback_archive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_flashback_archive() (localctx ICreate_flashback_archiveContext) { + localctx = NewCreate_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 440, PlSqlParserRULE_create_flashback_archive) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5855) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5856) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5857) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(5858) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5861) + + var _x = p.Id_expression() + + localctx.(*Create_flashback_archiveContext).fa = _x + } + { + p.SetState(5862) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5863) + + var _x = p.Id_expression() + + localctx.(*Create_flashback_archiveContext).ts = _x + } + p.SetState(5865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserQUOTA { + { + p.SetState(5864) + p.Flashback_archive_quota() + } + + } + p.SetState(5872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserOPTIMIZE { + p.SetState(5868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(5867) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5870) + p.Match(PlSqlParserOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5871) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5874) + p.Flashback_archive_retention() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_archive_quotaContext is an interface to support dynamic dispatch. +type IFlashback_archive_quotaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTA() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + + // IsFlashback_archive_quotaContext differentiates from other interfaces. + IsFlashback_archive_quotaContext() +} + +type Flashback_archive_quotaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_archive_quotaContext() *Flashback_archive_quotaContext { + var p = new(Flashback_archive_quotaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota + return p +} + +func InitEmptyFlashback_archive_quotaContext(p *Flashback_archive_quotaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota +} + +func (*Flashback_archive_quotaContext) IsFlashback_archive_quotaContext() {} + +func NewFlashback_archive_quotaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_quotaContext { + var p = new(Flashback_archive_quotaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_quota + + return p +} + +func (s *Flashback_archive_quotaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_quotaContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Flashback_archive_quotaContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Flashback_archive_quotaContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Flashback_archive_quotaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_quotaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_quotaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_quota(s) + } +} + +func (s *Flashback_archive_quotaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_quota(s) + } +} + +func (s *Flashback_archive_quotaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_archive_quota(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_archive_quota() (localctx IFlashback_archive_quotaContext) { + localctx = NewFlashback_archive_quotaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 442, PlSqlParserRULE_flashback_archive_quota) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5876) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5877) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5878) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserE_LETTER || _la == PlSqlParserG_LETTER || _la == PlSqlParserM_LETTER || _la == PlSqlParserP_LETTER || _la == PlSqlParserT_LETTER) { + 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 +} + +// IFlashback_archive_retentionContext is an interface to support dynamic dispatch. +type IFlashback_archive_retentionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + DAY() antlr.TerminalNode + + // IsFlashback_archive_retentionContext differentiates from other interfaces. + IsFlashback_archive_retentionContext() +} + +type Flashback_archive_retentionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_archive_retentionContext() *Flashback_archive_retentionContext { + var p = new(Flashback_archive_retentionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention + return p +} + +func InitEmptyFlashback_archive_retentionContext(p *Flashback_archive_retentionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention +} + +func (*Flashback_archive_retentionContext) IsFlashback_archive_retentionContext() {} + +func NewFlashback_archive_retentionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_retentionContext { + var p = new(Flashback_archive_retentionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_retention + + return p +} + +func (s *Flashback_archive_retentionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_retentionContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Flashback_archive_retentionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Flashback_archive_retentionContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Flashback_archive_retentionContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Flashback_archive_retentionContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Flashback_archive_retentionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_retentionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_retentionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_retention(s) + } +} + +func (s *Flashback_archive_retentionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_retention(s) + } +} + +func (s *Flashback_archive_retentionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_archive_retention(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_archive_retention() (localctx IFlashback_archive_retentionContext) { + localctx = NewFlashback_archive_retentionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 444, PlSqlParserRULE_flashback_archive_retention) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5880) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5881) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5882) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserMONTH || _la == PlSqlParserYEAR) { + 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_hierarchyContext is an interface to support dynamic dispatch. +type ICreate_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Hier_using_clause() IHier_using_clauseContext + Level_hier_clause() ILevel_hier_clauseContext + Id_expression() IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FORCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + Hier_attrs_clause() IHier_attrs_clauseContext + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsCreate_hierarchyContext differentiates from other interfaces. + IsCreate_hierarchyContext() +} + +type Create_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + h IId_expressionContext +} + +func NewEmptyCreate_hierarchyContext() *Create_hierarchyContext { + var p = new(Create_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_hierarchy + return p +} + +func InitEmptyCreate_hierarchyContext(p *Create_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_hierarchy +} + +func (*Create_hierarchyContext) IsCreate_hierarchyContext() {} + +func NewCreate_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_hierarchyContext { + var p = new(Create_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_hierarchy + + return p +} + +func (s *Create_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_hierarchyContext) GetH() IId_expressionContext { return s.h } + +func (s *Create_hierarchyContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Create_hierarchyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Create_hierarchyContext) Hier_using_clause() IHier_using_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_using_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_using_clauseContext) +} + +func (s *Create_hierarchyContext) Level_hier_clause() ILevel_hier_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_hier_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILevel_hier_clauseContext) +} + +func (s *Create_hierarchyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_hierarchyContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_hierarchyContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_hierarchyContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_hierarchyContext) 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_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_hierarchyContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_hierarchyContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_hierarchyContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_hierarchyContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Create_hierarchyContext) Hier_attrs_clause() IHier_attrs_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attrs_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attrs_clauseContext) +} + +func (s *Create_hierarchyContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_hierarchyContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_hierarchyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_hierarchy(s) + } +} + +func (s *Create_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_hierarchy(s) + } +} + +func (s *Create_hierarchyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_hierarchy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_hierarchy() (localctx ICreate_hierarchyContext) { + localctx = NewCreate_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 446, PlSqlParserRULE_create_hierarchy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5884) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(5885) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5886) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(5893) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNO { + p.SetState(5890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(5889) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5892) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(5895) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5899) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 513, p.GetParserRuleContext()) == 1 { + { + p.SetState(5896) + p.Schema_name() + } + { + p.SetState(5897) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5901) + + var _x = p.Id_expression() + + localctx.(*Create_hierarchyContext).h = _x + } + p.SetState(5905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(5902) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5903) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5904) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(5910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5907) + p.Classification_clause() + } + + p.SetState(5912) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5913) + p.Hier_using_clause() + } + { + p.SetState(5914) + p.Level_hier_clause() + } + p.SetState(5916) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 516, p.GetParserRuleContext()) == 1 { + { + p.SetState(5915) + p.Hier_attrs_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 +} + +// IHier_using_clauseContext is an interface to support dynamic dispatch. +type IHier_using_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + USING() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsHier_using_clauseContext differentiates from other interfaces. + IsHier_using_clauseContext() +} + +type Hier_using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyHier_using_clauseContext() *Hier_using_clauseContext { + var p = new(Hier_using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_using_clause + return p +} + +func InitEmptyHier_using_clauseContext(p *Hier_using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_using_clause +} + +func (*Hier_using_clauseContext) IsHier_using_clauseContext() {} + +func NewHier_using_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_using_clauseContext { + var p = new(Hier_using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_using_clause + + return p +} + +func (s *Hier_using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_using_clauseContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Hier_using_clauseContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Hier_using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Hier_using_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Hier_using_clauseContext) 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 *Hier_using_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Hier_using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_using_clause(s) + } +} + +func (s *Hier_using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_using_clause(s) + } +} + +func (s *Hier_using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHier_using_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hier_using_clause() (localctx IHier_using_clauseContext) { + localctx = NewHier_using_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 448, PlSqlParserRULE_hier_using_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5918) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5922) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 517, p.GetParserRuleContext()) == 1 { + { + p.SetState(5919) + p.Schema_name() + } + { + p.SetState(5920) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5924) + + var _x = p.Id_expression() + + localctx.(*Hier_using_clauseContext).ad = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevel_hier_clauseContext is an interface to support dynamic dispatch. +type ILevel_hier_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCHILD() []antlr.TerminalNode + CHILD(i int) antlr.TerminalNode + AllOF() []antlr.TerminalNode + OF(i int) antlr.TerminalNode + + // IsLevel_hier_clauseContext differentiates from other interfaces. + IsLevel_hier_clauseContext() +} + +type Level_hier_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + l IId_expressionContext +} + +func NewEmptyLevel_hier_clauseContext() *Level_hier_clauseContext { + var p = new(Level_hier_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_hier_clause + return p +} + +func InitEmptyLevel_hier_clauseContext(p *Level_hier_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_hier_clause +} + +func (*Level_hier_clauseContext) IsLevel_hier_clauseContext() {} + +func NewLevel_hier_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_hier_clauseContext { + var p = new(Level_hier_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_hier_clause + + return p +} + +func (s *Level_hier_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_hier_clauseContext) GetL() IId_expressionContext { return s.l } + +func (s *Level_hier_clauseContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Level_hier_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_hier_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_hier_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Level_hier_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Level_hier_clauseContext) AllCHILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHILD) +} + +func (s *Level_hier_clauseContext) CHILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, i) +} + +func (s *Level_hier_clauseContext) AllOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOF) +} + +func (s *Level_hier_clauseContext) OF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, i) +} + +func (s *Level_hier_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_hier_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_hier_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_hier_clause(s) + } +} + +func (s *Level_hier_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_hier_clause(s) + } +} + +func (s *Level_hier_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevel_hier_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Level_hier_clause() (localctx ILevel_hier_clauseContext) { + localctx = NewLevel_hier_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 450, PlSqlParserRULE_level_hier_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5926) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(5927) + + var _x = p.Id_expression() + + localctx.(*Level_hier_clauseContext).l = _x + } + p.SetState(5930) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 518, p.GetParserRuleContext()) == 1 { + { + p.SetState(5928) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5929) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.SetState(5934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5936) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_attrs_clauseContext is an interface to support dynamic dispatch. +type IHier_attrs_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HIERARCHICAL() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Hier_attr_clause() IHier_attr_clauseContext + RIGHT_PAREN() antlr.TerminalNode + + // IsHier_attrs_clauseContext differentiates from other interfaces. + IsHier_attrs_clauseContext() +} + +type Hier_attrs_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attrs_clauseContext() *Hier_attrs_clauseContext { + var p = new(Hier_attrs_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause + return p +} + +func InitEmptyHier_attrs_clauseContext(p *Hier_attrs_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause +} + +func (*Hier_attrs_clauseContext) IsHier_attrs_clauseContext() {} + +func NewHier_attrs_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attrs_clauseContext { + var p = new(Hier_attrs_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attrs_clause + + return p +} + +func (s *Hier_attrs_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attrs_clauseContext) HIERARCHICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHICAL, 0) +} + +func (s *Hier_attrs_clauseContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Hier_attrs_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hier_attrs_clauseContext) Hier_attr_clause() IHier_attr_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attr_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attr_clauseContext) +} + +func (s *Hier_attrs_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hier_attrs_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attrs_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attrs_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attrs_clause(s) + } +} + +func (s *Hier_attrs_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attrs_clause(s) + } +} + +func (s *Hier_attrs_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHier_attrs_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hier_attrs_clause() (localctx IHier_attrs_clauseContext) { + localctx = NewHier_attrs_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 452, PlSqlParserRULE_hier_attrs_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5938) + p.Match(PlSqlParserHIERARCHICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5939) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5940) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5941) + p.Hier_attr_clause() + } + { + p.SetState(5942) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHier_attr_clauseContext is an interface to support dynamic dispatch. +type IHier_attr_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Hier_attr_name() IHier_attr_nameContext + AllClassification_clause() []IClassification_clauseContext + Classification_clause(i int) IClassification_clauseContext + + // IsHier_attr_clauseContext differentiates from other interfaces. + IsHier_attr_clauseContext() +} + +type Hier_attr_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attr_clauseContext() *Hier_attr_clauseContext { + var p = new(Hier_attr_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_clause + return p +} + +func InitEmptyHier_attr_clauseContext(p *Hier_attr_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_clause +} + +func (*Hier_attr_clauseContext) IsHier_attr_clauseContext() {} + +func NewHier_attr_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attr_clauseContext { + var p = new(Hier_attr_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attr_clause + + return p +} + +func (s *Hier_attr_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attr_clauseContext) Hier_attr_name() IHier_attr_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHier_attr_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHier_attr_nameContext) +} + +func (s *Hier_attr_clauseContext) AllClassification_clause() []IClassification_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClassification_clauseContext); ok { + len++ + } + } + + tst := make([]IClassification_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClassification_clauseContext); ok { + tst[i] = t.(IClassification_clauseContext) + i++ + } + } + + return tst +} + +func (s *Hier_attr_clauseContext) Classification_clause(i int) IClassification_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClassification_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClassification_clauseContext) +} + +func (s *Hier_attr_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attr_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attr_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attr_clause(s) + } +} + +func (s *Hier_attr_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attr_clause(s) + } +} + +func (s *Hier_attr_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHier_attr_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hier_attr_clause() (localctx IHier_attr_clauseContext) { + localctx = NewHier_attr_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 454, PlSqlParserRULE_hier_attr_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5944) + p.Hier_attr_name() + } + p.SetState(5948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCAPTION || _la == PlSqlParserCLASSIFICATION || _la == PlSqlParserDESCRIPTION { + { + p.SetState(5945) + p.Classification_clause() + } + + p.SetState(5950) + 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 +} + +// IHier_attr_nameContext is an interface to support dynamic dispatch. +type IHier_attr_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMBER_NAME() antlr.TerminalNode + MEMBER_UNIQUE_NAME() antlr.TerminalNode + MEMBER_CAPTION() antlr.TerminalNode + MEMBER_DESCRIPTION() antlr.TerminalNode + LEVEL_NAME() antlr.TerminalNode + HIER_ORDER() antlr.TerminalNode + DEPTH() antlr.TerminalNode + IS_LEAF() antlr.TerminalNode + PARENT_LEVEL_NAME() antlr.TerminalNode + PARENT_UNIQUE_NAME() antlr.TerminalNode + + // IsHier_attr_nameContext differentiates from other interfaces. + IsHier_attr_nameContext() +} + +type Hier_attr_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHier_attr_nameContext() *Hier_attr_nameContext { + var p = new(Hier_attr_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_name + return p +} + +func InitEmptyHier_attr_nameContext(p *Hier_attr_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hier_attr_name +} + +func (*Hier_attr_nameContext) IsHier_attr_nameContext() {} + +func NewHier_attr_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hier_attr_nameContext { + var p = new(Hier_attr_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hier_attr_name + + return p +} + +func (s *Hier_attr_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hier_attr_nameContext) MEMBER_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_NAME, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_UNIQUE_NAME, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_CAPTION, 0) +} + +func (s *Hier_attr_nameContext) MEMBER_DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_DESCRIPTION, 0) +} + +func (s *Hier_attr_nameContext) LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL_NAME, 0) +} + +func (s *Hier_attr_nameContext) HIER_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIER_ORDER, 0) +} + +func (s *Hier_attr_nameContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Hier_attr_nameContext) IS_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS_LEAF, 0) +} + +func (s *Hier_attr_nameContext) PARENT_LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_LEVEL_NAME, 0) +} + +func (s *Hier_attr_nameContext) PARENT_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_UNIQUE_NAME, 0) +} + +func (s *Hier_attr_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hier_attr_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hier_attr_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHier_attr_name(s) + } +} + +func (s *Hier_attr_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHier_attr_name(s) + } +} + +func (s *Hier_attr_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHier_attr_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hier_attr_name() (localctx IHier_attr_nameContext) { + localctx = NewHier_attr_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 456, PlSqlParserRULE_hier_attr_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5951) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEPTH || _la == PlSqlParserHIER_ORDER || _la == PlSqlParserIS_LEAF || _la == PlSqlParserLEVEL_NAME || ((int64((_la-866)) & ^0x3f) == 0 && ((int64(1)<<(_la-866))&15) != 0) || _la == PlSqlParserPARENT_LEVEL_NAME || _la == PlSqlParserPARENT_UNIQUE_NAME) { + 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_indexContext is an interface to support dynamic dispatch. +type ICreate_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + ON() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Cluster_index_clause() ICluster_index_clauseContext + Table_index_clause() ITable_index_clauseContext + Bitmap_join_index_clause() IBitmap_join_index_clauseContext + UNIQUE() antlr.TerminalNode + BITMAP() antlr.TerminalNode + USABLE() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + + // IsCreate_indexContext differentiates from other interfaces. + IsCreate_indexContext() +} + +type Create_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_indexContext() *Create_indexContext { + var p = new(Create_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_index + return p +} + +func InitEmptyCreate_indexContext(p *Create_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_index +} + +func (*Create_indexContext) IsCreate_indexContext() {} + +func NewCreate_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_indexContext { + var p = new(Create_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_index + + return p +} + +func (s *Create_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_indexContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Create_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Create_indexContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_indexContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_indexContext) Cluster_index_clause() ICluster_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_index_clauseContext) +} + +func (s *Create_indexContext) Table_index_clause() ITable_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_index_clauseContext) +} + +func (s *Create_indexContext) Bitmap_join_index_clause() IBitmap_join_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBitmap_join_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBitmap_join_index_clauseContext) +} + +func (s *Create_indexContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Create_indexContext) BITMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP, 0) +} + +func (s *Create_indexContext) USABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSABLE, 0) +} + +func (s *Create_indexContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Create_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_index(s) + } +} + +func (s *Create_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_index(s) + } +} + +func (s *Create_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_index() (localctx ICreate_indexContext) { + localctx = NewCreate_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 458, PlSqlParserRULE_create_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5953) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBITMAP || _la == PlSqlParserUNIQUE { + { + p.SetState(5954) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBITMAP || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5957) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5958) + p.Index_name() + } + { + p.SetState(5959) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5963) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 522, p.GetParserRuleContext()) { + case 1: + { + p.SetState(5960) + p.Cluster_index_clause() + } + + case 2: + { + p.SetState(5961) + p.Table_index_clause() + } + + case 3: + { + p.SetState(5962) + p.Bitmap_join_index_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(5966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE || _la == PlSqlParserUSABLE { + { + p.SetState(5965) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNUSABLE || _la == PlSqlParserUSABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(5968) + p.Match(PlSqlParserSEMICOLON) + 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_index_clauseContext is an interface to support dynamic dispatch. +type ICluster_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + Index_attributes() IIndex_attributesContext + + // IsCluster_index_clauseContext differentiates from other interfaces. + IsCluster_index_clauseContext() +} + +type Cluster_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_index_clauseContext() *Cluster_index_clauseContext { + var p = new(Cluster_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_index_clause + return p +} + +func InitEmptyCluster_index_clauseContext(p *Cluster_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_index_clause +} + +func (*Cluster_index_clauseContext) IsCluster_index_clauseContext() {} + +func NewCluster_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_index_clauseContext { + var p = new(Cluster_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_index_clause + + return p +} + +func (s *Cluster_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_index_clauseContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Cluster_index_clauseContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Cluster_index_clauseContext) Index_attributes() IIndex_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Cluster_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_index_clause(s) + } +} + +func (s *Cluster_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_index_clause(s) + } +} + +func (s *Cluster_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCluster_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cluster_index_clause() (localctx ICluster_index_clauseContext) { + localctx = NewCluster_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 460, PlSqlParserRULE_cluster_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5970) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5971) + p.Cluster_name() + } + p.SetState(5973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || ((int64((_la-660)) & ^0x3f) == 0 && ((int64(1)<<(_la-660))&2305843009247248385) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || _la == PlSqlParserONLINE || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822657) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(5972) + p.Index_attributes() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_nameContext is an interface to support dynamic dispatch. +type ICluster_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsCluster_nameContext differentiates from other interfaces. + IsCluster_nameContext() +} + +type Cluster_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_nameContext() *Cluster_nameContext { + var p = new(Cluster_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_name + return p +} + +func InitEmptyCluster_nameContext(p *Cluster_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_name +} + +func (*Cluster_nameContext) IsCluster_nameContext() {} + +func NewCluster_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_nameContext { + var p = new(Cluster_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_name + + return p +} + +func (s *Cluster_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Cluster_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Cluster_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Cluster_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_name(s) + } +} + +func (s *Cluster_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_name(s) + } +} + +func (s *Cluster_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCluster_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cluster_name() (localctx ICluster_nameContext) { + localctx = NewCluster_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 462, PlSqlParserRULE_cluster_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(5978) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 525, p.GetParserRuleContext()) == 1 { + { + p.SetState(5975) + p.Id_expression() + } + { + p.SetState(5976) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(5980) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_index_clauseContext is an interface to support dynamic dispatch. +type ITable_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + AllIndex_expr_option() []IIndex_expr_optionContext + Index_expr_option(i int) IIndex_expr_optionContext + RIGHT_PAREN() antlr.TerminalNode + Table_alias() ITable_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Index_properties() IIndex_propertiesContext + + // IsTable_index_clauseContext differentiates from other interfaces. + IsTable_index_clauseContext() +} + +type Table_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_index_clauseContext() *Table_index_clauseContext { + var p = new(Table_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_index_clause + return p +} + +func InitEmptyTable_index_clauseContext(p *Table_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_index_clause +} + +func (*Table_index_clauseContext) IsTable_index_clauseContext() {} + +func NewTable_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_index_clauseContext { + var p = new(Table_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_index_clause + + return p +} + +func (s *Table_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_index_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Table_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_index_clauseContext) AllIndex_expr_option() []IIndex_expr_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_expr_optionContext); ok { + len++ + } + } + + tst := make([]IIndex_expr_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_expr_optionContext); ok { + tst[i] = t.(IIndex_expr_optionContext) + i++ + } + } + + return tst +} + +func (s *Table_index_clauseContext) Index_expr_option(i int) IIndex_expr_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_expr_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_expr_optionContext) +} + +func (s *Table_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_index_clauseContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Table_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Table_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Table_index_clauseContext) Index_properties() IIndex_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_propertiesContext) +} + +func (s *Table_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_index_clause(s) + } +} + +func (s *Table_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_index_clause(s) + } +} + +func (s *Table_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_index_clause() (localctx ITable_index_clauseContext) { + localctx = NewTable_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 464, PlSqlParserRULE_table_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5982) + p.Tableview_name() + } + p.SetState(5984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(5983) + p.Table_alias() + } + + } + { + p.SetState(5986) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5987) + p.Index_expr_option() + } + p.SetState(5992) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(5988) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(5989) + p.Index_expr_option() + } + + p.SetState(5994) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(5995) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(5997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserGLOBAL || ((int64((_la-660)) & ^0x3f) == 0 && ((int64(1)<<(_la-660))&2305843009247256577) != 0) || ((int64((_la-804)) & ^0x3f) == 0 && ((int64(1)<<(_la-804))&72057594037929985) != 0) || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || _la == PlSqlParserONLINE || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822657) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(5996) + p.Index_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 +} + +// IBitmap_join_index_clauseContext is an interface to support dynamic dispatch. +type IBitmap_join_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + FROM() antlr.TerminalNode + AllTable_alias() []ITable_aliasContext + Table_alias(i int) ITable_aliasContext + Where_clause() IWhere_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Local_partitioned_index() ILocal_partitioned_indexContext + Index_attributes() IIndex_attributesContext + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + + // IsBitmap_join_index_clauseContext differentiates from other interfaces. + IsBitmap_join_index_clauseContext() +} + +type Bitmap_join_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBitmap_join_index_clauseContext() *Bitmap_join_index_clauseContext { + var p = new(Bitmap_join_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause + return p +} + +func InitEmptyBitmap_join_index_clauseContext(p *Bitmap_join_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause +} + +func (*Bitmap_join_index_clauseContext) IsBitmap_join_index_clauseContext() {} + +func NewBitmap_join_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bitmap_join_index_clauseContext { + var p = new(Bitmap_join_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bitmap_join_index_clause + + return p +} + +func (s *Bitmap_join_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bitmap_join_index_clauseContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Bitmap_join_index_clauseContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Bitmap_join_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Bitmap_join_index_clauseContext) 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 *Bitmap_join_index_clauseContext) 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 *Bitmap_join_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Bitmap_join_index_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Bitmap_join_index_clauseContext) AllTable_alias() []ITable_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_aliasContext); ok { + len++ + } + } + + tst := make([]ITable_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_aliasContext); ok { + tst[i] = t.(ITable_aliasContext) + i++ + } + } + + return tst +} + +func (s *Bitmap_join_index_clauseContext) Table_alias(i int) ITable_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Bitmap_join_index_clauseContext) 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 *Bitmap_join_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Bitmap_join_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Bitmap_join_index_clauseContext) Local_partitioned_index() ILocal_partitioned_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_partitioned_indexContext) +} + +func (s *Bitmap_join_index_clauseContext) Index_attributes() IIndex_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Bitmap_join_index_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserASC) +} + +func (s *Bitmap_join_index_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, i) +} + +func (s *Bitmap_join_index_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDESC) +} + +func (s *Bitmap_join_index_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, i) +} + +func (s *Bitmap_join_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bitmap_join_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bitmap_join_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBitmap_join_index_clause(s) + } +} + +func (s *Bitmap_join_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBitmap_join_index_clause(s) + } +} + +func (s *Bitmap_join_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBitmap_join_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Bitmap_join_index_clause() (localctx IBitmap_join_index_clauseContext) { + localctx = NewBitmap_join_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 466, PlSqlParserRULE_bitmap_join_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(5999) + p.Tableview_name() + } + { + p.SetState(6000) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6003) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) == 1 { + { + p.SetState(6001) + p.Tableview_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 529, p.GetParserRuleContext()) == 2 { + { + p.SetState(6002) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6005) + p.Column_name() + } + p.SetState(6007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6006) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(6020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6009) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6012) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 531, p.GetParserRuleContext()) == 1 { + { + p.SetState(6010) + p.Tableview_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 531, p.GetParserRuleContext()) == 2 { + { + p.SetState(6011) + p.Table_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6014) + p.Column_name() + } + p.SetState(6016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6015) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + p.SetState(6022) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6023) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6024) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6025) + p.Tableview_name() + } + { + p.SetState(6026) + p.Table_alias() + } + p.SetState(6033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6027) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6028) + p.Tableview_name() + } + { + p.SetState(6029) + p.Table_alias() + } + + p.SetState(6035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6036) + p.Where_clause() + } + p.SetState(6038) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(6037) + p.Local_partitioned_index() + } + + } + p.SetState(6041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || ((int64((_la-660)) & ^0x3f) == 0 && ((int64(1)<<(_la-660))&2305843009247248385) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || _la == PlSqlParserONLINE || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822657) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + { + p.SetState(6040) + p.Index_attributes() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_expr_optionContext is an interface to support dynamic dispatch. +type IIndex_expr_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_expr() IIndex_exprContext + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + + // IsIndex_expr_optionContext differentiates from other interfaces. + IsIndex_expr_optionContext() +} + +type Index_expr_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_expr_optionContext() *Index_expr_optionContext { + var p = new(Index_expr_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr_option + return p +} + +func InitEmptyIndex_expr_optionContext(p *Index_expr_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr_option +} + +func (*Index_expr_optionContext) IsIndex_expr_optionContext() {} + +func NewIndex_expr_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_expr_optionContext { + var p = new(Index_expr_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_expr_option + + return p +} + +func (s *Index_expr_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_expr_optionContext) Index_expr() IIndex_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_exprContext) +} + +func (s *Index_expr_optionContext) ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, 0) +} + +func (s *Index_expr_optionContext) DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, 0) +} + +func (s *Index_expr_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_expr_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_expr_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_expr_option(s) + } +} + +func (s *Index_expr_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_expr_option(s) + } +} + +func (s *Index_expr_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_expr_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_expr_option() (localctx IIndex_expr_optionContext) { + localctx = NewIndex_expr_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 468, PlSqlParserRULE_index_expr_option) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6043) + p.Index_expr() + } + p.SetState(6045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC || _la == PlSqlParserDESC { + { + p.SetState(6044) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + 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 +} + +// IIndex_exprContext is an interface to support dynamic dispatch. +type IIndex_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Expression() IExpressionContext + + // IsIndex_exprContext differentiates from other interfaces. + IsIndex_exprContext() +} + +type Index_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_exprContext() *Index_exprContext { + var p = new(Index_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr + return p +} + +func InitEmptyIndex_exprContext(p *Index_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_expr +} + +func (*Index_exprContext) IsIndex_exprContext() {} + +func NewIndex_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_exprContext { + var p = new(Index_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_expr + + return p +} + +func (s *Index_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_exprContext) 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 *Index_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Index_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_expr(s) + } +} + +func (s *Index_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_expr(s) + } +} + +func (s *Index_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_expr() (localctx IIndex_exprContext) { + localctx = NewIndex_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 470, PlSqlParserRULE_index_expr) + p.SetState(6049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 538, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6047) + p.Column_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6048) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_propertiesContext is an interface to support dynamic dispatch. +type IIndex_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGlobal_partitioned_index() []IGlobal_partitioned_indexContext + Global_partitioned_index(i int) IGlobal_partitioned_indexContext + AllLocal_partitioned_index() []ILocal_partitioned_indexContext + Local_partitioned_index(i int) ILocal_partitioned_indexContext + AllIndex_attributes() []IIndex_attributesContext + Index_attributes(i int) IIndex_attributesContext + INDEXTYPE() antlr.TerminalNode + IS() antlr.TerminalNode + Domain_index_clause() IDomain_index_clauseContext + Xmlindex_clause() IXmlindex_clauseContext + + // IsIndex_propertiesContext differentiates from other interfaces. + IsIndex_propertiesContext() +} + +type Index_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_propertiesContext() *Index_propertiesContext { + var p = new(Index_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_properties + return p +} + +func InitEmptyIndex_propertiesContext(p *Index_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_properties +} + +func (*Index_propertiesContext) IsIndex_propertiesContext() {} + +func NewIndex_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_propertiesContext { + var p = new(Index_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_properties + + return p +} + +func (s *Index_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_propertiesContext) AllGlobal_partitioned_index() []IGlobal_partitioned_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGlobal_partitioned_indexContext); ok { + len++ + } + } + + tst := make([]IGlobal_partitioned_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGlobal_partitioned_indexContext); ok { + tst[i] = t.(IGlobal_partitioned_indexContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Global_partitioned_index(i int) IGlobal_partitioned_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGlobal_partitioned_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGlobal_partitioned_indexContext) +} + +func (s *Index_propertiesContext) AllLocal_partitioned_index() []ILocal_partitioned_indexContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + len++ + } + } + + tst := make([]ILocal_partitioned_indexContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILocal_partitioned_indexContext); ok { + tst[i] = t.(ILocal_partitioned_indexContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Local_partitioned_index(i int) ILocal_partitioned_indexContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_partitioned_indexContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILocal_partitioned_indexContext) +} + +func (s *Index_propertiesContext) AllIndex_attributes() []IIndex_attributesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_attributesContext); ok { + len++ + } + } + + tst := make([]IIndex_attributesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_attributesContext); ok { + tst[i] = t.(IIndex_attributesContext) + i++ + } + } + + return tst +} + +func (s *Index_propertiesContext) Index_attributes(i int) IIndex_attributesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Index_propertiesContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Index_propertiesContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Index_propertiesContext) Domain_index_clause() IDomain_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDomain_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDomain_index_clauseContext) +} + +func (s *Index_propertiesContext) Xmlindex_clause() IXmlindex_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlindex_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlindex_clauseContext) +} + +func (s *Index_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_properties(s) + } +} + +func (s *Index_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_properties(s) + } +} + +func (s *Index_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_properties() (localctx IIndex_propertiesContext) { + localctx = NewIndex_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 472, PlSqlParserRULE_index_properties) + var _la int + + p.SetState(6064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserGLOBAL, PlSqlParserINDEXING, PlSqlParserINITRANS, PlSqlParserINVISIBLE, PlSqlParserLOCAL, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserNOSORT, PlSqlParserONLINE, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREVERSE, PlSqlParserSORT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserVISIBLE: + p.EnterOuterAlt(localctx, 1) + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserGLOBAL || ((int64((_la-660)) & ^0x3f) == 0 && ((int64(1)<<(_la-660))&2305843009247248385) != 0) || ((int64((_la-804)) & ^0x3f) == 0 && ((int64(1)<<(_la-804))&72057594037929985) != 0) || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserNOSORT || _la == PlSqlParserONLINE || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822657) != 0) || _la == PlSqlParserREVERSE || _la == PlSqlParserSORT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVISIBLE { + p.SetState(6054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGLOBAL: + { + p.SetState(6051) + p.Global_partitioned_index() + } + + case PlSqlParserLOCAL: + { + p.SetState(6052) + p.Local_partitioned_index() + } + + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINDEXING, PlSqlParserINITRANS, PlSqlParserINVISIBLE, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserNOSORT, PlSqlParserONLINE, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREVERSE, PlSqlParserSORT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserVISIBLE: + { + p.SetState(6053) + p.Index_attributes() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXTYPE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6058) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6059) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(6060) + p.Domain_index_clause() + } + + case PlSqlParserXDB, PlSqlParserXMLINDEX: + { + p.SetState(6061) + p.Xmlindex_clause() + } + + 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 +} + +// IDomain_index_clauseContext is an interface to support dynamic dispatch. +type IDomain_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Indextype() IIndextypeContext + Local_domain_index_clause() ILocal_domain_index_clauseContext + Parallel_clause() IParallel_clauseContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + + // IsDomain_index_clauseContext differentiates from other interfaces. + IsDomain_index_clauseContext() +} + +type Domain_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDomain_index_clauseContext() *Domain_index_clauseContext { + var p = new(Domain_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain_index_clause + return p +} + +func InitEmptyDomain_index_clauseContext(p *Domain_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain_index_clause +} + +func (*Domain_index_clauseContext) IsDomain_index_clauseContext() {} + +func NewDomain_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Domain_index_clauseContext { + var p = new(Domain_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_domain_index_clause + + return p +} + +func (s *Domain_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Domain_index_clauseContext) Indextype() IIndextypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndextypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndextypeContext) +} + +func (s *Domain_index_clauseContext) Local_domain_index_clause() ILocal_domain_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_domain_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_domain_index_clauseContext) +} + +func (s *Domain_index_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Domain_index_clauseContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Domain_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Domain_index_clauseContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Domain_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Domain_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Domain_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Domain_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDomain_index_clause(s) + } +} + +func (s *Domain_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDomain_index_clause(s) + } +} + +func (s *Domain_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDomain_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Domain_index_clause() (localctx IDomain_index_clauseContext) { + localctx = NewDomain_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 474, PlSqlParserRULE_domain_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6066) + p.Indextype() + } + p.SetState(6068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(6067) + p.Local_domain_index_clause() + } + + } + p.SetState(6071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6070) + p.Parallel_clause() + } + + } + p.SetState(6078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(6073) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6074) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6075) + p.Odci_parameters() + } + { + p.SetState(6076) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILocal_domain_index_clauseContext is an interface to support dynamic dispatch. +type ILocal_domain_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllPARAMETERS() []antlr.TerminalNode + PARAMETERS(i int) antlr.TerminalNode + AllOdci_parameters() []IOdci_parametersContext + Odci_parameters(i int) IOdci_parametersContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLocal_domain_index_clauseContext differentiates from other interfaces. + IsLocal_domain_index_clauseContext() +} + +type Local_domain_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_domain_index_clauseContext() *Local_domain_index_clauseContext { + var p = new(Local_domain_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause + return p +} + +func InitEmptyLocal_domain_index_clauseContext(p *Local_domain_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause +} + +func (*Local_domain_index_clauseContext) IsLocal_domain_index_clauseContext() {} + +func NewLocal_domain_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_domain_index_clauseContext { + var p = new(Local_domain_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_domain_index_clause + + return p +} + +func (s *Local_domain_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_domain_index_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_domain_index_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Local_domain_index_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Local_domain_index_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Local_domain_index_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Local_domain_index_clauseContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Local_domain_index_clauseContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Local_domain_index_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Local_domain_index_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Local_domain_index_clauseContext) AllPARAMETERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARAMETERS) +} + +func (s *Local_domain_index_clauseContext) PARAMETERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, i) +} + +func (s *Local_domain_index_clauseContext) AllOdci_parameters() []IOdci_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOdci_parametersContext); ok { + len++ + } + } + + tst := make([]IOdci_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOdci_parametersContext); ok { + tst[i] = t.(IOdci_parametersContext) + i++ + } + } + + return tst +} + +func (s *Local_domain_index_clauseContext) Odci_parameters(i int) IOdci_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Local_domain_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Local_domain_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Local_domain_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_domain_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_domain_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_domain_index_clause(s) + } +} + +func (s *Local_domain_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_domain_index_clause(s) + } +} + +func (s *Local_domain_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLocal_domain_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Local_domain_index_clause() (localctx ILocal_domain_index_clauseContext) { + localctx = NewLocal_domain_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 476, PlSqlParserRULE_local_domain_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6080) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6081) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6082) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6083) + p.Partition_name() + } + p.SetState(6089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(6084) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6085) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6086) + p.Odci_parameters() + } + { + p.SetState(6087) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6091) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6092) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6093) + p.Partition_name() + } + p.SetState(6099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(6094) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6095) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6096) + p.Odci_parameters() + } + { + p.SetState(6097) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(6105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6106) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlindex_clauseContext is an interface to support dynamic dispatch. +type IXmlindex_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLINDEX() antlr.TerminalNode + XDB() antlr.TerminalNode + PERIOD() antlr.TerminalNode + Local_xmlindex_clause() ILocal_xmlindex_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsXmlindex_clauseContext differentiates from other interfaces. + IsXmlindex_clauseContext() +} + +type Xmlindex_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlindex_clauseContext() *Xmlindex_clauseContext { + var p = new(Xmlindex_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlindex_clause + return p +} + +func InitEmptyXmlindex_clauseContext(p *Xmlindex_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlindex_clause +} + +func (*Xmlindex_clauseContext) IsXmlindex_clauseContext() {} + +func NewXmlindex_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlindex_clauseContext { + var p = new(Xmlindex_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlindex_clause + + return p +} + +func (s *Xmlindex_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlindex_clauseContext) XMLINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX, 0) +} + +func (s *Xmlindex_clauseContext) XDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserXDB, 0) +} + +func (s *Xmlindex_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Xmlindex_clauseContext) Local_xmlindex_clause() ILocal_xmlindex_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILocal_xmlindex_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILocal_xmlindex_clauseContext) +} + +func (s *Xmlindex_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Xmlindex_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlindex_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlindex_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlindex_clause(s) + } +} + +func (s *Xmlindex_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlindex_clause(s) + } +} + +func (s *Xmlindex_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlindex_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlindex_clause() (localctx IXmlindex_clauseContext) { + localctx = NewXmlindex_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 478, PlSqlParserRULE_xmlindex_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6112) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXDB { + { + p.SetState(6110) + p.Match(PlSqlParserXDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6111) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6114) + p.Match(PlSqlParserXMLINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(6115) + p.Local_xmlindex_clause() + } + + } + p.SetState(6119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6118) + p.Parallel_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 +} + +// ILocal_xmlindex_clauseContext is an interface to support dynamic dispatch. +type ILocal_xmlindex_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLocal_xmlindex_clauseContext differentiates from other interfaces. + IsLocal_xmlindex_clauseContext() +} + +type Local_xmlindex_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_xmlindex_clauseContext() *Local_xmlindex_clauseContext { + var p = new(Local_xmlindex_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause + return p +} + +func InitEmptyLocal_xmlindex_clauseContext(p *Local_xmlindex_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause +} + +func (*Local_xmlindex_clauseContext) IsLocal_xmlindex_clauseContext() {} + +func NewLocal_xmlindex_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_xmlindex_clauseContext { + var p = new(Local_xmlindex_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_xmlindex_clause + + return p +} + +func (s *Local_xmlindex_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_xmlindex_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_xmlindex_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Local_xmlindex_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Local_xmlindex_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Local_xmlindex_clauseContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Local_xmlindex_clauseContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Local_xmlindex_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Local_xmlindex_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Local_xmlindex_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Local_xmlindex_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_xmlindex_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_xmlindex_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_xmlindex_clause(s) + } +} + +func (s *Local_xmlindex_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_xmlindex_clause(s) + } +} + +func (s *Local_xmlindex_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLocal_xmlindex_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Local_xmlindex_clause() (localctx ILocal_xmlindex_clauseContext) { + localctx = NewLocal_xmlindex_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 480, PlSqlParserRULE_local_xmlindex_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6121) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6122) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6123) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6124) + p.Partition_name() + } + p.SetState(6130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6125) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6126) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6127) + p.Partition_name() + } + + p.SetState(6132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6133) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGlobal_partitioned_indexContext is an interface to support dynamic dispatch. +type IGlobal_partitioned_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GLOBAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllIndex_partitioning_clause() []IIndex_partitioning_clauseContext + Index_partitioning_clause(i int) IIndex_partitioning_clauseContext + HASH() antlr.TerminalNode + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGlobal_partitioned_indexContext differentiates from other interfaces. + IsGlobal_partitioned_indexContext() +} + +type Global_partitioned_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGlobal_partitioned_indexContext() *Global_partitioned_indexContext { + var p = new(Global_partitioned_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_global_partitioned_index + return p +} + +func InitEmptyGlobal_partitioned_indexContext(p *Global_partitioned_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_global_partitioned_index +} + +func (*Global_partitioned_indexContext) IsGlobal_partitioned_indexContext() {} + +func NewGlobal_partitioned_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Global_partitioned_indexContext { + var p = new(Global_partitioned_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_global_partitioned_index + + return p +} + +func (s *Global_partitioned_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Global_partitioned_indexContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Global_partitioned_indexContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Global_partitioned_indexContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Global_partitioned_indexContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Global_partitioned_indexContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Global_partitioned_indexContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Global_partitioned_indexContext) 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 *Global_partitioned_indexContext) 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 *Global_partitioned_indexContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Global_partitioned_indexContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Global_partitioned_indexContext) AllIndex_partitioning_clause() []IIndex_partitioning_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_partitioning_clauseContext); ok { + len++ + } + } + + tst := make([]IIndex_partitioning_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_partitioning_clauseContext); ok { + tst[i] = t.(IIndex_partitioning_clauseContext) + i++ + } + } + + return tst +} + +func (s *Global_partitioned_indexContext) Index_partitioning_clause(i int) IIndex_partitioning_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partitioning_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partitioning_clauseContext) +} + +func (s *Global_partitioned_indexContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Global_partitioned_indexContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Global_partitioned_indexContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Global_partitioned_indexContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Global_partitioned_indexContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Global_partitioned_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Global_partitioned_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Global_partitioned_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGlobal_partitioned_index(s) + } +} + +func (s *Global_partitioned_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGlobal_partitioned_index(s) + } +} + +func (s *Global_partitioned_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGlobal_partitioned_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Global_partitioned_index() (localctx IGlobal_partitioned_indexContext) { + localctx = NewGlobal_partitioned_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 482, PlSqlParserRULE_global_partitioned_index) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6137) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(6138) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6139) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRANGE: + { + p.SetState(6140) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6141) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6142) + p.Column_name() + } + p.SetState(6147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6143) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6144) + p.Column_name() + } + + p.SetState(6149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6150) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6151) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6152) + p.Index_partitioning_clause() + } + p.SetState(6157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6153) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6154) + p.Index_partitioning_clause() + } + + p.SetState(6159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6160) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASH: + { + p.SetState(6162) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6163) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6164) + p.Column_name() + } + p.SetState(6169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6165) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6166) + p.Column_name() + } + + p.SetState(6171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6172) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(6173) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(6174) + p.Hash_partitions_by_quantity() + } + + 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 +} + +// IIndex_partitioning_clauseContext is an interface to support dynamic dispatch. +type IIndex_partitioning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + VALUES() antlr.TerminalNode + LESS() antlr.TerminalNode + THAN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + RIGHT_PAREN() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Segment_attributes_clause() ISegment_attributes_clauseContext + + // IsIndex_partitioning_clauseContext differentiates from other interfaces. + IsIndex_partitioning_clauseContext() +} + +type Index_partitioning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partitioning_clauseContext() *Index_partitioning_clauseContext { + var p = new(Index_partitioning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause + return p +} + +func InitEmptyIndex_partitioning_clauseContext(p *Index_partitioning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause +} + +func (*Index_partitioning_clauseContext) IsIndex_partitioning_clauseContext() {} + +func NewIndex_partitioning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partitioning_clauseContext { + var p = new(Index_partitioning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_partitioning_clause + + return p +} + +func (s *Index_partitioning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partitioning_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Index_partitioning_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Index_partitioning_clauseContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Index_partitioning_clauseContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Index_partitioning_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_partitioning_clauseContext) 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 *Index_partitioning_clauseContext) 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 *Index_partitioning_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_partitioning_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Index_partitioning_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Index_partitioning_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Index_partitioning_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_partitioning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partitioning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partitioning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_partitioning_clause(s) + } +} + +func (s *Index_partitioning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_partitioning_clause(s) + } +} + +func (s *Index_partitioning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_partitioning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_partitioning_clause() (localctx IIndex_partitioning_clauseContext) { + localctx = NewIndex_partitioning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 484, PlSqlParserRULE_index_partitioning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6181) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(6182) + p.Partition_name() + } + + } + { + p.SetState(6185) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6186) + p.Match(PlSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6187) + p.Match(PlSqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6188) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6189) + p.Literal() + } + p.SetState(6194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6190) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6191) + p.Literal() + } + + p.SetState(6196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6197) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(6198) + p.Segment_attributes_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 +} + +// ILocal_partitioned_indexContext is an interface to support dynamic dispatch. +type ILocal_partitioned_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + On_range_partitioned_table() IOn_range_partitioned_tableContext + On_list_partitioned_table() IOn_list_partitioned_tableContext + On_hash_partitioned_table() IOn_hash_partitioned_tableContext + On_comp_partitioned_table() IOn_comp_partitioned_tableContext + + // IsLocal_partitioned_indexContext differentiates from other interfaces. + IsLocal_partitioned_indexContext() +} + +type Local_partitioned_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLocal_partitioned_indexContext() *Local_partitioned_indexContext { + var p = new(Local_partitioned_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_partitioned_index + return p +} + +func InitEmptyLocal_partitioned_indexContext(p *Local_partitioned_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_local_partitioned_index +} + +func (*Local_partitioned_indexContext) IsLocal_partitioned_indexContext() {} + +func NewLocal_partitioned_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Local_partitioned_indexContext { + var p = new(Local_partitioned_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_local_partitioned_index + + return p +} + +func (s *Local_partitioned_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Local_partitioned_indexContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Local_partitioned_indexContext) On_range_partitioned_table() IOn_range_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_range_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_range_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_list_partitioned_table() IOn_list_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_list_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_list_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_hash_partitioned_table() IOn_hash_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_hash_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_hash_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) On_comp_partitioned_table() IOn_comp_partitioned_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_comp_partitioned_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_comp_partitioned_tableContext) +} + +func (s *Local_partitioned_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Local_partitioned_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Local_partitioned_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLocal_partitioned_index(s) + } +} + +func (s *Local_partitioned_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLocal_partitioned_index(s) + } +} + +func (s *Local_partitioned_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLocal_partitioned_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Local_partitioned_index() (localctx ILocal_partitioned_indexContext) { + localctx = NewLocal_partitioned_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 486, PlSqlParserRULE_local_partitioned_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6201) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6206) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 1 { + { + p.SetState(6202) + p.On_range_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 2 { + { + p.SetState(6203) + p.On_list_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 3 { + { + p.SetState(6204) + p.On_hash_partitioned_table() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 564, p.GetParserRuleContext()) == 4 { + { + p.SetState(6205) + p.On_comp_partitioned_table() + } + + } 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 +} + +// IOn_range_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_range_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPartitioned_table() []IPartitioned_tableContext + Partitioned_table(i int) IPartitioned_tableContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_range_partitioned_tableContext differentiates from other interfaces. + IsOn_range_partitioned_tableContext() +} + +type On_range_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_range_partitioned_tableContext() *On_range_partitioned_tableContext { + var p = new(On_range_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table + return p +} + +func InitEmptyOn_range_partitioned_tableContext(p *On_range_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table +} + +func (*On_range_partitioned_tableContext) IsOn_range_partitioned_tableContext() {} + +func NewOn_range_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_range_partitioned_tableContext { + var p = new(On_range_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_range_partitioned_table + + return p +} + +func (s *On_range_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_range_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_range_partitioned_tableContext) AllPartitioned_table() []IPartitioned_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioned_tableContext); ok { + len++ + } + } + + tst := make([]IPartitioned_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioned_tableContext); ok { + tst[i] = t.(IPartitioned_tableContext) + i++ + } + } + + return tst +} + +func (s *On_range_partitioned_tableContext) Partitioned_table(i int) IPartitioned_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioned_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioned_tableContext) +} + +func (s *On_range_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_range_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_range_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_range_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_range_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_range_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_range_partitioned_table(s) + } +} + +func (s *On_range_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_range_partitioned_table(s) + } +} + +func (s *On_range_partitioned_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_range_partitioned_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_range_partitioned_table() (localctx IOn_range_partitioned_tableContext) { + localctx = NewOn_range_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 488, PlSqlParserRULE_on_range_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6208) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6209) + p.Partitioned_table() + } + p.SetState(6214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6210) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6211) + p.Partitioned_table() + } + + p.SetState(6216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6217) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_list_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_list_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPartitioned_table() []IPartitioned_tableContext + Partitioned_table(i int) IPartitioned_tableContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_list_partitioned_tableContext differentiates from other interfaces. + IsOn_list_partitioned_tableContext() +} + +type On_list_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_list_partitioned_tableContext() *On_list_partitioned_tableContext { + var p = new(On_list_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table + return p +} + +func InitEmptyOn_list_partitioned_tableContext(p *On_list_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table +} + +func (*On_list_partitioned_tableContext) IsOn_list_partitioned_tableContext() {} + +func NewOn_list_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_list_partitioned_tableContext { + var p = new(On_list_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_list_partitioned_table + + return p +} + +func (s *On_list_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_list_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_list_partitioned_tableContext) AllPartitioned_table() []IPartitioned_tableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioned_tableContext); ok { + len++ + } + } + + tst := make([]IPartitioned_tableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioned_tableContext); ok { + tst[i] = t.(IPartitioned_tableContext) + i++ + } + } + + return tst +} + +func (s *On_list_partitioned_tableContext) Partitioned_table(i int) IPartitioned_tableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioned_tableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioned_tableContext) +} + +func (s *On_list_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_list_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_list_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_list_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_list_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_list_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_list_partitioned_table(s) + } +} + +func (s *On_list_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_list_partitioned_table(s) + } +} + +func (s *On_list_partitioned_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_list_partitioned_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_list_partitioned_table() (localctx IOn_list_partitioned_tableContext) { + localctx = NewOn_list_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 490, PlSqlParserRULE_on_list_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6219) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6220) + p.Partitioned_table() + } + p.SetState(6225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6221) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6222) + p.Partitioned_table() + } + + p.SetState(6227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6228) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartitioned_tableContext is an interface to support dynamic dispatch. +type IPartitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsPartitioned_tableContext differentiates from other interfaces. + IsPartitioned_tableContext() +} + +type Partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitioned_tableContext() *Partitioned_tableContext { + var p = new(Partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioned_table + return p +} + +func InitEmptyPartitioned_tableContext(p *Partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioned_table +} + +func (*Partitioned_tableContext) IsPartitioned_tableContext() {} + +func NewPartitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partitioned_tableContext { + var p = new(Partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partitioned_table + + return p +} + +func (s *Partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partitioned_tableContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partitioned_tableContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partitioned_tableContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Partitioned_tableContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Partitioned_tableContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioned_tableContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Partitioned_tableContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartitioned_table(s) + } +} + +func (s *Partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartitioned_table(s) + } +} + +func (s *Partitioned_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartitioned_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partitioned_table() (localctx IPartitioned_tableContext) { + localctx = NewPartitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 492, PlSqlParserRULE_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6230) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6232) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 567, p.GetParserRuleContext()) == 1 { + { + p.SetState(6231) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 568, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6234) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6235) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(6242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6241) + p.Match(PlSqlParserUNUSABLE) + 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 +} + +// IOn_hash_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_hash_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllOn_hash_partitioned_clause() []IOn_hash_partitioned_clauseContext + On_hash_partitioned_clause(i int) IOn_hash_partitioned_clauseContext + + // IsOn_hash_partitioned_tableContext differentiates from other interfaces. + IsOn_hash_partitioned_tableContext() +} + +type On_hash_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_hash_partitioned_tableContext() *On_hash_partitioned_tableContext { + var p = new(On_hash_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table + return p +} + +func InitEmptyOn_hash_partitioned_tableContext(p *On_hash_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table +} + +func (*On_hash_partitioned_tableContext) IsOn_hash_partitioned_tableContext() {} + +func NewOn_hash_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_hash_partitioned_tableContext { + var p = new(On_hash_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_table + + return p +} + +func (s *On_hash_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_hash_partitioned_tableContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *On_hash_partitioned_tableContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *On_hash_partitioned_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *On_hash_partitioned_tableContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *On_hash_partitioned_tableContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_hash_partitioned_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *On_hash_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_hash_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_hash_partitioned_tableContext) AllOn_hash_partitioned_clause() []IOn_hash_partitioned_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + len++ + } + } + + tst := make([]IOn_hash_partitioned_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + tst[i] = t.(IOn_hash_partitioned_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_hash_partitioned_tableContext) On_hash_partitioned_clause(i int) IOn_hash_partitioned_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_hash_partitioned_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_hash_partitioned_clauseContext) +} + +func (s *On_hash_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_hash_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_hash_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_hash_partitioned_table(s) + } +} + +func (s *On_hash_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_hash_partitioned_table(s) + } +} + +func (s *On_hash_partitioned_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_hash_partitioned_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_hash_partitioned_table() (localctx IOn_hash_partitioned_tableContext) { + localctx = NewOn_hash_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 494, PlSqlParserRULE_on_hash_partitioned_table) + var _la int + + p.SetState(6268) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6244) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6245) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6246) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6247) + p.Tablespace() + } + p.SetState(6252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6248) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6249) + p.Tablespace() + } + + p.SetState(6254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6255) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6257) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6258) + p.On_hash_partitioned_clause() + } + p.SetState(6263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6259) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6260) + p.On_hash_partitioned_clause() + } + + p.SetState(6265) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6266) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_hash_partitioned_clauseContext is an interface to support dynamic dispatch. +type IOn_hash_partitioned_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsOn_hash_partitioned_clauseContext differentiates from other interfaces. + IsOn_hash_partitioned_clauseContext() +} + +type On_hash_partitioned_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_hash_partitioned_clauseContext() *On_hash_partitioned_clauseContext { + var p = new(On_hash_partitioned_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause + return p +} + +func InitEmptyOn_hash_partitioned_clauseContext(p *On_hash_partitioned_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause +} + +func (*On_hash_partitioned_clauseContext) IsOn_hash_partitioned_clauseContext() {} + +func NewOn_hash_partitioned_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_hash_partitioned_clauseContext { + var p = new(On_hash_partitioned_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_hash_partitioned_clause + + return p +} + +func (s *On_hash_partitioned_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_hash_partitioned_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *On_hash_partitioned_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *On_hash_partitioned_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *On_hash_partitioned_clauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_hash_partitioned_clauseContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *On_hash_partitioned_clauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *On_hash_partitioned_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_hash_partitioned_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_hash_partitioned_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_hash_partitioned_clause(s) + } +} + +func (s *On_hash_partitioned_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_hash_partitioned_clause(s) + } +} + +func (s *On_hash_partitioned_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_hash_partitioned_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_hash_partitioned_clause() (localctx IOn_hash_partitioned_clauseContext) { + localctx = NewOn_hash_partitioned_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 496, PlSqlParserRULE_on_hash_partitioned_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6270) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6272) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 574, p.GetParserRuleContext()) == 1 { + { + p.SetState(6271) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6276) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6274) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6275) + p.Tablespace() + } + + } + p.SetState(6279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6278) + p.Key_compression() + } + + } + p.SetState(6282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6281) + p.Match(PlSqlParserUNUSABLE) + 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 +} + +// IOn_comp_partitioned_tableContext is an interface to support dynamic dispatch. +type IOn_comp_partitioned_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllOn_comp_partitioned_clause() []IOn_comp_partitioned_clauseContext + On_comp_partitioned_clause(i int) IOn_comp_partitioned_clauseContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_comp_partitioned_tableContext differentiates from other interfaces. + IsOn_comp_partitioned_tableContext() +} + +type On_comp_partitioned_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_comp_partitioned_tableContext() *On_comp_partitioned_tableContext { + var p = new(On_comp_partitioned_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table + return p +} + +func InitEmptyOn_comp_partitioned_tableContext(p *On_comp_partitioned_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table +} + +func (*On_comp_partitioned_tableContext) IsOn_comp_partitioned_tableContext() {} + +func NewOn_comp_partitioned_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_comp_partitioned_tableContext { + var p = new(On_comp_partitioned_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_table + + return p +} + +func (s *On_comp_partitioned_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_comp_partitioned_tableContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *On_comp_partitioned_tableContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *On_comp_partitioned_tableContext) AllOn_comp_partitioned_clause() []IOn_comp_partitioned_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + len++ + } + } + + tst := make([]IOn_comp_partitioned_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + tst[i] = t.(IOn_comp_partitioned_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_tableContext) On_comp_partitioned_clause(i int) IOn_comp_partitioned_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_comp_partitioned_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOn_comp_partitioned_clauseContext) +} + +func (s *On_comp_partitioned_tableContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *On_comp_partitioned_tableContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *On_comp_partitioned_tableContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *On_comp_partitioned_tableContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *On_comp_partitioned_tableContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_tableContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *On_comp_partitioned_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_comp_partitioned_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_comp_partitioned_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_comp_partitioned_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_comp_partitioned_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_comp_partitioned_table(s) + } +} + +func (s *On_comp_partitioned_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_comp_partitioned_table(s) + } +} + +func (s *On_comp_partitioned_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_comp_partitioned_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_comp_partitioned_table() (localctx IOn_comp_partitioned_tableContext) { + localctx = NewOn_comp_partitioned_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 498, PlSqlParserRULE_on_comp_partitioned_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(6284) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6285) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6286) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6287) + p.Tablespace() + } + p.SetState(6292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6288) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6289) + p.Tablespace() + } + + p.SetState(6294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6295) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6299) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6300) + p.On_comp_partitioned_clause() + } + p.SetState(6305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6301) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6302) + p.On_comp_partitioned_clause() + } + + p.SetState(6307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6308) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_comp_partitioned_clauseContext is an interface to support dynamic dispatch. +type IOn_comp_partitioned_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + Index_subpartition_clause() IIndex_subpartition_clauseContext + + // IsOn_comp_partitioned_clauseContext differentiates from other interfaces. + IsOn_comp_partitioned_clauseContext() +} + +type On_comp_partitioned_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_comp_partitioned_clauseContext() *On_comp_partitioned_clauseContext { + var p = new(On_comp_partitioned_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause + return p +} + +func InitEmptyOn_comp_partitioned_clauseContext(p *On_comp_partitioned_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause +} + +func (*On_comp_partitioned_clauseContext) IsOn_comp_partitioned_clauseContext() {} + +func NewOn_comp_partitioned_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_comp_partitioned_clauseContext { + var p = new(On_comp_partitioned_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_comp_partitioned_clause + + return p +} + +func (s *On_comp_partitioned_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_comp_partitioned_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *On_comp_partitioned_clauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *On_comp_partitioned_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *On_comp_partitioned_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *On_comp_partitioned_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *On_comp_partitioned_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *On_comp_partitioned_clauseContext) Index_subpartition_clause() IIndex_subpartition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_clauseContext) +} + +func (s *On_comp_partitioned_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_comp_partitioned_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_comp_partitioned_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_comp_partitioned_clause(s) + } +} + +func (s *On_comp_partitioned_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_comp_partitioned_clause(s) + } +} + +func (s *On_comp_partitioned_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_comp_partitioned_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_comp_partitioned_clause() (localctx IOn_comp_partitioned_clauseContext) { + localctx = NewOn_comp_partitioned_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 500, PlSqlParserRULE_on_comp_partitioned_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6310) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 581, p.GetParserRuleContext()) == 1 { + { + p.SetState(6311) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 582, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6314) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6315) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6321) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(6322) + p.Index_subpartition_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 +} + +// IIndex_subpartition_clauseContext is an interface to support dynamic dispatch. +type IIndex_subpartition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllIndex_subpartition_subclause() []IIndex_subpartition_subclauseContext + Index_subpartition_subclause(i int) IIndex_subpartition_subclauseContext + + // IsIndex_subpartition_clauseContext differentiates from other interfaces. + IsIndex_subpartition_clauseContext() +} + +type Index_subpartition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_subpartition_clauseContext() *Index_subpartition_clauseContext { + var p = new(Index_subpartition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause + return p +} + +func InitEmptyIndex_subpartition_clauseContext(p *Index_subpartition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause +} + +func (*Index_subpartition_clauseContext) IsIndex_subpartition_clauseContext() {} + +func NewIndex_subpartition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_subpartition_clauseContext { + var p = new(Index_subpartition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_subpartition_clause + + return p +} + +func (s *Index_subpartition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_subpartition_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Index_subpartition_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Index_subpartition_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_subpartition_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Index_subpartition_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_subpartition_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_subpartition_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Index_subpartition_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Index_subpartition_clauseContext) AllIndex_subpartition_subclause() []IIndex_subpartition_subclauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + len++ + } + } + + tst := make([]IIndex_subpartition_subclauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + tst[i] = t.(IIndex_subpartition_subclauseContext) + i++ + } + } + + return tst +} + +func (s *Index_subpartition_clauseContext) Index_subpartition_subclause(i int) IIndex_subpartition_subclauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_subclauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_subclauseContext) +} + +func (s *Index_subpartition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_subpartition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_subpartition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_subpartition_clause(s) + } +} + +func (s *Index_subpartition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_subpartition_clause(s) + } +} + +func (s *Index_subpartition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_subpartition_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_subpartition_clause() (localctx IIndex_subpartition_clauseContext) { + localctx = NewIndex_subpartition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 502, PlSqlParserRULE_index_subpartition_clause) + var _la int + + p.SetState(6349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTORE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6325) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6326) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6327) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6328) + p.Tablespace() + } + p.SetState(6333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6329) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6330) + p.Tablespace() + } + + p.SetState(6335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6336) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6338) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6339) + p.Index_subpartition_subclause() + } + p.SetState(6344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6340) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6341) + p.Index_subpartition_subclause() + } + + p.SetState(6346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6347) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_subpartition_subclauseContext is an interface to support dynamic dispatch. +type IIndex_subpartition_subclauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsIndex_subpartition_subclauseContext differentiates from other interfaces. + IsIndex_subpartition_subclauseContext() +} + +type Index_subpartition_subclauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_subpartition_subclauseContext() *Index_subpartition_subclauseContext { + var p = new(Index_subpartition_subclauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause + return p +} + +func InitEmptyIndex_subpartition_subclauseContext(p *Index_subpartition_subclauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause +} + +func (*Index_subpartition_subclauseContext) IsIndex_subpartition_subclauseContext() {} + +func NewIndex_subpartition_subclauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_subpartition_subclauseContext { + var p = new(Index_subpartition_subclauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_subpartition_subclause + + return p +} + +func (s *Index_subpartition_subclauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_subpartition_subclauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Index_subpartition_subclauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Index_subpartition_subclauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Index_subpartition_subclauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_subpartition_subclauseContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_subpartition_subclauseContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Index_subpartition_subclauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_subpartition_subclauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_subpartition_subclauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_subpartition_subclause(s) + } +} + +func (s *Index_subpartition_subclauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_subpartition_subclause(s) + } +} + +func (s *Index_subpartition_subclauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_subpartition_subclause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_subpartition_subclause() (localctx IIndex_subpartition_subclauseContext) { + localctx = NewIndex_subpartition_subclauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 504, PlSqlParserRULE_index_subpartition_subclause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6351) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6353) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 588, p.GetParserRuleContext()) == 1 { + { + p.SetState(6352) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6355) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6356) + p.Tablespace() + } + + } + p.SetState(6360) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6359) + p.Key_compression() + } + + } + p.SetState(6363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6362) + p.Match(PlSqlParserUNUSABLE) + 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 +} + +// IOdci_parametersContext is an interface to support dynamic dispatch. +type IOdci_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsOdci_parametersContext differentiates from other interfaces. + IsOdci_parametersContext() +} + +type Odci_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOdci_parametersContext() *Odci_parametersContext { + var p = new(Odci_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_odci_parameters + return p +} + +func InitEmptyOdci_parametersContext(p *Odci_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_odci_parameters +} + +func (*Odci_parametersContext) IsOdci_parametersContext() {} + +func NewOdci_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Odci_parametersContext { + var p = new(Odci_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_odci_parameters + + return p +} + +func (s *Odci_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Odci_parametersContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Odci_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Odci_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Odci_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOdci_parameters(s) + } +} + +func (s *Odci_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOdci_parameters(s) + } +} + +func (s *Odci_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOdci_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Odci_parameters() (localctx IOdci_parametersContext) { + localctx = NewOdci_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 506, PlSqlParserRULE_odci_parameters) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6365) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IIndextypeContext is an interface to support dynamic dispatch. +type IIndextypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsIndextypeContext differentiates from other interfaces. + IsIndextypeContext() +} + +type IndextypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndextypeContext() *IndextypeContext { + var p = new(IndextypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype + return p +} + +func InitEmptyIndextypeContext(p *IndextypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype +} + +func (*IndextypeContext) IsIndextypeContext() {} + +func NewIndextypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IndextypeContext { + var p = new(IndextypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indextype + + return p +} + +func (s *IndextypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *IndextypeContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *IndextypeContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *IndextypeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *IndextypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IndextypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IndextypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndextype(s) + } +} + +func (s *IndextypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndextype(s) + } +} + +func (s *IndextypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndextype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Indextype() (localctx IIndextypeContext) { + localctx = NewIndextypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 508, PlSqlParserRULE_indextype) + p.EnterOuterAlt(localctx, 1) + p.SetState(6370) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 592, p.GetParserRuleContext()) == 1 { + { + p.SetState(6367) + p.Id_expression() + } + { + p.SetState(6368) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6372) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_indexContext is an interface to support dynamic dispatch. +type IAlter_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + SEMICOLON() antlr.TerminalNode + Alter_index_ops_set1() IAlter_index_ops_set1Context + Alter_index_ops_set2() IAlter_index_ops_set2Context + + // IsAlter_indexContext differentiates from other interfaces. + IsAlter_indexContext() +} + +type Alter_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_indexContext() *Alter_indexContext { + var p = new(Alter_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index + return p +} + +func InitEmptyAlter_indexContext(p *Alter_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index +} + +func (*Alter_indexContext) IsAlter_indexContext() {} + +func NewAlter_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_indexContext { + var p = new(Alter_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index + + return p +} + +func (s *Alter_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_indexContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Alter_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Alter_indexContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_indexContext) Alter_index_ops_set1() IAlter_index_ops_set1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_ops_set1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_ops_set1Context) +} + +func (s *Alter_indexContext) Alter_index_ops_set2() IAlter_index_ops_set2Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_ops_set2Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_ops_set2Context) +} + +func (s *Alter_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index(s) + } +} + +func (s *Alter_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index(s) + } +} + +func (s *Alter_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_index() (localctx IAlter_indexContext) { + localctx = NewAlter_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 510, PlSqlParserRULE_alter_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6374) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6375) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6376) + p.Index_name() + } + p.SetState(6379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE, PlSqlParserCOMPUTE, PlSqlParserDEALLOCATE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSHRINK, PlSqlParserSTORAGE: + { + p.SetState(6377) + p.Alter_index_ops_set1() + } + + case PlSqlParserADD, PlSqlParserCOALESCE, PlSqlParserCOMPILE, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserINVISIBLE, PlSqlParserMODIFY, PlSqlParserMONITORING, PlSqlParserNOMONITORING, PlSqlParserPARAMETERS, PlSqlParserREBUILD, PlSqlParserRENAME, PlSqlParserSPLIT, PlSqlParserUNUSABLE, PlSqlParserUPDATE, PlSqlParserVISIBLE: + { + p.SetState(6378) + p.Alter_index_ops_set2() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6381) + p.Match(PlSqlParserSEMICOLON) + 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_index_ops_set1Context is an interface to support dynamic dispatch. +type IAlter_index_ops_set1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsAlter_index_ops_set1Context differentiates from other interfaces. + IsAlter_index_ops_set1Context() +} + +type Alter_index_ops_set1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_ops_set1Context() *Alter_index_ops_set1Context { + var p = new(Alter_index_ops_set1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 + return p +} + +func InitEmptyAlter_index_ops_set1Context(p *Alter_index_ops_set1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 +} + +func (*Alter_index_ops_set1Context) IsAlter_index_ops_set1Context() {} + +func NewAlter_index_ops_set1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_ops_set1Context { + var p = new(Alter_index_ops_set1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set1 + + return p +} + +func (s *Alter_index_ops_set1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_ops_set1Context) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_index_ops_set1Context) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_index_ops_set1Context) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_index_ops_set1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_ops_set1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_ops_set1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_ops_set1(s) + } +} + +func (s *Alter_index_ops_set1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_ops_set1(s) + } +} + +func (s *Alter_index_ops_set1Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_index_ops_set1(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_index_ops_set1() (localctx IAlter_index_ops_set1Context) { + localctx = NewAlter_index_ops_set1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 512, PlSqlParserRULE_alter_index_ops_set1) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822657) != 0) || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE { + p.SetState(6389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEALLOCATE: + { + p.SetState(6383) + p.Deallocate_unused_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(6384) + p.Allocate_extent_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(6385) + p.Shrink_clause() + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(6386) + p.Parallel_clause() + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6387) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6388) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6391) + 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_index_ops_set2Context is an interface to support dynamic dispatch. +type IAlter_index_ops_set2Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rebuild_clause() IRebuild_clauseContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Enable_or_disable() IEnable_or_disableContext + UNUSABLE() antlr.TerminalNode + Visible_or_invisible() IVisible_or_invisibleContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_index_name() INew_index_nameContext + COALESCE() antlr.TerminalNode + Monitoring_nomonitoring() IMonitoring_nomonitoringContext + USAGE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + Alter_index_partitioning() IAlter_index_partitioningContext + + // IsAlter_index_ops_set2Context differentiates from other interfaces. + IsAlter_index_ops_set2Context() +} + +type Alter_index_ops_set2Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_ops_set2Context() *Alter_index_ops_set2Context { + var p = new(Alter_index_ops_set2Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 + return p +} + +func InitEmptyAlter_index_ops_set2Context(p *Alter_index_ops_set2Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 +} + +func (*Alter_index_ops_set2Context) IsAlter_index_ops_set2Context() {} + +func NewAlter_index_ops_set2Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_ops_set2Context { + var p = new(Alter_index_ops_set2Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_ops_set2 + + return p +} + +func (s *Alter_index_ops_set2Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_ops_set2Context) Rebuild_clause() IRebuild_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRebuild_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRebuild_clauseContext) +} + +func (s *Alter_index_ops_set2Context) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Alter_index_ops_set2Context) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_index_ops_set2Context) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Alter_index_ops_set2Context) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_index_ops_set2Context) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_index_ops_set2Context) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_index_ops_set2Context) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Alter_index_ops_set2Context) Visible_or_invisible() IVisible_or_invisibleContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVisible_or_invisibleContext) +} + +func (s *Alter_index_ops_set2Context) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_index_ops_set2Context) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_index_ops_set2Context) New_index_name() INew_index_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_index_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_index_nameContext) +} + +func (s *Alter_index_ops_set2Context) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_index_ops_set2Context) Monitoring_nomonitoring() IMonitoring_nomonitoringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMonitoring_nomonitoringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMonitoring_nomonitoringContext) +} + +func (s *Alter_index_ops_set2Context) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Alter_index_ops_set2Context) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Alter_index_ops_set2Context) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Alter_index_ops_set2Context) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Alter_index_ops_set2Context) Alter_index_partitioning() IAlter_index_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_index_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_index_partitioningContext) +} + +func (s *Alter_index_ops_set2Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_ops_set2Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_ops_set2Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_ops_set2(s) + } +} + +func (s *Alter_index_ops_set2Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_ops_set2(s) + } +} + +func (s *Alter_index_ops_set2Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_index_ops_set2(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_index_ops_set2() (localctx IAlter_index_ops_set2Context) { + localctx = NewAlter_index_ops_set2Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 514, PlSqlParserRULE_alter_index_ops_set2) + p.SetState(6414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 596, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6393) + p.Rebuild_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6394) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6395) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6396) + p.Odci_parameters() + } + { + p.SetState(6397) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6399) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6400) + p.Enable_or_disable() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6401) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6402) + p.Visible_or_invisible() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6403) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6404) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6405) + p.New_index_name() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6406) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6407) + p.Monitoring_nomonitoring() + } + { + p.SetState(6408) + p.Match(PlSqlParserUSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(6410) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6411) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6412) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(6413) + p.Alter_index_partitioning() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVisible_or_invisibleContext is an interface to support dynamic dispatch. +type IVisible_or_invisibleContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + + // IsVisible_or_invisibleContext differentiates from other interfaces. + IsVisible_or_invisibleContext() +} + +type Visible_or_invisibleContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVisible_or_invisibleContext() *Visible_or_invisibleContext { + var p = new(Visible_or_invisibleContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_visible_or_invisible + return p +} + +func InitEmptyVisible_or_invisibleContext(p *Visible_or_invisibleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_visible_or_invisible +} + +func (*Visible_or_invisibleContext) IsVisible_or_invisibleContext() {} + +func NewVisible_or_invisibleContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Visible_or_invisibleContext { + var p = new(Visible_or_invisibleContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_visible_or_invisible + + return p +} + +func (s *Visible_or_invisibleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Visible_or_invisibleContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Visible_or_invisibleContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Visible_or_invisibleContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Visible_or_invisibleContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Visible_or_invisibleContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVisible_or_invisible(s) + } +} + +func (s *Visible_or_invisibleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVisible_or_invisible(s) + } +} + +func (s *Visible_or_invisibleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVisible_or_invisible(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Visible_or_invisible() (localctx IVisible_or_invisibleContext) { + localctx = NewVisible_or_invisibleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 516, PlSqlParserRULE_visible_or_invisible) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6416) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + 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 +} + +// IMonitoring_nomonitoringContext is an interface to support dynamic dispatch. +type IMonitoring_nomonitoringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MONITORING() antlr.TerminalNode + NOMONITORING() antlr.TerminalNode + + // IsMonitoring_nomonitoringContext differentiates from other interfaces. + IsMonitoring_nomonitoringContext() +} + +type Monitoring_nomonitoringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMonitoring_nomonitoringContext() *Monitoring_nomonitoringContext { + var p = new(Monitoring_nomonitoringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring + return p +} + +func InitEmptyMonitoring_nomonitoringContext(p *Monitoring_nomonitoringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring +} + +func (*Monitoring_nomonitoringContext) IsMonitoring_nomonitoringContext() {} + +func NewMonitoring_nomonitoringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Monitoring_nomonitoringContext { + var p = new(Monitoring_nomonitoringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_monitoring_nomonitoring + + return p +} + +func (s *Monitoring_nomonitoringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Monitoring_nomonitoringContext) MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITORING, 0) +} + +func (s *Monitoring_nomonitoringContext) NOMONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMONITORING, 0) +} + +func (s *Monitoring_nomonitoringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Monitoring_nomonitoringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Monitoring_nomonitoringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMonitoring_nomonitoring(s) + } +} + +func (s *Monitoring_nomonitoringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMonitoring_nomonitoring(s) + } +} + +func (s *Monitoring_nomonitoringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMonitoring_nomonitoring(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Monitoring_nomonitoring() (localctx IMonitoring_nomonitoringContext) { + localctx = NewMonitoring_nomonitoringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 518, PlSqlParserRULE_monitoring_nomonitoring) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6418) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMONITORING || _la == PlSqlParserNOMONITORING) { + 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 +} + +// IRebuild_clauseContext is an interface to support dynamic dispatch. +type IRebuild_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REBUILD() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + REVERSE() antlr.TerminalNode + NOREVERSE() antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllPARAMETERS() []antlr.TerminalNode + PARAMETERS(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllOdci_parameters() []IOdci_parametersContext + Odci_parameters(i int) IOdci_parametersContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsRebuild_clauseContext differentiates from other interfaces. + IsRebuild_clauseContext() +} + +type Rebuild_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRebuild_clauseContext() *Rebuild_clauseContext { + var p = new(Rebuild_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebuild_clause + return p +} + +func InitEmptyRebuild_clauseContext(p *Rebuild_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rebuild_clause +} + +func (*Rebuild_clauseContext) IsRebuild_clauseContext() {} + +func NewRebuild_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rebuild_clauseContext { + var p = new(Rebuild_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rebuild_clause + + return p +} + +func (s *Rebuild_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rebuild_clauseContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Rebuild_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Rebuild_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Rebuild_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Rebuild_clauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Rebuild_clauseContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Rebuild_clauseContext) NOREVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREVERSE, 0) +} + +func (s *Rebuild_clauseContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Rebuild_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Rebuild_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Rebuild_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Rebuild_clauseContext) AllPARAMETERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARAMETERS) +} + +func (s *Rebuild_clauseContext) PARAMETERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, i) +} + +func (s *Rebuild_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Rebuild_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Rebuild_clauseContext) AllOdci_parameters() []IOdci_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOdci_parametersContext); ok { + len++ + } + } + + tst := make([]IOdci_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOdci_parametersContext); ok { + tst[i] = t.(IOdci_parametersContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Odci_parameters(i int) IOdci_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Rebuild_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Rebuild_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Rebuild_clauseContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Rebuild_clauseContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Rebuild_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Rebuild_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Rebuild_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Rebuild_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Rebuild_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rebuild_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rebuild_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRebuild_clause(s) + } +} + +func (s *Rebuild_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRebuild_clause(s) + } +} + +func (s *Rebuild_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRebuild_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rebuild_clause() (localctx IRebuild_clauseContext) { + localctx = NewRebuild_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 520, PlSqlParserRULE_rebuild_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6420) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(6421) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6422) + p.Partition_name() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(6423) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6424) + p.Subpartition_name() + } + + case PlSqlParserREVERSE: + { + p.SetState(6425) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOREVERSE: + { + p.SetState(6426) + p.Match(PlSqlParserNOREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserONLINE, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserSEMICOLON: + + default: + } + p.SetState(6443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserONLINE || ((int64((_la-1243)) & ^0x3f) == 0 && ((int64(1)<<(_la-1243))&154618822659) != 0) || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(6429) + p.Parallel_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(6430) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6431) + p.Tablespace() + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6432) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6433) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6434) + p.Odci_parameters() + } + { + p.SetState(6435) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserONLINE: + { + p.SetState(6437) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6438) + p.Physical_attributes_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(6439) + p.Key_compression() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6440) + p.Logging_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(6445) + 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_index_partitioningContext is an interface to support dynamic dispatch. +type IAlter_index_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Modify_index_default_attrs() IModify_index_default_attrsContext + Add_hash_index_partition() IAdd_hash_index_partitionContext + Modify_index_partition() IModify_index_partitionContext + Rename_index_partition() IRename_index_partitionContext + Drop_index_partition() IDrop_index_partitionContext + Split_index_partition() ISplit_index_partitionContext + Coalesce_index_partition() ICoalesce_index_partitionContext + Modify_index_subpartition() IModify_index_subpartitionContext + + // IsAlter_index_partitioningContext differentiates from other interfaces. + IsAlter_index_partitioningContext() +} + +type Alter_index_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_index_partitioningContext() *Alter_index_partitioningContext { + var p = new(Alter_index_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning + return p +} + +func InitEmptyAlter_index_partitioningContext(p *Alter_index_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning +} + +func (*Alter_index_partitioningContext) IsAlter_index_partitioningContext() {} + +func NewAlter_index_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_index_partitioningContext { + var p = new(Alter_index_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_index_partitioning + + return p +} + +func (s *Alter_index_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_index_partitioningContext) Modify_index_default_attrs() IModify_index_default_attrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_default_attrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_default_attrsContext) +} + +func (s *Alter_index_partitioningContext) Add_hash_index_partition() IAdd_hash_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_hash_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_hash_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Modify_index_partition() IModify_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Rename_index_partition() IRename_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Drop_index_partition() IDrop_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Split_index_partition() ISplit_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISplit_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISplit_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Coalesce_index_partition() ICoalesce_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICoalesce_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICoalesce_index_partitionContext) +} + +func (s *Alter_index_partitioningContext) Modify_index_subpartition() IModify_index_subpartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_subpartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_subpartitionContext) +} + +func (s *Alter_index_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_index_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_index_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_index_partitioning(s) + } +} + +func (s *Alter_index_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_index_partitioning(s) + } +} + +func (s *Alter_index_partitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_index_partitioning(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_index_partitioning() (localctx IAlter_index_partitioningContext) { + localctx = NewAlter_index_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 522, PlSqlParserRULE_alter_index_partitioning) + p.SetState(6454) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 600, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6446) + p.Modify_index_default_attrs() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6447) + p.Add_hash_index_partition() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6448) + p.Modify_index_partition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6449) + p.Rename_index_partition() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6450) + p.Drop_index_partition() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6451) + p.Split_index_partition() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6452) + p.Coalesce_index_partition() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6453) + p.Modify_index_subpartition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_default_attrsContext is an interface to support dynamic dispatch. +type IModify_index_default_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + Physical_attributes_clause() IPhysical_attributes_clauseContext + TABLESPACE() antlr.TerminalNode + Logging_clause() ILogging_clauseContext + FOR() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + Tablespace() ITablespaceContext + + // IsModify_index_default_attrsContext differentiates from other interfaces. + IsModify_index_default_attrsContext() +} + +type Modify_index_default_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_default_attrsContext() *Modify_index_default_attrsContext { + var p = new(Modify_index_default_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs + return p +} + +func InitEmptyModify_index_default_attrsContext(p *Modify_index_default_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs +} + +func (*Modify_index_default_attrsContext) IsModify_index_default_attrsContext() {} + +func NewModify_index_default_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_default_attrsContext { + var p = new(Modify_index_default_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_default_attrs + + return p +} + +func (s *Modify_index_default_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_default_attrsContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_default_attrsContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Modify_index_default_attrsContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Modify_index_default_attrsContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Modify_index_default_attrsContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Modify_index_default_attrsContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Modify_index_default_attrsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_index_default_attrsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Modify_index_default_attrsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_index_default_attrsContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_index_default_attrsContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Modify_index_default_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_default_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_default_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_default_attrs(s) + } +} + +func (s *Modify_index_default_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_default_attrs(s) + } +} + +func (s *Modify_index_default_attrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_index_default_attrs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_index_default_attrs() (localctx IModify_index_default_attrsContext) { + localctx = NewModify_index_default_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 524, PlSqlParserRULE_modify_index_default_attrs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6456) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6457) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6458) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(6459) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6460) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6461) + p.Partition_name() + } + + } + p.SetState(6471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(6464) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(6465) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(6466) + p.Tablespace() + } + + case PlSqlParserDEFAULT: + { + p.SetState(6467) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(6470) + p.Logging_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 +} + +// IAdd_hash_index_partitionContext is an interface to support dynamic dispatch. +type IAdd_hash_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + Parallel_clause() IParallel_clauseContext + + // IsAdd_hash_index_partitionContext differentiates from other interfaces. + IsAdd_hash_index_partitionContext() +} + +type Add_hash_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_hash_index_partitionContext() *Add_hash_index_partitionContext { + var p = new(Add_hash_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition + return p +} + +func InitEmptyAdd_hash_index_partitionContext(p *Add_hash_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition +} + +func (*Add_hash_index_partitionContext) IsAdd_hash_index_partitionContext() {} + +func NewAdd_hash_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_hash_index_partitionContext { + var p = new(Add_hash_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_hash_index_partition + + return p +} + +func (s *Add_hash_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_hash_index_partitionContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_hash_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Add_hash_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Add_hash_index_partitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Add_hash_index_partitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Add_hash_index_partitionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Add_hash_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Add_hash_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_hash_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_hash_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_hash_index_partition(s) + } +} + +func (s *Add_hash_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_hash_index_partition(s) + } +} + +func (s *Add_hash_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_hash_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_hash_index_partition() (localctx IAdd_hash_index_partitionContext) { + localctx = NewAdd_hash_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 526, PlSqlParserRULE_add_hash_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6473) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6474) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6476) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 604, p.GetParserRuleContext()) == 1 { + { + p.SetState(6475) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(6480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(6478) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6479) + p.Tablespace() + } + + } + p.SetState(6483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(6482) + p.Key_compression() + } + + } + p.SetState(6486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6485) + p.Parallel_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 +} + +// ICoalesce_index_partitionContext is an interface to support dynamic dispatch. +type ICoalesce_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COALESCE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + + // IsCoalesce_index_partitionContext differentiates from other interfaces. + IsCoalesce_index_partitionContext() +} + +type Coalesce_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCoalesce_index_partitionContext() *Coalesce_index_partitionContext { + var p = new(Coalesce_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition + return p +} + +func InitEmptyCoalesce_index_partitionContext(p *Coalesce_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition +} + +func (*Coalesce_index_partitionContext) IsCoalesce_index_partitionContext() {} + +func NewCoalesce_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Coalesce_index_partitionContext { + var p = new(Coalesce_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_coalesce_index_partition + + return p +} + +func (s *Coalesce_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Coalesce_index_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Coalesce_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Coalesce_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Coalesce_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Coalesce_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Coalesce_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCoalesce_index_partition(s) + } +} + +func (s *Coalesce_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCoalesce_index_partition(s) + } +} + +func (s *Coalesce_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCoalesce_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Coalesce_index_partition() (localctx ICoalesce_index_partitionContext) { + localctx = NewCoalesce_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 528, PlSqlParserRULE_coalesce_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6488) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6489) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6490) + p.Parallel_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 +} + +// IModify_index_partitionContext is an interface to support dynamic dispatch. +type IModify_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + COALESCE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + AllModify_index_partitions_ops() []IModify_index_partitions_opsContext + Modify_index_partitions_ops(i int) IModify_index_partitions_opsContext + + // IsModify_index_partitionContext differentiates from other interfaces. + IsModify_index_partitionContext() +} + +type Modify_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_partitionContext() *Modify_index_partitionContext { + var p = new(Modify_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partition + return p +} + +func InitEmptyModify_index_partitionContext(p *Modify_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partition +} + +func (*Modify_index_partitionContext) IsModify_index_partitionContext() {} + +func NewModify_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_partitionContext { + var p = new(Modify_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_partition + + return p +} + +func (s *Modify_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_partitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_index_partitionContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Modify_index_partitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_index_partitionContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Modify_index_partitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_index_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Modify_index_partitionContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Modify_index_partitionContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Modify_index_partitionContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Modify_index_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_index_partitionContext) AllModify_index_partitions_ops() []IModify_index_partitions_opsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_index_partitions_opsContext); ok { + len++ + } + } + + tst := make([]IModify_index_partitions_opsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_index_partitions_opsContext); ok { + tst[i] = t.(IModify_index_partitions_opsContext) + i++ + } + } + + return tst +} + +func (s *Modify_index_partitionContext) Modify_index_partitions_ops(i int) IModify_index_partitions_opsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_index_partitions_opsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_index_partitions_opsContext) +} + +func (s *Modify_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_partition(s) + } +} + +func (s *Modify_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_partition(s) + } +} + +func (s *Modify_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_index_partition() (localctx IModify_index_partitionContext) { + localctx = NewModify_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 530, PlSqlParserRULE_modify_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6493) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6494) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6495) + p.Partition_name() + } + p.SetState(6511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDEALLOCATE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + p.SetState(6497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE { + { + p.SetState(6496) + p.Modify_index_partitions_ops() + } + + p.SetState(6499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6501) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6502) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6503) + p.Odci_parameters() + } + { + p.SetState(6504) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOALESCE: + { + p.SetState(6506) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUPDATE: + { + p.SetState(6507) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6508) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6509) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNUSABLE: + { + p.SetState(6510) + p.Match(PlSqlParserUNUSABLE) + 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 +} + +// IModify_index_partitions_opsContext is an interface to support dynamic dispatch. +type IModify_index_partitions_opsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Deallocate_unused_clause() IDeallocate_unused_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Physical_attributes_clause() IPhysical_attributes_clauseContext + Logging_clause() ILogging_clauseContext + Key_compression() IKey_compressionContext + + // IsModify_index_partitions_opsContext differentiates from other interfaces. + IsModify_index_partitions_opsContext() +} + +type Modify_index_partitions_opsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_partitions_opsContext() *Modify_index_partitions_opsContext { + var p = new(Modify_index_partitions_opsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops + return p +} + +func InitEmptyModify_index_partitions_opsContext(p *Modify_index_partitions_opsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops +} + +func (*Modify_index_partitions_opsContext) IsModify_index_partitions_opsContext() {} + +func NewModify_index_partitions_opsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_partitions_opsContext { + var p = new(Modify_index_partitions_opsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_partitions_ops + + return p +} + +func (s *Modify_index_partitions_opsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_partitions_opsContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_index_partitions_opsContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Modify_index_partitions_opsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_partitions_opsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_partitions_opsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_partitions_ops(s) + } +} + +func (s *Modify_index_partitions_opsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_partitions_ops(s) + } +} + +func (s *Modify_index_partitions_opsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_index_partitions_ops(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_index_partitions_ops() (localctx IModify_index_partitions_opsContext) { + localctx = NewModify_index_partitions_opsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 532, PlSqlParserRULE_modify_index_partitions_ops) + p.SetState(6518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEALLOCATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6513) + p.Deallocate_unused_clause() + } + + case PlSqlParserALLOCATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6514) + p.Allocate_extent_clause() + } + + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6515) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6516) + p.Logging_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6517) + p.Key_compression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRename_index_partitionContext is an interface to support dynamic dispatch. +type IRename_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_partition_name() INew_partition_nameContext + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + + // IsRename_index_partitionContext differentiates from other interfaces. + IsRename_index_partitionContext() +} + +type Rename_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_index_partitionContext() *Rename_index_partitionContext { + var p = new(Rename_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_index_partition + return p +} + +func InitEmptyRename_index_partitionContext(p *Rename_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_index_partition +} + +func (*Rename_index_partitionContext) IsRename_index_partitionContext() {} + +func NewRename_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_index_partitionContext { + var p = new(Rename_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_index_partition + + return p +} + +func (s *Rename_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_index_partitionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_index_partitionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_index_partitionContext) New_partition_name() INew_partition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_partition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_partition_nameContext) +} + +func (s *Rename_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Rename_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Rename_index_partitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Rename_index_partitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Rename_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_index_partition(s) + } +} + +func (s *Rename_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_index_partition(s) + } +} + +func (s *Rename_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRename_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rename_index_partition() (localctx IRename_index_partitionContext) { + localctx = NewRename_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 534, PlSqlParserRULE_rename_index_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6520) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(6521) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6522) + p.Partition_name() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(6523) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6524) + p.Subpartition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6527) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6528) + p.New_partition_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_index_partitionContext is an interface to support dynamic dispatch. +type IDrop_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + + // IsDrop_index_partitionContext differentiates from other interfaces. + IsDrop_index_partitionContext() +} + +type Drop_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_index_partitionContext() *Drop_index_partitionContext { + var p = new(Drop_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index_partition + return p +} + +func InitEmptyDrop_index_partitionContext(p *Drop_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index_partition +} + +func (*Drop_index_partitionContext) IsDrop_index_partitionContext() {} + +func NewDrop_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_index_partitionContext { + var p = new(Drop_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_index_partition + + return p +} + +func (s *Drop_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_index_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Drop_index_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Drop_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_index_partition(s) + } +} + +func (s *Drop_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_index_partition(s) + } +} + +func (s *Drop_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_index_partition() (localctx IDrop_index_partitionContext) { + localctx = NewDrop_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 536, PlSqlParserRULE_drop_index_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6530) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6531) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6532) + p.Partition_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 +} + +// ISplit_index_partitionContext is an interface to support dynamic dispatch. +type ISplit_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SPLIT() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name_old() IPartition_name_oldContext + AT() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + AllIndex_partition_description() []IIndex_partition_descriptionContext + Index_partition_description(i int) IIndex_partition_descriptionContext + Parallel_clause() IParallel_clauseContext + + // IsSplit_index_partitionContext differentiates from other interfaces. + IsSplit_index_partitionContext() +} + +type Split_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySplit_index_partitionContext() *Split_index_partitionContext { + var p = new(Split_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_index_partition + return p +} + +func InitEmptySplit_index_partitionContext(p *Split_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_index_partition +} + +func (*Split_index_partitionContext) IsSplit_index_partitionContext() {} + +func NewSplit_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Split_index_partitionContext { + var p = new(Split_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_split_index_partition + + return p +} + +func (s *Split_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Split_index_partitionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Split_index_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Split_index_partitionContext) Partition_name_old() IPartition_name_oldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_name_oldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_name_oldContext) +} + +func (s *Split_index_partitionContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Split_index_partitionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Split_index_partitionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Split_index_partitionContext) 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 *Split_index_partitionContext) 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 *Split_index_partitionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Split_index_partitionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Split_index_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Split_index_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Split_index_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Split_index_partitionContext) AllIndex_partition_description() []IIndex_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]IIndex_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_partition_descriptionContext); ok { + tst[i] = t.(IIndex_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *Split_index_partitionContext) Index_partition_description(i int) IIndex_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partition_descriptionContext) +} + +func (s *Split_index_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Split_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Split_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Split_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSplit_index_partition(s) + } +} + +func (s *Split_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSplit_index_partition(s) + } +} + +func (s *Split_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSplit_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Split_index_partition() (localctx ISplit_index_partitionContext) { + localctx = NewSplit_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 538, PlSqlParserRULE_split_index_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6534) + p.Match(PlSqlParserSPLIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6535) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6536) + p.Partition_name_old() + } + { + p.SetState(6537) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6538) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6539) + p.Literal() + } + p.SetState(6544) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6540) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6541) + p.Literal() + } + + p.SetState(6546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6547) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(6548) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6549) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6550) + p.Index_partition_description() + } + { + p.SetState(6551) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6552) + p.Index_partition_description() + } + { + p.SetState(6553) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(6557) + p.Parallel_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 +} + +// IIndex_partition_descriptionContext is an interface to support dynamic dispatch. +type IIndex_partition_descriptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Odci_parameters() IOdci_parametersContext + RIGHT_PAREN() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + + // IsIndex_partition_descriptionContext differentiates from other interfaces. + IsIndex_partition_descriptionContext() +} + +type Index_partition_descriptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_partition_descriptionContext() *Index_partition_descriptionContext { + var p = new(Index_partition_descriptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partition_description + return p +} + +func InitEmptyIndex_partition_descriptionContext(p *Index_partition_descriptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_partition_description +} + +func (*Index_partition_descriptionContext) IsIndex_partition_descriptionContext() {} + +func NewIndex_partition_descriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_partition_descriptionContext { + var p = new(Index_partition_descriptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_partition_description + + return p +} + +func (s *Index_partition_descriptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_partition_descriptionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Index_partition_descriptionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Index_partition_descriptionContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Index_partition_descriptionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Index_partition_descriptionContext) Odci_parameters() IOdci_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOdci_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOdci_parametersContext) +} + +func (s *Index_partition_descriptionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Index_partition_descriptionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Index_partition_descriptionContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_partition_descriptionContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_partition_descriptionContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_partition_descriptionContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_partition_descriptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_partition_descriptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_partition_descriptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_partition_description(s) + } +} + +func (s *Index_partition_descriptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_partition_description(s) + } +} + +func (s *Index_partition_descriptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_partition_description(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_partition_description() (localctx IIndex_partition_descriptionContext) { + localctx = NewIndex_partition_descriptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 540, PlSqlParserRULE_index_partition_description) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6560) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6578) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 620, p.GetParserRuleContext()) == 1 { + { + p.SetState(6561) + p.Partition_name() + } + p.SetState(6573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE, PlSqlParserTABLESPACE: + p.SetState(6564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(6564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 616, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6562) + p.Segment_attributes_clause() + } + + case 2: + { + p.SetState(6563) + p.Key_compression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPARAMETERS: + { + p.SetState(6568) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6569) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6570) + p.Odci_parameters() + } + { + p.SetState(6571) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(6576) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(6575) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_index_subpartitionContext is an interface to support dynamic dispatch. +type IModify_index_subpartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + UNUSABLE() antlr.TerminalNode + Allocate_extent_clause() IAllocate_extent_clauseContext + Deallocate_unused_clause() IDeallocate_unused_clauseContext + + // IsModify_index_subpartitionContext differentiates from other interfaces. + IsModify_index_subpartitionContext() +} + +type Modify_index_subpartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_index_subpartitionContext() *Modify_index_subpartitionContext { + var p = new(Modify_index_subpartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition + return p +} + +func InitEmptyModify_index_subpartitionContext(p *Modify_index_subpartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition +} + +func (*Modify_index_subpartitionContext) IsModify_index_subpartitionContext() {} + +func NewModify_index_subpartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_index_subpartitionContext { + var p = new(Modify_index_subpartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_index_subpartition + + return p +} + +func (s *Modify_index_subpartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_index_subpartitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_index_subpartitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Modify_index_subpartitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Modify_index_subpartitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_index_subpartitionContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Modify_index_subpartitionContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Modify_index_subpartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_index_subpartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_index_subpartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_index_subpartition(s) + } +} + +func (s *Modify_index_subpartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_index_subpartition(s) + } +} + +func (s *Modify_index_subpartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_index_subpartition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_index_subpartition() (localctx IModify_index_subpartitionContext) { + localctx = NewModify_index_subpartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 542, PlSqlParserRULE_modify_index_subpartition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6580) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6581) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6582) + p.Subpartition_name() + } + p.SetState(6586) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNUSABLE: + { + p.SetState(6583) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOCATE: + { + p.SetState(6584) + p.Allocate_extent_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(6585) + p.Deallocate_unused_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 +} + +// IPartition_name_oldContext is an interface to support dynamic dispatch. +type IPartition_name_oldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsPartition_name_oldContext differentiates from other interfaces. + IsPartition_name_oldContext() +} + +type Partition_name_oldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_name_oldContext() *Partition_name_oldContext { + var p = new(Partition_name_oldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name_old + return p +} + +func InitEmptyPartition_name_oldContext(p *Partition_name_oldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name_old +} + +func (*Partition_name_oldContext) IsPartition_name_oldContext() {} + +func NewPartition_name_oldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_name_oldContext { + var p = new(Partition_name_oldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_name_old + + return p +} + +func (s *Partition_name_oldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_name_oldContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_name_oldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_name_oldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_name_oldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_name_old(s) + } +} + +func (s *Partition_name_oldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_name_old(s) + } +} + +func (s *Partition_name_oldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_name_old(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_name_old() (localctx IPartition_name_oldContext) { + localctx = NewPartition_name_oldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 544, PlSqlParserRULE_partition_name_old) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6588) + p.Partition_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 +} + +// INew_partition_nameContext is an interface to support dynamic dispatch. +type INew_partition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsNew_partition_nameContext differentiates from other interfaces. + IsNew_partition_nameContext() +} + +type New_partition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_partition_nameContext() *New_partition_nameContext { + var p = new(New_partition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_partition_name + return p +} + +func InitEmptyNew_partition_nameContext(p *New_partition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_partition_name +} + +func (*New_partition_nameContext) IsNew_partition_nameContext() {} + +func NewNew_partition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_partition_nameContext { + var p = new(New_partition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_partition_name + + return p +} + +func (s *New_partition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_partition_nameContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *New_partition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_partition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_partition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_partition_name(s) + } +} + +func (s *New_partition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_partition_name(s) + } +} + +func (s *New_partition_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_partition_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_partition_name() (localctx INew_partition_nameContext) { + localctx = NewNew_partition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 546, PlSqlParserRULE_new_partition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6590) + p.Partition_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 +} + +// INew_index_nameContext is an interface to support dynamic dispatch. +type INew_index_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_name() IIndex_nameContext + + // IsNew_index_nameContext differentiates from other interfaces. + IsNew_index_nameContext() +} + +type New_index_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_index_nameContext() *New_index_nameContext { + var p = new(New_index_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_index_name + return p +} + +func InitEmptyNew_index_nameContext(p *New_index_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_index_name +} + +func (*New_index_nameContext) IsNew_index_nameContext() {} + +func NewNew_index_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_index_nameContext { + var p = new(New_index_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_index_name + + return p +} + +func (s *New_index_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_index_nameContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *New_index_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_index_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_index_name(s) + } +} + +func (s *New_index_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_index_name(s) + } +} + +func (s *New_index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_index_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_index_name() (localctx INew_index_nameContext) { + localctx = NewNew_index_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 548, PlSqlParserRULE_new_index_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6592) + p.Index_name() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_inmemory_join_groupContext is an interface to support dynamic dispatch. +type IAlter_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + ADD() antlr.TerminalNode + REMOVE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsAlter_inmemory_join_groupContext differentiates from other interfaces. + IsAlter_inmemory_join_groupContext() +} + +type Alter_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext + t IId_expressionContext + c IId_expressionContext +} + +func NewEmptyAlter_inmemory_join_groupContext() *Alter_inmemory_join_groupContext { + var p = new(Alter_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group + return p +} + +func InitEmptyAlter_inmemory_join_groupContext(p *Alter_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group +} + +func (*Alter_inmemory_join_groupContext) IsAlter_inmemory_join_groupContext() {} + +func NewAlter_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_inmemory_join_groupContext { + var p = new(Alter_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_inmemory_join_group + + return p +} + +func (s *Alter_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Alter_inmemory_join_groupContext) GetT() IId_expressionContext { return s.t } + +func (s *Alter_inmemory_join_groupContext) GetC() IId_expressionContext { return s.c } + +func (s *Alter_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Alter_inmemory_join_groupContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Alter_inmemory_join_groupContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Alter_inmemory_join_groupContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Alter_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Alter_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_inmemory_join_groupContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_inmemory_join_groupContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_inmemory_join_groupContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_inmemory_join_groupContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_inmemory_join_groupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_inmemory_join_groupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_inmemory_join_groupContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_inmemory_join_groupContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Alter_inmemory_join_groupContext) 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_inmemory_join_groupContext) 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_inmemory_join_groupContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Alter_inmemory_join_groupContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Alter_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_inmemory_join_group(s) + } +} + +func (s *Alter_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_inmemory_join_group(s) + } +} + +func (s *Alter_inmemory_join_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_inmemory_join_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_inmemory_join_group() (localctx IAlter_inmemory_join_groupContext) { + localctx = NewAlter_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 550, PlSqlParserRULE_alter_inmemory_join_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6594) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6595) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6596) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6597) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6601) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 622, p.GetParserRuleContext()) == 1 { + { + p.SetState(6598) + p.Schema_name() + } + { + p.SetState(6599) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6603) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).jg = _x + } + { + p.SetState(6604) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6605) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6609) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 623, p.GetParserRuleContext()) == 1 { + { + p.SetState(6606) + p.Schema_name() + } + { + p.SetState(6607) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(6611) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).t = _x + } + { + p.SetState(6612) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6613) + + var _x = p.Id_expression() + + localctx.(*Alter_inmemory_join_groupContext).c = _x + } + { + p.SetState(6614) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6615) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + User_object_name() IUser_object_nameContext + SEMICOLON() antlr.TerminalNode + AllIdentified_by() []IIdentified_byContext + Identified_by(i int) IIdentified_byContext + AllIdentified_other_clause() []IIdentified_other_clauseContext + Identified_other_clause(i int) IIdentified_other_clauseContext + AllUser_tablespace_clause() []IUser_tablespace_clauseContext + User_tablespace_clause(i int) IUser_tablespace_clauseContext + AllQuota_clause() []IQuota_clauseContext + Quota_clause(i int) IQuota_clauseContext + AllProfile_clause() []IProfile_clauseContext + Profile_clause(i int) IProfile_clauseContext + AllPassword_expire_clause() []IPassword_expire_clauseContext + Password_expire_clause(i int) IPassword_expire_clauseContext + AllUser_lock_clause() []IUser_lock_clauseContext + User_lock_clause(i int) IUser_lock_clauseContext + AllUser_editions_clause() []IUser_editions_clauseContext + User_editions_clause(i int) IUser_editions_clauseContext + AllContainer_clause() []IContainer_clauseContext + Container_clause(i int) IContainer_clauseContext + + // 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 = PlSqlParserRULE_create_user + return p +} + +func InitEmptyCreate_userContext(p *Create_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_user + + return p +} + +func (s *Create_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_userContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Create_userContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Create_userContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_userContext) AllIdentified_by() []IIdentified_byContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_byContext); ok { + len++ + } + } + + tst := make([]IIdentified_byContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_byContext); ok { + tst[i] = t.(IIdentified_byContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Identified_by(i int) IIdentified_byContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Create_userContext) AllIdentified_other_clause() []IIdentified_other_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_other_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_other_clauseContext); ok { + tst[i] = t.(IIdentified_other_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Identified_other_clause(i int) IIdentified_other_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_other_clauseContext) +} + +func (s *Create_userContext) AllUser_tablespace_clause() []IUser_tablespace_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_tablespace_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_tablespace_clauseContext); ok { + tst[i] = t.(IUser_tablespace_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_tablespace_clause(i int) IUser_tablespace_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_tablespace_clauseContext) +} + +func (s *Create_userContext) AllQuota_clause() []IQuota_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuota_clauseContext); ok { + len++ + } + } + + tst := make([]IQuota_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuota_clauseContext); ok { + tst[i] = t.(IQuota_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Quota_clause(i int) IQuota_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuota_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuota_clauseContext) +} + +func (s *Create_userContext) AllProfile_clause() []IProfile_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProfile_clauseContext); ok { + len++ + } + } + + tst := make([]IProfile_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProfile_clauseContext); ok { + tst[i] = t.(IProfile_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Profile_clause(i int) IProfile_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProfile_clauseContext) +} + +func (s *Create_userContext) AllPassword_expire_clause() []IPassword_expire_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + len++ + } + } + + tst := make([]IPassword_expire_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_expire_clauseContext); ok { + tst[i] = t.(IPassword_expire_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Password_expire_clause(i int) IPassword_expire_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_expire_clauseContext) +} + +func (s *Create_userContext) AllUser_lock_clause() []IUser_lock_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_lock_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_lock_clauseContext); ok { + tst[i] = t.(IUser_lock_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_lock_clause(i int) IUser_lock_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_lock_clauseContext) +} + +func (s *Create_userContext) AllUser_editions_clause() []IUser_editions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_editions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_editions_clauseContext); ok { + tst[i] = t.(IUser_editions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) User_editions_clause(i int) IUser_editions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_editions_clauseContext) +} + +func (s *Create_userContext) AllContainer_clause() []IContainer_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_clauseContext); ok { + tst[i] = t.(IContainer_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_userContext) Container_clause(i int) IContainer_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_user(s) + } +} + +func (s *Create_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_user(s) + } +} + +func (s *Create_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_user() (localctx ICreate_userContext) { + localctx = NewCreate_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 552, PlSqlParserRULE_create_user) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6617) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6618) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6619) + p.User_object_name() + } + p.SetState(6629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserACCOUNT || _la == PlSqlParserCONTAINER || _la == PlSqlParserDEFAULT || _la == PlSqlParserENABLE || _la == PlSqlParserIDENTIFIED || _la == PlSqlParserPASSWORD || _la == PlSqlParserPROFILE || _la == PlSqlParserQUOTA || _la == PlSqlParserTEMPORARY { + p.SetState(6629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 624, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6620) + p.Identified_by() + } + + case 2: + { + p.SetState(6621) + p.Identified_other_clause() + } + + case 3: + { + p.SetState(6622) + p.User_tablespace_clause() + } + + case 4: + { + p.SetState(6623) + p.Quota_clause() + } + + case 5: + { + p.SetState(6624) + p.Profile_clause() + } + + case 6: + { + p.SetState(6625) + p.Password_expire_clause() + } + + case 7: + { + p.SetState(6626) + p.User_lock_clause() + } + + case 8: + { + p.SetState(6627) + p.User_editions_clause() + } + + case 9: + { + p.SetState(6628) + p.Container_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6633) + p.Match(PlSqlParserSEMICOLON) + 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_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 + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + SEMICOLON() antlr.TerminalNode + AllAlter_identified_by() []IAlter_identified_byContext + Alter_identified_by(i int) IAlter_identified_byContext + AllIdentified_other_clause() []IIdentified_other_clauseContext + Identified_other_clause(i int) IIdentified_other_clauseContext + AllUser_tablespace_clause() []IUser_tablespace_clauseContext + User_tablespace_clause(i int) IUser_tablespace_clauseContext + AllQuota_clause() []IQuota_clauseContext + Quota_clause(i int) IQuota_clauseContext + AllProfile_clause() []IProfile_clauseContext + Profile_clause(i int) IProfile_clauseContext + AllUser_default_role_clause() []IUser_default_role_clauseContext + User_default_role_clause(i int) IUser_default_role_clauseContext + AllPassword_expire_clause() []IPassword_expire_clauseContext + Password_expire_clause(i int) IPassword_expire_clauseContext + AllUser_lock_clause() []IUser_lock_clauseContext + User_lock_clause(i int) IUser_lock_clauseContext + AllAlter_user_editions_clause() []IAlter_user_editions_clauseContext + Alter_user_editions_clause(i int) IAlter_user_editions_clauseContext + AllContainer_clause() []IContainer_clauseContext + Container_clause(i int) IContainer_clauseContext + AllContainer_data_clause() []IContainer_data_clauseContext + Container_data_clause(i int) IContainer_data_clauseContext + Proxy_clause() IProxy_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // 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 = PlSqlParserRULE_alter_user + return p +} + +func InitEmptyAlter_userContext(p *Alter_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_user + + return p +} + +func (s *Alter_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_userContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Alter_userContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Alter_userContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_userContext) AllAlter_identified_by() []IAlter_identified_byContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_identified_byContext); ok { + len++ + } + } + + tst := make([]IAlter_identified_byContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_identified_byContext); ok { + tst[i] = t.(IAlter_identified_byContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Alter_identified_by(i int) IAlter_identified_byContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_identified_byContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_identified_byContext) +} + +func (s *Alter_userContext) AllIdentified_other_clause() []IIdentified_other_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_other_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_other_clauseContext); ok { + tst[i] = t.(IIdentified_other_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Identified_other_clause(i int) IIdentified_other_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_other_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_other_clauseContext) +} + +func (s *Alter_userContext) AllUser_tablespace_clause() []IUser_tablespace_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_tablespace_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_tablespace_clauseContext); ok { + tst[i] = t.(IUser_tablespace_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_tablespace_clause(i int) IUser_tablespace_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_tablespace_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_tablespace_clauseContext) +} + +func (s *Alter_userContext) AllQuota_clause() []IQuota_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuota_clauseContext); ok { + len++ + } + } + + tst := make([]IQuota_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuota_clauseContext); ok { + tst[i] = t.(IQuota_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Quota_clause(i int) IQuota_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuota_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuota_clauseContext) +} + +func (s *Alter_userContext) AllProfile_clause() []IProfile_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProfile_clauseContext); ok { + len++ + } + } + + tst := make([]IProfile_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProfile_clauseContext); ok { + tst[i] = t.(IProfile_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Profile_clause(i int) IProfile_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProfile_clauseContext) +} + +func (s *Alter_userContext) AllUser_default_role_clause() []IUser_default_role_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_default_role_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_default_role_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_default_role_clauseContext); ok { + tst[i] = t.(IUser_default_role_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_default_role_clause(i int) IUser_default_role_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_default_role_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_default_role_clauseContext) +} + +func (s *Alter_userContext) AllPassword_expire_clause() []IPassword_expire_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + len++ + } + } + + tst := make([]IPassword_expire_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_expire_clauseContext); ok { + tst[i] = t.(IPassword_expire_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Password_expire_clause(i int) IPassword_expire_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_expire_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_expire_clauseContext) +} + +func (s *Alter_userContext) AllUser_lock_clause() []IUser_lock_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + len++ + } + } + + tst := make([]IUser_lock_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_lock_clauseContext); ok { + tst[i] = t.(IUser_lock_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) User_lock_clause(i int) IUser_lock_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_lock_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_lock_clauseContext) +} + +func (s *Alter_userContext) AllAlter_user_editions_clause() []IAlter_user_editions_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAlter_user_editions_clauseContext); ok { + len++ + } + } + + tst := make([]IAlter_user_editions_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAlter_user_editions_clauseContext); ok { + tst[i] = t.(IAlter_user_editions_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Alter_user_editions_clause(i int) IAlter_user_editions_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_user_editions_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAlter_user_editions_clauseContext) +} + +func (s *Alter_userContext) AllContainer_clause() []IContainer_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_clauseContext); ok { + tst[i] = t.(IContainer_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Container_clause(i int) IContainer_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Alter_userContext) AllContainer_data_clause() []IContainer_data_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IContainer_data_clauseContext); ok { + len++ + } + } + + tst := make([]IContainer_data_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IContainer_data_clauseContext); ok { + tst[i] = t.(IContainer_data_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_userContext) Container_data_clause(i int) IContainer_data_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_data_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IContainer_data_clauseContext) +} + +func (s *Alter_userContext) Proxy_clause() IProxy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProxy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProxy_clauseContext) +} + +func (s *Alter_userContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_userContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_user(s) + } +} + +func (s *Alter_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_user(s) + } +} + +func (s *Alter_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_user() (localctx IAlter_userContext) { + localctx = NewAlter_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 554, PlSqlParserRULE_alter_user) + var _la int + + p.SetState(6666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6635) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6636) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6637) + p.User_object_name() + } + p.SetState(6649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserACCOUNT || _la == PlSqlParserADD || _la == PlSqlParserCONTAINER || _la == PlSqlParserDEFAULT || _la == PlSqlParserENABLE || _la == PlSqlParserIDENTIFIED || _la == PlSqlParserPASSWORD || _la == PlSqlParserPROFILE || _la == PlSqlParserQUOTA || _la == PlSqlParserREMOVE || _la == PlSqlParserSET || _la == PlSqlParserTEMPORARY { + p.SetState(6649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 626, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6638) + p.Alter_identified_by() + } + + case 2: + { + p.SetState(6639) + p.Identified_other_clause() + } + + case 3: + { + p.SetState(6640) + p.User_tablespace_clause() + } + + case 4: + { + p.SetState(6641) + p.Quota_clause() + } + + case 5: + { + p.SetState(6642) + p.Profile_clause() + } + + case 6: + { + p.SetState(6643) + p.User_default_role_clause() + } + + case 7: + { + p.SetState(6644) + p.Password_expire_clause() + } + + case 8: + { + p.SetState(6645) + p.User_lock_clause() + } + + case 9: + { + p.SetState(6646) + p.Alter_user_editions_clause() + } + + case 10: + { + p.SetState(6647) + p.Container_clause() + } + + case 11: + { + p.SetState(6648) + p.Container_data_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(6651) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6653) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6655) + p.User_object_name() + } + p.SetState(6660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6656) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6657) + p.User_object_name() + } + + p.SetState(6662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6663) + p.Proxy_clause() + } + { + p.SetState(6664) + p.Match(PlSqlParserSEMICOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_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 + User_object_name() IUser_object_nameContext + CASCADE() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_user + return p +} + +func InitEmptyDrop_userContext(p *Drop_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_user + + return p +} + +func (s *Drop_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_userContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_userContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Drop_userContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Drop_userContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_user(s) + } +} + +func (s *Drop_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_user(s) + } +} + +func (s *Drop_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_user() (localctx IDrop_userContext) { + localctx = NewDrop_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 556, PlSqlParserRULE_drop_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6668) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6669) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6670) + p.User_object_name() + } + p.SetState(6672) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 630, p.GetParserRuleContext()) == 1 { + { + p.SetState(6671) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_identified_byContext is an interface to support dynamic dispatch. +type IAlter_identified_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identified_by() IIdentified_byContext + REPLACE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsAlter_identified_byContext differentiates from other interfaces. + IsAlter_identified_byContext() +} + +type Alter_identified_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_identified_byContext() *Alter_identified_byContext { + var p = new(Alter_identified_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_identified_by + return p +} + +func InitEmptyAlter_identified_byContext(p *Alter_identified_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_identified_by +} + +func (*Alter_identified_byContext) IsAlter_identified_byContext() {} + +func NewAlter_identified_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_identified_byContext { + var p = new(Alter_identified_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_identified_by + + return p +} + +func (s *Alter_identified_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_identified_byContext) Identified_by() IIdentified_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Alter_identified_byContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Alter_identified_byContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_identified_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_identified_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_identified_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_identified_by(s) + } +} + +func (s *Alter_identified_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_identified_by(s) + } +} + +func (s *Alter_identified_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_identified_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_identified_by() (localctx IAlter_identified_byContext) { + localctx = NewAlter_identified_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 558, PlSqlParserRULE_alter_identified_by) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6674) + p.Identified_by() + } + p.SetState(6677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREPLACE { + { + p.SetState(6675) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6676) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_byContext is an interface to support dynamic dispatch. +type IIdentified_byContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsIdentified_byContext differentiates from other interfaces. + IsIdentified_byContext() +} + +type Identified_byContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_byContext() *Identified_byContext { + var p = new(Identified_byContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by + return p +} + +func InitEmptyIdentified_byContext(p *Identified_byContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by +} + +func (*Identified_byContext) IsIdentified_byContext() {} + +func NewIdentified_byContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_byContext { + var p = new(Identified_byContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by + + return p +} + +func (s *Identified_byContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_byContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_byContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_byContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Identified_byContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_byContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_byContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by(s) + } +} + +func (s *Identified_byContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by(s) + } +} + +func (s *Identified_byContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentified_by(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identified_by() (localctx IIdentified_byContext) { + localctx = NewIdentified_byContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 560, PlSqlParserRULE_identified_by) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6679) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6680) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6681) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentified_other_clauseContext is an interface to support dynamic dispatch. +type IIdentified_other_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + AS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsIdentified_other_clauseContext differentiates from other interfaces. + IsIdentified_other_clauseContext() +} + +type Identified_other_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_other_clauseContext() *Identified_other_clauseContext { + var p = new(Identified_other_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_other_clause + return p +} + +func InitEmptyIdentified_other_clauseContext(p *Identified_other_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_other_clause +} + +func (*Identified_other_clauseContext) IsIdentified_other_clauseContext() {} + +func NewIdentified_other_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_other_clauseContext { + var p = new(Identified_other_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_other_clause + + return p +} + +func (s *Identified_other_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_other_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_other_clauseContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Identified_other_clauseContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Identified_other_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Identified_other_clauseContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Identified_other_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_other_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_other_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_other_clause(s) + } +} + +func (s *Identified_other_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_other_clause(s) + } +} + +func (s *Identified_other_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentified_other_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identified_other_clause() (localctx IIdentified_other_clauseContext) { + localctx = NewIdentified_other_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 562, PlSqlParserRULE_identified_other_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6683) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6684) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXTERNALLY || _la == PlSqlParserGLOBALLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(6687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(6685) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6686) + p.Quoted_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 +} + +// IUser_tablespace_clauseContext is an interface to support dynamic dispatch. +type IUser_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + DEFAULT() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + + // IsUser_tablespace_clauseContext differentiates from other interfaces. + IsUser_tablespace_clauseContext() +} + +type User_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_tablespace_clauseContext() *User_tablespace_clauseContext { + var p = new(User_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause + return p +} + +func InitEmptyUser_tablespace_clauseContext(p *User_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause +} + +func (*User_tablespace_clauseContext) IsUser_tablespace_clauseContext() {} + +func NewUser_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_tablespace_clauseContext { + var p = new(User_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_tablespace_clause + + return p +} + +func (s *User_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *User_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *User_tablespace_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *User_tablespace_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *User_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_tablespace_clause(s) + } +} + +func (s *User_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_tablespace_clause(s) + } +} + +func (s *User_tablespace_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_tablespace_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_tablespace_clause() (localctx IUser_tablespace_clauseContext) { + localctx = NewUser_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 564, PlSqlParserRULE_user_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6689) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6690) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6691) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuota_clauseContext is an interface to support dynamic dispatch. +type IQuota_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + QUOTA() antlr.TerminalNode + ON() antlr.TerminalNode + Id_expression() IId_expressionContext + Size_clause() ISize_clauseContext + UNLIMITED() antlr.TerminalNode + + // IsQuota_clauseContext differentiates from other interfaces. + IsQuota_clauseContext() +} + +type Quota_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuota_clauseContext() *Quota_clauseContext { + var p = new(Quota_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quota_clause + return p +} + +func InitEmptyQuota_clauseContext(p *Quota_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quota_clause +} + +func (*Quota_clauseContext) IsQuota_clauseContext() {} + +func NewQuota_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quota_clauseContext { + var p = new(Quota_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quota_clause + + return p +} + +func (s *Quota_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quota_clauseContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Quota_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Quota_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Quota_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Quota_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Quota_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quota_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quota_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuota_clause(s) + } +} + +func (s *Quota_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuota_clause(s) + } +} + +func (s *Quota_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuota_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quota_clause() (localctx IQuota_clauseContext) { + localctx = NewQuota_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 566, PlSqlParserRULE_quota_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6693) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(6694) + p.Size_clause() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(6695) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6698) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6699) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProfile_clauseContext is an interface to support dynamic dispatch. +type IProfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProfile_clauseContext differentiates from other interfaces. + IsProfile_clauseContext() +} + +type Profile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProfile_clauseContext() *Profile_clauseContext { + var p = new(Profile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_clause + return p +} + +func InitEmptyProfile_clauseContext(p *Profile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_clause +} + +func (*Profile_clauseContext) IsProfile_clauseContext() {} + +func NewProfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Profile_clauseContext { + var p = new(Profile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_profile_clause + + return p +} + +func (s *Profile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Profile_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Profile_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Profile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Profile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Profile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProfile_clause(s) + } +} + +func (s *Profile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProfile_clause(s) + } +} + +func (s *Profile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProfile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Profile_clause() (localctx IProfile_clauseContext) { + localctx = NewProfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 568, PlSqlParserRULE_profile_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6701) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6702) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_clauseContext is an interface to support dynamic dispatch. +type IRole_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALL() antlr.TerminalNode + AllEXCEPT() []antlr.TerminalNode + EXCEPT(i int) antlr.TerminalNode + + // IsRole_clauseContext differentiates from other interfaces. + IsRole_clauseContext() +} + +type Role_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_clauseContext() *Role_clauseContext { + var p = new(Role_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_clause + return p +} + +func InitEmptyRole_clauseContext(p *Role_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_clause +} + +func (*Role_clauseContext) IsRole_clauseContext() {} + +func NewRole_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_clauseContext { + var p = new(Role_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_clause + + return p +} + +func (s *Role_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_clauseContext) 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 *Role_clauseContext) 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 *Role_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Role_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Role_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Role_clauseContext) AllEXCEPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEXCEPT) +} + +func (s *Role_clauseContext) EXCEPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, i) +} + +func (s *Role_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_clause(s) + } +} + +func (s *Role_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_clause(s) + } +} + +func (s *Role_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRole_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Role_clause() (localctx IRole_clauseContext) { + localctx = NewRole_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 570, PlSqlParserRULE_role_clause) + var _la int + + p.SetState(6727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESOURCE, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6704) + p.Role_name() + } + p.SetState(6709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6705) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6706) + p.Role_name() + } + + p.SetState(6711) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6712) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserEXCEPT { + { + p.SetState(6713) + p.Match(PlSqlParserEXCEPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6714) + p.Role_name() + } + p.SetState(6719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6715) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6716) + p.Role_name() + } + + p.SetState(6721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + p.SetState(6726) + 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 +} + +// IUser_default_role_clauseContext is an interface to support dynamic dispatch. +type IUser_default_role_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + ROLE() antlr.TerminalNode + NONE() antlr.TerminalNode + Role_clause() IRole_clauseContext + + // IsUser_default_role_clauseContext differentiates from other interfaces. + IsUser_default_role_clauseContext() +} + +type User_default_role_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_default_role_clauseContext() *User_default_role_clauseContext { + var p = new(User_default_role_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_default_role_clause + return p +} + +func InitEmptyUser_default_role_clauseContext(p *User_default_role_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_default_role_clause +} + +func (*User_default_role_clauseContext) IsUser_default_role_clauseContext() {} + +func NewUser_default_role_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_default_role_clauseContext { + var p = new(User_default_role_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_default_role_clause + + return p +} + +func (s *User_default_role_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_default_role_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *User_default_role_clauseContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *User_default_role_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *User_default_role_clauseContext) Role_clause() IRole_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_clauseContext) +} + +func (s *User_default_role_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_default_role_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_default_role_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_default_role_clause(s) + } +} + +func (s *User_default_role_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_default_role_clause(s) + } +} + +func (s *User_default_role_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_default_role_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_default_role_clause() (localctx IUser_default_role_clauseContext) { + localctx = NewUser_default_role_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 572, PlSqlParserRULE_user_default_role_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6729) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6730) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 638, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6731) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6732) + p.Role_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 +} + +// IPassword_expire_clauseContext is an interface to support dynamic dispatch. +type IPassword_expire_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSWORD() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + + // IsPassword_expire_clauseContext differentiates from other interfaces. + IsPassword_expire_clauseContext() +} + +type Password_expire_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_expire_clauseContext() *Password_expire_clauseContext { + var p = new(Password_expire_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_expire_clause + return p +} + +func InitEmptyPassword_expire_clauseContext(p *Password_expire_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_expire_clause +} + +func (*Password_expire_clauseContext) IsPassword_expire_clauseContext() {} + +func NewPassword_expire_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_expire_clauseContext { + var p = new(Password_expire_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_expire_clause + + return p +} + +func (s *Password_expire_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_expire_clauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Password_expire_clauseContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPIRE, 0) +} + +func (s *Password_expire_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_expire_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_expire_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_expire_clause(s) + } +} + +func (s *Password_expire_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_expire_clause(s) + } +} + +func (s *Password_expire_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPassword_expire_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Password_expire_clause() (localctx IPassword_expire_clauseContext) { + localctx = NewPassword_expire_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 574, PlSqlParserRULE_password_expire_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6735) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6736) + p.Match(PlSqlParserEXPIRE) + 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 +} + +// IUser_lock_clauseContext is an interface to support dynamic dispatch. +type IUser_lock_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACCOUNT() antlr.TerminalNode + LOCK() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + + // IsUser_lock_clauseContext differentiates from other interfaces. + IsUser_lock_clauseContext() +} + +type User_lock_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_lock_clauseContext() *User_lock_clauseContext { + var p = new(User_lock_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_lock_clause + return p +} + +func InitEmptyUser_lock_clauseContext(p *User_lock_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_lock_clause +} + +func (*User_lock_clauseContext) IsUser_lock_clauseContext() {} + +func NewUser_lock_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_lock_clauseContext { + var p = new(User_lock_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_lock_clause + + return p +} + +func (s *User_lock_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_lock_clauseContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCOUNT, 0) +} + +func (s *User_lock_clauseContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *User_lock_clauseContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOCK, 0) +} + +func (s *User_lock_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_lock_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_lock_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_lock_clause(s) + } +} + +func (s *User_lock_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_lock_clause(s) + } +} + +func (s *User_lock_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_lock_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_lock_clause() (localctx IUser_lock_clauseContext) { + localctx = NewUser_lock_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 576, PlSqlParserRULE_user_lock_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6738) + p.Match(PlSqlParserACCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6739) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCK || _la == PlSqlParserUNLOCK) { + 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 +} + +// IUser_editions_clauseContext is an interface to support dynamic dispatch. +type IUser_editions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + EDITIONS() antlr.TerminalNode + + // IsUser_editions_clauseContext differentiates from other interfaces. + IsUser_editions_clauseContext() +} + +type User_editions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_editions_clauseContext() *User_editions_clauseContext { + var p = new(User_editions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_editions_clause + return p +} + +func InitEmptyUser_editions_clauseContext(p *User_editions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_editions_clause +} + +func (*User_editions_clauseContext) IsUser_editions_clauseContext() {} + +func NewUser_editions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_editions_clauseContext { + var p = new(User_editions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_editions_clause + + return p +} + +func (s *User_editions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_editions_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *User_editions_clauseContext) EDITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONS, 0) +} + +func (s *User_editions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_editions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_editions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_editions_clause(s) + } +} + +func (s *User_editions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_editions_clause(s) + } +} + +func (s *User_editions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_editions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_editions_clause() (localctx IUser_editions_clauseContext) { + localctx = NewUser_editions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 578, PlSqlParserRULE_user_editions_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6741) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6742) + p.Match(PlSqlParserEDITIONS) + 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_user_editions_clauseContext is an interface to support dynamic dispatch. +type IAlter_user_editions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + User_editions_clause() IUser_editions_clauseContext + FOR() antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + FORCE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_user_editions_clauseContext differentiates from other interfaces. + IsAlter_user_editions_clauseContext() +} + +type Alter_user_editions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_user_editions_clauseContext() *Alter_user_editions_clauseContext { + var p = new(Alter_user_editions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause + return p +} + +func InitEmptyAlter_user_editions_clauseContext(p *Alter_user_editions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause +} + +func (*Alter_user_editions_clauseContext) IsAlter_user_editions_clauseContext() {} + +func NewAlter_user_editions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_user_editions_clauseContext { + var p = new(Alter_user_editions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_user_editions_clause + + return p +} + +func (s *Alter_user_editions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_user_editions_clauseContext) User_editions_clause() IUser_editions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_editions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_editions_clauseContext) +} + +func (s *Alter_user_editions_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Alter_user_editions_clauseContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Alter_user_editions_clauseContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Alter_user_editions_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_user_editions_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_user_editions_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_user_editions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_user_editions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_user_editions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_user_editions_clause(s) + } +} + +func (s *Alter_user_editions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_user_editions_clause(s) + } +} + +func (s *Alter_user_editions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_user_editions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_user_editions_clause() (localctx IAlter_user_editions_clauseContext) { + localctx = NewAlter_user_editions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 580, PlSqlParserRULE_alter_user_editions_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6744) + p.User_editions_clause() + } + p.SetState(6754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(6745) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6746) + p.Regular_id() + } + p.SetState(6751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6747) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6748) + p.Regular_id() + } + + p.SetState(6753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(6757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6756) + p.Match(PlSqlParserFORCE) + 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 +} + +// IProxy_clauseContext is an interface to support dynamic dispatch. +type IProxy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + CONNECT() antlr.TerminalNode + THROUGH() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + USERS() antlr.TerminalNode + User_object_name() IUser_object_nameContext + GRANT() antlr.TerminalNode + WITH() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + AUTHENTICATED() antlr.TerminalNode + USING() antlr.TerminalNode + NO() antlr.TerminalNode + ROLES() antlr.TerminalNode + ROLE() antlr.TerminalNode + Role_clause() IRole_clauseContext + PASSWORD() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + DISTINGUISHED() antlr.TerminalNode + NAME() antlr.TerminalNode + + // IsProxy_clauseContext differentiates from other interfaces. + IsProxy_clauseContext() +} + +type Proxy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProxy_clauseContext() *Proxy_clauseContext { + var p = new(Proxy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proxy_clause + return p +} + +func InitEmptyProxy_clauseContext(p *Proxy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_proxy_clause +} + +func (*Proxy_clauseContext) IsProxy_clauseContext() {} + +func NewProxy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Proxy_clauseContext { + var p = new(Proxy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_proxy_clause + + return p +} + +func (s *Proxy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Proxy_clauseContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Proxy_clauseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Proxy_clauseContext) THROUGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHROUGH, 0) +} + +func (s *Proxy_clauseContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTERPRISE, 0) +} + +func (s *Proxy_clauseContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Proxy_clauseContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Proxy_clauseContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Proxy_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Proxy_clauseContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Proxy_clauseContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREQUIRED, 0) +} + +func (s *Proxy_clauseContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Proxy_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Proxy_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Proxy_clauseContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Proxy_clauseContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Proxy_clauseContext) Role_clause() IRole_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_clauseContext) +} + +func (s *Proxy_clauseContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Proxy_clauseContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCERTIFICATE, 0) +} + +func (s *Proxy_clauseContext) DISTINGUISHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINGUISHED, 0) +} + +func (s *Proxy_clauseContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Proxy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Proxy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Proxy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProxy_clause(s) + } +} + +func (s *Proxy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProxy_clause(s) + } +} + +func (s *Proxy_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProxy_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Proxy_clause() (localctx IProxy_clauseContext) { + localctx = NewProxy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 582, PlSqlParserRULE_proxy_clause) + var _la int + + p.SetState(6798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREVOKE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6759) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6760) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6761) + p.Match(PlSqlParserTHROUGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 642, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6762) + p.Match(PlSqlParserENTERPRISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6763) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6764) + p.User_object_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserGRANT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6767) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6768) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6769) + p.Match(PlSqlParserTHROUGH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 648, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6770) + p.Match(PlSqlParserENTERPRISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6771) + p.Match(PlSqlParserUSERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(6772) + p.User_object_name() + } + p.SetState(6780) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6773) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + { + p.SetState(6774) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6775) + p.Match(PlSqlParserROLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROLE: + { + p.SetState(6776) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6777) + p.Role_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(6784) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHENTICATION { + { + p.SetState(6782) + p.Match(PlSqlParserAUTHENTICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6783) + p.Match(PlSqlParserREQUIRED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHENTICATED { + { + p.SetState(6786) + p.Match(PlSqlParserAUTHENTICATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6787) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPASSWORD: + { + p.SetState(6788) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCERTIFICATE: + { + p.SetState(6789) + p.Match(PlSqlParserCERTIFICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISTINGUISHED: + { + p.SetState(6790) + p.Match(PlSqlParserDISTINGUISHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6791) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_namesContext is an interface to support dynamic dispatch. +type IContainer_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsContainer_namesContext differentiates from other interfaces. + IsContainer_namesContext() +} + +type Container_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_namesContext() *Container_namesContext { + var p = new(Container_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_names + return p +} + +func InitEmptyContainer_namesContext(p *Container_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_names +} + +func (*Container_namesContext) IsContainer_namesContext() {} + +func NewContainer_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_namesContext { + var p = new(Container_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_names + + return p +} + +func (s *Container_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Container_namesContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Container_namesContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Container_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Container_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Container_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Container_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_names(s) + } +} + +func (s *Container_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_names(s) + } +} + +func (s *Container_namesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitContainer_names(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Container_names() (localctx IContainer_namesContext) { + localctx = NewContainer_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 584, PlSqlParserRULE_container_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6800) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6801) + p.Id_expression() + } + p.SetState(6806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(6802) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6803) + p.Id_expression() + } + + p.SetState(6808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(6809) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_container_dataContext is an interface to support dynamic dispatch. +type ISet_container_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + CONTAINER_DATA() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + ALL() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Container_names() IContainer_namesContext + + // IsSet_container_dataContext differentiates from other interfaces. + IsSet_container_dataContext() +} + +type Set_container_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_container_dataContext() *Set_container_dataContext { + var p = new(Set_container_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_container_data + return p +} + +func InitEmptySet_container_dataContext(p *Set_container_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_container_data +} + +func (*Set_container_dataContext) IsSet_container_dataContext() {} + +func NewSet_container_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_container_dataContext { + var p = new(Set_container_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_container_data + + return p +} + +func (s *Set_container_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_container_dataContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_container_dataContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Set_container_dataContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Set_container_dataContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Set_container_dataContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Set_container_dataContext) Container_names() IContainer_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_namesContext) +} + +func (s *Set_container_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_container_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_container_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_container_data(s) + } +} + +func (s *Set_container_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_container_data(s) + } +} + +func (s *Set_container_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_container_data(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_container_data() (localctx ISet_container_dataContext) { + localctx = NewSet_container_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 586, PlSqlParserRULE_set_container_data) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6811) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6812) + p.Match(PlSqlParserCONTAINER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6813) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(6814) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(6815) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(6816) + p.Container_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_rem_container_dataContext is an interface to support dynamic dispatch. +type IAdd_rem_container_dataContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER_DATA() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Container_names() IContainer_namesContext + ADD() antlr.TerminalNode + REMOVE() antlr.TerminalNode + + // IsAdd_rem_container_dataContext differentiates from other interfaces. + IsAdd_rem_container_dataContext() +} + +type Add_rem_container_dataContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_rem_container_dataContext() *Add_rem_container_dataContext { + var p = new(Add_rem_container_dataContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_rem_container_data + return p +} + +func InitEmptyAdd_rem_container_dataContext(p *Add_rem_container_dataContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_rem_container_data +} + +func (*Add_rem_container_dataContext) IsAdd_rem_container_dataContext() {} + +func NewAdd_rem_container_dataContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_rem_container_dataContext { + var p = new(Add_rem_container_dataContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_rem_container_data + + return p +} + +func (s *Add_rem_container_dataContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_rem_container_dataContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Add_rem_container_dataContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Add_rem_container_dataContext) Container_names() IContainer_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_namesContext) +} + +func (s *Add_rem_container_dataContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_rem_container_dataContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Add_rem_container_dataContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_rem_container_dataContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_rem_container_dataContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_rem_container_data(s) + } +} + +func (s *Add_rem_container_dataContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_rem_container_data(s) + } +} + +func (s *Add_rem_container_dataContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_rem_container_data(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_rem_container_data() (localctx IAdd_rem_container_dataContext) { + localctx = NewAdd_rem_container_dataContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 588, PlSqlParserRULE_add_rem_container_data) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6819) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(6820) + p.Match(PlSqlParserCONTAINER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6821) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6822) + p.Container_names() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_data_clauseContext is an interface to support dynamic dispatch. +type IContainer_data_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_container_data() ISet_container_dataContext + Add_rem_container_data() IAdd_rem_container_dataContext + FOR() antlr.TerminalNode + Container_tableview_name() IContainer_tableview_nameContext + + // IsContainer_data_clauseContext differentiates from other interfaces. + IsContainer_data_clauseContext() +} + +type Container_data_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_data_clauseContext() *Container_data_clauseContext { + var p = new(Container_data_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_data_clause + return p +} + +func InitEmptyContainer_data_clauseContext(p *Container_data_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_data_clause +} + +func (*Container_data_clauseContext) IsContainer_data_clauseContext() {} + +func NewContainer_data_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_data_clauseContext { + var p = new(Container_data_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_data_clause + + return p +} + +func (s *Container_data_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_data_clauseContext) Set_container_data() ISet_container_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_container_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_container_dataContext) +} + +func (s *Container_data_clauseContext) Add_rem_container_data() IAdd_rem_container_dataContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_rem_container_dataContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_rem_container_dataContext) +} + +func (s *Container_data_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Container_data_clauseContext) Container_tableview_name() IContainer_tableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_tableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_tableview_nameContext) +} + +func (s *Container_data_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_data_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_data_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_data_clause(s) + } +} + +func (s *Container_data_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_data_clause(s) + } +} + +func (s *Container_data_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitContainer_data_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Container_data_clause() (localctx IContainer_data_clauseContext) { + localctx = NewContainer_data_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 590, PlSqlParserRULE_container_data_clause) + var _la int + + p.SetState(6830) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6824) + p.Set_container_data() + } + + case PlSqlParserADD, PlSqlParserREMOVE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6825) + p.Add_rem_container_data() + } + p.SetState(6828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(6826) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6827) + p.Container_tableview_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 +} + +// IAdminister_key_managementContext is an interface to support dynamic dispatch. +type IAdminister_key_managementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADMINISTER() antlr.TerminalNode + KEY() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Keystore_management_clauses() IKeystore_management_clausesContext + Key_management_clauses() IKey_management_clausesContext + Secret_management_clauses() ISecret_management_clausesContext + Zero_downtime_software_patching_clauses() IZero_downtime_software_patching_clausesContext + + // IsAdminister_key_managementContext differentiates from other interfaces. + IsAdminister_key_managementContext() +} + +type Administer_key_managementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdminister_key_managementContext() *Administer_key_managementContext { + var p = new(Administer_key_managementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_administer_key_management + return p +} + +func InitEmptyAdminister_key_managementContext(p *Administer_key_managementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_administer_key_management +} + +func (*Administer_key_managementContext) IsAdminister_key_managementContext() {} + +func NewAdminister_key_managementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Administer_key_managementContext { + var p = new(Administer_key_managementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_administer_key_management + + return p +} + +func (s *Administer_key_managementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Administer_key_managementContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *Administer_key_managementContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Administer_key_managementContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Administer_key_managementContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Administer_key_managementContext) Keystore_management_clauses() IKeystore_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_management_clausesContext) +} + +func (s *Administer_key_managementContext) Key_management_clauses() IKey_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_management_clausesContext) +} + +func (s *Administer_key_managementContext) Secret_management_clauses() ISecret_management_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecret_management_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecret_management_clausesContext) +} + +func (s *Administer_key_managementContext) Zero_downtime_software_patching_clauses() IZero_downtime_software_patching_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZero_downtime_software_patching_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZero_downtime_software_patching_clausesContext) +} + +func (s *Administer_key_managementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Administer_key_managementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Administer_key_managementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdminister_key_management(s) + } +} + +func (s *Administer_key_managementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdminister_key_management(s) + } +} + +func (s *Administer_key_managementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdminister_key_management(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Administer_key_management() (localctx IAdminister_key_managementContext) { + localctx = NewAdminister_key_managementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 592, PlSqlParserRULE_administer_key_management) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6832) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6833) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6834) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 654, p.GetParserRuleContext()) { + case 1: + { + p.SetState(6835) + p.Keystore_management_clauses() + } + + case 2: + { + p.SetState(6836) + p.Key_management_clauses() + } + + case 3: + { + p.SetState(6837) + p.Secret_management_clauses() + } + + case 4: + { + p.SetState(6838) + p.Zero_downtime_software_patching_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(6841) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IKeystore_management_clausesContext is an interface to support dynamic dispatch. +type IKeystore_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Create_keystore() ICreate_keystoreContext + Open_keystore() IOpen_keystoreContext + Close_keystore() IClose_keystoreContext + Backup_keystore() IBackup_keystoreContext + Alter_keystore_password() IAlter_keystore_passwordContext + Merge_into_new_keystore() IMerge_into_new_keystoreContext + Merge_into_existing_keystore() IMerge_into_existing_keystoreContext + Isolate_keystore() IIsolate_keystoreContext + Unite_keystore() IUnite_keystoreContext + + // IsKeystore_management_clausesContext differentiates from other interfaces. + IsKeystore_management_clausesContext() +} + +type Keystore_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeystore_management_clausesContext() *Keystore_management_clausesContext { + var p = new(Keystore_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses + return p +} + +func InitEmptyKeystore_management_clausesContext(p *Keystore_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses +} + +func (*Keystore_management_clausesContext) IsKeystore_management_clausesContext() {} + +func NewKeystore_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keystore_management_clausesContext { + var p = new(Keystore_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keystore_management_clauses + + return p +} + +func (s *Keystore_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keystore_management_clausesContext) Create_keystore() ICreate_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Open_keystore() IOpen_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Close_keystore() IClose_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClose_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClose_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Backup_keystore() IBackup_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBackup_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBackup_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Alter_keystore_password() IAlter_keystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_keystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_keystore_passwordContext) +} + +func (s *Keystore_management_clausesContext) Merge_into_new_keystore() IMerge_into_new_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_into_new_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_into_new_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Merge_into_existing_keystore() IMerge_into_existing_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_into_existing_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_into_existing_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Isolate_keystore() IIsolate_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIsolate_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIsolate_keystoreContext) +} + +func (s *Keystore_management_clausesContext) Unite_keystore() IUnite_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnite_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnite_keystoreContext) +} + +func (s *Keystore_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keystore_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keystore_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeystore_management_clauses(s) + } +} + +func (s *Keystore_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeystore_management_clauses(s) + } +} + +func (s *Keystore_management_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKeystore_management_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Keystore_management_clauses() (localctx IKeystore_management_clausesContext) { + localctx = NewKeystore_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 594, PlSqlParserRULE_keystore_management_clauses) + p.SetState(6852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 655, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6843) + p.Create_keystore() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6844) + p.Open_keystore() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6845) + p.Close_keystore() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6846) + p.Backup_keystore() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6847) + p.Alter_keystore_password() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6848) + p.Merge_into_new_keystore() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6849) + p.Merge_into_existing_keystore() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6850) + p.Isolate_keystore() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6851) + p.Unite_keystore() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_keystoreContext is an interface to support dynamic dispatch. +type ICreate_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl returns the ksl token. + GetKsl() antlr.Token + + // SetKsl sets the ksl token. + SetKsl(antlr.Token) + + // Getter signatures + CREATE() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + FROM() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsCreate_keystoreContext differentiates from other interfaces. + IsCreate_keystoreContext() +} + +type Create_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl antlr.Token +} + +func NewEmptyCreate_keystoreContext() *Create_keystoreContext { + var p = new(Create_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_keystore + return p +} + +func InitEmptyCreate_keystoreContext(p *Create_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_keystore +} + +func (*Create_keystoreContext) IsCreate_keystoreContext() {} + +func NewCreate_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keystoreContext { + var p = new(Create_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_keystore + + return p +} + +func (s *Create_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_keystoreContext) GetKsl() antlr.Token { return s.ksl } + +func (s *Create_keystoreContext) SetKsl(v antlr.Token) { s.ksl = v } + +func (s *Create_keystoreContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Create_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Create_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Create_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Create_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Create_keystoreContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Create_keystoreContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_keystoreContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Create_keystoreContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Create_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_keystore(s) + } +} + +func (s *Create_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_keystore(s) + } +} + +func (s *Create_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_keystore() (localctx ICreate_keystoreContext) { + localctx = NewCreate_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 596, PlSqlParserRULE_create_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6854) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserKEYSTORE: + { + p.SetState(6855) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6856) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_keystoreContext).ksl = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTO_LOGIN, PlSqlParserLOCAL: + p.SetState(6858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(6857) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6860) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6861) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6862) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6863) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6864) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Create_keystoreContext).ksl = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(6867) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6868) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6869) + p.Keystore_password() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpen_keystoreContext is an interface to support dynamic dispatch. +type IOpen_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + OPEN() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Force_keystore() IForce_keystoreContext + Container_clause() IContainer_clauseContext + + // IsOpen_keystoreContext differentiates from other interfaces. + IsOpen_keystoreContext() +} + +type Open_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_keystoreContext() *Open_keystoreContext { + var p = new(Open_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_keystore + return p +} + +func InitEmptyOpen_keystoreContext(p *Open_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_keystore +} + +func (*Open_keystoreContext) IsOpen_keystoreContext() {} + +func NewOpen_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_keystoreContext { + var p = new(Open_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_keystore + + return p +} + +func (s *Open_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_keystoreContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Open_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Open_keystoreContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Open_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Open_keystoreContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Open_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_keystore(s) + } +} + +func (s *Open_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_keystore(s) + } +} + +func (s *Open_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOpen_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Open_keystore() (localctx IOpen_keystoreContext) { + localctx = NewOpen_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 598, PlSqlParserRULE_open_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6871) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6872) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6873) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6874) + p.Force_keystore() + } + + } + { + p.SetState(6877) + p.Identified_by_store() + } + p.SetState(6879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(6878) + p.Container_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 +} + +// IForce_keystoreContext is an interface to support dynamic dispatch. +type IForce_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORCE() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + + // IsForce_keystoreContext differentiates from other interfaces. + IsForce_keystoreContext() +} + +type Force_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForce_keystoreContext() *Force_keystoreContext { + var p = new(Force_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_keystore + return p +} + +func InitEmptyForce_keystoreContext(p *Force_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_force_keystore +} + +func (*Force_keystoreContext) IsForce_keystoreContext() {} + +func NewForce_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Force_keystoreContext { + var p = new(Force_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_force_keystore + + return p +} + +func (s *Force_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Force_keystoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Force_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Force_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Force_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Force_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForce_keystore(s) + } +} + +func (s *Force_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForce_keystore(s) + } +} + +func (s *Force_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitForce_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Force_keystore() (localctx IForce_keystoreContext) { + localctx = NewForce_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 600, PlSqlParserRULE_force_keystore) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6881) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6882) + p.Match(PlSqlParserKEYSTORE) + 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 +} + +// IClose_keystoreContext is an interface to support dynamic dispatch. +type IClose_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + CLOSE() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Container_clause() IContainer_clauseContext + + // IsClose_keystoreContext differentiates from other interfaces. + IsClose_keystoreContext() +} + +type Close_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClose_keystoreContext() *Close_keystoreContext { + var p = new(Close_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_keystore + return p +} + +func InitEmptyClose_keystoreContext(p *Close_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_keystore +} + +func (*Close_keystoreContext) IsClose_keystoreContext() {} + +func NewClose_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_keystoreContext { + var p = new(Close_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_close_keystore + + return p +} + +func (s *Close_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Close_keystoreContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Close_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Close_keystoreContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Close_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Close_keystoreContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Close_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Close_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Close_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClose_keystore(s) + } +} + +func (s *Close_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClose_keystore(s) + } +} + +func (s *Close_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClose_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Close_keystore() (localctx IClose_keystoreContext) { + localctx = NewClose_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 602, PlSqlParserRULE_close_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6884) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6885) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6886) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(6887) + p.Identified_by_store() + } + + } + p.SetState(6891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(6890) + p.Container_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 +} + +// IBackup_keystoreContext is an interface to support dynamic dispatch. +type IBackup_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBi returns the bi token. + GetBi() antlr.Token + + // GetKsl returns the ksl token. + GetKsl() antlr.Token + + // SetBi sets the bi token. + SetBi(antlr.Token) + + // SetKsl sets the ksl token. + SetKsl(antlr.Token) + + // Getter signatures + BACKUP() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + USING() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + TO() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + + // IsBackup_keystoreContext differentiates from other interfaces. + IsBackup_keystoreContext() +} + +type Backup_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bi antlr.Token + ksl antlr.Token +} + +func NewEmptyBackup_keystoreContext() *Backup_keystoreContext { + var p = new(Backup_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_backup_keystore + return p +} + +func InitEmptyBackup_keystoreContext(p *Backup_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_backup_keystore +} + +func (*Backup_keystoreContext) IsBackup_keystoreContext() {} + +func NewBackup_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Backup_keystoreContext { + var p = new(Backup_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_backup_keystore + + return p +} + +func (s *Backup_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Backup_keystoreContext) GetBi() antlr.Token { return s.bi } + +func (s *Backup_keystoreContext) GetKsl() antlr.Token { return s.ksl } + +func (s *Backup_keystoreContext) SetBi(v antlr.Token) { s.bi = v } + +func (s *Backup_keystoreContext) SetKsl(v antlr.Token) { s.ksl = v } + +func (s *Backup_keystoreContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Backup_keystoreContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Backup_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Backup_keystoreContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Backup_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Backup_keystoreContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Backup_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Backup_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Backup_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Backup_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Backup_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBackup_keystore(s) + } +} + +func (s *Backup_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBackup_keystore(s) + } +} + +func (s *Backup_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBackup_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Backup_keystore() (localctx IBackup_keystoreContext) { + localctx = NewBackup_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 604, PlSqlParserRULE_backup_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6893) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6894) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(6895) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6896) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Backup_keystoreContext).bi = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(6900) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6899) + p.Force_keystore() + } + + } + { + p.SetState(6902) + p.Identified_by_store() + } + p.SetState(6905) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(6903) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6904) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Backup_keystoreContext).ksl = _m + 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_keystore_passwordContext is an interface to support dynamic dispatch. +type IAlter_keystore_passwordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IKeystore_passwordContext + + // GetN returns the n rule contexts. + GetN() IKeystore_passwordContext + + // SetO sets the o rule contexts. + SetO(IKeystore_passwordContext) + + // SetN sets the n rule contexts. + SetN(IKeystore_passwordContext) + + // Getter signatures + ALTER() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + SET() antlr.TerminalNode + AllKeystore_password() []IKeystore_passwordContext + Keystore_password(i int) IKeystore_passwordContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsAlter_keystore_passwordContext differentiates from other interfaces. + IsAlter_keystore_passwordContext() +} + +type Alter_keystore_passwordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IKeystore_passwordContext + n IKeystore_passwordContext +} + +func NewEmptyAlter_keystore_passwordContext() *Alter_keystore_passwordContext { + var p = new(Alter_keystore_passwordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_keystore_password + return p +} + +func InitEmptyAlter_keystore_passwordContext(p *Alter_keystore_passwordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_keystore_password +} + +func (*Alter_keystore_passwordContext) IsAlter_keystore_passwordContext() {} + +func NewAlter_keystore_passwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_keystore_passwordContext { + var p = new(Alter_keystore_passwordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_keystore_password + + return p +} + +func (s *Alter_keystore_passwordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_keystore_passwordContext) GetO() IKeystore_passwordContext { return s.o } + +func (s *Alter_keystore_passwordContext) GetN() IKeystore_passwordContext { return s.n } + +func (s *Alter_keystore_passwordContext) SetO(v IKeystore_passwordContext) { s.o = v } + +func (s *Alter_keystore_passwordContext) SetN(v IKeystore_passwordContext) { s.n = v } + +func (s *Alter_keystore_passwordContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_keystore_passwordContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Alter_keystore_passwordContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Alter_keystore_passwordContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Alter_keystore_passwordContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Alter_keystore_passwordContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_keystore_passwordContext) AllKeystore_password() []IKeystore_passwordContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeystore_passwordContext); ok { + len++ + } + } + + tst := make([]IKeystore_passwordContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeystore_passwordContext); ok { + tst[i] = t.(IKeystore_passwordContext) + i++ + } + } + + return tst +} + +func (s *Alter_keystore_passwordContext) Keystore_password(i int) IKeystore_passwordContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Alter_keystore_passwordContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Alter_keystore_passwordContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Alter_keystore_passwordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_keystore_passwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_keystore_passwordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_keystore_password(s) + } +} + +func (s *Alter_keystore_passwordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_keystore_password(s) + } +} + +func (s *Alter_keystore_passwordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_keystore_password(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_keystore_password() (localctx IAlter_keystore_passwordContext) { + localctx = NewAlter_keystore_passwordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 606, PlSqlParserRULE_alter_keystore_password) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6907) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6908) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6909) + p.Match(PlSqlParserPASSWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6910) + p.Force_keystore() + } + + } + { + p.SetState(6913) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6914) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6915) + + var _x = p.Keystore_password() + + localctx.(*Alter_keystore_passwordContext).o = _x + } + { + p.SetState(6916) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6917) + + var _x = p.Keystore_password() + + localctx.(*Alter_keystore_passwordContext).n = _x + } + p.SetState(6919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6918) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_into_new_keystoreContext is an interface to support dynamic dispatch. +type IMerge_into_new_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // GetKsl2 returns the ksl2 token. + GetKsl2() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // SetKsl2 sets the ksl2 token. + SetKsl2(antlr.Token) + + // Getter signatures + MERGE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AND() antlr.TerminalNode + INTO() antlr.TerminalNode + NEW() antlr.TerminalNode + AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext + Identified_by_password_clause(i int) IIdentified_by_password_clauseContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + + // IsMerge_into_new_keystoreContext differentiates from other interfaces. + IsMerge_into_new_keystoreContext() +} + +type Merge_into_new_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksl2 antlr.Token +} + +func NewEmptyMerge_into_new_keystoreContext() *Merge_into_new_keystoreContext { + var p = new(Merge_into_new_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore + return p +} + +func InitEmptyMerge_into_new_keystoreContext(p *Merge_into_new_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore +} + +func (*Merge_into_new_keystoreContext) IsMerge_into_new_keystoreContext() {} + +func NewMerge_into_new_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_into_new_keystoreContext { + var p = new(Merge_into_new_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_into_new_keystore + + return p +} + +func (s *Merge_into_new_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_into_new_keystoreContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Merge_into_new_keystoreContext) GetKsl2() antlr.Token { return s.ksl2 } + +func (s *Merge_into_new_keystoreContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Merge_into_new_keystoreContext) SetKsl2(v antlr.Token) { s.ksl2 = v } + +func (s *Merge_into_new_keystoreContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_into_new_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Merge_into_new_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Merge_into_new_keystoreContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Merge_into_new_keystoreContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_into_new_keystoreContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Merge_into_new_keystoreContext) AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_by_password_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_by_password_clauseContext); ok { + tst[i] = t.(IIdentified_by_password_clauseContext) + i++ + } + } + + return tst +} + +func (s *Merge_into_new_keystoreContext) Identified_by_password_clause(i int) IIdentified_by_password_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_password_clauseContext) +} + +func (s *Merge_into_new_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Merge_into_new_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Merge_into_new_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_into_new_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_into_new_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_into_new_keystore(s) + } +} + +func (s *Merge_into_new_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_into_new_keystore(s) + } +} + +func (s *Merge_into_new_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_into_new_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_into_new_keystore() (localctx IMerge_into_new_keystoreContext) { + localctx = NewMerge_into_new_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 608, PlSqlParserRULE_merge_into_new_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6921) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6922) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6923) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(6924) + p.Identified_by_password_clause() + } + + } + { + p.SetState(6927) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6928) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6929) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6931) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(6930) + p.Identified_by_password_clause() + } + + } + { + p.SetState(6933) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6934) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6935) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6936) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_new_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6937) + p.Identified_by_password_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_into_existing_keystoreContext is an interface to support dynamic dispatch. +type IMerge_into_existing_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // GetKsl2 returns the ksl2 token. + GetKsl2() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // SetKsl2 sets the ksl2 token. + SetKsl2(antlr.Token) + + // Getter signatures + MERGE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + INTO() antlr.TerminalNode + EXISTING() antlr.TerminalNode + AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext + Identified_by_password_clause(i int) IIdentified_by_password_clauseContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + With_backup_clause() IWith_backup_clauseContext + + // IsMerge_into_existing_keystoreContext differentiates from other interfaces. + IsMerge_into_existing_keystoreContext() +} + +type Merge_into_existing_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksl2 antlr.Token +} + +func NewEmptyMerge_into_existing_keystoreContext() *Merge_into_existing_keystoreContext { + var p = new(Merge_into_existing_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore + return p +} + +func InitEmptyMerge_into_existing_keystoreContext(p *Merge_into_existing_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore +} + +func (*Merge_into_existing_keystoreContext) IsMerge_into_existing_keystoreContext() {} + +func NewMerge_into_existing_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_into_existing_keystoreContext { + var p = new(Merge_into_existing_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_into_existing_keystore + + return p +} + +func (s *Merge_into_existing_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_into_existing_keystoreContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Merge_into_existing_keystoreContext) GetKsl2() antlr.Token { return s.ksl2 } + +func (s *Merge_into_existing_keystoreContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Merge_into_existing_keystoreContext) SetKsl2(v antlr.Token) { s.ksl2 = v } + +func (s *Merge_into_existing_keystoreContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_into_existing_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Merge_into_existing_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Merge_into_existing_keystoreContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_into_existing_keystoreContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Merge_into_existing_keystoreContext) AllIdentified_by_password_clause() []IIdentified_by_password_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + len++ + } + } + + tst := make([]IIdentified_by_password_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentified_by_password_clauseContext); ok { + tst[i] = t.(IIdentified_by_password_clauseContext) + i++ + } + } + + return tst +} + +func (s *Merge_into_existing_keystoreContext) Identified_by_password_clause(i int) IIdentified_by_password_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_password_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_password_clauseContext) +} + +func (s *Merge_into_existing_keystoreContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Merge_into_existing_keystoreContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Merge_into_existing_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Merge_into_existing_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_into_existing_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_into_existing_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_into_existing_keystore(s) + } +} + +func (s *Merge_into_existing_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_into_existing_keystore(s) + } +} + +func (s *Merge_into_existing_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_into_existing_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_into_existing_keystore() (localctx IMerge_into_existing_keystoreContext) { + localctx = NewMerge_into_existing_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 610, PlSqlParserRULE_merge_into_existing_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6939) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6940) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6941) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_existing_keystoreContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6943) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(6942) + p.Identified_by_password_clause() + } + + } + { + p.SetState(6945) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6946) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6947) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6948) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Merge_into_existing_keystoreContext).ksl2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6949) + p.Identified_by_password_clause() + } + p.SetState(6951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6950) + p.With_backup_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 +} + +// IIsolate_keystoreContext is an interface to support dynamic dispatch. +type IIsolate_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetI returns the i rule contexts. + GetI() IKeystore_passwordContext + + // SetI sets the i rule contexts. + SetI(IKeystore_passwordContext) + + // Getter signatures + ISOLATE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + FROM() antlr.TerminalNode + ROOT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Keystore_password() IKeystore_passwordContext + FORCE() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsIsolate_keystoreContext differentiates from other interfaces. + IsIsolate_keystoreContext() +} + +type Isolate_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + i IKeystore_passwordContext +} + +func NewEmptyIsolate_keystoreContext() *Isolate_keystoreContext { + var p = new(Isolate_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_isolate_keystore + return p +} + +func InitEmptyIsolate_keystoreContext(p *Isolate_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_isolate_keystore +} + +func (*Isolate_keystoreContext) IsIsolate_keystoreContext() {} + +func NewIsolate_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Isolate_keystoreContext { + var p = new(Isolate_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_isolate_keystore + + return p +} + +func (s *Isolate_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Isolate_keystoreContext) GetI() IKeystore_passwordContext { return s.i } + +func (s *Isolate_keystoreContext) SetI(v IKeystore_passwordContext) { s.i = v } + +func (s *Isolate_keystoreContext) ISOLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATE, 0) +} + +func (s *Isolate_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Isolate_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Isolate_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Isolate_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Isolate_keystoreContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Isolate_keystoreContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Isolate_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Isolate_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Isolate_keystoreContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Isolate_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Isolate_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Isolate_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Isolate_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Isolate_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIsolate_keystore(s) + } +} + +func (s *Isolate_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIsolate_keystore(s) + } +} + +func (s *Isolate_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIsolate_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Isolate_keystore() (localctx IIsolate_keystoreContext) { + localctx = NewIsolate_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 612, PlSqlParserRULE_isolate_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(6954) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6953) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(6956) + p.Match(PlSqlParserISOLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6957) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6958) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6959) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6960) + + var _x = p.Keystore_password() + + localctx.(*Isolate_keystoreContext).i = _x + } + { + p.SetState(6961) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6962) + p.Match(PlSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6963) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6965) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6964) + p.Force_keystore() + } + + } + { + p.SetState(6967) + p.Identified_by_store() + } + p.SetState(6969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6968) + p.With_backup_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 +} + +// IUnite_keystoreContext is an interface to support dynamic dispatch. +type IUnite_keystoreContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetI returns the i rule contexts. + GetI() IKeystore_passwordContext + + // SetI sets the i rule contexts. + SetI(IKeystore_passwordContext) + + // Getter signatures + UNITE() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + WITH() antlr.TerminalNode + ROOT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + Keystore_password() IKeystore_passwordContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsUnite_keystoreContext differentiates from other interfaces. + IsUnite_keystoreContext() +} + +type Unite_keystoreContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + i IKeystore_passwordContext +} + +func NewEmptyUnite_keystoreContext() *Unite_keystoreContext { + var p = new(Unite_keystoreContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unite_keystore + return p +} + +func InitEmptyUnite_keystoreContext(p *Unite_keystoreContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unite_keystore +} + +func (*Unite_keystoreContext) IsUnite_keystoreContext() {} + +func NewUnite_keystoreContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unite_keystoreContext { + var p = new(Unite_keystoreContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unite_keystore + + return p +} + +func (s *Unite_keystoreContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unite_keystoreContext) GetI() IKeystore_passwordContext { return s.i } + +func (s *Unite_keystoreContext) SetI(v IKeystore_passwordContext) { s.i = v } + +func (s *Unite_keystoreContext) UNITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNITE, 0) +} + +func (s *Unite_keystoreContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Unite_keystoreContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Unite_keystoreContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Unite_keystoreContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Unite_keystoreContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Unite_keystoreContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Unite_keystoreContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Unite_keystoreContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Unite_keystoreContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Unite_keystoreContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Unite_keystoreContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unite_keystoreContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unite_keystoreContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnite_keystore(s) + } +} + +func (s *Unite_keystoreContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnite_keystore(s) + } +} + +func (s *Unite_keystoreContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnite_keystore(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unite_keystore() (localctx IUnite_keystoreContext) { + localctx = NewUnite_keystoreContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 614, PlSqlParserRULE_unite_keystore) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6971) + p.Match(PlSqlParserUNITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6972) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6973) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6974) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6975) + + var _x = p.Keystore_password() + + localctx.(*Unite_keystoreContext).i = _x + } + { + p.SetState(6976) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6977) + p.Match(PlSqlParserROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(6978) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6980) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(6979) + p.Force_keystore() + } + + } + { + p.SetState(6982) + p.Identified_by_store() + } + p.SetState(6984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(6983) + p.With_backup_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 +} + +// IKey_management_clausesContext is an interface to support dynamic dispatch. +type IKey_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_key() ISet_keyContext + Create_key() ICreate_keyContext + Use_key() IUse_keyContext + Set_key_tag() ISet_key_tagContext + Export_keys() IExport_keysContext + Import_keys() IImport_keysContext + Migrate_keys() IMigrate_keysContext + Reverse_migrate_keys() IReverse_migrate_keysContext + Move_keys() IMove_keysContext + + // IsKey_management_clausesContext differentiates from other interfaces. + IsKey_management_clausesContext() +} + +type Key_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_management_clausesContext() *Key_management_clausesContext { + var p = new(Key_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_management_clauses + return p +} + +func InitEmptyKey_management_clausesContext(p *Key_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_management_clauses +} + +func (*Key_management_clausesContext) IsKey_management_clausesContext() {} + +func NewKey_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_management_clausesContext { + var p = new(Key_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_management_clauses + + return p +} + +func (s *Key_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_management_clausesContext) Set_key() ISet_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_keyContext) +} + +func (s *Key_management_clausesContext) Create_key() ICreate_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_keyContext) +} + +func (s *Key_management_clausesContext) Use_key() IUse_keyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUse_keyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUse_keyContext) +} + +func (s *Key_management_clausesContext) Set_key_tag() ISet_key_tagContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_key_tagContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_key_tagContext) +} + +func (s *Key_management_clausesContext) Export_keys() IExport_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExport_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExport_keysContext) +} + +func (s *Key_management_clausesContext) Import_keys() IImport_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImport_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImport_keysContext) +} + +func (s *Key_management_clausesContext) Migrate_keys() IMigrate_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMigrate_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMigrate_keysContext) +} + +func (s *Key_management_clausesContext) Reverse_migrate_keys() IReverse_migrate_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReverse_migrate_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReverse_migrate_keysContext) +} + +func (s *Key_management_clausesContext) Move_keys() IMove_keysContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_keysContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_keysContext) +} + +func (s *Key_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_management_clauses(s) + } +} + +func (s *Key_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_management_clauses(s) + } +} + +func (s *Key_management_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKey_management_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Key_management_clauses() (localctx IKey_management_clausesContext) { + localctx = NewKey_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 616, PlSqlParserRULE_key_management_clauses) + p.SetState(6995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 676, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6986) + p.Set_key() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(6987) + p.Create_key() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(6988) + p.Use_key() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(6989) + p.Set_key_tag() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(6990) + p.Export_keys() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(6991) + p.Import_keys() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(6992) + p.Migrate_keys() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(6993) + p.Reverse_migrate_keys() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(6994) + p.Move_keys() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_keyContext is an interface to support dynamic dispatch. +type ISet_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Mk() IMkContext + Using_tag_clause() IUsing_tag_clauseContext + Using_algorithm_clause() IUsing_algorithm_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + Container_clause() IContainer_clauseContext + Mkid() IMkidContext + COLON() antlr.TerminalNode + + // IsSet_keyContext differentiates from other interfaces. + IsSet_keyContext() +} + +type Set_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_keyContext() *Set_keyContext { + var p = new(Set_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key + return p +} + +func InitEmptySet_keyContext(p *Set_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key +} + +func (*Set_keyContext) IsSet_keyContext() {} + +func NewSet_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_keyContext { + var p = new(Set_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_key + + return p +} + +func (s *Set_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_keyContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Set_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Set_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Set_keyContext) Mk() IMkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkContext) +} + +func (s *Set_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Set_keyContext) Using_algorithm_clause() IUsing_algorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_algorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_algorithm_clauseContext) +} + +func (s *Set_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Set_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Set_keyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Set_keyContext) Mkid() IMkidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkidContext) +} + +func (s *Set_keyContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Set_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_key(s) + } +} + +func (s *Set_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_key(s) + } +} + +func (s *Set_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_key() (localctx ISet_keyContext) { + localctx = NewSet_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 618, PlSqlParserRULE_set_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(6997) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(6999) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(6998) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7001) + p.Match(PlSqlParserKEY) + 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 == PlSqlParserCHAR_STRING { + p.SetState(7005) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 678, p.GetParserRuleContext()) == 1 { + { + p.SetState(7002) + p.Mkid() + } + { + p.SetState(7003) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7007) + p.Mk() + } + + } + p.SetState(7011) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 680, p.GetParserRuleContext()) == 1 { + { + p.SetState(7010) + p.Using_tag_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7013) + p.Using_algorithm_clause() + } + + } + p.SetState(7017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7016) + p.Force_keystore() + } + + } + { + p.SetState(7019) + p.Identified_by_store() + } + p.SetState(7021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7020) + p.With_backup_clause() + } + + } + p.SetState(7024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7023) + p.Container_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_keyContext is an interface to support dynamic dispatch. +type ICreate_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Mk() IMkContext + Using_tag_clause() IUsing_tag_clauseContext + Using_algorithm_clause() IUsing_algorithm_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + Container_clause() IContainer_clauseContext + Mkid() IMkidContext + COLON() antlr.TerminalNode + + // IsCreate_keyContext differentiates from other interfaces. + IsCreate_keyContext() +} + +type Create_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_keyContext() *Create_keyContext { + var p = new(Create_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_key + return p +} + +func InitEmptyCreate_keyContext(p *Create_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_key +} + +func (*Create_keyContext) IsCreate_keyContext() {} + +func NewCreate_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_keyContext { + var p = new(Create_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_key + + return p +} + +func (s *Create_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_keyContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Create_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Create_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Create_keyContext) Mk() IMkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkContext) +} + +func (s *Create_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Create_keyContext) Using_algorithm_clause() IUsing_algorithm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_algorithm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_algorithm_clauseContext) +} + +func (s *Create_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Create_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Create_keyContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_keyContext) Mkid() IMkidContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMkidContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMkidContext) +} + +func (s *Create_keyContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Create_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_key(s) + } +} + +func (s *Create_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_key(s) + } +} + +func (s *Create_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_key() (localctx ICreate_keyContext) { + localctx = NewCreate_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 620, PlSqlParserRULE_create_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7026) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7027) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7030) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + p.SetState(7034) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 686, p.GetParserRuleContext()) == 1 { + { + p.SetState(7031) + p.Mkid() + } + { + p.SetState(7032) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7036) + p.Mk() + } + + } + p.SetState(7040) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 688, p.GetParserRuleContext()) == 1 { + { + p.SetState(7039) + p.Using_tag_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7042) + p.Using_algorithm_clause() + } + + } + p.SetState(7046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7045) + p.Force_keystore() + } + + } + { + p.SetState(7048) + p.Identified_by_store() + } + p.SetState(7050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7049) + p.With_backup_clause() + } + + } + p.SetState(7053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(7052) + p.Container_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 +} + +// IMkidContext is an interface to support dynamic dispatch. +type IMkidContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsMkidContext differentiates from other interfaces. + IsMkidContext() +} + +type MkidContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMkidContext() *MkidContext { + var p = new(MkidContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mkid + return p +} + +func InitEmptyMkidContext(p *MkidContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mkid +} + +func (*MkidContext) IsMkidContext() {} + +func NewMkidContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MkidContext { + var p = new(MkidContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mkid + + return p +} + +func (s *MkidContext) GetParser() antlr.Parser { return s.parser } + +func (s *MkidContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *MkidContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MkidContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MkidContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMkid(s) + } +} + +func (s *MkidContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMkid(s) + } +} + +func (s *MkidContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMkid(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mkid() (localctx IMkidContext) { + localctx = NewMkidContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 622, PlSqlParserRULE_mkid) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7055) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IMkContext is an interface to support dynamic dispatch. +type IMkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsMkContext differentiates from other interfaces. + IsMkContext() +} + +type MkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMkContext() *MkContext { + var p = new(MkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mk + return p +} + +func InitEmptyMkContext(p *MkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mk +} + +func (*MkContext) IsMkContext() {} + +func NewMkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *MkContext { + var p = new(MkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mk + + return p +} + +func (s *MkContext) GetParser() antlr.Parser { return s.parser } + +func (s *MkContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *MkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *MkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *MkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMk(s) + } +} + +func (s *MkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMk(s) + } +} + +func (s *MkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMk(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mk() (localctx IMkContext) { + localctx = NewMkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 624, PlSqlParserRULE_mk) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7057) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IUse_keyContext is an interface to support dynamic dispatch. +type IUse_keyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetK returns the k token. + GetK() antlr.Token + + // SetK sets the k token. + SetK(antlr.Token) + + // Getter signatures + USE() antlr.TerminalNode + KEY() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + CHAR_STRING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsUse_keyContext differentiates from other interfaces. + IsUse_keyContext() +} + +type Use_keyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + k antlr.Token +} + +func NewEmptyUse_keyContext() *Use_keyContext { + var p = new(Use_keyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_use_key + return p +} + +func InitEmptyUse_keyContext(p *Use_keyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_use_key +} + +func (*Use_keyContext) IsUse_keyContext() {} + +func NewUse_keyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Use_keyContext { + var p = new(Use_keyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_use_key + + return p +} + +func (s *Use_keyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Use_keyContext) GetK() antlr.Token { return s.k } + +func (s *Use_keyContext) SetK(v antlr.Token) { s.k = v } + +func (s *Use_keyContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Use_keyContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Use_keyContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Use_keyContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Use_keyContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Use_keyContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Use_keyContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Use_keyContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Use_keyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Use_keyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Use_keyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUse_key(s) + } +} + +func (s *Use_keyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUse_key(s) + } +} + +func (s *Use_keyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUse_key(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Use_key() (localctx IUse_keyContext) { + localctx = NewUse_keyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 626, PlSqlParserRULE_use_key) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7059) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7060) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7063) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7064) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Use_keyContext).k = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7065) + p.Using_tag_clause() + } + + } + p.SetState(7069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7068) + p.Force_keystore() + } + + } + { + p.SetState(7071) + p.Identified_by_store() + } + p.SetState(7073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7072) + p.With_backup_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISet_key_tagContext is an interface to support dynamic dispatch. +type ISet_key_tagContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t token. + GetT() antlr.Token + + // GetK returns the k token. + GetK() antlr.Token + + // SetT sets the t token. + SetT(antlr.Token) + + // SetK sets the k token. + SetK(antlr.Token) + + // Getter signatures + SET() antlr.TerminalNode + TAG() antlr.TerminalNode + FOR() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsSet_key_tagContext differentiates from other interfaces. + IsSet_key_tagContext() +} + +type Set_key_tagContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t antlr.Token + k antlr.Token +} + +func NewEmptySet_key_tagContext() *Set_key_tagContext { + var p = new(Set_key_tagContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key_tag + return p +} + +func InitEmptySet_key_tagContext(p *Set_key_tagContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_key_tag +} + +func (*Set_key_tagContext) IsSet_key_tagContext() {} + +func NewSet_key_tagContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_key_tagContext { + var p = new(Set_key_tagContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_key_tag + + return p +} + +func (s *Set_key_tagContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_key_tagContext) GetT() antlr.Token { return s.t } + +func (s *Set_key_tagContext) GetK() antlr.Token { return s.k } + +func (s *Set_key_tagContext) SetT(v antlr.Token) { s.t = v } + +func (s *Set_key_tagContext) SetK(v antlr.Token) { s.k = v } + +func (s *Set_key_tagContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_key_tagContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Set_key_tagContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Set_key_tagContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Set_key_tagContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Set_key_tagContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Set_key_tagContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Set_key_tagContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Set_key_tagContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_key_tagContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_key_tagContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_key_tag(s) + } +} + +func (s *Set_key_tagContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_key_tag(s) + } +} + +func (s *Set_key_tagContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_key_tag(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_key_tag() (localctx ISet_key_tagContext) { + localctx = NewSet_key_tagContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 628, PlSqlParserRULE_set_key_tag) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7075) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7076) + p.Match(PlSqlParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7077) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Set_key_tagContext).t = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7078) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7079) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Set_key_tagContext).k = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7080) + p.Force_keystore() + } + + } + { + p.SetState(7083) + p.Identified_by_store() + } + p.SetState(7085) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7084) + p.With_backup_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 +} + +// IExport_keysContext is an interface to support dynamic dispatch. +type IExport_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPORT() antlr.TerminalNode + KEYS() antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + SECRET() antlr.TerminalNode + Secret() ISecretContext + TO() antlr.TerminalNode + Filename() IFilenameContext + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + IDENTIFIER() antlr.TerminalNode + IN() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExport_keysContext differentiates from other interfaces. + IsExport_keysContext() +} + +type Export_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExport_keysContext() *Export_keysContext { + var p = new(Export_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_export_keys + return p +} + +func InitEmptyExport_keysContext(p *Export_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_export_keys +} + +func (*Export_keysContext) IsExport_keysContext() {} + +func NewExport_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Export_keysContext { + var p = new(Export_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_export_keys + + return p +} + +func (s *Export_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Export_keysContext) EXPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPORT, 0) +} + +func (s *Export_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Export_keysContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Export_keysContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Export_keysContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Export_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Export_keysContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Export_keysContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Export_keysContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Export_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Export_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Export_keysContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Export_keysContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Export_keysContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Export_keysContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Export_keysContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Export_keysContext) 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 *Export_keysContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Export_keysContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Export_keysContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Export_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Export_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Export_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExport_keys(s) + } +} + +func (s *Export_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExport_keys(s) + } +} + +func (s *Export_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExport_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Export_keys() (localctx IExport_keysContext) { + localctx = NewExport_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 630, PlSqlParserRULE_export_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7087) + p.Match(PlSqlParserEXPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7088) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7091) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7092) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7093) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7094) + p.Secret() + } + { + p.SetState(7095) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7096) + p.Filename() + } + p.SetState(7098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7097) + p.Force_keystore() + } + + } + { + p.SetState(7100) + p.Identified_by_store() + } + p.SetState(7118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7101) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7102) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7103) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(7104) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7105) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7106) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(7111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(7112) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7113) + p.Subquery() + } + { + p.SetState(7114) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImport_keysContext is an interface to support dynamic dispatch. +type IImport_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IMPORT() antlr.TerminalNode + KEYS() antlr.TerminalNode + WITH() antlr.TerminalNode + SECRET() antlr.TerminalNode + Secret() ISecretContext + FROM() antlr.TerminalNode + Filename() IFilenameContext + Identified_by_store() IIdentified_by_storeContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsImport_keysContext differentiates from other interfaces. + IsImport_keysContext() +} + +type Import_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImport_keysContext() *Import_keysContext { + var p = new(Import_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_import_keys + return p +} + +func InitEmptyImport_keysContext(p *Import_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_import_keys +} + +func (*Import_keysContext) IsImport_keysContext() {} + +func NewImport_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Import_keysContext { + var p = new(Import_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_import_keys + + return p +} + +func (s *Import_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Import_keysContext) IMPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPORT, 0) +} + +func (s *Import_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Import_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Import_keysContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Import_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Import_keysContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Import_keysContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Import_keysContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Import_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Import_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Import_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Import_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Import_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Import_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImport_keys(s) + } +} + +func (s *Import_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImport_keys(s) + } +} + +func (s *Import_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImport_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Import_keys() (localctx IImport_keysContext) { + localctx = NewImport_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 632, PlSqlParserRULE_import_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7120) + p.Match(PlSqlParserIMPORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7122) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7121) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7124) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7125) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7126) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7127) + p.Secret() + } + { + p.SetState(7128) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7129) + p.Filename() + } + p.SetState(7131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7130) + p.Force_keystore() + } + + } + { + p.SetState(7133) + p.Identified_by_store() + } + p.SetState(7135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7134) + p.With_backup_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 +} + +// IMigrate_keysContext is an interface to support dynamic dispatch. +type IMigrate_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHsm returns the hsm rule contexts. + GetHsm() ISecretContext + + // SetHsm sets the hsm rule contexts. + SetHsm(ISecretContext) + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + USING() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + Secret() ISecretContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsMigrate_keysContext differentiates from other interfaces. + IsMigrate_keysContext() +} + +type Migrate_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hsm ISecretContext +} + +func NewEmptyMigrate_keysContext() *Migrate_keysContext { + var p = new(Migrate_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_migrate_keys + return p +} + +func InitEmptyMigrate_keysContext(p *Migrate_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_migrate_keys +} + +func (*Migrate_keysContext) IsMigrate_keysContext() {} + +func NewMigrate_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Migrate_keysContext { + var p = new(Migrate_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_migrate_keys + + return p +} + +func (s *Migrate_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Migrate_keysContext) GetHsm() ISecretContext { return s.hsm } + +func (s *Migrate_keysContext) SetHsm(v ISecretContext) { s.hsm = v } + +func (s *Migrate_keysContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Migrate_keysContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Migrate_keysContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Migrate_keysContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Migrate_keysContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Migrate_keysContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Migrate_keysContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Migrate_keysContext) Secret() ISecretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Migrate_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Migrate_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Migrate_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Migrate_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Migrate_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Migrate_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMigrate_keys(s) + } +} + +func (s *Migrate_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMigrate_keys(s) + } +} + +func (s *Migrate_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMigrate_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Migrate_keys() (localctx IMigrate_keysContext) { + localctx = NewMigrate_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 634, PlSqlParserRULE_migrate_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7137) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7138) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7141) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7142) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7143) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7144) + + var _x = p.Secret() + + localctx.(*Migrate_keysContext).hsm = _x + } + p.SetState(7146) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7145) + p.Force_keystore() + } + + } + { + p.SetState(7148) + p.Match(PlSqlParserMIGRATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7149) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7150) + p.Keystore_password() + } + p.SetState(7152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7151) + p.With_backup_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 +} + +// IReverse_migrate_keysContext is an interface to support dynamic dispatch. +type IReverse_migrate_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s rule contexts. + GetS() ISecretContext + + // GetHsm returns the hsm rule contexts. + GetHsm() ISecretContext + + // SetS sets the s rule contexts. + SetS(ISecretContext) + + // SetHsm sets the hsm rule contexts. + SetHsm(ISecretContext) + + // Getter signatures + SET() antlr.TerminalNode + KEY() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + REVERSE() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + USING() antlr.TerminalNode + AllSecret() []ISecretContext + Secret(i int) ISecretContext + ENCRYPTION() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + + // IsReverse_migrate_keysContext differentiates from other interfaces. + IsReverse_migrate_keysContext() +} + +type Reverse_migrate_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s ISecretContext + hsm ISecretContext +} + +func NewEmptyReverse_migrate_keysContext() *Reverse_migrate_keysContext { + var p = new(Reverse_migrate_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys + return p +} + +func InitEmptyReverse_migrate_keysContext(p *Reverse_migrate_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys +} + +func (*Reverse_migrate_keysContext) IsReverse_migrate_keysContext() {} + +func NewReverse_migrate_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reverse_migrate_keysContext { + var p = new(Reverse_migrate_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reverse_migrate_keys + + return p +} + +func (s *Reverse_migrate_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reverse_migrate_keysContext) GetS() ISecretContext { return s.s } + +func (s *Reverse_migrate_keysContext) GetHsm() ISecretContext { return s.hsm } + +func (s *Reverse_migrate_keysContext) SetS(v ISecretContext) { s.s = v } + +func (s *Reverse_migrate_keysContext) SetHsm(v ISecretContext) { s.hsm = v } + +func (s *Reverse_migrate_keysContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Reverse_migrate_keysContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Reverse_migrate_keysContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Reverse_migrate_keysContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Reverse_migrate_keysContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Reverse_migrate_keysContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Reverse_migrate_keysContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Reverse_migrate_keysContext) AllSecret() []ISecretContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISecretContext); ok { + len++ + } + } + + tst := make([]ISecretContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISecretContext); ok { + tst[i] = t.(ISecretContext) + i++ + } + } + + return tst +} + +func (s *Reverse_migrate_keysContext) Secret(i int) ISecretContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecretContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISecretContext) +} + +func (s *Reverse_migrate_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Reverse_migrate_keysContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Reverse_migrate_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reverse_migrate_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reverse_migrate_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReverse_migrate_keys(s) + } +} + +func (s *Reverse_migrate_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReverse_migrate_keys(s) + } +} + +func (s *Reverse_migrate_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReverse_migrate_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Reverse_migrate_keys() (localctx IReverse_migrate_keysContext) { + localctx = NewReverse_migrate_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 636, PlSqlParserRULE_reverse_migrate_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7154) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7155) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7158) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7159) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7160) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7161) + + var _x = p.Secret() + + localctx.(*Reverse_migrate_keysContext).s = _x + } + p.SetState(7163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7162) + p.Force_keystore() + } + + } + { + p.SetState(7165) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7166) + p.Match(PlSqlParserMIGRATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7167) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7168) + + var _x = p.Secret() + + localctx.(*Reverse_migrate_keysContext).hsm = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_keysContext is an interface to support dynamic dispatch. +type IMove_keysContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetKsl1 returns the ksl1 token. + GetKsl1() antlr.Token + + // SetKsl1 sets the ksl1 token. + SetKsl1(antlr.Token) + + // GetKsp1 returns the ksp1 rule contexts. + GetKsp1() IKeystore_passwordContext + + // GetKsp returns the ksp rule contexts. + GetKsp() IKeystore_passwordContext + + // SetKsp1 sets the ksp1 rule contexts. + SetKsp1(IKeystore_passwordContext) + + // SetKsp sets the ksp rule contexts. + SetKsp(IKeystore_passwordContext) + + // Getter signatures + MOVE() antlr.TerminalNode + KEYS() antlr.TerminalNode + TO() antlr.TerminalNode + NEW() antlr.TerminalNode + AllKEYSTORE() []antlr.TerminalNode + KEYSTORE(i int) antlr.TerminalNode + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + FROM() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllKeystore_password() []IKeystore_passwordContext + Keystore_password(i int) IKeystore_passwordContext + ENCRYPTION() antlr.TerminalNode + FORCE() antlr.TerminalNode + WITH() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IN() antlr.TerminalNode + With_backup_clause() IWith_backup_clauseContext + Subquery() ISubqueryContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMove_keysContext differentiates from other interfaces. + IsMove_keysContext() +} + +type Move_keysContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ksl1 antlr.Token + ksp1 IKeystore_passwordContext + ksp IKeystore_passwordContext +} + +func NewEmptyMove_keysContext() *Move_keysContext { + var p = new(Move_keysContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_keys + return p +} + +func InitEmptyMove_keysContext(p *Move_keysContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_keys +} + +func (*Move_keysContext) IsMove_keysContext() {} + +func NewMove_keysContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_keysContext { + var p = new(Move_keysContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_keys + + return p +} + +func (s *Move_keysContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_keysContext) GetKsl1() antlr.Token { return s.ksl1 } + +func (s *Move_keysContext) SetKsl1(v antlr.Token) { s.ksl1 = v } + +func (s *Move_keysContext) GetKsp1() IKeystore_passwordContext { return s.ksp1 } + +func (s *Move_keysContext) GetKsp() IKeystore_passwordContext { return s.ksp } + +func (s *Move_keysContext) SetKsp1(v IKeystore_passwordContext) { s.ksp1 = v } + +func (s *Move_keysContext) SetKsp(v IKeystore_passwordContext) { s.ksp = v } + +func (s *Move_keysContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_keysContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Move_keysContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_keysContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Move_keysContext) AllKEYSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEYSTORE) +} + +func (s *Move_keysContext) KEYSTORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, i) +} + +func (s *Move_keysContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Move_keysContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Move_keysContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Move_keysContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Move_keysContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Move_keysContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Move_keysContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Move_keysContext) AllKeystore_password() []IKeystore_passwordContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKeystore_passwordContext); ok { + len++ + } + } + + tst := make([]IKeystore_passwordContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKeystore_passwordContext); ok { + tst[i] = t.(IKeystore_passwordContext) + i++ + } + } + + return tst +} + +func (s *Move_keysContext) Keystore_password(i int) IKeystore_passwordContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Move_keysContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Move_keysContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Move_keysContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Move_keysContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Move_keysContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Move_keysContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Move_keysContext) 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 *Move_keysContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Move_keysContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Move_keysContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_keysContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_keysContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_keys(s) + } +} + +func (s *Move_keysContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_keys(s) + } +} + +func (s *Move_keysContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMove_keys(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Move_keys() (localctx IMove_keysContext) { + localctx = NewMove_keysContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 638, PlSqlParserRULE_move_keys) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7170) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPTION { + { + p.SetState(7171) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7174) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7175) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7176) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7177) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7178) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Move_keysContext).ksl1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7179) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7180) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7181) + + var _x = p.Keystore_password() + + localctx.(*Move_keysContext).ksp1 = _x + } + { + p.SetState(7182) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7183) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7186) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7187) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7188) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7189) + + var _x = p.Keystore_password() + + localctx.(*Move_keysContext).ksp = _x + } + p.SetState(7204) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 716, p.GetParserRuleContext()) == 1 { + { + p.SetState(7190) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7191) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7192) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(7193) + p.Match(PlSqlParserCHAR_STRING) + 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) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7194) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7195) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(7200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(7201) + p.Subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7206) + p.With_backup_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 +} + +// IIdentified_by_storeContext is an interface to support dynamic dispatch. +type IIdentified_by_storeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + STORE() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + + // IsIdentified_by_storeContext differentiates from other interfaces. + IsIdentified_by_storeContext() +} + +type Identified_by_storeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_by_storeContext() *Identified_by_storeContext { + var p = new(Identified_by_storeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_store + return p +} + +func InitEmptyIdentified_by_storeContext(p *Identified_by_storeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_store +} + +func (*Identified_by_storeContext) IsIdentified_by_storeContext() {} + +func NewIdentified_by_storeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_by_storeContext { + var p = new(Identified_by_storeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by_store + + return p +} + +func (s *Identified_by_storeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_by_storeContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_by_storeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_by_storeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Identified_by_storeContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Identified_by_storeContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Identified_by_storeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_by_storeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_by_storeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by_store(s) + } +} + +func (s *Identified_by_storeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by_store(s) + } +} + +func (s *Identified_by_storeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentified_by_store(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identified_by_store() (localctx IIdentified_by_storeContext) { + localctx = NewIdentified_by_storeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 640, PlSqlParserRULE_identified_by_store) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7209) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7210) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7214) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXTERNAL: + { + p.SetState(7211) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7212) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDELIMITED_ID: + { + p.SetState(7213) + p.Keystore_password() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_algorithm_clauseContext is an interface to support dynamic dispatch. +type IUsing_algorithm_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEa returns the ea token. + GetEa() antlr.Token + + // SetEa sets the ea token. + SetEa(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsUsing_algorithm_clauseContext differentiates from other interfaces. + IsUsing_algorithm_clauseContext() +} + +type Using_algorithm_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ea antlr.Token +} + +func NewEmptyUsing_algorithm_clauseContext() *Using_algorithm_clauseContext { + var p = new(Using_algorithm_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause + return p +} + +func InitEmptyUsing_algorithm_clauseContext(p *Using_algorithm_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause +} + +func (*Using_algorithm_clauseContext) IsUsing_algorithm_clauseContext() {} + +func NewUsing_algorithm_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_algorithm_clauseContext { + var p = new(Using_algorithm_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_algorithm_clause + + return p +} + +func (s *Using_algorithm_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_algorithm_clauseContext) GetEa() antlr.Token { return s.ea } + +func (s *Using_algorithm_clauseContext) SetEa(v antlr.Token) { s.ea = v } + +func (s *Using_algorithm_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_algorithm_clauseContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(PlSqlParserALGORITHM, 0) +} + +func (s *Using_algorithm_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Using_algorithm_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_algorithm_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_algorithm_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_algorithm_clause(s) + } +} + +func (s *Using_algorithm_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_algorithm_clause(s) + } +} + +func (s *Using_algorithm_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_algorithm_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_algorithm_clause() (localctx IUsing_algorithm_clauseContext) { + localctx = NewUsing_algorithm_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 642, PlSqlParserRULE_using_algorithm_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7216) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7217) + p.Match(PlSqlParserALGORITHM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7218) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Using_algorithm_clauseContext).ea = _m + 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 +} + +// IUsing_tag_clauseContext is an interface to support dynamic dispatch. +type IUsing_tag_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetT returns the t token. + GetT() antlr.Token + + // SetT sets the t token. + SetT(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + TAG() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsUsing_tag_clauseContext differentiates from other interfaces. + IsUsing_tag_clauseContext() +} + +type Using_tag_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + t antlr.Token +} + +func NewEmptyUsing_tag_clauseContext() *Using_tag_clauseContext { + var p = new(Using_tag_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_tag_clause + return p +} + +func InitEmptyUsing_tag_clauseContext(p *Using_tag_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_tag_clause +} + +func (*Using_tag_clauseContext) IsUsing_tag_clauseContext() {} + +func NewUsing_tag_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_tag_clauseContext { + var p = new(Using_tag_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_tag_clause + + return p +} + +func (s *Using_tag_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_tag_clauseContext) GetT() antlr.Token { return s.t } + +func (s *Using_tag_clauseContext) SetT(v antlr.Token) { s.t = v } + +func (s *Using_tag_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_tag_clauseContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Using_tag_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Using_tag_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_tag_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_tag_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_tag_clause(s) + } +} + +func (s *Using_tag_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_tag_clause(s) + } +} + +func (s *Using_tag_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_tag_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_tag_clause() (localctx IUsing_tag_clauseContext) { + localctx = NewUsing_tag_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 644, PlSqlParserRULE_using_tag_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7220) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7221) + p.Match(PlSqlParserTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7222) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Using_tag_clauseContext).t = _m + 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 +} + +// ISecret_management_clausesContext is an interface to support dynamic dispatch. +type ISecret_management_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_update_secret() IAdd_update_secretContext + Delete_secret() IDelete_secretContext + Add_update_secret_seps() IAdd_update_secret_sepsContext + Delete_secret_seps() IDelete_secret_sepsContext + + // IsSecret_management_clausesContext differentiates from other interfaces. + IsSecret_management_clausesContext() +} + +type Secret_management_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecret_management_clausesContext() *Secret_management_clausesContext { + var p = new(Secret_management_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret_management_clauses + return p +} + +func InitEmptySecret_management_clausesContext(p *Secret_management_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret_management_clauses +} + +func (*Secret_management_clausesContext) IsSecret_management_clausesContext() {} + +func NewSecret_management_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Secret_management_clausesContext { + var p = new(Secret_management_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_secret_management_clauses + + return p +} + +func (s *Secret_management_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Secret_management_clausesContext) Add_update_secret() IAdd_update_secretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_update_secretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_update_secretContext) +} + +func (s *Secret_management_clausesContext) Delete_secret() IDelete_secretContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_secretContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_secretContext) +} + +func (s *Secret_management_clausesContext) Add_update_secret_seps() IAdd_update_secret_sepsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_update_secret_sepsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_update_secret_sepsContext) +} + +func (s *Secret_management_clausesContext) Delete_secret_seps() IDelete_secret_sepsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelete_secret_sepsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelete_secret_sepsContext) +} + +func (s *Secret_management_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Secret_management_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Secret_management_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecret_management_clauses(s) + } +} + +func (s *Secret_management_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecret_management_clauses(s) + } +} + +func (s *Secret_management_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSecret_management_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Secret_management_clauses() (localctx ISecret_management_clausesContext) { + localctx = NewSecret_management_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 646, PlSqlParserRULE_secret_management_clauses) + p.SetState(7228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 719, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7224) + p.Add_update_secret() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7225) + p.Delete_secret() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7226) + p.Add_update_secret_seps() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7227) + p.Delete_secret_seps() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_update_secretContext is an interface to support dynamic dispatch. +type IAdd_update_secretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + ADD() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + Force_keystore() IForce_keystoreContext + Identified_by_store() IIdentified_by_storeContext + With_backup_clause() IWith_backup_clauseContext + + // IsAdd_update_secretContext differentiates from other interfaces. + IsAdd_update_secretContext() +} + +type Add_update_secretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyAdd_update_secretContext() *Add_update_secretContext { + var p = new(Add_update_secretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret + return p +} + +func InitEmptyAdd_update_secretContext(p *Add_update_secretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret +} + +func (*Add_update_secretContext) IsAdd_update_secretContext() {} + +func NewAdd_update_secretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_update_secretContext { + var p = new(Add_update_secretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_update_secret + + return p +} + +func (s *Add_update_secretContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_update_secretContext) GetS() antlr.Token { return s.s } + +func (s *Add_update_secretContext) GetCi() antlr.Token { return s.ci } + +func (s *Add_update_secretContext) SetS(v antlr.Token) { s.s = v } + +func (s *Add_update_secretContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Add_update_secretContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Add_update_secretContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Add_update_secretContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Add_update_secretContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_update_secretContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Add_update_secretContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_update_secretContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_update_secretContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Add_update_secretContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Add_update_secretContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Add_update_secretContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Add_update_secretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_update_secretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_update_secretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_update_secret(s) + } +} + +func (s *Add_update_secretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_update_secret(s) + } +} + +func (s *Add_update_secretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_update_secret(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_update_secret() (localctx IAdd_update_secretContext) { + localctx = NewAdd_update_secretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 648, PlSqlParserRULE_add_update_secret) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7230) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7231) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7232) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secretContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7233) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7234) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7235) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secretContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7236) + p.Using_tag_clause() + } + + } + p.SetState(7240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7239) + p.Force_keystore() + } + + } + p.SetState(7243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(7242) + p.Identified_by_store() + } + + } + p.SetState(7246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7245) + p.With_backup_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 +} + +// IDelete_secretContext is an interface to support dynamic dispatch. +type IDelete_secretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + Identified_by_store() IIdentified_by_storeContext + CHAR_STRING() antlr.TerminalNode + Force_keystore() IForce_keystoreContext + With_backup_clause() IWith_backup_clauseContext + + // IsDelete_secretContext differentiates from other interfaces. + IsDelete_secretContext() +} + +type Delete_secretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ci antlr.Token +} + +func NewEmptyDelete_secretContext() *Delete_secretContext { + var p = new(Delete_secretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret + return p +} + +func InitEmptyDelete_secretContext(p *Delete_secretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret +} + +func (*Delete_secretContext) IsDelete_secretContext() {} + +func NewDelete_secretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_secretContext { + var p = new(Delete_secretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delete_secret + + return p +} + +func (s *Delete_secretContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_secretContext) GetCi() antlr.Token { return s.ci } + +func (s *Delete_secretContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Delete_secretContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_secretContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Delete_secretContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Delete_secretContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Delete_secretContext) Identified_by_store() IIdentified_by_storeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_by_storeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_by_storeContext) +} + +func (s *Delete_secretContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Delete_secretContext) Force_keystore() IForce_keystoreContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForce_keystoreContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForce_keystoreContext) +} + +func (s *Delete_secretContext) With_backup_clause() IWith_backup_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWith_backup_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWith_backup_clauseContext) +} + +func (s *Delete_secretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_secretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_secretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelete_secret(s) + } +} + +func (s *Delete_secretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_secret(s) + } +} + +func (s *Delete_secretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDelete_secret(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Delete_secret() (localctx IDelete_secretContext) { + localctx = NewDelete_secretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 650, PlSqlParserRULE_delete_secret) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7248) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7249) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7250) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7251) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7252) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secretContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(7253) + p.Force_keystore() + } + + } + { + p.SetState(7256) + p.Identified_by_store() + } + p.SetState(7258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7257) + p.With_backup_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 +} + +// IAdd_update_secret_sepsContext is an interface to support dynamic dispatch. +type IAdd_update_secret_sepsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + SECRET() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + TO() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Directory_path() IDirectory_pathContext + ADD() antlr.TerminalNode + UPDATE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Using_tag_clause() IUsing_tag_clauseContext + LOCAL() antlr.TerminalNode + + // IsAdd_update_secret_sepsContext differentiates from other interfaces. + IsAdd_update_secret_sepsContext() +} + +type Add_update_secret_sepsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyAdd_update_secret_sepsContext() *Add_update_secret_sepsContext { + var p = new(Add_update_secret_sepsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps + return p +} + +func InitEmptyAdd_update_secret_sepsContext(p *Add_update_secret_sepsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps +} + +func (*Add_update_secret_sepsContext) IsAdd_update_secret_sepsContext() {} + +func NewAdd_update_secret_sepsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_update_secret_sepsContext { + var p = new(Add_update_secret_sepsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_update_secret_seps + + return p +} + +func (s *Add_update_secret_sepsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_update_secret_sepsContext) GetS() antlr.Token { return s.s } + +func (s *Add_update_secret_sepsContext) GetCi() antlr.Token { return s.ci } + +func (s *Add_update_secret_sepsContext) SetS(v antlr.Token) { s.s = v } + +func (s *Add_update_secret_sepsContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Add_update_secret_sepsContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Add_update_secret_sepsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Add_update_secret_sepsContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Add_update_secret_sepsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Add_update_secret_sepsContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Add_update_secret_sepsContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Add_update_secret_sepsContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Add_update_secret_sepsContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_update_secret_sepsContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Add_update_secret_sepsContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Add_update_secret_sepsContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Add_update_secret_sepsContext) Using_tag_clause() IUsing_tag_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_tag_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_tag_clauseContext) +} + +func (s *Add_update_secret_sepsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Add_update_secret_sepsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_update_secret_sepsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_update_secret_sepsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_update_secret_seps(s) + } +} + +func (s *Add_update_secret_sepsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_update_secret_seps(s) + } +} + +func (s *Add_update_secret_sepsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_update_secret_seps(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_update_secret_seps() (localctx IAdd_update_secret_sepsContext) { + localctx = NewAdd_update_secret_sepsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 652, PlSqlParserRULE_add_update_secret_seps) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7260) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7261) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7262) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secret_sepsContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7263) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7264) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7265) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Add_update_secret_sepsContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7266) + p.Using_tag_clause() + } + + } + { + p.SetState(7269) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7270) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7273) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7274) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7275) + p.Directory_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_secret_sepsContext is an interface to support dynamic dispatch. +type IDelete_secret_sepsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetS returns the s token. + GetS() antlr.Token + + // GetCi returns the ci token. + GetCi() antlr.Token + + // SetS sets the s token. + SetS(antlr.Token) + + // SetCi sets the ci token. + SetCi(antlr.Token) + + // Getter signatures + DELETE() antlr.TerminalNode + SECRET() antlr.TerminalNode + SQ() antlr.TerminalNode + FOR() antlr.TerminalNode + CLIENT() antlr.TerminalNode + FROM() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + Directory_path() IDirectory_pathContext + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsDelete_secret_sepsContext differentiates from other interfaces. + IsDelete_secret_sepsContext() +} + +type Delete_secret_sepsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + s antlr.Token + ci antlr.Token +} + +func NewEmptyDelete_secret_sepsContext() *Delete_secret_sepsContext { + var p = new(Delete_secret_sepsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret_seps + return p +} + +func InitEmptyDelete_secret_sepsContext(p *Delete_secret_sepsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delete_secret_seps +} + +func (*Delete_secret_sepsContext) IsDelete_secret_sepsContext() {} + +func NewDelete_secret_sepsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delete_secret_sepsContext { + var p = new(Delete_secret_sepsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delete_secret_seps + + return p +} + +func (s *Delete_secret_sepsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_secret_sepsContext) GetS() antlr.Token { return s.s } + +func (s *Delete_secret_sepsContext) GetCi() antlr.Token { return s.ci } + +func (s *Delete_secret_sepsContext) SetS(v antlr.Token) { s.s = v } + +func (s *Delete_secret_sepsContext) SetCi(v antlr.Token) { s.ci = v } + +func (s *Delete_secret_sepsContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_secret_sepsContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Delete_secret_sepsContext) SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQ, 0) +} + +func (s *Delete_secret_sepsContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Delete_secret_sepsContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Delete_secret_sepsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Delete_secret_sepsContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Delete_secret_sepsContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Delete_secret_sepsContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Delete_secret_sepsContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Delete_secret_sepsContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Delete_secret_sepsContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Delete_secret_sepsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delete_secret_sepsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delete_secret_sepsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelete_secret_seps(s) + } +} + +func (s *Delete_secret_sepsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_secret_seps(s) + } +} + +func (s *Delete_secret_sepsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDelete_secret_seps(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Delete_secret_seps() (localctx IDelete_secret_sepsContext) { + localctx = NewDelete_secret_sepsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 654, PlSqlParserRULE_delete_secret_seps) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7277) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7278) + p.Match(PlSqlParserSECRET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7279) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secret_sepsContext).s = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7280) + p.Match(PlSqlParserSQ) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7281) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7282) + p.Match(PlSqlParserCLIENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7283) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Delete_secret_sepsContext).ci = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7284) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7285) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7288) + p.Match(PlSqlParserAUTO_LOGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7289) + p.Match(PlSqlParserKEYSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7290) + p.Directory_path() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZero_downtime_software_patching_clausesContext is an interface to support dynamic dispatch. +type IZero_downtime_software_patching_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SWITCHOVER() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Path() IPathContext + FOR() antlr.TerminalNode + ALL() antlr.TerminalNode + CONTAINERS() antlr.TerminalNode + TO() antlr.TerminalNode + + // IsZero_downtime_software_patching_clausesContext differentiates from other interfaces. + IsZero_downtime_software_patching_clausesContext() +} + +type Zero_downtime_software_patching_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZero_downtime_software_patching_clausesContext() *Zero_downtime_software_patching_clausesContext { + var p = new(Zero_downtime_software_patching_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses + return p +} + +func InitEmptyZero_downtime_software_patching_clausesContext(p *Zero_downtime_software_patching_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses +} + +func (*Zero_downtime_software_patching_clausesContext) IsZero_downtime_software_patching_clausesContext() { +} + +func NewZero_downtime_software_patching_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zero_downtime_software_patching_clausesContext { + var p = new(Zero_downtime_software_patching_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zero_downtime_software_patching_clauses + + return p +} + +func (s *Zero_downtime_software_patching_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zero_downtime_software_patching_clausesContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) Path() IPathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPathContext) +} + +func (s *Zero_downtime_software_patching_clausesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) CONTAINERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Zero_downtime_software_patching_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zero_downtime_software_patching_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zero_downtime_software_patching_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZero_downtime_software_patching_clauses(s) + } +} + +func (s *Zero_downtime_software_patching_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZero_downtime_software_patching_clauses(s) + } +} + +func (s *Zero_downtime_software_patching_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitZero_downtime_software_patching_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Zero_downtime_software_patching_clauses() (localctx IZero_downtime_software_patching_clausesContext) { + localctx = NewZero_downtime_software_patching_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 656, PlSqlParserRULE_zero_downtime_software_patching_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7292) + p.Match(PlSqlParserSWITCHOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(7293) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7296) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7297) + p.Path() + } + { + p.SetState(7298) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7299) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7300) + p.Match(PlSqlParserCONTAINERS) + 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_backup_clauseContext is an interface to support dynamic dispatch. +type IWith_backup_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBi returns the bi token. + GetBi() antlr.Token + + // SetBi sets the bi token. + SetBi(antlr.Token) + + // Getter signatures + WITH() antlr.TerminalNode + BACKUP() antlr.TerminalNode + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsWith_backup_clauseContext differentiates from other interfaces. + IsWith_backup_clauseContext() +} + +type With_backup_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bi antlr.Token +} + +func NewEmptyWith_backup_clauseContext() *With_backup_clauseContext { + var p = new(With_backup_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_backup_clause + return p +} + +func InitEmptyWith_backup_clauseContext(p *With_backup_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_with_backup_clause +} + +func (*With_backup_clauseContext) IsWith_backup_clauseContext() {} + +func NewWith_backup_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *With_backup_clauseContext { + var p = new(With_backup_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_with_backup_clause + + return p +} + +func (s *With_backup_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *With_backup_clauseContext) GetBi() antlr.Token { return s.bi } + +func (s *With_backup_clauseContext) SetBi(v antlr.Token) { s.bi = v } + +func (s *With_backup_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *With_backup_clauseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *With_backup_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *With_backup_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *With_backup_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *With_backup_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *With_backup_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWith_backup_clause(s) + } +} + +func (s *With_backup_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWith_backup_clause(s) + } +} + +func (s *With_backup_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWith_backup_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) With_backup_clause() (localctx IWith_backup_clauseContext) { + localctx = NewWith_backup_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 658, PlSqlParserRULE_with_backup_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7302) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7303) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(7304) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7305) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*With_backup_clauseContext).bi = _m + 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 +} + +// IIdentified_by_password_clauseContext is an interface to support dynamic dispatch. +type IIdentified_by_password_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Keystore_password() IKeystore_passwordContext + + // IsIdentified_by_password_clauseContext differentiates from other interfaces. + IsIdentified_by_password_clauseContext() +} + +type Identified_by_password_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentified_by_password_clauseContext() *Identified_by_password_clauseContext { + var p = new(Identified_by_password_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause + return p +} + +func InitEmptyIdentified_by_password_clauseContext(p *Identified_by_password_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause +} + +func (*Identified_by_password_clauseContext) IsIdentified_by_password_clauseContext() {} + +func NewIdentified_by_password_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identified_by_password_clauseContext { + var p = new(Identified_by_password_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identified_by_password_clause + + return p +} + +func (s *Identified_by_password_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identified_by_password_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Identified_by_password_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identified_by_password_clauseContext) Keystore_password() IKeystore_passwordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeystore_passwordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeystore_passwordContext) +} + +func (s *Identified_by_password_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identified_by_password_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identified_by_password_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentified_by_password_clause(s) + } +} + +func (s *Identified_by_password_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentified_by_password_clause(s) + } +} + +func (s *Identified_by_password_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentified_by_password_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identified_by_password_clause() (localctx IIdentified_by_password_clauseContext) { + localctx = NewIdentified_by_password_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 660, PlSqlParserRULE_identified_by_password_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7308) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7309) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7310) + p.Keystore_password() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeystore_passwordContext is an interface to support dynamic dispatch. +type IKeystore_passwordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsKeystore_passwordContext differentiates from other interfaces. + IsKeystore_passwordContext() +} + +type Keystore_passwordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeystore_passwordContext() *Keystore_passwordContext { + var p = new(Keystore_passwordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_password + return p +} + +func InitEmptyKeystore_passwordContext(p *Keystore_passwordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keystore_password +} + +func (*Keystore_passwordContext) IsKeystore_passwordContext() {} + +func NewKeystore_passwordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keystore_passwordContext { + var p = new(Keystore_passwordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keystore_password + + return p +} + +func (s *Keystore_passwordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keystore_passwordContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Keystore_passwordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keystore_passwordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keystore_passwordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeystore_password(s) + } +} + +func (s *Keystore_passwordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeystore_password(s) + } +} + +func (s *Keystore_passwordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKeystore_password(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Keystore_password() (localctx IKeystore_passwordContext) { + localctx = NewKeystore_passwordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 662, PlSqlParserRULE_keystore_password) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7312) + p.Match(PlSqlParserDELIMITED_ID) + 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 +} + +// IPathContext is an interface to support dynamic dispatch. +type IPathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsPathContext differentiates from other interfaces. + IsPathContext() +} + +type PathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPathContext() *PathContext { + var p = new(PathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_path + return p +} + +func InitEmptyPathContext(p *PathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_path +} + +func (*PathContext) IsPathContext() {} + +func NewPathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *PathContext { + var p = new(PathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_path + + return p +} + +func (s *PathContext) GetParser() antlr.Parser { return s.parser } + +func (s *PathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *PathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *PathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *PathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPath(s) + } +} + +func (s *PathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPath(s) + } +} + +func (s *PathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPath(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Path() (localctx IPathContext) { + localctx = NewPathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 664, PlSqlParserRULE_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7314) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// ISecretContext is an interface to support dynamic dispatch. +type ISecretContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsSecretContext differentiates from other interfaces. + IsSecretContext() +} + +type SecretContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecretContext() *SecretContext { + var p = new(SecretContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret + return p +} + +func InitEmptySecretContext(p *SecretContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_secret +} + +func (*SecretContext) IsSecretContext() {} + +func NewSecretContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *SecretContext { + var p = new(SecretContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_secret + + return p +} + +func (s *SecretContext) GetParser() antlr.Parser { return s.parser } + +func (s *SecretContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *SecretContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *SecretContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *SecretContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecret(s) + } +} + +func (s *SecretContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecret(s) + } +} + +func (s *SecretContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSecret(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Secret() (localctx ISecretContext) { + localctx = NewSecretContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 666, PlSqlParserRULE_secret) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7316) + p.Match(PlSqlParserDELIMITED_ID) + 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 +} + +// IAnalyzeContext is an interface to support dynamic dispatch. +type IAnalyzeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEMICOLON() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + Validation_clauses() IValidation_clausesContext + LIST() antlr.TerminalNode + CHAINED() antlr.TerminalNode + ROWS() antlr.TerminalNode + DELETE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + Partition_extention_clause() IPartition_extention_clauseContext + Into_clause1() IInto_clause1Context + SYSTEM() antlr.TerminalNode + + // IsAnalyzeContext differentiates from other interfaces. + IsAnalyzeContext() +} + +type AnalyzeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnalyzeContext() *AnalyzeContext { + var p = new(AnalyzeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_analyze + return p +} + +func InitEmptyAnalyzeContext(p *AnalyzeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_analyze +} + +func (*AnalyzeContext) IsAnalyzeContext() {} + +func NewAnalyzeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AnalyzeContext { + var p = new(AnalyzeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_analyze + + return p +} + +func (s *AnalyzeContext) GetParser() antlr.Parser { return s.parser } + +func (s *AnalyzeContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *AnalyzeContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *AnalyzeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *AnalyzeContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *AnalyzeContext) Validation_clauses() IValidation_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValidation_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValidation_clausesContext) +} + +func (s *AnalyzeContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *AnalyzeContext) CHAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAINED, 0) +} + +func (s *AnalyzeContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *AnalyzeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *AnalyzeContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *AnalyzeContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *AnalyzeContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *AnalyzeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *AnalyzeContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *AnalyzeContext) Partition_extention_clause() IPartition_extention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extention_clauseContext) +} + +func (s *AnalyzeContext) Into_clause1() IInto_clause1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clause1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInto_clause1Context) +} + +func (s *AnalyzeContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *AnalyzeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AnalyzeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AnalyzeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnalyze(s) + } +} + +func (s *AnalyzeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnalyze(s) + } +} + +func (s *AnalyzeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAnalyze(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Analyze() (localctx IAnalyzeContext) { + localctx = NewAnalyzeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 668, PlSqlParserRULE_analyze) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 733, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7318) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(7319) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7320) + p.Tableview_name() + } + + case PlSqlParserINDEX: + { + p.SetState(7321) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7322) + p.Index_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION { + { + p.SetState(7325) + p.Partition_extention_clause() + } + + } + + case 2: + { + p.SetState(7328) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7329) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7330) + p.Cluster_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALIDATE: + { + p.SetState(7333) + p.Validation_clauses() + } + + case PlSqlParserLIST: + { + p.SetState(7334) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7335) + p.Match(PlSqlParserCHAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7336) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7338) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(7337) + p.Into_clause1() + } + + } + + case PlSqlParserDELETE: + { + p.SetState(7340) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7342) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(7341) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7344) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7347) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPartition_extention_clauseContext is an interface to support dynamic dispatch. +type IPartition_extention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Partition_name() IPartition_nameContext + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllPartition_key_value() []IPartition_key_valueContext + Partition_key_value(i int) IPartition_key_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + AllSubpartition_key_value() []ISubpartition_key_valueContext + Subpartition_key_value(i int) ISubpartition_key_valueContext + + // IsPartition_extention_clauseContext differentiates from other interfaces. + IsPartition_extention_clauseContext() +} + +type Partition_extention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extention_clauseContext() *Partition_extention_clauseContext { + var p = new(Partition_extention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extention_clause + return p +} + +func InitEmptyPartition_extention_clauseContext(p *Partition_extention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extention_clause +} + +func (*Partition_extention_clauseContext) IsPartition_extention_clauseContext() {} + +func NewPartition_extention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extention_clauseContext { + var p = new(Partition_extention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extention_clause + + return p +} + +func (s *Partition_extention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extention_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extention_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extention_clauseContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_extention_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extention_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extention_clauseContext) AllPartition_key_value() []IPartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_key_valueContext); ok { + len++ + } + } + + tst := make([]IPartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_key_valueContext); ok { + tst[i] = t.(IPartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extention_clauseContext) Partition_key_value(i int) IPartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_key_valueContext) +} + +func (s *Partition_extention_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partition_extention_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partition_extention_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Partition_extention_clauseContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Partition_extention_clauseContext) AllSubpartition_key_value() []ISubpartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + len++ + } + } + + tst := make([]ISubpartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartition_key_valueContext); ok { + tst[i] = t.(ISubpartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extention_clauseContext) Subpartition_key_value(i int) ISubpartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_key_valueContext) +} + +func (s *Partition_extention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extention_clause(s) + } +} + +func (s *Partition_extention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extention_clause(s) + } +} + +func (s *Partition_extention_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_extention_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_extention_clause() (localctx IPartition_extention_clauseContext) { + localctx = NewPartition_extention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 670, PlSqlParserRULE_partition_extention_clause) + var _la int + + p.SetState(7387) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7349) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(7350) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7351) + p.Partition_name() + } + { + p.SetState(7352) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(7354) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7355) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7356) + p.Partition_key_value() + } + p.SetState(7361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7357) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7358) + p.Partition_key_value() + } + + p.SetState(7363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7364) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserSUBPARTITION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7368) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(7369) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7370) + p.Subpartition_name() + } + { + p.SetState(7371) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(7373) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7374) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7375) + p.Subpartition_key_value() + } + p.SetState(7380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7376) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7377) + p.Subpartition_key_value() + } + + p.SetState(7382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7383) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IValidation_clausesContext is an interface to support dynamic dispatch. +type IValidation_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALIDATE() antlr.TerminalNode + REF() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + DANGLING() antlr.TerminalNode + TO() antlr.TerminalNode + NULL_() antlr.TerminalNode + STRUCTURE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + FAST() antlr.TerminalNode + AllOnline_or_offline() []IOnline_or_offlineContext + Online_or_offline(i int) IOnline_or_offlineContext + AllInto_clause() []IInto_clauseContext + Into_clause(i int) IInto_clauseContext + + // IsValidation_clausesContext differentiates from other interfaces. + IsValidation_clausesContext() +} + +type Validation_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValidation_clausesContext() *Validation_clausesContext { + var p = new(Validation_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_validation_clauses + return p +} + +func InitEmptyValidation_clausesContext(p *Validation_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_validation_clauses +} + +func (*Validation_clausesContext) IsValidation_clausesContext() {} + +func NewValidation_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Validation_clausesContext { + var p = new(Validation_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_validation_clauses + + return p +} + +func (s *Validation_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Validation_clausesContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Validation_clausesContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Validation_clausesContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Validation_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Validation_clausesContext) DANGLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDANGLING, 0) +} + +func (s *Validation_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Validation_clausesContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Validation_clausesContext) STRUCTURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCTURE, 0) +} + +func (s *Validation_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Validation_clausesContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Validation_clausesContext) AllOnline_or_offline() []IOnline_or_offlineContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + len++ + } + } + + tst := make([]IOnline_or_offlineContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOnline_or_offlineContext); ok { + tst[i] = t.(IOnline_or_offlineContext) + i++ + } + } + + return tst +} + +func (s *Validation_clausesContext) Online_or_offline(i int) IOnline_or_offlineContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOnline_or_offlineContext) +} + +func (s *Validation_clausesContext) AllInto_clause() []IInto_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInto_clauseContext); ok { + len++ + } + } + + tst := make([]IInto_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInto_clauseContext); ok { + tst[i] = t.(IInto_clauseContext) + i++ + } + } + + return tst +} + +func (s *Validation_clausesContext) Into_clause(i int) IInto_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInto_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInto_clauseContext) +} + +func (s *Validation_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Validation_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Validation_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterValidation_clauses(s) + } +} + +func (s *Validation_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitValidation_clauses(s) + } +} + +func (s *Validation_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitValidation_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Validation_clauses() (localctx IValidation_clausesContext) { + localctx = NewValidation_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 672, PlSqlParserRULE_validation_clauses) + var _la int + + p.SetState(7418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 748, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7389) + p.Match(PlSqlParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7390) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7391) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(7392) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7393) + p.Match(PlSqlParserDANGLING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7394) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7395) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7398) + p.Match(PlSqlParserVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7399) + p.Match(PlSqlParserSTRUCTURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7410) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 745, p.GetParserRuleContext()) == 1 { + { + p.SetState(7400) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7401) + p.Match(PlSqlParserFAST) + 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(), 745, p.GetParserRuleContext()) == 2 { + { + p.SetState(7402) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7404) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 743, p.GetParserRuleContext()) == 1 { + { + p.SetState(7403) + p.Online_or_offline() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7407) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 744, p.GetParserRuleContext()) == 1 { + { + p.SetState(7406) + p.Into_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 745, p.GetParserRuleContext()) == 3 { + { + p.SetState(7409) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7413) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE { + { + p.SetState(7412) + p.Online_or_offline() + } + + } + p.SetState(7416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBULK || _la == PlSqlParserINTO { + { + p.SetState(7415) + p.Into_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 +} + +// ICompute_clausesContext is an interface to support dynamic dispatch. +type ICompute_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPUTE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + For_clause() IFor_clauseContext + + // IsCompute_clausesContext differentiates from other interfaces. + IsCompute_clausesContext() +} + +type Compute_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompute_clausesContext() *Compute_clausesContext { + var p = new(Compute_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compute_clauses + return p +} + +func InitEmptyCompute_clausesContext(p *Compute_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compute_clauses +} + +func (*Compute_clausesContext) IsCompute_clausesContext() {} + +func NewCompute_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compute_clausesContext { + var p = new(Compute_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compute_clauses + + return p +} + +func (s *Compute_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compute_clausesContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Compute_clausesContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Compute_clausesContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Compute_clausesContext) For_clause() IFor_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *Compute_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compute_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compute_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompute_clauses(s) + } +} + +func (s *Compute_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompute_clauses(s) + } +} + +func (s *Compute_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompute_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compute_clauses() (localctx ICompute_clausesContext) { + localctx = NewCompute_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 674, PlSqlParserRULE_compute_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7420) + p.Match(PlSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSTEM { + { + p.SetState(7421) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7424) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7426) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 750, p.GetParserRuleContext()) == 1 { + { + p.SetState(7425) + p.For_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 +} + +// IFor_clauseContext is an interface to support dynamic dispatch. +type IFor_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + TABLE() antlr.TerminalNode + ALL() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + INDEXES() antlr.TerminalNode + AllFor_clause() []IFor_clauseContext + For_clause(i int) IFor_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + INDEXED() antlr.TerminalNode + LOCAL() antlr.TerminalNode + + // IsFor_clauseContext differentiates from other interfaces. + IsFor_clauseContext() +} + +type For_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_clauseContext() *For_clauseContext { + var p = new(For_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_clause + return p +} + +func InitEmptyFor_clauseContext(p *For_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_clause +} + +func (*For_clauseContext) IsFor_clauseContext() {} + +func NewFor_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_clauseContext { + var p = new(For_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_clause + + return p +} + +func (s *For_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *For_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *For_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *For_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *For_clauseContext) AllFor_clause() []IFor_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFor_clauseContext); ok { + len++ + } + } + + tst := make([]IFor_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFor_clauseContext); ok { + tst[i] = t.(IFor_clauseContext) + i++ + } + } + + return tst +} + +func (s *For_clauseContext) For_clause(i int) IFor_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFor_clauseContext) +} + +func (s *For_clauseContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *For_clauseContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *For_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *For_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *For_clauseContext) 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 *For_clauseContext) 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 *For_clauseContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *For_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *For_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_clause(s) + } +} + +func (s *For_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_clause(s) + } +} + +func (s *For_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFor_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) For_clause() (localctx IFor_clauseContext) { + localctx = NewFor_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 676, PlSqlParserRULE_for_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7428) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(7429) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7433) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 751, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7430) + p.For_clause() + } + + } + p.SetState(7435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 751, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(7436) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7455) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS, PlSqlParserINDEXED: + p.SetState(7438) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXED { + { + p.SetState(7437) + p.Match(PlSqlParserINDEXED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7440) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7443) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 753, p.GetParserRuleContext()) == 1 { + { + p.SetState(7441) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7442) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 754, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7445) + p.For_clause() + } + + } + p.SetState(7450) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 754, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserINDEXES, PlSqlParserLOCAL: + p.SetState(7452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(7451) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7454) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCOLUMNS: + { + p.SetState(7457) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(7458) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7459) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(7466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(7462) + p.Column_name() + } + { + p.SetState(7463) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7464) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(7468) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 758, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(7473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7470) + p.For_clause() + } + + } + p.SetState(7475) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 759, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IOnline_or_offlineContext is an interface to support dynamic dispatch. +type IOnline_or_offlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFLINE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + + // IsOnline_or_offlineContext differentiates from other interfaces. + IsOnline_or_offlineContext() +} + +type Online_or_offlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOnline_or_offlineContext() *Online_or_offlineContext { + var p = new(Online_or_offlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_online_or_offline + return p +} + +func InitEmptyOnline_or_offlineContext(p *Online_or_offlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_online_or_offline +} + +func (*Online_or_offlineContext) IsOnline_or_offlineContext() {} + +func NewOnline_or_offlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Online_or_offlineContext { + var p = new(Online_or_offlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_online_or_offline + + return p +} + +func (s *Online_or_offlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Online_or_offlineContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Online_or_offlineContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Online_or_offlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Online_or_offlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Online_or_offlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOnline_or_offline(s) + } +} + +func (s *Online_or_offlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOnline_or_offline(s) + } +} + +func (s *Online_or_offlineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOnline_or_offline(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Online_or_offline() (localctx IOnline_or_offlineContext) { + localctx = NewOnline_or_offlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 678, PlSqlParserRULE_online_or_offline) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7478) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE) { + 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 +} + +// IInto_clause1Context is an interface to support dynamic dispatch. +type IInto_clause1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsInto_clause1Context differentiates from other interfaces. + IsInto_clause1Context() +} + +type Into_clause1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInto_clause1Context() *Into_clause1Context { + var p = new(Into_clause1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause1 + return p +} + +func InitEmptyInto_clause1Context(p *Into_clause1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_into_clause1 +} + +func (*Into_clause1Context) IsInto_clause1Context() {} + +func NewInto_clause1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Into_clause1Context { + var p = new(Into_clause1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_into_clause1 + + return p +} + +func (s *Into_clause1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clause1Context) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Into_clause1Context) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Into_clause1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Into_clause1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Into_clause1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInto_clause1(s) + } +} + +func (s *Into_clause1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInto_clause1(s) + } +} + +func (s *Into_clause1Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInto_clause1(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Into_clause1() (localctx IInto_clause1Context) { + localctx = NewInto_clause1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 680, PlSqlParserRULE_into_clause1) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7480) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(7481) + p.Tableview_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 +} + +// IPartition_key_valueContext is an interface to support dynamic dispatch. +type IPartition_key_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Literal() ILiteralContext + TIMESTAMP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsPartition_key_valueContext differentiates from other interfaces. + IsPartition_key_valueContext() +} + +type Partition_key_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_key_valueContext() *Partition_key_valueContext { + var p = new(Partition_key_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_key_value + return p +} + +func InitEmptyPartition_key_valueContext(p *Partition_key_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_key_value +} + +func (*Partition_key_valueContext) IsPartition_key_valueContext() {} + +func NewPartition_key_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_key_valueContext { + var p = new(Partition_key_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_key_value + + return p +} + +func (s *Partition_key_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_key_valueContext) 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 *Partition_key_valueContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Partition_key_valueContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Partition_key_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_key_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_key_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_key_value(s) + } +} + +func (s *Partition_key_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_key_value(s) + } +} + +func (s *Partition_key_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_key_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_key_value() (localctx IPartition_key_valueContext) { + localctx = NewPartition_key_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 682, PlSqlParserRULE_partition_key_value) + p.SetState(7487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7484) + p.Literal() + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7485) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7486) + p.Quoted_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 +} + +// ISubpartition_key_valueContext is an interface to support dynamic dispatch. +type ISubpartition_key_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Literal() ILiteralContext + TIMESTAMP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsSubpartition_key_valueContext differentiates from other interfaces. + IsSubpartition_key_valueContext() +} + +type Subpartition_key_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_key_valueContext() *Subpartition_key_valueContext { + var p = new(Subpartition_key_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_key_value + return p +} + +func InitEmptySubpartition_key_valueContext(p *Subpartition_key_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_key_value +} + +func (*Subpartition_key_valueContext) IsSubpartition_key_valueContext() {} + +func NewSubpartition_key_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_key_valueContext { + var p = new(Subpartition_key_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_key_value + + return p +} + +func (s *Subpartition_key_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_key_valueContext) 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 *Subpartition_key_valueContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Subpartition_key_valueContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Subpartition_key_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_key_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_key_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_key_value(s) + } +} + +func (s *Subpartition_key_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_key_value(s) + } +} + +func (s *Subpartition_key_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_key_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_key_value() (localctx ISubpartition_key_valueContext) { + localctx = NewSubpartition_key_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 684, PlSqlParserRULE_subpartition_key_value) + p.SetState(7492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7489) + p.Literal() + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7490) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7491) + p.Quoted_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 +} + +// IAssociate_statisticsContext is an interface to support dynamic dispatch. +type IAssociate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + WITH() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Column_association() IColumn_associationContext + Function_association() IFunction_associationContext + Storage_table_clause() IStorage_table_clauseContext + + // IsAssociate_statisticsContext differentiates from other interfaces. + IsAssociate_statisticsContext() +} + +type Associate_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssociate_statisticsContext() *Associate_statisticsContext { + var p = new(Associate_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_associate_statistics + return p +} + +func InitEmptyAssociate_statisticsContext(p *Associate_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_associate_statistics +} + +func (*Associate_statisticsContext) IsAssociate_statisticsContext() {} + +func NewAssociate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Associate_statisticsContext { + var p = new(Associate_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_associate_statistics + + return p +} + +func (s *Associate_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Associate_statisticsContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Associate_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Associate_statisticsContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Associate_statisticsContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Associate_statisticsContext) Column_association() IColumn_associationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_associationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_associationContext) +} + +func (s *Associate_statisticsContext) Function_association() IFunction_associationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_associationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_associationContext) +} + +func (s *Associate_statisticsContext) Storage_table_clause() IStorage_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_table_clauseContext) +} + +func (s *Associate_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Associate_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Associate_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAssociate_statistics(s) + } +} + +func (s *Associate_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAssociate_statistics(s) + } +} + +func (s *Associate_statisticsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAssociate_statistics(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Associate_statistics() (localctx IAssociate_statisticsContext) { + localctx = NewAssociate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 686, PlSqlParserRULE_associate_statistics) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7494) + p.Match(PlSqlParserASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7495) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7496) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS: + { + p.SetState(7497) + p.Column_association() + } + + case PlSqlParserFUNCTIONS, PlSqlParserINDEXES, PlSqlParserINDEXTYPES, PlSqlParserPACKAGES, PlSqlParserTYPES: + { + p.SetState(7498) + p.Function_association() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(7502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(7501) + p.Storage_table_clause() + } + + } + { + p.SetState(7504) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IColumn_associationContext is an interface to support dynamic dispatch. +type IColumn_associationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + Using_statistics_type() IUsing_statistics_typeContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_associationContext differentiates from other interfaces. + IsColumn_associationContext() +} + +type Column_associationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_associationContext() *Column_associationContext { + var p = new(Column_associationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_association + return p +} + +func InitEmptyColumn_associationContext(p *Column_associationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_association +} + +func (*Column_associationContext) IsColumn_associationContext() {} + +func NewColumn_associationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_associationContext { + var p = new(Column_associationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_association + + return p +} + +func (s *Column_associationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_associationContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Column_associationContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Column_associationContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Column_associationContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Column_associationContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Column_associationContext) 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_associationContext) 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_associationContext) Using_statistics_type() IUsing_statistics_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_statistics_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_statistics_typeContext) +} + +func (s *Column_associationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_associationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_associationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_associationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_associationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_association(s) + } +} + +func (s *Column_associationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_association(s) + } +} + +func (s *Column_associationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_association(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_association() (localctx IColumn_associationContext) { + localctx = NewColumn_associationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 688, PlSqlParserRULE_column_association) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7506) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7507) + p.Tableview_name() + } + { + p.SetState(7508) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7509) + p.Column_name() + } + p.SetState(7517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7510) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7511) + p.Tableview_name() + } + { + p.SetState(7512) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7513) + p.Column_name() + } + + p.SetState(7519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(7520) + p.Using_statistics_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_associationContext is an interface to support dynamic dispatch. +type IFunction_associationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FUNCTIONS() antlr.TerminalNode + AllFunction_name() []IFunction_nameContext + Function_name(i int) IFunction_nameContext + PACKAGES() antlr.TerminalNode + AllPackage_name() []IPackage_nameContext + Package_name(i int) IPackage_nameContext + TYPES() antlr.TerminalNode + AllType_name() []IType_nameContext + Type_name(i int) IType_nameContext + INDEXES() antlr.TerminalNode + AllIndex_name() []IIndex_nameContext + Index_name(i int) IIndex_nameContext + INDEXTYPES() antlr.TerminalNode + AllIndextype_name() []IIndextype_nameContext + Indextype_name(i int) IIndextype_nameContext + Using_statistics_type() IUsing_statistics_typeContext + Default_cost_clause() IDefault_cost_clauseContext + Default_selectivity_clause() IDefault_selectivity_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_associationContext differentiates from other interfaces. + IsFunction_associationContext() +} + +type Function_associationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_associationContext() *Function_associationContext { + var p = new(Function_associationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_association + return p +} + +func InitEmptyFunction_associationContext(p *Function_associationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_association +} + +func (*Function_associationContext) IsFunction_associationContext() {} + +func NewFunction_associationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_associationContext { + var p = new(Function_associationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_association + + return p +} + +func (s *Function_associationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_associationContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Function_associationContext) AllFunction_name() []IFunction_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFunction_nameContext); ok { + len++ + } + } + + tst := make([]IFunction_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFunction_nameContext); ok { + tst[i] = t.(IFunction_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Function_name(i int) IFunction_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Function_associationContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Function_associationContext) AllPackage_name() []IPackage_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPackage_nameContext); ok { + len++ + } + } + + tst := make([]IPackage_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPackage_nameContext); ok { + tst[i] = t.(IPackage_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Package_name(i int) IPackage_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Function_associationContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Function_associationContext) AllType_name() []IType_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_nameContext); ok { + len++ + } + } + + tst := make([]IType_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_nameContext); ok { + tst[i] = t.(IType_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Type_name(i int) IType_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Function_associationContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Function_associationContext) AllIndex_name() []IIndex_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndex_nameContext); ok { + len++ + } + } + + tst := make([]IIndex_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndex_nameContext); ok { + tst[i] = t.(IIndex_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Index_name(i int) IIndex_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Function_associationContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Function_associationContext) AllIndextype_name() []IIndextype_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndextype_nameContext); ok { + len++ + } + } + + tst := make([]IIndextype_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndextype_nameContext); ok { + tst[i] = t.(IIndextype_nameContext) + i++ + } + } + + return tst +} + +func (s *Function_associationContext) Indextype_name(i int) IIndextype_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndextype_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndextype_nameContext) +} + +func (s *Function_associationContext) Using_statistics_type() IUsing_statistics_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_statistics_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_statistics_typeContext) +} + +func (s *Function_associationContext) Default_cost_clause() IDefault_cost_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_cost_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_cost_clauseContext) +} + +func (s *Function_associationContext) Default_selectivity_clause() IDefault_selectivity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_selectivity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_selectivity_clauseContext) +} + +func (s *Function_associationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_associationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_associationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_associationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_associationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_association(s) + } +} + +func (s *Function_associationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_association(s) + } +} + +func (s *Function_associationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_association(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_association() (localctx IFunction_associationContext) { + localctx = NewFunction_associationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 690, PlSqlParserRULE_function_association) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFUNCTIONS: + { + p.SetState(7522) + p.Match(PlSqlParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7523) + p.Function_name() + } + p.SetState(7528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7524) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7525) + p.Function_name() + } + + p.SetState(7530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserPACKAGES: + { + p.SetState(7531) + p.Match(PlSqlParserPACKAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7532) + p.Package_name() + } + p.SetState(7537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7533) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7534) + p.Package_name() + } + + p.SetState(7539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTYPES: + { + p.SetState(7540) + p.Match(PlSqlParserTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7541) + p.Type_name() + } + p.SetState(7546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7542) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7543) + p.Type_name() + } + + p.SetState(7548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXES: + { + p.SetState(7549) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7550) + p.Index_name() + } + p.SetState(7555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7551) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7552) + p.Index_name() + } + + p.SetState(7557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserINDEXTYPES: + { + p.SetState(7558) + p.Match(PlSqlParserINDEXTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7559) + p.Indextype_name() + } + p.SetState(7564) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7560) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7561) + p.Indextype_name() + } + + p.SetState(7566) + 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(7580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 775, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7569) + p.Using_statistics_type() + } + + case 2: + { + p.SetState(7570) + p.Default_cost_clause() + } + p.SetState(7573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(7571) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7572) + p.Default_selectivity_clause() + } + + } + + case 3: + { + p.SetState(7575) + p.Default_selectivity_clause() + } + p.SetState(7578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(7576) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7577) + p.Default_cost_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 +} + +// IIndextype_nameContext is an interface to support dynamic dispatch. +type IIndextype_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsIndextype_nameContext differentiates from other interfaces. + IsIndextype_nameContext() +} + +type Indextype_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndextype_nameContext() *Indextype_nameContext { + var p = new(Indextype_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype_name + return p +} + +func InitEmptyIndextype_nameContext(p *Indextype_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indextype_name +} + +func (*Indextype_nameContext) IsIndextype_nameContext() {} + +func NewIndextype_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indextype_nameContext { + var p = new(Indextype_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indextype_name + + return p +} + +func (s *Indextype_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Indextype_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Indextype_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Indextype_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Indextype_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndextype_name(s) + } +} + +func (s *Indextype_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndextype_name(s) + } +} + +func (s *Indextype_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndextype_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Indextype_name() (localctx IIndextype_nameContext) { + localctx = NewIndextype_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 692, PlSqlParserRULE_indextype_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7582) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUsing_statistics_typeContext is an interface to support dynamic dispatch. +type IUsing_statistics_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Statistics_type_name() IStatistics_type_nameContext + NULL_() antlr.TerminalNode + + // IsUsing_statistics_typeContext differentiates from other interfaces. + IsUsing_statistics_typeContext() +} + +type Using_statistics_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_statistics_typeContext() *Using_statistics_typeContext { + var p = new(Using_statistics_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_statistics_type + return p +} + +func InitEmptyUsing_statistics_typeContext(p *Using_statistics_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_statistics_type +} + +func (*Using_statistics_typeContext) IsUsing_statistics_typeContext() {} + +func NewUsing_statistics_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_statistics_typeContext { + var p = new(Using_statistics_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_statistics_type + + return p +} + +func (s *Using_statistics_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_statistics_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_statistics_typeContext) Statistics_type_name() IStatistics_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatistics_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatistics_type_nameContext) +} + +func (s *Using_statistics_typeContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Using_statistics_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_statistics_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_statistics_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_statistics_type(s) + } +} + +func (s *Using_statistics_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_statistics_type(s) + } +} + +func (s *Using_statistics_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_statistics_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_statistics_type() (localctx IUsing_statistics_typeContext) { + localctx = NewUsing_statistics_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 694, PlSqlParserRULE_using_statistics_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7584) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + { + p.SetState(7585) + p.Statistics_type_name() + } + + case PlSqlParserNULL_: + { + p.SetState(7586) + p.Match(PlSqlParserNULL_) + 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 +} + +// IStatistics_type_nameContext is an interface to support dynamic dispatch. +type IStatistics_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsStatistics_type_nameContext differentiates from other interfaces. + IsStatistics_type_nameContext() +} + +type Statistics_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatistics_type_nameContext() *Statistics_type_nameContext { + var p = new(Statistics_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statistics_type_name + return p +} + +func InitEmptyStatistics_type_nameContext(p *Statistics_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statistics_type_name +} + +func (*Statistics_type_nameContext) IsStatistics_type_nameContext() {} + +func NewStatistics_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Statistics_type_nameContext { + var p = new(Statistics_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statistics_type_name + + return p +} + +func (s *Statistics_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Statistics_type_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Statistics_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Statistics_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Statistics_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatistics_type_name(s) + } +} + +func (s *Statistics_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatistics_type_name(s) + } +} + +func (s *Statistics_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStatistics_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Statistics_type_name() (localctx IStatistics_type_nameContext) { + localctx = NewStatistics_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 696, PlSqlParserRULE_statistics_type_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7589) + p.Regular_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 +} + +// IDefault_cost_clauseContext is an interface to support dynamic dispatch. +type IDefault_cost_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + COST() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Cpu_cost() ICpu_costContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Io_cost() IIo_costContext + Network_cost() INetwork_costContext + RIGHT_PAREN() antlr.TerminalNode + + // IsDefault_cost_clauseContext differentiates from other interfaces. + IsDefault_cost_clauseContext() +} + +type Default_cost_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_cost_clauseContext() *Default_cost_clauseContext { + var p = new(Default_cost_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_cost_clause + return p +} + +func InitEmptyDefault_cost_clauseContext(p *Default_cost_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_cost_clause +} + +func (*Default_cost_clauseContext) IsDefault_cost_clauseContext() {} + +func NewDefault_cost_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_cost_clauseContext { + var p = new(Default_cost_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_cost_clause + + return p +} + +func (s *Default_cost_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_cost_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_cost_clauseContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Default_cost_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Default_cost_clauseContext) Cpu_cost() ICpu_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICpu_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICpu_costContext) +} + +func (s *Default_cost_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Default_cost_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Default_cost_clauseContext) Io_cost() IIo_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIo_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIo_costContext) +} + +func (s *Default_cost_clauseContext) Network_cost() INetwork_costContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INetwork_costContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INetwork_costContext) +} + +func (s *Default_cost_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Default_cost_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_cost_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_cost_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_cost_clause(s) + } +} + +func (s *Default_cost_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_cost_clause(s) + } +} + +func (s *Default_cost_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_cost_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_cost_clause() (localctx IDefault_cost_clauseContext) { + localctx = NewDefault_cost_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 698, PlSqlParserRULE_default_cost_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7591) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7592) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7593) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7594) + p.Cpu_cost() + } + { + p.SetState(7595) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7596) + p.Io_cost() + } + { + p.SetState(7597) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7598) + p.Network_cost() + } + { + p.SetState(7599) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICpu_costContext is an interface to support dynamic dispatch. +type ICpu_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsCpu_costContext differentiates from other interfaces. + IsCpu_costContext() +} + +type Cpu_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCpu_costContext() *Cpu_costContext { + var p = new(Cpu_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cpu_cost + return p +} + +func InitEmptyCpu_costContext(p *Cpu_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cpu_cost +} + +func (*Cpu_costContext) IsCpu_costContext() {} + +func NewCpu_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cpu_costContext { + var p = new(Cpu_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cpu_cost + + return p +} + +func (s *Cpu_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cpu_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Cpu_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cpu_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cpu_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCpu_cost(s) + } +} + +func (s *Cpu_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCpu_cost(s) + } +} + +func (s *Cpu_costContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCpu_cost(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cpu_cost() (localctx ICpu_costContext) { + localctx = NewCpu_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 700, PlSqlParserRULE_cpu_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7601) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IIo_costContext is an interface to support dynamic dispatch. +type IIo_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsIo_costContext differentiates from other interfaces. + IsIo_costContext() +} + +type Io_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIo_costContext() *Io_costContext { + var p = new(Io_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_io_cost + return p +} + +func InitEmptyIo_costContext(p *Io_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_io_cost +} + +func (*Io_costContext) IsIo_costContext() {} + +func NewIo_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Io_costContext { + var p = new(Io_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_io_cost + + return p +} + +func (s *Io_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Io_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Io_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Io_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Io_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIo_cost(s) + } +} + +func (s *Io_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIo_cost(s) + } +} + +func (s *Io_costContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIo_cost(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Io_cost() (localctx IIo_costContext) { + localctx = NewIo_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 702, PlSqlParserRULE_io_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7603) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// INetwork_costContext is an interface to support dynamic dispatch. +type INetwork_costContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsNetwork_costContext differentiates from other interfaces. + IsNetwork_costContext() +} + +type Network_costContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNetwork_costContext() *Network_costContext { + var p = new(Network_costContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_network_cost + return p +} + +func InitEmptyNetwork_costContext(p *Network_costContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_network_cost +} + +func (*Network_costContext) IsNetwork_costContext() {} + +func NewNetwork_costContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Network_costContext { + var p = new(Network_costContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_network_cost + + return p +} + +func (s *Network_costContext) GetParser() antlr.Parser { return s.parser } + +func (s *Network_costContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Network_costContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Network_costContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Network_costContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNetwork_cost(s) + } +} + +func (s *Network_costContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNetwork_cost(s) + } +} + +func (s *Network_costContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNetwork_cost(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Network_cost() (localctx INetwork_costContext) { + localctx = NewNetwork_costContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 704, PlSqlParserRULE_network_cost) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7605) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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_selectivity_clauseContext is an interface to support dynamic dispatch. +type IDefault_selectivity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + SELECTIVITY() antlr.TerminalNode + Default_selectivity() IDefault_selectivityContext + + // IsDefault_selectivity_clauseContext differentiates from other interfaces. + IsDefault_selectivity_clauseContext() +} + +type Default_selectivity_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_selectivity_clauseContext() *Default_selectivity_clauseContext { + var p = new(Default_selectivity_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause + return p +} + +func InitEmptyDefault_selectivity_clauseContext(p *Default_selectivity_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause +} + +func (*Default_selectivity_clauseContext) IsDefault_selectivity_clauseContext() {} + +func NewDefault_selectivity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_selectivity_clauseContext { + var p = new(Default_selectivity_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_selectivity_clause + + return p +} + +func (s *Default_selectivity_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_selectivity_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_selectivity_clauseContext) SELECTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECTIVITY, 0) +} + +func (s *Default_selectivity_clauseContext) Default_selectivity() IDefault_selectivityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_selectivityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_selectivityContext) +} + +func (s *Default_selectivity_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_selectivity_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_selectivity_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_selectivity_clause(s) + } +} + +func (s *Default_selectivity_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_selectivity_clause(s) + } +} + +func (s *Default_selectivity_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_selectivity_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_selectivity_clause() (localctx IDefault_selectivity_clauseContext) { + localctx = NewDefault_selectivity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 706, PlSqlParserRULE_default_selectivity_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7607) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7608) + p.Match(PlSqlParserSELECTIVITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7609) + p.Default_selectivity() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_selectivityContext is an interface to support dynamic dispatch. +type IDefault_selectivityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsDefault_selectivityContext differentiates from other interfaces. + IsDefault_selectivityContext() +} + +type Default_selectivityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_selectivityContext() *Default_selectivityContext { + var p = new(Default_selectivityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity + return p +} + +func InitEmptyDefault_selectivityContext(p *Default_selectivityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_selectivity +} + +func (*Default_selectivityContext) IsDefault_selectivityContext() {} + +func NewDefault_selectivityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_selectivityContext { + var p = new(Default_selectivityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_selectivity + + return p +} + +func (s *Default_selectivityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_selectivityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Default_selectivityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_selectivityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_selectivityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_selectivity(s) + } +} + +func (s *Default_selectivityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_selectivity(s) + } +} + +func (s *Default_selectivityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_selectivity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_selectivity() (localctx IDefault_selectivityContext) { + localctx = NewDefault_selectivityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 708, PlSqlParserRULE_default_selectivity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7611) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IStorage_table_clauseContext is an interface to support dynamic dispatch. +type IStorage_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + MANAGED() antlr.TerminalNode + STORAGE() antlr.TerminalNode + TABLES() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + USER() antlr.TerminalNode + + // IsStorage_table_clauseContext differentiates from other interfaces. + IsStorage_table_clauseContext() +} + +type Storage_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStorage_table_clauseContext() *Storage_table_clauseContext { + var p = new(Storage_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_table_clause + return p +} + +func InitEmptyStorage_table_clauseContext(p *Storage_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_table_clause +} + +func (*Storage_table_clauseContext) IsStorage_table_clauseContext() {} + +func NewStorage_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Storage_table_clauseContext { + var p = new(Storage_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_storage_table_clause + + return p +} + +func (s *Storage_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Storage_table_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Storage_table_clauseContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Storage_table_clauseContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Storage_table_clauseContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Storage_table_clauseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Storage_table_clauseContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Storage_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Storage_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Storage_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStorage_table_clause(s) + } +} + +func (s *Storage_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStorage_table_clause(s) + } +} + +func (s *Storage_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStorage_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Storage_table_clause() (localctx IStorage_table_clauseContext) { + localctx = NewStorage_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 710, PlSqlParserRULE_storage_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7613) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7614) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSYSTEM || _la == PlSqlParserUSER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7615) + p.Match(PlSqlParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7616) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7617) + p.Match(PlSqlParserTABLES) + 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 +} + +// IUnified_auditingContext is an interface to support dynamic dispatch. +type IUnified_auditingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUDIT() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + POLICY() antlr.TerminalNode + Policy_name() IPolicy_nameContext + CONTEXT() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + Oracle_namespace() IOracle_namespaceContext + ATTRIBUTES() antlr.TerminalNode + AllAttribute_name() []IAttribute_nameContext + Attribute_name(i int) IAttribute_nameContext + AllAudit_user() []IAudit_userContext + Audit_user(i int) IAudit_userContext + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + BY() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUnified_auditingContext differentiates from other interfaces. + IsUnified_auditingContext() +} + +type Unified_auditingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnified_auditingContext() *Unified_auditingContext { + var p = new(Unified_auditingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unified_auditing + return p +} + +func InitEmptyUnified_auditingContext(p *Unified_auditingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unified_auditing +} + +func (*Unified_auditingContext) IsUnified_auditingContext() {} + +func NewUnified_auditingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unified_auditingContext { + var p = new(Unified_auditingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unified_auditing + + return p +} + +func (s *Unified_auditingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unified_auditingContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Unified_auditingContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Unified_auditingContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Unified_auditingContext) Policy_name() IPolicy_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPolicy_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPolicy_nameContext) +} + +func (s *Unified_auditingContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Unified_auditingContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMESPACE, 0) +} + +func (s *Unified_auditingContext) Oracle_namespace() IOracle_namespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOracle_namespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOracle_namespaceContext) +} + +func (s *Unified_auditingContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Unified_auditingContext) AllAttribute_name() []IAttribute_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_nameContext); ok { + len++ + } + } + + tst := make([]IAttribute_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_nameContext); ok { + tst[i] = t.(IAttribute_nameContext) + i++ + } + } + + return tst +} + +func (s *Unified_auditingContext) Attribute_name(i int) IAttribute_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Unified_auditingContext) AllAudit_user() []IAudit_userContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_userContext); ok { + len++ + } + } + + tst := make([]IAudit_userContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_userContext); ok { + tst[i] = t.(IAudit_userContext) + i++ + } + } + + return tst +} + +func (s *Unified_auditingContext) Audit_user(i int) IAudit_userContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_userContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_userContext) +} + +func (s *Unified_auditingContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Unified_auditingContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Unified_auditingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unified_auditingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unified_auditingContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Unified_auditingContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Unified_auditingContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Unified_auditingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unified_auditingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unified_auditingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnified_auditing(s) + } +} + +func (s *Unified_auditingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnified_auditing(s) + } +} + +func (s *Unified_auditingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnified_auditing(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unified_auditing() (localctx IUnified_auditingContext) { + localctx = NewUnified_auditingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 712, PlSqlParserRULE_unified_auditing) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7619) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7620) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPOLICY: + { + p.SetState(7621) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7622) + p.Policy_name() + } + p.SetState(7632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY || _la == PlSqlParserEXCEPT { + { + p.SetState(7623) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBY || _la == PlSqlParserEXCEPT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(7624) + p.Audit_user() + } + p.SetState(7629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7625) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7626) + p.Audit_user() + } + + p.SetState(7631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(7639) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWHENEVER { + { + p.SetState(7634) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7636) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(7635) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7638) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCONTEXT: + { + p.SetState(7641) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7642) + p.Match(PlSqlParserNAMESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7643) + p.Oracle_namespace() + } + { + p.SetState(7644) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7645) + p.Attribute_name() + } + p.SetState(7650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7646) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7647) + p.Attribute_name() + } + + p.SetState(7652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(7662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(7653) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7654) + p.Audit_user() + } + p.SetState(7659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7655) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7656) + p.Audit_user() + } + + p.SetState(7661) + 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(7666) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPolicy_nameContext is an interface to support dynamic dispatch. +type IPolicy_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsPolicy_nameContext differentiates from other interfaces. + IsPolicy_nameContext() +} + +type Policy_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPolicy_nameContext() *Policy_nameContext { + var p = new(Policy_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_policy_name + return p +} + +func InitEmptyPolicy_nameContext(p *Policy_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_policy_name +} + +func (*Policy_nameContext) IsPolicy_nameContext() {} + +func NewPolicy_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Policy_nameContext { + var p = new(Policy_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_policy_name + + return p +} + +func (s *Policy_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Policy_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Policy_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Policy_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Policy_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPolicy_name(s) + } +} + +func (s *Policy_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPolicy_name(s) + } +} + +func (s *Policy_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPolicy_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Policy_name() (localctx IPolicy_nameContext) { + localctx = NewPolicy_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 714, PlSqlParserRULE_policy_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7668) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAudit_traditionalContext is an interface to support dynamic dispatch. +type IAudit_traditionalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUDIT() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Audit_operation_clause() IAudit_operation_clauseContext + Audit_schema_object_clause() IAudit_schema_object_clauseContext + NETWORK() antlr.TerminalNode + Audit_direct_path() IAudit_direct_pathContext + BY() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + Audit_container_clause() IAudit_container_clauseContext + AllSESSION() []antlr.TerminalNode + SESSION(i int) antlr.TerminalNode + ACCESS() antlr.TerminalNode + Auditing_by_clause() IAuditing_by_clauseContext + IN() antlr.TerminalNode + CURRENT() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsAudit_traditionalContext differentiates from other interfaces. + IsAudit_traditionalContext() +} + +type Audit_traditionalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_traditionalContext() *Audit_traditionalContext { + var p = new(Audit_traditionalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_traditional + return p +} + +func InitEmptyAudit_traditionalContext(p *Audit_traditionalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_traditional +} + +func (*Audit_traditionalContext) IsAudit_traditionalContext() {} + +func NewAudit_traditionalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_traditionalContext { + var p = new(Audit_traditionalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_traditional + + return p +} + +func (s *Audit_traditionalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_traditionalContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Audit_traditionalContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Audit_traditionalContext) Audit_operation_clause() IAudit_operation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_operation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_operation_clauseContext) +} + +func (s *Audit_traditionalContext) Audit_schema_object_clause() IAudit_schema_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_schema_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_schema_object_clauseContext) +} + +func (s *Audit_traditionalContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Audit_traditionalContext) Audit_direct_path() IAudit_direct_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_direct_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_direct_pathContext) +} + +func (s *Audit_traditionalContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Audit_traditionalContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Audit_traditionalContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Audit_traditionalContext) Audit_container_clause() IAudit_container_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_container_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_container_clauseContext) +} + +func (s *Audit_traditionalContext) AllSESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSESSION) +} + +func (s *Audit_traditionalContext) SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, i) +} + +func (s *Audit_traditionalContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Audit_traditionalContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Audit_traditionalContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Audit_traditionalContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Audit_traditionalContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Audit_traditionalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_traditionalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_traditionalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_traditional(s) + } +} + +func (s *Audit_traditionalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_traditional(s) + } +} + +func (s *Audit_traditionalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_traditional(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_traditional() (localctx IAudit_traditionalContext) { + localctx = NewAudit_traditionalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 716, PlSqlParserRULE_audit_traditional) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7670) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7681) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 786, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7671) + p.Audit_operation_clause() + } + p.SetState(7676) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 785, p.GetParserRuleContext()) == 1 { + { + p.SetState(7672) + p.Auditing_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 785, p.GetParserRuleContext()) == 2 { + { + p.SetState(7673) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7674) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7675) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(7678) + p.Audit_schema_object_clause() + } + + case 3: + { + p.SetState(7679) + p.Match(PlSqlParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(7680) + p.Audit_direct_path() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7685) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 787, p.GetParserRuleContext()) == 1 { + { + p.SetState(7683) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7684) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACCESS || _la == PlSqlParserSESSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7692) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 789, p.GetParserRuleContext()) == 1 { + { + p.SetState(7687) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(7688) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(7691) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(7695) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 790, p.GetParserRuleContext()) == 1 { + { + p.SetState(7694) + p.Audit_container_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7697) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IAudit_direct_pathContext is an interface to support dynamic dispatch. +type IAudit_direct_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIRECT_PATH() antlr.TerminalNode + Auditing_by_clause() IAuditing_by_clauseContext + + // IsAudit_direct_pathContext differentiates from other interfaces. + IsAudit_direct_pathContext() +} + +type Audit_direct_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_direct_pathContext() *Audit_direct_pathContext { + var p = new(Audit_direct_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_direct_path + return p +} + +func InitEmptyAudit_direct_pathContext(p *Audit_direct_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_direct_path +} + +func (*Audit_direct_pathContext) IsAudit_direct_pathContext() {} + +func NewAudit_direct_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_direct_pathContext { + var p = new(Audit_direct_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_direct_path + + return p +} + +func (s *Audit_direct_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_direct_pathContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Audit_direct_pathContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Audit_direct_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_direct_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_direct_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_direct_path(s) + } +} + +func (s *Audit_direct_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_direct_path(s) + } +} + +func (s *Audit_direct_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_direct_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_direct_path() (localctx IAudit_direct_pathContext) { + localctx = NewAudit_direct_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 718, PlSqlParserRULE_audit_direct_path) + p.EnterOuterAlt(localctx, 1) + p.SetState(7699) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7700) + p.Match(PlSqlParserDIRECT_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7701) + p.Auditing_by_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 +} + +// IAudit_container_clauseContext is an interface to support dynamic dispatch. +type IAudit_container_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsAudit_container_clauseContext differentiates from other interfaces. + IsAudit_container_clauseContext() +} + +type Audit_container_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_container_clauseContext() *Audit_container_clauseContext { + var p = new(Audit_container_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_container_clause + return p +} + +func InitEmptyAudit_container_clauseContext(p *Audit_container_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_container_clause +} + +func (*Audit_container_clauseContext) IsAudit_container_clauseContext() {} + +func NewAudit_container_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_container_clauseContext { + var p = new(Audit_container_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_container_clause + + return p +} + +func (s *Audit_container_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_container_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Audit_container_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Audit_container_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Audit_container_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Audit_container_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_container_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_container_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_container_clause(s) + } +} + +func (s *Audit_container_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_container_clause(s) + } +} + +func (s *Audit_container_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_container_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_container_clause() (localctx IAudit_container_clauseContext) { + localctx = NewAudit_container_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 720, PlSqlParserRULE_audit_container_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7703) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + + { + p.SetState(7704) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7705) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7706) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCURRENT) { + 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 +} + +// IAudit_operation_clauseContext is an interface to support dynamic dispatch. +type IAudit_operation_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSql_statement_shortcut() []ISql_statement_shortcutContext + Sql_statement_shortcut(i int) ISql_statement_shortcutContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllPRIVILEGES() []antlr.TerminalNode + PRIVILEGES(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSTATEMENTS() []antlr.TerminalNode + STATEMENTS(i int) antlr.TerminalNode + + // IsAudit_operation_clauseContext differentiates from other interfaces. + IsAudit_operation_clauseContext() +} + +type Audit_operation_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_operation_clauseContext() *Audit_operation_clauseContext { + var p = new(Audit_operation_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_operation_clause + return p +} + +func InitEmptyAudit_operation_clauseContext(p *Audit_operation_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_operation_clause +} + +func (*Audit_operation_clauseContext) IsAudit_operation_clauseContext() {} + +func NewAudit_operation_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_operation_clauseContext { + var p = new(Audit_operation_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_operation_clause + + return p +} + +func (s *Audit_operation_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_operation_clauseContext) AllSql_statement_shortcut() []ISql_statement_shortcutContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_statement_shortcutContext); ok { + len++ + } + } + + tst := make([]ISql_statement_shortcutContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_statement_shortcutContext); ok { + tst[i] = t.(ISql_statement_shortcutContext) + i++ + } + } + + return tst +} + +func (s *Audit_operation_clauseContext) Sql_statement_shortcut(i int) ISql_statement_shortcutContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statement_shortcutContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_statement_shortcutContext) +} + +func (s *Audit_operation_clauseContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Audit_operation_clauseContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Audit_operation_clauseContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Audit_operation_clauseContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Audit_operation_clauseContext) AllPRIVILEGES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVILEGES) +} + +func (s *Audit_operation_clauseContext) PRIVILEGES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, i) +} + +func (s *Audit_operation_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Audit_operation_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Audit_operation_clauseContext) AllSTATEMENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATEMENTS) +} + +func (s *Audit_operation_clauseContext) STATEMENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENTS, i) +} + +func (s *Audit_operation_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_operation_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_operation_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_operation_clause(s) + } +} + +func (s *Audit_operation_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_operation_clause(s) + } +} + +func (s *Audit_operation_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_operation_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_operation_clause() (localctx IAudit_operation_clauseContext) { + localctx = NewAudit_operation_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 722, PlSqlParserRULE_audit_operation_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 799, p.GetParserRuleContext()) { + case 1: + p.SetState(7713) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 792, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7708) + p.Sql_statement_shortcut() + } + + case 2: + { + p.SetState(7709) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7711) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 791, p.GetParserRuleContext()) == 1 { + { + p.SetState(7710) + p.Match(PlSqlParserSTATEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7725) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7715) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 794, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7716) + p.Sql_statement_shortcut() + } + + case 2: + { + p.SetState(7717) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7719) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 793, p.GetParserRuleContext()) == 1 { + { + p.SetState(7718) + p.Match(PlSqlParserSTATEMENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 795, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.SetState(7731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 796, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7728) + p.System_privilege() + } + + case 2: + { + p.SetState(7729) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7730) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(7741) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 798, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7733) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 797, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7734) + p.System_privilege() + } + + case 2: + { + p.SetState(7735) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7736) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(7743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 798, 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 +} + +// IAuditing_by_clauseContext is an interface to support dynamic dispatch. +type IAuditing_by_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + AllAudit_user() []IAudit_userContext + Audit_user(i int) IAudit_userContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAuditing_by_clauseContext differentiates from other interfaces. + IsAuditing_by_clauseContext() +} + +type Auditing_by_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuditing_by_clauseContext() *Auditing_by_clauseContext { + var p = new(Auditing_by_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_by_clause + return p +} + +func InitEmptyAuditing_by_clauseContext(p *Auditing_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_by_clause +} + +func (*Auditing_by_clauseContext) IsAuditing_by_clauseContext() {} + +func NewAuditing_by_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auditing_by_clauseContext { + var p = new(Auditing_by_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_auditing_by_clause + + return p +} + +func (s *Auditing_by_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auditing_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Auditing_by_clauseContext) AllAudit_user() []IAudit_userContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAudit_userContext); ok { + len++ + } + } + + tst := make([]IAudit_userContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAudit_userContext); ok { + tst[i] = t.(IAudit_userContext) + i++ + } + } + + return tst +} + +func (s *Auditing_by_clauseContext) Audit_user(i int) IAudit_userContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_userContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAudit_userContext) +} + +func (s *Auditing_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Auditing_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Auditing_by_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auditing_by_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auditing_by_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAuditing_by_clause(s) + } +} + +func (s *Auditing_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAuditing_by_clause(s) + } +} + +func (s *Auditing_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAuditing_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Auditing_by_clause() (localctx IAuditing_by_clauseContext) { + localctx = NewAuditing_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 724, PlSqlParserRULE_auditing_by_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7746) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7747) + p.Audit_user() + } + p.SetState(7752) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7748) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7749) + p.Audit_user() + } + + } + p.SetState(7754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 800, 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 +} + +// IAudit_userContext is an interface to support dynamic dispatch. +type IAudit_userContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsAudit_userContext differentiates from other interfaces. + IsAudit_userContext() +} + +type Audit_userContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_userContext() *Audit_userContext { + var p = new(Audit_userContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_user + return p +} + +func InitEmptyAudit_userContext(p *Audit_userContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_user +} + +func (*Audit_userContext) IsAudit_userContext() {} + +func NewAudit_userContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_userContext { + var p = new(Audit_userContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_user + + return p +} + +func (s *Audit_userContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_userContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Audit_userContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_userContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_userContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_user(s) + } +} + +func (s *Audit_userContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_user(s) + } +} + +func (s *Audit_userContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_user(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_user() (localctx IAudit_userContext) { + localctx = NewAudit_userContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 726, PlSqlParserRULE_audit_user) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7755) + p.Regular_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 +} + +// IAudit_schema_object_clauseContext is an interface to support dynamic dispatch. +type IAudit_schema_object_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Auditing_on_clause() IAuditing_on_clauseContext + AllSql_operation() []ISql_operationContext + Sql_operation(i int) ISql_operationContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAudit_schema_object_clauseContext differentiates from other interfaces. + IsAudit_schema_object_clauseContext() +} + +type Audit_schema_object_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAudit_schema_object_clauseContext() *Audit_schema_object_clauseContext { + var p = new(Audit_schema_object_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause + return p +} + +func InitEmptyAudit_schema_object_clauseContext(p *Audit_schema_object_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause +} + +func (*Audit_schema_object_clauseContext) IsAudit_schema_object_clauseContext() {} + +func NewAudit_schema_object_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Audit_schema_object_clauseContext { + var p = new(Audit_schema_object_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_audit_schema_object_clause + + return p +} + +func (s *Audit_schema_object_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Audit_schema_object_clauseContext) Auditing_on_clause() IAuditing_on_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_on_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_on_clauseContext) +} + +func (s *Audit_schema_object_clauseContext) AllSql_operation() []ISql_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISql_operationContext); ok { + len++ + } + } + + tst := make([]ISql_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISql_operationContext); ok { + tst[i] = t.(ISql_operationContext) + i++ + } + } + + return tst +} + +func (s *Audit_schema_object_clauseContext) Sql_operation(i int) ISql_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISql_operationContext) +} + +func (s *Audit_schema_object_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Audit_schema_object_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Audit_schema_object_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Audit_schema_object_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Audit_schema_object_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Audit_schema_object_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAudit_schema_object_clause(s) + } +} + +func (s *Audit_schema_object_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAudit_schema_object_clause(s) + } +} + +func (s *Audit_schema_object_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAudit_schema_object_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Audit_schema_object_clause() (localctx IAudit_schema_object_clauseContext) { + localctx = NewAudit_schema_object_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 728, PlSqlParserRULE_audit_schema_object_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(7766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALTER, PlSqlParserAUDIT, PlSqlParserCOMMENT, PlSqlParserDELETE, PlSqlParserEXECUTE, PlSqlParserFLASHBACK, PlSqlParserGRANT, PlSqlParserINDEX, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserREAD, PlSqlParserRENAME, PlSqlParserSELECT, PlSqlParserUPDATE: + { + p.SetState(7757) + p.Sql_operation() + } + p.SetState(7762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(7758) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7759) + p.Sql_operation() + } + + p.SetState(7764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(7765) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(7768) + p.Auditing_on_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 +} + +// ISql_operationContext is an interface to support dynamic dispatch. +type ISql_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + GRANT() antlr.TerminalNode + INDEX() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + READ() antlr.TerminalNode + RENAME() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsSql_operationContext differentiates from other interfaces. + IsSql_operationContext() +} + +type Sql_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_operationContext() *Sql_operationContext { + var p = new(Sql_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_operation + return p +} + +func InitEmptySql_operationContext(p *Sql_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_operation +} + +func (*Sql_operationContext) IsSql_operationContext() {} + +func NewSql_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_operationContext { + var p = new(Sql_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_operation + + return p +} + +func (s *Sql_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_operationContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Sql_operationContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Sql_operationContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Sql_operationContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Sql_operationContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Sql_operationContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Sql_operationContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Sql_operationContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Sql_operationContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Sql_operationContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Sql_operationContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Sql_operationContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Sql_operationContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Sql_operationContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Sql_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_operation(s) + } +} + +func (s *Sql_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_operation(s) + } +} + +func (s *Sql_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_operation() (localctx ISql_operationContext) { + localctx = NewSql_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 730, PlSqlParserRULE_sql_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7770) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserAUDIT || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserEXECUTE || _la == PlSqlParserFLASHBACK || _la == PlSqlParserGRANT || _la == PlSqlParserINDEX || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserRENAME || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + 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 +} + +// IAuditing_on_clauseContext is an interface to support dynamic dispatch. +type IAuditing_on_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Object_name() IObject_nameContext + DIRECTORY() antlr.TerminalNode + Regular_id() IRegular_idContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + Model_name() IModel_nameContext + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Profile_name() IProfile_nameContext + DEFAULT() antlr.TerminalNode + + // IsAuditing_on_clauseContext differentiates from other interfaces. + IsAuditing_on_clauseContext() +} + +type Auditing_on_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAuditing_on_clauseContext() *Auditing_on_clauseContext { + var p = new(Auditing_on_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_on_clause + return p +} + +func InitEmptyAuditing_on_clauseContext(p *Auditing_on_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_auditing_on_clause +} + +func (*Auditing_on_clauseContext) IsAuditing_on_clauseContext() {} + +func NewAuditing_on_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Auditing_on_clauseContext { + var p = new(Auditing_on_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_auditing_on_clause + + return p +} + +func (s *Auditing_on_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Auditing_on_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Auditing_on_clauseContext) 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 *Auditing_on_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Auditing_on_clauseContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Auditing_on_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Auditing_on_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Auditing_on_clauseContext) Model_name() IModel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_nameContext) +} + +func (s *Auditing_on_clauseContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Auditing_on_clauseContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Auditing_on_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Auditing_on_clauseContext) Profile_name() IProfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProfile_nameContext) +} + +func (s *Auditing_on_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Auditing_on_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Auditing_on_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Auditing_on_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAuditing_on_clause(s) + } +} + +func (s *Auditing_on_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAuditing_on_clause(s) + } +} + +func (s *Auditing_on_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAuditing_on_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Auditing_on_clause() (localctx IAuditing_on_clauseContext) { + localctx = NewAuditing_on_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 732, PlSqlParserRULE_auditing_on_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7772) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 803, p.GetParserRuleContext()) { + case 1: + { + p.SetState(7773) + p.Object_name() + } + + case 2: + { + p.SetState(7774) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7775) + p.Regular_id() + } + + case 3: + { + p.SetState(7776) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7777) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7778) + p.Model_name() + } + + case 4: + p.SetState(7779) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7780) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7781) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7782) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7783) + p.Profile_name() + } + + case 5: + { + p.SetState(7784) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// IModel_nameContext is an interface to support dynamic dispatch. +type IModel_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsModel_nameContext differentiates from other interfaces. + IsModel_nameContext() +} + +type Model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_nameContext() *Model_nameContext { + var p = new(Model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_name + return p +} + +func InitEmptyModel_nameContext(p *Model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_name +} + +func (*Model_nameContext) IsModel_nameContext() {} + +func NewModel_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_nameContext { + var p = new(Model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_name + + return p +} + +func (s *Model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Model_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Model_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_name(s) + } +} + +func (s *Model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_name(s) + } +} + +func (s *Model_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_name() (localctx IModel_nameContext) { + localctx = NewModel_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 734, PlSqlParserRULE_model_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 804, p.GetParserRuleContext()) == 1 { + { + p.SetState(7787) + p.Id_expression() + } + { + p.SetState(7788) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7792) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_nameContext is an interface to support dynamic dispatch. +type IObject_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsObject_nameContext differentiates from other interfaces. + IsObject_nameContext() +} + +type Object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_nameContext() *Object_nameContext { + var p = new(Object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_name + return p +} + +func InitEmptyObject_nameContext(p *Object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_object_name + + return p +} + +func (s *Object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Object_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Object_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterObject_name(s) + } +} + +func (s *Object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_name(s) + } +} + +func (s *Object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_name() (localctx IObject_nameContext) { + localctx = NewObject_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 736, PlSqlParserRULE_object_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7797) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 805, p.GetParserRuleContext()) == 1 { + { + p.SetState(7794) + p.Id_expression() + } + { + p.SetState(7795) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7799) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IProfile_nameContext is an interface to support dynamic dispatch. +type IProfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsProfile_nameContext differentiates from other interfaces. + IsProfile_nameContext() +} + +type Profile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProfile_nameContext() *Profile_nameContext { + var p = new(Profile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_name + return p +} + +func InitEmptyProfile_nameContext(p *Profile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_profile_name +} + +func (*Profile_nameContext) IsProfile_nameContext() {} + +func NewProfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Profile_nameContext { + var p = new(Profile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_profile_name + + return p +} + +func (s *Profile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Profile_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Profile_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Profile_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Profile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Profile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Profile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProfile_name(s) + } +} + +func (s *Profile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProfile_name(s) + } +} + +func (s *Profile_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProfile_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Profile_name() (localctx IProfile_nameContext) { + localctx = NewProfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 738, PlSqlParserRULE_profile_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(7804) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 806, p.GetParserRuleContext()) == 1 { + { + p.SetState(7801) + p.Id_expression() + } + { + p.SetState(7802) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7806) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_statement_shortcutContext is an interface to support dynamic dispatch. +type ISql_statement_shortcutContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + INDEX() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + NOT() antlr.TerminalNode + EXISTS() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SESSION() antlr.TerminalNode + AUDIT() antlr.TerminalNode + GRANT() antlr.TerminalNode + TABLE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TYPE() antlr.TerminalNode + USER() antlr.TerminalNode + COMMENT() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCK() antlr.TerminalNode + SELECT() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsSql_statement_shortcutContext differentiates from other interfaces. + IsSql_statement_shortcutContext() +} + +type Sql_statement_shortcutContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_statement_shortcutContext() *Sql_statement_shortcutContext { + var p = new(Sql_statement_shortcutContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut + return p +} + +func InitEmptySql_statement_shortcutContext(p *Sql_statement_shortcutContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut +} + +func (*Sql_statement_shortcutContext) IsSql_statement_shortcutContext() {} + +func NewSql_statement_shortcutContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_statement_shortcutContext { + var p = new(Sql_statement_shortcutContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_statement_shortcut + + return p +} + +func (s *Sql_statement_shortcutContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_statement_shortcutContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Sql_statement_shortcutContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Sql_statement_shortcutContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Sql_statement_shortcutContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Sql_statement_shortcutContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Sql_statement_shortcutContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Sql_statement_shortcutContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Sql_statement_shortcutContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Sql_statement_shortcutContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Sql_statement_shortcutContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Sql_statement_shortcutContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Sql_statement_shortcutContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Sql_statement_shortcutContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Sql_statement_shortcutContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Sql_statement_shortcutContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Sql_statement_shortcutContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Sql_statement_shortcutContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Sql_statement_shortcutContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Sql_statement_shortcutContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Sql_statement_shortcutContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Sql_statement_shortcutContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Sql_statement_shortcutContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Sql_statement_shortcutContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Sql_statement_shortcutContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Sql_statement_shortcutContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Sql_statement_shortcutContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *Sql_statement_shortcutContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Sql_statement_shortcutContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Sql_statement_shortcutContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Sql_statement_shortcutContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Sql_statement_shortcutContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Sql_statement_shortcutContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Sql_statement_shortcutContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Sql_statement_shortcutContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Sql_statement_shortcutContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Sql_statement_shortcutContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Sql_statement_shortcutContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Sql_statement_shortcutContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Sql_statement_shortcutContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_statement_shortcutContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_statement_shortcutContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_statement_shortcut(s) + } +} + +func (s *Sql_statement_shortcutContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_statement_shortcut(s) + } +} + +func (s *Sql_statement_shortcutContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_statement_shortcut(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_statement_shortcut() (localctx ISql_statement_shortcutContext) { + localctx = NewSql_statement_shortcutContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 740, PlSqlParserRULE_sql_statement_shortcut) + p.SetState(7878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 807, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7808) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7809) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(7810) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(7811) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(7812) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7813) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(7814) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(7815) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(7816) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(7817) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7818) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(7819) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7820) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(7821) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + p.SetState(7822) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(7823) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7824) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(7825) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(7826) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(7827) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7828) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7829) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(7830) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7831) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(7832) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(7833) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7834) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(7835) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(7836) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(7837) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(7838) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7839) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(7840) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7841) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(7842) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(7843) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(7844) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(7845) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(7846) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(7847) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(7848) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7849) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(7850) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7851) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(7852) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7853) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(7854) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7855) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(7856) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7857) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(7858) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7859) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(7860) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7861) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(7862) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7863) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(7864) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7865) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(7866) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7867) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(7868) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7869) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(7870) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7871) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(7872) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7873) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(7874) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7875) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(7876) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7877) + p.Match(PlSqlParserTABLE) + 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 +} + +// IDrop_indexContext is an interface to support dynamic dispatch. +type IDrop_indexContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + SEMICOLON() antlr.TerminalNode + + // IsDrop_indexContext differentiates from other interfaces. + IsDrop_indexContext() +} + +type Drop_indexContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_indexContext() *Drop_indexContext { + var p = new(Drop_indexContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index + return p +} + +func InitEmptyDrop_indexContext(p *Drop_indexContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_index +} + +func (*Drop_indexContext) IsDrop_indexContext() {} + +func NewDrop_indexContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indexContext { + var p = new(Drop_indexContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_index + + return p +} + +func (s *Drop_indexContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_indexContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_indexContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Drop_indexContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Drop_indexContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_indexContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_indexContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_indexContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_index(s) + } +} + +func (s *Drop_indexContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_index(s) + } +} + +func (s *Drop_indexContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_index(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_index() (localctx IDrop_indexContext) { + localctx = NewDrop_indexContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 742, PlSqlParserRULE_drop_index) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7880) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7881) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7882) + p.Index_name() + } + { + p.SetState(7883) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDisassociate_statisticsContext is an interface to support dynamic dispatch. +type IDisassociate_statisticsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTb returns the tb rule contexts. + GetTb() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // GetFn returns the fn rule contexts. + GetFn() IId_expressionContext + + // GetPkg returns the pkg rule contexts. + GetPkg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetIx returns the ix rule contexts. + GetIx() IId_expressionContext + + // GetIt returns the it rule contexts. + GetIt() IId_expressionContext + + // SetTb sets the tb rule contexts. + SetTb(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // SetFn sets the fn rule contexts. + SetFn(IId_expressionContext) + + // SetPkg sets the pkg rule contexts. + SetPkg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetIx sets the ix rule contexts. + SetIx(IId_expressionContext) + + // SetIt sets the it rule contexts. + SetIt(IId_expressionContext) + + // Getter signatures + DISASSOCIATE() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + FROM() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + PACKAGES() antlr.TerminalNode + TYPES() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INDEXTYPES() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + FORCE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDisassociate_statisticsContext differentiates from other interfaces. + IsDisassociate_statisticsContext() +} + +type Disassociate_statisticsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tb IId_expressionContext + c IId_expressionContext + fn IId_expressionContext + pkg IId_expressionContext + t IId_expressionContext + ix IId_expressionContext + it IId_expressionContext +} + +func NewEmptyDisassociate_statisticsContext() *Disassociate_statisticsContext { + var p = new(Disassociate_statisticsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disassociate_statistics + return p +} + +func InitEmptyDisassociate_statisticsContext(p *Disassociate_statisticsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disassociate_statistics +} + +func (*Disassociate_statisticsContext) IsDisassociate_statisticsContext() {} + +func NewDisassociate_statisticsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disassociate_statisticsContext { + var p = new(Disassociate_statisticsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disassociate_statistics + + return p +} + +func (s *Disassociate_statisticsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disassociate_statisticsContext) GetTb() IId_expressionContext { return s.tb } + +func (s *Disassociate_statisticsContext) GetC() IId_expressionContext { return s.c } + +func (s *Disassociate_statisticsContext) GetFn() IId_expressionContext { return s.fn } + +func (s *Disassociate_statisticsContext) GetPkg() IId_expressionContext { return s.pkg } + +func (s *Disassociate_statisticsContext) GetT() IId_expressionContext { return s.t } + +func (s *Disassociate_statisticsContext) GetIx() IId_expressionContext { return s.ix } + +func (s *Disassociate_statisticsContext) GetIt() IId_expressionContext { return s.it } + +func (s *Disassociate_statisticsContext) SetTb(v IId_expressionContext) { s.tb = v } + +func (s *Disassociate_statisticsContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Disassociate_statisticsContext) SetFn(v IId_expressionContext) { s.fn = v } + +func (s *Disassociate_statisticsContext) SetPkg(v IId_expressionContext) { s.pkg = v } + +func (s *Disassociate_statisticsContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Disassociate_statisticsContext) SetIx(v IId_expressionContext) { s.ix = v } + +func (s *Disassociate_statisticsContext) SetIt(v IId_expressionContext) { s.it = v } + +func (s *Disassociate_statisticsContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Disassociate_statisticsContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Disassociate_statisticsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Disassociate_statisticsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Disassociate_statisticsContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Disassociate_statisticsContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Disassociate_statisticsContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Disassociate_statisticsContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Disassociate_statisticsContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Disassociate_statisticsContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Disassociate_statisticsContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Disassociate_statisticsContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Disassociate_statisticsContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Disassociate_statisticsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Disassociate_statisticsContext) 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 *Disassociate_statisticsContext) 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 *Disassociate_statisticsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Disassociate_statisticsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Disassociate_statisticsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disassociate_statisticsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disassociate_statisticsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisassociate_statistics(s) + } +} + +func (s *Disassociate_statisticsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisassociate_statistics(s) + } +} + +func (s *Disassociate_statisticsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisassociate_statistics(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disassociate_statistics() (localctx IDisassociate_statisticsContext) { + localctx = NewDisassociate_statisticsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 744, PlSqlParserRULE_disassociate_statistics) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(7885) + p.Match(PlSqlParserDISASSOCIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7886) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7887) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8007) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMNS: + { + p.SetState(7888) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7892) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 808, p.GetParserRuleContext()) == 1 { + { + p.SetState(7889) + p.Schema_name() + } + { + p.SetState(7890) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7894) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).tb = _x + } + { + p.SetState(7895) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7896) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).c = _x + } + p.SetState(7909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 810, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7897) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7901) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 809, p.GetParserRuleContext()) == 1 { + { + p.SetState(7898) + p.Schema_name() + } + { + p.SetState(7899) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7903) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).tb = _x + } + { + p.SetState(7904) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(7905) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).c = _x + } + + } + p.SetState(7911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 810, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserFUNCTIONS: + { + p.SetState(7912) + p.Match(PlSqlParserFUNCTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7916) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 811, p.GetParserRuleContext()) == 1 { + { + p.SetState(7913) + p.Schema_name() + } + { + p.SetState(7914) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7918) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).fn = _x + } + p.SetState(7928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 813, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7919) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7923) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 812, p.GetParserRuleContext()) == 1 { + { + p.SetState(7920) + p.Schema_name() + } + { + p.SetState(7921) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7925) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).fn = _x + } + + } + p.SetState(7930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 813, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserPACKAGES: + { + p.SetState(7931) + p.Match(PlSqlParserPACKAGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7935) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 814, p.GetParserRuleContext()) == 1 { + { + p.SetState(7932) + p.Schema_name() + } + { + p.SetState(7933) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7937) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).pkg = _x + } + p.SetState(7947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7938) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7942) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 815, p.GetParserRuleContext()) == 1 { + { + p.SetState(7939) + p.Schema_name() + } + { + p.SetState(7940) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7944) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).pkg = _x + } + + } + p.SetState(7949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 816, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserTYPES: + { + p.SetState(7950) + p.Match(PlSqlParserTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7954) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 817, p.GetParserRuleContext()) == 1 { + { + p.SetState(7951) + p.Schema_name() + } + { + p.SetState(7952) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7956) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).t = _x + } + p.SetState(7966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7957) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7961) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 818, p.GetParserRuleContext()) == 1 { + { + p.SetState(7958) + p.Schema_name() + } + { + p.SetState(7959) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7963) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).t = _x + } + + } + p.SetState(7968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 819, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserINDEXES: + { + p.SetState(7969) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7973) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 820, p.GetParserRuleContext()) == 1 { + { + p.SetState(7970) + p.Schema_name() + } + { + p.SetState(7971) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7975) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).ix = _x + } + p.SetState(7985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 822, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7976) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7980) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 821, p.GetParserRuleContext()) == 1 { + { + p.SetState(7977) + p.Schema_name() + } + { + p.SetState(7978) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7982) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).ix = _x + } + + } + p.SetState(7987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 822, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserINDEXTYPES: + { + p.SetState(7988) + p.Match(PlSqlParserINDEXTYPES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 823, p.GetParserRuleContext()) == 1 { + { + p.SetState(7989) + p.Schema_name() + } + { + p.SetState(7990) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(7994) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).it = _x + } + p.SetState(8004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 825, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(7995) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(7999) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 824, p.GetParserRuleContext()) == 1 { + { + p.SetState(7996) + p.Schema_name() + } + { + p.SetState(7997) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8001) + + var _x = p.Id_expression() + + localctx.(*Disassociate_statisticsContext).it = _x + } + + } + p.SetState(8006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 825, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8010) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 827, p.GetParserRuleContext()) == 1 { + { + p.SetState(8009) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_indextypeContext is an interface to support dynamic dispatch. +type IDrop_indextypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIt returns the it rule contexts. + GetIt() IId_expressionContext + + // SetIt sets the it rule contexts. + SetIt(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_indextypeContext differentiates from other interfaces. + IsDrop_indextypeContext() +} + +type Drop_indextypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + it IId_expressionContext +} + +func NewEmptyDrop_indextypeContext() *Drop_indextypeContext { + var p = new(Drop_indextypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_indextype + return p +} + +func InitEmptyDrop_indextypeContext(p *Drop_indextypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_indextype +} + +func (*Drop_indextypeContext) IsDrop_indextypeContext() {} + +func NewDrop_indextypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_indextypeContext { + var p = new(Drop_indextypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_indextype + + return p +} + +func (s *Drop_indextypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_indextypeContext) GetIt() IId_expressionContext { return s.it } + +func (s *Drop_indextypeContext) SetIt(v IId_expressionContext) { s.it = v } + +func (s *Drop_indextypeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_indextypeContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Drop_indextypeContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_indextypeContext) 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_indextypeContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_indextypeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_indextypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_indextypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_indextypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_indextype(s) + } +} + +func (s *Drop_indextypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_indextype(s) + } +} + +func (s *Drop_indextypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_indextype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_indextype() (localctx IDrop_indextypeContext) { + localctx = NewDrop_indextypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 746, PlSqlParserRULE_drop_indextype) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8012) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8013) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8017) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 828, p.GetParserRuleContext()) == 1 { + { + p.SetState(8014) + p.Schema_name() + } + { + p.SetState(8015) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8019) + + var _x = p.Id_expression() + + localctx.(*Drop_indextypeContext).it = _x + } + p.SetState(8021) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 829, p.GetParserRuleContext()) == 1 { + { + p.SetState(8020) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_inmemory_join_groupContext is an interface to support dynamic dispatch. +type IDrop_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_inmemory_join_groupContext differentiates from other interfaces. + IsDrop_inmemory_join_groupContext() +} + +type Drop_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext +} + +func NewEmptyDrop_inmemory_join_groupContext() *Drop_inmemory_join_groupContext { + var p = new(Drop_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group + return p +} + +func InitEmptyDrop_inmemory_join_groupContext(p *Drop_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group +} + +func (*Drop_inmemory_join_groupContext) IsDrop_inmemory_join_groupContext() {} + +func NewDrop_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_inmemory_join_groupContext { + var p = new(Drop_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_inmemory_join_group + + return p +} + +func (s *Drop_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Drop_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Drop_inmemory_join_groupContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Drop_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Drop_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Drop_inmemory_join_groupContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_inmemory_join_groupContext) 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_inmemory_join_groupContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_inmemory_join_group(s) + } +} + +func (s *Drop_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_inmemory_join_group(s) + } +} + +func (s *Drop_inmemory_join_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_inmemory_join_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_inmemory_join_group() (localctx IDrop_inmemory_join_groupContext) { + localctx = NewDrop_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 748, PlSqlParserRULE_drop_inmemory_join_group) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8023) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8024) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8025) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8026) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8030) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 830, p.GetParserRuleContext()) == 1 { + { + p.SetState(8027) + p.Schema_name() + } + { + p.SetState(8028) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8032) + + var _x = p.Id_expression() + + localctx.(*Drop_inmemory_join_groupContext).jg = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_tableContext is an interface to support dynamic dispatch. +type IFlashback_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLASHBACK() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllTableview_name() []ITableview_nameContext + Tableview_name(i int) ITableview_nameContext + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + BEFORE() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Expression() IExpressionContext + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + Restore_point() IRestore_pointContext + SCN() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + RENAME() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsFlashback_tableContext differentiates from other interfaces. + IsFlashback_tableContext() +} + +type Flashback_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_tableContext() *Flashback_tableContext { + var p = new(Flashback_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_table + return p +} + +func InitEmptyFlashback_tableContext(p *Flashback_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_table +} + +func (*Flashback_tableContext) IsFlashback_tableContext() {} + +func NewFlashback_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_tableContext { + var p = new(Flashback_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_table + + return p +} + +func (s *Flashback_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_tableContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Flashback_tableContext) AllTableview_name() []ITableview_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITableview_nameContext); ok { + len++ + } + } + + tst := make([]ITableview_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITableview_nameContext); ok { + tst[i] = t.(ITableview_nameContext) + i++ + } + } + + return tst +} + +func (s *Flashback_tableContext) Tableview_name(i int) ITableview_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Flashback_tableContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Flashback_tableContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Flashback_tableContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Flashback_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Flashback_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Flashback_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Flashback_tableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Flashback_tableContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Flashback_tableContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Flashback_tableContext) Restore_point() IRestore_pointContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRestore_pointContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRestore_pointContext) +} + +func (s *Flashback_tableContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Flashback_tableContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Flashback_tableContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, 0) +} + +func (s *Flashback_tableContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Flashback_tableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Flashback_tableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Flashback_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_table(s) + } +} + +func (s *Flashback_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_table(s) + } +} + +func (s *Flashback_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_table() (localctx IFlashback_tableContext) { + localctx = NewFlashback_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 750, PlSqlParserRULE_flashback_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8034) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8035) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8036) + p.Tableview_name() + } + p.SetState(8041) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8037) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8038) + p.Tableview_name() + } + + p.SetState(8043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8044) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESTORE, PlSqlParserSCN, PlSqlParserTIMESTAMP: + p.SetState(8050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCN, PlSqlParserTIMESTAMP: + { + p.SetState(8045) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8046) + p.Expression() + } + + case PlSqlParserRESTORE: + { + p.SetState(8047) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8048) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8049) + p.Restore_point() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8054) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 833, p.GetParserRuleContext()) == 1 { + { + p.SetState(8052) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8053) + p.Match(PlSqlParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserBEFORE: + { + p.SetState(8056) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8057) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8061) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 834, p.GetParserRuleContext()) == 1 { + { + p.SetState(8058) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8059) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8060) + p.Tableview_name() + } + + } 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 +} + +// IRestore_pointContext is an interface to support dynamic dispatch. +type IRestore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsRestore_pointContext differentiates from other interfaces. + IsRestore_pointContext() +} + +type Restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRestore_pointContext() *Restore_pointContext { + var p = new(Restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_restore_point + return p +} + +func InitEmptyRestore_pointContext(p *Restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_restore_point +} + +func (*Restore_pointContext) IsRestore_pointContext() {} + +func NewRestore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Restore_pointContext { + var p = new(Restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_restore_point + + return p +} + +func (s *Restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Restore_pointContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Restore_pointContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Restore_pointContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRestore_point(s) + } +} + +func (s *Restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRestore_point(s) + } +} + +func (s *Restore_pointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRestore_point(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Restore_point() (localctx IRestore_pointContext) { + localctx = NewRestore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 752, PlSqlParserRULE_restore_point) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8065) + p.Identifier() + } + p.SetState(8070) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8066) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8067) + p.Id_expression() + } + + } + p.SetState(8072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 836, 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 +} + +// IPurge_statementContext is an interface to support dynamic dispatch. +type IPurge_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // GetU returns the u rule contexts. + GetU() IId_expressionContext + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // SetU sets the u rule contexts. + SetU(IId_expressionContext) + + // Getter signatures + PURGE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + TABLESPACE() antlr.TerminalNode + RECYCLEBIN() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + TABLE() antlr.TerminalNode + INDEX() antlr.TerminalNode + SET() antlr.TerminalNode + USER() antlr.TerminalNode + + // IsPurge_statementContext differentiates from other interfaces. + IsPurge_statementContext() +} + +type Purge_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ts IId_expressionContext + u IId_expressionContext +} + +func NewEmptyPurge_statementContext() *Purge_statementContext { + var p = new(Purge_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_purge_statement + return p +} + +func InitEmptyPurge_statementContext(p *Purge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_purge_statement +} + +func (*Purge_statementContext) IsPurge_statementContext() {} + +func NewPurge_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Purge_statementContext { + var p = new(Purge_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_purge_statement + + return p +} + +func (s *Purge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Purge_statementContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Purge_statementContext) GetU() IId_expressionContext { return s.u } + +func (s *Purge_statementContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Purge_statementContext) SetU(v IId_expressionContext) { s.u = v } + +func (s *Purge_statementContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Purge_statementContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Purge_statementContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Purge_statementContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Purge_statementContext) RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLEBIN, 0) +} + +func (s *Purge_statementContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *Purge_statementContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Purge_statementContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Purge_statementContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Purge_statementContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Purge_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Purge_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Purge_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPurge_statement(s) + } +} + +func (s *Purge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPurge_statement(s) + } +} + +func (s *Purge_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPurge_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Purge_statement() (localctx IPurge_statementContext) { + localctx = NewPurge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 754, PlSqlParserRULE_purge_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8073) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINDEX, PlSqlParserTABLE: + { + p.SetState(8074) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINDEX || _la == PlSqlParserTABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8075) + p.Id_expression() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(8076) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8078) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 837, p.GetParserRuleContext()) == 1 { + { + p.SetState(8077) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8080) + + var _x = p.Id_expression() + + localctx.(*Purge_statementContext).ts = _x + } + p.SetState(8083) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 838, p.GetParserRuleContext()) == 1 { + { + p.SetState(8081) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8082) + + var _x = p.Id_expression() + + localctx.(*Purge_statementContext).u = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserRECYCLEBIN: + { + p.SetState(8085) + p.Match(PlSqlParserRECYCLEBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDBA_RECYCLEBIN: + { + p.SetState(8086) + p.Match(PlSqlParserDBA_RECYCLEBIN) + 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 +} + +// INoaudit_statementContext is an interface to support dynamic dispatch. +type INoaudit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOAUDIT() antlr.TerminalNode + Audit_operation_clause() IAudit_operation_clauseContext + Audit_schema_object_clause() IAudit_schema_object_clauseContext + NETWORK() antlr.TerminalNode + DIRECT_PATH() antlr.TerminalNode + LOAD() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + Container_clause() IContainer_clauseContext + Auditing_by_clause() IAuditing_by_clauseContext + NOT() antlr.TerminalNode + + // IsNoaudit_statementContext differentiates from other interfaces. + IsNoaudit_statementContext() +} + +type Noaudit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNoaudit_statementContext() *Noaudit_statementContext { + var p = new(Noaudit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_noaudit_statement + return p +} + +func InitEmptyNoaudit_statementContext(p *Noaudit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_noaudit_statement +} + +func (*Noaudit_statementContext) IsNoaudit_statementContext() {} + +func NewNoaudit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Noaudit_statementContext { + var p = new(Noaudit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_noaudit_statement + + return p +} + +func (s *Noaudit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Noaudit_statementContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Noaudit_statementContext) Audit_operation_clause() IAudit_operation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_operation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_operation_clauseContext) +} + +func (s *Noaudit_statementContext) Audit_schema_object_clause() IAudit_schema_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAudit_schema_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAudit_schema_object_clauseContext) +} + +func (s *Noaudit_statementContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Noaudit_statementContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Noaudit_statementContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Noaudit_statementContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Noaudit_statementContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Noaudit_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Noaudit_statementContext) Auditing_by_clause() IAuditing_by_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAuditing_by_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAuditing_by_clauseContext) +} + +func (s *Noaudit_statementContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Noaudit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Noaudit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Noaudit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNoaudit_statement(s) + } +} + +func (s *Noaudit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNoaudit_statement(s) + } +} + +func (s *Noaudit_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNoaudit_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Noaudit_statement() (localctx INoaudit_statementContext) { + localctx = NewNoaudit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 756, PlSqlParserRULE_noaudit_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8089) + p.Match(PlSqlParserNOAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 842, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8090) + p.Audit_operation_clause() + } + p.SetState(8092) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 840, p.GetParserRuleContext()) == 1 { + { + p.SetState(8091) + p.Auditing_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(8094) + p.Audit_schema_object_clause() + } + + case 3: + { + p.SetState(8095) + p.Match(PlSqlParserNETWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(8096) + p.Match(PlSqlParserDIRECT_PATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8097) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8099) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 841, p.GetParserRuleContext()) == 1 { + { + p.SetState(8098) + p.Auditing_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8108) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 844, p.GetParserRuleContext()) == 1 { + { + p.SetState(8103) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(8104) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8107) + p.Match(PlSqlParserSUCCESSFUL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8111) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 845, p.GetParserRuleContext()) == 1 { + { + p.SetState(8110) + p.Container_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 +} + +// IRename_objectContext is an interface to support dynamic dispatch. +type IRename_objectContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + AllObject_name() []IObject_nameContext + Object_name(i int) IObject_nameContext + TO() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + + // IsRename_objectContext differentiates from other interfaces. + IsRename_objectContext() +} + +type Rename_objectContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_objectContext() *Rename_objectContext { + var p = new(Rename_objectContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_object + return p +} + +func InitEmptyRename_objectContext(p *Rename_objectContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_object +} + +func (*Rename_objectContext) IsRename_objectContext() {} + +func NewRename_objectContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_objectContext { + var p = new(Rename_objectContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_object + + return p +} + +func (s *Rename_objectContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_objectContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_objectContext) 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 *Rename_objectContext) 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 *Rename_objectContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_objectContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Rename_objectContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_objectContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_objectContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_object(s) + } +} + +func (s *Rename_objectContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_object(s) + } +} + +func (s *Rename_objectContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRename_object(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rename_object() (localctx IRename_objectContext) { + localctx = NewRename_objectContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 758, PlSqlParserRULE_rename_object) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8113) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8114) + p.Object_name() + } + { + p.SetState(8115) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8116) + p.Object_name() + } + { + p.SetState(8117) + p.Match(PlSqlParserSEMICOLON) + 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_statementContext is an interface to support dynamic dispatch. +type IGrant_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGRANT() []antlr.TerminalNode + GRANT(i int) antlr.TerminalNode + TO() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + AllGrantee_name() []IGrantee_nameContext + Grantee_name(i int) IGrantee_nameContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + ON() antlr.TerminalNode + Grant_object_name() IGrant_object_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllOPTION() []antlr.TerminalNode + OPTION(i int) antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Container_clause() IContainer_clauseContext + ADMIN() antlr.TerminalNode + DELEGATE() antlr.TerminalNode + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + AllSystem_privilege() []ISystem_privilegeContext + System_privilege(i int) ISystem_privilegeContext + AllObject_privilege() []IObject_privilegeContext + Object_privilege(i int) IObject_privilegeContext + AllParen_column_list() []IParen_column_listContext + Paren_column_list(i int) IParen_column_listContext + + // IsGrant_statementContext differentiates from other interfaces. + IsGrant_statementContext() +} + +type Grant_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_statementContext() *Grant_statementContext { + var p = new(Grant_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_statement + return p +} + +func InitEmptyGrant_statementContext(p *Grant_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_statement +} + +func (*Grant_statementContext) IsGrant_statementContext() {} + +func NewGrant_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_statementContext { + var p = new(Grant_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grant_statement + + return p +} + +func (s *Grant_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_statementContext) AllGRANT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGRANT) +} + +func (s *Grant_statementContext) GRANT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, i) +} + +func (s *Grant_statementContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Grant_statementContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Grant_statementContext) AllGrantee_name() []IGrantee_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrantee_nameContext); ok { + len++ + } + } + + tst := make([]IGrantee_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrantee_nameContext); ok { + tst[i] = t.(IGrantee_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Grantee_name(i int) IGrantee_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrantee_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrantee_nameContext) +} + +func (s *Grant_statementContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Grant_statementContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Grant_statementContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Grant_statementContext) Grant_object_name() IGrant_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrant_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrant_object_nameContext) +} + +func (s *Grant_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grant_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grant_statementContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Grant_statementContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Grant_statementContext) AllOPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOPTION) +} + +func (s *Grant_statementContext) OPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, i) +} + +func (s *Grant_statementContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Grant_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Grant_statementContext) ADMIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMIN, 0) +} + +func (s *Grant_statementContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELEGATE, 0) +} + +func (s *Grant_statementContext) 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_statementContext) 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_statementContext) AllSystem_privilege() []ISystem_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISystem_privilegeContext); ok { + len++ + } + } + + tst := make([]ISystem_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISystem_privilegeContext); ok { + tst[i] = t.(ISystem_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) System_privilege(i int) ISystem_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Grant_statementContext) AllObject_privilege() []IObject_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_privilegeContext); ok { + len++ + } + } + + tst := make([]IObject_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_privilegeContext); ok { + tst[i] = t.(IObject_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Object_privilege(i int) IObject_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Grant_statementContext) AllParen_column_list() []IParen_column_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParen_column_listContext); ok { + len++ + } + } + + tst := make([]IParen_column_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParen_column_listContext); ok { + tst[i] = t.(IParen_column_listContext) + i++ + } + } + + return tst +} + +func (s *Grant_statementContext) Paren_column_list(i int) IParen_column_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Grant_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrant_statement(s) + } +} + +func (s *Grant_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrant_statement(s) + } +} + +func (s *Grant_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGrant_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Grant_statement() (localctx IGrant_statementContext) { + localctx = NewGrant_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 760, PlSqlParserRULE_grant_statement) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8119) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8120) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 848, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8123) + p.Role_name() + } + + case 2: + { + p.SetState(8124) + p.System_privilege() + } + + case 3: + { + p.SetState(8125) + p.Object_privilege() + } + p.SetState(8127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8126) + p.Paren_column_list() + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8133) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 849, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(8137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(8135) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8136) + p.Grant_object_name() + } + + } + { + p.SetState(8139) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 851, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8140) + p.Grantee_name() + } + + case 2: + { + p.SetState(8141) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8144) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8147) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 852, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8145) + p.Grantee_name() + } + + case 2: + { + p.SetState(8146) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8157) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 854, p.GetParserRuleContext()) == 1 { + { + p.SetState(8154) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8155) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADMIN || _la == PlSqlParserDELEGATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8156) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8162) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 855, p.GetParserRuleContext()) == 1 { + { + p.SetState(8159) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8160) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8161) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(8164) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8165) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8166) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONTAINER { + { + p.SetState(8169) + p.Container_clause() + } + + } + { + p.SetState(8172) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IContainer_clauseContext is an interface to support dynamic dispatch. +type IContainer_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTAINER() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsContainer_clauseContext differentiates from other interfaces. + IsContainer_clauseContext() +} + +type Container_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_clauseContext() *Container_clauseContext { + var p = new(Container_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_clause + return p +} + +func InitEmptyContainer_clauseContext(p *Container_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_clause +} + +func (*Container_clauseContext) IsContainer_clauseContext() {} + +func NewContainer_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_clauseContext { + var p = new(Container_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_clause + + return p +} + +func (s *Container_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_clauseContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Container_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Container_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Container_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Container_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_clause(s) + } +} + +func (s *Container_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_clause(s) + } +} + +func (s *Container_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitContainer_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Container_clause() (localctx IContainer_clauseContext) { + localctx = NewContainer_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 762, PlSqlParserRULE_container_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8174) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8175) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8176) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserCURRENT) { + 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 +} + +// IRevoke_statementContext is an interface to support dynamic dispatch. +type IRevoke_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REVOKE() antlr.TerminalNode + Revoke_roles_from_programs() IRevoke_roles_from_programsContext + Revoke_system_privilege() IRevoke_system_privilegeContext + Revoke_object_privileges() IRevoke_object_privilegesContext + Container_clause() IContainer_clauseContext + + // IsRevoke_statementContext differentiates from other interfaces. + IsRevoke_statementContext() +} + +type Revoke_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_statementContext() *Revoke_statementContext { + var p = new(Revoke_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_statement + return p +} + +func InitEmptyRevoke_statementContext(p *Revoke_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_statement +} + +func (*Revoke_statementContext) IsRevoke_statementContext() {} + +func NewRevoke_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_statementContext { + var p = new(Revoke_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_statement + + return p +} + +func (s *Revoke_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_statementContext) REVOKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVOKE, 0) +} + +func (s *Revoke_statementContext) Revoke_roles_from_programs() IRevoke_roles_from_programsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_roles_from_programsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_roles_from_programsContext) +} + +func (s *Revoke_statementContext) Revoke_system_privilege() IRevoke_system_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_system_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_system_privilegeContext) +} + +func (s *Revoke_statementContext) Revoke_object_privileges() IRevoke_object_privilegesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevoke_object_privilegesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevoke_object_privilegesContext) +} + +func (s *Revoke_statementContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Revoke_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_statement(s) + } +} + +func (s *Revoke_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_statement(s) + } +} + +func (s *Revoke_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRevoke_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Revoke_statement() (localctx IRevoke_statementContext) { + localctx = NewRevoke_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 764, PlSqlParserRULE_revoke_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8178) + p.Match(PlSqlParserREVOKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 860, p.GetParserRuleContext()) { + case 1: + p.SetState(8181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 858, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8179) + p.Revoke_system_privilege() + } + + case 2: + { + p.SetState(8180) + p.Revoke_object_privileges() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8184) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 859, p.GetParserRuleContext()) == 1 { + { + p.SetState(8183) + p.Container_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(8186) + p.Revoke_roles_from_programs() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_system_privilegeContext is an interface to support dynamic dispatch. +type IRevoke_system_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + Revokee_clause() IRevokee_clauseContext + System_privilege() ISystem_privilegeContext + Role_name() IRole_nameContext + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + + // IsRevoke_system_privilegeContext differentiates from other interfaces. + IsRevoke_system_privilegeContext() +} + +type Revoke_system_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_system_privilegeContext() *Revoke_system_privilegeContext { + var p = new(Revoke_system_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege + return p +} + +func InitEmptyRevoke_system_privilegeContext(p *Revoke_system_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege +} + +func (*Revoke_system_privilegeContext) IsRevoke_system_privilegeContext() {} + +func NewRevoke_system_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_system_privilegeContext { + var p = new(Revoke_system_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_system_privilege + + return p +} + +func (s *Revoke_system_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_system_privilegeContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_system_privilegeContext) Revokee_clause() IRevokee_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokee_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokee_clauseContext) +} + +func (s *Revoke_system_privilegeContext) System_privilege() ISystem_privilegeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_privilegeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_privilegeContext) +} + +func (s *Revoke_system_privilegeContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Revoke_system_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Revoke_system_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Revoke_system_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_system_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_system_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_system_privilege(s) + } +} + +func (s *Revoke_system_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_system_privilege(s) + } +} + +func (s *Revoke_system_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRevoke_system_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Revoke_system_privilege() (localctx IRevoke_system_privilegeContext) { + localctx = NewRevoke_system_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 766, PlSqlParserRULE_revoke_system_privilege) + p.EnterOuterAlt(localctx, 1) + p.SetState(8193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 861, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8189) + p.System_privilege() + } + + case 2: + { + p.SetState(8190) + p.Role_name() + } + + case 3: + { + p.SetState(8191) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8192) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8195) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8196) + p.Revokee_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 +} + +// IRevokee_clauseContext is an interface to support dynamic dispatch. +type IRevokee_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevokee_clauseContext differentiates from other interfaces. + IsRevokee_clauseContext() +} + +type Revokee_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevokee_clauseContext() *Revokee_clauseContext { + var p = new(Revokee_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revokee_clause + return p +} + +func InitEmptyRevokee_clauseContext(p *Revokee_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revokee_clause +} + +func (*Revokee_clauseContext) IsRevokee_clauseContext() {} + +func NewRevokee_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revokee_clauseContext { + var p = new(Revokee_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revokee_clause + + return p +} + +func (s *Revokee_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revokee_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Revokee_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Revokee_clauseContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Revokee_clauseContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Revokee_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revokee_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revokee_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revokee_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revokee_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevokee_clause(s) + } +} + +func (s *Revokee_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevokee_clause(s) + } +} + +func (s *Revokee_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRevokee_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Revokee_clause() (localctx IRevokee_clauseContext) { + localctx = NewRevokee_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 768, PlSqlParserRULE_revokee_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 862, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8198) + p.Id_expression() + } + + case 2: + { + p.SetState(8199) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 864, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8202) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8205) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 863, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8203) + p.Id_expression() + } + + case 2: + { + p.SetState(8204) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(8211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 864, 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 +} + +// IRevoke_object_privilegesContext is an interface to support dynamic dispatch. +type IRevoke_object_privilegesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + On_object_clause() IOn_object_clauseContext + FROM() antlr.TerminalNode + Revokee_clause() IRevokee_clauseContext + AllObject_privilege() []IObject_privilegeContext + Object_privilege(i int) IObject_privilegeContext + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + FORCE() antlr.TerminalNode + AllPRIVILEGES() []antlr.TerminalNode + PRIVILEGES(i int) antlr.TerminalNode + + // IsRevoke_object_privilegesContext differentiates from other interfaces. + IsRevoke_object_privilegesContext() +} + +type Revoke_object_privilegesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_object_privilegesContext() *Revoke_object_privilegesContext { + var p = new(Revoke_object_privilegesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges + return p +} + +func InitEmptyRevoke_object_privilegesContext(p *Revoke_object_privilegesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges +} + +func (*Revoke_object_privilegesContext) IsRevoke_object_privilegesContext() {} + +func NewRevoke_object_privilegesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_object_privilegesContext { + var p = new(Revoke_object_privilegesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_object_privileges + + return p +} + +func (s *Revoke_object_privilegesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_object_privilegesContext) On_object_clause() IOn_object_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_object_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_object_clauseContext) +} + +func (s *Revoke_object_privilegesContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_object_privilegesContext) Revokee_clause() IRevokee_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRevokee_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRevokee_clauseContext) +} + +func (s *Revoke_object_privilegesContext) AllObject_privilege() []IObject_privilegeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_privilegeContext); ok { + len++ + } + } + + tst := make([]IObject_privilegeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_privilegeContext); ok { + tst[i] = t.(IObject_privilegeContext) + i++ + } + } + + return tst +} + +func (s *Revoke_object_privilegesContext) Object_privilege(i int) IObject_privilegeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_privilegeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_privilegeContext) +} + +func (s *Revoke_object_privilegesContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Revoke_object_privilegesContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Revoke_object_privilegesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revoke_object_privilegesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revoke_object_privilegesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Revoke_object_privilegesContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Revoke_object_privilegesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Revoke_object_privilegesContext) AllPRIVILEGES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVILEGES) +} + +func (s *Revoke_object_privilegesContext) PRIVILEGES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, i) +} + +func (s *Revoke_object_privilegesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_object_privilegesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_object_privilegesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_object_privileges(s) + } +} + +func (s *Revoke_object_privilegesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_object_privileges(s) + } +} + +func (s *Revoke_object_privilegesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRevoke_object_privileges(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Revoke_object_privileges() (localctx IRevoke_object_privilegesContext) { + localctx = NewRevoke_object_privilegesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 770, PlSqlParserRULE_revoke_object_privileges) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 866, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8212) + p.Object_privilege() + } + + case 2: + { + p.SetState(8213) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(8214) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(8229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8219) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 868, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8220) + p.Object_privilege() + } + + case 2: + { + p.SetState(8221) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVILEGES { + { + p.SetState(8222) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8232) + p.On_object_clause() + } + { + p.SetState(8233) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8234) + p.Revokee_clause() + } + p.SetState(8238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 870, p.GetParserRuleContext()) == 1 { + { + p.SetState(8235) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8236) + p.Match(PlSqlParserCONSTRAINTS) + 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(), 870, p.GetParserRuleContext()) == 2 { + { + p.SetState(8237) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_object_clauseContext is an interface to support dynamic dispatch. +type IOn_object_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // GetMmn returns the mmn rule contexts. + GetMmn() IId_expressionContext + + // GetO2 returns the o2 rule contexts. + GetO2() IId_expressionContext + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // SetMmn sets the mmn rule contexts. + SetMmn(IId_expressionContext) + + // SetO2 sets the o2 rule contexts. + SetO2(IId_expressionContext) + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + ON() antlr.TerminalNode + USER() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + EDITION() antlr.TerminalNode + Edition_name() IEdition_nameContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + JAVA() antlr.TerminalNode + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOn_object_clauseContext differentiates from other interfaces. + IsOn_object_clauseContext() +} + +type On_object_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext + mmn IId_expressionContext + o2 IId_expressionContext + p IId_expressionContext +} + +func NewEmptyOn_object_clauseContext() *On_object_clauseContext { + var p = new(On_object_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_object_clause + return p +} + +func InitEmptyOn_object_clauseContext(p *On_object_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_object_clause +} + +func (*On_object_clauseContext) IsOn_object_clauseContext() {} + +func NewOn_object_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_object_clauseContext { + var p = new(On_object_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_object_clause + + return p +} + +func (s *On_object_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_object_clauseContext) GetO() IId_expressionContext { return s.o } + +func (s *On_object_clauseContext) GetMmn() IId_expressionContext { return s.mmn } + +func (s *On_object_clauseContext) GetO2() IId_expressionContext { return s.o2 } + +func (s *On_object_clauseContext) GetP() IId_expressionContext { return s.p } + +func (s *On_object_clauseContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *On_object_clauseContext) SetMmn(v IId_expressionContext) { s.mmn = v } + +func (s *On_object_clauseContext) SetO2(v IId_expressionContext) { s.o2 = v } + +func (s *On_object_clauseContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *On_object_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *On_object_clauseContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *On_object_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *On_object_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *On_object_clauseContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *On_object_clauseContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *On_object_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *On_object_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *On_object_clauseContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *On_object_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *On_object_clauseContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *On_object_clauseContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *On_object_clauseContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *On_object_clauseContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *On_object_clauseContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *On_object_clauseContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *On_object_clauseContext) 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 *On_object_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *On_object_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *On_object_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *On_object_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_object_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_object_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_object_clause(s) + } +} + +func (s *On_object_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_object_clause(s) + } +} + +func (s *On_object_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_object_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_object_clause() (localctx IOn_object_clauseContext) { + localctx = NewOn_object_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 772, PlSqlParserRULE_on_object_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8240) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 876, p.GetParserRuleContext()) { + case 1: + p.SetState(8244) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 871, p.GetParserRuleContext()) == 1 { + { + p.SetState(8241) + p.Schema_name() + } + { + p.SetState(8242) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8246) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).o = _x + } + + case 2: + { + p.SetState(8247) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8248) + p.Id_expression() + } + p.SetState(8253) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8249) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8250) + p.Id_expression() + } + + p.SetState(8255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(8256) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8257) + p.Directory_name() + } + + case 4: + { + p.SetState(8258) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8259) + p.Edition_name() + } + + case 5: + { + p.SetState(8260) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8261) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8265) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 873, p.GetParserRuleContext()) == 1 { + { + p.SetState(8262) + p.Schema_name() + } + { + p.SetState(8263) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8267) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).mmn = _x + } + + case 6: + { + p.SetState(8268) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8269) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8273) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 874, p.GetParserRuleContext()) == 1 { + { + p.SetState(8270) + p.Schema_name() + } + { + p.SetState(8271) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8275) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).o2 = _x + } + + case 7: + { + p.SetState(8276) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8277) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8278) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8282) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 875, p.GetParserRuleContext()) == 1 { + { + p.SetState(8279) + p.Schema_name() + } + { + p.SetState(8280) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8284) + + var _x = p.Id_expression() + + localctx.(*On_object_clauseContext).p = _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 +} + +// IRevoke_roles_from_programsContext is an interface to support dynamic dispatch. +type IRevoke_roles_from_programsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + AllProgram_unit() []IProgram_unitContext + Program_unit(i int) IProgram_unitContext + AllRole_name() []IRole_nameContext + Role_name(i int) IRole_nameContext + ALL() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRevoke_roles_from_programsContext differentiates from other interfaces. + IsRevoke_roles_from_programsContext() +} + +type Revoke_roles_from_programsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRevoke_roles_from_programsContext() *Revoke_roles_from_programsContext { + var p = new(Revoke_roles_from_programsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs + return p +} + +func InitEmptyRevoke_roles_from_programsContext(p *Revoke_roles_from_programsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs +} + +func (*Revoke_roles_from_programsContext) IsRevoke_roles_from_programsContext() {} + +func NewRevoke_roles_from_programsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Revoke_roles_from_programsContext { + var p = new(Revoke_roles_from_programsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_revoke_roles_from_programs + + return p +} + +func (s *Revoke_roles_from_programsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Revoke_roles_from_programsContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Revoke_roles_from_programsContext) AllProgram_unit() []IProgram_unitContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IProgram_unitContext); ok { + len++ + } + } + + tst := make([]IProgram_unitContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IProgram_unitContext); ok { + tst[i] = t.(IProgram_unitContext) + i++ + } + } + + return tst +} + +func (s *Revoke_roles_from_programsContext) Program_unit(i int) IProgram_unitContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProgram_unitContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IProgram_unitContext) +} + +func (s *Revoke_roles_from_programsContext) 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_roles_from_programsContext) 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_roles_from_programsContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Revoke_roles_from_programsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Revoke_roles_from_programsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Revoke_roles_from_programsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Revoke_roles_from_programsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Revoke_roles_from_programsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRevoke_roles_from_programs(s) + } +} + +func (s *Revoke_roles_from_programsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRevoke_roles_from_programs(s) + } +} + +func (s *Revoke_roles_from_programsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRevoke_roles_from_programs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Revoke_roles_from_programs() (localctx IRevoke_roles_from_programsContext) { + localctx = NewRevoke_roles_from_programsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 774, PlSqlParserRULE_revoke_roles_from_programs) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESOURCE, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(8287) + p.Role_name() + } + p.SetState(8292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8288) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8289) + p.Role_name() + } + + p.SetState(8294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserALL: + { + p.SetState(8295) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8298) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8299) + p.Program_unit() + } + p.SetState(8304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 879, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8300) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8301) + p.Program_unit() + } + + } + p.SetState(8306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 879, 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 +} + +// IProgram_unitContext is an interface to support dynamic dispatch. +type IProgram_unitContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + FUNCTION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsProgram_unitContext differentiates from other interfaces. + IsProgram_unitContext() +} + +type Program_unitContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProgram_unitContext() *Program_unitContext { + var p = new(Program_unitContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_program_unit + return p +} + +func InitEmptyProgram_unitContext(p *Program_unitContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_program_unit +} + +func (*Program_unitContext) IsProgram_unitContext() {} + +func NewProgram_unitContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Program_unitContext { + var p = new(Program_unitContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_program_unit + + return p +} + +func (s *Program_unitContext) GetParser() antlr.Parser { return s.parser } + +func (s *Program_unitContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Program_unitContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Program_unitContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Program_unitContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Program_unitContext) 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 *Program_unitContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Program_unitContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Program_unitContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Program_unitContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProgram_unit(s) + } +} + +func (s *Program_unitContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProgram_unit(s) + } +} + +func (s *Program_unitContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProgram_unit(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Program_unit() (localctx IProgram_unitContext) { + localctx = NewProgram_unitContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 776, PlSqlParserRULE_program_unit) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8307) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFUNCTION || _la == PlSqlParserPACKAGE || _la == PlSqlParserPROCEDURE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8311) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 880, p.GetParserRuleContext()) == 1 { + { + p.SetState(8308) + p.Schema_name() + } + { + p.SetState(8309) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8313) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_dimensionContext is an interface to support dynamic dispatch. +type ICreate_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + Identifier() IIdentifierContext + AllLevel_clause() []ILevel_clauseContext + Level_clause(i int) ILevel_clauseContext + AllHierarchy_clause() []IHierarchy_clauseContext + Hierarchy_clause(i int) IHierarchy_clauseContext + AllAttribute_clause() []IAttribute_clauseContext + Attribute_clause(i int) IAttribute_clauseContext + AllExtended_attribute_clause() []IExtended_attribute_clauseContext + Extended_attribute_clause(i int) IExtended_attribute_clauseContext + + // IsCreate_dimensionContext differentiates from other interfaces. + IsCreate_dimensionContext() +} + +type Create_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_dimensionContext() *Create_dimensionContext { + var p = new(Create_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_dimension + return p +} + +func InitEmptyCreate_dimensionContext(p *Create_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_dimension +} + +func (*Create_dimensionContext) IsCreate_dimensionContext() {} + +func NewCreate_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_dimensionContext { + var p = new(Create_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_dimension + + return p +} + +func (s *Create_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_dimensionContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Create_dimensionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Create_dimensionContext) AllLevel_clause() []ILevel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_clauseContext); ok { + len++ + } + } + + tst := make([]ILevel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_clauseContext); ok { + tst[i] = t.(ILevel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Level_clause(i int) ILevel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_clauseContext) +} + +func (s *Create_dimensionContext) AllHierarchy_clause() []IHierarchy_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + len++ + } + } + + tst := make([]IHierarchy_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHierarchy_clauseContext); ok { + tst[i] = t.(IHierarchy_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Hierarchy_clause(i int) IHierarchy_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHierarchy_clauseContext) +} + +func (s *Create_dimensionContext) AllAttribute_clause() []IAttribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_clauseContext); ok { + len++ + } + } + + tst := make([]IAttribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_clauseContext); ok { + tst[i] = t.(IAttribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Attribute_clause(i int) IAttribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clauseContext) +} + +func (s *Create_dimensionContext) AllExtended_attribute_clause() []IExtended_attribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + len++ + } + } + + tst := make([]IExtended_attribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtended_attribute_clauseContext); ok { + tst[i] = t.(IExtended_attribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_dimensionContext) Extended_attribute_clause(i int) IExtended_attribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtended_attribute_clauseContext) +} + +func (s *Create_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_dimension(s) + } +} + +func (s *Create_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_dimension(s) + } +} + +func (s *Create_dimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_dimension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_dimension() (localctx ICreate_dimensionContext) { + localctx = NewCreate_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 778, PlSqlParserRULE_create_dimension) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8315) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8316) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8317) + p.Identifier() + } + p.SetState(8319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEVEL { + { + p.SetState(8318) + p.Level_clause() + } + + p.SetState(8321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 882, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8323) + p.Hierarchy_clause() + } + + case 2: + { + p.SetState(8324) + p.Attribute_clause() + } + + case 3: + { + p.SetState(8325) + p.Extended_attribute_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8328) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 883, 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_directoryContext is an interface to support dynamic dispatch. +type ICreate_directoryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Directory_name() IDirectory_nameContext + AS() antlr.TerminalNode + Directory_path() IDirectory_pathContext + SEMICOLON() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_directoryContext differentiates from other interfaces. + IsCreate_directoryContext() +} + +type Create_directoryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_directoryContext() *Create_directoryContext { + var p = new(Create_directoryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_directory + return p +} + +func InitEmptyCreate_directoryContext(p *Create_directoryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_directory +} + +func (*Create_directoryContext) IsCreate_directoryContext() {} + +func NewCreate_directoryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_directoryContext { + var p = new(Create_directoryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_directory + + return p +} + +func (s *Create_directoryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_directoryContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_directoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Create_directoryContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Create_directoryContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_directoryContext) Directory_path() IDirectory_pathContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_pathContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_pathContext) +} + +func (s *Create_directoryContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_directoryContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_directoryContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_directoryContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_directoryContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_directoryContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_directoryContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_directoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_directoryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_directoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_directory(s) + } +} + +func (s *Create_directoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_directory(s) + } +} + +func (s *Create_directoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_directory(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_directory() (localctx ICreate_directoryContext) { + localctx = NewCreate_directoryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 780, PlSqlParserRULE_create_directory) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8330) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8331) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8332) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8335) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8336) + p.Directory_name() + } + p.SetState(8340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8337) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8338) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8339) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8342) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8343) + p.Directory_path() + } + { + p.SetState(8344) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDirectory_nameContext is an interface to support dynamic dispatch. +type IDirectory_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDirectory_nameContext differentiates from other interfaces. + IsDirectory_nameContext() +} + +type Directory_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_nameContext() *Directory_nameContext { + var p = new(Directory_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_name + return p +} + +func InitEmptyDirectory_nameContext(p *Directory_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_name +} + +func (*Directory_nameContext) IsDirectory_nameContext() {} + +func NewDirectory_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_nameContext { + var p = new(Directory_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_directory_name + + return p +} + +func (s *Directory_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Directory_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDirectory_name(s) + } +} + +func (s *Directory_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDirectory_name(s) + } +} + +func (s *Directory_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDirectory_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Directory_name() (localctx IDirectory_nameContext) { + localctx = NewDirectory_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 782, PlSqlParserRULE_directory_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8346) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDirectory_pathContext is an interface to support dynamic dispatch. +type IDirectory_pathContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsDirectory_pathContext differentiates from other interfaces. + IsDirectory_pathContext() +} + +type Directory_pathContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_pathContext() *Directory_pathContext { + var p = new(Directory_pathContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_path + return p +} + +func InitEmptyDirectory_pathContext(p *Directory_pathContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_path +} + +func (*Directory_pathContext) IsDirectory_pathContext() {} + +func NewDirectory_pathContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_pathContext { + var p = new(Directory_pathContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_directory_path + + return p +} + +func (s *Directory_pathContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_pathContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Directory_pathContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_pathContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_pathContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDirectory_path(s) + } +} + +func (s *Directory_pathContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDirectory_path(s) + } +} + +func (s *Directory_pathContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDirectory_path(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Directory_path() (localctx IDirectory_pathContext) { + localctx = NewDirectory_pathContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 784, PlSqlParserRULE_directory_path) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8348) + p.Match(PlSqlParserCHAR_STRING) + 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_inmemory_join_groupContext is an interface to support dynamic dispatch. +type ICreate_inmemory_join_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetJg returns the jg rule contexts. + GetJg() IId_expressionContext + + // GetT returns the t rule contexts. + GetT() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetJg sets the jg rule contexts. + SetJg(IId_expressionContext) + + // SetT sets the t rule contexts. + SetT(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + JOIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_inmemory_join_groupContext differentiates from other interfaces. + IsCreate_inmemory_join_groupContext() +} + +type Create_inmemory_join_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + jg IId_expressionContext + t IId_expressionContext + c IId_expressionContext +} + +func NewEmptyCreate_inmemory_join_groupContext() *Create_inmemory_join_groupContext { + var p = new(Create_inmemory_join_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group + return p +} + +func InitEmptyCreate_inmemory_join_groupContext(p *Create_inmemory_join_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group +} + +func (*Create_inmemory_join_groupContext) IsCreate_inmemory_join_groupContext() {} + +func NewCreate_inmemory_join_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_inmemory_join_groupContext { + var p = new(Create_inmemory_join_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_inmemory_join_group + + return p +} + +func (s *Create_inmemory_join_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_inmemory_join_groupContext) GetJg() IId_expressionContext { return s.jg } + +func (s *Create_inmemory_join_groupContext) GetT() IId_expressionContext { return s.t } + +func (s *Create_inmemory_join_groupContext) GetC() IId_expressionContext { return s.c } + +func (s *Create_inmemory_join_groupContext) SetJg(v IId_expressionContext) { s.jg = v } + +func (s *Create_inmemory_join_groupContext) SetT(v IId_expressionContext) { s.t = v } + +func (s *Create_inmemory_join_groupContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Create_inmemory_join_groupContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_inmemory_join_groupContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Create_inmemory_join_groupContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Create_inmemory_join_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Create_inmemory_join_groupContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_inmemory_join_groupContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_inmemory_join_groupContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_inmemory_join_groupContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_inmemory_join_groupContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_inmemory_join_groupContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_inmemory_join_groupContext) 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 *Create_inmemory_join_groupContext) 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 *Create_inmemory_join_groupContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Create_inmemory_join_groupContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Create_inmemory_join_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_inmemory_join_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_inmemory_join_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_inmemory_join_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_inmemory_join_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_inmemory_join_group(s) + } +} + +func (s *Create_inmemory_join_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_inmemory_join_group(s) + } +} + +func (s *Create_inmemory_join_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_inmemory_join_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_inmemory_join_group() (localctx ICreate_inmemory_join_groupContext) { + localctx = NewCreate_inmemory_join_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 786, PlSqlParserRULE_create_inmemory_join_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8350) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8351) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8352) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8353) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8357) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 886, p.GetParserRuleContext()) == 1 { + { + p.SetState(8354) + p.Schema_name() + } + { + p.SetState(8355) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8359) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).jg = _x + } + { + p.SetState(8360) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8364) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 887, p.GetParserRuleContext()) == 1 { + { + p.SetState(8361) + p.Schema_name() + } + { + p.SetState(8362) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8366) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).t = _x + } + { + p.SetState(8367) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8368) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).c = _x + } + { + p.SetState(8369) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(8370) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8374) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 888, p.GetParserRuleContext()) == 1 { + { + p.SetState(8371) + p.Schema_name() + } + { + p.SetState(8372) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8376) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).t = _x + } + { + p.SetState(8377) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8378) + + var _x = p.Id_expression() + + localctx.(*Create_inmemory_join_groupContext).c = _x + } + { + p.SetState(8379) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8385) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_hierarchyContext is an interface to support dynamic dispatch. +type IDrop_hierarchyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetHn returns the hn rule contexts. + GetHn() IId_expressionContext + + // SetHn sets the hn rule contexts. + SetHn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_hierarchyContext differentiates from other interfaces. + IsDrop_hierarchyContext() +} + +type Drop_hierarchyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + hn IId_expressionContext +} + +func NewEmptyDrop_hierarchyContext() *Drop_hierarchyContext { + var p = new(Drop_hierarchyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_hierarchy + return p +} + +func InitEmptyDrop_hierarchyContext(p *Drop_hierarchyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_hierarchy +} + +func (*Drop_hierarchyContext) IsDrop_hierarchyContext() {} + +func NewDrop_hierarchyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_hierarchyContext { + var p = new(Drop_hierarchyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_hierarchy + + return p +} + +func (s *Drop_hierarchyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_hierarchyContext) GetHn() IId_expressionContext { return s.hn } + +func (s *Drop_hierarchyContext) SetHn(v IId_expressionContext) { s.hn = v } + +func (s *Drop_hierarchyContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_hierarchyContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Drop_hierarchyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_hierarchyContext) 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_hierarchyContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_hierarchyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_hierarchyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_hierarchyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_hierarchy(s) + } +} + +func (s *Drop_hierarchyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_hierarchy(s) + } +} + +func (s *Drop_hierarchyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_hierarchy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_hierarchy() (localctx IDrop_hierarchyContext) { + localctx = NewDrop_hierarchyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 788, PlSqlParserRULE_drop_hierarchy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8387) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8388) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8392) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 890, p.GetParserRuleContext()) == 1 { + { + p.SetState(8389) + p.Schema_name() + } + { + p.SetState(8390) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8394) + + var _x = p.Id_expression() + + localctx.(*Drop_hierarchyContext).hn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_libraryContext is an interface to support dynamic dispatch. +type IAlter_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Library_name() ILibrary_nameContext + SEMICOLON() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Library_editionable() ILibrary_editionableContext + Library_debug() ILibrary_debugContext + AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext + Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext + REUSE() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + + // IsAlter_libraryContext differentiates from other interfaces. + IsAlter_libraryContext() +} + +type Alter_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_libraryContext() *Alter_libraryContext { + var p = new(Alter_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_library + return p +} + +func InitEmptyAlter_libraryContext(p *Alter_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_library +} + +func (*Alter_libraryContext) IsAlter_libraryContext() {} + +func NewAlter_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_libraryContext { + var p = new(Alter_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_library + + return p +} + +func (s *Alter_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_libraryContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Alter_libraryContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Alter_libraryContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_libraryContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_libraryContext) Library_editionable() ILibrary_editionableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_editionableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_editionableContext) +} + +func (s *Alter_libraryContext) Library_debug() ILibrary_debugContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_debugContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_debugContext) +} + +func (s *Alter_libraryContext) AllCompiler_parameters_clause() []ICompiler_parameters_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + len++ + } + } + + tst := make([]ICompiler_parameters_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompiler_parameters_clauseContext); ok { + tst[i] = t.(ICompiler_parameters_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_libraryContext) Compiler_parameters_clause(i int) ICompiler_parameters_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompiler_parameters_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompiler_parameters_clauseContext) +} + +func (s *Alter_libraryContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Alter_libraryContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Alter_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_library(s) + } +} + +func (s *Alter_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_library(s) + } +} + +func (s *Alter_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_library() (localctx IAlter_libraryContext) { + localctx = NewAlter_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 790, PlSqlParserRULE_alter_library) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8396) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8397) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8398) + p.Library_name() + } + p.SetState(8414) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 894, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8399) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8401) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 891, p.GetParserRuleContext()) == 1 { + { + p.SetState(8400) + p.Library_debug() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 892, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8403) + p.Compiler_parameters_clause() + } + + } + p.SetState(8408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 892, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(8411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(8409) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8410) + p.Match(PlSqlParserSETTINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + { + p.SetState(8413) + p.Library_editionable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8416) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDrop_javaContext is an interface to support dynamic dispatch. +type IDrop_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + JAVA() antlr.TerminalNode + Id_expression() IId_expressionContext + SOURCE() antlr.TerminalNode + CLASS() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_javaContext differentiates from other interfaces. + IsDrop_javaContext() +} + +type Drop_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_javaContext() *Drop_javaContext { + var p = new(Drop_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_java + return p +} + +func InitEmptyDrop_javaContext(p *Drop_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_java +} + +func (*Drop_javaContext) IsDrop_javaContext() {} + +func NewDrop_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_javaContext { + var p = new(Drop_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_java + + return p +} + +func (s *Drop_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_javaContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Drop_javaContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Drop_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Drop_javaContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Drop_javaContext) 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_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_java(s) + } +} + +func (s *Drop_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_java(s) + } +} + +func (s *Drop_javaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_java(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_java() (localctx IDrop_javaContext) { + localctx = NewDrop_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 792, PlSqlParserRULE_drop_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8418) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8419) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8420) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8424) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 895, p.GetParserRuleContext()) == 1 { + { + p.SetState(8421) + p.Schema_name() + } + { + p.SetState(8422) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8426) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_libraryContext is an interface to support dynamic dispatch. +type IDrop_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Library_name() ILibrary_nameContext + + // IsDrop_libraryContext differentiates from other interfaces. + IsDrop_libraryContext() +} + +type Drop_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_libraryContext() *Drop_libraryContext { + var p = new(Drop_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_library + return p +} + +func InitEmptyDrop_libraryContext(p *Drop_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_library +} + +func (*Drop_libraryContext) IsDrop_libraryContext() {} + +func NewDrop_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_libraryContext { + var p = new(Drop_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_library + + return p +} + +func (s *Drop_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_libraryContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Drop_libraryContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Drop_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_library(s) + } +} + +func (s *Drop_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_library(s) + } +} + +func (s *Drop_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_library() (localctx IDrop_libraryContext) { + localctx = NewDrop_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 794, PlSqlParserRULE_drop_library) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8428) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8429) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8430) + p.Library_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 +} + +// ICreate_javaContext is an interface to support dynamic dispatch. +type ICreate_javaContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPn returns the pn rule contexts. + GetPn() IId_expressionContext + + // GetSn returns the sn rule contexts. + GetSn() IId_expressionContext + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // SetPn sets the pn rule contexts. + SetPn(IId_expressionContext) + + // SetSn sets the sn rule contexts. + SetSn(IId_expressionContext) + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + JAVA() antlr.TerminalNode + NAMED() antlr.TerminalNode + CLASS() antlr.TerminalNode + USING() antlr.TerminalNode + AS() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AND() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Invoker_rights_clause() IInvoker_rights_clauseContext + RESOLVER() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RESOLVE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + BFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Filename() IFilenameContext + Subquery() ISubqueryContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + + // IsCreate_javaContext differentiates from other interfaces. + IsCreate_javaContext() +} + +type Create_javaContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pn IId_expressionContext + sn IId_expressionContext + d IId_expressionContext +} + +func NewEmptyCreate_javaContext() *Create_javaContext { + var p = new(Create_javaContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_java + return p +} + +func InitEmptyCreate_javaContext(p *Create_javaContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_java +} + +func (*Create_javaContext) IsCreate_javaContext() {} + +func NewCreate_javaContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_javaContext { + var p = new(Create_javaContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_java + + return p +} + +func (s *Create_javaContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_javaContext) GetPn() IId_expressionContext { return s.pn } + +func (s *Create_javaContext) GetSn() IId_expressionContext { return s.sn } + +func (s *Create_javaContext) GetD() IId_expressionContext { return s.d } + +func (s *Create_javaContext) SetPn(v IId_expressionContext) { s.pn = v } + +func (s *Create_javaContext) SetSn(v IId_expressionContext) { s.sn = v } + +func (s *Create_javaContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Create_javaContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_javaContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Create_javaContext) NAMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMED, 0) +} + +func (s *Create_javaContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Create_javaContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_javaContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_javaContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Create_javaContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Create_javaContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_javaContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_javaContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Create_javaContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Create_javaContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Create_javaContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Create_javaContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_javaContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_javaContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_javaContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_javaContext) Invoker_rights_clause() IInvoker_rights_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInvoker_rights_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInvoker_rights_clauseContext) +} + +func (s *Create_javaContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Create_javaContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_javaContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_javaContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_javaContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_javaContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Create_javaContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Create_javaContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_javaContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_javaContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Create_javaContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_javaContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_javaContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Create_javaContext) 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 *Create_javaContext) 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_javaContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_javaContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Create_javaContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Create_javaContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Create_javaContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *Create_javaContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *Create_javaContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_javaContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_javaContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_java(s) + } +} + +func (s *Create_javaContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_java(s) + } +} + +func (s *Create_javaContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_java(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_java() (localctx ICreate_javaContext) { + localctx = NewCreate_javaContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 796, PlSqlParserRULE_create_java) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8432) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8433) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8434) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(8437) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8438) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserRESOLVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(8442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOFORCE { + { + p.SetState(8441) + p.Match(PlSqlParserNOFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8444) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESOURCE, PlSqlParserSOURCE: + { + p.SetState(8445) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8446) + p.Match(PlSqlParserNAMED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8450) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 899, p.GetParserRuleContext()) == 1 { + { + p.SetState(8447) + p.Schema_name() + } + { + p.SetState(8448) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8452) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).pn = _x + } + + case PlSqlParserCLASS: + { + p.SetState(8453) + p.Match(PlSqlParserCLASS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSCHEMA { + { + p.SetState(8454) + p.Match(PlSqlParserSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8455) + p.Id_expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8460) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8461) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8462) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(8466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTHID { + { + p.SetState(8465) + p.Invoker_rights_clause() + } + + } + p.SetState(8485) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESOLVER { + { + p.SetState(8468) + p.Match(PlSqlParserRESOLVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8469) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8470) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8471) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8472) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(8475) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).sn = _x + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(8476) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(8479) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8484) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUSING: + { + p.SetState(8487) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 908, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8488) + p.Match(PlSqlParserBFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8489) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8490) + + var _x = p.Id_expression() + + localctx.(*Create_javaContext).d = _x + } + { + p.SetState(8491) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8492) + p.Filename() + } + { + p.SetState(8493) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(8495) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBFILE || _la == PlSqlParserBLOB || _la == PlSqlParserCLOB) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8496) + p.Subquery() + } + + case 3: + { + p.SetState(8497) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAS: + { + p.SetState(8500) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8501) + p.Match(PlSqlParserCHAR_STRING) + 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_libraryContext is an interface to support dynamic dispatch. +type ICreate_libraryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Plsql_library_source() IPlsql_library_sourceContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsCreate_libraryContext differentiates from other interfaces. + IsCreate_libraryContext() +} + +type Create_libraryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_libraryContext() *Create_libraryContext { + var p = new(Create_libraryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_library + return p +} + +func InitEmptyCreate_libraryContext(p *Create_libraryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_library +} + +func (*Create_libraryContext) IsCreate_libraryContext() {} + +func NewCreate_libraryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_libraryContext { + var p = new(Create_libraryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_library + + return p +} + +func (s *Create_libraryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_libraryContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_libraryContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Create_libraryContext) Plsql_library_source() IPlsql_library_sourceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPlsql_library_sourceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPlsql_library_sourceContext) +} + +func (s *Create_libraryContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_libraryContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_libraryContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Create_libraryContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Create_libraryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_libraryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_libraryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_library(s) + } +} + +func (s *Create_libraryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_library(s) + } +} + +func (s *Create_libraryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_library(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_library() (localctx ICreate_libraryContext) { + localctx = NewCreate_libraryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 798, PlSqlParserRULE_create_library) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8504) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8507) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8505) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8506) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(8509) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8512) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8513) + p.Plsql_library_source() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPlsql_library_sourceContext is an interface to support dynamic dispatch. +type IPlsql_library_sourceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Library_name() ILibrary_nameContext + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + IS() antlr.TerminalNode + AS() antlr.TerminalNode + IN() antlr.TerminalNode + Directory_name() IDirectory_nameContext + AGENT() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + Credential_name() ICredential_nameContext + + // IsPlsql_library_sourceContext differentiates from other interfaces. + IsPlsql_library_sourceContext() +} + +type Plsql_library_sourceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPlsql_library_sourceContext() *Plsql_library_sourceContext { + var p = new(Plsql_library_sourceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_plsql_library_source + return p +} + +func InitEmptyPlsql_library_sourceContext(p *Plsql_library_sourceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_plsql_library_source +} + +func (*Plsql_library_sourceContext) IsPlsql_library_sourceContext() {} + +func NewPlsql_library_sourceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Plsql_library_sourceContext { + var p = new(Plsql_library_sourceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_plsql_library_source + + return p +} + +func (s *Plsql_library_sourceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Plsql_library_sourceContext) Library_name() ILibrary_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILibrary_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILibrary_nameContext) +} + +func (s *Plsql_library_sourceContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *Plsql_library_sourceContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Plsql_library_sourceContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Plsql_library_sourceContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Plsql_library_sourceContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Plsql_library_sourceContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Plsql_library_sourceContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *Plsql_library_sourceContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREDENTIAL, 0) +} + +func (s *Plsql_library_sourceContext) Credential_name() ICredential_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICredential_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICredential_nameContext) +} + +func (s *Plsql_library_sourceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Plsql_library_sourceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Plsql_library_sourceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPlsql_library_source(s) + } +} + +func (s *Plsql_library_sourceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPlsql_library_source(s) + } +} + +func (s *Plsql_library_sourceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPlsql_library_source(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Plsql_library_source() (localctx IPlsql_library_sourceContext) { + localctx = NewPlsql_library_sourceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 800, PlSqlParserRULE_plsql_library_source) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8515) + p.Library_name() + } + { + p.SetState(8516) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAS || _la == PlSqlParserIS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(8517) + p.Quoted_string() + } + p.SetState(8520) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 912, p.GetParserRuleContext()) == 1 { + { + p.SetState(8518) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8519) + p.Directory_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8524) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 913, p.GetParserRuleContext()) == 1 { + { + p.SetState(8522) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8523) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8528) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 914, p.GetParserRuleContext()) == 1 { + { + p.SetState(8526) + p.Match(PlSqlParserCREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8527) + p.Credential_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 +} + +// ICredential_nameContext is an interface to support dynamic dispatch. +type ICredential_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + PERIOD() antlr.TerminalNode + + // IsCredential_nameContext differentiates from other interfaces. + IsCredential_nameContext() +} + +type Credential_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCredential_nameContext() *Credential_nameContext { + var p = new(Credential_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_credential_name + return p +} + +func InitEmptyCredential_nameContext(p *Credential_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_credential_name +} + +func (*Credential_nameContext) IsCredential_nameContext() {} + +func NewCredential_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Credential_nameContext { + var p = new(Credential_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_credential_name + + return p +} + +func (s *Credential_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Credential_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Credential_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Credential_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Credential_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Credential_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Credential_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCredential_name(s) + } +} + +func (s *Credential_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCredential_name(s) + } +} + +func (s *Credential_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCredential_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Credential_name() (localctx ICredential_nameContext) { + localctx = NewCredential_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 802, PlSqlParserRULE_credential_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(8533) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 915, p.GetParserRuleContext()) == 1 { + { + p.SetState(8530) + p.Id_expression() + } + { + p.SetState(8531) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8535) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILibrary_editionableContext is an interface to support dynamic dispatch. +type ILibrary_editionableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsLibrary_editionableContext differentiates from other interfaces. + IsLibrary_editionableContext() +} + +type Library_editionableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_editionableContext() *Library_editionableContext { + var p = new(Library_editionableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_editionable + return p +} + +func InitEmptyLibrary_editionableContext(p *Library_editionableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_editionable +} + +func (*Library_editionableContext) IsLibrary_editionableContext() {} + +func NewLibrary_editionableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_editionableContext { + var p = new(Library_editionableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_editionable + + return p +} + +func (s *Library_editionableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_editionableContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Library_editionableContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Library_editionableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_editionableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_editionableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_editionable(s) + } +} + +func (s *Library_editionableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_editionable(s) + } +} + +func (s *Library_editionableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLibrary_editionable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Library_editionable() (localctx ILibrary_editionableContext) { + localctx = NewLibrary_editionableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 804, PlSqlParserRULE_library_editionable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8537) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8538) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + 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 +} + +// ILibrary_debugContext is an interface to support dynamic dispatch. +type ILibrary_debugContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEBUG() antlr.TerminalNode + + // IsLibrary_debugContext differentiates from other interfaces. + IsLibrary_debugContext() +} + +type Library_debugContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_debugContext() *Library_debugContext { + var p = new(Library_debugContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_debug + return p +} + +func InitEmptyLibrary_debugContext(p *Library_debugContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_debug +} + +func (*Library_debugContext) IsLibrary_debugContext() {} + +func NewLibrary_debugContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_debugContext { + var p = new(Library_debugContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_debug + + return p +} + +func (s *Library_debugContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_debugContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Library_debugContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_debugContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_debugContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_debug(s) + } +} + +func (s *Library_debugContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_debug(s) + } +} + +func (s *Library_debugContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLibrary_debug(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Library_debug() (localctx ILibrary_debugContext) { + localctx = NewLibrary_debugContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 806, PlSqlParserRULE_library_debug) + p.EnterOuterAlt(localctx, 1) + p.SetState(8540) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8541) + p.Match(PlSqlParserDEBUG) + 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 +} + +// ICompiler_parameters_clauseContext is an interface to support dynamic dispatch. +type ICompiler_parameters_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + EQUALS_OP() antlr.TerminalNode + Parameter_value() IParameter_valueContext + + // IsCompiler_parameters_clauseContext differentiates from other interfaces. + IsCompiler_parameters_clauseContext() +} + +type Compiler_parameters_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCompiler_parameters_clauseContext() *Compiler_parameters_clauseContext { + var p = new(Compiler_parameters_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause + return p +} + +func InitEmptyCompiler_parameters_clauseContext(p *Compiler_parameters_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause +} + +func (*Compiler_parameters_clauseContext) IsCompiler_parameters_clauseContext() {} + +func NewCompiler_parameters_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compiler_parameters_clauseContext { + var p = new(Compiler_parameters_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compiler_parameters_clause + + return p +} + +func (s *Compiler_parameters_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compiler_parameters_clauseContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Compiler_parameters_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Compiler_parameters_clauseContext) Parameter_value() IParameter_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_valueContext) +} + +func (s *Compiler_parameters_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compiler_parameters_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compiler_parameters_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompiler_parameters_clause(s) + } +} + +func (s *Compiler_parameters_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompiler_parameters_clause(s) + } +} + +func (s *Compiler_parameters_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompiler_parameters_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compiler_parameters_clause() (localctx ICompiler_parameters_clauseContext) { + localctx = NewCompiler_parameters_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 808, PlSqlParserRULE_compiler_parameters_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8543) + p.Parameter_name() + } + { + p.SetState(8544) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8545) + p.Parameter_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 +} + +// IParameter_valueContext is an interface to support dynamic dispatch. +type IParameter_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + CHAR_STRING() antlr.TerminalNode + + // IsParameter_valueContext differentiates from other interfaces. + IsParameter_valueContext() +} + +type Parameter_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_valueContext() *Parameter_valueContext { + var p = new(Parameter_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_value + return p +} + +func InitEmptyParameter_valueContext(p *Parameter_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_value +} + +func (*Parameter_valueContext) IsParameter_valueContext() {} + +func NewParameter_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_valueContext { + var p = new(Parameter_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_value + + return p +} + +func (s *Parameter_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_valueContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Parameter_valueContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Parameter_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_value(s) + } +} + +func (s *Parameter_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_value(s) + } +} + +func (s *Parameter_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParameter_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parameter_value() (localctx IParameter_valueContext) { + localctx = NewParameter_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 810, PlSqlParserRULE_parameter_value) + p.SetState(8549) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8547) + p.Regular_id() + } + + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8548) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// ILibrary_nameContext is an interface to support dynamic dispatch. +type ILibrary_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + PERIOD() antlr.TerminalNode + + // IsLibrary_nameContext differentiates from other interfaces. + IsLibrary_nameContext() +} + +type Library_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLibrary_nameContext() *Library_nameContext { + var p = new(Library_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_name + return p +} + +func InitEmptyLibrary_nameContext(p *Library_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_library_name +} + +func (*Library_nameContext) IsLibrary_nameContext() {} + +func NewLibrary_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Library_nameContext { + var p = new(Library_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_library_name + + return p +} + +func (s *Library_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Library_nameContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Library_nameContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Library_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Library_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Library_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Library_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLibrary_name(s) + } +} + +func (s *Library_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLibrary_name(s) + } +} + +func (s *Library_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLibrary_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Library_name() (localctx ILibrary_nameContext) { + localctx = NewLibrary_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 812, PlSqlParserRULE_library_name) + p.EnterOuterAlt(localctx, 1) + p.SetState(8554) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 917, p.GetParserRuleContext()) == 1 { + { + p.SetState(8551) + p.Regular_id() + } + { + p.SetState(8552) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8556) + p.Regular_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 +} + +// IAlter_dimensionContext is an interface to support dynamic dispatch. +type IAlter_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + COMPILE() antlr.TerminalNode + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + AllLevel_clause() []ILevel_clauseContext + Level_clause(i int) ILevel_clauseContext + AllHierarchy_clause() []IHierarchy_clauseContext + Hierarchy_clause(i int) IHierarchy_clauseContext + AllAttribute_clause() []IAttribute_clauseContext + Attribute_clause(i int) IAttribute_clauseContext + AllExtended_attribute_clause() []IExtended_attribute_clauseContext + Extended_attribute_clause(i int) IExtended_attribute_clauseContext + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + AllHIERARCHY() []antlr.TerminalNode + HIERARCHY(i int) antlr.TerminalNode + AllATTRIBUTE() []antlr.TerminalNode + ATTRIBUTE(i int) antlr.TerminalNode + AllRESTRICT() []antlr.TerminalNode + RESTRICT(i int) antlr.TerminalNode + AllCASCADE() []antlr.TerminalNode + CASCADE(i int) antlr.TerminalNode + AllCOLUMN() []antlr.TerminalNode + COLUMN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_dimensionContext differentiates from other interfaces. + IsAlter_dimensionContext() +} + +type Alter_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_dimensionContext() *Alter_dimensionContext { + var p = new(Alter_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_dimension + return p +} + +func InitEmptyAlter_dimensionContext(p *Alter_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_dimension +} + +func (*Alter_dimensionContext) IsAlter_dimensionContext() {} + +func NewAlter_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_dimensionContext { + var p = new(Alter_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_dimension + + return p +} + +func (s *Alter_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_dimensionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Alter_dimensionContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Alter_dimensionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_dimensionContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserADD) +} + +func (s *Alter_dimensionContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, i) +} + +func (s *Alter_dimensionContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Alter_dimensionContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Alter_dimensionContext) AllLevel_clause() []ILevel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevel_clauseContext); ok { + len++ + } + } + + tst := make([]ILevel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevel_clauseContext); ok { + tst[i] = t.(ILevel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Level_clause(i int) ILevel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevel_clauseContext) +} + +func (s *Alter_dimensionContext) AllHierarchy_clause() []IHierarchy_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + len++ + } + } + + tst := make([]IHierarchy_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IHierarchy_clauseContext); ok { + tst[i] = t.(IHierarchy_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Hierarchy_clause(i int) IHierarchy_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchy_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IHierarchy_clauseContext) +} + +func (s *Alter_dimensionContext) AllAttribute_clause() []IAttribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAttribute_clauseContext); ok { + len++ + } + } + + tst := make([]IAttribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAttribute_clauseContext); ok { + tst[i] = t.(IAttribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Attribute_clause(i int) IAttribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clauseContext) +} + +func (s *Alter_dimensionContext) AllExtended_attribute_clause() []IExtended_attribute_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + len++ + } + } + + tst := make([]IExtended_attribute_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtended_attribute_clauseContext); ok { + tst[i] = t.(IExtended_attribute_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_dimensionContext) Extended_attribute_clause(i int) IExtended_attribute_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtended_attribute_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtended_attribute_clauseContext) +} + +func (s *Alter_dimensionContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Alter_dimensionContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Alter_dimensionContext) AllHIERARCHY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHIERARCHY) +} + +func (s *Alter_dimensionContext) HIERARCHY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, i) +} + +func (s *Alter_dimensionContext) AllATTRIBUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserATTRIBUTE) +} + +func (s *Alter_dimensionContext) ATTRIBUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, i) +} + +func (s *Alter_dimensionContext) AllRESTRICT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRESTRICT) +} + +func (s *Alter_dimensionContext) RESTRICT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT, i) +} + +func (s *Alter_dimensionContext) AllCASCADE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASCADE) +} + +func (s *Alter_dimensionContext) CASCADE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, i) +} + +func (s *Alter_dimensionContext) AllCOLUMN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLUMN) +} + +func (s *Alter_dimensionContext) COLUMN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, i) +} + +func (s *Alter_dimensionContext) 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_dimensionContext) 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_dimensionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_dimensionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_dimension(s) + } +} + +func (s *Alter_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_dimension(s) + } +} + +func (s *Alter_dimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_dimension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_dimension() (localctx IAlter_dimensionContext) { + localctx = NewAlter_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 814, PlSqlParserRULE_alter_dimension) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8558) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8559) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8560) + p.Identifier() + } + p.SetState(8605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.SetState(8568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8561) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 918, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8562) + p.Level_clause() + } + + case 2: + { + p.SetState(8563) + p.Hierarchy_clause() + } + + case 3: + { + p.SetState(8564) + p.Attribute_clause() + } + + case 4: + { + p.SetState(8565) + p.Extended_attribute_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8570) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 919, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDROP: + p.SetState(8600) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8572) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEVEL: + { + p.SetState(8573) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8574) + p.Identifier() + } + p.SetState(8576) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 920, p.GetParserRuleContext()) == 1 { + { + p.SetState(8575) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCASCADE || _la == PlSqlParserRESTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserHIERARCHY: + { + p.SetState(8578) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8579) + p.Identifier() + } + + case PlSqlParserATTRIBUTE: + { + p.SetState(8580) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8581) + p.Identifier() + } + p.SetState(8596) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 923, p.GetParserRuleContext()) == 1 { + { + p.SetState(8582) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8583) + p.Identifier() + } + p.SetState(8594) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 922, p.GetParserRuleContext()) == 1 { + { + p.SetState(8584) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8585) + p.Column_name() + } + p.SetState(8591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8586) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8587) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8588) + p.Column_name() + } + + } + p.SetState(8593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 921, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + 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 + } + + p.SetState(8602) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 925, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(8604) + p.Match(PlSqlParserCOMPILE) + 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 +} + +// ILevel_clauseContext is an interface to support dynamic dispatch. +type ILevel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEVEL() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + AllTable_name() []ITable_nameContext + Table_name(i int) ITable_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SKIP_() antlr.TerminalNode + WHEN() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLevel_clauseContext differentiates from other interfaces. + IsLevel_clauseContext() +} + +type Level_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLevel_clauseContext() *Level_clauseContext { + var p = new(Level_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_clause + return p +} + +func InitEmptyLevel_clauseContext(p *Level_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_level_clause +} + +func (*Level_clauseContext) IsLevel_clauseContext() {} + +func NewLevel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Level_clauseContext { + var p = new(Level_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_level_clause + + return p +} + +func (s *Level_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Level_clauseContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Level_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Level_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Level_clauseContext) AllTable_name() []ITable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_nameContext); ok { + len++ + } + } + + tst := make([]ITable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_nameContext); ok { + tst[i] = t.(ITable_nameContext) + i++ + } + } + + return tst +} + +func (s *Level_clauseContext) Table_name(i int) ITable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Level_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Level_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Level_clauseContext) 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 *Level_clauseContext) 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 *Level_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Level_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Level_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Level_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Level_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Level_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Level_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Level_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Level_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Level_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevel_clause(s) + } +} + +func (s *Level_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevel_clause(s) + } +} + +func (s *Level_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevel_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Level_clause() (localctx ILevel_clauseContext) { + localctx = NewLevel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 816, PlSqlParserRULE_level_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8607) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8608) + p.Identifier() + } + { + p.SetState(8609) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(8610) + p.Table_name() + } + { + p.SetState(8611) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8612) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(8614) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8615) + p.Table_name() + } + { + p.SetState(8616) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8617) + p.Column_name() + } + p.SetState(8625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8618) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8619) + p.Table_name() + } + { + p.SetState(8620) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8621) + p.Column_name() + } + + p.SetState(8627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8628) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8635) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 929, p.GetParserRuleContext()) == 1 { + { + p.SetState(8632) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8633) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8634) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchy_clauseContext is an interface to support dynamic dispatch. +type IHierarchy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HIERARCHY() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCHILD() []antlr.TerminalNode + CHILD(i int) antlr.TerminalNode + AllOF() []antlr.TerminalNode + OF(i int) antlr.TerminalNode + Dimension_join_clause() IDimension_join_clauseContext + + // IsHierarchy_clauseContext differentiates from other interfaces. + IsHierarchy_clauseContext() +} + +type Hierarchy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHierarchy_clauseContext() *Hierarchy_clauseContext { + var p = new(Hierarchy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchy_clause + return p +} + +func InitEmptyHierarchy_clauseContext(p *Hierarchy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchy_clause +} + +func (*Hierarchy_clauseContext) IsHierarchy_clauseContext() {} + +func NewHierarchy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchy_clauseContext { + var p = new(Hierarchy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hierarchy_clause + + return p +} + +func (s *Hierarchy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchy_clauseContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Hierarchy_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Hierarchy_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Hierarchy_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hierarchy_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hierarchy_clauseContext) AllCHILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHILD) +} + +func (s *Hierarchy_clauseContext) CHILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, i) +} + +func (s *Hierarchy_clauseContext) AllOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOF) +} + +func (s *Hierarchy_clauseContext) OF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, i) +} + +func (s *Hierarchy_clauseContext) Dimension_join_clause() IDimension_join_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDimension_join_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDimension_join_clauseContext) +} + +func (s *Hierarchy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHierarchy_clause(s) + } +} + +func (s *Hierarchy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHierarchy_clause(s) + } +} + +func (s *Hierarchy_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHierarchy_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hierarchy_clause() (localctx IHierarchy_clauseContext) { + localctx = NewHierarchy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 818, PlSqlParserRULE_hierarchy_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8637) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8638) + p.Identifier() + } + { + p.SetState(8639) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8640) + p.Identifier() + } + p.SetState(8644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHILD { + { + p.SetState(8641) + p.Match(PlSqlParserCHILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8642) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8643) + p.Identifier() + } + + p.SetState(8646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(8649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserJOIN { + { + p.SetState(8648) + p.Dimension_join_clause() + } + + } + { + p.SetState(8651) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDimension_join_clauseContext is an interface to support dynamic dispatch. +type IDimension_join_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJOIN() []antlr.TerminalNode + JOIN(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + AllREFERENCES() []antlr.TerminalNode + REFERENCES(i int) antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + + // IsDimension_join_clauseContext differentiates from other interfaces. + IsDimension_join_clauseContext() +} + +type Dimension_join_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDimension_join_clauseContext() *Dimension_join_clauseContext { + var p = new(Dimension_join_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dimension_join_clause + return p +} + +func InitEmptyDimension_join_clauseContext(p *Dimension_join_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dimension_join_clause +} + +func (*Dimension_join_clauseContext) IsDimension_join_clauseContext() {} + +func NewDimension_join_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dimension_join_clauseContext { + var p = new(Dimension_join_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dimension_join_clause + + return p +} + +func (s *Dimension_join_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dimension_join_clauseContext) AllJOIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserJOIN) +} + +func (s *Dimension_join_clauseContext) JOIN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, i) +} + +func (s *Dimension_join_clauseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Dimension_join_clauseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Dimension_join_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Dimension_join_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Dimension_join_clauseContext) AllREFERENCES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREFERENCES) +} + +func (s *Dimension_join_clauseContext) REFERENCES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, i) +} + +func (s *Dimension_join_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Dimension_join_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dimension_join_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dimension_join_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dimension_join_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDimension_join_clause(s) + } +} + +func (s *Dimension_join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDimension_join_clause(s) + } +} + +func (s *Dimension_join_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDimension_join_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dimension_join_clause() (localctx IDimension_join_clauseContext) { + localctx = NewDimension_join_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 820, PlSqlParserRULE_dimension_join_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserJOIN { + { + p.SetState(8653) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8654) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8655) + p.Column_one_or_more_sub_clause() + } + { + p.SetState(8656) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8657) + p.Identifier() + } + + p.SetState(8661) + 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 +} + +// IAttribute_clauseContext is an interface to support dynamic dispatch. +type IAttribute_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllATTRIBUTE() []antlr.TerminalNode + ATTRIBUTE(i int) antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllDETERMINES() []antlr.TerminalNode + DETERMINES(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + + // IsAttribute_clauseContext differentiates from other interfaces. + IsAttribute_clauseContext() +} + +type Attribute_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_clauseContext() *Attribute_clauseContext { + var p = new(Attribute_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clause + return p +} + +func InitEmptyAttribute_clauseContext(p *Attribute_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clause +} + +func (*Attribute_clauseContext) IsAttribute_clauseContext() {} + +func NewAttribute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_clauseContext { + var p = new(Attribute_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_clause + + return p +} + +func (s *Attribute_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_clauseContext) AllATTRIBUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserATTRIBUTE) +} + +func (s *Attribute_clauseContext) ATTRIBUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, i) +} + +func (s *Attribute_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Attribute_clauseContext) AllDETERMINES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINES) +} + +func (s *Attribute_clauseContext) DETERMINES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, i) +} + +func (s *Attribute_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Attribute_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_clause(s) + } +} + +func (s *Attribute_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_clause(s) + } +} + +func (s *Attribute_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAttribute_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Attribute_clause() (localctx IAttribute_clauseContext) { + localctx = NewAttribute_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 822, PlSqlParserRULE_attribute_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8663) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8664) + p.Identifier() + } + { + p.SetState(8665) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8666) + p.Column_one_or_more_sub_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8670) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 933, 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 +} + +// IExtended_attribute_clauseContext is an interface to support dynamic dispatch. +type IExtended_attribute_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ATTRIBUTE() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllLEVEL() []antlr.TerminalNode + LEVEL(i int) antlr.TerminalNode + AllDETERMINES() []antlr.TerminalNode + DETERMINES(i int) antlr.TerminalNode + AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext + Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext + + // IsExtended_attribute_clauseContext differentiates from other interfaces. + IsExtended_attribute_clauseContext() +} + +type Extended_attribute_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtended_attribute_clauseContext() *Extended_attribute_clauseContext { + var p = new(Extended_attribute_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause + return p +} + +func InitEmptyExtended_attribute_clauseContext(p *Extended_attribute_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause +} + +func (*Extended_attribute_clauseContext) IsExtended_attribute_clauseContext() {} + +func NewExtended_attribute_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extended_attribute_clauseContext { + var p = new(Extended_attribute_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_extended_attribute_clause + + return p +} + +func (s *Extended_attribute_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extended_attribute_clauseContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Extended_attribute_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Extended_attribute_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Extended_attribute_clauseContext) AllLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEVEL) +} + +func (s *Extended_attribute_clauseContext) LEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, i) +} + +func (s *Extended_attribute_clauseContext) AllDETERMINES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDETERMINES) +} + +func (s *Extended_attribute_clauseContext) DETERMINES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, i) +} + +func (s *Extended_attribute_clauseContext) AllColumn_one_or_more_sub_clause() []IColumn_one_or_more_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_one_or_more_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + tst[i] = t.(IColumn_one_or_more_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Extended_attribute_clauseContext) Column_one_or_more_sub_clause(i int) IColumn_one_or_more_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_one_or_more_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_one_or_more_sub_clauseContext) +} + +func (s *Extended_attribute_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extended_attribute_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extended_attribute_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExtended_attribute_clause(s) + } +} + +func (s *Extended_attribute_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExtended_attribute_clause(s) + } +} + +func (s *Extended_attribute_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExtended_attribute_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Extended_attribute_clause() (localctx IExtended_attribute_clauseContext) { + localctx = NewExtended_attribute_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 824, PlSqlParserRULE_extended_attribute_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8672) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8673) + p.Identifier() + } + p.SetState(8679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(8674) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8675) + p.Identifier() + } + { + p.SetState(8676) + p.Match(PlSqlParserDETERMINES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8677) + p.Column_one_or_more_sub_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8681) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 934, 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 +} + +// IColumn_one_or_more_sub_clauseContext is an interface to support dynamic dispatch. +type IColumn_one_or_more_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_one_or_more_sub_clauseContext differentiates from other interfaces. + IsColumn_one_or_more_sub_clauseContext() +} + +type Column_one_or_more_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_one_or_more_sub_clauseContext() *Column_one_or_more_sub_clauseContext { + var p = new(Column_one_or_more_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause + return p +} + +func InitEmptyColumn_one_or_more_sub_clauseContext(p *Column_one_or_more_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause +} + +func (*Column_one_or_more_sub_clauseContext) IsColumn_one_or_more_sub_clauseContext() {} + +func NewColumn_one_or_more_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_one_or_more_sub_clauseContext { + var p = new(Column_one_or_more_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_one_or_more_sub_clause + + return p +} + +func (s *Column_one_or_more_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_one_or_more_sub_clauseContext) 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_one_or_more_sub_clauseContext) 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_one_or_more_sub_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Column_one_or_more_sub_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Column_one_or_more_sub_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_one_or_more_sub_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_one_or_more_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_one_or_more_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_one_or_more_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_one_or_more_sub_clause(s) + } +} + +func (s *Column_one_or_more_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_one_or_more_sub_clause(s) + } +} + +func (s *Column_one_or_more_sub_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_one_or_more_sub_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_one_or_more_sub_clause() (localctx IColumn_one_or_more_sub_clauseContext) { + localctx = NewColumn_one_or_more_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 826, PlSqlParserRULE_column_one_or_more_sub_clause) + var _la int + + p.SetState(8695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8683) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8684) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8685) + p.Column_name() + } + p.SetState(8690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8686) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8687) + p.Column_name() + } + + p.SetState(8692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8693) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + ADD() antlr.TerminalNode + Out_of_line_constraint() IOut_of_line_constraintContext + MODIFY() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + DROP() antlr.TerminalNode + COMPILE() antlr.TerminalNode + READ() antlr.TerminalNode + RELY() antlr.TerminalNode + NORELY() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Alter_view_editionable() IAlter_view_editionableContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) 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 = PlSqlParserRULE_alter_view + return p +} + +func InitEmptyAlter_viewContext(p *Alter_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_view + + return p +} + +func (s *Alter_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_viewContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_viewContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_viewContext) 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 *Alter_viewContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_viewContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Alter_viewContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Alter_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_viewContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Alter_viewContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Alter_viewContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Alter_viewContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Alter_viewContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Alter_viewContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Alter_viewContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Alter_viewContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Alter_viewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_viewContext) 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_viewContext) 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_viewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_viewContext) Alter_view_editionable() IAlter_view_editionableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_view_editionableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_view_editionableContext) +} + +func (s *Alter_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_view(s) + } +} + +func (s *Alter_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_view(s) + } +} + +func (s *Alter_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_view() (localctx IAlter_viewContext) { + localctx = NewAlter_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 828, PlSqlParserRULE_alter_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8697) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8698) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8699) + p.Tableview_name() + } + p.SetState(8732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 940, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8700) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8701) + p.Out_of_line_constraint() + } + + case 2: + { + p.SetState(8702) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8703) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8704) + p.Constraint_name() + } + { + p.SetState(8705) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + { + p.SetState(8707) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8724) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONSTRAINT: + { + p.SetState(8708) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8709) + p.Constraint_name() + } + + case PlSqlParserPRIMARY: + { + p.SetState(8710) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8711) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(8712) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8713) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8714) + p.Column_name() + } + p.SetState(8719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8715) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8716) + p.Column_name() + } + + p.SetState(8721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8722) + p.Match(PlSqlParserRIGHT_PAREN) + 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.SetState(8726) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(8727) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8728) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 6: + p.SetState(8730) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 939, p.GetParserRuleContext()) == 1 { + { + p.SetState(8729) + p.Alter_view_editionable() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(8734) + p.Match(PlSqlParserSEMICOLON) + 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_view_editionableContext is an interface to support dynamic dispatch. +type IAlter_view_editionableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsAlter_view_editionableContext differentiates from other interfaces. + IsAlter_view_editionableContext() +} + +type Alter_view_editionableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_view_editionableContext() *Alter_view_editionableContext { + var p = new(Alter_view_editionableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view_editionable + return p +} + +func InitEmptyAlter_view_editionableContext(p *Alter_view_editionableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_view_editionable +} + +func (*Alter_view_editionableContext) IsAlter_view_editionableContext() {} + +func NewAlter_view_editionableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_view_editionableContext { + var p = new(Alter_view_editionableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_view_editionable + + return p +} + +func (s *Alter_view_editionableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_view_editionableContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Alter_view_editionableContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Alter_view_editionableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_view_editionableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_view_editionableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_view_editionable(s) + } +} + +func (s *Alter_view_editionableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_view_editionable(s) + } +} + +func (s *Alter_view_editionableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_view_editionable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_view_editionable() (localctx IAlter_view_editionableContext) { + localctx = NewAlter_view_editionableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 830, PlSqlParserRULE_alter_view_editionable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8736) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(8737) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + 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_viewContext is an interface to support dynamic dispatch. +type ICreate_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetV returns the v rule contexts. + GetV() IId_expressionContext + + // GetCn returns the cn rule contexts. + GetCn() IId_expressionContext + + // SetV sets the v rule contexts. + SetV(IId_expressionContext) + + // SetCn sets the cn rule contexts. + SetCn(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + VIEW() antlr.TerminalNode + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FORCE() antlr.TerminalNode + Editioning_clause() IEditioning_clauseContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + View_options() IView_optionsContext + DEFAULT() antlr.TerminalNode + COLLATION() antlr.TerminalNode + BEQUEATH() antlr.TerminalNode + Subquery_restriction_clause() ISubquery_restriction_clauseContext + CURRENT_USER() antlr.TerminalNode + DEFINER() antlr.TerminalNode + CONTAINER_MAP() antlr.TerminalNode + CONTAINERS_DEFAULT() antlr.TerminalNode + METADATA() antlr.TerminalNode + DATA() antlr.TerminalNode + NONE() antlr.TerminalNode + NO() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + + // IsCreate_viewContext differentiates from other interfaces. + IsCreate_viewContext() +} + +type Create_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + v IId_expressionContext + cn IId_expressionContext +} + +func NewEmptyCreate_viewContext() *Create_viewContext { + var p = new(Create_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_view + return p +} + +func InitEmptyCreate_viewContext(p *Create_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_view + + return p +} + +func (s *Create_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_viewContext) GetV() IId_expressionContext { return s.v } + +func (s *Create_viewContext) GetCn() IId_expressionContext { return s.cn } + +func (s *Create_viewContext) SetV(v IId_expressionContext) { s.v = v } + +func (s *Create_viewContext) SetCn(v IId_expressionContext) { s.cn = v } + +func (s *Create_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_viewContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_viewContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Create_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_viewContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_viewContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_viewContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Create_viewContext) Editioning_clause() IEditioning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEditioning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEditioning_clauseContext) +} + +func (s *Create_viewContext) 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_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_viewContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_viewContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_viewContext) View_options() IView_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IView_optionsContext) +} + +func (s *Create_viewContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Create_viewContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Create_viewContext) BEQUEATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEQUEATH, 0) +} + +func (s *Create_viewContext) Subquery_restriction_clause() ISubquery_restriction_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_restriction_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_restriction_clauseContext) +} + +func (s *Create_viewContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Create_viewContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Create_viewContext) CONTAINER_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_MAP, 0) +} + +func (s *Create_viewContext) CONTAINERS_DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS_DEFAULT, 0) +} + +func (s *Create_viewContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_viewContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_viewContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_viewContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_viewContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_view(s) + } +} + +func (s *Create_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_view(s) + } +} + +func (s *Create_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_view() (localctx ICreate_viewContext) { + localctx = NewCreate_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 832, PlSqlParserRULE_create_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8739) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(8740) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8741) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8748) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE || _la == PlSqlParserNO { + p.SetState(8745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(8744) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8747) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONABLE || _la == PlSqlParserEDITIONING || _la == PlSqlParserNONEDITIONABLE { + { + p.SetState(8750) + p.Editioning_clause() + } + + } + { + p.SetState(8753) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8757) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 945, p.GetParserRuleContext()) == 1 { + { + p.SetState(8754) + p.Schema_name() + } + { + p.SetState(8755) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8759) + + var _x = p.Id_expression() + + localctx.(*Create_viewContext).v = _x + } + p.SetState(8770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(8760) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8761) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMETADATA: + { + p.SetState(8762) + p.Match(PlSqlParserMETADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATA, PlSqlParserEXTENDED: + p.SetState(8764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENDED { + { + p.SetState(8763) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8766) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(8767) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(8773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8772) + p.View_options() + } + + } + p.SetState(8778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(8775) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8776) + p.Match(PlSqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8777) + + var _x = p.Id_expression() + + localctx.(*Create_viewContext).cn = _x + } + + } + p.SetState(8782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBEQUEATH { + { + p.SetState(8780) + p.Match(PlSqlParserBEQUEATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8781) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT_USER || _la == PlSqlParserDEFINER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(8784) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8785) + p.Select_only_statement() + } + p.SetState(8787) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 952, p.GetParserRuleContext()) == 1 { + { + p.SetState(8786) + p.Subquery_restriction_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(8790) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 953, p.GetParserRuleContext()) == 1 { + { + p.SetState(8789) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTAINERS_DEFAULT || _la == PlSqlParserCONTAINER_MAP) { + 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 +} + +// IEditioning_clauseContext is an interface to support dynamic dispatch. +type IEditioning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EDITIONING() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + + // IsEditioning_clauseContext differentiates from other interfaces. + IsEditioning_clauseContext() +} + +type Editioning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEditioning_clauseContext() *Editioning_clauseContext { + var p = new(Editioning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_editioning_clause + return p +} + +func InitEmptyEditioning_clauseContext(p *Editioning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_editioning_clause +} + +func (*Editioning_clauseContext) IsEditioning_clauseContext() {} + +func NewEditioning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Editioning_clauseContext { + var p = new(Editioning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_editioning_clause + + return p +} + +func (s *Editioning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Editioning_clauseContext) EDITIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONING, 0) +} + +func (s *Editioning_clauseContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Editioning_clauseContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Editioning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Editioning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Editioning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEditioning_clause(s) + } +} + +func (s *Editioning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEditioning_clause(s) + } +} + +func (s *Editioning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEditioning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Editioning_clause() (localctx IEditioning_clauseContext) { + localctx = NewEditioning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 834, PlSqlParserRULE_editioning_clause) + var _la int + + p.SetState(8798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEDITIONING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8792) + p.Match(PlSqlParserEDITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITIONABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8793) + p.Match(PlSqlParserEDITIONABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8795) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEDITIONING { + { + p.SetState(8794) + p.Match(PlSqlParserEDITIONING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNONEDITIONABLE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8797) + p.Match(PlSqlParserNONEDITIONABLE) + 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 +} + +// IView_optionsContext is an interface to support dynamic dispatch. +type IView_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + View_alias_constraint() IView_alias_constraintContext + Object_view_clause() IObject_view_clauseContext + Xmltype_view_clause() IXmltype_view_clauseContext + + // IsView_optionsContext differentiates from other interfaces. + IsView_optionsContext() +} + +type View_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_optionsContext() *View_optionsContext { + var p = new(View_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_options + return p +} + +func InitEmptyView_optionsContext(p *View_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_options +} + +func (*View_optionsContext) IsView_optionsContext() {} + +func NewView_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_optionsContext { + var p = new(View_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_view_options + + return p +} + +func (s *View_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_optionsContext) View_alias_constraint() IView_alias_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IView_alias_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IView_alias_constraintContext) +} + +func (s *View_optionsContext) Object_view_clause() IObject_view_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_view_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_view_clauseContext) +} + +func (s *View_optionsContext) Xmltype_view_clause() IXmltype_view_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_view_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_view_clauseContext) +} + +func (s *View_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterView_options(s) + } +} + +func (s *View_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitView_options(s) + } +} + +func (s *View_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitView_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) View_options() (localctx IView_optionsContext) { + localctx = NewView_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 836, PlSqlParserRULE_view_options) + p.SetState(8803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 956, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8800) + p.View_alias_constraint() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8801) + p.Object_view_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(8802) + p.Xmltype_view_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 +} + +// IView_alias_constraintContext is an interface to support dynamic dispatch. +type IView_alias_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllTable_alias() []ITable_aliasContext + Table_alias(i int) ITable_aliasContext + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsView_alias_constraintContext differentiates from other interfaces. + IsView_alias_constraintContext() +} + +type View_alias_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyView_alias_constraintContext() *View_alias_constraintContext { + var p = new(View_alias_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_alias_constraint + return p +} + +func InitEmptyView_alias_constraintContext(p *View_alias_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_view_alias_constraint +} + +func (*View_alias_constraintContext) IsView_alias_constraintContext() {} + +func NewView_alias_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *View_alias_constraintContext { + var p = new(View_alias_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_view_alias_constraint + + return p +} + +func (s *View_alias_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *View_alias_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *View_alias_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *View_alias_constraintContext) AllTable_alias() []ITable_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_aliasContext); ok { + len++ + } + } + + tst := make([]ITable_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_aliasContext); ok { + tst[i] = t.(ITable_aliasContext) + i++ + } + } + + return tst +} + +func (s *View_alias_constraintContext) Table_alias(i int) ITable_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *View_alias_constraintContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *View_alias_constraintContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *View_alias_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *View_alias_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *View_alias_constraintContext) 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 *View_alias_constraintContext) 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 *View_alias_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *View_alias_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *View_alias_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterView_alias_constraint(s) + } +} + +func (s *View_alias_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitView_alias_constraint(s) + } +} + +func (s *View_alias_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitView_alias_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) View_alias_constraint() (localctx IView_alias_constraintContext) { + localctx = NewView_alias_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 838, PlSqlParserRULE_view_alias_constraint) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8805) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-68727865345) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796093546497) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240515609) != 0) { + p.SetState(8807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8806) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8817) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 959, p.GetParserRuleContext()) { + case 1: + { + p.SetState(8809) + p.Table_alias() + } + p.SetState(8813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(8810) + p.Inline_constraint() + } + + } + p.SetState(8815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 958, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(8816) + p.Out_of_line_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(8821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8823) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IObject_view_clauseContext is an interface to support dynamic dispatch. +type IObject_view_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTn returns the tn rule contexts. + GetTn() IId_expressionContext + + // GetSv returns the sv rule contexts. + GetSv() IId_expressionContext + + // SetTn sets the tn rule contexts. + SetTn(IId_expressionContext) + + // SetSv sets the sv rule contexts. + SetSv(IId_expressionContext) + + // Getter signatures + OF() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + WITH() antlr.TerminalNode + OBJECT() antlr.TerminalNode + UNDER() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + ID() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllREGULAR_ID() []antlr.TerminalNode + REGULAR_ID(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsObject_view_clauseContext differentiates from other interfaces. + IsObject_view_clauseContext() +} + +type Object_view_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tn IId_expressionContext + sv IId_expressionContext +} + +func NewEmptyObject_view_clauseContext() *Object_view_clauseContext { + var p = new(Object_view_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_view_clause + return p +} + +func InitEmptyObject_view_clauseContext(p *Object_view_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_view_clause +} + +func (*Object_view_clauseContext) IsObject_view_clauseContext() {} + +func NewObject_view_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_view_clauseContext { + var p = new(Object_view_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_view_clause + + return p +} + +func (s *Object_view_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_view_clauseContext) GetTn() IId_expressionContext { return s.tn } + +func (s *Object_view_clauseContext) GetSv() IId_expressionContext { return s.sv } + +func (s *Object_view_clauseContext) SetTn(v IId_expressionContext) { s.tn = v } + +func (s *Object_view_clauseContext) SetSv(v IId_expressionContext) { s.sv = v } + +func (s *Object_view_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Object_view_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Object_view_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Object_view_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Object_view_clauseContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_view_clauseContext) 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 *Object_view_clauseContext) 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 *Object_view_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Object_view_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Object_view_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Object_view_clauseContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Object_view_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Object_view_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Object_view_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Object_view_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Object_view_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Object_view_clauseContext) AllREGULAR_ID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREGULAR_ID) +} + +func (s *Object_view_clauseContext) REGULAR_ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, i) +} + +func (s *Object_view_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_view_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_view_clauseContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *Object_view_clauseContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Object_view_clauseContext) 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 *Object_view_clauseContext) 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 *Object_view_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_view_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_view_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_view_clause(s) + } +} + +func (s *Object_view_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_view_clause(s) + } +} + +func (s *Object_view_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_view_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_view_clause() (localctx IObject_view_clauseContext) { + localctx = NewObject_view_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 840, PlSqlParserRULE_object_view_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8825) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8829) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 961, p.GetParserRuleContext()) == 1 { + { + p.SetState(8826) + p.Schema_name() + } + { + p.SetState(8827) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8831) + + var _x = p.Id_expression() + + localctx.(*Object_view_clauseContext).tn = _x + } + p.SetState(8855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITH: + { + p.SetState(8832) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8833) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8834) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIDENTIFIER || _la == PlSqlParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(8846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(8835) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(8836) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8837) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8842) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8838) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8839) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8845) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserUNDER: + { + p.SetState(8848) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 964, p.GetParserRuleContext()) == 1 { + { + p.SetState(8849) + p.Schema_name() + } + { + p.SetState(8850) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(8854) + + var _x = p.Id_expression() + + localctx.(*Object_view_clauseContext).sv = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserLEFT_PAREN { + { + p.SetState(8857) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE || _la == PlSqlParserCOMMA || _la == PlSqlParserREGULAR_ID { + p.SetState(8859) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8858) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(8864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHECK, PlSqlParserCONSTRAINT, PlSqlParserFOREIGN, PlSqlParserPRIMARY, PlSqlParserUNIQUE: + { + p.SetState(8861) + p.Out_of_line_constraint() + } + + case PlSqlParserREGULAR_ID: + { + p.SetState(8862) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8863) + p.Inline_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8870) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(8876) + 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 +} + +// IInline_constraintContext is an interface to support dynamic dispatch. +type IInline_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + References_clause() IReferences_clauseContext + Check_constraint() ICheck_constraintContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + NOT() 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 = PlSqlParserRULE_inline_constraint + return p +} + +func InitEmptyInline_constraintContext(p *Inline_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_inline_constraint + + return p +} + +func (s *Inline_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inline_constraintContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Inline_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Inline_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Inline_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Inline_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Inline_constraintContext) Check_constraint() ICheck_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_constraintContext) +} + +func (s *Inline_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Inline_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Inline_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Inline_constraintContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 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.(PlSqlParserListener); ok { + listenerT.EnterInline_constraint(s) + } +} + +func (s *Inline_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInline_constraint(s) + } +} + +func (s *Inline_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInline_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inline_constraint() (localctx IInline_constraintContext) { + localctx = NewInline_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 842, PlSqlParserRULE_inline_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(8877) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8878) + p.Constraint_name() + } + + } + p.SetState(8890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT, PlSqlParserNULL_: + p.SetState(8882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(8881) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8884) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(8885) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(8886) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8887) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREFERENCES: + { + p.SetState(8888) + p.References_clause() + } + + case PlSqlParserCHECK: + { + p.SetState(8889) + p.Check_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(8893) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 973, p.GetParserRuleContext()) == 1 { + { + p.SetState(8892) + p.Constraint_state() + } + + } 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 +} + +// IInline_ref_constraintContext is an interface to support dynamic dispatch. +type IInline_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SCOPE() antlr.TerminalNode + IS() antlr.TerminalNode + Tableview_name() ITableview_nameContext + WITH() antlr.TerminalNode + ROWID() antlr.TerminalNode + References_clause() IReferences_clauseContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + + // IsInline_ref_constraintContext differentiates from other interfaces. + IsInline_ref_constraintContext() +} + +type Inline_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInline_ref_constraintContext() *Inline_ref_constraintContext { + var p = new(Inline_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint + return p +} + +func InitEmptyInline_ref_constraintContext(p *Inline_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint +} + +func (*Inline_ref_constraintContext) IsInline_ref_constraintContext() {} + +func NewInline_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inline_ref_constraintContext { + var p = new(Inline_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inline_ref_constraint + + return p +} + +func (s *Inline_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inline_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Inline_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Inline_ref_constraintContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Inline_ref_constraintContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Inline_ref_constraintContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Inline_ref_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Inline_ref_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Inline_ref_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Inline_ref_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Inline_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inline_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inline_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInline_ref_constraint(s) + } +} + +func (s *Inline_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInline_ref_constraint(s) + } +} + +func (s *Inline_ref_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInline_ref_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inline_ref_constraint() (localctx IInline_ref_constraintContext) { + localctx = NewInline_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 844, PlSqlParserRULE_inline_ref_constraint) + var _la int + + p.SetState(8908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCOPE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8895) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8896) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8897) + p.Tableview_name() + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8898) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8899) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT, PlSqlParserREFERENCES: + p.EnterOuterAlt(localctx, 3) + p.SetState(8902) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(8900) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8901) + p.Constraint_name() + } + + } + { + p.SetState(8904) + p.References_clause() + } + p.SetState(8906) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 975, p.GetParserRuleContext()) == 1 { + { + p.SetState(8905) + p.Constraint_state() + } + + } 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 +} + +// IOut_of_line_ref_constraintContext is an interface to support dynamic dispatch. +type IOut_of_line_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRef_col_or_attr returns the ref_col_or_attr rule contexts. + GetRef_col_or_attr() IRegular_idContext + + // SetRef_col_or_attr sets the ref_col_or_attr rule contexts. + SetRef_col_or_attr(IRegular_idContext) + + // Getter signatures + SCOPE() antlr.TerminalNode + FOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + IS() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + REF() antlr.TerminalNode + WITH() antlr.TerminalNode + ROWID() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + References_clause() IReferences_clauseContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Constraint_state() IConstraint_stateContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsOut_of_line_ref_constraintContext differentiates from other interfaces. + IsOut_of_line_ref_constraintContext() +} + +type Out_of_line_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ref_col_or_attr IRegular_idContext +} + +func NewEmptyOut_of_line_ref_constraintContext() *Out_of_line_ref_constraintContext { + var p = new(Out_of_line_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint + return p +} + +func InitEmptyOut_of_line_ref_constraintContext(p *Out_of_line_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint +} + +func (*Out_of_line_ref_constraintContext) IsOut_of_line_ref_constraintContext() {} + +func NewOut_of_line_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Out_of_line_ref_constraintContext { + var p = new(Out_of_line_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_out_of_line_ref_constraint + + return p +} + +func (s *Out_of_line_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_ref_constraintContext) GetRef_col_or_attr() IRegular_idContext { + return s.ref_col_or_attr +} + +func (s *Out_of_line_ref_constraintContext) SetRef_col_or_attr(v IRegular_idContext) { + s.ref_col_or_attr = v +} + +func (s *Out_of_line_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Out_of_line_ref_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Out_of_line_ref_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Out_of_line_ref_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Out_of_line_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Out_of_line_ref_constraintContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Out_of_line_ref_constraintContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Out_of_line_ref_constraintContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Out_of_line_ref_constraintContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Out_of_line_ref_constraintContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Out_of_line_ref_constraintContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Out_of_line_ref_constraintContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Out_of_line_ref_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Out_of_line_ref_constraintContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Out_of_line_ref_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Out_of_line_ref_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Out_of_line_ref_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Out_of_line_ref_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Out_of_line_ref_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Out_of_line_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Out_of_line_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Out_of_line_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOut_of_line_ref_constraint(s) + } +} + +func (s *Out_of_line_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOut_of_line_ref_constraint(s) + } +} + +func (s *Out_of_line_ref_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOut_of_line_ref_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Out_of_line_ref_constraint() (localctx IOut_of_line_ref_constraintContext) { + localctx = NewOut_of_line_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 846, PlSqlParserRULE_out_of_line_ref_constraint) + var _la int + + p.SetState(8945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSCOPE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(8910) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8911) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8912) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8913) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + { + p.SetState(8914) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8915) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8916) + p.Tableview_name() + } + + case PlSqlParserREF: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(8918) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8919) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8920) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + { + p.SetState(8921) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8922) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8923) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT, PlSqlParserFOREIGN: + p.EnterOuterAlt(localctx, 3) + p.SetState(8927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(8925) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8926) + p.Constraint_name() + } + + } + { + p.SetState(8929) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8930) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8931) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(8936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877915137) != 0) { + p.SetState(8933) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(8932) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8935) + + var _x = p.Regular_id() + + localctx.(*Out_of_line_ref_constraintContext).ref_col_or_attr = _x + } + + p.SetState(8938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8940) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8941) + p.References_clause() + } + p.SetState(8943) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 980, p.GetParserRuleContext()) == 1 { + { + p.SetState(8942) + p.Constraint_state() + } + + } 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 +} + +// 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 + Constraint_state() IConstraint_stateContext + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + Foreign_key_clause() IForeign_key_clauseContext + CHECK() antlr.TerminalNode + Condition() IConditionContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // 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 = PlSqlParserRULE_out_of_line_constraint + return p +} + +func InitEmptyOut_of_line_constraintContext(p *Out_of_line_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_out_of_line_constraint + + return p +} + +func (s *Out_of_line_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_constraintContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Out_of_line_constraintContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Out_of_line_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Out_of_line_constraintContext) 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 *Out_of_line_constraintContext) 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 *Out_of_line_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Out_of_line_constraintContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Out_of_line_constraintContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Out_of_line_constraintContext) Foreign_key_clause() IForeign_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_clauseContext) +} + +func (s *Out_of_line_constraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Out_of_line_constraintContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Out_of_line_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Out_of_line_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Out_of_line_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Out_of_line_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterOut_of_line_constraint(s) + } +} + +func (s *Out_of_line_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOut_of_line_constraint(s) + } +} + +func (s *Out_of_line_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOut_of_line_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Out_of_line_constraint() (localctx IOut_of_line_constraintContext) { + localctx = NewOut_of_line_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 848, PlSqlParserRULE_out_of_line_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(8947) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8948) + p.Constraint_name() + } + + } + p.SetState(8982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNIQUE: + { + p.SetState(8951) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8952) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8953) + p.Column_name() + } + p.SetState(8958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8954) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8955) + p.Column_name() + } + + p.SetState(8960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8961) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(8963) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8964) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8965) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8966) + p.Column_name() + } + p.SetState(8971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(8967) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8968) + p.Column_name() + } + + p.SetState(8973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(8974) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOREIGN: + { + p.SetState(8976) + p.Foreign_key_clause() + } + + case PlSqlParserCHECK: + { + p.SetState(8977) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8978) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8979) + p.Condition() + } + { + p.SetState(8980) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(8985) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 986, p.GetParserRuleContext()) == 1 { + { + p.SetState(8984) + p.Constraint_state() + } + + } 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_stateContext is an interface to support dynamic dispatch. +type IConstraint_stateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDEFERRABLE() []antlr.TerminalNode + DEFERRABLE(i int) antlr.TerminalNode + AllINITIALLY() []antlr.TerminalNode + INITIALLY(i int) antlr.TerminalNode + AllUsing_index_clause() []IUsing_index_clauseContext + Using_index_clause(i int) IUsing_index_clauseContext + AllIMMEDIATE() []antlr.TerminalNode + IMMEDIATE(i int) antlr.TerminalNode + AllDEFERRED() []antlr.TerminalNode + DEFERRED(i int) antlr.TerminalNode + AllRELY() []antlr.TerminalNode + RELY(i int) antlr.TerminalNode + AllNORELY() []antlr.TerminalNode + NORELY(i int) antlr.TerminalNode + AllENABLE() []antlr.TerminalNode + ENABLE(i int) antlr.TerminalNode + AllDISABLE() []antlr.TerminalNode + DISABLE(i int) antlr.TerminalNode + AllVALIDATE() []antlr.TerminalNode + VALIDATE(i int) antlr.TerminalNode + AllNOVALIDATE() []antlr.TerminalNode + NOVALIDATE(i int) antlr.TerminalNode + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + + // IsConstraint_stateContext differentiates from other interfaces. + IsConstraint_stateContext() +} + +type Constraint_stateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_stateContext() *Constraint_stateContext { + var p = new(Constraint_stateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_state + return p +} + +func InitEmptyConstraint_stateContext(p *Constraint_stateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_state +} + +func (*Constraint_stateContext) IsConstraint_stateContext() {} + +func NewConstraint_stateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_stateContext { + var p = new(Constraint_stateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_state + + return p +} + +func (s *Constraint_stateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_stateContext) AllDEFERRABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFERRABLE) +} + +func (s *Constraint_stateContext) DEFERRABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRABLE, i) +} + +func (s *Constraint_stateContext) AllINITIALLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITIALLY) +} + +func (s *Constraint_stateContext) INITIALLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALLY, i) +} + +func (s *Constraint_stateContext) AllUsing_index_clause() []IUsing_index_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + len++ + } + } + + tst := make([]IUsing_index_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUsing_index_clauseContext); ok { + tst[i] = t.(IUsing_index_clauseContext) + i++ + } + } + + return tst +} + +func (s *Constraint_stateContext) Using_index_clause(i int) IUsing_index_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Constraint_stateContext) AllIMMEDIATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIMMEDIATE) +} + +func (s *Constraint_stateContext) IMMEDIATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, i) +} + +func (s *Constraint_stateContext) AllDEFERRED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFERRED) +} + +func (s *Constraint_stateContext) DEFERRED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, i) +} + +func (s *Constraint_stateContext) AllRELY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRELY) +} + +func (s *Constraint_stateContext) RELY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, i) +} + +func (s *Constraint_stateContext) AllNORELY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNORELY) +} + +func (s *Constraint_stateContext) NORELY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, i) +} + +func (s *Constraint_stateContext) AllENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENABLE) +} + +func (s *Constraint_stateContext) ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, i) +} + +func (s *Constraint_stateContext) AllDISABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISABLE) +} + +func (s *Constraint_stateContext) DISABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, i) +} + +func (s *Constraint_stateContext) AllVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserVALIDATE) +} + +func (s *Constraint_stateContext) VALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, i) +} + +func (s *Constraint_stateContext) AllNOVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOVALIDATE) +} + +func (s *Constraint_stateContext) NOVALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, i) +} + +func (s *Constraint_stateContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOT) +} + +func (s *Constraint_stateContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, i) +} + +func (s *Constraint_stateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_stateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_stateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_state(s) + } +} + +func (s *Constraint_stateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_state(s) + } +} + +func (s *Constraint_stateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstraint_state(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constraint_state() (localctx IConstraint_stateContext) { + localctx = NewConstraint_stateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 850, PlSqlParserRULE_constraint_state) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(8997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(8997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFERRABLE, PlSqlParserNOT: + p.SetState(8988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(8987) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(8990) + p.Match(PlSqlParserDEFERRABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINITIALLY: + { + p.SetState(8991) + p.Match(PlSqlParserINITIALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(8992) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNORELY, PlSqlParserRELY: + { + p.SetState(8993) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORELY || _la == PlSqlParserRELY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(8994) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserNOVALIDATE, PlSqlParserVALIDATE: + { + p.SetState(8995) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserUSING: + { + p.SetState(8996) + p.Using_index_clause() + } + + 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 + } + + p.SetState(8999) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 989, 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 +} + +// IXmltype_view_clauseContext is an interface to support dynamic dispatch. +type IXmltype_view_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + WITH() antlr.TerminalNode + OBJECT() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + ID() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Xml_schema_spec() IXml_schema_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXmltype_view_clauseContext differentiates from other interfaces. + IsXmltype_view_clauseContext() +} + +type Xmltype_view_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_view_clauseContext() *Xmltype_view_clauseContext { + var p = new(Xmltype_view_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause + return p +} + +func InitEmptyXmltype_view_clauseContext(p *Xmltype_view_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause +} + +func (*Xmltype_view_clauseContext) IsXmltype_view_clauseContext() {} + +func NewXmltype_view_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_view_clauseContext { + var p = new(Xmltype_view_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_view_clause + + return p +} + +func (s *Xmltype_view_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_view_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Xmltype_view_clauseContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Xmltype_view_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Xmltype_view_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Xmltype_view_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Xmltype_view_clauseContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Xmltype_view_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Xmltype_view_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_view_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xmltype_view_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmltype_view_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_view_clauseContext) Xml_schema_spec() IXml_schema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_schema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_schema_specContext) +} + +func (s *Xmltype_view_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xmltype_view_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xmltype_view_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_view_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_view_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_view_clause(s) + } +} + +func (s *Xmltype_view_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_view_clause(s) + } +} + +func (s *Xmltype_view_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltype_view_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltype_view_clause() (localctx IXmltype_view_clauseContext) { + localctx = NewXmltype_view_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 852, PlSqlParserRULE_xmltype_view_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9001) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9002) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(9003) + p.Xml_schema_spec() + } + + } + { + p.SetState(9006) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9007) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9008) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIDENTIFIER || _la == PlSqlParserID) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(9021) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(9009) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9010) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9011) + p.Expression() + } + p.SetState(9016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9012) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9013) + p.Expression() + } + + p.SetState(9018) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9019) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_schema_specContext is an interface to support dynamic dispatch. +type IXml_schema_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELEMENT() antlr.TerminalNode + Element() IElementContext + AllXml_schema_url() []IXml_schema_urlContext + Xml_schema_url(i int) IXml_schema_urlContext + HASH_OP() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + STORE() antlr.TerminalNode + ALL() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + AS() antlr.TerminalNode + AllAllow_or_disallow() []IAllow_or_disallowContext + Allow_or_disallow(i int) IAllow_or_disallowContext + NONSCHEMA() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + LOBS() antlr.TerminalNode + TABLES() antlr.TerminalNode + + // IsXml_schema_specContext differentiates from other interfaces. + IsXml_schema_specContext() +} + +type Xml_schema_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_schema_specContext() *Xml_schema_specContext { + var p = new(Xml_schema_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_spec + return p +} + +func InitEmptyXml_schema_specContext(p *Xml_schema_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_spec +} + +func (*Xml_schema_specContext) IsXml_schema_specContext() {} + +func NewXml_schema_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_specContext { + var p = new(Xml_schema_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_schema_spec + + return p +} + +func (s *Xml_schema_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_schema_specContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Xml_schema_specContext) Element() IElementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElementContext) +} + +func (s *Xml_schema_specContext) AllXml_schema_url() []IXml_schema_urlContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_schema_urlContext); ok { + len++ + } + } + + tst := make([]IXml_schema_urlContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_schema_urlContext); ok { + tst[i] = t.(IXml_schema_urlContext) + i++ + } + } + + return tst +} + +func (s *Xml_schema_specContext) Xml_schema_url(i int) IXml_schema_urlContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_schema_urlContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_schema_urlContext) +} + +func (s *Xml_schema_specContext) HASH_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_OP, 0) +} + +func (s *Xml_schema_specContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Xml_schema_specContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Xml_schema_specContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Xml_schema_specContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Xml_schema_specContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xml_schema_specContext) AllAllow_or_disallow() []IAllow_or_disallowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + len++ + } + } + + tst := make([]IAllow_or_disallowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllow_or_disallowContext); ok { + tst[i] = t.(IAllow_or_disallowContext) + i++ + } + } + + return tst +} + +func (s *Xml_schema_specContext) Allow_or_disallow(i int) IAllow_or_disallowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Xml_schema_specContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Xml_schema_specContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Xml_schema_specContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Xml_schema_specContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Xml_schema_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_schema_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_schema_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_schema_spec(s) + } +} + +func (s *Xml_schema_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_schema_spec(s) + } +} + +func (s *Xml_schema_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_schema_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_schema_spec() (localctx IXml_schema_specContext) { + localctx = NewXml_schema_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 854, PlSqlParserRULE_xml_schema_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXMLSCHEMA { + { + p.SetState(9023) + p.Match(PlSqlParserXMLSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9024) + p.Xml_schema_url() + } + + } + { + p.SetState(9027) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9033) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 994, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9028) + p.Element() + } + + case 2: + { + p.SetState(9029) + p.Xml_schema_url() + } + { + p.SetState(9030) + p.Match(PlSqlParserHASH_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9031) + p.Element() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(9040) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(9035) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9036) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9037) + p.Match(PlSqlParserVARRAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9038) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9039) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOBS || _la == PlSqlParserTABLES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9045) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 996, p.GetParserRuleContext()) == 1 { + { + p.SetState(9042) + p.Allow_or_disallow() + } + { + p.SetState(9043) + p.Match(PlSqlParserNONSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(9047) + p.Allow_or_disallow() + } + { + p.SetState(9048) + p.Match(PlSqlParserANYSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_schema_urlContext is an interface to support dynamic dispatch. +type IXml_schema_urlContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsXml_schema_urlContext differentiates from other interfaces. + IsXml_schema_urlContext() +} + +type Xml_schema_urlContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_schema_urlContext() *Xml_schema_urlContext { + var p = new(Xml_schema_urlContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_url + return p +} + +func InitEmptyXml_schema_urlContext(p *Xml_schema_urlContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_schema_url +} + +func (*Xml_schema_urlContext) IsXml_schema_urlContext() {} + +func NewXml_schema_urlContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_schema_urlContext { + var p = new(Xml_schema_urlContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_schema_url + + return p +} + +func (s *Xml_schema_urlContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_schema_urlContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Xml_schema_urlContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_schema_urlContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_schema_urlContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_schema_url(s) + } +} + +func (s *Xml_schema_urlContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_schema_url(s) + } +} + +func (s *Xml_schema_urlContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_schema_url(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_schema_url() (localctx IXml_schema_urlContext) { + localctx = NewXml_schema_urlContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 856, PlSqlParserRULE_xml_schema_url) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9052) + p.Match(PlSqlParserDELIMITED_ID) + 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 +} + +// IElementContext is an interface to support dynamic dispatch. +type IElementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELIMITED_ID() antlr.TerminalNode + + // IsElementContext differentiates from other interfaces. + IsElementContext() +} + +type ElementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElementContext() *ElementContext { + var p = new(ElementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element + return p +} + +func InitEmptyElementContext(p *ElementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_element +} + +func (*ElementContext) IsElementContext() {} + +func NewElementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ElementContext { + var p = new(ElementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_element + + return p +} + +func (s *ElementContext) GetParser() antlr.Parser { return s.parser } + +func (s *ElementContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *ElementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ElementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ElementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElement(s) + } +} + +func (s *ElementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElement(s) + } +} + +func (s *ElementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitElement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Element() (localctx IElementContext) { + localctx = NewElementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 858, PlSqlParserRULE_element) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9054) + p.Match(PlSqlParserDELIMITED_ID) + 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_tablespaceContext is an interface to support dynamic dispatch. +type IAlter_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + SEMICOLON() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + RESIZE() antlr.TerminalNode + COALESCE() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + New_tablespace_name() INew_tablespace_nameContext + Begin_or_end() IBegin_or_endContext + BACKUP() antlr.TerminalNode + Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext + Tablespace_logging_clauses() ITablespace_logging_clausesContext + Tablespace_group_clause() ITablespace_group_clauseContext + Tablespace_state_clauses() ITablespace_state_clausesContext + Autoextend_clause() IAutoextend_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + Table_compression() ITable_compressionContext + Storage_clause() IStorage_clauseContext + KEEP() antlr.TerminalNode + + // IsAlter_tablespaceContext differentiates from other interfaces. + IsAlter_tablespaceContext() +} + +type Alter_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tablespaceContext() *Alter_tablespaceContext { + var p = new(Alter_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace + return p +} + +func InitEmptyAlter_tablespaceContext(p *Alter_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace +} + +func (*Alter_tablespaceContext) IsAlter_tablespaceContext() {} + +func NewAlter_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespaceContext { + var p = new(Alter_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace + + return p +} + +func (s *Alter_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespaceContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Alter_tablespaceContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Alter_tablespaceContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Alter_tablespaceContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Alter_tablespaceContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tablespaceContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tablespaceContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_tablespaceContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_tablespaceContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Alter_tablespaceContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_tablespaceContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_tablespaceContext) New_tablespace_name() INew_tablespace_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_tablespace_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_tablespace_nameContext) +} + +func (s *Alter_tablespaceContext) Begin_or_end() IBegin_or_endContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_or_endContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_or_endContext) +} + +func (s *Alter_tablespaceContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_tablespaceContext) Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_clausesContext) +} + +func (s *Alter_tablespaceContext) Tablespace_logging_clauses() ITablespace_logging_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_logging_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_logging_clausesContext) +} + +func (s *Alter_tablespaceContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Alter_tablespaceContext) Tablespace_state_clauses() ITablespace_state_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_state_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_state_clausesContext) +} + +func (s *Alter_tablespaceContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tablespaceContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Alter_tablespaceContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Alter_tablespaceContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_tablespaceContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Alter_tablespaceContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Alter_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace(s) + } +} + +func (s *Alter_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace(s) + } +} + +func (s *Alter_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_tablespace() (localctx IAlter_tablespaceContext) { + localctx = NewAlter_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 860, PlSqlParserRULE_alter_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9056) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9057) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9058) + p.Tablespace() + } + p.SetState(9091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1001, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9059) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(9060) + p.Table_compression() + } + + } + p.SetState(9064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORAGE { + { + p.SetState(9063) + p.Storage_clause() + } + + } + + case 2: + { + p.SetState(9066) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9067) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9068) + p.Size_clause() + } + + case 3: + { + p.SetState(9069) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9070) + p.Size_clause() + } + + case 4: + { + p.SetState(9071) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(9072) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9073) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(9074) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9075) + p.Size_clause() + } + + } + + case 6: + { + p.SetState(9078) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9079) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9080) + p.New_tablespace_name() + } + + case 7: + { + p.SetState(9081) + p.Begin_or_end() + } + { + p.SetState(9082) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(9084) + p.Datafile_tempfile_clauses() + } + + case 9: + { + p.SetState(9085) + p.Tablespace_logging_clauses() + } + + case 10: + { + p.SetState(9086) + p.Tablespace_group_clause() + } + + case 11: + { + p.SetState(9087) + p.Tablespace_state_clauses() + } + + case 12: + { + p.SetState(9088) + p.Autoextend_clause() + } + + case 13: + { + p.SetState(9089) + p.Flashback_mode_clause() + } + + case 14: + { + p.SetState(9090) + p.Tablespace_retention_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(9093) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDatafile_tempfile_clausesContext is an interface to support dynamic dispatch. +type IDatafile_tempfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + Datafile_specification() IDatafile_specificationContext + Tempfile_specification() ITempfile_specificationContext + DROP() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + UNSIGNED_INTEGER() antlr.TerminalNode + KEEP() antlr.TerminalNode + Size_clause() ISize_clauseContext + SHRINK() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Online_or_offline() IOnline_or_offlineContext + + // IsDatafile_tempfile_clausesContext differentiates from other interfaces. + IsDatafile_tempfile_clausesContext() +} + +type Datafile_tempfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_tempfile_clausesContext() *Datafile_tempfile_clausesContext { + var p = new(Datafile_tempfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses + return p +} + +func InitEmptyDatafile_tempfile_clausesContext(p *Datafile_tempfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses +} + +func (*Datafile_tempfile_clausesContext) IsDatafile_tempfile_clausesContext() {} + +func NewDatafile_tempfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_tempfile_clausesContext { + var p = new(Datafile_tempfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_clauses + + return p +} + +func (s *Datafile_tempfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_tempfile_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Datafile_tempfile_clausesContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Datafile_tempfile_clausesContext) Tempfile_specification() ITempfile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITempfile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITempfile_specificationContext) +} + +func (s *Datafile_tempfile_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Datafile_tempfile_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Datafile_tempfile_clausesContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Datafile_tempfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Datafile_tempfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Datafile_tempfile_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Datafile_tempfile_clausesContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Datafile_tempfile_clausesContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Datafile_tempfile_clausesContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Datafile_tempfile_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Datafile_tempfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Datafile_tempfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Datafile_tempfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Datafile_tempfile_clausesContext) Online_or_offline() IOnline_or_offlineContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOnline_or_offlineContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOnline_or_offlineContext) +} + +func (s *Datafile_tempfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_tempfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_tempfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_tempfile_clauses(s) + } +} + +func (s *Datafile_tempfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_tempfile_clauses(s) + } +} + +func (s *Datafile_tempfile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatafile_tempfile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datafile_tempfile_clauses() (localctx IDatafile_tempfile_clausesContext) { + localctx = NewDatafile_tempfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 862, PlSqlParserRULE_datafile_tempfile_clauses) + var _la int + + var _alt int + + p.SetState(9141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9095) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATAFILE: + { + p.SetState(9096) + p.Datafile_specification() + } + + case PlSqlParserTEMPFILE: + { + p.SetState(9097) + p.Tempfile_specification() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9100) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9101) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAFILE || _la == PlSqlParserTEMPFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(9104) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9102) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9103) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9108) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1004, p.GetParserRuleContext()) == 1 { + { + p.SetState(9106) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9107) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSHRINK: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9110) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9111) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9112) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9113) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9118) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1006, p.GetParserRuleContext()) == 1 { + { + p.SetState(9116) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9117) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9120) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9121) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9122) + p.Filename() + } + p.SetState(9127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9123) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9124) + p.Filename() + } + + p.SetState(9129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9130) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9131) + p.Filename() + } + p.SetState(9136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1008, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9132) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9133) + p.Filename() + } + + } + p.SetState(9138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1008, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserDATAFILE, PlSqlParserTEMPFILE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9139) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATAFILE || _la == PlSqlParserTEMPFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + { + p.SetState(9140) + p.Online_or_offline() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_logging_clausesContext is an interface to support dynamic dispatch. +type ITablespace_logging_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Logging_clause() ILogging_clauseContext + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsTablespace_logging_clausesContext differentiates from other interfaces. + IsTablespace_logging_clausesContext() +} + +type Tablespace_logging_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_logging_clausesContext() *Tablespace_logging_clausesContext { + var p = new(Tablespace_logging_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses + return p +} + +func InitEmptyTablespace_logging_clausesContext(p *Tablespace_logging_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses +} + +func (*Tablespace_logging_clausesContext) IsTablespace_logging_clausesContext() {} + +func NewTablespace_logging_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_logging_clausesContext { + var p = new(Tablespace_logging_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_logging_clauses + + return p +} + +func (s *Tablespace_logging_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_logging_clausesContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Tablespace_logging_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Tablespace_logging_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Tablespace_logging_clausesContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Tablespace_logging_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_logging_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_logging_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_logging_clauses(s) + } +} + +func (s *Tablespace_logging_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_logging_clauses(s) + } +} + +func (s *Tablespace_logging_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_logging_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_logging_clauses() (localctx ITablespace_logging_clausesContext) { + localctx = NewTablespace_logging_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 864, PlSqlParserRULE_tablespace_logging_clauses) + var _la int + + p.SetState(9149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9143) + p.Logging_clause() + } + + case PlSqlParserFORCE, PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + p.SetState(9145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(9144) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9147) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9148) + p.Match(PlSqlParserLOGGING) + 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 +} + +// ITablespace_group_clauseContext is an interface to support dynamic dispatch. +type ITablespace_group_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + GROUP() antlr.TerminalNode + Tablespace_group_name() ITablespace_group_nameContext + CHAR_STRING() antlr.TerminalNode + + // IsTablespace_group_clauseContext differentiates from other interfaces. + IsTablespace_group_clauseContext() +} + +type Tablespace_group_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_group_clauseContext() *Tablespace_group_clauseContext { + var p = new(Tablespace_group_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause + return p +} + +func InitEmptyTablespace_group_clauseContext(p *Tablespace_group_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause +} + +func (*Tablespace_group_clauseContext) IsTablespace_group_clauseContext() {} + +func NewTablespace_group_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_group_clauseContext { + var p = new(Tablespace_group_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_group_clause + + return p +} + +func (s *Tablespace_group_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_group_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Tablespace_group_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Tablespace_group_clauseContext) Tablespace_group_name() ITablespace_group_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Tablespace_group_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Tablespace_group_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_group_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_group_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_group_clause(s) + } +} + +func (s *Tablespace_group_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_group_clause(s) + } +} + +func (s *Tablespace_group_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_group_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_group_clause() (localctx ITablespace_group_clauseContext) { + localctx = NewTablespace_group_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 866, PlSqlParserRULE_tablespace_group_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9151) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9152) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + { + p.SetState(9153) + p.Tablespace_group_name() + } + + case PlSqlParserCHAR_STRING: + { + p.SetState(9154) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// ITablespace_group_nameContext is an interface to support dynamic dispatch. +type ITablespace_group_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsTablespace_group_nameContext differentiates from other interfaces. + IsTablespace_group_nameContext() +} + +type Tablespace_group_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_group_nameContext() *Tablespace_group_nameContext { + var p = new(Tablespace_group_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_name + return p +} + +func InitEmptyTablespace_group_nameContext(p *Tablespace_group_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_group_name +} + +func (*Tablespace_group_nameContext) IsTablespace_group_nameContext() {} + +func NewTablespace_group_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_group_nameContext { + var p = new(Tablespace_group_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_group_name + + return p +} + +func (s *Tablespace_group_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_group_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Tablespace_group_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_group_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_group_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_group_name(s) + } +} + +func (s *Tablespace_group_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_group_name(s) + } +} + +func (s *Tablespace_group_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_group_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_group_name() (localctx ITablespace_group_nameContext) { + localctx = NewTablespace_group_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 868, PlSqlParserRULE_tablespace_group_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9157) + p.Regular_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 +} + +// ITablespace_state_clausesContext is an interface to support dynamic dispatch. +type ITablespace_state_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + NORMAL() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + PERMANENT() antlr.TerminalNode + + // IsTablespace_state_clausesContext differentiates from other interfaces. + IsTablespace_state_clausesContext() +} + +type Tablespace_state_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_state_clausesContext() *Tablespace_state_clausesContext { + var p = new(Tablespace_state_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses + return p +} + +func InitEmptyTablespace_state_clausesContext(p *Tablespace_state_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses +} + +func (*Tablespace_state_clausesContext) IsTablespace_state_clausesContext() {} + +func NewTablespace_state_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_state_clausesContext { + var p = new(Tablespace_state_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_state_clauses + + return p +} + +func (s *Tablespace_state_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_state_clausesContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Tablespace_state_clausesContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Tablespace_state_clausesContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Tablespace_state_clausesContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Tablespace_state_clausesContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Tablespace_state_clausesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Tablespace_state_clausesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Tablespace_state_clausesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Tablespace_state_clausesContext) PERMANENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMANENT, 0) +} + +func (s *Tablespace_state_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_state_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_state_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_state_clauses(s) + } +} + +func (s *Tablespace_state_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_state_clauses(s) + } +} + +func (s *Tablespace_state_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_state_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_state_clauses() (localctx ITablespace_state_clausesContext) { + localctx = NewTablespace_state_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 870, PlSqlParserRULE_tablespace_state_clauses) + var _la int + + p.SetState(9168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9159) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9160) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9162) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1013, p.GetParserRuleContext()) == 1 { + { + p.SetState(9161) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIMMEDIATE || _la == PlSqlParserNORMAL || _la == PlSqlParserTEMPORARY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserREAD: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9164) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9165) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPERMANENT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9166) + p.Match(PlSqlParserPERMANENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTEMPORARY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9167) + p.Match(PlSqlParserTEMPORARY) + 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 +} + +// IFlashback_mode_clauseContext is an interface to support dynamic dispatch. +type IFlashback_mode_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FLASHBACK() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsFlashback_mode_clauseContext differentiates from other interfaces. + IsFlashback_mode_clauseContext() +} + +type Flashback_mode_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_mode_clauseContext() *Flashback_mode_clauseContext { + var p = new(Flashback_mode_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause + return p +} + +func InitEmptyFlashback_mode_clauseContext(p *Flashback_mode_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause +} + +func (*Flashback_mode_clauseContext) IsFlashback_mode_clauseContext() {} + +func NewFlashback_mode_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_mode_clauseContext { + var p = new(Flashback_mode_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_mode_clause + + return p +} + +func (s *Flashback_mode_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_mode_clauseContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_mode_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Flashback_mode_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Flashback_mode_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_mode_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_mode_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_mode_clause(s) + } +} + +func (s *Flashback_mode_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_mode_clause(s) + } +} + +func (s *Flashback_mode_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_mode_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_mode_clause() (localctx IFlashback_mode_clauseContext) { + localctx = NewFlashback_mode_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 872, PlSqlParserRULE_flashback_mode_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9170) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9171) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + 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 +} + +// INew_tablespace_nameContext is an interface to support dynamic dispatch. +type INew_tablespace_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tablespace() ITablespaceContext + + // IsNew_tablespace_nameContext differentiates from other interfaces. + IsNew_tablespace_nameContext() +} + +type New_tablespace_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_tablespace_nameContext() *New_tablespace_nameContext { + var p = new(New_tablespace_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_tablespace_name + return p +} + +func InitEmptyNew_tablespace_nameContext(p *New_tablespace_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_tablespace_name +} + +func (*New_tablespace_nameContext) IsNew_tablespace_nameContext() {} + +func NewNew_tablespace_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_tablespace_nameContext { + var p = new(New_tablespace_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_tablespace_name + + return p +} + +func (s *New_tablespace_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_tablespace_nameContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *New_tablespace_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_tablespace_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_tablespace_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_tablespace_name(s) + } +} + +func (s *New_tablespace_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_tablespace_name(s) + } +} + +func (s *New_tablespace_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_tablespace_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_tablespace_name() (localctx INew_tablespace_nameContext) { + localctx = NewNew_tablespace_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 874, PlSqlParserRULE_new_tablespace_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9173) + p.Tablespace() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_tablespaceContext is an interface to support dynamic dispatch. +type ICreate_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Permanent_tablespace_clause() IPermanent_tablespace_clauseContext + Temporary_tablespace_clause() ITemporary_tablespace_clauseContext + Undo_tablespace_clause() IUndo_tablespace_clauseContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + + // IsCreate_tablespaceContext differentiates from other interfaces. + IsCreate_tablespaceContext() +} + +type Create_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_tablespaceContext() *Create_tablespaceContext { + var p = new(Create_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace + return p +} + +func InitEmptyCreate_tablespaceContext(p *Create_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace +} + +func (*Create_tablespaceContext) IsCreate_tablespaceContext() {} + +func NewCreate_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tablespaceContext { + var p = new(Create_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_tablespace + + return p +} + +func (s *Create_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tablespaceContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tablespaceContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_tablespaceContext) Permanent_tablespace_clause() IPermanent_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPermanent_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPermanent_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) Temporary_tablespace_clause() ITemporary_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITemporary_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITemporary_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) Undo_tablespace_clause() IUndo_tablespace_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_tablespace_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_tablespace_clauseContext) +} + +func (s *Create_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Create_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Create_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_tablespace(s) + } +} + +func (s *Create_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_tablespace(s) + } +} + +func (s *Create_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_tablespace() (localctx ICreate_tablespaceContext) { + localctx = NewCreate_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 876, PlSqlParserRULE_create_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9175) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(9176) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(9179) + p.Permanent_tablespace_clause() + } + + case PlSqlParserTEMPORARY: + { + p.SetState(9180) + p.Temporary_tablespace_clause() + } + + case PlSqlParserUNDO: + { + p.SetState(9181) + p.Undo_tablespace_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(9184) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPermanent_tablespace_clauseContext is an interface to support dynamic dispatch. +type IPermanent_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Datafile_specification() IDatafile_specificationContext + AllMINIMUM() []antlr.TerminalNode + MINIMUM(i int) antlr.TerminalNode + AllEXTENT() []antlr.TerminalNode + EXTENT(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllBLOCKSIZE() []antlr.TerminalNode + BLOCKSIZE(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllLOGGING() []antlr.TerminalNode + LOGGING(i int) antlr.TerminalNode + AllENCRYPTION() []antlr.TerminalNode + ENCRYPTION(i int) antlr.TerminalNode + AllTablespace_encryption_spec() []ITablespace_encryption_specContext + Tablespace_encryption_spec(i int) ITablespace_encryption_specContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllExtent_management_clause() []IExtent_management_clauseContext + Extent_management_clause(i int) IExtent_management_clauseContext + AllSegment_management_clause() []ISegment_management_clauseContext + Segment_management_clause(i int) ISegment_management_clauseContext + AllFlashback_mode_clause() []IFlashback_mode_clauseContext + Flashback_mode_clause(i int) IFlashback_mode_clauseContext + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + AllOFFLINE() []antlr.TerminalNode + OFFLINE(i int) antlr.TerminalNode + + // IsPermanent_tablespace_clauseContext differentiates from other interfaces. + IsPermanent_tablespace_clauseContext() +} + +type Permanent_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPermanent_tablespace_clauseContext() *Permanent_tablespace_clauseContext { + var p = new(Permanent_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause + return p +} + +func InitEmptyPermanent_tablespace_clauseContext(p *Permanent_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause +} + +func (*Permanent_tablespace_clauseContext) IsPermanent_tablespace_clauseContext() {} + +func NewPermanent_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Permanent_tablespace_clauseContext { + var p = new(Permanent_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_clause + + return p +} + +func (s *Permanent_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Permanent_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Permanent_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Permanent_tablespace_clauseContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Permanent_tablespace_clauseContext) AllMINIMUM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINIMUM) +} + +func (s *Permanent_tablespace_clauseContext) MINIMUM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, i) +} + +func (s *Permanent_tablespace_clauseContext) AllEXTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEXTENT) +} + +func (s *Permanent_tablespace_clauseContext) EXTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, i) +} + +func (s *Permanent_tablespace_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllBLOCKSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBLOCKSIZE) +} + +func (s *Permanent_tablespace_clauseContext) BLOCKSIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Permanent_tablespace_clauseContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllLOGGING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGGING) +} + +func (s *Permanent_tablespace_clauseContext) LOGGING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, i) +} + +func (s *Permanent_tablespace_clauseContext) AllENCRYPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPTION) +} + +func (s *Permanent_tablespace_clauseContext) ENCRYPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, i) +} + +func (s *Permanent_tablespace_clauseContext) AllTablespace_encryption_spec() []ITablespace_encryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + len++ + } + } + + tst := make([]ITablespace_encryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_encryption_specContext); ok { + tst[i] = t.(ITablespace_encryption_specContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Tablespace_encryption_spec(i int) ITablespace_encryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Permanent_tablespace_clauseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Permanent_tablespace_clauseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Permanent_tablespace_clauseContext) AllExtent_management_clause() []IExtent_management_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + len++ + } + } + + tst := make([]IExtent_management_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExtent_management_clauseContext); ok { + tst[i] = t.(IExtent_management_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Extent_management_clause(i int) IExtent_management_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllSegment_management_clause() []ISegment_management_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_management_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_management_clauseContext); ok { + tst[i] = t.(ISegment_management_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Segment_management_clause(i int) ISegment_management_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_management_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllFlashback_mode_clause() []IFlashback_mode_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_mode_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_mode_clauseContext); ok { + tst[i] = t.(IFlashback_mode_clauseContext) + i++ + } + } + + return tst +} + +func (s *Permanent_tablespace_clauseContext) Flashback_mode_clause(i int) IFlashback_mode_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Permanent_tablespace_clauseContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Permanent_tablespace_clauseContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Permanent_tablespace_clauseContext) AllOFFLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOFFLINE) +} + +func (s *Permanent_tablespace_clauseContext) OFFLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, i) +} + +func (s *Permanent_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Permanent_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Permanent_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPermanent_tablespace_clause(s) + } +} + +func (s *Permanent_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPermanent_tablespace_clause(s) + } +} + +func (s *Permanent_tablespace_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPermanent_tablespace_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Permanent_tablespace_clause() (localctx IPermanent_tablespace_clauseContext) { + localctx = NewPermanent_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 878, PlSqlParserRULE_permanent_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9186) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9187) + p.Id_expression() + } + p.SetState(9189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9188) + p.Datafile_specification() + } + + } + p.SetState(9208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserBLOCKSIZE || _la == PlSqlParserDEFAULT || _la == PlSqlParserENCRYPTION || _la == PlSqlParserEXTENT || ((int64((_la-538)) & ^0x3f) == 0 && ((int64(1)<<(_la-538))&4196353) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMINIMUM || _la == PlSqlParserNOLOGGING || _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE || _la == PlSqlParserSEGMENT { + p.SetState(9206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMINIMUM: + { + p.SetState(9191) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9192) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9193) + p.Size_clause() + } + + case PlSqlParserBLOCKSIZE: + { + p.SetState(9194) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9195) + p.Size_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(9196) + p.Logging_clause() + } + + case PlSqlParserFORCE: + { + p.SetState(9197) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9198) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE, PlSqlParserONLINE: + { + p.SetState(9199) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserENCRYPTION: + { + p.SetState(9200) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9201) + p.Tablespace_encryption_spec() + } + + case PlSqlParserDEFAULT: + { + p.SetState(9202) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENT: + { + p.SetState(9203) + p.Extent_management_clause() + } + + case PlSqlParserSEGMENT: + { + p.SetState(9204) + p.Segment_management_clause() + } + + case PlSqlParserFLASHBACK: + { + p.SetState(9205) + p.Flashback_mode_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(9210) + 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 +} + +// ITablespace_encryption_specContext is an interface to support dynamic dispatch. +type ITablespace_encryption_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetEncrypt_algorithm returns the encrypt_algorithm token. + GetEncrypt_algorithm() antlr.Token + + // SetEncrypt_algorithm sets the encrypt_algorithm token. + SetEncrypt_algorithm(antlr.Token) + + // Getter signatures + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsTablespace_encryption_specContext differentiates from other interfaces. + IsTablespace_encryption_specContext() +} + +type Tablespace_encryption_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + encrypt_algorithm antlr.Token +} + +func NewEmptyTablespace_encryption_specContext() *Tablespace_encryption_specContext { + var p = new(Tablespace_encryption_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec + return p +} + +func InitEmptyTablespace_encryption_specContext(p *Tablespace_encryption_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec +} + +func (*Tablespace_encryption_specContext) IsTablespace_encryption_specContext() {} + +func NewTablespace_encryption_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_encryption_specContext { + var p = new(Tablespace_encryption_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_spec + + return p +} + +func (s *Tablespace_encryption_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_encryption_specContext) GetEncrypt_algorithm() antlr.Token { + return s.encrypt_algorithm +} + +func (s *Tablespace_encryption_specContext) SetEncrypt_algorithm(v antlr.Token) { + s.encrypt_algorithm = v +} + +func (s *Tablespace_encryption_specContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Tablespace_encryption_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Tablespace_encryption_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_encryption_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_encryption_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_encryption_spec(s) + } +} + +func (s *Tablespace_encryption_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_encryption_spec(s) + } +} + +func (s *Tablespace_encryption_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_encryption_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_encryption_spec() (localctx ITablespace_encryption_specContext) { + localctx = NewTablespace_encryption_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 880, PlSqlParserRULE_tablespace_encryption_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9211) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9212) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Tablespace_encryption_specContext).encrypt_algorithm = _m + 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 +} + +// ILogging_clauseContext is an interface to support dynamic dispatch. +type ILogging_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGGING() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode + + // IsLogging_clauseContext differentiates from other interfaces. + IsLogging_clauseContext() +} + +type Logging_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogging_clauseContext() *Logging_clauseContext { + var p = new(Logging_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logging_clause + return p +} + +func InitEmptyLogging_clauseContext(p *Logging_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logging_clause +} + +func (*Logging_clauseContext) IsLogging_clauseContext() {} + +func NewLogging_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logging_clauseContext { + var p = new(Logging_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logging_clause + + return p +} + +func (s *Logging_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logging_clauseContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Logging_clauseContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Logging_clauseContext) FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESYSTEM_LIKE_LOGGING, 0) +} + +func (s *Logging_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logging_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logging_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogging_clause(s) + } +} + +func (s *Logging_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogging_clause(s) + } +} + +func (s *Logging_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogging_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logging_clause() (localctx ILogging_clauseContext) { + localctx = NewLogging_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 882, PlSqlParserRULE_logging_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9214) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING) { + 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 +} + +// IExtent_management_clauseContext is an interface to support dynamic dispatch. +type IExtent_management_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTENT() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + AUTOALLOCATE() antlr.TerminalNode + UNIFORM() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsExtent_management_clauseContext differentiates from other interfaces. + IsExtent_management_clauseContext() +} + +type Extent_management_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExtent_management_clauseContext() *Extent_management_clauseContext { + var p = new(Extent_management_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extent_management_clause + return p +} + +func InitEmptyExtent_management_clauseContext(p *Extent_management_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_extent_management_clause +} + +func (*Extent_management_clauseContext) IsExtent_management_clauseContext() {} + +func NewExtent_management_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Extent_management_clauseContext { + var p = new(Extent_management_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_extent_management_clause + + return p +} + +func (s *Extent_management_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Extent_management_clauseContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Extent_management_clauseContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Extent_management_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Extent_management_clauseContext) AUTOALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOALLOCATE, 0) +} + +func (s *Extent_management_clauseContext) UNIFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIFORM, 0) +} + +func (s *Extent_management_clauseContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Extent_management_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Extent_management_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Extent_management_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Extent_management_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExtent_management_clause(s) + } +} + +func (s *Extent_management_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExtent_management_clause(s) + } +} + +func (s *Extent_management_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExtent_management_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Extent_management_clause() (localctx IExtent_management_clauseContext) { + localctx = NewExtent_management_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 884, PlSqlParserRULE_extent_management_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9216) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9217) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9218) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9225) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1021, p.GetParserRuleContext()) == 1 { + { + p.SetState(9219) + p.Match(PlSqlParserAUTOALLOCATE) + 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(), 1021, p.GetParserRuleContext()) == 2 { + { + p.SetState(9220) + p.Match(PlSqlParserUNIFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9223) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1020, p.GetParserRuleContext()) == 1 { + { + p.SetState(9221) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9222) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISegment_management_clauseContext is an interface to support dynamic dispatch. +type ISegment_management_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + AUTO() antlr.TerminalNode + MANUAL() antlr.TerminalNode + + // IsSegment_management_clauseContext differentiates from other interfaces. + IsSegment_management_clauseContext() +} + +type Segment_management_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySegment_management_clauseContext() *Segment_management_clauseContext { + var p = new(Segment_management_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_management_clause + return p +} + +func InitEmptySegment_management_clauseContext(p *Segment_management_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_management_clause +} + +func (*Segment_management_clauseContext) IsSegment_management_clauseContext() {} + +func NewSegment_management_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_management_clauseContext { + var p = new(Segment_management_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_management_clause + + return p +} + +func (s *Segment_management_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_management_clauseContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Segment_management_clauseContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Segment_management_clauseContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Segment_management_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Segment_management_clauseContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Segment_management_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_management_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_management_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_management_clause(s) + } +} + +func (s *Segment_management_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_management_clause(s) + } +} + +func (s *Segment_management_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSegment_management_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Segment_management_clause() (localctx ISegment_management_clauseContext) { + localctx = NewSegment_management_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 886, PlSqlParserRULE_segment_management_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9227) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9228) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9229) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9230) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTO || _la == PlSqlParserMANUAL) { + 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 +} + +// ITemporary_tablespace_clauseContext is an interface to support dynamic dispatch. +type ITemporary_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + TEMPORARY() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Tempfile_specification() ITempfile_specificationContext + Tablespace_group_clause() ITablespace_group_clauseContext + Extent_management_clause() IExtent_management_clauseContext + + // IsTemporary_tablespace_clauseContext differentiates from other interfaces. + IsTemporary_tablespace_clauseContext() +} + +type Temporary_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyTemporary_tablespace_clauseContext() *Temporary_tablespace_clauseContext { + var p = new(Temporary_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause + return p +} + +func InitEmptyTemporary_tablespace_clauseContext(p *Temporary_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause +} + +func (*Temporary_tablespace_clauseContext) IsTemporary_tablespace_clauseContext() {} + +func NewTemporary_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Temporary_tablespace_clauseContext { + var p = new(Temporary_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_temporary_tablespace_clause + + return p +} + +func (s *Temporary_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Temporary_tablespace_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Temporary_tablespace_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Temporary_tablespace_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Temporary_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Temporary_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Temporary_tablespace_clauseContext) Tempfile_specification() ITempfile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITempfile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITempfile_specificationContext) +} + +func (s *Temporary_tablespace_clauseContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Temporary_tablespace_clauseContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Temporary_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Temporary_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Temporary_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTemporary_tablespace_clause(s) + } +} + +func (s *Temporary_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTemporary_tablespace_clause(s) + } +} + +func (s *Temporary_tablespace_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTemporary_tablespace_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Temporary_tablespace_clause() (localctx ITemporary_tablespace_clauseContext) { + localctx = NewTemporary_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 888, PlSqlParserRULE_temporary_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9232) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9233) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9234) + + var _x = p.Id_expression() + + localctx.(*Temporary_tablespace_clauseContext).tablespace_name = _x + } + p.SetState(9236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTEMPFILE { + { + p.SetState(9235) + p.Tempfile_specification() + } + + } + p.SetState(9239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(9238) + p.Tablespace_group_clause() + } + + } + p.SetState(9242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENT { + { + p.SetState(9241) + p.Extent_management_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 +} + +// IUndo_tablespace_clauseContext is an interface to support dynamic dispatch. +type IUndo_tablespace_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + UNDO() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Datafile_specification() IDatafile_specificationContext + Extent_management_clause() IExtent_management_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + + // IsUndo_tablespace_clauseContext differentiates from other interfaces. + IsUndo_tablespace_clauseContext() +} + +type Undo_tablespace_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyUndo_tablespace_clauseContext() *Undo_tablespace_clauseContext { + var p = new(Undo_tablespace_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause + return p +} + +func InitEmptyUndo_tablespace_clauseContext(p *Undo_tablespace_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause +} + +func (*Undo_tablespace_clauseContext) IsUndo_tablespace_clauseContext() {} + +func NewUndo_tablespace_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_tablespace_clauseContext { + var p = new(Undo_tablespace_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_tablespace_clause + + return p +} + +func (s *Undo_tablespace_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_tablespace_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Undo_tablespace_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Undo_tablespace_clauseContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_tablespace_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Undo_tablespace_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Undo_tablespace_clauseContext) Datafile_specification() IDatafile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_specificationContext) +} + +func (s *Undo_tablespace_clauseContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Undo_tablespace_clauseContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Undo_tablespace_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_tablespace_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_tablespace_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_tablespace_clause(s) + } +} + +func (s *Undo_tablespace_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_tablespace_clause(s) + } +} + +func (s *Undo_tablespace_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUndo_tablespace_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Undo_tablespace_clause() (localctx IUndo_tablespace_clauseContext) { + localctx = NewUndo_tablespace_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 890, PlSqlParserRULE_undo_tablespace_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9244) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9245) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9246) + + var _x = p.Id_expression() + + localctx.(*Undo_tablespace_clauseContext).tablespace_name = _x + } + p.SetState(9248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9247) + p.Datafile_specification() + } + + } + p.SetState(9251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENT { + { + p.SetState(9250) + p.Extent_management_clause() + } + + } + p.SetState(9254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETENTION { + { + p.SetState(9253) + p.Tablespace_retention_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 +} + +// ITablespace_retention_clauseContext is an interface to support dynamic dispatch. +type ITablespace_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + NOGUARANTEE() antlr.TerminalNode + + // IsTablespace_retention_clauseContext differentiates from other interfaces. + IsTablespace_retention_clauseContext() +} + +type Tablespace_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_retention_clauseContext() *Tablespace_retention_clauseContext { + var p = new(Tablespace_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause + return p +} + +func InitEmptyTablespace_retention_clauseContext(p *Tablespace_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause +} + +func (*Tablespace_retention_clauseContext) IsTablespace_retention_clauseContext() {} + +func NewTablespace_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_retention_clauseContext { + var p = new(Tablespace_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_retention_clause + + return p +} + +func (s *Tablespace_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_retention_clauseContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Tablespace_retention_clauseContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Tablespace_retention_clauseContext) NOGUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOGUARANTEE, 0) +} + +func (s *Tablespace_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_retention_clause(s) + } +} + +func (s *Tablespace_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_retention_clause(s) + } +} + +func (s *Tablespace_retention_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_retention_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_retention_clause() (localctx ITablespace_retention_clauseContext) { + localctx = NewTablespace_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 892, PlSqlParserRULE_tablespace_retention_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9256) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9257) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGUARANTEE || _la == PlSqlParserNOGUARANTEE) { + 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_tablespace_setContext is an interface to support dynamic dispatch. +type ICreate_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // GetSs returns the ss rule contexts. + GetSs() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // SetSs sets the ss rule contexts. + SetSs(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + IN() antlr.TerminalNode + SHARDSPACE() antlr.TerminalNode + USING() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + AllPermanent_tablespace_attrs() []IPermanent_tablespace_attrsContext + Permanent_tablespace_attrs(i int) IPermanent_tablespace_attrsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCreate_tablespace_setContext differentiates from other interfaces. + IsCreate_tablespace_setContext() +} + +type Create_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext + ss IId_expressionContext +} + +func NewEmptyCreate_tablespace_setContext() *Create_tablespace_setContext { + var p = new(Create_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace_set + return p +} + +func InitEmptyCreate_tablespace_setContext(p *Create_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_tablespace_set +} + +func (*Create_tablespace_setContext) IsCreate_tablespace_setContext() {} + +func NewCreate_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_tablespace_setContext { + var p = new(Create_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_tablespace_set + + return p +} + +func (s *Create_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Create_tablespace_setContext) GetSs() IId_expressionContext { return s.ss } + +func (s *Create_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Create_tablespace_setContext) SetSs(v IId_expressionContext) { s.ss = v } + +func (s *Create_tablespace_setContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Create_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Create_tablespace_setContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_tablespace_setContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Create_tablespace_setContext) SHARDSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDSPACE, 0) +} + +func (s *Create_tablespace_setContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_tablespace_setContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Create_tablespace_setContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_tablespace_setContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_tablespace_setContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_tablespace_setContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Create_tablespace_setContext) AllPermanent_tablespace_attrs() []IPermanent_tablespace_attrsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + len++ + } + } + + tst := make([]IPermanent_tablespace_attrsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + tst[i] = t.(IPermanent_tablespace_attrsContext) + i++ + } + } + + return tst +} + +func (s *Create_tablespace_setContext) Permanent_tablespace_attrs(i int) IPermanent_tablespace_attrsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPermanent_tablespace_attrsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPermanent_tablespace_attrsContext) +} + +func (s *Create_tablespace_setContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_tablespace_setContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_tablespace_set(s) + } +} + +func (s *Create_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_tablespace_set(s) + } +} + +func (s *Create_tablespace_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_tablespace_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_tablespace_set() (localctx ICreate_tablespace_setContext) { + localctx = NewCreate_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 894, PlSqlParserRULE_create_tablespace_set) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9259) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9260) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9261) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9262) + + var _x = p.Id_expression() + + localctx.(*Create_tablespace_setContext).tss = _x + } + p.SetState(9266) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1028, p.GetParserRuleContext()) == 1 { + { + p.SetState(9263) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9264) + p.Match(PlSqlParserSHARDSPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9265) + + var _x = p.Id_expression() + + localctx.(*Create_tablespace_setContext).ss = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9289) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1032, p.GetParserRuleContext()) == 1 { + { + p.SetState(9268) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9269) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9270) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATAFILE { + { + p.SetState(9271) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9272) + p.File_specification() + } + p.SetState(9277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9273) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9274) + p.File_specification() + } + + p.SetState(9279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + p.SetState(9283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBLOCKSIZE || _la == PlSqlParserDEFAULT || _la == PlSqlParserDISABLE || ((int64((_la-453)) & ^0x3f) == 0 && ((int64(1)<<(_la-453))&4503599627370529) != 0) || ((int64((_la-538)) & ^0x3f) == 0 && ((int64(1)<<(_la-538))&4196353) != 0) || _la == PlSqlParserLOGGING || _la == PlSqlParserMINIMUM || _la == PlSqlParserNOLOGGING || _la == PlSqlParserOFFLINE || _la == PlSqlParserONLINE || _la == PlSqlParserREMOVE || _la == PlSqlParserSEGMENT || _la == PlSqlParserSUSPEND { + { + p.SetState(9282) + p.Permanent_tablespace_attrs() + } + + p.SetState(9285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9287) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPermanent_tablespace_attrsContext is an interface to support dynamic dispatch. +type IPermanent_tablespace_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + BLOCKSIZE() antlr.TerminalNode + Numeric() INumericContext + K_LETTER() antlr.TerminalNode + Logging_clause() ILogging_clauseContext + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + Tablespace_encryption_clause() ITablespace_encryption_clauseContext + Default_tablespace_params() IDefault_tablespace_paramsContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + Extent_management_clause() IExtent_management_clauseContext + Segment_management_clause() ISegment_management_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Lost_write_protection() ILost_write_protectionContext + + // IsPermanent_tablespace_attrsContext differentiates from other interfaces. + IsPermanent_tablespace_attrsContext() +} + +type Permanent_tablespace_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPermanent_tablespace_attrsContext() *Permanent_tablespace_attrsContext { + var p = new(Permanent_tablespace_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs + return p +} + +func InitEmptyPermanent_tablespace_attrsContext(p *Permanent_tablespace_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs +} + +func (*Permanent_tablespace_attrsContext) IsPermanent_tablespace_attrsContext() {} + +func NewPermanent_tablespace_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Permanent_tablespace_attrsContext { + var p = new(Permanent_tablespace_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_permanent_tablespace_attrs + + return p +} + +func (s *Permanent_tablespace_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Permanent_tablespace_attrsContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Permanent_tablespace_attrsContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Permanent_tablespace_attrsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Permanent_tablespace_attrsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Permanent_tablespace_attrsContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Permanent_tablespace_attrsContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Permanent_tablespace_attrsContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Permanent_tablespace_attrsContext) Tablespace_encryption_clause() ITablespace_encryption_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Default_tablespace_params() IDefault_tablespace_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespace_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespace_paramsContext) +} + +func (s *Permanent_tablespace_attrsContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Permanent_tablespace_attrsContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Permanent_tablespace_attrsContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Segment_management_clause() ISegment_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_management_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Permanent_tablespace_attrsContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Permanent_tablespace_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Permanent_tablespace_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Permanent_tablespace_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPermanent_tablespace_attrs(s) + } +} + +func (s *Permanent_tablespace_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPermanent_tablespace_attrs(s) + } +} + +func (s *Permanent_tablespace_attrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPermanent_tablespace_attrs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Permanent_tablespace_attrs() (localctx IPermanent_tablespace_attrsContext) { + localctx = NewPermanent_tablespace_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 896, PlSqlParserRULE_permanent_tablespace_attrs) + var _la int + + p.SetState(9310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMINIMUM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9291) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9292) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9293) + p.Size_clause() + } + + case PlSqlParserBLOCKSIZE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9294) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9295) + p.Numeric() + } + p.SetState(9297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserK_LETTER { + { + p.SetState(9296) + p.Match(PlSqlParserK_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(9299) + p.Logging_clause() + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(9300) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9301) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENCRYPTION: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(9302) + p.Tablespace_encryption_clause() + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(9303) + p.Default_tablespace_params() + } + + case PlSqlParserONLINE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(9304) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(9305) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTENT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(9306) + p.Extent_management_clause() + } + + case PlSqlParserSEGMENT: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(9307) + p.Segment_management_clause() + } + + case PlSqlParserFLASHBACK: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(9308) + p.Flashback_mode_clause() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserREMOVE, PlSqlParserSUSPEND: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(9309) + p.Lost_write_protection() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_encryption_clauseContext is an interface to support dynamic dispatch. +type ITablespace_encryption_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + Tablespace_encryption_spec() ITablespace_encryption_specContext + + // IsTablespace_encryption_clauseContext differentiates from other interfaces. + IsTablespace_encryption_clauseContext() +} + +type Tablespace_encryption_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_encryption_clauseContext() *Tablespace_encryption_clauseContext { + var p = new(Tablespace_encryption_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause + return p +} + +func InitEmptyTablespace_encryption_clauseContext(p *Tablespace_encryption_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause +} + +func (*Tablespace_encryption_clauseContext) IsTablespace_encryption_clauseContext() {} + +func NewTablespace_encryption_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_encryption_clauseContext { + var p = new(Tablespace_encryption_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_encryption_clause + + return p +} + +func (s *Tablespace_encryption_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_encryption_clauseContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Tablespace_encryption_clauseContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Tablespace_encryption_clauseContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Tablespace_encryption_clauseContext) Tablespace_encryption_spec() ITablespace_encryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Tablespace_encryption_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_encryption_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_encryption_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_encryption_clause(s) + } +} + +func (s *Tablespace_encryption_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_encryption_clause(s) + } +} + +func (s *Tablespace_encryption_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_encryption_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_encryption_clause() (localctx ITablespace_encryption_clauseContext) { + localctx = NewTablespace_encryption_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 898, PlSqlParserRULE_tablespace_encryption_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9312) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserUSING: + p.SetState(9314) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(9313) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(9316) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(9317) + p.Match(PlSqlParserDECRYPT) + 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 +} + +// IDefault_tablespace_paramsContext is an interface to support dynamic dispatch. +type IDefault_tablespace_paramsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Default_table_compression() IDefault_table_compressionContext + Default_index_compression() IDefault_index_compressionContext + Inmmemory_clause() IInmmemory_clauseContext + Ilm_clause() IIlm_clauseContext + Storage_clause() IStorage_clauseContext + + // IsDefault_tablespace_paramsContext differentiates from other interfaces. + IsDefault_tablespace_paramsContext() +} + +type Default_tablespace_paramsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_tablespace_paramsContext() *Default_tablespace_paramsContext { + var p = new(Default_tablespace_paramsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace_params + return p +} + +func InitEmptyDefault_tablespace_paramsContext(p *Default_tablespace_paramsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace_params +} + +func (*Default_tablespace_paramsContext) IsDefault_tablespace_paramsContext() {} + +func NewDefault_tablespace_paramsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_tablespace_paramsContext { + var p = new(Default_tablespace_paramsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_tablespace_params + + return p +} + +func (s *Default_tablespace_paramsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_tablespace_paramsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_tablespace_paramsContext) Default_table_compression() IDefault_table_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_table_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_table_compressionContext) +} + +func (s *Default_tablespace_paramsContext) Default_index_compression() IDefault_index_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_index_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_index_compressionContext) +} + +func (s *Default_tablespace_paramsContext) Inmmemory_clause() IInmmemory_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmmemory_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmmemory_clauseContext) +} + +func (s *Default_tablespace_paramsContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Default_tablespace_paramsContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Default_tablespace_paramsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_tablespace_paramsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_tablespace_paramsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_tablespace_params(s) + } +} + +func (s *Default_tablespace_paramsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_tablespace_params(s) + } +} + +func (s *Default_tablespace_paramsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_tablespace_params(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_tablespace_params() (localctx IDefault_tablespace_paramsContext) { + localctx = NewDefault_tablespace_paramsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 900, PlSqlParserRULE_default_tablespace_params) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9320) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9322) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1037, p.GetParserRuleContext()) == 1 { + { + p.SetState(9321) + p.Default_table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9325) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1038, p.GetParserRuleContext()) == 1 { + { + p.SetState(9324) + p.Default_index_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9328) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1039, p.GetParserRuleContext()) == 1 { + { + p.SetState(9327) + p.Inmmemory_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9331) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1040, p.GetParserRuleContext()) == 1 { + { + p.SetState(9330) + p.Ilm_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9334) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1041, p.GetParserRuleContext()) == 1 { + { + p.SetState(9333) + p.Storage_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 +} + +// IDefault_table_compressionContext is an interface to support dynamic dispatch. +type IDefault_table_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + FOR() antlr.TerminalNode + NOCOMPRESS() antlr.TerminalNode + OLTP() antlr.TerminalNode + QUERY() antlr.TerminalNode + Low_high() ILow_highContext + ARCHIVE() antlr.TerminalNode + + // IsDefault_table_compressionContext differentiates from other interfaces. + IsDefault_table_compressionContext() +} + +type Default_table_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_table_compressionContext() *Default_table_compressionContext { + var p = new(Default_table_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_table_compression + return p +} + +func InitEmptyDefault_table_compressionContext(p *Default_table_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_table_compression +} + +func (*Default_table_compressionContext) IsDefault_table_compressionContext() {} + +func NewDefault_table_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_table_compressionContext { + var p = new(Default_table_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_table_compression + + return p +} + +func (s *Default_table_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_table_compressionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Default_table_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Default_table_compressionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Default_table_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Default_table_compressionContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Default_table_compressionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Default_table_compressionContext) Low_high() ILow_highContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_highContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_highContext) +} + +func (s *Default_table_compressionContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Default_table_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_table_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_table_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_table_compression(s) + } +} + +func (s *Default_table_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_table_compression(s) + } +} + +func (s *Default_table_compressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_table_compression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_table_compression() (localctx IDefault_table_compressionContext) { + localctx = NewDefault_table_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 902, PlSqlParserRULE_default_table_compression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9336) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + { + p.SetState(9337) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9338) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9344) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOLTP: + { + p.SetState(9339) + p.Match(PlSqlParserOLTP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserQUERY: + { + p.SetState(9340) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9341) + p.Low_high() + } + + case PlSqlParserARCHIVE: + { + p.SetState(9342) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9343) + p.Low_high() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserNOCOMPRESS: + { + p.SetState(9346) + p.Match(PlSqlParserNOCOMPRESS) + 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 +} + +// ILow_highContext is an interface to support dynamic dispatch. +type ILow_highContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + + // IsLow_highContext differentiates from other interfaces. + IsLow_highContext() +} + +type Low_highContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLow_highContext() *Low_highContext { + var p = new(Low_highContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_low_high + return p +} + +func InitEmptyLow_highContext(p *Low_highContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_low_high +} + +func (*Low_highContext) IsLow_highContext() {} + +func NewLow_highContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Low_highContext { + var p = new(Low_highContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_low_high + + return p +} + +func (s *Low_highContext) GetParser() antlr.Parser { return s.parser } + +func (s *Low_highContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Low_highContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Low_highContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Low_highContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Low_highContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLow_high(s) + } +} + +func (s *Low_highContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLow_high(s) + } +} + +func (s *Low_highContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLow_high(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Low_high() (localctx ILow_highContext) { + localctx = NewLow_highContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 904, PlSqlParserRULE_low_high) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9349) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + 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 +} + +// IDefault_index_compressionContext is an interface to support dynamic dispatch. +type IDefault_index_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEX() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + Low_high() ILow_highContext + NOCOMPRESS() antlr.TerminalNode + + // IsDefault_index_compressionContext differentiates from other interfaces. + IsDefault_index_compressionContext() +} + +type Default_index_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_index_compressionContext() *Default_index_compressionContext { + var p = new(Default_index_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_index_compression + return p +} + +func InitEmptyDefault_index_compressionContext(p *Default_index_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_index_compression +} + +func (*Default_index_compressionContext) IsDefault_index_compressionContext() {} + +func NewDefault_index_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_index_compressionContext { + var p = new(Default_index_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_index_compression + + return p +} + +func (s *Default_index_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_index_compressionContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Default_index_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Default_index_compressionContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Default_index_compressionContext) Low_high() ILow_highContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILow_highContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILow_highContext) +} + +func (s *Default_index_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Default_index_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_index_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_index_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_index_compression(s) + } +} + +func (s *Default_index_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_index_compression(s) + } +} + +func (s *Default_index_compressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_index_compression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_index_compression() (localctx IDefault_index_compressionContext) { + localctx = NewDefault_index_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 906, PlSqlParserRULE_default_index_compression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9351) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + { + p.SetState(9352) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9353) + p.Match(PlSqlParserADVANCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9354) + p.Low_high() + } + + case PlSqlParserNOCOMPRESS: + { + p.SetState(9355) + p.Match(PlSqlParserNOCOMPRESS) + 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 +} + +// IInmmemory_clauseContext is an interface to support dynamic dispatch. +type IInmmemory_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INMEMORY() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + TEXT() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllPolicy_name() []IPolicy_nameContext + Policy_name(i int) IPolicy_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmmemory_clauseContext differentiates from other interfaces. + IsInmmemory_clauseContext() +} + +type Inmmemory_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmmemory_clauseContext() *Inmmemory_clauseContext { + var p = new(Inmmemory_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmmemory_clause + return p +} + +func InitEmptyInmmemory_clauseContext(p *Inmmemory_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmmemory_clause +} + +func (*Inmmemory_clauseContext) IsInmmemory_clauseContext() {} + +func NewInmmemory_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmmemory_clauseContext { + var p = new(Inmmemory_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmmemory_clause + + return p +} + +func (s *Inmmemory_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmmemory_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmmemory_clauseContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Inmmemory_clauseContext) TEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEXT, 0) +} + +func (s *Inmmemory_clauseContext) 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 *Inmmemory_clauseContext) 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 *Inmmemory_clauseContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Inmmemory_clauseContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Inmmemory_clauseContext) AllPolicy_name() []IPolicy_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPolicy_nameContext); ok { + len++ + } + } + + tst := make([]IPolicy_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPolicy_nameContext); ok { + tst[i] = t.(IPolicy_nameContext) + i++ + } + } + + return tst +} + +func (s *Inmmemory_clauseContext) Policy_name(i int) IPolicy_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPolicy_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPolicy_nameContext) +} + +func (s *Inmmemory_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Inmmemory_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Inmmemory_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmmemory_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmmemory_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmmemory_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmmemory_clause(s) + } +} + +func (s *Inmmemory_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmmemory_clause(s) + } +} + +func (s *Inmmemory_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmmemory_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmmemory_clause() (localctx IInmmemory_clauseContext) { + localctx = NewInmmemory_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 908, PlSqlParserRULE_inmmemory_clause) + var _alt int + + p.SetState(9390) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9358) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9360) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1045, p.GetParserRuleContext()) == 1 { + { + p.SetState(9359) + p.Inmemory_attributes() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9386) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1049, p.GetParserRuleContext()) == 1 { + { + p.SetState(9362) + p.Match(PlSqlParserTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1048, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9363) + p.Column_name() + } + p.SetState(9368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1046, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9364) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9365) + p.Column_name() + } + + } + p.SetState(9370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1046, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(9371) + p.Column_name() + } + { + p.SetState(9372) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9373) + p.Policy_name() + } + p.SetState(9381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9374) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9375) + p.Column_name() + } + { + p.SetState(9376) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9377) + p.Policy_name() + } + + } + p.SetState(9383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1047, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9388) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9389) + p.Match(PlSqlParserINMEMORY) + 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 +} + +// IDatafile_specificationContext is an interface to support dynamic dispatch. +type IDatafile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + COMMA() antlr.TerminalNode + + // IsDatafile_specificationContext differentiates from other interfaces. + IsDatafile_specificationContext() +} + +type Datafile_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_specificationContext() *Datafile_specificationContext { + var p = new(Datafile_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_specification + return p +} + +func InitEmptyDatafile_specificationContext(p *Datafile_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_specification +} + +func (*Datafile_specificationContext) IsDatafile_specificationContext() {} + +func NewDatafile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_specificationContext { + var p = new(Datafile_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_specification + + return p +} + +func (s *Datafile_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_specificationContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Datafile_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Datafile_specificationContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Datafile_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_specification(s) + } +} + +func (s *Datafile_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_specification(s) + } +} + +func (s *Datafile_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatafile_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datafile_specification() (localctx IDatafile_specificationContext) { + localctx = NewDatafile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 910, PlSqlParserRULE_datafile_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9392) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9394) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1051, p.GetParserRuleContext()) == 1 { + { + p.SetState(9393) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9396) + p.Datafile_tempfile_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITempfile_specificationContext is an interface to support dynamic dispatch. +type ITempfile_specificationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + COMMA() antlr.TerminalNode + + // IsTempfile_specificationContext differentiates from other interfaces. + IsTempfile_specificationContext() +} + +type Tempfile_specificationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTempfile_specificationContext() *Tempfile_specificationContext { + var p = new(Tempfile_specificationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tempfile_specification + return p +} + +func InitEmptyTempfile_specificationContext(p *Tempfile_specificationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tempfile_specification +} + +func (*Tempfile_specificationContext) IsTempfile_specificationContext() {} + +func NewTempfile_specificationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tempfile_specificationContext { + var p = new(Tempfile_specificationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tempfile_specification + + return p +} + +func (s *Tempfile_specificationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tempfile_specificationContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Tempfile_specificationContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Tempfile_specificationContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Tempfile_specificationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tempfile_specificationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tempfile_specificationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTempfile_specification(s) + } +} + +func (s *Tempfile_specificationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTempfile_specification(s) + } +} + +func (s *Tempfile_specificationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTempfile_specification(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tempfile_specification() (localctx ITempfile_specificationContext) { + localctx = NewTempfile_specificationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 912, PlSqlParserRULE_tempfile_specification) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9398) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(9400) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1052, p.GetParserRuleContext()) == 1 { + { + p.SetState(9399) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(9402) + p.Datafile_tempfile_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatafile_tempfile_specContext is an interface to support dynamic dispatch. +type IDatafile_tempfile_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + SIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + REUSE() antlr.TerminalNode + Autoextend_clause() IAutoextend_clauseContext + + // IsDatafile_tempfile_specContext differentiates from other interfaces. + IsDatafile_tempfile_specContext() +} + +type Datafile_tempfile_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatafile_tempfile_specContext() *Datafile_tempfile_specContext { + var p = new(Datafile_tempfile_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec + return p +} + +func InitEmptyDatafile_tempfile_specContext(p *Datafile_tempfile_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec +} + +func (*Datafile_tempfile_specContext) IsDatafile_tempfile_specContext() {} + +func NewDatafile_tempfile_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datafile_tempfile_specContext { + var p = new(Datafile_tempfile_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datafile_tempfile_spec + + return p +} + +func (s *Datafile_tempfile_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datafile_tempfile_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Datafile_tempfile_specContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Datafile_tempfile_specContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Datafile_tempfile_specContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Datafile_tempfile_specContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Datafile_tempfile_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datafile_tempfile_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datafile_tempfile_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatafile_tempfile_spec(s) + } +} + +func (s *Datafile_tempfile_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatafile_tempfile_spec(s) + } +} + +func (s *Datafile_tempfile_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatafile_tempfile_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datafile_tempfile_spec() (localctx IDatafile_tempfile_specContext) { + localctx = NewDatafile_tempfile_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 914, PlSqlParserRULE_datafile_tempfile_spec) + p.EnterOuterAlt(localctx, 1) + p.SetState(9405) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1053, p.GetParserRuleContext()) == 1 { + { + p.SetState(9404) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9409) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1054, p.GetParserRuleContext()) == 1 { + { + p.SetState(9407) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9408) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9412) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1055, p.GetParserRuleContext()) == 1 { + { + p.SetState(9411) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9415) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1056, p.GetParserRuleContext()) == 1 { + { + p.SetState(9414) + p.Autoextend_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 +} + +// IRedo_log_file_specContext is an interface to support dynamic dispatch. +type IRedo_log_file_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SIZE() antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + BLOCKSIZE() antlr.TerminalNode + REUSE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRedo_log_file_specContext differentiates from other interfaces. + IsRedo_log_file_specContext() +} + +type Redo_log_file_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRedo_log_file_specContext() *Redo_log_file_specContext { + var p = new(Redo_log_file_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec + return p +} + +func InitEmptyRedo_log_file_specContext(p *Redo_log_file_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec +} + +func (*Redo_log_file_specContext) IsRedo_log_file_specContext() {} + +func NewRedo_log_file_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Redo_log_file_specContext { + var p = new(Redo_log_file_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_redo_log_file_spec + + return p +} + +func (s *Redo_log_file_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Redo_log_file_specContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Redo_log_file_specContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Redo_log_file_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Redo_log_file_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Redo_log_file_specContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Redo_log_file_specContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Redo_log_file_specContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Redo_log_file_specContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Redo_log_file_specContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Redo_log_file_specContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Redo_log_file_specContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Redo_log_file_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Redo_log_file_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Redo_log_file_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRedo_log_file_spec(s) + } +} + +func (s *Redo_log_file_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRedo_log_file_spec(s) + } +} + +func (s *Redo_log_file_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRedo_log_file_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Redo_log_file_spec() (localctx IRedo_log_file_specContext) { + localctx = NewRedo_log_file_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 916, PlSqlParserRULE_redo_log_file_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(9417) + p.Filename() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9418) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9419) + p.Filename() + } + p.SetState(9424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9420) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9421) + p.Filename() + } + + p.SetState(9426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9427) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9433) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1059, p.GetParserRuleContext()) == 1 { + { + p.SetState(9431) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9432) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9437) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1060, p.GetParserRuleContext()) == 1 { + { + p.SetState(9435) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9436) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9440) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1061, p.GetParserRuleContext()) == 1 { + { + p.SetState(9439) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAutoextend_clauseContext is an interface to support dynamic dispatch. +type IAutoextend_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTOEXTEND() antlr.TerminalNode + OFF() antlr.TerminalNode + ON() antlr.TerminalNode + NEXT() antlr.TerminalNode + Size_clause() ISize_clauseContext + Maxsize_clause() IMaxsize_clauseContext + + // IsAutoextend_clauseContext differentiates from other interfaces. + IsAutoextend_clauseContext() +} + +type Autoextend_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAutoextend_clauseContext() *Autoextend_clauseContext { + var p = new(Autoextend_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autoextend_clause + return p +} + +func InitEmptyAutoextend_clauseContext(p *Autoextend_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autoextend_clause +} + +func (*Autoextend_clauseContext) IsAutoextend_clauseContext() {} + +func NewAutoextend_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Autoextend_clauseContext { + var p = new(Autoextend_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_autoextend_clause + + return p +} + +func (s *Autoextend_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Autoextend_clauseContext) AUTOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOEXTEND, 0) +} + +func (s *Autoextend_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Autoextend_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Autoextend_clauseContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Autoextend_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Autoextend_clauseContext) Maxsize_clause() IMaxsize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaxsize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaxsize_clauseContext) +} + +func (s *Autoextend_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Autoextend_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Autoextend_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAutoextend_clause(s) + } +} + +func (s *Autoextend_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAutoextend_clause(s) + } +} + +func (s *Autoextend_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAutoextend_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Autoextend_clause() (localctx IAutoextend_clauseContext) { + localctx = NewAutoextend_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 918, PlSqlParserRULE_autoextend_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9442) + p.Match(PlSqlParserAUTOEXTEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOFF: + { + p.SetState(9443) + p.Match(PlSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserON: + { + p.SetState(9444) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9447) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1062, p.GetParserRuleContext()) == 1 { + { + p.SetState(9445) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9446) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9450) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1063, p.GetParserRuleContext()) == 1 { + { + p.SetState(9449) + p.Maxsize_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMaxsize_clauseContext is an interface to support dynamic dispatch. +type IMaxsize_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAXSIZE() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsMaxsize_clauseContext differentiates from other interfaces. + IsMaxsize_clauseContext() +} + +type Maxsize_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaxsize_clauseContext() *Maxsize_clauseContext { + var p = new(Maxsize_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maxsize_clause + return p +} + +func InitEmptyMaxsize_clauseContext(p *Maxsize_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maxsize_clause +} + +func (*Maxsize_clauseContext) IsMaxsize_clauseContext() {} + +func NewMaxsize_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maxsize_clauseContext { + var p = new(Maxsize_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_maxsize_clause + + return p +} + +func (s *Maxsize_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maxsize_clauseContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXSIZE, 0) +} + +func (s *Maxsize_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Maxsize_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Maxsize_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maxsize_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maxsize_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMaxsize_clause(s) + } +} + +func (s *Maxsize_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMaxsize_clause(s) + } +} + +func (s *Maxsize_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMaxsize_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Maxsize_clause() (localctx IMaxsize_clauseContext) { + localctx = NewMaxsize_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 920, PlSqlParserRULE_maxsize_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9454) + p.Match(PlSqlParserMAXSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNLIMITED: + { + p.SetState(9455) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(9456) + p.Size_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 +} + +// IBuild_clauseContext is an interface to support dynamic dispatch. +type IBuild_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BUILD() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + + // IsBuild_clauseContext differentiates from other interfaces. + IsBuild_clauseContext() +} + +type Build_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBuild_clauseContext() *Build_clauseContext { + var p = new(Build_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_build_clause + return p +} + +func InitEmptyBuild_clauseContext(p *Build_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_build_clause +} + +func (*Build_clauseContext) IsBuild_clauseContext() {} + +func NewBuild_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Build_clauseContext { + var p = new(Build_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_build_clause + + return p +} + +func (s *Build_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Build_clauseContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *Build_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Build_clauseContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Build_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Build_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Build_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBuild_clause(s) + } +} + +func (s *Build_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBuild_clause(s) + } +} + +func (s *Build_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBuild_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Build_clause() (localctx IBuild_clauseContext) { + localctx = NewBuild_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 922, PlSqlParserRULE_build_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9459) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9460) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + 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 +} + +// IPartial_index_clauseContext is an interface to support dynamic dispatch. +type IPartial_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEXING() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + FULL() antlr.TerminalNode + + // IsPartial_index_clauseContext differentiates from other interfaces. + IsPartial_index_clauseContext() +} + +type Partial_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartial_index_clauseContext() *Partial_index_clauseContext { + var p = new(Partial_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_index_clause + return p +} + +func InitEmptyPartial_index_clauseContext(p *Partial_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_index_clause +} + +func (*Partial_index_clauseContext) IsPartial_index_clauseContext() {} + +func NewPartial_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partial_index_clauseContext { + var p = new(Partial_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partial_index_clause + + return p +} + +func (s *Partial_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partial_index_clauseContext) INDEXING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXING, 0) +} + +func (s *Partial_index_clauseContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL, 0) +} + +func (s *Partial_index_clauseContext) FULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL, 0) +} + +func (s *Partial_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partial_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partial_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartial_index_clause(s) + } +} + +func (s *Partial_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartial_index_clause(s) + } +} + +func (s *Partial_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartial_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partial_index_clause() (localctx IPartial_index_clauseContext) { + localctx = NewPartial_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 924, PlSqlParserRULE_partial_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9462) + p.Match(PlSqlParserINDEXING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9463) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFULL || _la == PlSqlParserPARTIAL) { + 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 +} + +// IParallel_clauseContext is an interface to support dynamic dispatch. +type IParallel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetParallel_count returns the parallel_count token. + GetParallel_count() antlr.Token + + // SetParallel_count sets the parallel_count token. + SetParallel_count(antlr.Token) + + // Getter signatures + NOPARALLEL() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsParallel_clauseContext differentiates from other interfaces. + IsParallel_clauseContext() +} + +type Parallel_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + parallel_count antlr.Token +} + +func NewEmptyParallel_clauseContext() *Parallel_clauseContext { + var p = new(Parallel_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_clause + return p +} + +func InitEmptyParallel_clauseContext(p *Parallel_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parallel_clause +} + +func (*Parallel_clauseContext) IsParallel_clauseContext() {} + +func NewParallel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parallel_clauseContext { + var p = new(Parallel_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parallel_clause + + return p +} + +func (s *Parallel_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parallel_clauseContext) GetParallel_count() antlr.Token { return s.parallel_count } + +func (s *Parallel_clauseContext) SetParallel_count(v antlr.Token) { s.parallel_count = v } + +func (s *Parallel_clauseContext) NOPARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL, 0) +} + +func (s *Parallel_clauseContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, 0) +} + +func (s *Parallel_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Parallel_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parallel_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parallel_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParallel_clause(s) + } +} + +func (s *Parallel_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParallel_clause(s) + } +} + +func (s *Parallel_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParallel_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parallel_clause() (localctx IParallel_clauseContext) { + localctx = NewParallel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 926, PlSqlParserRULE_parallel_clause) + p.SetState(9470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOPARALLEL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9465) + p.Match(PlSqlParserNOPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARALLEL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9466) + p.Match(PlSqlParserPARALLEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9468) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1066, p.GetParserRuleContext()) == 1 { + { + p.SetState(9467) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Parallel_clauseContext).parallel_count = _m + 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 +} + +// 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 + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + Modify_mv_column_clause() IModify_mv_column_clauseContext + Table_compression() ITable_compressionContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllModify_lob_storage_clause() []IModify_lob_storage_clauseContext + Modify_lob_storage_clause(i int) IModify_lob_storage_clauseContext + Parallel_clause() IParallel_clauseContext + Logging_clause() ILogging_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Deallocate_unused_clause() IDeallocate_unused_clauseContext + Shrink_clause() IShrink_clauseContext + Alter_iot_clauses() IAlter_iot_clausesContext + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Alter_mv_option1() IAlter_mv_option1Context + Enable_or_disable() IEnable_or_disableContext + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + CONSIDER() antlr.TerminalNode + FRESH() antlr.TerminalNode + Cache_or_nocache() ICache_or_nocacheContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // 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 = PlSqlParserRULE_alter_materialized_view + return p +} + +func InitEmptyAlter_materialized_viewContext(p *Alter_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_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(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_materialized_viewContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_materialized_viewContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_materialized_viewContext) Modify_mv_column_clause() IModify_mv_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_mv_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_mv_column_clauseContext) +} + +func (s *Alter_materialized_viewContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_materialized_viewContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Alter_materialized_viewContext) AllModify_lob_storage_clause() []IModify_lob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]IModify_lob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_lob_storage_clauseContext); ok { + tst[i] = t.(IModify_lob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_materialized_viewContext) Modify_lob_storage_clause(i int) IModify_lob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_storage_clauseContext) +} + +func (s *Alter_materialized_viewContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_materialized_viewContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_materialized_viewContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_materialized_viewContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_materialized_viewContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_materialized_viewContext) Alter_iot_clauses() IAlter_iot_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_iot_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_iot_clausesContext) +} + +func (s *Alter_materialized_viewContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Alter_materialized_viewContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Alter_materialized_viewContext) Alter_mv_option1() IAlter_mv_option1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mv_option1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mv_option1Context) +} + +func (s *Alter_materialized_viewContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_materialized_viewContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Alter_materialized_viewContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Alter_materialized_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_materialized_viewContext) CONSIDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSIDER, 0) +} + +func (s *Alter_materialized_viewContext) FRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRESH, 0) +} + +func (s *Alter_materialized_viewContext) Cache_or_nocache() ICache_or_nocacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_materialized_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_materialized_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_view(s) + } +} + +func (s *Alter_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_view(s) + } +} + +func (s *Alter_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_materialized_view() (localctx IAlter_materialized_viewContext) { + localctx = NewAlter_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 928, PlSqlParserRULE_alter_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9472) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9473) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9474) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9475) + p.Tableview_name() + } + p.SetState(9501) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 1 { + { + p.SetState(9476) + p.Physical_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 2 { + { + p.SetState(9477) + p.Modify_mv_column_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 3 { + { + p.SetState(9478) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 4 { + { + p.SetState(9479) + p.Lob_storage_clause() + } + p.SetState(9484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9480) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9481) + p.Lob_storage_clause() + } + + p.SetState(9486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 5 { + { + p.SetState(9487) + p.Modify_lob_storage_clause() + } + p.SetState(9492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9488) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9489) + p.Modify_lob_storage_clause() + } + + p.SetState(9494) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 6 { + { + p.SetState(9495) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 7 { + { + p.SetState(9496) + p.Logging_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 8 { + { + p.SetState(9497) + p.Allocate_extent_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 9 { + { + p.SetState(9498) + p.Deallocate_unused_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 10 { + { + p.SetState(9499) + p.Shrink_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1070, p.GetParserRuleContext()) == 11 { + { + p.SetState(9500) + p.Cache_or_nocache() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9504) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD || _la == PlSqlParserCOALESCE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(9503) + p.Alter_iot_clauses() + } + + } + p.SetState(9509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(9506) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9507) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9508) + p.Physical_attributes_clause() + } + + } + p.SetState(9512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFRESH { + { + p.SetState(9511) + p.Alter_mv_option1() + } + + } + p.SetState(9521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(9514) + p.Enable_or_disable() + } + { + p.SetState(9515) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9516) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(9518) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSIDER: + { + p.SetState(9519) + p.Match(PlSqlParserCONSIDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9520) + p.Match(PlSqlParserFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEMICOLON: + + default: + } + { + p.SetState(9523) + p.Match(PlSqlParserSEMICOLON) + 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_mv_option1Context is an interface to support dynamic dispatch. +type IAlter_mv_option1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_mv_refresh() IAlter_mv_refreshContext + + // IsAlter_mv_option1Context differentiates from other interfaces. + IsAlter_mv_option1Context() +} + +type Alter_mv_option1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mv_option1Context() *Alter_mv_option1Context { + var p = new(Alter_mv_option1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 + return p +} + +func InitEmptyAlter_mv_option1Context(p *Alter_mv_option1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 +} + +func (*Alter_mv_option1Context) IsAlter_mv_option1Context() {} + +func NewAlter_mv_option1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mv_option1Context { + var p = new(Alter_mv_option1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mv_option1 + + return p +} + +func (s *Alter_mv_option1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mv_option1Context) Alter_mv_refresh() IAlter_mv_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mv_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mv_refreshContext) +} + +func (s *Alter_mv_option1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mv_option1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mv_option1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mv_option1(s) + } +} + +func (s *Alter_mv_option1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mv_option1(s) + } +} + +func (s *Alter_mv_option1Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_mv_option1(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_mv_option1() (localctx IAlter_mv_option1Context) { + localctx = NewAlter_mv_option1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 930, PlSqlParserRULE_alter_mv_option1) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9525) + p.Alter_mv_refresh() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_mv_refreshContext is an interface to support dynamic dispatch. +type IAlter_mv_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH() antlr.TerminalNode + AllFAST() []antlr.TerminalNode + FAST(i int) antlr.TerminalNode + AllCOMPLETE() []antlr.TerminalNode + COMPLETE(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllSTART() []antlr.TerminalNode + START(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllROLLBACK() []antlr.TerminalNode + ROLLBACK(i int) antlr.TerminalNode + AllSEGMENT() []antlr.TerminalNode + SEGMENT(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllDEMAND() []antlr.TerminalNode + DEMAND(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllENFORCED() []antlr.TerminalNode + ENFORCED(i int) antlr.TerminalNode + AllTRUSTED() []antlr.TerminalNode + TRUSTED(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllRollback_segment() []IRollback_segmentContext + Rollback_segment(i int) IRollback_segmentContext + + // IsAlter_mv_refreshContext differentiates from other interfaces. + IsAlter_mv_refreshContext() +} + +type Alter_mv_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mv_refreshContext() *Alter_mv_refreshContext { + var p = new(Alter_mv_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh + return p +} + +func InitEmptyAlter_mv_refreshContext(p *Alter_mv_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh +} + +func (*Alter_mv_refreshContext) IsAlter_mv_refreshContext() {} + +func NewAlter_mv_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mv_refreshContext { + var p = new(Alter_mv_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mv_refresh + + return p +} + +func (s *Alter_mv_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mv_refreshContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Alter_mv_refreshContext) AllFAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAST) +} + +func (s *Alter_mv_refreshContext) FAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, i) +} + +func (s *Alter_mv_refreshContext) AllCOMPLETE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMPLETE) +} + +func (s *Alter_mv_refreshContext) COMPLETE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, i) +} + +func (s *Alter_mv_refreshContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Alter_mv_refreshContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Alter_mv_refreshContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Alter_mv_refreshContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Alter_mv_refreshContext) AllSTART() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTART) +} + +func (s *Alter_mv_refreshContext) START(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, i) +} + +func (s *Alter_mv_refreshContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Alter_mv_refreshContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Alter_mv_refreshContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_mv_refreshContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_mv_refreshContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Alter_mv_refreshContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Alter_mv_refreshContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Alter_mv_refreshContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Alter_mv_refreshContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Alter_mv_refreshContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Alter_mv_refreshContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Alter_mv_refreshContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Alter_mv_refreshContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMASTER) +} + +func (s *Alter_mv_refreshContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, i) +} + +func (s *Alter_mv_refreshContext) AllROLLBACK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROLLBACK) +} + +func (s *Alter_mv_refreshContext) ROLLBACK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, i) +} + +func (s *Alter_mv_refreshContext) AllSEGMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEGMENT) +} + +func (s *Alter_mv_refreshContext) SEGMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, i) +} + +func (s *Alter_mv_refreshContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Alter_mv_refreshContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Alter_mv_refreshContext) AllDEMAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEMAND) +} + +func (s *Alter_mv_refreshContext) DEMAND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, i) +} + +func (s *Alter_mv_refreshContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Alter_mv_refreshContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Alter_mv_refreshContext) AllENFORCED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENFORCED) +} + +func (s *Alter_mv_refreshContext) ENFORCED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, i) +} + +func (s *Alter_mv_refreshContext) AllTRUSTED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRUSTED) +} + +func (s *Alter_mv_refreshContext) TRUSTED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, i) +} + +func (s *Alter_mv_refreshContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Alter_mv_refreshContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Alter_mv_refreshContext) AllRollback_segment() []IRollback_segmentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRollback_segmentContext); ok { + len++ + } + } + + tst := make([]IRollback_segmentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRollback_segmentContext); ok { + tst[i] = t.(IRollback_segmentContext) + i++ + } + } + + return tst +} + +func (s *Alter_mv_refreshContext) Rollback_segment(i int) IRollback_segmentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segmentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segmentContext) +} + +func (s *Alter_mv_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mv_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mv_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mv_refresh(s) + } +} + +func (s *Alter_mv_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mv_refresh(s) + } +} + +func (s *Alter_mv_refreshContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_mv_refresh(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_mv_refresh() (localctx IAlter_mv_refreshContext) { + localctx = NewAlter_mv_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 932, PlSqlParserRULE_alter_mv_refresh) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9527) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE || _la == PlSqlParserNEXT || _la == PlSqlParserON || _la == PlSqlParserSTART || _la == PlSqlParserUSING || _la == PlSqlParserWITH { + p.SetState(9554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1077, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9528) + p.Match(PlSqlParserFAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9529) + p.Match(PlSqlParserCOMPLETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(9530) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(9531) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9532) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserDEMAND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 5: + { + p.SetState(9533) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9534) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9535) + p.Expression() + } + + case 6: + { + p.SetState(9536) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9537) + p.Expression() + } + + case 7: + { + p.SetState(9538) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9539) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9540) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + { + p.SetState(9541) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(9542) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9545) + p.Match(PlSqlParserMASTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9546) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9547) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9549) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1076, p.GetParserRuleContext()) == 1 { + { + p.SetState(9548) + p.Rollback_segment() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + { + p.SetState(9551) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9552) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENFORCED || _la == PlSqlParserTRUSTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9553) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(9556) + 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 +} + +// IRollback_segmentContext is an interface to support dynamic dispatch. +type IRollback_segmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsRollback_segmentContext differentiates from other interfaces. + IsRollback_segmentContext() +} + +type Rollback_segmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_segmentContext() *Rollback_segmentContext { + var p = new(Rollback_segmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment + return p +} + +func InitEmptyRollback_segmentContext(p *Rollback_segmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment +} + +func (*Rollback_segmentContext) IsRollback_segmentContext() {} + +func NewRollback_segmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_segmentContext { + var p = new(Rollback_segmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_segment + + return p +} + +func (s *Rollback_segmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_segmentContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Rollback_segmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_segmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_segmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_segment(s) + } +} + +func (s *Rollback_segmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_segment(s) + } +} + +func (s *Rollback_segmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRollback_segment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rollback_segment() (localctx IRollback_segmentContext) { + localctx = NewRollback_segmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 934, PlSqlParserRULE_rollback_segment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9558) + p.Regular_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 +} + +// IModify_mv_column_clauseContext is an interface to support dynamic dispatch. +type IModify_mv_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + DECRYPT() antlr.TerminalNode + + // IsModify_mv_column_clauseContext differentiates from other interfaces. + IsModify_mv_column_clauseContext() +} + +type Modify_mv_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_mv_column_clauseContext() *Modify_mv_column_clauseContext { + var p = new(Modify_mv_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause + return p +} + +func InitEmptyModify_mv_column_clauseContext(p *Modify_mv_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause +} + +func (*Modify_mv_column_clauseContext) IsModify_mv_column_clauseContext() {} + +func NewModify_mv_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_mv_column_clauseContext { + var p = new(Modify_mv_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_mv_column_clause + + return p +} + +func (s *Modify_mv_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_mv_column_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_mv_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_mv_column_clauseContext) 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 *Modify_mv_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_mv_column_clauseContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Modify_mv_column_clauseContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_mv_column_clauseContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Modify_mv_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_mv_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_mv_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_mv_column_clause(s) + } +} + +func (s *Modify_mv_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_mv_column_clause(s) + } +} + +func (s *Modify_mv_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_mv_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_mv_column_clause() (localctx IModify_mv_column_clauseContext) { + localctx = NewModify_mv_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 936, PlSqlParserRULE_modify_mv_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9560) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9561) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9562) + p.Column_name() + } + p.SetState(9566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT: + { + p.SetState(9563) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9564) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(9565) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(9568) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_materialized_view_logContext is an interface to support dynamic dispatch. +type IAlter_materialized_view_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + FORCE() antlr.TerminalNode + Physical_attributes_clause() IPhysical_attributes_clauseContext + Add_mv_log_column_clause() IAdd_mv_log_column_clauseContext + Parallel_clause() IParallel_clauseContext + Logging_clause() ILogging_clauseContext + Allocate_extent_clause() IAllocate_extent_clauseContext + Shrink_clause() IShrink_clauseContext + Move_mv_log_clause() IMove_mv_log_clauseContext + Cache_or_nocache() ICache_or_nocacheContext + Mv_log_augmentation() IMv_log_augmentationContext + Mv_log_purge_clause() IMv_log_purge_clauseContext + + // IsAlter_materialized_view_logContext differentiates from other interfaces. + IsAlter_materialized_view_logContext() +} + +type Alter_materialized_view_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_view_logContext() *Alter_materialized_view_logContext { + var p = new(Alter_materialized_view_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log + return p +} + +func InitEmptyAlter_materialized_view_logContext(p *Alter_materialized_view_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log +} + +func (*Alter_materialized_view_logContext) IsAlter_materialized_view_logContext() {} + +func NewAlter_materialized_view_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_view_logContext { + var p = new(Alter_materialized_view_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_materialized_view_log + + return p +} + +func (s *Alter_materialized_view_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_view_logContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_view_logContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_view_logContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_materialized_view_logContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Alter_materialized_view_logContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Alter_materialized_view_logContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_materialized_view_logContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_materialized_view_logContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Alter_materialized_view_logContext) Physical_attributes_clause() IPhysical_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Add_mv_log_column_clause() IAdd_mv_log_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_mv_log_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_mv_log_column_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Logging_clause() ILogging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Move_mv_log_clause() IMove_mv_log_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_mv_log_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_mv_log_clauseContext) +} + +func (s *Alter_materialized_view_logContext) Cache_or_nocache() ICache_or_nocacheContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_materialized_view_logContext) Mv_log_augmentation() IMv_log_augmentationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_augmentationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_augmentationContext) +} + +func (s *Alter_materialized_view_logContext) Mv_log_purge_clause() IMv_log_purge_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_purge_clauseContext) +} + +func (s *Alter_materialized_view_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_view_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_view_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_view_log(s) + } +} + +func (s *Alter_materialized_view_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_view_log(s) + } +} + +func (s *Alter_materialized_view_logContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_materialized_view_log(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_materialized_view_log() (localctx IAlter_materialized_view_logContext) { + localctx = NewAlter_materialized_view_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 938, PlSqlParserRULE_alter_materialized_view_log) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9570) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9571) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9572) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9573) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(9574) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9577) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9578) + p.Tableview_name() + } + p.SetState(9587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 1 { + { + p.SetState(9579) + p.Physical_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 2 { + { + p.SetState(9580) + p.Add_mv_log_column_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 3 { + { + p.SetState(9581) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 4 { + { + p.SetState(9582) + p.Logging_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 5 { + { + p.SetState(9583) + p.Allocate_extent_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 6 { + { + p.SetState(9584) + p.Shrink_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 7 { + { + p.SetState(9585) + p.Move_mv_log_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1081, p.GetParserRuleContext()) == 8 { + { + p.SetState(9586) + p.Cache_or_nocache() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(9589) + p.Mv_log_augmentation() + } + + } + p.SetState(9593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(9592) + p.Mv_log_purge_clause() + } + + } + { + p.SetState(9595) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IAdd_mv_log_column_clauseContext is an interface to support dynamic dispatch. +type IAdd_mv_log_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + + // IsAdd_mv_log_column_clauseContext differentiates from other interfaces. + IsAdd_mv_log_column_clauseContext() +} + +type Add_mv_log_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_mv_log_column_clauseContext() *Add_mv_log_column_clauseContext { + var p = new(Add_mv_log_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause + return p +} + +func InitEmptyAdd_mv_log_column_clauseContext(p *Add_mv_log_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause +} + +func (*Add_mv_log_column_clauseContext) IsAdd_mv_log_column_clauseContext() {} + +func NewAdd_mv_log_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_mv_log_column_clauseContext { + var p = new(Add_mv_log_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_mv_log_column_clause + + return p +} + +func (s *Add_mv_log_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_mv_log_column_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_mv_log_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_mv_log_column_clauseContext) 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 *Add_mv_log_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_mv_log_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_mv_log_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_mv_log_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_mv_log_column_clause(s) + } +} + +func (s *Add_mv_log_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_mv_log_column_clause(s) + } +} + +func (s *Add_mv_log_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_mv_log_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_mv_log_column_clause() (localctx IAdd_mv_log_column_clauseContext) { + localctx = NewAdd_mv_log_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 940, PlSqlParserRULE_add_mv_log_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9597) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9598) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9599) + p.Column_name() + } + { + p.SetState(9600) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMove_mv_log_clauseContext is an interface to support dynamic dispatch. +type IMove_mv_log_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + Segment_attributes_clause() ISegment_attributes_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsMove_mv_log_clauseContext differentiates from other interfaces. + IsMove_mv_log_clauseContext() +} + +type Move_mv_log_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_mv_log_clauseContext() *Move_mv_log_clauseContext { + var p = new(Move_mv_log_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause + return p +} + +func InitEmptyMove_mv_log_clauseContext(p *Move_mv_log_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause +} + +func (*Move_mv_log_clauseContext) IsMove_mv_log_clauseContext() {} + +func NewMove_mv_log_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_mv_log_clauseContext { + var p = new(Move_mv_log_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_mv_log_clause + + return p +} + +func (s *Move_mv_log_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_mv_log_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_mv_log_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Move_mv_log_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Move_mv_log_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_mv_log_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_mv_log_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_mv_log_clause(s) + } +} + +func (s *Move_mv_log_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_mv_log_clause(s) + } +} + +func (s *Move_mv_log_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMove_mv_log_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Move_mv_log_clause() (localctx IMove_mv_log_clauseContext) { + localctx = NewMove_mv_log_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 942, PlSqlParserRULE_move_mv_log_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9602) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9603) + p.Segment_attributes_clause() + } + p.SetState(9605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(9604) + p.Parallel_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 +} + +// IMv_log_augmentationContext is an interface to support dynamic dispatch. +type IMv_log_augmentationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + New_values_clause() INew_values_clauseContext + OBJECT() antlr.TerminalNode + ID() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + ROWID() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMv_log_augmentationContext differentiates from other interfaces. + IsMv_log_augmentationContext() +} + +type Mv_log_augmentationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_log_augmentationContext() *Mv_log_augmentationContext { + var p = new(Mv_log_augmentationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation + return p +} + +func InitEmptyMv_log_augmentationContext(p *Mv_log_augmentationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation +} + +func (*Mv_log_augmentationContext) IsMv_log_augmentationContext() {} + +func NewMv_log_augmentationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_log_augmentationContext { + var p = new(Mv_log_augmentationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_log_augmentation + + return p +} + +func (s *Mv_log_augmentationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_log_augmentationContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Mv_log_augmentationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Mv_log_augmentationContext) 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 *Mv_log_augmentationContext) 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 *Mv_log_augmentationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Mv_log_augmentationContext) New_values_clause() INew_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_values_clauseContext) +} + +func (s *Mv_log_augmentationContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Mv_log_augmentationContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Mv_log_augmentationContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Mv_log_augmentationContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Mv_log_augmentationContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Mv_log_augmentationContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Mv_log_augmentationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Mv_log_augmentationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Mv_log_augmentationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_log_augmentationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_log_augmentationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_log_augmentation(s) + } +} + +func (s *Mv_log_augmentationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_log_augmentation(s) + } +} + +func (s *Mv_log_augmentationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMv_log_augmentation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mv_log_augmentation() (localctx IMv_log_augmentationContext) { + localctx = NewMv_log_augmentationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 944, PlSqlParserRULE_mv_log_augmentation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9607) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT, PlSqlParserPRIMARY, PlSqlParserROWID, PlSqlParserSEQUENCE: + p.SetState(9614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(9608) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9609) + p.Match(PlSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9610) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9611) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(9612) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEQUENCE: + { + p.SetState(9613) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9616) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9617) + p.Column_name() + } + p.SetState(9622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9618) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9619) + p.Column_name() + } + + p.SetState(9624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9625) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(9629) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9630) + p.Column_name() + } + p.SetState(9635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9631) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9632) + p.Column_name() + } + + p.SetState(9637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9638) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(9643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING { + { + p.SetState(9642) + p.New_values_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatetime_exprContext is an interface to support dynamic dispatch. +type IDatetime_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + + // IsDatetime_exprContext differentiates from other interfaces. + IsDatetime_exprContext() +} + +type Datetime_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatetime_exprContext() *Datetime_exprContext { + var p = new(Datetime_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datetime_expr + return p +} + +func InitEmptyDatetime_exprContext(p *Datetime_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datetime_expr +} + +func (*Datetime_exprContext) IsDatetime_exprContext() {} + +func NewDatetime_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datetime_exprContext { + var p = new(Datetime_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datetime_expr + + return p +} + +func (s *Datetime_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datetime_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Datetime_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datetime_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datetime_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatetime_expr(s) + } +} + +func (s *Datetime_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatetime_expr(s) + } +} + +func (s *Datetime_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatetime_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datetime_expr() (localctx IDatetime_exprContext) { + localctx = NewDatetime_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 946, PlSqlParserRULE_datetime_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9645) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInterval_exprContext is an interface to support dynamic dispatch. +type IInterval_exprContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + + // IsInterval_exprContext differentiates from other interfaces. + IsInterval_exprContext() +} + +type Interval_exprContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInterval_exprContext() *Interval_exprContext { + var p = new(Interval_exprContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expr + return p +} + +func InitEmptyInterval_exprContext(p *Interval_exprContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expr +} + +func (*Interval_exprContext) IsInterval_exprContext() {} + +func NewInterval_exprContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_exprContext { + var p = new(Interval_exprContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_interval_expr + + return p +} + +func (s *Interval_exprContext) GetParser() antlr.Parser { return s.parser } + +func (s *Interval_exprContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Interval_exprContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Interval_exprContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Interval_exprContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInterval_expr(s) + } +} + +func (s *Interval_exprContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInterval_expr(s) + } +} + +func (s *Interval_exprContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInterval_expr(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Interval_expr() (localctx IInterval_exprContext) { + localctx = NewInterval_exprContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 948, PlSqlParserRULE_interval_expr) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9647) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISynchronous_or_asynchronousContext is an interface to support dynamic dispatch. +type ISynchronous_or_asynchronousContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SYNCHRONOUS() antlr.TerminalNode + ASYNCHRONOUS() antlr.TerminalNode + + // IsSynchronous_or_asynchronousContext differentiates from other interfaces. + IsSynchronous_or_asynchronousContext() +} + +type Synchronous_or_asynchronousContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySynchronous_or_asynchronousContext() *Synchronous_or_asynchronousContext { + var p = new(Synchronous_or_asynchronousContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synchronous_or_asynchronous + return p +} + +func InitEmptySynchronous_or_asynchronousContext(p *Synchronous_or_asynchronousContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synchronous_or_asynchronous +} + +func (*Synchronous_or_asynchronousContext) IsSynchronous_or_asynchronousContext() {} + +func NewSynchronous_or_asynchronousContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Synchronous_or_asynchronousContext { + var p = new(Synchronous_or_asynchronousContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_synchronous_or_asynchronous + + return p +} + +func (s *Synchronous_or_asynchronousContext) GetParser() antlr.Parser { return s.parser } + +func (s *Synchronous_or_asynchronousContext) SYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNCHRONOUS, 0) +} + +func (s *Synchronous_or_asynchronousContext) ASYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNCHRONOUS, 0) +} + +func (s *Synchronous_or_asynchronousContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Synchronous_or_asynchronousContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Synchronous_or_asynchronousContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSynchronous_or_asynchronous(s) + } +} + +func (s *Synchronous_or_asynchronousContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSynchronous_or_asynchronous(s) + } +} + +func (s *Synchronous_or_asynchronousContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSynchronous_or_asynchronous(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Synchronous_or_asynchronous() (localctx ISynchronous_or_asynchronousContext) { + localctx = NewSynchronous_or_asynchronousContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 950, PlSqlParserRULE_synchronous_or_asynchronous) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9649) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASYNCHRONOUS || _la == PlSqlParserSYNCHRONOUS) { + 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 +} + +// IIncluding_or_excludingContext is an interface to support dynamic dispatch. +type IIncluding_or_excludingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + + // IsIncluding_or_excludingContext differentiates from other interfaces. + IsIncluding_or_excludingContext() +} + +type Including_or_excludingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIncluding_or_excludingContext() *Including_or_excludingContext { + var p = new(Including_or_excludingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_or_excluding + return p +} + +func InitEmptyIncluding_or_excludingContext(p *Including_or_excludingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_or_excluding +} + +func (*Including_or_excludingContext) IsIncluding_or_excludingContext() {} + +func NewIncluding_or_excludingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Including_or_excludingContext { + var p = new(Including_or_excludingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_including_or_excluding + + return p +} + +func (s *Including_or_excludingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Including_or_excludingContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Including_or_excludingContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Including_or_excludingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Including_or_excludingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Including_or_excludingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIncluding_or_excluding(s) + } +} + +func (s *Including_or_excludingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIncluding_or_excluding(s) + } +} + +func (s *Including_or_excludingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIncluding_or_excluding(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Including_or_excluding() (localctx IIncluding_or_excludingContext) { + localctx = NewIncluding_or_excludingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 952, PlSqlParserRULE_including_or_excluding) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9651) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING) { + 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_materialized_view_logContext is an interface to support dynamic dispatch. +type ICreate_materialized_view_logContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + LOG() antlr.TerminalNode + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Parallel_clause() IParallel_clauseContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllMv_log_purge_clause() []IMv_log_purge_clauseContext + Mv_log_purge_clause(i int) IMv_log_purge_clauseContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllOBJECT() []antlr.TerminalNode + OBJECT(i int) antlr.TerminalNode + AllID() []antlr.TerminalNode + ID(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllROWID() []antlr.TerminalNode + ROWID(i int) antlr.TerminalNode + AllSEQUENCE() []antlr.TerminalNode + SEQUENCE(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllSCN() []antlr.TerminalNode + SCN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + AllNew_values_clause() []INew_values_clauseContext + New_values_clause(i int) INew_values_clauseContext + + // IsCreate_materialized_view_logContext differentiates from other interfaces. + IsCreate_materialized_view_logContext() +} + +type Create_materialized_view_logContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyCreate_materialized_view_logContext() *Create_materialized_view_logContext { + var p = new(Create_materialized_view_logContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log + return p +} + +func InitEmptyCreate_materialized_view_logContext(p *Create_materialized_view_logContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log +} + +func (*Create_materialized_view_logContext) IsCreate_materialized_view_logContext() {} + +func NewCreate_materialized_view_logContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_view_logContext { + var p = new(Create_materialized_view_logContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_materialized_view_log + + return p +} + +func (s *Create_materialized_view_logContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_view_logContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Create_materialized_view_logContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Create_materialized_view_logContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_view_logContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_view_logContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_materialized_view_logContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Create_materialized_view_logContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_materialized_view_logContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_materialized_view_logContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Create_materialized_view_logContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Create_materialized_view_logContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_materialized_view_logContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_materialized_view_logContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Create_materialized_view_logContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Create_materialized_view_logContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Create_materialized_view_logContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Create_materialized_view_logContext) AllMv_log_purge_clause() []IMv_log_purge_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + len++ + } + } + + tst := make([]IMv_log_purge_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMv_log_purge_clauseContext); ok { + tst[i] = t.(IMv_log_purge_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Mv_log_purge_clause(i int) IMv_log_purge_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_log_purge_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMv_log_purge_clauseContext) +} + +func (s *Create_materialized_view_logContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_materialized_view_logContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Create_materialized_view_logContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Create_materialized_view_logContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Create_materialized_view_logContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Create_materialized_view_logContext) AllOBJECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOBJECT) +} + +func (s *Create_materialized_view_logContext) OBJECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, i) +} + +func (s *Create_materialized_view_logContext) AllID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserID) +} + +func (s *Create_materialized_view_logContext) ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserID, i) +} + +func (s *Create_materialized_view_logContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Create_materialized_view_logContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Create_materialized_view_logContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Create_materialized_view_logContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Create_materialized_view_logContext) AllROWID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROWID) +} + +func (s *Create_materialized_view_logContext) ROWID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, i) +} + +func (s *Create_materialized_view_logContext) AllSEQUENCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEQUENCE) +} + +func (s *Create_materialized_view_logContext) SEQUENCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, i) +} + +func (s *Create_materialized_view_logContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Create_materialized_view_logContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Create_materialized_view_logContext) AllSCN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSCN) +} + +func (s *Create_materialized_view_logContext) SCN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, i) +} + +func (s *Create_materialized_view_logContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_materialized_view_logContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_materialized_view_logContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Create_materialized_view_logContext) AllNew_values_clause() []INew_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INew_values_clauseContext); ok { + len++ + } + } + + tst := make([]INew_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INew_values_clauseContext); ok { + tst[i] = t.(INew_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_view_logContext) New_values_clause(i int) INew_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INew_values_clauseContext) +} + +func (s *Create_materialized_view_logContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_view_logContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_view_logContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_view_log(s) + } +} + +func (s *Create_materialized_view_logContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_view_log(s) + } +} + +func (s *Create_materialized_view_logContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_materialized_view_log(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_materialized_view_log() (localctx ICreate_materialized_view_logContext) { + localctx = NewCreate_materialized_view_logContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 954, PlSqlParserRULE_create_materialized_view_log) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9653) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9654) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9655) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9656) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9657) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9658) + p.Tableview_name() + } + p.SetState(9668) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1093, p.GetParserRuleContext()) == 1 { + p.SetState(9664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(9659) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(9660) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9661) + + var _x = p.Id_expression() + + localctx.(*Create_materialized_view_logContext).tablespace_name = _x + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(9662) + p.Logging_clause() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(9663) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + 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 + } + + p.SetState(9666) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1092, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9671) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1094, p.GetParserRuleContext()) == 1 { + { + p.SetState(9670) + p.Parallel_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1103, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9673) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9689) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1097, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(9675) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9674) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(9677) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9678) + p.Match(PlSqlParserID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(9679) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9680) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(9681) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEQUENCE: + { + p.SetState(9682) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMMIT: + { + p.SetState(9683) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9684) + p.Match(PlSqlParserSCN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(9691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1097, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(9705) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1101, p.GetParserRuleContext()) == 1 { + { + p.SetState(9692) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877915137) != 0) { + p.SetState(9694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(9693) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9696) + p.Regular_id() + } + + p.SetState(9699) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9701) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9703) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1100, p.GetParserRuleContext()) == 1 { + { + p.SetState(9702) + p.New_values_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9708) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1102, p.GetParserRuleContext()) == 1 { + { + p.SetState(9707) + p.Mv_log_purge_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(9714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1103, 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 +} + +// INew_values_clauseContext is an interface to support dynamic dispatch. +type INew_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NEW() antlr.TerminalNode + VALUES() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + + // IsNew_values_clauseContext differentiates from other interfaces. + IsNew_values_clauseContext() +} + +type New_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_values_clauseContext() *New_values_clauseContext { + var p = new(New_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_values_clause + return p +} + +func InitEmptyNew_values_clauseContext(p *New_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_values_clause +} + +func (*New_values_clauseContext) IsNew_values_clauseContext() {} + +func NewNew_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_values_clauseContext { + var p = new(New_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_values_clause + + return p +} + +func (s *New_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_values_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *New_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *New_values_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *New_values_clauseContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *New_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_values_clause(s) + } +} + +func (s *New_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_values_clause(s) + } +} + +func (s *New_values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_values_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_values_clause() (localctx INew_values_clauseContext) { + localctx = NewNew_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 956, PlSqlParserRULE_new_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9715) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9716) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9717) + p.Match(PlSqlParserVALUES) + 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 +} + +// IMv_log_purge_clauseContext is an interface to support dynamic dispatch. +type IMv_log_purge_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PURGE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + SYNCHRONOUS() antlr.TerminalNode + ASYNCHRONOUS() antlr.TerminalNode + + // IsMv_log_purge_clauseContext differentiates from other interfaces. + IsMv_log_purge_clauseContext() +} + +type Mv_log_purge_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_log_purge_clauseContext() *Mv_log_purge_clauseContext { + var p = new(Mv_log_purge_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause + return p +} + +func InitEmptyMv_log_purge_clauseContext(p *Mv_log_purge_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause +} + +func (*Mv_log_purge_clauseContext) IsMv_log_purge_clauseContext() {} + +func NewMv_log_purge_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_log_purge_clauseContext { + var p = new(Mv_log_purge_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_log_purge_clause + + return p +} + +func (s *Mv_log_purge_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_log_purge_clauseContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Mv_log_purge_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Mv_log_purge_clauseContext) SYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNCHRONOUS, 0) +} + +func (s *Mv_log_purge_clauseContext) ASYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNCHRONOUS, 0) +} + +func (s *Mv_log_purge_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_log_purge_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_log_purge_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_log_purge_clause(s) + } +} + +func (s *Mv_log_purge_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_log_purge_clause(s) + } +} + +func (s *Mv_log_purge_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMv_log_purge_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mv_log_purge_clause() (localctx IMv_log_purge_clauseContext) { + localctx = NewMv_log_purge_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 958, PlSqlParserRULE_mv_log_purge_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9719) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(9720) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9722) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1104, p.GetParserRuleContext()) == 1 { + { + p.SetState(9721) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASYNCHRONOUS || _la == PlSqlParserSYNCHRONOUS) { + 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 +} + +// ICreate_materialized_zonemapContext is an interface to support dynamic dispatch. +type ICreate_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + Create_zonemap_on_table() ICreate_zonemap_on_tableContext + Create_zonemap_as_subquery() ICreate_zonemap_as_subqueryContext + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + Zonemap_attributes() IZonemap_attributesContext + Zonemap_refresh_clause() IZonemap_refresh_clauseContext + PRUNING() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCreate_materialized_zonemapContext differentiates from other interfaces. + IsCreate_materialized_zonemapContext() +} + +type Create_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_materialized_zonemapContext() *Create_materialized_zonemapContext { + var p = new(Create_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap + return p +} + +func InitEmptyCreate_materialized_zonemapContext(p *Create_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap +} + +func (*Create_materialized_zonemapContext) IsCreate_materialized_zonemapContext() {} + +func NewCreate_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_materialized_zonemapContext { + var p = new(Create_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_materialized_zonemap + + return p +} + +func (s *Create_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_zonemapContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Create_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Create_materialized_zonemapContext) Create_zonemap_on_table() ICreate_zonemap_on_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_zonemap_on_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_zonemap_on_tableContext) +} + +func (s *Create_materialized_zonemapContext) Create_zonemap_as_subquery() ICreate_zonemap_as_subqueryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_zonemap_as_subqueryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_zonemap_as_subqueryContext) +} + +func (s *Create_materialized_zonemapContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_materialized_zonemapContext) 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_materialized_zonemapContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_materialized_zonemapContext) Zonemap_attributes() IZonemap_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_attributesContext) +} + +func (s *Create_materialized_zonemapContext) Zonemap_refresh_clause() IZonemap_refresh_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_refresh_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_refresh_clauseContext) +} + +func (s *Create_materialized_zonemapContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Create_materialized_zonemapContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Create_materialized_zonemapContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Create_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_zonemap(s) + } +} + +func (s *Create_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_zonemap(s) + } +} + +func (s *Create_materialized_zonemapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_materialized_zonemap(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_materialized_zonemap() (localctx ICreate_materialized_zonemapContext) { + localctx = NewCreate_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 960, PlSqlParserRULE_create_materialized_zonemap) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9724) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9725) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9726) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9727) + p.Zonemap_name() + } + p.SetState(9732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9728) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9729) + p.Column_list() + } + { + p.SetState(9730) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSCALE || _la == PlSqlParserTABLESPACE { + { + p.SetState(9734) + p.Zonemap_attributes() + } + + } + p.SetState(9738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREFRESH { + { + p.SetState(9737) + p.Zonemap_refresh_clause() + } + + } + p.SetState(9742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(9740) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9741) + p.Match(PlSqlParserPRUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(9744) + p.Create_zonemap_on_table() + } + + case PlSqlParserAS: + { + p.SetState(9745) + p.Create_zonemap_as_subquery() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_zonemapContext is an interface to support dynamic dispatch. +type IAlter_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + Zonemap_attributes() IZonemap_attributesContext + Zonemap_refresh_clause() IZonemap_refresh_clauseContext + PRUNING() antlr.TerminalNode + COMPILE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsAlter_materialized_zonemapContext differentiates from other interfaces. + IsAlter_materialized_zonemapContext() +} + +type Alter_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_materialized_zonemapContext() *Alter_materialized_zonemapContext { + var p = new(Alter_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap + return p +} + +func InitEmptyAlter_materialized_zonemapContext(p *Alter_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap +} + +func (*Alter_materialized_zonemapContext) IsAlter_materialized_zonemapContext() {} + +func NewAlter_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_materialized_zonemapContext { + var p = new(Alter_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_materialized_zonemap + + return p +} + +func (s *Alter_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_materialized_zonemapContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Alter_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_attributes() IZonemap_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_attributesContext) +} + +func (s *Alter_materialized_zonemapContext) Zonemap_refresh_clause() IZonemap_refresh_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_refresh_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_refresh_clauseContext) +} + +func (s *Alter_materialized_zonemapContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Alter_materialized_zonemapContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_materialized_zonemapContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Alter_materialized_zonemapContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Alter_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_materialized_zonemap(s) + } +} + +func (s *Alter_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_materialized_zonemap(s) + } +} + +func (s *Alter_materialized_zonemapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_materialized_zonemap(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_materialized_zonemap() (localctx IAlter_materialized_zonemapContext) { + localctx = NewAlter_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 962, PlSqlParserRULE_alter_materialized_zonemap) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9748) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9749) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9750) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9751) + p.Zonemap_name() + } + p.SetState(9759) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCACHE, PlSqlParserNOCACHE, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSCALE, PlSqlParserTABLESPACE: + { + p.SetState(9752) + p.Zonemap_attributes() + } + + case PlSqlParserREFRESH: + { + p.SetState(9753) + p.Zonemap_refresh_clause() + } + + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(9754) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9755) + p.Match(PlSqlParserPRUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPILE: + { + p.SetState(9756) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREBUILD: + { + p.SetState(9757) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNUSABLE: + { + p.SetState(9758) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_materialized_zonemapContext is an interface to support dynamic dispatch. +type IDrop_materialized_zonemapContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + + // IsDrop_materialized_zonemapContext differentiates from other interfaces. + IsDrop_materialized_zonemapContext() +} + +type Drop_materialized_zonemapContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_materialized_zonemapContext() *Drop_materialized_zonemapContext { + var p = new(Drop_materialized_zonemapContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap + return p +} + +func InitEmptyDrop_materialized_zonemapContext(p *Drop_materialized_zonemapContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap +} + +func (*Drop_materialized_zonemapContext) IsDrop_materialized_zonemapContext() {} + +func NewDrop_materialized_zonemapContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_materialized_zonemapContext { + var p = new(Drop_materialized_zonemapContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_materialized_zonemap + + return p +} + +func (s *Drop_materialized_zonemapContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_materialized_zonemapContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_materialized_zonemapContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_zonemapContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Drop_materialized_zonemapContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Drop_materialized_zonemapContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_materialized_zonemapContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_materialized_zonemapContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_materialized_zonemap(s) + } +} + +func (s *Drop_materialized_zonemapContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_materialized_zonemap(s) + } +} + +func (s *Drop_materialized_zonemapContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_materialized_zonemap(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_materialized_zonemap() (localctx IDrop_materialized_zonemapContext) { + localctx = NewDrop_materialized_zonemapContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 964, PlSqlParserRULE_drop_materialized_zonemap) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9761) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9762) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9763) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9764) + p.Zonemap_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 +} + +// IZonemap_refresh_clauseContext is an interface to support dynamic dispatch. +type IZonemap_refresh_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFRESH() antlr.TerminalNode + ON() antlr.TerminalNode + FAST() antlr.TerminalNode + COMPILE() antlr.TerminalNode + FORCE() antlr.TerminalNode + DEMAND() antlr.TerminalNode + COMMIT() antlr.TerminalNode + LOAD() antlr.TerminalNode + DATA() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + + // IsZonemap_refresh_clauseContext differentiates from other interfaces. + IsZonemap_refresh_clauseContext() +} + +type Zonemap_refresh_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_refresh_clauseContext() *Zonemap_refresh_clauseContext { + var p = new(Zonemap_refresh_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause + return p +} + +func InitEmptyZonemap_refresh_clauseContext(p *Zonemap_refresh_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause +} + +func (*Zonemap_refresh_clauseContext) IsZonemap_refresh_clauseContext() {} + +func NewZonemap_refresh_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_refresh_clauseContext { + var p = new(Zonemap_refresh_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_refresh_clause + + return p +} + +func (s *Zonemap_refresh_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_refresh_clauseContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Zonemap_refresh_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Zonemap_refresh_clauseContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Zonemap_refresh_clauseContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Zonemap_refresh_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Zonemap_refresh_clauseContext) DEMAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, 0) +} + +func (s *Zonemap_refresh_clauseContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Zonemap_refresh_clauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Zonemap_refresh_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Zonemap_refresh_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Zonemap_refresh_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_refresh_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_refresh_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_refresh_clause(s) + } +} + +func (s *Zonemap_refresh_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_refresh_clause(s) + } +} + +func (s *Zonemap_refresh_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitZonemap_refresh_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Zonemap_refresh_clause() (localctx IZonemap_refresh_clauseContext) { + localctx = NewZonemap_refresh_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 966, PlSqlParserRULE_zonemap_refresh_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9766) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9768) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1111, p.GetParserRuleContext()) == 1 { + { + p.SetState(9767) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(9781) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1113, p.GetParserRuleContext()) == 1 { + { + p.SetState(9770) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1112, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9771) + p.Match(PlSqlParserDEMAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(9772) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(9773) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(9774) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9775) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(9776) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9777) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9778) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IZonemap_attributesContext is an interface to support dynamic dispatch. +type IZonemap_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPCTFREE() []antlr.TerminalNode + PCTFREE(i int) antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllPCTUSED() []antlr.TerminalNode + PCTUSED(i int) antlr.TerminalNode + AllSCALE() []antlr.TerminalNode + SCALE(i int) antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + + // IsZonemap_attributesContext differentiates from other interfaces. + IsZonemap_attributesContext() +} + +type Zonemap_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_attributesContext() *Zonemap_attributesContext { + var p = new(Zonemap_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_attributes + return p +} + +func InitEmptyZonemap_attributesContext(p *Zonemap_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_attributes +} + +func (*Zonemap_attributesContext) IsZonemap_attributesContext() {} + +func NewZonemap_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_attributesContext { + var p = new(Zonemap_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_attributes + + return p +} + +func (s *Zonemap_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_attributesContext) AllPCTFREE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTFREE) +} + +func (s *Zonemap_attributesContext) PCTFREE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTFREE, i) +} + +func (s *Zonemap_attributesContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Zonemap_attributesContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Zonemap_attributesContext) AllPCTUSED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTUSED) +} + +func (s *Zonemap_attributesContext) PCTUSED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, i) +} + +func (s *Zonemap_attributesContext) AllSCALE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSCALE) +} + +func (s *Zonemap_attributesContext) SCALE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, i) +} + +func (s *Zonemap_attributesContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Zonemap_attributesContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Zonemap_attributesContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Zonemap_attributesContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Zonemap_attributesContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Zonemap_attributesContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Zonemap_attributesContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Zonemap_attributesContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Zonemap_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_attributes(s) + } +} + +func (s *Zonemap_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_attributes(s) + } +} + +func (s *Zonemap_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitZonemap_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Zonemap_attributes() (localctx IZonemap_attributesContext) { + localctx = NewZonemap_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 968, PlSqlParserRULE_zonemap_attributes) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(9792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(9792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPCTFREE: + { + p.SetState(9783) + p.Match(PlSqlParserPCTFREE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9784) + p.Numeric() + } + + case PlSqlParserPCTUSED: + { + p.SetState(9785) + p.Match(PlSqlParserPCTUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9786) + p.Numeric() + } + + case PlSqlParserSCALE: + { + p.SetState(9787) + p.Match(PlSqlParserSCALE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9788) + p.Numeric() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(9789) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9790) + p.Tablespace() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(9791) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + 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 + } + + p.SetState(9794) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1115, 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 +} + +// IZonemap_nameContext is an interface to support dynamic dispatch. +type IZonemap_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsZonemap_nameContext differentiates from other interfaces. + IsZonemap_nameContext() +} + +type Zonemap_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_nameContext() *Zonemap_nameContext { + var p = new(Zonemap_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_name + return p +} + +func InitEmptyZonemap_nameContext(p *Zonemap_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_name +} + +func (*Zonemap_nameContext) IsZonemap_nameContext() {} + +func NewZonemap_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_nameContext { + var p = new(Zonemap_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_name + + return p +} + +func (s *Zonemap_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Zonemap_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Zonemap_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Zonemap_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_name(s) + } +} + +func (s *Zonemap_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_name(s) + } +} + +func (s *Zonemap_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitZonemap_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Zonemap_name() (localctx IZonemap_nameContext) { + localctx = NewZonemap_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 970, PlSqlParserRULE_zonemap_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9796) + p.Identifier() + } + p.SetState(9799) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1116, p.GetParserRuleContext()) == 1 { + { + p.SetState(9797) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9798) + p.Id_expression() + } + + } 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 +} + +// IOperator_nameContext is an interface to support dynamic dispatch. +type IOperator_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsOperator_nameContext differentiates from other interfaces. + IsOperator_nameContext() +} + +type Operator_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_nameContext() *Operator_nameContext { + var p = new(Operator_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_name + return p +} + +func InitEmptyOperator_nameContext(p *Operator_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_name +} + +func (*Operator_nameContext) IsOperator_nameContext() {} + +func NewOperator_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_nameContext { + var p = new(Operator_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_name + + return p +} + +func (s *Operator_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Operator_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Operator_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Operator_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_name(s) + } +} + +func (s *Operator_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_name(s) + } +} + +func (s *Operator_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOperator_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Operator_name() (localctx IOperator_nameContext) { + localctx = NewOperator_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 972, PlSqlParserRULE_operator_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9801) + p.Identifier() + } + p.SetState(9804) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1117, p.GetParserRuleContext()) == 1 { + { + p.SetState(9802) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9803) + p.Id_expression() + } + + } 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 +} + +// IOperator_function_nameContext is an interface to support dynamic dispatch. +type IOperator_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsOperator_function_nameContext differentiates from other interfaces. + IsOperator_function_nameContext() +} + +type Operator_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_function_nameContext() *Operator_function_nameContext { + var p = new(Operator_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_function_name + return p +} + +func InitEmptyOperator_function_nameContext(p *Operator_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_function_name +} + +func (*Operator_function_nameContext) IsOperator_function_nameContext() {} + +func NewOperator_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_function_nameContext { + var p = new(Operator_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_function_name + + return p +} + +func (s *Operator_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Operator_function_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Operator_function_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Operator_function_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Operator_function_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Operator_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_function_name(s) + } +} + +func (s *Operator_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_function_name(s) + } +} + +func (s *Operator_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOperator_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Operator_function_name() (localctx IOperator_function_nameContext) { + localctx = NewOperator_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 974, PlSqlParserRULE_operator_function_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9806) + p.Identifier() + } + p.SetState(9811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9807) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9808) + p.Id_expression() + } + + } + p.SetState(9813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1118, 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_zonemap_on_tableContext is an interface to support dynamic dispatch. +type ICreate_zonemap_on_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCreate_zonemap_on_tableContext differentiates from other interfaces. + IsCreate_zonemap_on_tableContext() +} + +type Create_zonemap_on_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_zonemap_on_tableContext() *Create_zonemap_on_tableContext { + var p = new(Create_zonemap_on_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table + return p +} + +func InitEmptyCreate_zonemap_on_tableContext(p *Create_zonemap_on_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table +} + +func (*Create_zonemap_on_tableContext) IsCreate_zonemap_on_tableContext() {} + +func NewCreate_zonemap_on_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_zonemap_on_tableContext { + var p = new(Create_zonemap_on_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_zonemap_on_table + + return p +} + +func (s *Create_zonemap_on_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_zonemap_on_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_zonemap_on_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_zonemap_on_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_zonemap_on_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 *Create_zonemap_on_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_zonemap_on_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_zonemap_on_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_zonemap_on_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_zonemap_on_table(s) + } +} + +func (s *Create_zonemap_on_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_zonemap_on_table(s) + } +} + +func (s *Create_zonemap_on_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_zonemap_on_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_zonemap_on_table() (localctx ICreate_zonemap_on_tableContext) { + localctx = NewCreate_zonemap_on_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 976, PlSqlParserRULE_create_zonemap_on_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9814) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9815) + p.Tableview_name() + } + { + p.SetState(9816) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9817) + p.Column_list() + } + { + p.SetState(9818) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_zonemap_as_subqueryContext is an interface to support dynamic dispatch. +type ICreate_zonemap_as_subqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AS() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsCreate_zonemap_as_subqueryContext differentiates from other interfaces. + IsCreate_zonemap_as_subqueryContext() +} + +type Create_zonemap_as_subqueryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_zonemap_as_subqueryContext() *Create_zonemap_as_subqueryContext { + var p = new(Create_zonemap_as_subqueryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery + return p +} + +func InitEmptyCreate_zonemap_as_subqueryContext(p *Create_zonemap_as_subqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery +} + +func (*Create_zonemap_as_subqueryContext) IsCreate_zonemap_as_subqueryContext() {} + +func NewCreate_zonemap_as_subqueryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_zonemap_as_subqueryContext { + var p = new(Create_zonemap_as_subqueryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_zonemap_as_subquery + + return p +} + +func (s *Create_zonemap_as_subqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_zonemap_as_subqueryContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_zonemap_as_subqueryContext) 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 *Create_zonemap_as_subqueryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_zonemap_as_subqueryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_zonemap_as_subqueryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_zonemap_as_subquery(s) + } +} + +func (s *Create_zonemap_as_subqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_zonemap_as_subquery(s) + } +} + +func (s *Create_zonemap_as_subqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_zonemap_as_subquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_zonemap_as_subquery() (localctx ICreate_zonemap_as_subqueryContext) { + localctx = NewCreate_zonemap_as_subqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 978, PlSqlParserRULE_create_zonemap_as_subquery) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9820) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9821) + p.Subquery() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_operatorContext is an interface to support dynamic dispatch. +type IAlter_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + Add_binding_clause() IAdd_binding_clauseContext + Drop_binding_clause() IDrop_binding_clauseContext + COMPILE() antlr.TerminalNode + + // IsAlter_operatorContext differentiates from other interfaces. + IsAlter_operatorContext() +} + +type Alter_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_operatorContext() *Alter_operatorContext { + var p = new(Alter_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_operator + return p +} + +func InitEmptyAlter_operatorContext(p *Alter_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_operator +} + +func (*Alter_operatorContext) IsAlter_operatorContext() {} + +func NewAlter_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_operatorContext { + var p = new(Alter_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_operator + + return p +} + +func (s *Alter_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_operatorContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Alter_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Alter_operatorContext) Add_binding_clause() IAdd_binding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_binding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_binding_clauseContext) +} + +func (s *Alter_operatorContext) Drop_binding_clause() IDrop_binding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_binding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_binding_clauseContext) +} + +func (s *Alter_operatorContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_operator(s) + } +} + +func (s *Alter_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_operator(s) + } +} + +func (s *Alter_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_operator() (localctx IAlter_operatorContext) { + localctx = NewAlter_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 980, PlSqlParserRULE_alter_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9823) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9824) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9825) + p.Operator_name() + } + p.SetState(9829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(9826) + p.Add_binding_clause() + } + + case PlSqlParserDROP: + { + p.SetState(9827) + p.Drop_binding_clause() + } + + case PlSqlParserCOMPILE: + { + p.SetState(9828) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_operatorContext is an interface to support dynamic dispatch. +type IDrop_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + FORCE() antlr.TerminalNode + + // IsDrop_operatorContext differentiates from other interfaces. + IsDrop_operatorContext() +} + +type Drop_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_operatorContext() *Drop_operatorContext { + var p = new(Drop_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_operator + return p +} + +func InitEmptyDrop_operatorContext(p *Drop_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_operator +} + +func (*Drop_operatorContext) IsDrop_operatorContext() {} + +func NewDrop_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_operatorContext { + var p = new(Drop_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_operator + + return p +} + +func (s *Drop_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_operatorContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Drop_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Drop_operatorContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_operator(s) + } +} + +func (s *Drop_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_operator(s) + } +} + +func (s *Drop_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_operator() (localctx IDrop_operatorContext) { + localctx = NewDrop_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 982, PlSqlParserRULE_drop_operator) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9831) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9832) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9833) + p.Operator_name() + } + p.SetState(9835) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1120, p.GetParserRuleContext()) == 1 { + { + p.SetState(9834) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_operatorContext is an interface to support dynamic dispatch. +type ICreate_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + Operator_name() IOperator_nameContext + BINDING() antlr.TerminalNode + AllBinding_clause() []IBinding_clauseContext + Binding_clause(i int) IBinding_clauseContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + METADATA() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsCreate_operatorContext differentiates from other interfaces. + IsCreate_operatorContext() +} + +type Create_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_operatorContext() *Create_operatorContext { + var p = new(Create_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_operator + return p +} + +func InitEmptyCreate_operatorContext(p *Create_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_operator +} + +func (*Create_operatorContext) IsCreate_operatorContext() {} + +func NewCreate_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_operatorContext { + var p = new(Create_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_operator + + return p +} + +func (s *Create_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_operatorContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_operatorContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Create_operatorContext) Operator_name() IOperator_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_nameContext) +} + +func (s *Create_operatorContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Create_operatorContext) AllBinding_clause() []IBinding_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBinding_clauseContext); ok { + len++ + } + } + + tst := make([]IBinding_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBinding_clauseContext); ok { + tst[i] = t.(IBinding_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_operatorContext) Binding_clause(i int) IBinding_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinding_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBinding_clauseContext) +} + +func (s *Create_operatorContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_operatorContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_operatorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_operatorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_operatorContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_operatorContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_operatorContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_operatorContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_operator(s) + } +} + +func (s *Create_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_operator(s) + } +} + +func (s *Create_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_operator() (localctx ICreate_operatorContext) { + localctx = NewCreate_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 984, PlSqlParserRULE_create_operator) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9837) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(9838) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9839) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9842) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9843) + p.Operator_name() + } + { + p.SetState(9844) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9845) + p.Binding_clause() + } + p.SetState(9850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(9846) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9847) + p.Binding_clause() + } + + } + p.SetState(9852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1122, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(9856) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1123, p.GetParserRuleContext()) == 1 { + { + p.SetState(9853) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9854) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9855) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMETADATA || _la == PlSqlParserNONE) { + 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 +} + +// IBinding_clauseContext is an interface to support dynamic dispatch. +type IBinding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RETURN() antlr.TerminalNode + Using_function_clause() IUsing_function_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Implementation_clause() IImplementation_clauseContext + + // IsBinding_clauseContext differentiates from other interfaces. + IsBinding_clauseContext() +} + +type Binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBinding_clauseContext() *Binding_clauseContext { + var p = new(Binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_binding_clause + return p +} + +func InitEmptyBinding_clauseContext(p *Binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_binding_clause +} + +func (*Binding_clauseContext) IsBinding_clauseContext() {} + +func NewBinding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Binding_clauseContext { + var p = new(Binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_binding_clause + + return p +} + +func (s *Binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Binding_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Binding_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Binding_clauseContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Binding_clauseContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Binding_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Binding_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Binding_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Binding_clauseContext) Using_function_clause() IUsing_function_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_function_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_function_clauseContext) +} + +func (s *Binding_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Binding_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Binding_clauseContext) Implementation_clause() IImplementation_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_clauseContext) +} + +func (s *Binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBinding_clause(s) + } +} + +func (s *Binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBinding_clause(s) + } +} + +func (s *Binding_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBinding_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Binding_clause() (localctx IBinding_clauseContext) { + localctx = NewBinding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 986, PlSqlParserRULE_binding_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9858) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9859) + p.Datatype() + } + p.SetState(9864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9860) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9861) + p.Datatype() + } + + p.SetState(9866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9867) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9868) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9869) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(9872) + p.Datatype() + } + p.SetState(9874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(9873) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANCILLARY || _la == PlSqlParserWITH { + { + p.SetState(9876) + p.Implementation_clause() + } + + } + { + p.SetState(9879) + p.Using_function_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 +} + +// IAdd_binding_clauseContext is an interface to support dynamic dispatch. +type IAdd_binding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + BINDING() antlr.TerminalNode + Binding_clause() IBinding_clauseContext + + // IsAdd_binding_clauseContext differentiates from other interfaces. + IsAdd_binding_clauseContext() +} + +type Add_binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_binding_clauseContext() *Add_binding_clauseContext { + var p = new(Add_binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_binding_clause + return p +} + +func InitEmptyAdd_binding_clauseContext(p *Add_binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_binding_clause +} + +func (*Add_binding_clauseContext) IsAdd_binding_clauseContext() {} + +func NewAdd_binding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_binding_clauseContext { + var p = new(Add_binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_binding_clause + + return p +} + +func (s *Add_binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_binding_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_binding_clauseContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Add_binding_clauseContext) Binding_clause() IBinding_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBinding_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBinding_clauseContext) +} + +func (s *Add_binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_binding_clause(s) + } +} + +func (s *Add_binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_binding_clause(s) + } +} + +func (s *Add_binding_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_binding_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_binding_clause() (localctx IAdd_binding_clauseContext) { + localctx = NewAdd_binding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 988, PlSqlParserRULE_add_binding_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9881) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9882) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9883) + p.Binding_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 +} + +// IImplementation_clauseContext is an interface to support dynamic dispatch. +type IImplementation_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ANCILLARY() antlr.TerminalNode + TO() antlr.TerminalNode + Primary_operator_list() IPrimary_operator_listContext + Operator_context_clause() IOperator_context_clauseContext + + // IsImplementation_clauseContext differentiates from other interfaces. + IsImplementation_clauseContext() +} + +type Implementation_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplementation_clauseContext() *Implementation_clauseContext { + var p = new(Implementation_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_clause + return p +} + +func InitEmptyImplementation_clauseContext(p *Implementation_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_clause +} + +func (*Implementation_clauseContext) IsImplementation_clauseContext() {} + +func NewImplementation_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implementation_clauseContext { + var p = new(Implementation_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_implementation_clause + + return p +} + +func (s *Implementation_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implementation_clauseContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Implementation_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Implementation_clauseContext) Primary_operator_list() IPrimary_operator_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_operator_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_operator_listContext) +} + +func (s *Implementation_clauseContext) Operator_context_clause() IOperator_context_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_context_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_context_clauseContext) +} + +func (s *Implementation_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implementation_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implementation_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImplementation_clause(s) + } +} + +func (s *Implementation_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImplementation_clause(s) + } +} + +func (s *Implementation_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImplementation_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Implementation_clause() (localctx IImplementation_clauseContext) { + localctx = NewImplementation_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 990, PlSqlParserRULE_implementation_clause) + p.SetState(9889) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserANCILLARY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9885) + p.Match(PlSqlParserANCILLARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9886) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9887) + p.Primary_operator_list() + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(9888) + p.Operator_context_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 +} + +// IPrimary_operator_listContext is an interface to support dynamic dispatch. +type IPrimary_operator_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPrimary_operator_item() []IPrimary_operator_itemContext + Primary_operator_item(i int) IPrimary_operator_itemContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrimary_operator_listContext differentiates from other interfaces. + IsPrimary_operator_listContext() +} + +type Primary_operator_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_operator_listContext() *Primary_operator_listContext { + var p = new(Primary_operator_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_list + return p +} + +func InitEmptyPrimary_operator_listContext(p *Primary_operator_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_list +} + +func (*Primary_operator_listContext) IsPrimary_operator_listContext() {} + +func NewPrimary_operator_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_operator_listContext { + var p = new(Primary_operator_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_primary_operator_list + + return p +} + +func (s *Primary_operator_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_operator_listContext) AllPrimary_operator_item() []IPrimary_operator_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrimary_operator_itemContext); ok { + len++ + } + } + + tst := make([]IPrimary_operator_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrimary_operator_itemContext); ok { + tst[i] = t.(IPrimary_operator_itemContext) + i++ + } + } + + return tst +} + +func (s *Primary_operator_listContext) Primary_operator_item(i int) IPrimary_operator_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_operator_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_operator_itemContext) +} + +func (s *Primary_operator_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Primary_operator_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Primary_operator_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_operator_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_operator_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrimary_operator_list(s) + } +} + +func (s *Primary_operator_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrimary_operator_list(s) + } +} + +func (s *Primary_operator_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrimary_operator_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Primary_operator_list() (localctx IPrimary_operator_listContext) { + localctx = NewPrimary_operator_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 992, PlSqlParserRULE_primary_operator_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9891) + p.Primary_operator_item() + } + p.SetState(9896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9892) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9893) + p.Primary_operator_item() + } + + p.SetState(9898) + 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 +} + +// IPrimary_operator_itemContext is an interface to support dynamic dispatch. +type IPrimary_operator_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Schema_object_name() ISchema_object_nameContext + LEFT_PAREN() antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPrimary_operator_itemContext differentiates from other interfaces. + IsPrimary_operator_itemContext() +} + +type Primary_operator_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_operator_itemContext() *Primary_operator_itemContext { + var p = new(Primary_operator_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_item + return p +} + +func InitEmptyPrimary_operator_itemContext(p *Primary_operator_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_operator_item +} + +func (*Primary_operator_itemContext) IsPrimary_operator_itemContext() {} + +func NewPrimary_operator_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_operator_itemContext { + var p = new(Primary_operator_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_primary_operator_item + + return p +} + +func (s *Primary_operator_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_operator_itemContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Primary_operator_itemContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Primary_operator_itemContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Primary_operator_itemContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Primary_operator_itemContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Primary_operator_itemContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Primary_operator_itemContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Primary_operator_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_operator_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_operator_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrimary_operator_item(s) + } +} + +func (s *Primary_operator_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrimary_operator_item(s) + } +} + +func (s *Primary_operator_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrimary_operator_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Primary_operator_item() (localctx IPrimary_operator_itemContext) { + localctx = NewPrimary_operator_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 994, PlSqlParserRULE_primary_operator_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9899) + p.Schema_object_name() + } + { + p.SetState(9900) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9901) + p.Datatype() + } + p.SetState(9906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9902) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9903) + p.Datatype() + } + + p.SetState(9908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9909) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOperator_context_clauseContext is an interface to support dynamic dispatch. +type IOperator_context_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + INDEX() antlr.TerminalNode + AllCONTEXT() []antlr.TerminalNode + CONTEXT(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + SCAN() antlr.TerminalNode + Implementation_type_name() IImplementation_type_nameContext + COMPUTE() antlr.TerminalNode + ANCILLARY() antlr.TerminalNode + DATA() antlr.TerminalNode + COLUMN() antlr.TerminalNode + + // IsOperator_context_clauseContext differentiates from other interfaces. + IsOperator_context_clauseContext() +} + +type Operator_context_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOperator_context_clauseContext() *Operator_context_clauseContext { + var p = new(Operator_context_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_context_clause + return p +} + +func InitEmptyOperator_context_clauseContext(p *Operator_context_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_operator_context_clause +} + +func (*Operator_context_clauseContext) IsOperator_context_clauseContext() {} + +func NewOperator_context_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Operator_context_clauseContext { + var p = new(Operator_context_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_operator_context_clause + + return p +} + +func (s *Operator_context_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Operator_context_clauseContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Operator_context_clauseContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Operator_context_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Operator_context_clauseContext) AllCONTEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTEXT) +} + +func (s *Operator_context_clauseContext) CONTEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, i) +} + +func (s *Operator_context_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Operator_context_clauseContext) SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN, 0) +} + +func (s *Operator_context_clauseContext) Implementation_type_name() IImplementation_type_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImplementation_type_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImplementation_type_nameContext) +} + +func (s *Operator_context_clauseContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Operator_context_clauseContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Operator_context_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Operator_context_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Operator_context_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Operator_context_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Operator_context_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOperator_context_clause(s) + } +} + +func (s *Operator_context_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOperator_context_clause(s) + } +} + +func (s *Operator_context_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOperator_context_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Operator_context_clause() (localctx IOperator_context_clauseContext) { + localctx = NewOperator_context_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 996, PlSqlParserRULE_operator_context_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9911) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9912) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9913) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9914) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9915) + p.Match(PlSqlParserSCAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9916) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9917) + p.Implementation_type_name() + } + p.SetState(9921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPUTE { + { + p.SetState(9918) + p.Match(PlSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9919) + p.Match(PlSqlParserANCILLARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9920) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(9923) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9924) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9925) + p.Match(PlSqlParserCONTEXT) + 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 +} + +// IUsing_function_clauseContext is an interface to support dynamic dispatch. +type IUsing_function_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Operator_function_name() IOperator_function_nameContext + + // IsUsing_function_clauseContext differentiates from other interfaces. + IsUsing_function_clauseContext() +} + +type Using_function_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_function_clauseContext() *Using_function_clauseContext { + var p = new(Using_function_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_function_clause + return p +} + +func InitEmptyUsing_function_clauseContext(p *Using_function_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_function_clause +} + +func (*Using_function_clauseContext) IsUsing_function_clauseContext() {} + +func NewUsing_function_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_function_clauseContext { + var p = new(Using_function_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_function_clause + + return p +} + +func (s *Using_function_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_function_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_function_clauseContext) Operator_function_name() IOperator_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOperator_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOperator_function_nameContext) +} + +func (s *Using_function_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_function_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_function_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_function_clause(s) + } +} + +func (s *Using_function_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_function_clause(s) + } +} + +func (s *Using_function_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_function_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_function_clause() (localctx IUsing_function_clauseContext) { + localctx = NewUsing_function_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 998, PlSqlParserRULE_using_function_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9928) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9929) + p.Operator_function_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_binding_clauseContext is an interface to support dynamic dispatch. +type IDrop_binding_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + BINDING() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_binding_clauseContext differentiates from other interfaces. + IsDrop_binding_clauseContext() +} + +type Drop_binding_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_binding_clauseContext() *Drop_binding_clauseContext { + var p = new(Drop_binding_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_binding_clause + return p +} + +func InitEmptyDrop_binding_clauseContext(p *Drop_binding_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_binding_clause +} + +func (*Drop_binding_clauseContext) IsDrop_binding_clauseContext() {} + +func NewDrop_binding_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_binding_clauseContext { + var p = new(Drop_binding_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_binding_clause + + return p +} + +func (s *Drop_binding_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_binding_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_binding_clauseContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Drop_binding_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_binding_clauseContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Drop_binding_clauseContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Drop_binding_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_binding_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_binding_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_binding_clauseContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_binding_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_binding_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_binding_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_binding_clause(s) + } +} + +func (s *Drop_binding_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_binding_clause(s) + } +} + +func (s *Drop_binding_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_binding_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_binding_clause() (localctx IDrop_binding_clauseContext) { + localctx = NewDrop_binding_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1000, PlSqlParserRULE_drop_binding_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9931) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9932) + p.Match(PlSqlParserBINDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9933) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9934) + p.Datatype() + } + p.SetState(9939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9935) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9936) + p.Datatype() + } + + p.SetState(9941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9942) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9944) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1134, p.GetParserRuleContext()) == 1 { + { + p.SetState(9943) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_materialized_viewContext is an interface to support dynamic dispatch. +type ICreate_materialized_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMv_tablespace returns the mv_tablespace rule contexts. + GetMv_tablespace() IId_expressionContext + + // SetMv_tablespace sets the mv_tablespace rule contexts. + SetMv_tablespace(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + SEMICOLON() antlr.TerminalNode + ON() antlr.TerminalNode + PREBUILT() antlr.TerminalNode + TABLE() antlr.TerminalNode + OF() antlr.TerminalNode + Type_name() IType_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + NO() antlr.TerminalNode + Create_mv_refresh() ICreate_mv_refreshContext + FOR() antlr.TerminalNode + UPDATE() antlr.TerminalNode + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + AllScoped_table_ref_constraint() []IScoped_table_ref_constraintContext + Scoped_table_ref_constraint(i int) IScoped_table_ref_constraintContext + AllMv_column_alias() []IMv_column_aliasContext + Mv_column_alias(i int) IMv_column_aliasContext + REDUCED() antlr.TerminalNode + PRECISION() antlr.TerminalNode + Physical_properties() IPhysical_propertiesContext + Parallel_clause() IParallel_clauseContext + Build_clause() IBuild_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsCreate_materialized_viewContext differentiates from other interfaces. + IsCreate_materialized_viewContext() +} + +type Create_materialized_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mv_tablespace IId_expressionContext +} + +func NewEmptyCreate_materialized_viewContext() *Create_materialized_viewContext { + var p = new(Create_materialized_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_materialized_view + return p +} + +func InitEmptyCreate_materialized_viewContext(p *Create_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_materialized_view + + return p +} + +func (s *Create_materialized_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_materialized_viewContext) GetMv_tablespace() IId_expressionContext { + return s.mv_tablespace +} + +func (s *Create_materialized_viewContext) SetMv_tablespace(v IId_expressionContext) { + s.mv_tablespace = v +} + +func (s *Create_materialized_viewContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Create_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Create_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_materialized_viewContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_materialized_viewContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Create_materialized_viewContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_materialized_viewContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_materialized_viewContext) PREBUILT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREBUILT, 0) +} + +func (s *Create_materialized_viewContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Create_materialized_viewContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_materialized_viewContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Create_materialized_viewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_materialized_viewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_materialized_viewContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_materialized_viewContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Create_materialized_viewContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Create_materialized_viewContext) Create_mv_refresh() ICreate_mv_refreshContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_mv_refreshContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_mv_refreshContext) +} + +func (s *Create_materialized_viewContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_materialized_viewContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Create_materialized_viewContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Create_materialized_viewContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Create_materialized_viewContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Create_materialized_viewContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Create_materialized_viewContext) AllScoped_table_ref_constraint() []IScoped_table_ref_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IScoped_table_ref_constraintContext); ok { + len++ + } + } + + tst := make([]IScoped_table_ref_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IScoped_table_ref_constraintContext); ok { + tst[i] = t.(IScoped_table_ref_constraintContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Scoped_table_ref_constraint(i int) IScoped_table_ref_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IScoped_table_ref_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IScoped_table_ref_constraintContext) +} + +func (s *Create_materialized_viewContext) AllMv_column_alias() []IMv_column_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMv_column_aliasContext); ok { + len++ + } + } + + tst := make([]IMv_column_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMv_column_aliasContext); ok { + tst[i] = t.(IMv_column_aliasContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Mv_column_alias(i int) IMv_column_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMv_column_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMv_column_aliasContext) +} + +func (s *Create_materialized_viewContext) REDUCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUCED, 0) +} + +func (s *Create_materialized_viewContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Create_materialized_viewContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Create_materialized_viewContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_materialized_viewContext) Build_clause() IBuild_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBuild_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBuild_clauseContext) +} + +func (s *Create_materialized_viewContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_materialized_viewContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_materialized_viewContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Create_materialized_viewContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Create_materialized_viewContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Create_materialized_viewContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Create_materialized_viewContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_materialized_viewContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_materialized_viewContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_materialized_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_materialized_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_materialized_view(s) + } +} + +func (s *Create_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_materialized_view(s) + } +} + +func (s *Create_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_materialized_view() (localctx ICreate_materialized_viewContext) { + localctx = NewCreate_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1002, PlSqlParserRULE_create_materialized_view) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(9946) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9947) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9948) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9949) + p.Tableview_name() + } + p.SetState(9952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(9950) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9951) + p.Type_name() + } + + } + p.SetState(9971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(9954) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1136, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9955) + p.Scoped_table_ref_constraint() + } + + case 2: + { + p.SetState(9956) + p.Mv_column_alias() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(9966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(9959) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(9962) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1137, p.GetParserRuleContext()) { + case 1: + { + p.SetState(9960) + p.Scoped_table_ref_constraint() + } + + case 2: + { + p.SetState(9961) + p.Mv_column_alias() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(9968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(9969) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(9993) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(9973) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9974) + p.Match(PlSqlParserPREBUILT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9975) + p.Match(PlSqlParserTABLE) + 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 == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(9976) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(9977) + p.Match(PlSqlParserREDUCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9978) + p.Match(PlSqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAS, PlSqlParserBUILD, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFOR, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNEVER, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNOPARALLEL, PlSqlParserORGANIZATION, PlSqlParserPARALLEL, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREFRESH, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserUSING: + p.SetState(9982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-206)) & ^0x3f) == 0 && ((int64(1)<<(_la-206))&206158430209) != 0) || _la == PlSqlParserEXTERNAL || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&5188146770730811393) != 0) || _la == PlSqlParserSEGMENT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(9981) + p.Physical_properties() + } + + } + p.SetState(9985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE { + { + p.SetState(9984) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(9988) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(9987) + p.Parallel_clause() + } + + } + p.SetState(9991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBUILD { + { + p.SetState(9990) + p.Build_clause() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10012) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1149, p.GetParserRuleContext()) == 1 { + { + p.SetState(9995) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9996) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPUTE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(10000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(9997) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(9998) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(9999) + + var _x = p.Id_expression() + + localctx.(*Create_materialized_viewContext).mv_tablespace = _x + } + + 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 + } + + p.SetState(10002) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1147, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + p.SetState(10008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1149, p.GetParserRuleContext()) == 2 { + { + p.SetState(10009) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10010) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10011) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNEVER || _la == PlSqlParserREFRESH { + { + p.SetState(10014) + p.Create_mv_refresh() + } + + } + p.SetState(10019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(10017) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10018) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10024) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(10021) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10022) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10023) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10026) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10027) + p.Select_only_statement() + } + { + p.SetState(10028) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IScoped_table_ref_constraintContext is an interface to support dynamic dispatch. +type IScoped_table_ref_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRef_column_or_attribute returns the ref_column_or_attribute rule contexts. + GetRef_column_or_attribute() IIdentifierContext + + // GetScope_table_name_or_c_alias returns the scope_table_name_or_c_alias rule contexts. + GetScope_table_name_or_c_alias() IIdentifierContext + + // SetRef_column_or_attribute sets the ref_column_or_attribute rule contexts. + SetRef_column_or_attribute(IIdentifierContext) + + // SetScope_table_name_or_c_alias sets the scope_table_name_or_c_alias rule contexts. + SetScope_table_name_or_c_alias(IIdentifierContext) + + // Getter signatures + SCOPE() antlr.TerminalNode + FOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + IS() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsScoped_table_ref_constraintContext differentiates from other interfaces. + IsScoped_table_ref_constraintContext() +} + +type Scoped_table_ref_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ref_column_or_attribute IIdentifierContext + scope_table_name_or_c_alias IIdentifierContext +} + +func NewEmptyScoped_table_ref_constraintContext() *Scoped_table_ref_constraintContext { + var p = new(Scoped_table_ref_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint + return p +} + +func InitEmptyScoped_table_ref_constraintContext(p *Scoped_table_ref_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint +} + +func (*Scoped_table_ref_constraintContext) IsScoped_table_ref_constraintContext() {} + +func NewScoped_table_ref_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Scoped_table_ref_constraintContext { + var p = new(Scoped_table_ref_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_scoped_table_ref_constraint + + return p +} + +func (s *Scoped_table_ref_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Scoped_table_ref_constraintContext) GetRef_column_or_attribute() IIdentifierContext { + return s.ref_column_or_attribute +} + +func (s *Scoped_table_ref_constraintContext) GetScope_table_name_or_c_alias() IIdentifierContext { + return s.scope_table_name_or_c_alias +} + +func (s *Scoped_table_ref_constraintContext) SetRef_column_or_attribute(v IIdentifierContext) { + s.ref_column_or_attribute = v +} + +func (s *Scoped_table_ref_constraintContext) SetScope_table_name_or_c_alias(v IIdentifierContext) { + s.scope_table_name_or_c_alias = v +} + +func (s *Scoped_table_ref_constraintContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Scoped_table_ref_constraintContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Scoped_table_ref_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Scoped_table_ref_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Scoped_table_ref_constraintContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Scoped_table_ref_constraintContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Scoped_table_ref_constraintContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Scoped_table_ref_constraintContext) 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 *Scoped_table_ref_constraintContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Scoped_table_ref_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Scoped_table_ref_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Scoped_table_ref_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterScoped_table_ref_constraint(s) + } +} + +func (s *Scoped_table_ref_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitScoped_table_ref_constraint(s) + } +} + +func (s *Scoped_table_ref_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitScoped_table_ref_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Scoped_table_ref_constraint() (localctx IScoped_table_ref_constraintContext) { + localctx = NewScoped_table_ref_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1004, PlSqlParserRULE_scoped_table_ref_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10030) + p.Match(PlSqlParserSCOPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10031) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10032) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10033) + + var _x = p.Identifier() + + localctx.(*Scoped_table_ref_constraintContext).ref_column_or_attribute = _x + } + { + p.SetState(10034) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10035) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10039) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1153, p.GetParserRuleContext()) == 1 { + { + p.SetState(10036) + p.Schema_name() + } + { + p.SetState(10037) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10041) + + var _x = p.Identifier() + + localctx.(*Scoped_table_ref_constraintContext).scope_table_name_or_c_alias = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMv_column_aliasContext is an interface to support dynamic dispatch. +type IMv_column_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + + // IsMv_column_aliasContext differentiates from other interfaces. + IsMv_column_aliasContext() +} + +type Mv_column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMv_column_aliasContext() *Mv_column_aliasContext { + var p = new(Mv_column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_column_alias + return p +} + +func InitEmptyMv_column_aliasContext(p *Mv_column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mv_column_alias +} + +func (*Mv_column_aliasContext) IsMv_column_aliasContext() {} + +func NewMv_column_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mv_column_aliasContext { + var p = new(Mv_column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mv_column_alias + + return p +} + +func (s *Mv_column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mv_column_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Mv_column_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Mv_column_aliasContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Mv_column_aliasContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Mv_column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mv_column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mv_column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMv_column_alias(s) + } +} + +func (s *Mv_column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMv_column_alias(s) + } +} + +func (s *Mv_column_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMv_column_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mv_column_alias() (localctx IMv_column_aliasContext) { + localctx = NewMv_column_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1006, PlSqlParserRULE_mv_column_alias) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1154, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10043) + p.Identifier() + } + + case 2: + { + p.SetState(10044) + p.Quoted_string() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPT { + { + p.SetState(10047) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10048) + p.Encryption_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_mv_refreshContext is an interface to support dynamic dispatch. +type ICreate_mv_refreshContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRb_segment returns the rb_segment token. + GetRb_segment() antlr.Token + + // SetRb_segment sets the rb_segment token. + SetRb_segment(antlr.Token) + + // Getter signatures + NEVER() antlr.TerminalNode + REFRESH() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllFAST() []antlr.TerminalNode + FAST(i int) antlr.TerminalNode + AllCOMPLETE() []antlr.TerminalNode + COMPLETE(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + AllDEMAND() []antlr.TerminalNode + DEMAND(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + AllENFORCED() []antlr.TerminalNode + ENFORCED(i int) antlr.TerminalNode + AllTRUSTED() []antlr.TerminalNode + TRUSTED(i int) antlr.TerminalNode + AllSTART() []antlr.TerminalNode + START(i int) antlr.TerminalNode + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllROWID() []antlr.TerminalNode + ROWID(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllROLLBACK() []antlr.TerminalNode + ROLLBACK(i int) antlr.TerminalNode + AllSEGMENT() []antlr.TerminalNode + SEGMENT(i int) antlr.TerminalNode + AllREGULAR_ID() []antlr.TerminalNode + REGULAR_ID(i int) antlr.TerminalNode + AllMASTER() []antlr.TerminalNode + MASTER(i int) antlr.TerminalNode + AllLOCAL() []antlr.TerminalNode + LOCAL(i int) antlr.TerminalNode + + // IsCreate_mv_refreshContext differentiates from other interfaces. + IsCreate_mv_refreshContext() +} + +type Create_mv_refreshContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rb_segment antlr.Token +} + +func NewEmptyCreate_mv_refreshContext() *Create_mv_refreshContext { + var p = new(Create_mv_refreshContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_mv_refresh + return p +} + +func InitEmptyCreate_mv_refreshContext(p *Create_mv_refreshContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_mv_refresh +} + +func (*Create_mv_refreshContext) IsCreate_mv_refreshContext() {} + +func NewCreate_mv_refreshContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_mv_refreshContext { + var p = new(Create_mv_refreshContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_mv_refresh + + return p +} + +func (s *Create_mv_refreshContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_mv_refreshContext) GetRb_segment() antlr.Token { return s.rb_segment } + +func (s *Create_mv_refreshContext) SetRb_segment(v antlr.Token) { s.rb_segment = v } + +func (s *Create_mv_refreshContext) NEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEVER, 0) +} + +func (s *Create_mv_refreshContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Create_mv_refreshContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Create_mv_refreshContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Create_mv_refreshContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Create_mv_refreshContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Create_mv_refreshContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Create_mv_refreshContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Create_mv_refreshContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Create_mv_refreshContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Create_mv_refreshContext) AllFAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFAST) +} + +func (s *Create_mv_refreshContext) FAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, i) +} + +func (s *Create_mv_refreshContext) AllCOMPLETE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMPLETE) +} + +func (s *Create_mv_refreshContext) COMPLETE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, i) +} + +func (s *Create_mv_refreshContext) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Create_mv_refreshContext) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Create_mv_refreshContext) AllDEMAND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEMAND) +} + +func (s *Create_mv_refreshContext) DEMAND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, i) +} + +func (s *Create_mv_refreshContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Create_mv_refreshContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Create_mv_refreshContext) AllENFORCED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENFORCED) +} + +func (s *Create_mv_refreshContext) ENFORCED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, i) +} + +func (s *Create_mv_refreshContext) AllTRUSTED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRUSTED) +} + +func (s *Create_mv_refreshContext) TRUSTED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, i) +} + +func (s *Create_mv_refreshContext) AllSTART() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTART) +} + +func (s *Create_mv_refreshContext) START(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, i) +} + +func (s *Create_mv_refreshContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Create_mv_refreshContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Create_mv_refreshContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Create_mv_refreshContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Create_mv_refreshContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Create_mv_refreshContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Create_mv_refreshContext) AllROWID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROWID) +} + +func (s *Create_mv_refreshContext) ROWID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, i) +} + +func (s *Create_mv_refreshContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Create_mv_refreshContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Create_mv_refreshContext) AllROLLBACK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROLLBACK) +} + +func (s *Create_mv_refreshContext) ROLLBACK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, i) +} + +func (s *Create_mv_refreshContext) AllSEGMENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEGMENT) +} + +func (s *Create_mv_refreshContext) SEGMENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, i) +} + +func (s *Create_mv_refreshContext) AllREGULAR_ID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREGULAR_ID) +} + +func (s *Create_mv_refreshContext) REGULAR_ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, i) +} + +func (s *Create_mv_refreshContext) AllMASTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMASTER) +} + +func (s *Create_mv_refreshContext) MASTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, i) +} + +func (s *Create_mv_refreshContext) AllLOCAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOCAL) +} + +func (s *Create_mv_refreshContext) LOCAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, i) +} + +func (s *Create_mv_refreshContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_mv_refreshContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_mv_refreshContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_mv_refresh(s) + } +} + +func (s *Create_mv_refreshContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_mv_refresh(s) + } +} + +func (s *Create_mv_refreshContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_mv_refresh(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_mv_refresh() (localctx ICreate_mv_refreshContext) { + localctx = NewCreate_mv_refreshContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1008, PlSqlParserRULE_create_mv_refresh) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNEVER: + { + p.SetState(10051) + p.Match(PlSqlParserNEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10052) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREFRESH: + { + p.SetState(10053) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE || _la == PlSqlParserNEXT || _la == PlSqlParserON || _la == PlSqlParserSTART || _la == PlSqlParserUSING || _la == PlSqlParserWITH { + p.SetState(10086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1161, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10054) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPLETE || _la == PlSqlParserFAST || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(10055) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10056) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserDEMAND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 3: + p.SetState(10060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + { + p.SetState(10057) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10058) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNEXT: + { + p.SetState(10059) + p.Match(PlSqlParserNEXT) + 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.SetState(10062) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY: + { + p.SetState(10063) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10064) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + { + p.SetState(10065) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 5: + { + p.SetState(10068) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(10069) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL || _la == PlSqlParserMASTER { + { + p.SetState(10070) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCAL || _la == PlSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10073) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10074) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOCAL, PlSqlParserMASTER, PlSqlParserROLLBACK: + p.SetState(10076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL || _la == PlSqlParserMASTER { + { + p.SetState(10075) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCAL || _la == PlSqlParserMASTER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10078) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10079) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10080) + + var _m = p.Match(PlSqlParserREGULAR_ID) + + localctx.(*Create_mv_refreshContext).rb_segment = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 6: + { + p.SetState(10083) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10084) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENFORCED || _la == PlSqlParserTRUSTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10085) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(10088) + 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 +} + +// 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 + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + TABLE() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_materialized_view + return p +} + +func InitEmptyDrop_materialized_viewContext(p *Drop_materialized_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_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(PlSqlParserDROP, 0) +} + +func (s *Drop_materialized_viewContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Drop_materialized_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_materialized_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_materialized_viewContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_materialized_viewContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Drop_materialized_viewContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_materialized_view(s) + } +} + +func (s *Drop_materialized_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_materialized_view(s) + } +} + +func (s *Drop_materialized_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_materialized_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_materialized_view() (localctx IDrop_materialized_viewContext) { + localctx = NewDrop_materialized_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1010, PlSqlParserRULE_drop_materialized_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10092) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10093) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10094) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10095) + p.Tableview_name() + } + p.SetState(10098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRESERVE { + { + p.SetState(10096) + p.Match(PlSqlParserPRESERVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10097) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10100) + p.Match(PlSqlParserSEMICOLON) + 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_contextContext is an interface to support dynamic dispatch. +type ICreate_contextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + Oracle_namespace() IOracle_namespaceContext + USING() antlr.TerminalNode + Package_name() IPackage_nameContext + SEMICOLON() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + PERIOD() antlr.TerminalNode + INITIALIZED() antlr.TerminalNode + ACCESSED() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + + // IsCreate_contextContext differentiates from other interfaces. + IsCreate_contextContext() +} + +type Create_contextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_contextContext() *Create_contextContext { + var p = new(Create_contextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_context + return p +} + +func InitEmptyCreate_contextContext(p *Create_contextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_context +} + +func (*Create_contextContext) IsCreate_contextContext() {} + +func NewCreate_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_contextContext { + var p = new(Create_contextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_context + + return p +} + +func (s *Create_contextContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_contextContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_contextContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Create_contextContext) Oracle_namespace() IOracle_namespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOracle_namespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOracle_namespaceContext) +} + +func (s *Create_contextContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_contextContext) Package_name() IPackage_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPackage_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPackage_nameContext) +} + +func (s *Create_contextContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_contextContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_contextContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_contextContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_contextContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_contextContext) INITIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALIZED, 0) +} + +func (s *Create_contextContext) ACCESSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSED, 0) +} + +func (s *Create_contextContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Create_contextContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Create_contextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_contextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_context(s) + } +} + +func (s *Create_contextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_context(s) + } +} + +func (s *Create_contextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_context(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_context() (localctx ICreate_contextContext) { + localctx = NewCreate_contextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1012, PlSqlParserRULE_create_context) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10102) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(10103) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10104) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10107) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10108) + p.Oracle_namespace() + } + { + p.SetState(10109) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10113) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1166, p.GetParserRuleContext()) == 1 { + { + p.SetState(10110) + p.Schema_object_name() + } + { + p.SetState(10111) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10115) + p.Package_name() + } + p.SetState(10120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINITIALIZED: + { + p.SetState(10116) + p.Match(PlSqlParserINITIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10117) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXTERNALLY || _la == PlSqlParserGLOBALLY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserACCESSED: + { + p.SetState(10118) + p.Match(PlSqlParserACCESSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10119) + p.Match(PlSqlParserGLOBALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEMICOLON: + + default: + } + { + p.SetState(10122) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IOracle_namespaceContext is an interface to support dynamic dispatch. +type IOracle_namespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsOracle_namespaceContext differentiates from other interfaces. + IsOracle_namespaceContext() +} + +type Oracle_namespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOracle_namespaceContext() *Oracle_namespaceContext { + var p = new(Oracle_namespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oracle_namespace + return p +} + +func InitEmptyOracle_namespaceContext(p *Oracle_namespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oracle_namespace +} + +func (*Oracle_namespaceContext) IsOracle_namespaceContext() {} + +func NewOracle_namespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oracle_namespaceContext { + var p = new(Oracle_namespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oracle_namespace + + return p +} + +func (s *Oracle_namespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oracle_namespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Oracle_namespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oracle_namespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oracle_namespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOracle_namespace(s) + } +} + +func (s *Oracle_namespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOracle_namespace(s) + } +} + +func (s *Oracle_namespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOracle_namespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Oracle_namespace() (localctx IOracle_namespaceContext) { + localctx = NewOracle_namespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1014, PlSqlParserRULE_oracle_namespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10124) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_clusterContext is an interface to support dynamic dispatch. +type ICreate_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllDatatype() []IDatatypeContext + Datatype(i int) IDatatypeContext + RIGHT_PAREN() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + AllSORT() []antlr.TerminalNode + SORT(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllINDEX() []antlr.TerminalNode + INDEX(i int) antlr.TerminalNode + AllHASHKEYS() []antlr.TerminalNode + HASHKEYS(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + ROWDEPENDENCIES() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + AllSINGLE() []antlr.TerminalNode + SINGLE(i int) antlr.TerminalNode + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + AllHASH() []antlr.TerminalNode + HASH(i int) antlr.TerminalNode + AllIS() []antlr.TerminalNode + IS(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + + // IsCreate_clusterContext differentiates from other interfaces. + IsCreate_clusterContext() +} + +type Create_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_clusterContext() *Create_clusterContext { + var p = new(Create_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_cluster + return p +} + +func InitEmptyCreate_clusterContext(p *Create_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_cluster +} + +func (*Create_clusterContext) IsCreate_clusterContext() {} + +func NewCreate_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_clusterContext { + var p = new(Create_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_cluster + + return p +} + +func (s *Create_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_clusterContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Create_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Create_clusterContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Create_clusterContext) 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 *Create_clusterContext) 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 *Create_clusterContext) AllDatatype() []IDatatypeContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatatypeContext); ok { + len++ + } + } + + tst := make([]IDatatypeContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatatypeContext); ok { + tst[i] = t.(IDatatypeContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Datatype(i int) IDatatypeContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Create_clusterContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Create_clusterContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_clusterContext) AllSORT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSORT) +} + +func (s *Create_clusterContext) SORT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, i) +} + +func (s *Create_clusterContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_clusterContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_clusterContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Create_clusterContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Create_clusterContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Create_clusterContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Create_clusterContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_clusterContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_clusterContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Create_clusterContext) AllINDEX() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINDEX) +} + +func (s *Create_clusterContext) INDEX(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, i) +} + +func (s *Create_clusterContext) AllHASHKEYS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHASHKEYS) +} + +func (s *Create_clusterContext) HASHKEYS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHKEYS, i) +} + +func (s *Create_clusterContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Create_clusterContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Create_clusterContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Create_clusterContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Create_clusterContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Create_clusterContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Create_clusterContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Create_clusterContext) AllSINGLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSINGLE) +} + +func (s *Create_clusterContext) SINGLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, i) +} + +func (s *Create_clusterContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLE) +} + +func (s *Create_clusterContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, i) +} + +func (s *Create_clusterContext) AllHASH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHASH) +} + +func (s *Create_clusterContext) HASH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, i) +} + +func (s *Create_clusterContext) AllIS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIS) +} + +func (s *Create_clusterContext) IS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, i) +} + +func (s *Create_clusterContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Create_clusterContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_cluster(s) + } +} + +func (s *Create_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_cluster(s) + } +} + +func (s *Create_clusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_cluster(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_cluster() (localctx ICreate_clusterContext) { + localctx = NewCreate_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1016, PlSqlParserRULE_create_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10126) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10127) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10128) + p.Cluster_name() + } + { + p.SetState(10129) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10130) + p.Column_name() + } + { + p.SetState(10131) + p.Datatype() + } + p.SetState(10133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(10132) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10135) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10136) + p.Column_name() + } + { + p.SetState(10137) + p.Datatype() + } + p.SetState(10139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(10138) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(10145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10146) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMPUTE || _la == PlSqlParserHASHKEYS || _la == PlSqlParserINDEX || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSINGLE || _la == PlSqlParserSIZE || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(10147) + p.Physical_attributes_clause() + } + + case PlSqlParserSIZE: + { + p.SetState(10148) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10149) + p.Size_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(10150) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10151) + p.Tablespace() + } + + case PlSqlParserINDEX: + { + p.SetState(10152) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHASHKEYS, PlSqlParserSINGLE: + p.SetState(10155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSINGLE { + { + p.SetState(10153) + p.Match(PlSqlParserSINGLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10154) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10157) + p.Match(PlSqlParserHASHKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10158) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHASH { + { + p.SetState(10159) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10160) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10161) + p.Expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(10170) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(10169) + p.Parallel_clause() + } + + } + p.SetState(10173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES { + { + p.SetState(10172) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE { + { + p.SetState(10175) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10178) + p.Match(PlSqlParserSEMICOLON) + 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_profileContext is an interface to support dynamic dispatch. +type ICreate_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + PROFILE() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Id_expression() IId_expressionContext + MANDATORY() antlr.TerminalNode + AllResource_parameters() []IResource_parametersContext + Resource_parameters(i int) IResource_parametersContext + AllPassword_parameters() []IPassword_parametersContext + Password_parameters(i int) IPassword_parametersContext + Container_clause() IContainer_clauseContext + + // IsCreate_profileContext differentiates from other interfaces. + IsCreate_profileContext() +} + +type Create_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyCreate_profileContext() *Create_profileContext { + var p = new(Create_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_profile + return p +} + +func InitEmptyCreate_profileContext(p *Create_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_profile +} + +func (*Create_profileContext) IsCreate_profileContext() {} + +func NewCreate_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_profileContext { + var p = new(Create_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_profile + + return p +} + +func (s *Create_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_profileContext) GetP() IId_expressionContext { return s.p } + +func (s *Create_profileContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Create_profileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Create_profileContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Create_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_profileContext) MANDATORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANDATORY, 0) +} + +func (s *Create_profileContext) AllResource_parameters() []IResource_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IResource_parametersContext); ok { + len++ + } + } + + tst := make([]IResource_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IResource_parametersContext); ok { + tst[i] = t.(IResource_parametersContext) + i++ + } + } + + return tst +} + +func (s *Create_profileContext) Resource_parameters(i int) IResource_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResource_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IResource_parametersContext) +} + +func (s *Create_profileContext) AllPassword_parameters() []IPassword_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_parametersContext); ok { + len++ + } + } + + tst := make([]IPassword_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_parametersContext); ok { + tst[i] = t.(IPassword_parametersContext) + i++ + } + } + + return tst +} + +func (s *Create_profileContext) Password_parameters(i int) IPassword_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_parametersContext) +} + +func (s *Create_profileContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +func (s *Create_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_profile(s) + } +} + +func (s *Create_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_profile(s) + } +} + +func (s *Create_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_profile() (localctx ICreate_profileContext) { + localctx = NewCreate_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1018, PlSqlParserRULE_create_profile) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10180) + p.Match(PlSqlParserCREATE) + 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 == PlSqlParserMANDATORY { + { + p.SetState(10181) + p.Match(PlSqlParserMANDATORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10184) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10185) + + var _x = p.Id_expression() + + localctx.(*Create_profileContext).p = _x + } + { + p.SetState(10186) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(10189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCONNECT_TIME, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserIDLE_TIME, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserPRIVATE_SGA, PlSqlParserSESSIONS_PER_USER: + { + p.SetState(10187) + p.Resource_parameters() + } + + case PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION: + { + p.SetState(10188) + p.Password_parameters() + } + + 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 + } + + p.SetState(10191) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1180, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(10194) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1181, p.GetParserRuleContext()) == 1 { + { + p.SetState(10193) + p.Container_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 +} + +// IResource_parametersContext is an interface to support dynamic dispatch. +type IResource_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SESSIONS_PER_USER() antlr.TerminalNode + CPU_PER_SESSION() antlr.TerminalNode + CPU_PER_CALL() antlr.TerminalNode + CONNECT_TIME() antlr.TerminalNode + IDLE_TIME() antlr.TerminalNode + LOGICAL_READS_PER_SESSION() antlr.TerminalNode + LOGICAL_READS_PER_CALL() antlr.TerminalNode + COMPOSITE_LIMIT() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PRIVATE_SGA() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsResource_parametersContext differentiates from other interfaces. + IsResource_parametersContext() +} + +type Resource_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResource_parametersContext() *Resource_parametersContext { + var p = new(Resource_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resource_parameters + return p +} + +func InitEmptyResource_parametersContext(p *Resource_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resource_parameters +} + +func (*Resource_parametersContext) IsResource_parametersContext() {} + +func NewResource_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resource_parametersContext { + var p = new(Resource_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resource_parameters + + return p +} + +func (s *Resource_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resource_parametersContext) SESSIONS_PER_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONS_PER_USER, 0) +} + +func (s *Resource_parametersContext) CPU_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, 0) +} + +func (s *Resource_parametersContext) CPU_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_CALL, 0) +} + +func (s *Resource_parametersContext) CONNECT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, 0) +} + +func (s *Resource_parametersContext) IDLE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE_TIME, 0) +} + +func (s *Resource_parametersContext) LOGICAL_READS_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, 0) +} + +func (s *Resource_parametersContext) LOGICAL_READS_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_CALL, 0) +} + +func (s *Resource_parametersContext) COMPOSITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE_LIMIT, 0) +} + +func (s *Resource_parametersContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Resource_parametersContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Resource_parametersContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Resource_parametersContext) PRIVATE_SGA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, 0) +} + +func (s *Resource_parametersContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Resource_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resource_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resource_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResource_parameters(s) + } +} + +func (s *Resource_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResource_parameters(s) + } +} + +func (s *Resource_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitResource_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Resource_parameters() (localctx IResource_parametersContext) { + localctx = NewResource_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1020, PlSqlParserRULE_resource_parameters) + var _la int + + p.SetState(10204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCONNECT_TIME, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserIDLE_TIME, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserSESSIONS_PER_USER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10196) + _la = p.GetTokenStream().LA(1) + + if !(((int64((_la-240)) & ^0x3f) == 0 && ((int64(1)<<(_la-240))&864691128459329537) != 0) || _la == PlSqlParserIDLE_TIME || _la == PlSqlParserLOGICAL_READS_PER_CALL || _la == PlSqlParserLOGICAL_READS_PER_SESSION || _la == PlSqlParserSESSIONS_PER_USER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10197) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPRIVATE_SGA: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10198) + p.Match(PlSqlParserPRIVATE_SGA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(10199) + p.Size_clause() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(10200) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(10201) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// IPassword_parametersContext is an interface to support dynamic dispatch. +type IPassword_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + PASSWORD_LIFE_TIME() antlr.TerminalNode + PASSWORD_REUSE_TIME() antlr.TerminalNode + PASSWORD_REUSE_MAX() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PASSWORD_GRACE_TIME() antlr.TerminalNode + INACTIVE_ACCOUNT_TIME() antlr.TerminalNode + Expression() IExpressionContext + UNLIMITED() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode + Function_name() IFunction_nameContext + NULL_() antlr.TerminalNode + PASSWORD_ROLLOVER_TIME() antlr.TerminalNode + + // IsPassword_parametersContext differentiates from other interfaces. + IsPassword_parametersContext() +} + +type Password_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_parametersContext() *Password_parametersContext { + var p = new(Password_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_parameters + return p +} + +func InitEmptyPassword_parametersContext(p *Password_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_parameters +} + +func (*Password_parametersContext) IsPassword_parametersContext() {} + +func NewPassword_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_parametersContext { + var p = new(Password_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_parameters + + return p +} + +func (s *Password_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_parametersContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *Password_parametersContext) PASSWORD_LIFE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LIFE_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_REUSE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_REUSE_MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_MAX, 0) +} + +func (s *Password_parametersContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *Password_parametersContext) PASSWORD_GRACE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_GRACE_TIME, 0) +} + +func (s *Password_parametersContext) INACTIVE_ACCOUNT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE_ACCOUNT_TIME, 0) +} + +func (s *Password_parametersContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Password_parametersContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Password_parametersContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Password_parametersContext) PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_VERIFY_FUNCTION, 0) +} + +func (s *Password_parametersContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Password_parametersContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Password_parametersContext) PASSWORD_ROLLOVER_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_ROLLOVER_TIME, 0) +} + +func (s *Password_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_parameters(s) + } +} + +func (s *Password_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_parameters(s) + } +} + +func (s *Password_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPassword_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Password_parameters() (localctx IPassword_parametersContext) { + localctx = NewPassword_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1022, PlSqlParserRULE_password_parameters) + var _la int + + p.SetState(10223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10206) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFAILED_LOGIN_ATTEMPTS || _la == PlSqlParserINACTIVE_ACCOUNT_TIME || ((int64((_la-1261)) & ^0x3f) == 0 && ((int64(1)<<(_la-1261))&55) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(10210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1184, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10207) + p.Expression() + } + + case 2: + { + p.SetState(10208) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(10209) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserPASSWORD_VERIFY_FUNCTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10212) + p.Match(PlSqlParserPASSWORD_VERIFY_FUNCTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(10213) + p.Function_name() + } + + case PlSqlParserNULL_: + { + p.SetState(10214) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(10215) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserPASSWORD_ROLLOVER_TIME: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10218) + p.Match(PlSqlParserPASSWORD_ROLLOVER_TIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1186, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10219) + p.Expression() + } + + case 2: + { + p.SetState(10220) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_lockdown_profileContext is an interface to support dynamic dispatch. +type ICreate_lockdown_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + PROFILE() antlr.TerminalNode + Id_expression() IId_expressionContext + Static_base_profile() IStatic_base_profileContext + Dynamic_base_profile() IDynamic_base_profileContext + + // IsCreate_lockdown_profileContext differentiates from other interfaces. + IsCreate_lockdown_profileContext() +} + +type Create_lockdown_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_lockdown_profileContext() *Create_lockdown_profileContext { + var p = new(Create_lockdown_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile + return p +} + +func InitEmptyCreate_lockdown_profileContext(p *Create_lockdown_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile +} + +func (*Create_lockdown_profileContext) IsCreate_lockdown_profileContext() {} + +func NewCreate_lockdown_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_lockdown_profileContext { + var p = new(Create_lockdown_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_lockdown_profile + + return p +} + +func (s *Create_lockdown_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_lockdown_profileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_lockdown_profileContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Create_lockdown_profileContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Create_lockdown_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_lockdown_profileContext) Static_base_profile() IStatic_base_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_base_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_base_profileContext) +} + +func (s *Create_lockdown_profileContext) Dynamic_base_profile() IDynamic_base_profileContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDynamic_base_profileContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDynamic_base_profileContext) +} + +func (s *Create_lockdown_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_lockdown_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_lockdown_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_lockdown_profile(s) + } +} + +func (s *Create_lockdown_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_lockdown_profile(s) + } +} + +func (s *Create_lockdown_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_lockdown_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_lockdown_profile() (localctx ICreate_lockdown_profileContext) { + localctx = NewCreate_lockdown_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1024, PlSqlParserRULE_create_lockdown_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10225) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10226) + p.Match(PlSqlParserLOCKDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10227) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10228) + p.Id_expression() + } + p.SetState(10231) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1188, p.GetParserRuleContext()) == 1 { + { + p.SetState(10229) + p.Static_base_profile() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1188, p.GetParserRuleContext()) == 2 { + { + p.SetState(10230) + p.Dynamic_base_profile() + } + + } 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 +} + +// IStatic_base_profileContext is an interface to support dynamic dispatch. +type IStatic_base_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBp returns the bp rule contexts. + GetBp() IId_expressionContext + + // SetBp sets the bp rule contexts. + SetBp(IId_expressionContext) + + // Getter signatures + FROM() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsStatic_base_profileContext differentiates from other interfaces. + IsStatic_base_profileContext() +} + +type Static_base_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bp IId_expressionContext +} + +func NewEmptyStatic_base_profileContext() *Static_base_profileContext { + var p = new(Static_base_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_base_profile + return p +} + +func InitEmptyStatic_base_profileContext(p *Static_base_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_base_profile +} + +func (*Static_base_profileContext) IsStatic_base_profileContext() {} + +func NewStatic_base_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Static_base_profileContext { + var p = new(Static_base_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_static_base_profile + + return p +} + +func (s *Static_base_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Static_base_profileContext) GetBp() IId_expressionContext { return s.bp } + +func (s *Static_base_profileContext) SetBp(v IId_expressionContext) { s.bp = v } + +func (s *Static_base_profileContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Static_base_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Static_base_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Static_base_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Static_base_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatic_base_profile(s) + } +} + +func (s *Static_base_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatic_base_profile(s) + } +} + +func (s *Static_base_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStatic_base_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Static_base_profile() (localctx IStatic_base_profileContext) { + localctx = NewStatic_base_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1026, PlSqlParserRULE_static_base_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10233) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10234) + + var _x = p.Id_expression() + + localctx.(*Static_base_profileContext).bp = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDynamic_base_profileContext is an interface to support dynamic dispatch. +type IDynamic_base_profileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetBp returns the bp rule contexts. + GetBp() IId_expressionContext + + // SetBp sets the bp rule contexts. + SetBp(IId_expressionContext) + + // Getter signatures + INCLUDING() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDynamic_base_profileContext differentiates from other interfaces. + IsDynamic_base_profileContext() +} + +type Dynamic_base_profileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + bp IId_expressionContext +} + +func NewEmptyDynamic_base_profileContext() *Dynamic_base_profileContext { + var p = new(Dynamic_base_profileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile + return p +} + +func InitEmptyDynamic_base_profileContext(p *Dynamic_base_profileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile +} + +func (*Dynamic_base_profileContext) IsDynamic_base_profileContext() {} + +func NewDynamic_base_profileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dynamic_base_profileContext { + var p = new(Dynamic_base_profileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dynamic_base_profile + + return p +} + +func (s *Dynamic_base_profileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dynamic_base_profileContext) GetBp() IId_expressionContext { return s.bp } + +func (s *Dynamic_base_profileContext) SetBp(v IId_expressionContext) { s.bp = v } + +func (s *Dynamic_base_profileContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Dynamic_base_profileContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dynamic_base_profileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dynamic_base_profileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dynamic_base_profileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDynamic_base_profile(s) + } +} + +func (s *Dynamic_base_profileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDynamic_base_profile(s) + } +} + +func (s *Dynamic_base_profileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDynamic_base_profile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dynamic_base_profile() (localctx IDynamic_base_profileContext) { + localctx = NewDynamic_base_profileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1028, PlSqlParserRULE_dynamic_base_profile) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10236) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10237) + + var _x = p.Id_expression() + + localctx.(*Dynamic_base_profileContext).bp = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_outlineContext is an interface to support dynamic dispatch. +type ICreate_outlineContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetO returns the o rule contexts. + GetO() IId_expressionContext + + // GetSo returns the so rule contexts. + GetSo() IId_expressionContext + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetO sets the o rule contexts. + SetO(IId_expressionContext) + + // SetSo sets the so rule contexts. + SetSo(IId_expressionContext) + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + FROM() antlr.TerminalNode + FOR() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + ON() antlr.TerminalNode + Statement() IStatementContext + AllPUBLIC() []antlr.TerminalNode + PUBLIC(i int) antlr.TerminalNode + AllPRIVATE() []antlr.TerminalNode + PRIVATE(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsCreate_outlineContext differentiates from other interfaces. + IsCreate_outlineContext() +} + +type Create_outlineContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + o IId_expressionContext + so IId_expressionContext + c IId_expressionContext +} + +func NewEmptyCreate_outlineContext() *Create_outlineContext { + var p = new(Create_outlineContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_outline + return p +} + +func InitEmptyCreate_outlineContext(p *Create_outlineContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_outline +} + +func (*Create_outlineContext) IsCreate_outlineContext() {} + +func NewCreate_outlineContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_outlineContext { + var p = new(Create_outlineContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_outline + + return p +} + +func (s *Create_outlineContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_outlineContext) GetO() IId_expressionContext { return s.o } + +func (s *Create_outlineContext) GetSo() IId_expressionContext { return s.so } + +func (s *Create_outlineContext) GetC() IId_expressionContext { return s.c } + +func (s *Create_outlineContext) SetO(v IId_expressionContext) { s.o = v } + +func (s *Create_outlineContext) SetSo(v IId_expressionContext) { s.so = v } + +func (s *Create_outlineContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Create_outlineContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_outlineContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Create_outlineContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_outlineContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_outlineContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_outlineContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_outlineContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Create_outlineContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Create_outlineContext) Statement() IStatementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *Create_outlineContext) AllPUBLIC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPUBLIC) +} + +func (s *Create_outlineContext) PUBLIC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, i) +} + +func (s *Create_outlineContext) AllPRIVATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIVATE) +} + +func (s *Create_outlineContext) PRIVATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, i) +} + +func (s *Create_outlineContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_outlineContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_outlineContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_outlineContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_outlineContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_outline(s) + } +} + +func (s *Create_outlineContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_outline(s) + } +} + +func (s *Create_outlineContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_outline(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_outline() (localctx ICreate_outlineContext) { + localctx = NewCreate_outlineContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1030, PlSqlParserRULE_create_outline) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10239) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(10240) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10241) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC { + { + p.SetState(10244) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10247) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10249) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1191, p.GetParserRuleContext()) == 1 { + { + p.SetState(10248) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).o = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10256) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1193, p.GetParserRuleContext()) == 1 { + { + p.SetState(10251) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10253) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1192, p.GetParserRuleContext()) == 1 { + { + p.SetState(10252) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPRIVATE || _la == PlSqlParserPUBLIC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10255) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).so = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10261) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1194, p.GetParserRuleContext()) == 1 { + { + p.SetState(10258) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10259) + p.Match(PlSqlParserCATEGORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10260) + + var _x = p.Id_expression() + + localctx.(*Create_outlineContext).c = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10265) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1195, p.GetParserRuleContext()) == 1 { + { + p.SetState(10263) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10264) + p.Statement() + } + + } 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 +} + +// ICreate_restore_pointContext is an interface to support dynamic dispatch. +type ICreate_restore_pointContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRp returns the rp rule contexts. + GetRp() IId_expressionContext + + // GetPdb returns the pdb rule contexts. + GetPdb() IId_expressionContext + + // SetRp sets the rp rule contexts. + SetRp(IId_expressionContext) + + // SetPdb sets the pdb rule contexts. + SetPdb(IId_expressionContext) + + // Getter signatures + CREATE() antlr.TerminalNode + RESTORE() antlr.TerminalNode + POINT() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + CLEAN() antlr.TerminalNode + FOR() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + AllDATABASE() []antlr.TerminalNode + DATABASE(i int) antlr.TerminalNode + AS() antlr.TerminalNode + OF() antlr.TerminalNode + Expression() IExpressionContext + PRESERVE() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + SCN() antlr.TerminalNode + + // IsCreate_restore_pointContext differentiates from other interfaces. + IsCreate_restore_pointContext() +} + +type Create_restore_pointContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + rp IId_expressionContext + pdb IId_expressionContext +} + +func NewEmptyCreate_restore_pointContext() *Create_restore_pointContext { + var p = new(Create_restore_pointContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_restore_point + return p +} + +func InitEmptyCreate_restore_pointContext(p *Create_restore_pointContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_restore_point +} + +func (*Create_restore_pointContext) IsCreate_restore_pointContext() {} + +func NewCreate_restore_pointContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_restore_pointContext { + var p = new(Create_restore_pointContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_restore_point + + return p +} + +func (s *Create_restore_pointContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_restore_pointContext) GetRp() IId_expressionContext { return s.rp } + +func (s *Create_restore_pointContext) GetPdb() IId_expressionContext { return s.pdb } + +func (s *Create_restore_pointContext) SetRp(v IId_expressionContext) { s.rp = v } + +func (s *Create_restore_pointContext) SetPdb(v IId_expressionContext) { s.pdb = v } + +func (s *Create_restore_pointContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_restore_pointContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Create_restore_pointContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Create_restore_pointContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Create_restore_pointContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Create_restore_pointContext) CLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAN, 0) +} + +func (s *Create_restore_pointContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_restore_pointContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Create_restore_pointContext) AllDATABASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATABASE) +} + +func (s *Create_restore_pointContext) DATABASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, i) +} + +func (s *Create_restore_pointContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_restore_pointContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Create_restore_pointContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Create_restore_pointContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Create_restore_pointContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Create_restore_pointContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Create_restore_pointContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Create_restore_pointContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Create_restore_pointContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_restore_pointContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_restore_pointContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_restore_point(s) + } +} + +func (s *Create_restore_pointContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_restore_point(s) + } +} + +func (s *Create_restore_pointContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_restore_point(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_restore_point() (localctx ICreate_restore_pointContext) { + localctx = NewCreate_restore_pointContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1032, PlSqlParserRULE_create_restore_point) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10267) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLEAN { + { + p.SetState(10268) + p.Match(PlSqlParserCLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10271) + p.Match(PlSqlParserRESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10272) + p.Match(PlSqlParserPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10273) + + var _x = p.Id_expression() + + localctx.(*Create_restore_pointContext).rp = _x + } + p.SetState(10278) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1197, p.GetParserRuleContext()) == 1 { + { + p.SetState(10274) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10275) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10276) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10277) + + var _x = p.Id_expression() + + localctx.(*Create_restore_pointContext).pdb = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10284) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1198, p.GetParserRuleContext()) == 1 { + { + p.SetState(10280) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10281) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10282) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10283) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10290) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1199, p.GetParserRuleContext()) == 1 { + { + p.SetState(10286) + p.Match(PlSqlParserPRESERVE) + 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(), 1199, p.GetParserRuleContext()) == 2 { + { + p.SetState(10287) + p.Match(PlSqlParserGUARANTEE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10288) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10289) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Role_name() IRole_nameContext + Role_identified_clause() IRole_identified_clauseContext + Container_clause() IContainer_clauseContext + + // 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 = PlSqlParserRULE_create_role + return p +} + +func InitEmptyCreate_roleContext(p *Create_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_role + + return p +} + +func (s *Create_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_roleContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Create_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Create_roleContext) Role_identified_clause() IRole_identified_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_identified_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_identified_clauseContext) +} + +func (s *Create_roleContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_role(s) + } +} + +func (s *Create_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_role(s) + } +} + +func (s *Create_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_role() (localctx ICreate_roleContext) { + localctx = NewCreate_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1034, PlSqlParserRULE_create_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10292) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10293) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10294) + p.Role_name() + } + p.SetState(10296) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1200, p.GetParserRuleContext()) == 1 { + { + p.SetState(10295) + p.Role_identified_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10299) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1201, p.GetParserRuleContext()) == 1 { + { + p.SetState(10298) + p.Container_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 +} + +// 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 + Table_name() ITable_nameContext + SEMICOLON() antlr.TerminalNode + Relational_table() IRelational_tableContext + Object_table() IObject_tableContext + Xmltype_table() IXmltype_tableContext + TEMPORARY() antlr.TerminalNode + SHARDED() antlr.TerminalNode + DUPLICATED() antlr.TerminalNode + BLOCKCHAIN() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + SHARING() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + AllMEMOPTIMIZE() []antlr.TerminalNode + MEMOPTIMIZE(i int) antlr.TerminalNode + AllFOR() []antlr.TerminalNode + FOR(i int) antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + PARENT() antlr.TerminalNode + Tableview_name() ITableview_nameContext + GLOBAL() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + METADATA() antlr.TerminalNode + DATA() antlr.TerminalNode + NONE() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + + // 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 = PlSqlParserRULE_create_table + return p +} + +func InitEmptyCreate_tableContext(p *Create_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_table + + return p +} + +func (s *Create_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_tableContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Create_tableContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Create_tableContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Create_tableContext) Relational_table() IRelational_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_tableContext) +} + +func (s *Create_tableContext) Object_table() IObject_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_tableContext) +} + +func (s *Create_tableContext) Xmltype_table() IXmltype_tableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_tableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_tableContext) +} + +func (s *Create_tableContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Create_tableContext) SHARDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDED, 0) +} + +func (s *Create_tableContext) DUPLICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATED, 0) +} + +func (s *Create_tableContext) BLOCKCHAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKCHAIN, 0) +} + +func (s *Create_tableContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMUTABLE, 0) +} + +func (s *Create_tableContext) 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_tableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Create_tableContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Create_tableContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Create_tableContext) AllMEMOPTIMIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMEMOPTIMIZE) +} + +func (s *Create_tableContext) MEMOPTIMIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, i) +} + +func (s *Create_tableContext) AllFOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFOR) +} + +func (s *Create_tableContext) FOR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, i) +} + +func (s *Create_tableContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Create_tableContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Create_tableContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Create_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Create_tableContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Create_tableContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Create_tableContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Create_tableContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Create_tableContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Create_tableContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_table(s) + } +} + +func (s *Create_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_table(s) + } +} + +func (s *Create_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_table() (localctx ICreate_tableContext) { + localctx = NewCreate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1036, PlSqlParserRULE_create_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10301) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10311) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1203, p.GetParserRuleContext()) == 1 { + { + p.SetState(10302) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGLOBAL || _la == PlSqlParserPRIVATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10303) + p.Match(PlSqlParserTEMPORARY) + 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(), 1203, p.GetParserRuleContext()) == 2 { + { + p.SetState(10304) + p.Match(PlSqlParserSHARDED) + 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(), 1203, p.GetParserRuleContext()) == 3 { + { + p.SetState(10305) + p.Match(PlSqlParserDUPLICATED) + 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(), 1203, p.GetParserRuleContext()) == 4 { + p.SetState(10307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIMMUTABLE { + { + p.SetState(10306) + p.Match(PlSqlParserIMMUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10309) + p.Match(PlSqlParserBLOCKCHAIN) + 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(), 1203, p.GetParserRuleContext()) == 5 { + { + p.SetState(10310) + p.Match(PlSqlParserIMMUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10313) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10317) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1204, p.GetParserRuleContext()) == 1 { + { + p.SetState(10314) + p.Schema_name() + } + { + p.SetState(10315) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10319) + p.Table_name() + } + p.SetState(10330) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARING { + { + p.SetState(10320) + p.Match(PlSqlParserSHARING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10321) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMETADATA: + { + p.SetState(10322) + p.Match(PlSqlParserMETADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATA, PlSqlParserEXTENDED: + p.SetState(10324) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTENDED { + { + p.SetState(10323) + p.Match(PlSqlParserEXTENDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10326) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(10327) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(10335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1208, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10332) + p.Relational_table() + } + + case 2: + { + p.SetState(10333) + p.Object_table() + } + + case 3: + { + p.SetState(10334) + p.Xmltype_table() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10340) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1209, p.GetParserRuleContext()) == 1 { + { + p.SetState(10337) + p.Match(PlSqlParserMEMOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10338) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10339) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMOPTIMIZE { + { + p.SetState(10342) + p.Match(PlSqlParserMEMOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10343) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10344) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARENT { + { + p.SetState(10347) + p.Match(PlSqlParserPARENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10348) + p.Tableview_name() + } + + } + { + p.SetState(10351) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IXmltype_tableContext is an interface to support dynamic dispatch. +type IXmltype_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + AllXMLTYPE() []antlr.TerminalNode + XMLTYPE(i int) antlr.TerminalNode + Table_properties() ITable_propertiesContext + LEFT_PAREN() antlr.TerminalNode + Object_properties() IObject_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + Xmltype_storage() IXmltype_storageContext + Xmlschema_spec() IXmlschema_specContext + Xmltype_virtual_columns() IXmltype_virtual_columnsContext + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + ROWS() antlr.TerminalNode + Oid_clause() IOid_clauseContext + Oid_index_clause() IOid_index_clauseContext + Physical_properties() IPhysical_propertiesContext + DELETE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + + // IsXmltype_tableContext differentiates from other interfaces. + IsXmltype_tableContext() +} + +type Xmltype_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_tableContext() *Xmltype_tableContext { + var p = new(Xmltype_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_table + return p +} + +func InitEmptyXmltype_tableContext(p *Xmltype_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_table +} + +func (*Xmltype_tableContext) IsXmltype_tableContext() {} + +func NewXmltype_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_tableContext { + var p = new(Xmltype_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_table + + return p +} + +func (s *Xmltype_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_tableContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Xmltype_tableContext) AllXMLTYPE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserXMLTYPE) +} + +func (s *Xmltype_tableContext) XMLTYPE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, i) +} + +func (s *Xmltype_tableContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Xmltype_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_tableContext) 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 *Xmltype_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_tableContext) Xmltype_storage() IXmltype_storageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_storageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_storageContext) +} + +func (s *Xmltype_tableContext) Xmlschema_spec() IXmlschema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlschema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlschema_specContext) +} + +func (s *Xmltype_tableContext) Xmltype_virtual_columns() IXmltype_virtual_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_virtual_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_virtual_columnsContext) +} + +func (s *Xmltype_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Xmltype_tableContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Xmltype_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Xmltype_tableContext) Oid_clause() IOid_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_clauseContext) +} + +func (s *Xmltype_tableContext) Oid_index_clause() IOid_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_index_clauseContext) +} + +func (s *Xmltype_tableContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Xmltype_tableContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Xmltype_tableContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Xmltype_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_table(s) + } +} + +func (s *Xmltype_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_table(s) + } +} + +func (s *Xmltype_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltype_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltype_table() (localctx IXmltype_tableContext) { + localctx = NewXmltype_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1038, PlSqlParserRULE_xmltype_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10353) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10354) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10355) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10356) + p.Object_properties() + } + { + p.SetState(10357) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10363) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1213, p.GetParserRuleContext()) == 1 { + { + p.SetState(10361) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10362) + p.Xmltype_storage() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10365) + p.Xmlschema_spec() + } + + } + p.SetState(10369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVIRTUAL { + { + p.SetState(10368) + p.Xmltype_virtual_columns() + } + + } + p.SetState(10375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10371) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10372) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10373) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10374) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(10377) + p.Oid_clause() + } + + } + p.SetState(10381) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOIDINDEX { + { + p.SetState(10380) + p.Oid_index_clause() + } + + } + p.SetState(10384) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1219, p.GetParserRuleContext()) == 1 { + { + p.SetState(10383) + p.Physical_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10386) + p.Table_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 +} + +// IXmltype_virtual_columnsContext is an interface to support dynamic dispatch. +type IXmltype_virtual_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VIRTUAL() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXmltype_virtual_columnsContext differentiates from other interfaces. + IsXmltype_virtual_columnsContext() +} + +type Xmltype_virtual_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_virtual_columnsContext() *Xmltype_virtual_columnsContext { + var p = new(Xmltype_virtual_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns + return p +} + +func InitEmptyXmltype_virtual_columnsContext(p *Xmltype_virtual_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns +} + +func (*Xmltype_virtual_columnsContext) IsXmltype_virtual_columnsContext() {} + +func NewXmltype_virtual_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_virtual_columnsContext { + var p = new(Xmltype_virtual_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_virtual_columns + + return p +} + +func (s *Xmltype_virtual_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_virtual_columnsContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Xmltype_virtual_columnsContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Xmltype_virtual_columnsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Xmltype_virtual_columnsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Xmltype_virtual_columnsContext) 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 *Xmltype_virtual_columnsContext) 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 *Xmltype_virtual_columnsContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Xmltype_virtual_columnsContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Xmltype_virtual_columnsContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xmltype_virtual_columnsContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmltype_virtual_columnsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Xmltype_virtual_columnsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Xmltype_virtual_columnsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xmltype_virtual_columnsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xmltype_virtual_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_virtual_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_virtual_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_virtual_columns(s) + } +} + +func (s *Xmltype_virtual_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_virtual_columns(s) + } +} + +func (s *Xmltype_virtual_columnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltype_virtual_columns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltype_virtual_columns() (localctx IXmltype_virtual_columnsContext) { + localctx = NewXmltype_virtual_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1040, PlSqlParserRULE_xmltype_virtual_columns) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10388) + p.Match(PlSqlParserVIRTUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10389) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10390) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10391) + p.Column_name() + } + { + p.SetState(10392) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10393) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10394) + p.Expression() + } + { + p.SetState(10395) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10396) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10397) + p.Column_name() + } + { + p.SetState(10398) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10399) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10400) + p.Expression() + } + { + p.SetState(10401) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(10407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10408) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_column_propertiesContext is an interface to support dynamic dispatch. +type IXmltype_column_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLTYPE() antlr.TerminalNode + Column_name() IColumn_nameContext + COLUMN() antlr.TerminalNode + Xmltype_storage() IXmltype_storageContext + Xmlschema_spec() IXmlschema_specContext + + // IsXmltype_column_propertiesContext differentiates from other interfaces. + IsXmltype_column_propertiesContext() +} + +type Xmltype_column_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_column_propertiesContext() *Xmltype_column_propertiesContext { + var p = new(Xmltype_column_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties + return p +} + +func InitEmptyXmltype_column_propertiesContext(p *Xmltype_column_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties +} + +func (*Xmltype_column_propertiesContext) IsXmltype_column_propertiesContext() {} + +func NewXmltype_column_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_column_propertiesContext { + var p = new(Xmltype_column_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_column_properties + + return p +} + +func (s *Xmltype_column_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_column_propertiesContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Xmltype_column_propertiesContext) 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 *Xmltype_column_propertiesContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Xmltype_column_propertiesContext) Xmltype_storage() IXmltype_storageContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_storageContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_storageContext) +} + +func (s *Xmltype_column_propertiesContext) Xmlschema_spec() IXmlschema_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlschema_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlschema_specContext) +} + +func (s *Xmltype_column_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_column_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_column_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_column_properties(s) + } +} + +func (s *Xmltype_column_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_column_properties(s) + } +} + +func (s *Xmltype_column_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltype_column_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltype_column_properties() (localctx IXmltype_column_propertiesContext) { + localctx = NewXmltype_column_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1042, PlSqlParserRULE_xmltype_column_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10410) + p.Match(PlSqlParserXMLTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10412) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1221, p.GetParserRuleContext()) == 1 { + { + p.SetState(10411) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10414) + p.Column_name() + } + p.SetState(10416) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(10415) + p.Xmltype_storage() + } + + } + p.SetState(10419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10418) + p.Xmlschema_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmltype_storageContext is an interface to support dynamic dispatch. +type IXmltype_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + OBJECT() antlr.TerminalNode + RELATIONAL() antlr.TerminalNode + CLOB() antlr.TerminalNode + BINARY() antlr.TerminalNode + XML() antlr.TerminalNode + Lob_segname() ILob_segnameContext + LEFT_PAREN() antlr.TerminalNode + Lob_parameters() ILob_parametersContext + RIGHT_PAREN() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + LOBS() antlr.TerminalNode + TABLES() antlr.TerminalNode + + // IsXmltype_storageContext differentiates from other interfaces. + IsXmltype_storageContext() +} + +type Xmltype_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltype_storageContext() *Xmltype_storageContext { + var p = new(Xmltype_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_storage + return p +} + +func InitEmptyXmltype_storageContext(p *Xmltype_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltype_storage +} + +func (*Xmltype_storageContext) IsXmltype_storageContext() {} + +func NewXmltype_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmltype_storageContext { + var p = new(Xmltype_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltype_storage + + return p +} + +func (s *Xmltype_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmltype_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Xmltype_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xmltype_storageContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Xmltype_storageContext) RELATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELATIONAL, 0) +} + +func (s *Xmltype_storageContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Xmltype_storageContext) BINARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY, 0) +} + +func (s *Xmltype_storageContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Xmltype_storageContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Xmltype_storageContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xmltype_storageContext) Lob_parameters() ILob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_parametersContext) +} + +func (s *Xmltype_storageContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xmltype_storageContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Xmltype_storageContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Xmltype_storageContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Xmltype_storageContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Xmltype_storageContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Xmltype_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmltype_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmltype_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltype_storage(s) + } +} + +func (s *Xmltype_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltype_storage(s) + } +} + +func (s *Xmltype_storageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltype_storage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltype_storage() (localctx IXmltype_storageContext) { + localctx = NewXmltype_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1044, PlSqlParserRULE_xmltype_storage) + var _la int + + p.SetState(10452) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1229, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10421) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10422) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOBJECT: + { + p.SetState(10423) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10424) + p.Match(PlSqlParserRELATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBASICFILE, PlSqlParserBINARY, PlSqlParserCLOB, PlSqlParserSECUREFILE: + p.SetState(10426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(10425) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCLOB: + { + p.SetState(10428) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY: + { + p.SetState(10429) + p.Match(PlSqlParserBINARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10430) + p.Match(PlSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(10444) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1227, p.GetParserRuleContext()) == 1 { + { + p.SetState(10433) + p.Lob_segname() + } + p.SetState(10438) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1226, p.GetParserRuleContext()) == 1 { + { + p.SetState(10434) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10435) + p.Lob_parameters() + } + { + p.SetState(10436) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1227, p.GetParserRuleContext()) == 2 { + { + p.SetState(10440) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10441) + p.Lob_parameters() + } + { + p.SetState(10442) + p.Match(PlSqlParserRIGHT_PAREN) + 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 + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10448) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10449) + p.Match(PlSqlParserVARRAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10450) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10451) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOBS || _la == PlSqlParserTABLES) { + 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 +} + +// IXmlschema_specContext is an interface to support dynamic dispatch. +type IXmlschema_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELEMENT() antlr.TerminalNode + AllDELIMITED_ID() []antlr.TerminalNode + DELIMITED_ID(i int) antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + AllAllow_or_disallow() []IAllow_or_disallowContext + Allow_or_disallow(i int) IAllow_or_disallowContext + NONSCHEMA() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + + // IsXmlschema_specContext differentiates from other interfaces. + IsXmlschema_specContext() +} + +type Xmlschema_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlschema_specContext() *Xmlschema_specContext { + var p = new(Xmlschema_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlschema_spec + return p +} + +func InitEmptyXmlschema_specContext(p *Xmlschema_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlschema_spec +} + +func (*Xmlschema_specContext) IsXmlschema_specContext() {} + +func NewXmlschema_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlschema_specContext { + var p = new(Xmlschema_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlschema_spec + + return p +} + +func (s *Xmlschema_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlschema_specContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Xmlschema_specContext) AllDELIMITED_ID() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDELIMITED_ID) +} + +func (s *Xmlschema_specContext) DELIMITED_ID(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, i) +} + +func (s *Xmlschema_specContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Xmlschema_specContext) AllAllow_or_disallow() []IAllow_or_disallowContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + len++ + } + } + + tst := make([]IAllow_or_disallowContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllow_or_disallowContext); ok { + tst[i] = t.(IAllow_or_disallowContext) + i++ + } + } + + return tst +} + +func (s *Xmlschema_specContext) Allow_or_disallow(i int) IAllow_or_disallowContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Xmlschema_specContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Xmlschema_specContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Xmlschema_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlschema_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlschema_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlschema_spec(s) + } +} + +func (s *Xmlschema_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlschema_spec(s) + } +} + +func (s *Xmlschema_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlschema_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlschema_spec() (localctx IXmlschema_specContext) { + localctx = NewXmlschema_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1046, PlSqlParserRULE_xmlschema_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXMLSCHEMA { + { + p.SetState(10454) + p.Match(PlSqlParserXMLSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10455) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10458) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10459) + p.Match(PlSqlParserDELIMITED_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10463) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1231, p.GetParserRuleContext()) == 1 { + { + p.SetState(10460) + p.Allow_or_disallow() + } + { + p.SetState(10461) + p.Match(PlSqlParserNONSCHEMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(10465) + p.Allow_or_disallow() + } + { + p.SetState(10466) + p.Match(PlSqlParserANYSCHEMA) + 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 +} + +// IObject_tableContext is an interface to support dynamic dispatch. +type IObject_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + Object_type() IObject_typeContext + Table_properties() ITable_propertiesContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + Object_table_substitution() IObject_table_substitutionContext + LEFT_PAREN() antlr.TerminalNode + AllObject_properties() []IObject_propertiesContext + Object_properties(i int) IObject_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + ROWS() antlr.TerminalNode + Oid_clause() IOid_clauseContext + Oid_index_clause() IOid_index_clauseContext + Physical_properties() IPhysical_propertiesContext + DELETE() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsObject_tableContext differentiates from other interfaces. + IsObject_tableContext() +} + +type Object_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_tableContext() *Object_tableContext { + var p = new(Object_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table + return p +} + +func InitEmptyObject_tableContext(p *Object_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table +} + +func (*Object_tableContext) IsObject_tableContext() {} + +func NewObject_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_tableContext { + var p = new(Object_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_table + + return p +} + +func (s *Object_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_tableContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Object_tableContext) 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 *Object_tableContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Object_tableContext) 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 *Object_tableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Object_tableContext) Object_table_substitution() IObject_table_substitutionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_table_substitutionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IObject_table_substitutionContext) +} + +func (s *Object_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Object_tableContext) AllObject_properties() []IObject_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_propertiesContext); ok { + tst[i] = t.(IObject_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Object_tableContext) Object_properties(i int) IObject_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Object_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Object_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Object_tableContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Object_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Object_tableContext) Oid_clause() IOid_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_clauseContext) +} + +func (s *Object_tableContext) Oid_index_clause() IOid_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOid_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOid_index_clauseContext) +} + +func (s *Object_tableContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Object_tableContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_tableContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Object_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_table(s) + } +} + +func (s *Object_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_table(s) + } +} + +func (s *Object_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_table() (localctx IObject_tableContext) { + localctx = NewObject_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1048, PlSqlParserRULE_object_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10470) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10474) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1233, p.GetParserRuleContext()) == 1 { + { + p.SetState(10471) + p.Schema_name() + } + { + p.SetState(10472) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10476) + p.Object_type() + } + p.SetState(10478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(10477) + p.Object_table_substitution() + } + + } + p.SetState(10491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10480) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10481) + p.Object_properties() + } + p.SetState(10486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10482) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10483) + p.Object_properties() + } + + p.SetState(10488) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10489) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10497) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10493) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10494) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10495) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10496) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(10499) + p.Oid_clause() + } + + } + p.SetState(10503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOIDINDEX { + { + p.SetState(10502) + p.Oid_index_clause() + } + + } + p.SetState(10506) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1240, p.GetParserRuleContext()) == 1 { + { + p.SetState(10505) + p.Physical_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10508) + p.Table_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 +} + +// IObject_typeContext is an interface to support dynamic dispatch. +type IObject_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // 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 = PlSqlParserRULE_object_type + return p +} + +func InitEmptyObject_typeContext(p *Object_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_object_type + + return p +} + +func (s *Object_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_typeContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterObject_type(s) + } +} + +func (s *Object_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type(s) + } +} + +func (s *Object_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_type() (localctx IObject_typeContext) { + localctx = NewObject_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1050, PlSqlParserRULE_object_type) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10510) + p.Regular_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 +} + +// IOid_index_clauseContext is an interface to support dynamic dispatch. +type IOid_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OIDINDEX() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Index_name() IIndex_nameContext + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsOid_index_clauseContext differentiates from other interfaces. + IsOid_index_clauseContext() +} + +type Oid_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOid_index_clauseContext() *Oid_index_clauseContext { + var p = new(Oid_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_index_clause + return p +} + +func InitEmptyOid_index_clauseContext(p *Oid_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_index_clause +} + +func (*Oid_index_clauseContext) IsOid_index_clauseContext() {} + +func NewOid_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oid_index_clauseContext { + var p = new(Oid_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oid_index_clause + + return p +} + +func (s *Oid_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oid_index_clauseContext) OIDINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserOIDINDEX, 0) +} + +func (s *Oid_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Oid_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Oid_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Oid_index_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Oid_index_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Oid_index_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Oid_index_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Oid_index_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Oid_index_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Oid_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oid_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oid_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOid_index_clause(s) + } +} + +func (s *Oid_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOid_index_clause(s) + } +} + +func (s *Oid_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOid_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Oid_index_clause() (localctx IOid_index_clauseContext) { + localctx = NewOid_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1052, PlSqlParserRULE_oid_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10512) + p.Match(PlSqlParserOIDINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10514) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(10513) + p.Index_name() + } + + } + { + p.SetState(10516) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPUTE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(10520) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(10517) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(10518) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10519) + p.Tablespace() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(10522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10524) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOid_clauseContext is an interface to support dynamic dispatch. +type IOid_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OBJECT() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IS() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + GENERATED() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + + // IsOid_clauseContext differentiates from other interfaces. + IsOid_clauseContext() +} + +type Oid_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOid_clauseContext() *Oid_clauseContext { + var p = new(Oid_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_clause + return p +} + +func InitEmptyOid_clauseContext(p *Oid_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_oid_clause +} + +func (*Oid_clauseContext) IsOid_clauseContext() {} + +func NewOid_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Oid_clauseContext { + var p = new(Oid_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_oid_clause + + return p +} + +func (s *Oid_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Oid_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Oid_clauseContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Oid_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Oid_clauseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Oid_clauseContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Oid_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Oid_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Oid_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Oid_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Oid_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOid_clause(s) + } +} + +func (s *Oid_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOid_clause(s) + } +} + +func (s *Oid_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOid_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Oid_clause() (localctx IOid_clauseContext) { + localctx = NewOid_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1054, PlSqlParserRULE_oid_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10526) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10527) + p.Match(PlSqlParserIDENTIFIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10528) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSYSTEM: + { + p.SetState(10529) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10530) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(10531) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10532) + p.Match(PlSqlParserKEY) + 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_propertiesContext is an interface to support dynamic dispatch. +type IObject_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Attribute_name() IAttribute_nameContext + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + Inline_ref_constraint() IInline_ref_constraintContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Out_of_line_constraint() IOut_of_line_constraintContext + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + Supplemental_logging_props() ISupplemental_logging_propsContext + + // 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 = PlSqlParserRULE_object_properties + return p +} + +func InitEmptyObject_propertiesContext(p *Object_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_object_properties + + return p +} + +func (s *Object_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_propertiesContext) 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 *Object_propertiesContext) Attribute_name() IAttribute_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_nameContext) +} + +func (s *Object_propertiesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Object_propertiesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Object_propertiesContext) 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 *Object_propertiesContext) 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 *Object_propertiesContext) Inline_ref_constraint() IInline_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_ref_constraintContext) +} + +func (s *Object_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Object_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Object_propertiesContext) 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 *Object_propertiesContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Object_propertiesContext) Supplemental_logging_props() ISupplemental_logging_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_logging_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_logging_propsContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterObject_properties(s) + } +} + +func (s *Object_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_properties(s) + } +} + +func (s *Object_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_properties() (localctx IObject_propertiesContext) { + localctx = NewObject_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1056, PlSqlParserRULE_object_properties) + var _la int + + var _alt int + + p.SetState(10557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1249, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(10537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1245, p.GetParserRuleContext()) { + case 1: + { + p.SetState(10535) + p.Column_name() + } + + case 2: + { + p.SetState(10536) + p.Attribute_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(10541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(10539) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10540) + p.Expression() + } + + } + p.SetState(10552) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1248, p.GetParserRuleContext()) == 1 { + { + p.SetState(10543) + p.Inline_constraint() + } + p.SetState(10548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1247, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(10544) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10545) + p.Inline_constraint() + } + + } + p.SetState(10550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1247, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1248, p.GetParserRuleContext()) == 2 { + { + p.SetState(10551) + p.Inline_ref_constraint() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10554) + p.Out_of_line_constraint() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10555) + p.Out_of_line_ref_constraint() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10556) + p.Supplemental_logging_props() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_table_substitutionContext is an interface to support dynamic dispatch. +type IObject_table_substitutionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsObject_table_substitutionContext differentiates from other interfaces. + IsObject_table_substitutionContext() +} + +type Object_table_substitutionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyObject_table_substitutionContext() *Object_table_substitutionContext { + var p = new(Object_table_substitutionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table_substitution + return p +} + +func InitEmptyObject_table_substitutionContext(p *Object_table_substitutionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_table_substitution +} + +func (*Object_table_substitutionContext) IsObject_table_substitutionContext() {} + +func NewObject_table_substitutionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_table_substitutionContext { + var p = new(Object_table_substitutionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_table_substitution + + return p +} + +func (s *Object_table_substitutionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_table_substitutionContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Object_table_substitutionContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Object_table_substitutionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Object_table_substitutionContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Object_table_substitutionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Object_table_substitutionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_table_substitutionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_table_substitutionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_table_substitution(s) + } +} + +func (s *Object_table_substitutionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_table_substitution(s) + } +} + +func (s *Object_table_substitutionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_table_substitution(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_table_substitution() (localctx IObject_table_substitutionContext) { + localctx = NewObject_table_substitutionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1058, PlSqlParserRULE_object_table_substitution) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(10559) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10562) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10563) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10564) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10565) + p.Match(PlSqlParserLEVELS) + 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 +} + +// IRelational_tableContext is an interface to support dynamic dispatch. +type IRelational_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Immutable_table_clauses() IImmutable_table_clausesContext + Table_properties() ITable_propertiesContext + LEFT_PAREN() antlr.TerminalNode + AllRelational_property() []IRelational_propertyContext + Relational_property(i int) IRelational_propertyContext + RIGHT_PAREN() antlr.TerminalNode + Blockchain_table_clauses() IBlockchain_table_clausesContext + DEFAULT() antlr.TerminalNode + COLLATION() antlr.TerminalNode + Collation_name() ICollation_nameContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllCOMMIT() []antlr.TerminalNode + COMMIT(i int) antlr.TerminalNode + DEFINITION() antlr.TerminalNode + ROWS() antlr.TerminalNode + Physical_properties() IPhysical_propertiesContext + DROP() antlr.TerminalNode + AllPRESERVE() []antlr.TerminalNode + PRESERVE(i int) antlr.TerminalNode + DELETE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRelational_tableContext differentiates from other interfaces. + IsRelational_tableContext() +} + +type Relational_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_tableContext() *Relational_tableContext { + var p = new(Relational_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table + return p +} + +func InitEmptyRelational_tableContext(p *Relational_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_table +} + +func (*Relational_tableContext) IsRelational_tableContext() {} + +func NewRelational_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_tableContext { + var p = new(Relational_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_table + + return p +} + +func (s *Relational_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_tableContext) Immutable_table_clauses() IImmutable_table_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_clausesContext) +} + +func (s *Relational_tableContext) Table_properties() ITable_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_propertiesContext) +} + +func (s *Relational_tableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Relational_tableContext) AllRelational_property() []IRelational_propertyContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_propertyContext); ok { + len++ + } + } + + tst := make([]IRelational_propertyContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_propertyContext); ok { + tst[i] = t.(IRelational_propertyContext) + i++ + } + } + + return tst +} + +func (s *Relational_tableContext) Relational_property(i int) IRelational_propertyContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_propertyContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_propertyContext) +} + +func (s *Relational_tableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Relational_tableContext) Blockchain_table_clauses() IBlockchain_table_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_table_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_table_clausesContext) +} + +func (s *Relational_tableContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Relational_tableContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Relational_tableContext) Collation_name() ICollation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollation_nameContext) +} + +func (s *Relational_tableContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Relational_tableContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Relational_tableContext) AllCOMMIT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMIT) +} + +func (s *Relational_tableContext) COMMIT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, i) +} + +func (s *Relational_tableContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINITION, 0) +} + +func (s *Relational_tableContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Relational_tableContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Relational_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Relational_tableContext) AllPRESERVE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRESERVE) +} + +func (s *Relational_tableContext) PRESERVE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, i) +} + +func (s *Relational_tableContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Relational_tableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Relational_tableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Relational_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_table(s) + } +} + +func (s *Relational_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_table(s) + } +} + +func (s *Relational_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRelational_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Relational_table() (localctx IRelational_tableContext) { + localctx = NewRelational_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1060, PlSqlParserRULE_relational_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10578) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10567) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10568) + p.Relational_property() + } + p.SetState(10573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10569) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10570) + p.Relational_property() + } + + p.SetState(10575) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10576) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(10580) + p.Immutable_table_clauses() + } + p.SetState(10582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1253, p.GetParserRuleContext()) == 1 { + { + p.SetState(10581) + p.Blockchain_table_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10587) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(10584) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10585) + p.Match(PlSqlParserCOLLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10586) + p.Collation_name() + } + + } + p.SetState(10593) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1255, p.GetParserRuleContext()) == 1 { + { + p.SetState(10589) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10590) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10591) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10592) + p.Match(PlSqlParserDEFINITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(10595) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10596) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10597) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserPRESERVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(10598) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10602) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1257, p.GetParserRuleContext()) == 1 { + { + p.SetState(10601) + p.Physical_properties() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10604) + p.Table_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 +} + +// IImmutable_table_clausesContext is an interface to support dynamic dispatch. +type IImmutable_table_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Immutable_table_no_drop_clause() IImmutable_table_no_drop_clauseContext + Immutable_table_no_delete_clause() IImmutable_table_no_delete_clauseContext + + // IsImmutable_table_clausesContext differentiates from other interfaces. + IsImmutable_table_clausesContext() +} + +type Immutable_table_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_clausesContext() *Immutable_table_clausesContext { + var p = new(Immutable_table_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses + return p +} + +func InitEmptyImmutable_table_clausesContext(p *Immutable_table_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses +} + +func (*Immutable_table_clausesContext) IsImmutable_table_clausesContext() {} + +func NewImmutable_table_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_clausesContext { + var p = new(Immutable_table_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_clauses + + return p +} + +func (s *Immutable_table_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_clausesContext) Immutable_table_no_drop_clause() IImmutable_table_no_drop_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_no_drop_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_no_drop_clauseContext) +} + +func (s *Immutable_table_clausesContext) Immutable_table_no_delete_clause() IImmutable_table_no_delete_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IImmutable_table_no_delete_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IImmutable_table_no_delete_clauseContext) +} + +func (s *Immutable_table_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_clauses(s) + } +} + +func (s *Immutable_table_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_clauses(s) + } +} + +func (s *Immutable_table_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImmutable_table_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Immutable_table_clauses() (localctx IImmutable_table_clausesContext) { + localctx = NewImmutable_table_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1062, PlSqlParserRULE_immutable_table_clauses) + p.EnterOuterAlt(localctx, 1) + p.SetState(10607) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1258, p.GetParserRuleContext()) == 1 { + { + p.SetState(10606) + p.Immutable_table_no_drop_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10610) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1259, p.GetParserRuleContext()) == 1 { + { + p.SetState(10609) + p.Immutable_table_no_delete_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 +} + +// IImmutable_table_no_drop_clauseContext is an interface to support dynamic dispatch. +type IImmutable_table_no_drop_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DROP() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + IDLE() antlr.TerminalNode + + // IsImmutable_table_no_drop_clauseContext differentiates from other interfaces. + IsImmutable_table_no_drop_clauseContext() +} + +type Immutable_table_no_drop_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_no_drop_clauseContext() *Immutable_table_no_drop_clauseContext { + var p = new(Immutable_table_no_drop_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause + return p +} + +func InitEmptyImmutable_table_no_drop_clauseContext(p *Immutable_table_no_drop_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause +} + +func (*Immutable_table_no_drop_clauseContext) IsImmutable_table_no_drop_clauseContext() {} + +func NewImmutable_table_no_drop_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_no_drop_clauseContext { + var p = new(Immutable_table_no_drop_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_no_drop_clause + + return p +} + +func (s *Immutable_table_no_drop_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_no_drop_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Immutable_table_no_drop_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Immutable_table_no_drop_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_no_drop_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_no_drop_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_no_drop_clause(s) + } +} + +func (s *Immutable_table_no_drop_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_no_drop_clause(s) + } +} + +func (s *Immutable_table_no_drop_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImmutable_table_no_drop_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Immutable_table_no_drop_clause() (localctx IImmutable_table_no_drop_clauseContext) { + localctx = NewImmutable_table_no_drop_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1064, PlSqlParserRULE_immutable_table_no_drop_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10612) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10613) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(10614) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10615) + p.Numeric() + } + { + p.SetState(10616) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10617) + p.Match(PlSqlParserIDLE) + 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 +} + +// IImmutable_table_no_delete_clauseContext is an interface to support dynamic dispatch. +type IImmutable_table_no_delete_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DELETE() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCKED() antlr.TerminalNode + + // IsImmutable_table_no_delete_clauseContext differentiates from other interfaces. + IsImmutable_table_no_delete_clauseContext() +} + +type Immutable_table_no_delete_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImmutable_table_no_delete_clauseContext() *Immutable_table_no_delete_clauseContext { + var p = new(Immutable_table_no_delete_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause + return p +} + +func InitEmptyImmutable_table_no_delete_clauseContext(p *Immutable_table_no_delete_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause +} + +func (*Immutable_table_no_delete_clauseContext) IsImmutable_table_no_delete_clauseContext() {} + +func NewImmutable_table_no_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Immutable_table_no_delete_clauseContext { + var p = new(Immutable_table_no_delete_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_immutable_table_no_delete_clause + + return p +} + +func (s *Immutable_table_no_delete_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Immutable_table_no_delete_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Immutable_table_no_delete_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Immutable_table_no_delete_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Immutable_table_no_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Immutable_table_no_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImmutable_table_no_delete_clause(s) + } +} + +func (s *Immutable_table_no_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImmutable_table_no_delete_clause(s) + } +} + +func (s *Immutable_table_no_delete_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImmutable_table_no_delete_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Immutable_table_no_delete_clause() (localctx IImmutable_table_no_delete_clauseContext) { + localctx = NewImmutable_table_no_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1066, PlSqlParserRULE_immutable_table_no_delete_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10621) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10622) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCLUSTERING, PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDEFAULT, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFLASHBACK, PlSqlParserFOR, PlSqlParserINDEXING, PlSqlParserINITRANS, PlSqlParserLOB, PlSqlParserLOCKED, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNESTED, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNO, PlSqlParserNOPARALLEL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserON, PlSqlParserORGANIZATION, PlSqlParserPARALLEL, PlSqlParserPARENT, PlSqlParserPARTITION, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserREAD, PlSqlParserRESULT_CACHE, PlSqlParserROWDEPENDENCIES, PlSqlParserROW, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserVARRAY, PlSqlParserXMLTYPE, PlSqlParserMEMOPTIMIZE, PlSqlParserSEMICOLON: + p.SetState(10624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10623) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserUNTIL: + { + p.SetState(10626) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10627) + p.Numeric() + } + { + p.SetState(10628) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10629) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10630) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10631) + p.Match(PlSqlParserLOCKED) + 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 +} + +// IBlockchain_table_clausesContext is an interface to support dynamic dispatch. +type IBlockchain_table_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Blockchain_drop_table_clause() IBlockchain_drop_table_clauseContext + Blockchain_row_retention_clause() IBlockchain_row_retention_clauseContext + Blockchain_hash_and_data_format_clause() IBlockchain_hash_and_data_format_clauseContext + + // IsBlockchain_table_clausesContext differentiates from other interfaces. + IsBlockchain_table_clausesContext() +} + +type Blockchain_table_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_table_clausesContext() *Blockchain_table_clausesContext { + var p = new(Blockchain_table_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses + return p +} + +func InitEmptyBlockchain_table_clausesContext(p *Blockchain_table_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses +} + +func (*Blockchain_table_clausesContext) IsBlockchain_table_clausesContext() {} + +func NewBlockchain_table_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_table_clausesContext { + var p = new(Blockchain_table_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_table_clauses + + return p +} + +func (s *Blockchain_table_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_table_clausesContext) Blockchain_drop_table_clause() IBlockchain_drop_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_drop_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_drop_table_clauseContext) +} + +func (s *Blockchain_table_clausesContext) Blockchain_row_retention_clause() IBlockchain_row_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_row_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_row_retention_clauseContext) +} + +func (s *Blockchain_table_clausesContext) Blockchain_hash_and_data_format_clause() IBlockchain_hash_and_data_format_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockchain_hash_and_data_format_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockchain_hash_and_data_format_clauseContext) +} + +func (s *Blockchain_table_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_table_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_table_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_table_clauses(s) + } +} + +func (s *Blockchain_table_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_table_clauses(s) + } +} + +func (s *Blockchain_table_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBlockchain_table_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Blockchain_table_clauses() (localctx IBlockchain_table_clausesContext) { + localctx = NewBlockchain_table_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1068, PlSqlParserRULE_blockchain_table_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10636) + p.Blockchain_drop_table_clause() + } + { + p.SetState(10637) + p.Blockchain_row_retention_clause() + } + { + p.SetState(10638) + p.Blockchain_hash_and_data_format_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 +} + +// IBlockchain_drop_table_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_drop_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DROP() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + IDLE() antlr.TerminalNode + + // IsBlockchain_drop_table_clauseContext differentiates from other interfaces. + IsBlockchain_drop_table_clauseContext() +} + +type Blockchain_drop_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_drop_table_clauseContext() *Blockchain_drop_table_clauseContext { + var p = new(Blockchain_drop_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause + return p +} + +func InitEmptyBlockchain_drop_table_clauseContext(p *Blockchain_drop_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause +} + +func (*Blockchain_drop_table_clauseContext) IsBlockchain_drop_table_clauseContext() {} + +func NewBlockchain_drop_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_drop_table_clauseContext { + var p = new(Blockchain_drop_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_drop_table_clause + + return p +} + +func (s *Blockchain_drop_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_drop_table_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Blockchain_drop_table_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Blockchain_drop_table_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Blockchain_drop_table_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Blockchain_drop_table_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Blockchain_drop_table_clauseContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Blockchain_drop_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_drop_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_drop_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_drop_table_clause(s) + } +} + +func (s *Blockchain_drop_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_drop_table_clause(s) + } +} + +func (s *Blockchain_drop_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBlockchain_drop_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Blockchain_drop_table_clause() (localctx IBlockchain_drop_table_clauseContext) { + localctx = NewBlockchain_drop_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1070, PlSqlParserRULE_blockchain_drop_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10640) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10641) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(10642) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10643) + p.Numeric() + } + { + p.SetState(10644) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10645) + p.Match(PlSqlParserIDLE) + 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 +} + +// IBlockchain_row_retention_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_row_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + DELETE() antlr.TerminalNode + UNTIL() antlr.TerminalNode + Numeric() INumericContext + DAYS() antlr.TerminalNode + AFTER() antlr.TerminalNode + INSERT() antlr.TerminalNode + LOCKED() antlr.TerminalNode + + // IsBlockchain_row_retention_clauseContext differentiates from other interfaces. + IsBlockchain_row_retention_clauseContext() +} + +type Blockchain_row_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_row_retention_clauseContext() *Blockchain_row_retention_clauseContext { + var p = new(Blockchain_row_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause + return p +} + +func InitEmptyBlockchain_row_retention_clauseContext(p *Blockchain_row_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause +} + +func (*Blockchain_row_retention_clauseContext) IsBlockchain_row_retention_clauseContext() {} + +func NewBlockchain_row_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_row_retention_clauseContext { + var p = new(Blockchain_row_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_row_retention_clause + + return p +} + +func (s *Blockchain_row_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_row_retention_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Blockchain_row_retention_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Blockchain_row_retention_clauseContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Blockchain_row_retention_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Blockchain_row_retention_clauseContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Blockchain_row_retention_clauseContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Blockchain_row_retention_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Blockchain_row_retention_clauseContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Blockchain_row_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_row_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_row_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_row_retention_clause(s) + } +} + +func (s *Blockchain_row_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_row_retention_clause(s) + } +} + +func (s *Blockchain_row_retention_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBlockchain_row_retention_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Blockchain_row_retention_clause() (localctx IBlockchain_row_retention_clauseContext) { + localctx = NewBlockchain_row_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1072, PlSqlParserRULE_blockchain_row_retention_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10649) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10650) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOCKED, PlSqlParserHASHING: + p.SetState(10652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10651) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserUNTIL: + { + p.SetState(10654) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10655) + p.Numeric() + } + { + p.SetState(10656) + p.Match(PlSqlParserDAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10657) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10658) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10660) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCKED { + { + p.SetState(10659) + p.Match(PlSqlParserLOCKED) + 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 +} + +// IBlockchain_hash_and_data_format_clauseContext is an interface to support dynamic dispatch. +type IBlockchain_hash_and_data_format_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + HASHING() antlr.TerminalNode + USING() antlr.TerminalNode + SHA2_512_Q() antlr.TerminalNode + VERSION() antlr.TerminalNode + V1_Q() antlr.TerminalNode + + // IsBlockchain_hash_and_data_format_clauseContext differentiates from other interfaces. + IsBlockchain_hash_and_data_format_clauseContext() +} + +type Blockchain_hash_and_data_format_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockchain_hash_and_data_format_clauseContext() *Blockchain_hash_and_data_format_clauseContext { + var p = new(Blockchain_hash_and_data_format_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause + return p +} + +func InitEmptyBlockchain_hash_and_data_format_clauseContext(p *Blockchain_hash_and_data_format_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause +} + +func (*Blockchain_hash_and_data_format_clauseContext) IsBlockchain_hash_and_data_format_clauseContext() { +} + +func NewBlockchain_hash_and_data_format_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Blockchain_hash_and_data_format_clauseContext { + var p = new(Blockchain_hash_and_data_format_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_blockchain_hash_and_data_format_clause + + return p +} + +func (s *Blockchain_hash_and_data_format_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Blockchain_hash_and_data_format_clauseContext) HASHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHING, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) SHA2_512_Q() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHA2_512_Q, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) V1_Q() antlr.TerminalNode { + return s.GetToken(PlSqlParserV1_Q, 0) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Blockchain_hash_and_data_format_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Blockchain_hash_and_data_format_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlockchain_hash_and_data_format_clause(s) + } +} + +func (s *Blockchain_hash_and_data_format_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlockchain_hash_and_data_format_clause(s) + } +} + +func (s *Blockchain_hash_and_data_format_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBlockchain_hash_and_data_format_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Blockchain_hash_and_data_format_clause() (localctx IBlockchain_hash_and_data_format_clauseContext) { + localctx = NewBlockchain_hash_and_data_format_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1074, PlSqlParserRULE_blockchain_hash_and_data_format_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10664) + p.Match(PlSqlParserHASHING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10665) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10666) + p.Match(PlSqlParserSHA2_512_Q) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10667) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10668) + p.Match(PlSqlParserV1_Q) + 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 +} + +// ICollation_nameContext is an interface to support dynamic dispatch. +type ICollation_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsCollation_nameContext differentiates from other interfaces. + IsCollation_nameContext() +} + +type Collation_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollation_nameContext() *Collation_nameContext { + var p = new(Collation_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collation_name + return p +} + +func InitEmptyCollation_nameContext(p *Collation_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collation_name +} + +func (*Collation_nameContext) IsCollation_nameContext() {} + +func NewCollation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collation_nameContext { + var p = new(Collation_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collation_name + + return p +} + +func (s *Collation_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collation_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Collation_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collation_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollation_name(s) + } +} + +func (s *Collation_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollation_name(s) + } +} + +func (s *Collation_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCollation_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Collation_name() (localctx ICollation_nameContext) { + localctx = NewCollation_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1076, PlSqlParserRULE_collation_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10670) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_propertiesContext is an interface to support dynamic dispatch. +type ITable_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_properties() IColumn_propertiesContext + Read_only_clause() IRead_only_clauseContext + Indexing_clause() IIndexing_clauseContext + Table_partitioning_clauses() ITable_partitioning_clausesContext + Attribute_clustering_clause() IAttribute_clustering_clauseContext + Result_cache_clause() IResult_cache_clauseContext + Parallel_clause() IParallel_clauseContext + AllEnable_disable_clause() []IEnable_disable_clauseContext + Enable_disable_clause(i int) IEnable_disable_clauseContext + Row_movement_clause() IRow_movement_clauseContext + Logical_replication_clause() ILogical_replication_clauseContext + Flashback_archive_clause() IFlashback_archive_clauseContext + Physical_properties() IPhysical_propertiesContext + ROW() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + AS() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + FOR() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + WITH() antlr.TerminalNode + TABLE() antlr.TerminalNode + Table_name() ITable_nameContext + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + ROWDEPENDENCIES() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsTable_propertiesContext differentiates from other interfaces. + IsTable_propertiesContext() +} + +type Table_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_propertiesContext() *Table_propertiesContext { + var p = new(Table_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_properties + return p +} + +func InitEmptyTable_propertiesContext(p *Table_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_properties +} + +func (*Table_propertiesContext) IsTable_propertiesContext() {} + +func NewTable_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_propertiesContext { + var p = new(Table_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_properties + + return p +} + +func (s *Table_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_propertiesContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Table_propertiesContext) Read_only_clause() IRead_only_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRead_only_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRead_only_clauseContext) +} + +func (s *Table_propertiesContext) Indexing_clause() IIndexing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndexing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndexing_clauseContext) +} + +func (s *Table_propertiesContext) Table_partitioning_clauses() ITable_partitioning_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partitioning_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partitioning_clausesContext) +} + +func (s *Table_propertiesContext) Attribute_clustering_clause() IAttribute_clustering_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAttribute_clustering_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAttribute_clustering_clauseContext) +} + +func (s *Table_propertiesContext) Result_cache_clause() IResult_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResult_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResult_cache_clauseContext) +} + +func (s *Table_propertiesContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Table_propertiesContext) AllEnable_disable_clause() []IEnable_disable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + len++ + } + } + + tst := make([]IEnable_disable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_disable_clauseContext); ok { + tst[i] = t.(IEnable_disable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_propertiesContext) Enable_disable_clause(i int) IEnable_disable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_clauseContext) +} + +func (s *Table_propertiesContext) Row_movement_clause() IRow_movement_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRow_movement_clauseContext) +} + +func (s *Table_propertiesContext) Logical_replication_clause() ILogical_replication_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_replication_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogical_replication_clauseContext) +} + +func (s *Table_propertiesContext) Flashback_archive_clause() IFlashback_archive_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_clauseContext) +} + +func (s *Table_propertiesContext) Physical_properties() IPhysical_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Table_propertiesContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Table_propertiesContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Table_propertiesContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Table_propertiesContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Table_propertiesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Table_propertiesContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Table_propertiesContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Table_propertiesContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_propertiesContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Table_propertiesContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Table_propertiesContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Table_propertiesContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Table_propertiesContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Table_propertiesContext) 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 *Table_propertiesContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Table_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_properties(s) + } +} + +func (s *Table_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_properties(s) + } +} + +func (s *Table_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_properties() (localctx ITable_propertiesContext) { + localctx = NewTable_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1078, PlSqlParserRULE_table_properties) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserLOB || _la == PlSqlParserNESTED || _la == PlSqlParserVARRAY || _la == PlSqlParserXMLTYPE { + { + p.SetState(10672) + p.Column_properties() + } + + } + p.SetState(10676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREAD { + { + p.SetState(10675) + p.Read_only_clause() + } + + } + p.SetState(10679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXING { + { + p.SetState(10678) + p.Indexing_clause() + } + + } + p.SetState(10682) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(10681) + p.Table_partitioning_clauses() + } + + } + p.SetState(10685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLUSTERING { + { + p.SetState(10684) + p.Attribute_clustering_clause() + } + + } + p.SetState(10688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE { + { + p.SetState(10687) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRESULT_CACHE { + { + p.SetState(10690) + p.Result_cache_clause() + } + + } + p.SetState(10694) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(10693) + p.Parallel_clause() + } + + } + p.SetState(10697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES { + { + p.SetState(10696) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOROWDEPENDENCIES || _la == PlSqlParserROWDEPENDENCIES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(10702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1277, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(10699) + p.Enable_disable_clause() + } + + } + p.SetState(10704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1277, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(10706) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1278, p.GetParserRuleContext()) == 1 { + { + p.SetState(10705) + p.Row_movement_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(10708) + p.Logical_replication_clause() + } + + } + p.SetState(10712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFLASHBACK || _la == PlSqlParserNO { + { + p.SetState(10711) + p.Flashback_archive_clause() + } + + } + p.SetState(10715) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-206)) & ^0x3f) == 0 && ((int64(1)<<(_la-206))&206158430209) != 0) || _la == PlSqlParserEXTERNAL || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&5188146770730811393) != 0) || _la == PlSqlParserSEGMENT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(10714) + p.Physical_properties() + } + + } + p.SetState(10719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserROW { + { + p.SetState(10717) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10718) + p.Match(PlSqlParserARCHIVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(10733) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserAS: + { + p.SetState(10721) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10722) + p.Select_only_statement() + } + + case PlSqlParserFOR: + { + p.SetState(10723) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10724) + p.Match(PlSqlParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10725) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10726) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10730) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1283, p.GetParserRuleContext()) == 1 { + { + p.SetState(10727) + p.Schema_name() + } + { + p.SetState(10728) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10732) + p.Table_name() + } + + case PlSqlParserPARENT, PlSqlParserMEMOPTIMIZE, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRead_only_clauseContext is an interface to support dynamic dispatch. +type IRead_only_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + + // IsRead_only_clauseContext differentiates from other interfaces. + IsRead_only_clauseContext() +} + +type Read_only_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRead_only_clauseContext() *Read_only_clauseContext { + var p = new(Read_only_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_read_only_clause + return p +} + +func InitEmptyRead_only_clauseContext(p *Read_only_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_read_only_clause +} + +func (*Read_only_clauseContext) IsRead_only_clauseContext() {} + +func NewRead_only_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Read_only_clauseContext { + var p = new(Read_only_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_read_only_clause + + return p +} + +func (s *Read_only_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Read_only_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Read_only_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Read_only_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Read_only_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Read_only_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Read_only_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRead_only_clause(s) + } +} + +func (s *Read_only_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRead_only_clause(s) + } +} + +func (s *Read_only_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRead_only_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Read_only_clause() (localctx IRead_only_clauseContext) { + localctx = NewRead_only_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1080, PlSqlParserRULE_read_only_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10735) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10736) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + 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 +} + +// IIndexing_clauseContext is an interface to support dynamic dispatch. +type IIndexing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INDEXING() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsIndexing_clauseContext differentiates from other interfaces. + IsIndexing_clauseContext() +} + +type Indexing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndexing_clauseContext() *Indexing_clauseContext { + var p = new(Indexing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indexing_clause + return p +} + +func InitEmptyIndexing_clauseContext(p *Indexing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_indexing_clause +} + +func (*Indexing_clauseContext) IsIndexing_clauseContext() {} + +func NewIndexing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Indexing_clauseContext { + var p = new(Indexing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_indexing_clause + + return p +} + +func (s *Indexing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Indexing_clauseContext) INDEXING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXING, 0) +} + +func (s *Indexing_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Indexing_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Indexing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Indexing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Indexing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndexing_clause(s) + } +} + +func (s *Indexing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndexing_clause(s) + } +} + +func (s *Indexing_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndexing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Indexing_clause() (localctx IIndexing_clauseContext) { + localctx = NewIndexing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1082, PlSqlParserRULE_indexing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10738) + p.Match(PlSqlParserINDEXING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10739) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + 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 +} + +// IAttribute_clustering_clauseContext is an interface to support dynamic dispatch. +type IAttribute_clustering_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLUSTERING() antlr.TerminalNode + Cluster_clause() ICluster_clauseContext + Clustering_join() IClustering_joinContext + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + LOAD() antlr.TerminalNode + DATA() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + Zonemap_clause() IZonemap_clauseContext + AllYes_no() []IYes_noContext + Yes_no(i int) IYes_noContext + + // IsAttribute_clustering_clauseContext differentiates from other interfaces. + IsAttribute_clustering_clauseContext() +} + +type Attribute_clustering_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_clustering_clauseContext() *Attribute_clustering_clauseContext { + var p = new(Attribute_clustering_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause + return p +} + +func InitEmptyAttribute_clustering_clauseContext(p *Attribute_clustering_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause +} + +func (*Attribute_clustering_clauseContext) IsAttribute_clustering_clauseContext() {} + +func NewAttribute_clustering_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_clustering_clauseContext { + var p = new(Attribute_clustering_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_clustering_clause + + return p +} + +func (s *Attribute_clustering_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_clustering_clauseContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Attribute_clustering_clauseContext) Cluster_clause() ICluster_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_clauseContext) +} + +func (s *Attribute_clustering_clauseContext) Clustering_join() IClustering_joinContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_joinContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClustering_joinContext) +} + +func (s *Attribute_clustering_clauseContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Attribute_clustering_clauseContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Attribute_clustering_clauseContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Attribute_clustering_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Attribute_clustering_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Attribute_clustering_clauseContext) Zonemap_clause() IZonemap_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_clauseContext) +} + +func (s *Attribute_clustering_clauseContext) AllYes_no() []IYes_noContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IYes_noContext); ok { + len++ + } + } + + tst := make([]IYes_noContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IYes_noContext); ok { + tst[i] = t.(IYes_noContext) + i++ + } + } + + return tst +} + +func (s *Attribute_clustering_clauseContext) Yes_no(i int) IYes_noContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IYes_noContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IYes_noContext) +} + +func (s *Attribute_clustering_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_clustering_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_clustering_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_clustering_clause(s) + } +} + +func (s *Attribute_clustering_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_clustering_clause(s) + } +} + +func (s *Attribute_clustering_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAttribute_clustering_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Attribute_clustering_clause() (localctx IAttribute_clustering_clauseContext) { + localctx = NewAttribute_clustering_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1084, PlSqlParserRULE_attribute_clustering_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10741) + p.Match(PlSqlParserCLUSTERING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279172874257) != 0) { + { + p.SetState(10742) + p.Clustering_join() + } + + } + { + p.SetState(10745) + p.Cluster_clause() + } + p.SetState(10751) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1287, p.GetParserRuleContext()) == 1 { + p.SetState(10747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserYES { + { + p.SetState(10746) + p.Yes_no() + } + + } + { + p.SetState(10749) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10750) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10759) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1289, p.GetParserRuleContext()) == 1 { + p.SetState(10754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserYES { + { + p.SetState(10753) + p.Yes_no() + } + + } + { + p.SetState(10756) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10757) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10758) + p.Match(PlSqlParserMOVEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(10761) + p.Zonemap_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 +} + +// IClustering_joinContext is an interface to support dynamic dispatch. +type IClustering_joinContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_name() ITable_nameContext + AllClustering_join_item() []IClustering_join_itemContext + Clustering_join_item(i int) IClustering_join_itemContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_joinContext differentiates from other interfaces. + IsClustering_joinContext() +} + +type Clustering_joinContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_joinContext() *Clustering_joinContext { + var p = new(Clustering_joinContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join + return p +} + +func InitEmptyClustering_joinContext(p *Clustering_joinContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join +} + +func (*Clustering_joinContext) IsClustering_joinContext() {} + +func NewClustering_joinContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_joinContext { + var p = new(Clustering_joinContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_join + + return p +} + +func (s *Clustering_joinContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_joinContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Clustering_joinContext) AllClustering_join_item() []IClustering_join_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClustering_join_itemContext); ok { + len++ + } + } + + tst := make([]IClustering_join_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClustering_join_itemContext); ok { + tst[i] = t.(IClustering_join_itemContext) + i++ + } + } + + return tst +} + +func (s *Clustering_joinContext) Clustering_join_item(i int) IClustering_join_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_join_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClustering_join_itemContext) +} + +func (s *Clustering_joinContext) 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 *Clustering_joinContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Clustering_joinContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_joinContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_joinContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_joinContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_joinContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_join(s) + } +} + +func (s *Clustering_joinContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_join(s) + } +} + +func (s *Clustering_joinContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClustering_join(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Clustering_join() (localctx IClustering_joinContext) { + localctx = NewClustering_joinContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1086, PlSqlParserRULE_clustering_join) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(10767) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1291, p.GetParserRuleContext()) == 1 { + { + p.SetState(10764) + p.Schema_name() + } + { + p.SetState(10765) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10769) + p.Table_name() + } + { + p.SetState(10770) + p.Clustering_join_item() + } + p.SetState(10775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10771) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10772) + p.Clustering_join_item() + } + + p.SetState(10777) + 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 +} + +// IClustering_join_itemContext is an interface to support dynamic dispatch. +type IClustering_join_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JOIN() antlr.TerminalNode + Table_name() ITable_nameContext + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Equijoin_condition() IEquijoin_conditionContext + RIGHT_PAREN() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsClustering_join_itemContext differentiates from other interfaces. + IsClustering_join_itemContext() +} + +type Clustering_join_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_join_itemContext() *Clustering_join_itemContext { + var p = new(Clustering_join_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join_item + return p +} + +func InitEmptyClustering_join_itemContext(p *Clustering_join_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_join_item +} + +func (*Clustering_join_itemContext) IsClustering_join_itemContext() {} + +func NewClustering_join_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_join_itemContext { + var p = new(Clustering_join_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_join_item + + return p +} + +func (s *Clustering_join_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_join_itemContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Clustering_join_itemContext) Table_name() ITable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_nameContext) +} + +func (s *Clustering_join_itemContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Clustering_join_itemContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_join_itemContext) Equijoin_condition() IEquijoin_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEquijoin_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEquijoin_conditionContext) +} + +func (s *Clustering_join_itemContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_join_itemContext) 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 *Clustering_join_itemContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Clustering_join_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_join_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_join_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_join_item(s) + } +} + +func (s *Clustering_join_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_join_item(s) + } +} + +func (s *Clustering_join_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClustering_join_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Clustering_join_item() (localctx IClustering_join_itemContext) { + localctx = NewClustering_join_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1088, PlSqlParserRULE_clustering_join_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10778) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10782) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1293, p.GetParserRuleContext()) == 1 { + { + p.SetState(10779) + p.Schema_name() + } + { + p.SetState(10780) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(10784) + p.Table_name() + } + { + p.SetState(10785) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10786) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10787) + p.Equijoin_condition() + } + { + p.SetState(10788) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEquijoin_conditionContext is an interface to support dynamic dispatch. +type IEquijoin_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + + // IsEquijoin_conditionContext differentiates from other interfaces. + IsEquijoin_conditionContext() +} + +type Equijoin_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEquijoin_conditionContext() *Equijoin_conditionContext { + var p = new(Equijoin_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_equijoin_condition + return p +} + +func InitEmptyEquijoin_conditionContext(p *Equijoin_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_equijoin_condition +} + +func (*Equijoin_conditionContext) IsEquijoin_conditionContext() {} + +func NewEquijoin_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Equijoin_conditionContext { + var p = new(Equijoin_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_equijoin_condition + + return p +} + +func (s *Equijoin_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Equijoin_conditionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Equijoin_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Equijoin_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Equijoin_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEquijoin_condition(s) + } +} + +func (s *Equijoin_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEquijoin_condition(s) + } +} + +func (s *Equijoin_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEquijoin_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Equijoin_condition() (localctx IEquijoin_conditionContext) { + localctx = NewEquijoin_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1090, PlSqlParserRULE_equijoin_condition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10790) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICluster_clauseContext is an interface to support dynamic dispatch. +type ICluster_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BY() antlr.TerminalNode + ORDER() antlr.TerminalNode + Clustering_columns() IClustering_columnsContext + LINEAR() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + + // IsCluster_clauseContext differentiates from other interfaces. + IsCluster_clauseContext() +} + +type Cluster_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCluster_clauseContext() *Cluster_clauseContext { + var p = new(Cluster_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_clause + return p +} + +func InitEmptyCluster_clauseContext(p *Cluster_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cluster_clause +} + +func (*Cluster_clauseContext) IsCluster_clauseContext() {} + +func NewCluster_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cluster_clauseContext { + var p = new(Cluster_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cluster_clause + + return p +} + +func (s *Cluster_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cluster_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Cluster_clauseContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Cluster_clauseContext) Clustering_columns() IClustering_columnsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_columnsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClustering_columnsContext) +} + +func (s *Cluster_clauseContext) LINEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINEAR, 0) +} + +func (s *Cluster_clauseContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERLEAVED, 0) +} + +func (s *Cluster_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cluster_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cluster_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCluster_clause(s) + } +} + +func (s *Cluster_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCluster_clause(s) + } +} + +func (s *Cluster_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCluster_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cluster_clause() (localctx ICluster_clauseContext) { + localctx = NewCluster_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1092, PlSqlParserRULE_cluster_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10792) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERLEAVED || _la == PlSqlParserLINEAR { + { + p.SetState(10793) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINTERLEAVED || _la == PlSqlParserLINEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(10796) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10797) + p.Clustering_columns() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_columnsContext is an interface to support dynamic dispatch. +type IClustering_columnsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllClustering_column_group() []IClustering_column_groupContext + Clustering_column_group(i int) IClustering_column_groupContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_columnsContext differentiates from other interfaces. + IsClustering_columnsContext() +} + +type Clustering_columnsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_columnsContext() *Clustering_columnsContext { + var p = new(Clustering_columnsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_columns + return p +} + +func InitEmptyClustering_columnsContext(p *Clustering_columnsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_columns +} + +func (*Clustering_columnsContext) IsClustering_columnsContext() {} + +func NewClustering_columnsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_columnsContext { + var p = new(Clustering_columnsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_columns + + return p +} + +func (s *Clustering_columnsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_columnsContext) AllClustering_column_group() []IClustering_column_groupContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IClustering_column_groupContext); ok { + len++ + } + } + + tst := make([]IClustering_column_groupContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IClustering_column_groupContext); ok { + tst[i] = t.(IClustering_column_groupContext) + i++ + } + } + + return tst +} + +func (s *Clustering_columnsContext) Clustering_column_group(i int) IClustering_column_groupContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClustering_column_groupContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IClustering_column_groupContext) +} + +func (s *Clustering_columnsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_columnsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_columnsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_columnsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_columnsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_columnsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_columnsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_columns(s) + } +} + +func (s *Clustering_columnsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_columns(s) + } +} + +func (s *Clustering_columnsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClustering_columns(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Clustering_columns() (localctx IClustering_columnsContext) { + localctx = NewClustering_columnsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1094, PlSqlParserRULE_clustering_columns) + var _la int + + p.SetState(10811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1296, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10799) + p.Clustering_column_group() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10800) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10801) + p.Clustering_column_group() + } + p.SetState(10806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10802) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10803) + p.Clustering_column_group() + } + + p.SetState(10808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10809) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IClustering_column_groupContext is an interface to support dynamic dispatch. +type IClustering_column_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsClustering_column_groupContext differentiates from other interfaces. + IsClustering_column_groupContext() +} + +type Clustering_column_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClustering_column_groupContext() *Clustering_column_groupContext { + var p = new(Clustering_column_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_column_group + return p +} + +func InitEmptyClustering_column_groupContext(p *Clustering_column_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_clustering_column_group +} + +func (*Clustering_column_groupContext) IsClustering_column_groupContext() {} + +func NewClustering_column_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Clustering_column_groupContext { + var p = new(Clustering_column_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_clustering_column_group + + return p +} + +func (s *Clustering_column_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Clustering_column_groupContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Clustering_column_groupContext) 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 *Clustering_column_groupContext) 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 *Clustering_column_groupContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Clustering_column_groupContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Clustering_column_groupContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Clustering_column_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Clustering_column_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Clustering_column_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClustering_column_group(s) + } +} + +func (s *Clustering_column_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClustering_column_group(s) + } +} + +func (s *Clustering_column_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClustering_column_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Clustering_column_group() (localctx IClustering_column_groupContext) { + localctx = NewClustering_column_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1096, PlSqlParserRULE_clustering_column_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10813) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10814) + p.Column_name() + } + p.SetState(10819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10815) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10816) + p.Column_name() + } + + p.SetState(10821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10822) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IYes_noContext is an interface to support dynamic dispatch. +type IYes_noContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + YES() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsYes_noContext differentiates from other interfaces. + IsYes_noContext() +} + +type Yes_noContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyYes_noContext() *Yes_noContext { + var p = new(Yes_noContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_yes_no + return p +} + +func InitEmptyYes_noContext(p *Yes_noContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_yes_no +} + +func (*Yes_noContext) IsYes_noContext() {} + +func NewYes_noContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Yes_noContext { + var p = new(Yes_noContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_yes_no + + return p +} + +func (s *Yes_noContext) GetParser() antlr.Parser { return s.parser } + +func (s *Yes_noContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Yes_noContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Yes_noContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Yes_noContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Yes_noContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterYes_no(s) + } +} + +func (s *Yes_noContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitYes_no(s) + } +} + +func (s *Yes_noContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitYes_no(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Yes_no() (localctx IYes_noContext) { + localctx = NewYes_noContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1098, PlSqlParserRULE_yes_no) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10824) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNO || _la == PlSqlParserYES) { + 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 +} + +// IZonemap_clauseContext is an interface to support dynamic dispatch. +type IZonemap_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Zonemap_name() IZonemap_nameContext + RIGHT_PAREN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsZonemap_clauseContext differentiates from other interfaces. + IsZonemap_clauseContext() +} + +type Zonemap_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyZonemap_clauseContext() *Zonemap_clauseContext { + var p = new(Zonemap_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_clause + return p +} + +func InitEmptyZonemap_clauseContext(p *Zonemap_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_zonemap_clause +} + +func (*Zonemap_clauseContext) IsZonemap_clauseContext() {} + +func NewZonemap_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Zonemap_clauseContext { + var p = new(Zonemap_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_zonemap_clause + + return p +} + +func (s *Zonemap_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Zonemap_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Zonemap_clauseContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Zonemap_clauseContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Zonemap_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Zonemap_clauseContext) Zonemap_name() IZonemap_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IZonemap_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IZonemap_nameContext) +} + +func (s *Zonemap_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Zonemap_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Zonemap_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Zonemap_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Zonemap_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterZonemap_clause(s) + } +} + +func (s *Zonemap_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitZonemap_clause(s) + } +} + +func (s *Zonemap_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitZonemap_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Zonemap_clause() (localctx IZonemap_clauseContext) { + localctx = NewZonemap_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1100, PlSqlParserRULE_zonemap_clause) + var _la int + + p.SetState(10838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10826) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10827) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10828) + p.Match(PlSqlParserZONEMAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(10829) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10830) + p.Zonemap_name() + } + { + p.SetState(10831) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserWITHOUT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10835) + p.Match(PlSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10836) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10837) + p.Match(PlSqlParserZONEMAP) + 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 +} + +// ILogical_replication_clauseContext is an interface to support dynamic dispatch. +type ILogical_replication_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISABLE() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + ENABLE() antlr.TerminalNode + KEYS() antlr.TerminalNode + ALL() antlr.TerminalNode + ALLOW() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + + // IsLogical_replication_clauseContext differentiates from other interfaces. + IsLogical_replication_clauseContext() +} + +type Logical_replication_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_replication_clauseContext() *Logical_replication_clauseContext { + var p = new(Logical_replication_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_replication_clause + return p +} + +func InitEmptyLogical_replication_clauseContext(p *Logical_replication_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_replication_clause +} + +func (*Logical_replication_clauseContext) IsLogical_replication_clauseContext() {} + +func NewLogical_replication_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_replication_clauseContext { + var p = new(Logical_replication_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_replication_clause + + return p +} + +func (s *Logical_replication_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_replication_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Logical_replication_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Logical_replication_clauseContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Logical_replication_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Logical_replication_clauseContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Logical_replication_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Logical_replication_clauseContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Logical_replication_clauseContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Logical_replication_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_replication_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_replication_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_replication_clause(s) + } +} + +func (s *Logical_replication_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_replication_clause(s) + } +} + +func (s *Logical_replication_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogical_replication_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logical_replication_clause() (localctx ILogical_replication_clauseContext) { + localctx = NewLogical_replication_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1102, PlSqlParserRULE_logical_replication_clause) + var _la int + + p.SetState(10854) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10840) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10841) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10842) + p.Match(PlSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENABLE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10843) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10844) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10845) + p.Match(PlSqlParserREPLICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10852) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL || _la == PlSqlParserALLOW { + p.SetState(10849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(10846) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOW: + { + p.SetState(10847) + p.Match(PlSqlParserALLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10848) + p.Match(PlSqlParserNOVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(10851) + p.Match(PlSqlParserKEYS) + 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_nameContext is an interface to support dynamic dispatch. +type ITable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsTable_nameContext differentiates from other interfaces. + IsTable_nameContext() +} + +type Table_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_nameContext() *Table_nameContext { + var p = new(Table_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_name + return p +} + +func InitEmptyTable_nameContext(p *Table_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_name +} + +func (*Table_nameContext) IsTable_nameContext() {} + +func NewTable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_nameContext { + var p = new(Table_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_name + + return p +} + +func (s *Table_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_name(s) + } +} + +func (s *Table_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_name(s) + } +} + +func (s *Table_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_name() (localctx ITable_nameContext) { + localctx = NewTable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1104, PlSqlParserRULE_table_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10856) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_propertyContext is an interface to support dynamic dispatch. +type IRelational_propertyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_definition() IColumn_definitionContext + Virtual_column_definition() IVirtual_column_definitionContext + Period_definition() IPeriod_definitionContext + Out_of_line_constraint() IOut_of_line_constraintContext + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + Supplemental_logging_props() ISupplemental_logging_propsContext + + // IsRelational_propertyContext differentiates from other interfaces. + IsRelational_propertyContext() +} + +type Relational_propertyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_propertyContext() *Relational_propertyContext { + var p = new(Relational_propertyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_property + return p +} + +func InitEmptyRelational_propertyContext(p *Relational_propertyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_property +} + +func (*Relational_propertyContext) IsRelational_propertyContext() {} + +func NewRelational_propertyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_propertyContext { + var p = new(Relational_propertyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_property + + return p +} + +func (s *Relational_propertyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_propertyContext) Column_definition() IColumn_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Relational_propertyContext) Virtual_column_definition() IVirtual_column_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVirtual_column_definitionContext) +} + +func (s *Relational_propertyContext) Period_definition() IPeriod_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPeriod_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPeriod_definitionContext) +} + +func (s *Relational_propertyContext) 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 *Relational_propertyContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Relational_propertyContext) Supplemental_logging_props() ISupplemental_logging_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_logging_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_logging_propsContext) +} + +func (s *Relational_propertyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_propertyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_propertyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_property(s) + } +} + +func (s *Relational_propertyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_property(s) + } +} + +func (s *Relational_propertyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRelational_property(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Relational_property() (localctx IRelational_propertyContext) { + localctx = NewRelational_propertyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1106, PlSqlParserRULE_relational_property) + p.SetState(10864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1303, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10858) + p.Column_definition() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10859) + p.Virtual_column_definition() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10860) + p.Period_definition() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10861) + p.Out_of_line_constraint() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10862) + p.Out_of_line_ref_constraint() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10863) + p.Supplemental_logging_props() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_partitioning_clausesContext is an interface to support dynamic dispatch. +type ITable_partitioning_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Range_partitions() IRange_partitionsContext + List_partitions() IList_partitionsContext + Hash_partitions() IHash_partitionsContext + Composite_range_partitions() IComposite_range_partitionsContext + Composite_list_partitions() IComposite_list_partitionsContext + Composite_hash_partitions() IComposite_hash_partitionsContext + Reference_partitioning() IReference_partitioningContext + System_partitioning() ISystem_partitioningContext + + // IsTable_partitioning_clausesContext differentiates from other interfaces. + IsTable_partitioning_clausesContext() +} + +type Table_partitioning_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_partitioning_clausesContext() *Table_partitioning_clausesContext { + var p = new(Table_partitioning_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses + return p +} + +func InitEmptyTable_partitioning_clausesContext(p *Table_partitioning_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses +} + +func (*Table_partitioning_clausesContext) IsTable_partitioning_clausesContext() {} + +func NewTable_partitioning_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_partitioning_clausesContext { + var p = new(Table_partitioning_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_partitioning_clauses + + return p +} + +func (s *Table_partitioning_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_partitioning_clausesContext) Range_partitions() IRange_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) List_partitions() IList_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Hash_partitions() IHash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_range_partitions() IComposite_range_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_range_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_range_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_list_partitions() IComposite_list_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_list_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_list_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Composite_hash_partitions() IComposite_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IComposite_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IComposite_hash_partitionsContext) +} + +func (s *Table_partitioning_clausesContext) Reference_partitioning() IReference_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReference_partitioningContext) +} + +func (s *Table_partitioning_clausesContext) System_partitioning() ISystem_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISystem_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISystem_partitioningContext) +} + +func (s *Table_partitioning_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_partitioning_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_partitioning_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_partitioning_clauses(s) + } +} + +func (s *Table_partitioning_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_partitioning_clauses(s) + } +} + +func (s *Table_partitioning_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_partitioning_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_partitioning_clauses() (localctx ITable_partitioning_clausesContext) { + localctx = NewTable_partitioning_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1108, PlSqlParserRULE_table_partitioning_clauses) + p.SetState(10874) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1304, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10866) + p.Range_partitions() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(10867) + p.List_partitions() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(10868) + p.Hash_partitions() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(10869) + p.Composite_range_partitions() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(10870) + p.Composite_list_partitions() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(10871) + p.Composite_hash_partitions() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(10872) + p.Reference_partitioning() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(10873) + p.System_partitioning() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_partitionsContext is an interface to support dynamic dispatch. +type IRange_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllRange_values_clause() []IRange_values_clauseContext + Range_values_clause(i int) IRange_values_clauseContext + AllTable_partition_description() []ITable_partition_descriptionContext + Table_partition_description(i int) ITable_partition_descriptionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTERVAL() antlr.TerminalNode + Expression() IExpressionContext + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsRange_partitionsContext differentiates from other interfaces. + IsRange_partitionsContext() +} + +type Range_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_partitionsContext() *Range_partitionsContext { + var p = new(Range_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partitions + return p +} + +func InitEmptyRange_partitionsContext(p *Range_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partitions +} + +func (*Range_partitionsContext) IsRange_partitionsContext() {} + +func NewRange_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_partitionsContext { + var p = new(Range_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_partitions + + return p +} + +func (s *Range_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Range_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Range_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Range_partitionsContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Range_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Range_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Range_partitionsContext) 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 *Range_partitionsContext) 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 *Range_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Range_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Range_partitionsContext) AllRange_values_clause() []IRange_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_values_clauseContext); ok { + len++ + } + } + + tst := make([]IRange_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_values_clauseContext); ok { + tst[i] = t.(IRange_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Range_values_clause(i int) IRange_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_partitionsContext) AllTable_partition_description() []ITable_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]ITable_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_partition_descriptionContext); ok { + tst[i] = t.(ITable_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Table_partition_description(i int) ITable_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Range_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_partitionsContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Range_partitionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Range_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Range_partitionsContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Range_partitionsContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Range_partitionsContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Range_partitionsContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Range_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_partitions(s) + } +} + +func (s *Range_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_partitions(s) + } +} + +func (s *Range_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRange_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Range_partitions() (localctx IRange_partitionsContext) { + localctx = NewRange_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1110, PlSqlParserRULE_range_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10876) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10877) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10878) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10879) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10880) + p.Column_name() + } + p.SetState(10885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10881) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10882) + p.Column_name() + } + + p.SetState(10887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10888) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERVAL { + { + p.SetState(10889) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10890) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10891) + p.Expression() + } + { + p.SetState(10892) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(10893) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10894) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10895) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10896) + p.Tablespace() + } + p.SetState(10901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10897) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10898) + p.Tablespace() + } + + p.SetState(10903) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10904) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + { + p.SetState(10910) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10911) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10913) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(10912) + p.Partition_name() + } + + } + { + p.SetState(10915) + p.Range_values_clause() + } + { + p.SetState(10916) + p.Table_partition_description() + } + p.SetState(10927) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10917) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10918) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(10919) + p.Partition_name() + } + + } + { + p.SetState(10922) + p.Range_values_clause() + } + { + p.SetState(10923) + p.Table_partition_description() + } + + p.SetState(10929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10930) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_partitionsContext is an interface to support dynamic dispatch. +type IList_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Column_name() IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllList_values_clause() []IList_values_clauseContext + List_values_clause(i int) IList_values_clauseContext + AllTable_partition_description() []ITable_partition_descriptionContext + Table_partition_description(i int) ITable_partition_descriptionContext + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_partitionsContext differentiates from other interfaces. + IsList_partitionsContext() +} + +type List_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_partitionsContext() *List_partitionsContext { + var p = new(List_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partitions + return p +} + +func InitEmptyList_partitionsContext(p *List_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partitions +} + +func (*List_partitionsContext) IsList_partitionsContext() {} + +func NewList_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_partitionsContext { + var p = new(List_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_partitions + + return p +} + +func (s *List_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *List_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *List_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *List_partitionsContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *List_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *List_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *List_partitionsContext) 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 *List_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *List_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *List_partitionsContext) AllList_values_clause() []IList_values_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_values_clauseContext); ok { + len++ + } + } + + tst := make([]IList_values_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_values_clauseContext); ok { + tst[i] = t.(IList_values_clauseContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) List_values_clause(i int) IList_values_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_partitionsContext) AllTable_partition_description() []ITable_partition_descriptionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + len++ + } + } + + tst := make([]ITable_partition_descriptionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_partition_descriptionContext); ok { + tst[i] = t.(ITable_partition_descriptionContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) Table_partition_description(i int) ITable_partition_descriptionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *List_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *List_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *List_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_partitions(s) + } +} + +func (s *List_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_partitions(s) + } +} + +func (s *List_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitList_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) List_partitions() (localctx IList_partitionsContext) { + localctx = NewList_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1112, PlSqlParserRULE_list_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10932) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10933) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10934) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10935) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10936) + p.Column_name() + } + { + p.SetState(10937) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10938) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10939) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10941) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(10940) + p.Partition_name() + } + + } + { + p.SetState(10943) + p.List_values_clause() + } + { + p.SetState(10944) + p.Table_partition_description() + } + p.SetState(10955) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10945) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10946) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(10947) + p.Partition_name() + } + + } + { + p.SetState(10950) + p.List_values_clause() + } + { + p.SetState(10951) + p.Table_partition_description() + } + + p.SetState(10957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10958) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partitionsContext is an interface to support dynamic dispatch. +type IHash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_partitionsContext differentiates from other interfaces. + IsHash_partitionsContext() +} + +type Hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partitionsContext() *Hash_partitionsContext { + var p = new(Hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions + return p +} + +func InitEmptyHash_partitionsContext(p *Hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions +} + +func (*Hash_partitionsContext) IsHash_partitionsContext() {} + +func NewHash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partitionsContext { + var p = new(Hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partitions + + return p +} + +func (s *Hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Hash_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Hash_partitionsContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hash_partitionsContext) 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 *Hash_partitionsContext) 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 *Hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hash_partitionsContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Hash_partitionsContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partitions(s) + } +} + +func (s *Hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partitions(s) + } +} + +func (s *Hash_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHash_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hash_partitions() (localctx IHash_partitionsContext) { + localctx = NewHash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1114, PlSqlParserRULE_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10960) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10961) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10962) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10963) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10964) + p.Column_name() + } + p.SetState(10969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10965) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10966) + p.Column_name() + } + + p.SetState(10971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10972) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10975) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(10973) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(10974) + p.Hash_partitions_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndividual_hash_partitionsContext is an interface to support dynamic dispatch. +type IIndividual_hash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AllPartitioning_storage_clause() []IPartitioning_storage_clauseContext + Partitioning_storage_clause(i int) IPartitioning_storage_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsIndividual_hash_partitionsContext differentiates from other interfaces. + IsIndividual_hash_partitionsContext() +} + +type Individual_hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndividual_hash_partitionsContext() *Individual_hash_partitionsContext { + var p = new(Individual_hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions + return p +} + +func InitEmptyIndividual_hash_partitionsContext(p *Individual_hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions +} + +func (*Individual_hash_partitionsContext) IsIndividual_hash_partitionsContext() {} + +func NewIndividual_hash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Individual_hash_partitionsContext { + var p = new(Individual_hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_individual_hash_partitions + + return p +} + +func (s *Individual_hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Individual_hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Individual_hash_partitionsContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Individual_hash_partitionsContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Individual_hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Individual_hash_partitionsContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Individual_hash_partitionsContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Individual_hash_partitionsContext) AllPartitioning_storage_clause() []IPartitioning_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + len++ + } + } + + tst := make([]IPartitioning_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartitioning_storage_clauseContext); ok { + tst[i] = t.(IPartitioning_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Individual_hash_partitionsContext) Partitioning_storage_clause(i int) IPartitioning_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Individual_hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Individual_hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Individual_hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Individual_hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Individual_hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndividual_hash_partitions(s) + } +} + +func (s *Individual_hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndividual_hash_partitions(s) + } +} + +func (s *Individual_hash_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndividual_hash_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Individual_hash_partitions() (localctx IIndividual_hash_partitionsContext) { + localctx = NewIndividual_hash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1116, PlSqlParserRULE_individual_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(10977) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10978) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10980) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1317, p.GetParserRuleContext()) == 1 { + { + p.SetState(10979) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(10982) + p.Partitioning_storage_clause() + } + + } + p.SetState(10995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(10985) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(10986) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(10988) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1319, p.GetParserRuleContext()) == 1 { + { + p.SetState(10987) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(10991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(10990) + p.Partitioning_storage_clause() + } + + } + + p.SetState(10997) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(10998) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partitions_by_quantityContext is an interface to support dynamic dispatch. +type IHash_partitions_by_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITIONS() antlr.TerminalNode + Hash_partition_quantity() IHash_partition_quantityContext + AllSTORE() []antlr.TerminalNode + STORE(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Table_compression() ITable_compressionContext + Key_compression() IKey_compressionContext + OVERFLOW() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_partitions_by_quantityContext differentiates from other interfaces. + IsHash_partitions_by_quantityContext() +} + +type Hash_partitions_by_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partitions_by_quantityContext() *Hash_partitions_by_quantityContext { + var p = new(Hash_partitions_by_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity + return p +} + +func InitEmptyHash_partitions_by_quantityContext(p *Hash_partitions_by_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity +} + +func (*Hash_partitions_by_quantityContext) IsHash_partitions_by_quantityContext() {} + +func NewHash_partitions_by_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partitions_by_quantityContext { + var p = new(Hash_partitions_by_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partitions_by_quantity + + return p +} + +func (s *Hash_partitions_by_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partitions_by_quantityContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Hash_partitions_by_quantityContext) Hash_partition_quantity() IHash_partition_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partition_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partition_quantityContext) +} + +func (s *Hash_partitions_by_quantityContext) AllSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORE) +} + +func (s *Hash_partitions_by_quantityContext) STORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, i) +} + +func (s *Hash_partitions_by_quantityContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Hash_partitions_by_quantityContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Hash_partitions_by_quantityContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Hash_partitions_by_quantityContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Hash_partitions_by_quantityContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Hash_partitions_by_quantityContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Hash_partitions_by_quantityContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Hash_partitions_by_quantityContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Hash_partitions_by_quantityContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Hash_partitions_by_quantityContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Hash_partitions_by_quantityContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Hash_partitions_by_quantityContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_partitions_by_quantityContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_partitions_by_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partitions_by_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partitions_by_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partitions_by_quantity(s) + } +} + +func (s *Hash_partitions_by_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partitions_by_quantity(s) + } +} + +func (s *Hash_partitions_by_quantityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHash_partitions_by_quantity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hash_partitions_by_quantity() (localctx IHash_partitions_by_quantityContext) { + localctx = NewHash_partitions_by_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1118, PlSqlParserRULE_hash_partitions_by_quantity) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11000) + p.Match(PlSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11001) + p.Hash_partition_quantity() + } + p.SetState(11015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11002) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11003) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11004) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11005) + p.Tablespace() + } + p.SetState(11010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11006) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11007) + p.Tablespace() + } + + p.SetState(11012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11013) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11019) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1324, p.GetParserRuleContext()) == 1 { + { + p.SetState(11017) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1324, p.GetParserRuleContext()) == 2 { + { + p.SetState(11018) + p.Key_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11035) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOVERFLOW { + { + p.SetState(11021) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11022) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11023) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11024) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11025) + p.Tablespace() + } + p.SetState(11030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11026) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11027) + p.Tablespace() + } + + p.SetState(11032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11033) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_partition_quantityContext is an interface to support dynamic dispatch. +type IHash_partition_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsHash_partition_quantityContext differentiates from other interfaces. + IsHash_partition_quantityContext() +} + +type Hash_partition_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_partition_quantityContext() *Hash_partition_quantityContext { + var p = new(Hash_partition_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity + return p +} + +func InitEmptyHash_partition_quantityContext(p *Hash_partition_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity +} + +func (*Hash_partition_quantityContext) IsHash_partition_quantityContext() {} + +func NewHash_partition_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_partition_quantityContext { + var p = new(Hash_partition_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_partition_quantity + + return p +} + +func (s *Hash_partition_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_partition_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_partition_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_partition_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_partition_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_partition_quantity(s) + } +} + +func (s *Hash_partition_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_partition_quantity(s) + } +} + +func (s *Hash_partition_quantityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHash_partition_quantity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hash_partition_quantity() (localctx IHash_partition_quantityContext) { + localctx = NewHash_partition_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1120, PlSqlParserRULE_hash_partition_quantity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11037) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IComposite_range_partitionsContext is an interface to support dynamic dispatch. +type IComposite_range_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllRange_partition_desc() []IRange_partition_descContext + Range_partition_desc(i int) IRange_partition_descContext + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INTERVAL() antlr.TerminalNode + Expression() IExpressionContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsComposite_range_partitionsContext differentiates from other interfaces. + IsComposite_range_partitionsContext() +} + +type Composite_range_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_range_partitionsContext() *Composite_range_partitionsContext { + var p = new(Composite_range_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_range_partitions + return p +} + +func InitEmptyComposite_range_partitionsContext(p *Composite_range_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_range_partitions +} + +func (*Composite_range_partitionsContext) IsComposite_range_partitionsContext() {} + +func NewComposite_range_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_range_partitionsContext { + var p = new(Composite_range_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_range_partitions + + return p +} + +func (s *Composite_range_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_range_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_range_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_range_partitionsContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Composite_range_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Composite_range_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Composite_range_partitionsContext) 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 *Composite_range_partitionsContext) 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 *Composite_range_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Composite_range_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Composite_range_partitionsContext) AllRange_partition_desc() []IRange_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_partition_descContext); ok { + len++ + } + } + + tst := make([]IRange_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_partition_descContext); ok { + tst[i] = t.(IRange_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Composite_range_partitionsContext) Range_partition_desc(i int) IRange_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_range_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_range_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_range_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_range_partitionsContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Composite_range_partitionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Composite_range_partitionsContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Composite_range_partitionsContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Composite_range_partitionsContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Composite_range_partitionsContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Composite_range_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_range_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_range_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_range_partitions(s) + } +} + +func (s *Composite_range_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_range_partitions(s) + } +} + +func (s *Composite_range_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComposite_range_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Composite_range_partitions() (localctx IComposite_range_partitionsContext) { + localctx = NewComposite_range_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1122, PlSqlParserRULE_composite_range_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11039) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11040) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11041) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11042) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11043) + p.Column_name() + } + p.SetState(11048) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11044) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11045) + p.Column_name() + } + + p.SetState(11050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11051) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTERVAL { + { + p.SetState(11052) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11053) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11054) + p.Expression() + } + { + p.SetState(11055) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11056) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11057) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11058) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11059) + p.Tablespace() + } + p.SetState(11064) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11060) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11061) + p.Tablespace() + } + + p.SetState(11066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11067) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(11076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1331, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11073) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11074) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11075) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11078) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11079) + p.Range_partition_desc() + } + p.SetState(11084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11080) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11081) + p.Range_partition_desc() + } + + p.SetState(11086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11087) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComposite_list_partitionsContext is an interface to support dynamic dispatch. +type IComposite_list_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Column_name() IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllList_partition_desc() []IList_partition_descContext + List_partition_desc(i int) IList_partition_descContext + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsComposite_list_partitionsContext differentiates from other interfaces. + IsComposite_list_partitionsContext() +} + +type Composite_list_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_list_partitionsContext() *Composite_list_partitionsContext { + var p = new(Composite_list_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_list_partitions + return p +} + +func InitEmptyComposite_list_partitionsContext(p *Composite_list_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_list_partitions +} + +func (*Composite_list_partitionsContext) IsComposite_list_partitionsContext() {} + +func NewComposite_list_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_list_partitionsContext { + var p = new(Composite_list_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_list_partitions + + return p +} + +func (s *Composite_list_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_list_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_list_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_list_partitionsContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Composite_list_partitionsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Composite_list_partitionsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Composite_list_partitionsContext) 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 *Composite_list_partitionsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Composite_list_partitionsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Composite_list_partitionsContext) AllList_partition_desc() []IList_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_partition_descContext); ok { + len++ + } + } + + tst := make([]IList_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_partition_descContext); ok { + tst[i] = t.(IList_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Composite_list_partitionsContext) List_partition_desc(i int) IList_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_list_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_list_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_list_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_list_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_list_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_list_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_list_partitions(s) + } +} + +func (s *Composite_list_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_list_partitions(s) + } +} + +func (s *Composite_list_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComposite_list_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Composite_list_partitions() (localctx IComposite_list_partitionsContext) { + localctx = NewComposite_list_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1124, PlSqlParserRULE_composite_list_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11089) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11090) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11091) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11092) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11093) + p.Column_name() + } + { + p.SetState(11094) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1333, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11095) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11096) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11097) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11100) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11101) + p.List_partition_desc() + } + p.SetState(11106) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11102) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11103) + p.List_partition_desc() + } + + p.SetState(11108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11109) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IComposite_hash_partitionsContext is an interface to support dynamic dispatch. +type IComposite_hash_partitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subpartition_by_range() ISubpartition_by_rangeContext + Subpartition_by_list() ISubpartition_by_listContext + Subpartition_by_hash() ISubpartition_by_hashContext + Individual_hash_partitions() IIndividual_hash_partitionsContext + Hash_partitions_by_quantity() IHash_partitions_by_quantityContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + + // IsComposite_hash_partitionsContext differentiates from other interfaces. + IsComposite_hash_partitionsContext() +} + +type Composite_hash_partitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComposite_hash_partitionsContext() *Composite_hash_partitionsContext { + var p = new(Composite_hash_partitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions + return p +} + +func InitEmptyComposite_hash_partitionsContext(p *Composite_hash_partitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions +} + +func (*Composite_hash_partitionsContext) IsComposite_hash_partitionsContext() {} + +func NewComposite_hash_partitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Composite_hash_partitionsContext { + var p = new(Composite_hash_partitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_composite_hash_partitions + + return p +} + +func (s *Composite_hash_partitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Composite_hash_partitionsContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Composite_hash_partitionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Composite_hash_partitionsContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Composite_hash_partitionsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Composite_hash_partitionsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_range() ISubpartition_by_rangeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_rangeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_rangeContext) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_list() ISubpartition_by_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_listContext) +} + +func (s *Composite_hash_partitionsContext) Subpartition_by_hash() ISubpartition_by_hashContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_by_hashContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_by_hashContext) +} + +func (s *Composite_hash_partitionsContext) Individual_hash_partitions() IIndividual_hash_partitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_partitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_partitionsContext) +} + +func (s *Composite_hash_partitionsContext) Hash_partitions_by_quantity() IHash_partitions_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_partitions_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_partitions_by_quantityContext) +} + +func (s *Composite_hash_partitionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Composite_hash_partitionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Composite_hash_partitionsContext) 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 *Composite_hash_partitionsContext) 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 *Composite_hash_partitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Composite_hash_partitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Composite_hash_partitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComposite_hash_partitions(s) + } +} + +func (s *Composite_hash_partitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComposite_hash_partitions(s) + } +} + +func (s *Composite_hash_partitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComposite_hash_partitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Composite_hash_partitions() (localctx IComposite_hash_partitionsContext) { + localctx = NewComposite_hash_partitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1126, PlSqlParserRULE_composite_hash_partitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11111) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11112) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11113) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11114) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11117) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(11115) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11116) + p.Column_name() + } + + p.SetState(11119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11121) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1336, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11122) + p.Subpartition_by_range() + } + + case 2: + { + p.SetState(11123) + p.Subpartition_by_list() + } + + case 3: + { + p.SetState(11124) + p.Subpartition_by_hash() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(11129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11127) + p.Individual_hash_partitions() + } + + case PlSqlParserPARTITIONS: + { + p.SetState(11128) + p.Hash_partitions_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_partitioningContext is an interface to support dynamic dispatch. +type IReference_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Regular_id() IRegular_idContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllReference_partition_desc() []IReference_partition_descContext + Reference_partition_desc(i int) IReference_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsReference_partitioningContext differentiates from other interfaces. + IsReference_partitioningContext() +} + +type Reference_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_partitioningContext() *Reference_partitioningContext { + var p = new(Reference_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partitioning + return p +} + +func InitEmptyReference_partitioningContext(p *Reference_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partitioning +} + +func (*Reference_partitioningContext) IsReference_partitioningContext() {} + +func NewReference_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_partitioningContext { + var p = new(Reference_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_partitioning + + return p +} + +func (s *Reference_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_partitioningContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Reference_partitioningContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Reference_partitioningContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Reference_partitioningContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Reference_partitioningContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Reference_partitioningContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Reference_partitioningContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Reference_partitioningContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Reference_partitioningContext) AllReference_partition_desc() []IReference_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_partition_descContext); ok { + len++ + } + } + + tst := make([]IReference_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_partition_descContext); ok { + tst[i] = t.(IReference_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Reference_partitioningContext) Reference_partition_desc(i int) IReference_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_partition_descContext) +} + +func (s *Reference_partitioningContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Reference_partitioningContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Reference_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_partitioning(s) + } +} + +func (s *Reference_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_partitioning(s) + } +} + +func (s *Reference_partitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReference_partitioning(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Reference_partitioning() (localctx IReference_partitioningContext) { + localctx = NewReference_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1128, PlSqlParserRULE_reference_partitioning) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11131) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11132) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11133) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11134) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11135) + p.Regular_id() + } + { + p.SetState(11136) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11137) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11138) + p.Reference_partition_desc() + } + p.SetState(11143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11139) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11140) + p.Reference_partition_desc() + } + + p.SetState(11145) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11146) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_partition_descContext is an interface to support dynamic dispatch. +type IReference_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + + // IsReference_partition_descContext differentiates from other interfaces. + IsReference_partition_descContext() +} + +type Reference_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_partition_descContext() *Reference_partition_descContext { + var p = new(Reference_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partition_desc + return p +} + +func InitEmptyReference_partition_descContext(p *Reference_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_partition_desc +} + +func (*Reference_partition_descContext) IsReference_partition_descContext() {} + +func NewReference_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_partition_descContext { + var p = new(Reference_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_partition_desc + + return p +} + +func (s *Reference_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Reference_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Reference_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Reference_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_partition_desc(s) + } +} + +func (s *Reference_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_partition_desc(s) + } +} + +func (s *Reference_partition_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReference_partition_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Reference_partition_desc() (localctx IReference_partition_descContext) { + localctx = NewReference_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1130, PlSqlParserRULE_reference_partition_desc) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11150) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11152) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1340, p.GetParserRuleContext()) == 1 { + { + p.SetState(11151) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11154) + p.Table_partition_description() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_partitioningContext is an interface to support dynamic dispatch. +type ISystem_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AllReference_partition_desc() []IReference_partition_descContext + Reference_partition_desc(i int) IReference_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSystem_partitioningContext differentiates from other interfaces. + IsSystem_partitioningContext() +} + +type System_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_partitioningContext() *System_partitioningContext { + var p = new(System_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_partitioning + return p +} + +func InitEmptySystem_partitioningContext(p *System_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_partitioning +} + +func (*System_partitioningContext) IsSystem_partitioningContext() {} + +func NewSystem_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_partitioningContext { + var p = new(System_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_partitioning + + return p +} + +func (s *System_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_partitioningContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *System_partitioningContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *System_partitioningContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *System_partitioningContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *System_partitioningContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *System_partitioningContext) AllReference_partition_desc() []IReference_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_partition_descContext); ok { + len++ + } + } + + tst := make([]IReference_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_partition_descContext); ok { + tst[i] = t.(IReference_partition_descContext) + i++ + } + } + + return tst +} + +func (s *System_partitioningContext) Reference_partition_desc(i int) IReference_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_partition_descContext) +} + +func (s *System_partitioningContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *System_partitioningContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *System_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_partitioning(s) + } +} + +func (s *System_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_partitioning(s) + } +} + +func (s *System_partitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSystem_partitioning(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) System_partitioning() (localctx ISystem_partitioningContext) { + localctx = NewSystem_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1132, PlSqlParserRULE_system_partitioning) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11156) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11157) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11158) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITIONS: + { + p.SetState(11159) + p.Match(PlSqlParserPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11160) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARTITION: + { + p.SetState(11161) + p.Reference_partition_desc() + } + p.SetState(11166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11162) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11163) + p.Reference_partition_desc() + } + + p.SetState(11168) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserAS, PlSqlParserCACHE, PlSqlParserCLUSTER, PlSqlParserCLUSTERING, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFLASHBACK, PlSqlParserFOR, PlSqlParserINITRANS, PlSqlParserINVALIDATE, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserNO, PlSqlParserNOPARALLEL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserONLINE, PlSqlParserORGANIZATION, PlSqlParserPARALLEL, PlSqlParserPARENT, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserRESULT_CACHE, PlSqlParserROWDEPENDENCIES, PlSqlParserROW, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserUPDATE, PlSqlParserMEMOPTIMIZE, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_partition_descContext is an interface to support dynamic dispatch. +type IRange_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Range_values_clause() IRange_values_clauseContext + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subparts_by_quantity() IHash_subparts_by_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRange_partition_descContext differentiates from other interfaces. + IsRange_partition_descContext() +} + +type Range_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_partition_descContext() *Range_partition_descContext { + var p = new(Range_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partition_desc + return p +} + +func InitEmptyRange_partition_descContext(p *Range_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_partition_desc +} + +func (*Range_partition_descContext) IsRange_partition_descContext() {} + +func NewRange_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_partition_descContext { + var p = new(Range_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_partition_desc + + return p +} + +func (s *Range_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Range_partition_descContext) Range_values_clause() IRange_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *Range_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Range_partition_descContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Range_partition_descContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Range_partition_descContext) Hash_subparts_by_quantity() IHash_subparts_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subparts_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subparts_by_quantityContext) +} + +func (s *Range_partition_descContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Range_partition_descContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *Range_partition_descContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *Range_partition_descContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *Range_partition_descContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_partition_descContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_partition_desc(s) + } +} + +func (s *Range_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_partition_desc(s) + } +} + +func (s *Range_partition_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRange_partition_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Range_partition_desc() (localctx IRange_partition_descContext) { + localctx = NewRange_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1134, PlSqlParserRULE_range_partition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11171) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(11172) + p.Partition_name() + } + + } + { + p.SetState(11175) + p.Range_values_clause() + } + { + p.SetState(11176) + p.Table_partition_description() + } + p.SetState(11209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserLEFT_PAREN { + p.SetState(11207) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11177) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1347, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11178) + p.Range_subpartition_desc() + } + p.SetState(11183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11179) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11180) + p.Range_subpartition_desc() + } + + p.SetState(11185) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11186) + p.List_subpartition_desc() + } + p.SetState(11191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11187) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11188) + p.List_subpartition_desc() + } + + p.SetState(11193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11194) + p.Individual_hash_subparts() + } + p.SetState(11199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11195) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11196) + p.Individual_hash_subparts() + } + + p.SetState(11201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11204) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11206) + p.Hash_subparts_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_partition_descContext is an interface to support dynamic dispatch. +type IList_partition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + List_values_clause() IList_values_clauseContext + Table_partition_description() ITable_partition_descriptionContext + Partition_name() IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subparts_by_quantity() IHash_subparts_by_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_partition_descContext differentiates from other interfaces. + IsList_partition_descContext() +} + +type List_partition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_partition_descContext() *List_partition_descContext { + var p = new(List_partition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partition_desc + return p +} + +func InitEmptyList_partition_descContext(p *List_partition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_partition_desc +} + +func (*List_partition_descContext) IsList_partition_descContext() {} + +func NewList_partition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_partition_descContext { + var p = new(List_partition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_partition_desc + + return p +} + +func (s *List_partition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_partition_descContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *List_partition_descContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_partition_descContext) Table_partition_description() ITable_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partition_descriptionContext) +} + +func (s *List_partition_descContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *List_partition_descContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *List_partition_descContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *List_partition_descContext) Hash_subparts_by_quantity() IHash_subparts_by_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subparts_by_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subparts_by_quantityContext) +} + +func (s *List_partition_descContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *List_partition_descContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *List_partition_descContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *List_partition_descContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *List_partition_descContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_partition_descContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_partition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_partition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_partition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_partition_desc(s) + } +} + +func (s *List_partition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_partition_desc(s) + } +} + +func (s *List_partition_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitList_partition_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) List_partition_desc() (localctx IList_partition_descContext) { + localctx = NewList_partition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1136, PlSqlParserRULE_list_partition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11211) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(11212) + p.Partition_name() + } + + } + { + p.SetState(11215) + p.List_values_clause() + } + { + p.SetState(11216) + p.Table_partition_description() + } + p.SetState(11249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserLEFT_PAREN { + p.SetState(11247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11217) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1354, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11218) + p.Range_subpartition_desc() + } + p.SetState(11223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11219) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11220) + p.Range_subpartition_desc() + } + + p.SetState(11225) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11226) + p.List_subpartition_desc() + } + p.SetState(11231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11227) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11228) + p.List_subpartition_desc() + } + + p.SetState(11233) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11234) + p.Individual_hash_subparts() + } + p.SetState(11239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11235) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11236) + p.Individual_hash_subparts() + } + + p.SetState(11241) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11244) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11246) + p.Hash_subparts_by_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_templateContext is an interface to support dynamic dispatch. +type ISubpartition_templateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Hash_subpartition_quantity() IHash_subpartition_quantityContext + AllRange_subpartition_desc() []IRange_subpartition_descContext + Range_subpartition_desc(i int) IRange_subpartition_descContext + AllList_subpartition_desc() []IList_subpartition_descContext + List_subpartition_desc(i int) IList_subpartition_descContext + AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext + Individual_hash_subparts(i int) IIndividual_hash_subpartsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSubpartition_templateContext differentiates from other interfaces. + IsSubpartition_templateContext() +} + +type Subpartition_templateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_templateContext() *Subpartition_templateContext { + var p = new(Subpartition_templateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_template + return p +} + +func InitEmptySubpartition_templateContext(p *Subpartition_templateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_template +} + +func (*Subpartition_templateContext) IsSubpartition_templateContext() {} + +func NewSubpartition_templateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_templateContext { + var p = new(Subpartition_templateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_template + + return p +} + +func (s *Subpartition_templateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_templateContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_templateContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Subpartition_templateContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_templateContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_templateContext) Hash_subpartition_quantity() IHash_subpartition_quantityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHash_subpartition_quantityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHash_subpartition_quantityContext) +} + +func (s *Subpartition_templateContext) AllRange_subpartition_desc() []IRange_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IRange_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_subpartition_descContext); ok { + tst[i] = t.(IRange_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) Range_subpartition_desc(i int) IRange_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Subpartition_templateContext) AllList_subpartition_desc() []IList_subpartition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_subpartition_descContext); ok { + len++ + } + } + + tst := make([]IList_subpartition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_subpartition_descContext); ok { + tst[i] = t.(IList_subpartition_descContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) List_subpartition_desc(i int) IList_subpartition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_subpartition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_subpartition_descContext) +} + +func (s *Subpartition_templateContext) AllIndividual_hash_subparts() []IIndividual_hash_subpartsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + len++ + } + } + + tst := make([]IIndividual_hash_subpartsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIndividual_hash_subpartsContext); ok { + tst[i] = t.(IIndividual_hash_subpartsContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_templateContext) Individual_hash_subparts(i int) IIndividual_hash_subpartsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndividual_hash_subpartsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIndividual_hash_subpartsContext) +} + +func (s *Subpartition_templateContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_templateContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_templateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_templateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_templateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_template(s) + } +} + +func (s *Subpartition_templateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_template(s) + } +} + +func (s *Subpartition_templateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_template(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_template() (localctx ISubpartition_templateContext) { + localctx = NewSubpartition_templateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1138, PlSqlParserRULE_subpartition_template) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11251) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11252) + p.Match(PlSqlParserTEMPLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(11253) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1360, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11254) + p.Range_subpartition_desc() + } + p.SetState(11259) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11255) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11256) + p.Range_subpartition_desc() + } + + p.SetState(11261) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(11262) + p.List_subpartition_desc() + } + p.SetState(11267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11263) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11264) + p.List_subpartition_desc() + } + + p.SetState(11269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(11270) + p.Individual_hash_subparts() + } + p.SetState(11275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11271) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11272) + p.Individual_hash_subparts() + } + + p.SetState(11277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(11280) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(11282) + p.Hash_subpartition_quantity() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHash_subpartition_quantityContext is an interface to support dynamic dispatch. +type IHash_subpartition_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsHash_subpartition_quantityContext differentiates from other interfaces. + IsHash_subpartition_quantityContext() +} + +type Hash_subpartition_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_subpartition_quantityContext() *Hash_subpartition_quantityContext { + var p = new(Hash_subpartition_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity + return p +} + +func InitEmptyHash_subpartition_quantityContext(p *Hash_subpartition_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity +} + +func (*Hash_subpartition_quantityContext) IsHash_subpartition_quantityContext() {} + +func NewHash_subpartition_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_subpartition_quantityContext { + var p = new(Hash_subpartition_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_subpartition_quantity + + return p +} + +func (s *Hash_subpartition_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_subpartition_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_subpartition_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_subpartition_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_subpartition_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_subpartition_quantity(s) + } +} + +func (s *Hash_subpartition_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_subpartition_quantity(s) + } +} + +func (s *Hash_subpartition_quantityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHash_subpartition_quantity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hash_subpartition_quantity() (localctx IHash_subpartition_quantityContext) { + localctx = NewHash_subpartition_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1140, PlSqlParserRULE_hash_subpartition_quantity) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11285) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// ISubpartition_by_rangeContext is an interface to support dynamic dispatch. +type ISubpartition_by_rangeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + RANGE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + + // IsSubpartition_by_rangeContext differentiates from other interfaces. + IsSubpartition_by_rangeContext() +} + +type Subpartition_by_rangeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_rangeContext() *Subpartition_by_rangeContext { + var p = new(Subpartition_by_rangeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_range + return p +} + +func InitEmptySubpartition_by_rangeContext(p *Subpartition_by_rangeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_range +} + +func (*Subpartition_by_rangeContext) IsSubpartition_by_rangeContext() {} + +func NewSubpartition_by_rangeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_rangeContext { + var p = new(Subpartition_by_rangeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_range + + return p +} + +func (s *Subpartition_by_rangeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_rangeContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_rangeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_rangeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Subpartition_by_rangeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_by_rangeContext) 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 *Subpartition_by_rangeContext) 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 *Subpartition_by_rangeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_by_rangeContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_by_rangeContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_by_rangeContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_rangeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_rangeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_rangeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_range(s) + } +} + +func (s *Subpartition_by_rangeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_range(s) + } +} + +func (s *Subpartition_by_rangeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_by_range(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_by_range() (localctx ISubpartition_by_rangeContext) { + localctx = NewSubpartition_by_rangeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1142, PlSqlParserRULE_subpartition_by_range) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11287) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11288) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11289) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11290) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11291) + p.Column_name() + } + p.SetState(11296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11292) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11293) + p.Column_name() + } + + p.SetState(11298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11299) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITION { + { + p.SetState(11300) + p.Subpartition_template() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_by_listContext is an interface to support dynamic dispatch. +type ISubpartition_by_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + LIST() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + + // IsSubpartition_by_listContext differentiates from other interfaces. + IsSubpartition_by_listContext() +} + +type Subpartition_by_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_listContext() *Subpartition_by_listContext { + var p = new(Subpartition_by_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_list + return p +} + +func InitEmptySubpartition_by_listContext(p *Subpartition_by_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_list +} + +func (*Subpartition_by_listContext) IsSubpartition_by_listContext() {} + +func NewSubpartition_by_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_listContext { + var p = new(Subpartition_by_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_list + + return p +} + +func (s *Subpartition_by_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_listContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_listContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_listContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Subpartition_by_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_by_listContext) 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 *Subpartition_by_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_by_listContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_list(s) + } +} + +func (s *Subpartition_by_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_list(s) + } +} + +func (s *Subpartition_by_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_by_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_by_list() (localctx ISubpartition_by_listContext) { + localctx = NewSubpartition_by_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1144, PlSqlParserRULE_subpartition_by_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11303) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11304) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11305) + p.Match(PlSqlParserLIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11306) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11307) + p.Column_name() + } + { + p.SetState(11308) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11310) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSUBPARTITION { + { + p.SetState(11309) + p.Subpartition_template() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_by_hashContext is an interface to support dynamic dispatch. +type ISubpartition_by_hashContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + HASH() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Subpartition_template() ISubpartition_templateContext + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + + // IsSubpartition_by_hashContext differentiates from other interfaces. + IsSubpartition_by_hashContext() +} + +type Subpartition_by_hashContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_by_hashContext() *Subpartition_by_hashContext { + var p = new(Subpartition_by_hashContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash + return p +} + +func InitEmptySubpartition_by_hashContext(p *Subpartition_by_hashContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash +} + +func (*Subpartition_by_hashContext) IsSubpartition_by_hashContext() {} + +func NewSubpartition_by_hashContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_by_hashContext { + var p = new(Subpartition_by_hashContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_by_hash + + return p +} + +func (s *Subpartition_by_hashContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_by_hashContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_by_hashContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Subpartition_by_hashContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Subpartition_by_hashContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Subpartition_by_hashContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Subpartition_by_hashContext) 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 *Subpartition_by_hashContext) 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 *Subpartition_by_hashContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Subpartition_by_hashContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Subpartition_by_hashContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_by_hashContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_by_hashContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Subpartition_by_hashContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Subpartition_by_hashContext) Subpartition_template() ISubpartition_templateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_templateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_templateContext) +} + +func (s *Subpartition_by_hashContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Subpartition_by_hashContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Subpartition_by_hashContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_by_hashContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Subpartition_by_hashContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_by_hashContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_by_hashContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_by_hash(s) + } +} + +func (s *Subpartition_by_hashContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_by_hash(s) + } +} + +func (s *Subpartition_by_hashContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_by_hash(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_by_hash() (localctx ISubpartition_by_hashContext) { + localctx = NewSubpartition_by_hashContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1146, PlSqlParserRULE_subpartition_by_hash) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11312) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11313) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11314) + p.Match(PlSqlParserHASH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11315) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11316) + p.Column_name() + } + p.SetState(11321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11317) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11318) + p.Column_name() + } + + p.SetState(11323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11324) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUBPARTITIONS: + { + p.SetState(11325) + p.Match(PlSqlParserSUBPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11326) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11327) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11328) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11329) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11330) + p.Tablespace() + } + p.SetState(11335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11331) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11332) + p.Tablespace() + } + + p.SetState(11337) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11338) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(11342) + p.Subpartition_template() + } + + case PlSqlParserPARTITIONS, PlSqlParserLEFT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_nameContext is an interface to support dynamic dispatch. +type ISubpartition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Partition_name() IPartition_nameContext + + // IsSubpartition_nameContext differentiates from other interfaces. + IsSubpartition_nameContext() +} + +type Subpartition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_nameContext() *Subpartition_nameContext { + var p = new(Subpartition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_name + return p +} + +func InitEmptySubpartition_nameContext(p *Subpartition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_name +} + +func (*Subpartition_nameContext) IsSubpartition_nameContext() {} + +func NewSubpartition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_nameContext { + var p = new(Subpartition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_name + + return p +} + +func (s *Subpartition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_nameContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Subpartition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_name(s) + } +} + +func (s *Subpartition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_name(s) + } +} + +func (s *Subpartition_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_name() (localctx ISubpartition_nameContext) { + localctx = NewSubpartition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1148, PlSqlParserRULE_subpartition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11345) + p.Partition_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 +} + +// IRange_subpartition_descContext is an interface to support dynamic dispatch. +type IRange_subpartition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Range_values_clause() IRange_values_clauseContext + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsRange_subpartition_descContext differentiates from other interfaces. + IsRange_subpartition_descContext() +} + +type Range_subpartition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_subpartition_descContext() *Range_subpartition_descContext { + var p = new(Range_subpartition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc + return p +} + +func InitEmptyRange_subpartition_descContext(p *Range_subpartition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc +} + +func (*Range_subpartition_descContext) IsRange_subpartition_descContext() {} + +func NewRange_subpartition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_subpartition_descContext { + var p = new(Range_subpartition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_subpartition_desc + + return p +} + +func (s *Range_subpartition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_subpartition_descContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Range_subpartition_descContext) Range_values_clause() IRange_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_values_clauseContext) +} + +func (s *Range_subpartition_descContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Range_subpartition_descContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Range_subpartition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_subpartition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_subpartition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_subpartition_desc(s) + } +} + +func (s *Range_subpartition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_subpartition_desc(s) + } +} + +func (s *Range_subpartition_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRange_subpartition_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Range_subpartition_desc() (localctx IRange_subpartition_descContext) { + localctx = NewRange_subpartition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1150, PlSqlParserRULE_range_subpartition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11347) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(11348) + p.Subpartition_name() + } + + } + { + p.SetState(11351) + p.Range_values_clause() + } + p.SetState(11353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11352) + p.Partitioning_storage_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 +} + +// IList_subpartition_descContext is an interface to support dynamic dispatch. +type IList_subpartition_descContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + List_values_clause() IList_values_clauseContext + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsList_subpartition_descContext differentiates from other interfaces. + IsList_subpartition_descContext() +} + +type List_subpartition_descContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_subpartition_descContext() *List_subpartition_descContext { + var p = new(List_subpartition_descContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc + return p +} + +func InitEmptyList_subpartition_descContext(p *List_subpartition_descContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc +} + +func (*List_subpartition_descContext) IsList_subpartition_descContext() {} + +func NewList_subpartition_descContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_subpartition_descContext { + var p = new(List_subpartition_descContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_subpartition_desc + + return p +} + +func (s *List_subpartition_descContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_subpartition_descContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *List_subpartition_descContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *List_subpartition_descContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *List_subpartition_descContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *List_subpartition_descContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_subpartition_descContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_subpartition_descContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_subpartition_desc(s) + } +} + +func (s *List_subpartition_descContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_subpartition_desc(s) + } +} + +func (s *List_subpartition_descContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitList_subpartition_desc(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) List_subpartition_desc() (localctx IList_subpartition_descContext) { + localctx = NewList_subpartition_descContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1152, PlSqlParserRULE_list_subpartition_desc) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11355) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(11356) + p.Subpartition_name() + } + + } + { + p.SetState(11359) + p.List_values_clause() + } + p.SetState(11361) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11360) + p.Partitioning_storage_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 +} + +// IIndividual_hash_subpartsContext is an interface to support dynamic dispatch. +type IIndividual_hash_subpartsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + Partitioning_storage_clause() IPartitioning_storage_clauseContext + + // IsIndividual_hash_subpartsContext differentiates from other interfaces. + IsIndividual_hash_subpartsContext() +} + +type Individual_hash_subpartsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndividual_hash_subpartsContext() *Individual_hash_subpartsContext { + var p = new(Individual_hash_subpartsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts + return p +} + +func InitEmptyIndividual_hash_subpartsContext(p *Individual_hash_subpartsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts +} + +func (*Individual_hash_subpartsContext) IsIndividual_hash_subpartsContext() {} + +func NewIndividual_hash_subpartsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Individual_hash_subpartsContext { + var p = new(Individual_hash_subpartsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_individual_hash_subparts + + return p +} + +func (s *Individual_hash_subpartsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Individual_hash_subpartsContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Individual_hash_subpartsContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Individual_hash_subpartsContext) Partitioning_storage_clause() IPartitioning_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartitioning_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartitioning_storage_clauseContext) +} + +func (s *Individual_hash_subpartsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Individual_hash_subpartsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Individual_hash_subpartsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndividual_hash_subparts(s) + } +} + +func (s *Individual_hash_subpartsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndividual_hash_subparts(s) + } +} + +func (s *Individual_hash_subpartsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndividual_hash_subparts(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Individual_hash_subparts() (localctx IIndividual_hash_subpartsContext) { + localctx = NewIndividual_hash_subpartsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1154, PlSqlParserRULE_individual_hash_subparts) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11363) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11365) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1373, p.GetParserRuleContext()) == 1 { + { + p.SetState(11364) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + { + p.SetState(11367) + p.Partitioning_storage_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 +} + +// IHash_subparts_by_quantityContext is an interface to support dynamic dispatch. +type IHash_subparts_by_quantityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITIONS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + STORE() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsHash_subparts_by_quantityContext differentiates from other interfaces. + IsHash_subparts_by_quantityContext() +} + +type Hash_subparts_by_quantityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHash_subparts_by_quantityContext() *Hash_subparts_by_quantityContext { + var p = new(Hash_subparts_by_quantityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity + return p +} + +func InitEmptyHash_subparts_by_quantityContext(p *Hash_subparts_by_quantityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity +} + +func (*Hash_subparts_by_quantityContext) IsHash_subparts_by_quantityContext() {} + +func NewHash_subparts_by_quantityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hash_subparts_by_quantityContext { + var p = new(Hash_subparts_by_quantityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hash_subparts_by_quantity + + return p +} + +func (s *Hash_subparts_by_quantityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hash_subparts_by_quantityContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Hash_subparts_by_quantityContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Hash_subparts_by_quantityContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Hash_subparts_by_quantityContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Hash_subparts_by_quantityContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Hash_subparts_by_quantityContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Hash_subparts_by_quantityContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Hash_subparts_by_quantityContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Hash_subparts_by_quantityContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Hash_subparts_by_quantityContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Hash_subparts_by_quantityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hash_subparts_by_quantityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hash_subparts_by_quantityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHash_subparts_by_quantity(s) + } +} + +func (s *Hash_subparts_by_quantityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHash_subparts_by_quantity(s) + } +} + +func (s *Hash_subparts_by_quantityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHash_subparts_by_quantity(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hash_subparts_by_quantity() (localctx IHash_subparts_by_quantityContext) { + localctx = NewHash_subparts_by_quantityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1156, PlSqlParserRULE_hash_subparts_by_quantity) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11370) + p.Match(PlSqlParserSUBPARTITIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11371) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE { + { + p.SetState(11372) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11373) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11374) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11375) + p.Tablespace() + } + p.SetState(11380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11376) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11377) + p.Tablespace() + } + + p.SetState(11382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11383) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRange_values_clauseContext is an interface to support dynamic dispatch. +type IRange_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + LESS() antlr.TerminalNode + THAN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRange_values_clauseContext differentiates from other interfaces. + IsRange_values_clauseContext() +} + +type Range_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRange_values_clauseContext() *Range_values_clauseContext { + var p = new(Range_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_clause + return p +} + +func InitEmptyRange_values_clauseContext(p *Range_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_range_values_clause +} + +func (*Range_values_clauseContext) IsRange_values_clauseContext() {} + +func NewRange_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Range_values_clauseContext { + var p = new(Range_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_range_values_clause + + return p +} + +func (s *Range_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Range_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Range_values_clauseContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Range_values_clauseContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Range_values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Range_values_clauseContext) 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 *Range_values_clauseContext) 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 *Range_values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Range_values_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Range_values_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Range_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Range_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Range_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRange_values_clause(s) + } +} + +func (s *Range_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRange_values_clause(s) + } +} + +func (s *Range_values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRange_values_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Range_values_clause() (localctx IRange_values_clauseContext) { + localctx = NewRange_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1158, PlSqlParserRULE_range_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11387) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11388) + p.Match(PlSqlParserLESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11389) + p.Match(PlSqlParserTHAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11390) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11391) + p.Literal() + } + p.SetState(11396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11392) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11393) + p.Literal() + } + + p.SetState(11398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11399) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IList_values_clauseContext is an interface to support dynamic dispatch. +type IList_values_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + AllTIMESTAMP() []antlr.TerminalNode + TIMESTAMP(i int) antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsList_values_clauseContext differentiates from other interfaces. + IsList_values_clauseContext() +} + +type List_values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyList_values_clauseContext() *List_values_clauseContext { + var p = new(List_values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_values_clause + return p +} + +func InitEmptyList_values_clauseContext(p *List_values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_list_values_clause +} + +func (*List_values_clauseContext) IsList_values_clauseContext() {} + +func NewList_values_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *List_values_clauseContext { + var p = new(List_values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_list_values_clause + + return p +} + +func (s *List_values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *List_values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *List_values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *List_values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *List_values_clauseContext) 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 *List_values_clauseContext) 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 *List_values_clauseContext) AllTIMESTAMP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIMESTAMP) +} + +func (s *List_values_clauseContext) TIMESTAMP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, i) +} + +func (s *List_values_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *List_values_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *List_values_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *List_values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *List_values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *List_values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterList_values_clause(s) + } +} + +func (s *List_values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitList_values_clause(s) + } +} + +func (s *List_values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitList_values_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) List_values_clause() (localctx IList_values_clauseContext) { + localctx = NewList_values_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1160, PlSqlParserRULE_list_values_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11401) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11402) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11422) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHR, PlSqlParserMAXVALUE, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING: + { + p.SetState(11403) + p.Literal() + } + p.SetState(11408) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11404) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11405) + p.Literal() + } + + p.SetState(11410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserTIMESTAMP: + { + p.SetState(11411) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11412) + p.Literal() + } + p.SetState(11418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11413) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11414) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11415) + p.Literal() + } + + p.SetState(11420) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDEFAULT: + { + p.SetState(11421) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11424) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_partition_descriptionContext is an interface to support dynamic dispatch. +type ITable_partition_descriptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Deferred_segment_creation() IDeferred_segment_creationContext + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + Table_compression() ITable_compressionContext + Key_compression() IKey_compressionContext + OVERFLOW() antlr.TerminalNode + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + AllNested_table_col_properties() []INested_table_col_propertiesContext + Nested_table_col_properties(i int) INested_table_col_propertiesContext + + // IsTable_partition_descriptionContext differentiates from other interfaces. + IsTable_partition_descriptionContext() +} + +type Table_partition_descriptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_partition_descriptionContext() *Table_partition_descriptionContext { + var p = new(Table_partition_descriptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partition_description + return p +} + +func InitEmptyTable_partition_descriptionContext(p *Table_partition_descriptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_partition_description +} + +func (*Table_partition_descriptionContext) IsTable_partition_descriptionContext() {} + +func NewTable_partition_descriptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_partition_descriptionContext { + var p = new(Table_partition_descriptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_partition_description + + return p +} + +func (s *Table_partition_descriptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_partition_descriptionContext) Deferred_segment_creation() IDeferred_segment_creationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeferred_segment_creationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeferred_segment_creationContext) +} + +func (s *Table_partition_descriptionContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Table_partition_descriptionContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Table_partition_descriptionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Table_partition_descriptionContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Table_partition_descriptionContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Table_partition_descriptionContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Table_partition_descriptionContext) AllNested_table_col_properties() []INested_table_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + len++ + } + } + + tst := make([]INested_table_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INested_table_col_propertiesContext); ok { + tst[i] = t.(INested_table_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Table_partition_descriptionContext) Nested_table_col_properties(i int) INested_table_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INested_table_col_propertiesContext) +} + +func (s *Table_partition_descriptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_partition_descriptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_partition_descriptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_partition_description(s) + } +} + +func (s *Table_partition_descriptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_partition_description(s) + } +} + +func (s *Table_partition_descriptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_partition_description(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_partition_description() (localctx ITable_partition_descriptionContext) { + localctx = NewTable_partition_descriptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1162, PlSqlParserRULE_table_partition_description) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11427) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1381, p.GetParserRuleContext()) == 1 { + { + p.SetState(11426) + p.Deferred_segment_creation() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11430) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1382, p.GetParserRuleContext()) == 1 { + { + p.SetState(11429) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11434) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1383, p.GetParserRuleContext()) == 1 { + { + p.SetState(11432) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1383, p.GetParserRuleContext()) == 2 { + { + p.SetState(11433) + p.Key_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11440) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOVERFLOW { + { + p.SetState(11436) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11438) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1384, p.GetParserRuleContext()) == 1 { + { + p.SetState(11437) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } + p.SetState(11447) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserLOB || _la == PlSqlParserNESTED || _la == PlSqlParserVARRAY { + p.SetState(11445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOB: + { + p.SetState(11442) + p.Lob_storage_clause() + } + + case PlSqlParserVARRAY: + { + p.SetState(11443) + p.Varray_col_properties() + } + + case PlSqlParserNESTED: + { + p.SetState(11444) + p.Nested_table_col_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11449) + 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 +} + +// IPartitioning_storage_clauseContext is an interface to support dynamic dispatch. +type IPartitioning_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllOVERFLOW() []antlr.TerminalNode + OVERFLOW(i int) antlr.TerminalNode + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllLob_partitioning_storage() []ILob_partitioning_storageContext + Lob_partitioning_storage(i int) ILob_partitioning_storageContext + AllVARRAY() []antlr.TerminalNode + VARRAY(i int) antlr.TerminalNode + AllVarray_item() []IVarray_itemContext + Varray_item(i int) IVarray_itemContext + AllSTORE() []antlr.TerminalNode + STORE(i int) antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + AllLOB() []antlr.TerminalNode + LOB(i int) antlr.TerminalNode + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + + // IsPartitioning_storage_clauseContext differentiates from other interfaces. + IsPartitioning_storage_clauseContext() +} + +type Partitioning_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartitioning_storage_clauseContext() *Partitioning_storage_clauseContext { + var p = new(Partitioning_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause + return p +} + +func InitEmptyPartitioning_storage_clauseContext(p *Partitioning_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause +} + +func (*Partitioning_storage_clauseContext) IsPartitioning_storage_clauseContext() {} + +func NewPartitioning_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partitioning_storage_clauseContext { + var p = new(Partitioning_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partitioning_storage_clause + + return p +} + +func (s *Partitioning_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partitioning_storage_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Partitioning_storage_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Partitioning_storage_clauseContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partitioning_storage_clauseContext) AllOVERFLOW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOVERFLOW) +} + +func (s *Partitioning_storage_clauseContext) OVERFLOW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, i) +} + +func (s *Partitioning_storage_clauseContext) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Partitioning_storage_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Partitioning_storage_clauseContext) AllLob_partitioning_storage() []ILob_partitioning_storageContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_partitioning_storageContext); ok { + len++ + } + } + + tst := make([]ILob_partitioning_storageContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_partitioning_storageContext); ok { + tst[i] = t.(ILob_partitioning_storageContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Lob_partitioning_storage(i int) ILob_partitioning_storageContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_partitioning_storageContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_partitioning_storageContext) +} + +func (s *Partitioning_storage_clauseContext) AllVARRAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserVARRAY) +} + +func (s *Partitioning_storage_clauseContext) VARRAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, i) +} + +func (s *Partitioning_storage_clauseContext) AllVarray_item() []IVarray_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_itemContext); ok { + len++ + } + } + + tst := make([]IVarray_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_itemContext); ok { + tst[i] = t.(IVarray_itemContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Varray_item(i int) IVarray_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_itemContext) +} + +func (s *Partitioning_storage_clauseContext) AllSTORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORE) +} + +func (s *Partitioning_storage_clauseContext) STORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, i) +} + +func (s *Partitioning_storage_clauseContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Partitioning_storage_clauseContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Partitioning_storage_clauseContext) AllLOB() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOB) +} + +func (s *Partitioning_storage_clauseContext) LOB(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, i) +} + +func (s *Partitioning_storage_clauseContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Partitioning_storage_clauseContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Partitioning_storage_clauseContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Partitioning_storage_clauseContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Partitioning_storage_clauseContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Partitioning_storage_clauseContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Partitioning_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partitioning_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partitioning_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartitioning_storage_clause(s) + } +} + +func (s *Partitioning_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartitioning_storage_clause(s) + } +} + +func (s *Partitioning_storage_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartitioning_storage_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partitioning_storage_clause() (localctx IPartitioning_storage_clauseContext) { + localctx = NewPartitioning_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1164, PlSqlParserRULE_partitioning_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMPRESS || _la == PlSqlParserLOB || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserOVERFLOW || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY { + p.SetState(11470) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1390, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11450) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11451) + p.Tablespace() + } + + case 2: + { + p.SetState(11452) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11455) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1388, p.GetParserRuleContext()) == 1 { + { + p.SetState(11453) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11454) + p.Tablespace() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + { + p.SetState(11457) + p.Table_compression() + } + + case 4: + { + p.SetState(11458) + p.Key_compression() + } + + case 5: + { + p.SetState(11459) + p.Lob_partitioning_storage() + } + + case 6: + { + p.SetState(11460) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11461) + p.Varray_item() + } + { + p.SetState(11462) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11463) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(11464) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(11467) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11468) + p.Lob_segname() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(11472) + 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 +} + +// ILob_partitioning_storageContext is an interface to support dynamic dispatch. +type ILob_partitioning_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Lob_item() ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + Lob_segname() ILob_segnameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + BASICFILE() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + + // IsLob_partitioning_storageContext differentiates from other interfaces. + IsLob_partitioning_storageContext() +} + +type Lob_partitioning_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_partitioning_storageContext() *Lob_partitioning_storageContext { + var p = new(Lob_partitioning_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage + return p +} + +func InitEmptyLob_partitioning_storageContext(p *Lob_partitioning_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage +} + +func (*Lob_partitioning_storageContext) IsLob_partitioning_storageContext() {} + +func NewLob_partitioning_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_partitioning_storageContext { + var p = new(Lob_partitioning_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_partitioning_storage + + return p +} + +func (s *Lob_partitioning_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_partitioning_storageContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_partitioning_storageContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_partitioning_storageContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_partitioning_storageContext) Lob_item() ILob_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_partitioning_storageContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_partitioning_storageContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_partitioning_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_partitioning_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_partitioning_storageContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_partitioning_storageContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Lob_partitioning_storageContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Lob_partitioning_storageContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Lob_partitioning_storageContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Lob_partitioning_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_partitioning_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_partitioning_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_partitioning_storage(s) + } +} + +func (s *Lob_partitioning_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_partitioning_storage(s) + } +} + +func (s *Lob_partitioning_storageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_partitioning_storage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_partitioning_storage() (localctx ILob_partitioning_storageContext) { + localctx = NewLob_partitioning_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1166, PlSqlParserRULE_lob_partitioning_storage) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11474) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11475) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11476) + p.Lob_item() + } + { + p.SetState(11477) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11478) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11479) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1392, p.GetParserRuleContext()) == 1 { + { + p.SetState(11480) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + { + p.SetState(11483) + p.Lob_segname() + } + p.SetState(11489) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(11484) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11485) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11486) + p.Tablespace() + } + { + p.SetState(11487) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(11491) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11492) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11493) + p.Tablespace() + } + { + p.SetState(11494) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDatatype_null_enableContext is an interface to support dynamic dispatch. +type IDatatype_null_enableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Datatype() IDatatypeContext + SORT() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + ENCRYPT() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + USING() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + REGULAR_ID() antlr.TerminalNode + SALT() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsDatatype_null_enableContext differentiates from other interfaces. + IsDatatype_null_enableContext() +} + +type Datatype_null_enableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatype_null_enableContext() *Datatype_null_enableContext { + var p = new(Datatype_null_enableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype_null_enable + return p +} + +func InitEmptyDatatype_null_enableContext(p *Datatype_null_enableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype_null_enable +} + +func (*Datatype_null_enableContext) IsDatatype_null_enableContext() {} + +func NewDatatype_null_enableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datatype_null_enableContext { + var p = new(Datatype_null_enableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datatype_null_enable + + return p +} + +func (s *Datatype_null_enableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datatype_null_enableContext) 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 *Datatype_null_enableContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Datatype_null_enableContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Datatype_null_enableContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Datatype_null_enableContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Datatype_null_enableContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Datatype_null_enableContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Datatype_null_enableContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Datatype_null_enableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Datatype_null_enableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Datatype_null_enableContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Datatype_null_enableContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Datatype_null_enableContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Datatype_null_enableContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Datatype_null_enableContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Datatype_null_enableContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Datatype_null_enableContext) SALT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSALT, 0) +} + +func (s *Datatype_null_enableContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Datatype_null_enableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datatype_null_enableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datatype_null_enableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatatype_null_enable(s) + } +} + +func (s *Datatype_null_enableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatatype_null_enable(s) + } +} + +func (s *Datatype_null_enableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatatype_null_enable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datatype_null_enable() (localctx IDatatype_null_enableContext) { + localctx = NewDatatype_null_enableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1168, PlSqlParserRULE_datatype_null_enable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11498) + p.Column_name() + } + { + p.SetState(11499) + p.Datatype() + } + p.SetState(11501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(11500) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(11503) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11504) + p.Expression() + } + + } + p.SetState(11526) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPT { + { + p.SetState(11507) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(11508) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11509) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(11512) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11513) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11514) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(11517) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11524) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserSALT { + p.SetState(11521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(11520) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11523) + p.Match(PlSqlParserSALT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(11530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(11528) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11529) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(11533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(11532) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + 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 +} + +// ISize_clauseContext is an interface to support dynamic dispatch. +type ISize_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + + // IsSize_clauseContext differentiates from other interfaces. + IsSize_clauseContext() +} + +type Size_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySize_clauseContext() *Size_clauseContext { + var p = new(Size_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_size_clause + return p +} + +func InitEmptySize_clauseContext(p *Size_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_size_clause +} + +func (*Size_clauseContext) IsSize_clauseContext() {} + +func NewSize_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Size_clauseContext { + var p = new(Size_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_size_clause + + return p +} + +func (s *Size_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Size_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Size_clauseContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Size_clauseContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Size_clauseContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Size_clauseContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Size_clauseContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Size_clauseContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Size_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Size_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Size_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSize_clause(s) + } +} + +func (s *Size_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSize_clause(s) + } +} + +func (s *Size_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSize_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Size_clause() (localctx ISize_clauseContext) { + localctx = NewSize_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1170, PlSqlParserRULE_size_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11535) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11537) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1405, p.GetParserRuleContext()) == 1 { + { + p.SetState(11536) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserE_LETTER || _la == PlSqlParserG_LETTER || _la == PlSqlParserK_LETTER || _la == PlSqlParserM_LETTER || _la == PlSqlParserP_LETTER || _la == PlSqlParserT_LETTER) { + 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 +} + +// ITable_compressionContext is an interface to support dynamic dispatch. +type ITable_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMPRESS() antlr.TerminalNode + BASIC() antlr.TerminalNode + FOR() antlr.TerminalNode + OLTP() antlr.TerminalNode + QUERY() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + NOCOMPRESS() antlr.TerminalNode + + // IsTable_compressionContext differentiates from other interfaces. + IsTable_compressionContext() +} + +type Table_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_compressionContext() *Table_compressionContext { + var p = new(Table_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_compression + return p +} + +func InitEmptyTable_compressionContext(p *Table_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_compression +} + +func (*Table_compressionContext) IsTable_compressionContext() {} + +func NewTable_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_compressionContext { + var p = new(Table_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_compression + + return p +} + +func (s *Table_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Table_compressionContext) BASIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASIC, 0) +} + +func (s *Table_compressionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Table_compressionContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Table_compressionContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Table_compressionContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Table_compressionContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Table_compressionContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Table_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Table_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_compression(s) + } +} + +func (s *Table_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_compression(s) + } +} + +func (s *Table_compressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_compression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_compression() (localctx ITable_compressionContext) { + localctx = NewTable_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1172, PlSqlParserRULE_table_compression) + var _la int + + p.SetState(11552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11539) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11549) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1408, p.GetParserRuleContext()) == 1 { + { + p.SetState(11540) + p.Match(PlSqlParserBASIC) + 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(), 1408, p.GetParserRuleContext()) == 2 { + { + p.SetState(11541) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOLTP: + { + p.SetState(11542) + p.Match(PlSqlParserOLTP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARCHIVE, PlSqlParserQUERY: + { + p.SetState(11543) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserARCHIVE || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIGH || _la == PlSqlParserLOW { + { + p.SetState(11544) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11551) + p.Match(PlSqlParserNOCOMPRESS) + 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 +} + +// IInmemory_table_clauseContext is an interface to support dynamic dispatch. +type IInmemory_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllInmemory_column_clause() []IInmemory_column_clauseContext + Inmemory_column_clause(i int) IInmemory_column_clauseContext + INMEMORY() antlr.TerminalNode + NO() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + + // IsInmemory_table_clauseContext differentiates from other interfaces. + IsInmemory_table_clauseContext() +} + +type Inmemory_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_table_clauseContext() *Inmemory_table_clauseContext { + var p = new(Inmemory_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause + return p +} + +func InitEmptyInmemory_table_clauseContext(p *Inmemory_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause +} + +func (*Inmemory_table_clauseContext) IsInmemory_table_clauseContext() {} + +func NewInmemory_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_table_clauseContext { + var p = new(Inmemory_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_table_clause + + return p +} + +func (s *Inmemory_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_table_clauseContext) AllInmemory_column_clause() []IInmemory_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_column_clauseContext); ok { + len++ + } + } + + tst := make([]IInmemory_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_column_clauseContext); ok { + tst[i] = t.(IInmemory_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Inmemory_table_clauseContext) Inmemory_column_clause(i int) IInmemory_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_column_clauseContext) +} + +func (s *Inmemory_table_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmemory_table_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_table_clauseContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Inmemory_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_table_clause(s) + } +} + +func (s *Inmemory_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_table_clause(s) + } +} + +func (s *Inmemory_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_table_clause() (localctx IInmemory_table_clauseContext) { + localctx = NewInmemory_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1174, PlSqlParserRULE_inmemory_table_clause) + var _alt int + + p.SetState(11573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1414, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(11555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(11554) + p.Inmemory_column_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11557) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1410, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + { + p.SetState(11559) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11561) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1411, p.GetParserRuleContext()) == 1 { + { + p.SetState(11560) + p.Inmemory_attributes() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + { + p.SetState(11563) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11564) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1413, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(11567) + p.Inmemory_column_clause() + } + + } + p.SetState(11572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1413, 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 +} + +// IInmemory_attributesContext is an interface to support dynamic dispatch. +type IInmemory_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Inmemory_memcompress() IInmemory_memcompressContext + Inmemory_priority() IInmemory_priorityContext + Inmemory_distribute() IInmemory_distributeContext + Inmemory_duplicate() IInmemory_duplicateContext + + // IsInmemory_attributesContext differentiates from other interfaces. + IsInmemory_attributesContext() +} + +type Inmemory_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_attributesContext() *Inmemory_attributesContext { + var p = new(Inmemory_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_attributes + return p +} + +func InitEmptyInmemory_attributesContext(p *Inmemory_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_attributes +} + +func (*Inmemory_attributesContext) IsInmemory_attributesContext() {} + +func NewInmemory_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_attributesContext { + var p = new(Inmemory_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_attributes + + return p +} + +func (s *Inmemory_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_attributesContext) Inmemory_memcompress() IInmemory_memcompressContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Inmemory_attributesContext) Inmemory_priority() IInmemory_priorityContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_priorityContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_priorityContext) +} + +func (s *Inmemory_attributesContext) Inmemory_distribute() IInmemory_distributeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_distributeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_distributeContext) +} + +func (s *Inmemory_attributesContext) Inmemory_duplicate() IInmemory_duplicateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_duplicateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_duplicateContext) +} + +func (s *Inmemory_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_attributes(s) + } +} + +func (s *Inmemory_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_attributes(s) + } +} + +func (s *Inmemory_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_attributes() (localctx IInmemory_attributesContext) { + localctx = NewInmemory_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1176, PlSqlParserRULE_inmemory_attributes) + p.SetState(11597) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1421, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11575) + p.Inmemory_memcompress() + } + p.SetState(11577) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1415, p.GetParserRuleContext()) == 1 { + { + p.SetState(11576) + p.Inmemory_priority() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11580) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1416, p.GetParserRuleContext()) == 1 { + { + p.SetState(11579) + p.Inmemory_distribute() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11583) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1417, p.GetParserRuleContext()) == 1 { + { + p.SetState(11582) + p.Inmemory_duplicate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11585) + p.Inmemory_priority() + } + p.SetState(11587) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1418, p.GetParserRuleContext()) == 1 { + { + p.SetState(11586) + p.Inmemory_distribute() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11590) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1419, p.GetParserRuleContext()) == 1 { + { + p.SetState(11589) + p.Inmemory_duplicate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11592) + p.Inmemory_distribute() + } + p.SetState(11594) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1420, p.GetParserRuleContext()) == 1 { + { + p.SetState(11593) + p.Inmemory_duplicate() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11596) + p.Inmemory_duplicate() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_memcompressContext is an interface to support dynamic dispatch. +type IInmemory_memcompressContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMCOMPRESS() antlr.TerminalNode + FOR() antlr.TerminalNode + DML() antlr.TerminalNode + QUERY() antlr.TerminalNode + CAPACITY() antlr.TerminalNode + LOW() antlr.TerminalNode + HIGH() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmemory_memcompressContext differentiates from other interfaces. + IsInmemory_memcompressContext() +} + +type Inmemory_memcompressContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_memcompressContext() *Inmemory_memcompressContext { + var p = new(Inmemory_memcompressContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress + return p +} + +func InitEmptyInmemory_memcompressContext(p *Inmemory_memcompressContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress +} + +func (*Inmemory_memcompressContext) IsInmemory_memcompressContext() {} + +func NewInmemory_memcompressContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_memcompressContext { + var p = new(Inmemory_memcompressContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_memcompress + + return p +} + +func (s *Inmemory_memcompressContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_memcompressContext) MEMCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMCOMPRESS, 0) +} + +func (s *Inmemory_memcompressContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Inmemory_memcompressContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Inmemory_memcompressContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Inmemory_memcompressContext) CAPACITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPACITY, 0) +} + +func (s *Inmemory_memcompressContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Inmemory_memcompressContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Inmemory_memcompressContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_memcompressContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_memcompressContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_memcompressContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_memcompress(s) + } +} + +func (s *Inmemory_memcompressContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_memcompress(s) + } +} + +func (s *Inmemory_memcompressContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_memcompress(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_memcompress() (localctx IInmemory_memcompressContext) { + localctx = NewInmemory_memcompressContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1178, PlSqlParserRULE_inmemory_memcompress) + var _la int + + p.SetState(11610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMEMCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11599) + p.Match(PlSqlParserMEMCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11600) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDML: + { + p.SetState(11601) + p.Match(PlSqlParserDML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCAPACITY, PlSqlParserQUERY: + { + p.SetState(11602) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCAPACITY || _la == PlSqlParserQUERY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(11604) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1422, p.GetParserRuleContext()) == 1 { + { + p.SetState(11603) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11608) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11609) + p.Match(PlSqlParserMEMCOMPRESS) + 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 +} + +// IInmemory_priorityContext is an interface to support dynamic dispatch. +type IInmemory_priorityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIORITY() antlr.TerminalNode + NONE() antlr.TerminalNode + LOW() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + HIGH() antlr.TerminalNode + CRITICAL() antlr.TerminalNode + + // IsInmemory_priorityContext differentiates from other interfaces. + IsInmemory_priorityContext() +} + +type Inmemory_priorityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_priorityContext() *Inmemory_priorityContext { + var p = new(Inmemory_priorityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_priority + return p +} + +func InitEmptyInmemory_priorityContext(p *Inmemory_priorityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_priority +} + +func (*Inmemory_priorityContext) IsInmemory_priorityContext() {} + +func NewInmemory_priorityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_priorityContext { + var p = new(Inmemory_priorityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_priority + + return p +} + +func (s *Inmemory_priorityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_priorityContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIORITY, 0) +} + +func (s *Inmemory_priorityContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Inmemory_priorityContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Inmemory_priorityContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Inmemory_priorityContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Inmemory_priorityContext) CRITICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRITICAL, 0) +} + +func (s *Inmemory_priorityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_priorityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_priorityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_priority(s) + } +} + +func (s *Inmemory_priorityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_priority(s) + } +} + +func (s *Inmemory_priorityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_priority(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_priority() (localctx IInmemory_priorityContext) { + localctx = NewInmemory_priorityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1180, PlSqlParserRULE_inmemory_priority) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11612) + p.Match(PlSqlParserPRIORITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11613) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCRITICAL || _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM || _la == PlSqlParserNONE) { + 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 +} + +// IInmemory_distributeContext is an interface to support dynamic dispatch. +type IInmemory_distributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISTRIBUTE() antlr.TerminalNode + AUTO() antlr.TerminalNode + BY() antlr.TerminalNode + FOR() antlr.TerminalNode + SERVICE() antlr.TerminalNode + ROWID() antlr.TerminalNode + RANGE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ALL() antlr.TerminalNode + Identifier() IIdentifierContext + NONE() antlr.TerminalNode + + // IsInmemory_distributeContext differentiates from other interfaces. + IsInmemory_distributeContext() +} + +type Inmemory_distributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_distributeContext() *Inmemory_distributeContext { + var p = new(Inmemory_distributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_distribute + return p +} + +func InitEmptyInmemory_distributeContext(p *Inmemory_distributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_distribute +} + +func (*Inmemory_distributeContext) IsInmemory_distributeContext() {} + +func NewInmemory_distributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_distributeContext { + var p = new(Inmemory_distributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_distribute + + return p +} + +func (s *Inmemory_distributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_distributeContext) DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTE, 0) +} + +func (s *Inmemory_distributeContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Inmemory_distributeContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Inmemory_distributeContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Inmemory_distributeContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Inmemory_distributeContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Inmemory_distributeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Inmemory_distributeContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Inmemory_distributeContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Inmemory_distributeContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Inmemory_distributeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Inmemory_distributeContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Inmemory_distributeContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Inmemory_distributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_distributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_distributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_distribute(s) + } +} + +func (s *Inmemory_distributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_distribute(s) + } +} + +func (s *Inmemory_distributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_distribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_distribute() (localctx IInmemory_distributeContext) { + localctx = NewInmemory_distributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1182, PlSqlParserRULE_inmemory_distribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11615) + p.Match(PlSqlParserDISTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11624) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1426, p.GetParserRuleContext()) == 1 { + { + p.SetState(11616) + p.Match(PlSqlParserAUTO) + 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(), 1426, p.GetParserRuleContext()) == 2 { + { + p.SetState(11617) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserROWID: + { + p.SetState(11618) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11619) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPARTITION: + { + p.SetState(11620) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(11621) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11634) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1428, p.GetParserRuleContext()) == 1 { + { + p.SetState(11626) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11627) + p.Match(PlSqlParserSERVICE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1427, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11628) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11629) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11630) + p.Identifier() + } + + case 4: + { + p.SetState(11631) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInmemory_duplicateContext is an interface to support dynamic dispatch. +type IInmemory_duplicateContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DUPLICATE() antlr.TerminalNode + ALL() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsInmemory_duplicateContext differentiates from other interfaces. + IsInmemory_duplicateContext() +} + +type Inmemory_duplicateContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_duplicateContext() *Inmemory_duplicateContext { + var p = new(Inmemory_duplicateContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate + return p +} + +func InitEmptyInmemory_duplicateContext(p *Inmemory_duplicateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate +} + +func (*Inmemory_duplicateContext) IsInmemory_duplicateContext() {} + +func NewInmemory_duplicateContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_duplicateContext { + var p = new(Inmemory_duplicateContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_duplicate + + return p +} + +func (s *Inmemory_duplicateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_duplicateContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATE, 0) +} + +func (s *Inmemory_duplicateContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Inmemory_duplicateContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_duplicateContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_duplicateContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_duplicateContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_duplicate(s) + } +} + +func (s *Inmemory_duplicateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_duplicate(s) + } +} + +func (s *Inmemory_duplicateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_duplicate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_duplicate() (localctx IInmemory_duplicateContext) { + localctx = NewInmemory_duplicateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1184, PlSqlParserRULE_inmemory_duplicate) + p.SetState(11642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDUPLICATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11636) + p.Match(PlSqlParserDUPLICATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11638) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1429, p.GetParserRuleContext()) == 1 { + { + p.SetState(11637) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11640) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11641) + p.Match(PlSqlParserDUPLICATE) + 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 +} + +// IInmemory_column_clauseContext is an interface to support dynamic dispatch. +type IInmemory_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + NO() antlr.TerminalNode + Inmemory_memcompress() IInmemory_memcompressContext + + // IsInmemory_column_clauseContext differentiates from other interfaces. + IsInmemory_column_clauseContext() +} + +type Inmemory_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInmemory_column_clauseContext() *Inmemory_column_clauseContext { + var p = new(Inmemory_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause + return p +} + +func InitEmptyInmemory_column_clauseContext(p *Inmemory_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause +} + +func (*Inmemory_column_clauseContext) IsInmemory_column_clauseContext() {} + +func NewInmemory_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Inmemory_column_clauseContext { + var p = new(Inmemory_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_inmemory_column_clause + + return p +} + +func (s *Inmemory_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Inmemory_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Inmemory_column_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 *Inmemory_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Inmemory_column_clauseContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Inmemory_column_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Inmemory_column_clauseContext) Inmemory_memcompress() IInmemory_memcompressContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Inmemory_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Inmemory_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Inmemory_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInmemory_column_clause(s) + } +} + +func (s *Inmemory_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInmemory_column_clause(s) + } +} + +func (s *Inmemory_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInmemory_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Inmemory_column_clause() (localctx IInmemory_column_clauseContext) { + localctx = NewInmemory_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1186, PlSqlParserRULE_inmemory_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11650) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINMEMORY: + { + p.SetState(11644) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMEMCOMPRESS || _la == PlSqlParserNO { + { + p.SetState(11645) + p.Inmemory_memcompress() + } + + } + + case PlSqlParserNO: + { + p.SetState(11648) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11649) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(11652) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11653) + p.Column_list() + } + { + p.SetState(11654) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPhysical_attributes_clauseContext is an interface to support dynamic dispatch. +type IPhysical_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetPctfree returns the pctfree token. + GetPctfree() antlr.Token + + // GetPctused returns the pctused token. + GetPctused() antlr.Token + + // GetInittrans returns the inittrans token. + GetInittrans() antlr.Token + + // GetMaxtrans returns the maxtrans token. + GetMaxtrans() antlr.Token + + // SetPctfree sets the pctfree token. + SetPctfree(antlr.Token) + + // SetPctused sets the pctused token. + SetPctused(antlr.Token) + + // SetInittrans sets the inittrans token. + SetInittrans(antlr.Token) + + // SetMaxtrans sets the maxtrans token. + SetMaxtrans(antlr.Token) + + // Getter signatures + AllPCTFREE() []antlr.TerminalNode + PCTFREE(i int) antlr.TerminalNode + AllPCTUSED() []antlr.TerminalNode + PCTUSED(i int) antlr.TerminalNode + AllINITRANS() []antlr.TerminalNode + INITRANS(i int) antlr.TerminalNode + AllMAXTRANS() []antlr.TerminalNode + MAXTRANS(i int) antlr.TerminalNode + AllCOMPUTE() []antlr.TerminalNode + COMPUTE(i int) antlr.TerminalNode + AllSTATISTICS() []antlr.TerminalNode + STATISTICS(i int) antlr.TerminalNode + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + AllCompute_clauses() []ICompute_clausesContext + Compute_clauses(i int) ICompute_clausesContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + + // IsPhysical_attributes_clauseContext differentiates from other interfaces. + IsPhysical_attributes_clauseContext() +} + +type Physical_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + pctfree antlr.Token + pctused antlr.Token + inittrans antlr.Token + maxtrans antlr.Token +} + +func NewEmptyPhysical_attributes_clauseContext() *Physical_attributes_clauseContext { + var p = new(Physical_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause + return p +} + +func InitEmptyPhysical_attributes_clauseContext(p *Physical_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause +} + +func (*Physical_attributes_clauseContext) IsPhysical_attributes_clauseContext() {} + +func NewPhysical_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Physical_attributes_clauseContext { + var p = new(Physical_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_physical_attributes_clause + + return p +} + +func (s *Physical_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Physical_attributes_clauseContext) GetPctfree() antlr.Token { return s.pctfree } + +func (s *Physical_attributes_clauseContext) GetPctused() antlr.Token { return s.pctused } + +func (s *Physical_attributes_clauseContext) GetInittrans() antlr.Token { return s.inittrans } + +func (s *Physical_attributes_clauseContext) GetMaxtrans() antlr.Token { return s.maxtrans } + +func (s *Physical_attributes_clauseContext) SetPctfree(v antlr.Token) { s.pctfree = v } + +func (s *Physical_attributes_clauseContext) SetPctused(v antlr.Token) { s.pctused = v } + +func (s *Physical_attributes_clauseContext) SetInittrans(v antlr.Token) { s.inittrans = v } + +func (s *Physical_attributes_clauseContext) SetMaxtrans(v antlr.Token) { s.maxtrans = v } + +func (s *Physical_attributes_clauseContext) AllPCTFREE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTFREE) +} + +func (s *Physical_attributes_clauseContext) PCTFREE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTFREE, i) +} + +func (s *Physical_attributes_clauseContext) AllPCTUSED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTUSED) +} + +func (s *Physical_attributes_clauseContext) PCTUSED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, i) +} + +func (s *Physical_attributes_clauseContext) AllINITRANS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITRANS) +} + +func (s *Physical_attributes_clauseContext) INITRANS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITRANS, i) +} + +func (s *Physical_attributes_clauseContext) AllMAXTRANS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXTRANS) +} + +func (s *Physical_attributes_clauseContext) MAXTRANS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXTRANS, i) +} + +func (s *Physical_attributes_clauseContext) AllCOMPUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMPUTE) +} + +func (s *Physical_attributes_clauseContext) COMPUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, i) +} + +func (s *Physical_attributes_clauseContext) AllSTATISTICS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTATISTICS) +} + +func (s *Physical_attributes_clauseContext) STATISTICS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, i) +} + +func (s *Physical_attributes_clauseContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Physical_attributes_clauseContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Physical_attributes_clauseContext) AllCompute_clauses() []ICompute_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICompute_clausesContext); ok { + len++ + } + } + + tst := make([]ICompute_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICompute_clausesContext); ok { + tst[i] = t.(ICompute_clausesContext) + i++ + } + } + + return tst +} + +func (s *Physical_attributes_clauseContext) Compute_clauses(i int) ICompute_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompute_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICompute_clausesContext) +} + +func (s *Physical_attributes_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Physical_attributes_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Physical_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Physical_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Physical_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhysical_attributes_clause(s) + } +} + +func (s *Physical_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhysical_attributes_clause(s) + } +} + +func (s *Physical_attributes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPhysical_attributes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Physical_attributes_clause() (localctx IPhysical_attributes_clauseContext) { + localctx = NewPhysical_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1188, PlSqlParserRULE_physical_attributes_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(11668) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1433, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11656) + p.Match(PlSqlParserPCTFREE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11657) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).pctfree = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11658) + p.Match(PlSqlParserPCTUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11659) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).pctused = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11660) + p.Match(PlSqlParserINITRANS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11661) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).inittrans = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(11662) + p.Match(PlSqlParserMAXTRANS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11663) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Physical_attributes_clauseContext).maxtrans = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(11664) + p.Match(PlSqlParserCOMPUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11665) + p.Match(PlSqlParserSTATISTICS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(11666) + p.Storage_clause() + } + + case 7: + { + p.SetState(11667) + p.Compute_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11670) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1434, 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 +} + +// IStorage_clauseContext is an interface to support dynamic dispatch. +type IStorage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMinextents returns the minextents token. + GetMinextents() antlr.Token + + // GetPctincrease returns the pctincrease token. + GetPctincrease() antlr.Token + + // GetFreelists returns the freelists token. + GetFreelists() antlr.Token + + // GetFreelist_groups returns the freelist_groups token. + GetFreelist_groups() antlr.Token + + // SetMinextents sets the minextents token. + SetMinextents(antlr.Token) + + // SetPctincrease sets the pctincrease token. + SetPctincrease(antlr.Token) + + // SetFreelists sets the freelists token. + SetFreelists(antlr.Token) + + // SetFreelist_groups sets the freelist_groups token. + SetFreelist_groups(antlr.Token) + + // GetInitial_size returns the initial_size rule contexts. + GetInitial_size() ISize_clauseContext + + // GetNext_size returns the next_size rule contexts. + GetNext_size() ISize_clauseContext + + // SetInitial_size sets the initial_size rule contexts. + SetInitial_size(ISize_clauseContext) + + // SetNext_size sets the next_size rule contexts. + SetNext_size(ISize_clauseContext) + + // Getter signatures + STORAGE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllINITIAL() []antlr.TerminalNode + INITIAL(i int) antlr.TerminalNode + AllNEXT() []antlr.TerminalNode + NEXT(i int) antlr.TerminalNode + AllMINEXTENTS() []antlr.TerminalNode + MINEXTENTS(i int) antlr.TerminalNode + AllMAXEXTENTS() []antlr.TerminalNode + MAXEXTENTS(i int) antlr.TerminalNode + AllPCTINCREASE() []antlr.TerminalNode + PCTINCREASE(i int) antlr.TerminalNode + AllFREELISTS() []antlr.TerminalNode + FREELISTS(i int) antlr.TerminalNode + AllFREELIST() []antlr.TerminalNode + FREELIST(i int) antlr.TerminalNode + AllGROUPS() []antlr.TerminalNode + GROUPS(i int) antlr.TerminalNode + AllOPTIMAL() []antlr.TerminalNode + OPTIMAL(i int) antlr.TerminalNode + AllBUFFER_POOL() []antlr.TerminalNode + BUFFER_POOL(i int) antlr.TerminalNode + AllFLASH_CACHE() []antlr.TerminalNode + FLASH_CACHE(i int) antlr.TerminalNode + AllCELL_FLASH_CACHE() []antlr.TerminalNode + CELL_FLASH_CACHE(i int) antlr.TerminalNode + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllKEEP() []antlr.TerminalNode + KEEP(i int) antlr.TerminalNode + AllRECYCLE() []antlr.TerminalNode + RECYCLE(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllNONE() []antlr.TerminalNode + NONE(i int) antlr.TerminalNode + AllUNLIMITED() []antlr.TerminalNode + UNLIMITED(i int) antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + + // IsStorage_clauseContext differentiates from other interfaces. + IsStorage_clauseContext() +} + +type Storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + initial_size ISize_clauseContext + next_size ISize_clauseContext + minextents antlr.Token + pctincrease antlr.Token + freelists antlr.Token + freelist_groups antlr.Token +} + +func NewEmptyStorage_clauseContext() *Storage_clauseContext { + var p = new(Storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_clause + return p +} + +func InitEmptyStorage_clauseContext(p *Storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_storage_clause +} + +func (*Storage_clauseContext) IsStorage_clauseContext() {} + +func NewStorage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Storage_clauseContext { + var p = new(Storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_storage_clause + + return p +} + +func (s *Storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Storage_clauseContext) GetMinextents() antlr.Token { return s.minextents } + +func (s *Storage_clauseContext) GetPctincrease() antlr.Token { return s.pctincrease } + +func (s *Storage_clauseContext) GetFreelists() antlr.Token { return s.freelists } + +func (s *Storage_clauseContext) GetFreelist_groups() antlr.Token { return s.freelist_groups } + +func (s *Storage_clauseContext) SetMinextents(v antlr.Token) { s.minextents = v } + +func (s *Storage_clauseContext) SetPctincrease(v antlr.Token) { s.pctincrease = v } + +func (s *Storage_clauseContext) SetFreelists(v antlr.Token) { s.freelists = v } + +func (s *Storage_clauseContext) SetFreelist_groups(v antlr.Token) { s.freelist_groups = v } + +func (s *Storage_clauseContext) GetInitial_size() ISize_clauseContext { return s.initial_size } + +func (s *Storage_clauseContext) GetNext_size() ISize_clauseContext { return s.next_size } + +func (s *Storage_clauseContext) SetInitial_size(v ISize_clauseContext) { s.initial_size = v } + +func (s *Storage_clauseContext) SetNext_size(v ISize_clauseContext) { s.next_size = v } + +func (s *Storage_clauseContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Storage_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Storage_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Storage_clauseContext) AllINITIAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINITIAL) +} + +func (s *Storage_clauseContext) INITIAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, i) +} + +func (s *Storage_clauseContext) AllNEXT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNEXT) +} + +func (s *Storage_clauseContext) NEXT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, i) +} + +func (s *Storage_clauseContext) AllMINEXTENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINEXTENTS) +} + +func (s *Storage_clauseContext) MINEXTENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINEXTENTS, i) +} + +func (s *Storage_clauseContext) AllMAXEXTENTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXEXTENTS) +} + +func (s *Storage_clauseContext) MAXEXTENTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXEXTENTS, i) +} + +func (s *Storage_clauseContext) AllPCTINCREASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTINCREASE) +} + +func (s *Storage_clauseContext) PCTINCREASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTINCREASE, i) +} + +func (s *Storage_clauseContext) AllFREELISTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREELISTS) +} + +func (s *Storage_clauseContext) FREELISTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELISTS, i) +} + +func (s *Storage_clauseContext) AllFREELIST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREELIST) +} + +func (s *Storage_clauseContext) FREELIST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELIST, i) +} + +func (s *Storage_clauseContext) AllGROUPS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUPS) +} + +func (s *Storage_clauseContext) GROUPS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPS, i) +} + +func (s *Storage_clauseContext) AllOPTIMAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOPTIMAL) +} + +func (s *Storage_clauseContext) OPTIMAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMAL, i) +} + +func (s *Storage_clauseContext) AllBUFFER_POOL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBUFFER_POOL) +} + +func (s *Storage_clauseContext) BUFFER_POOL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_POOL, i) +} + +func (s *Storage_clauseContext) AllFLASH_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFLASH_CACHE) +} + +func (s *Storage_clauseContext) FLASH_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASH_CACHE, i) +} + +func (s *Storage_clauseContext) AllCELL_FLASH_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCELL_FLASH_CACHE) +} + +func (s *Storage_clauseContext) CELL_FLASH_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCELL_FLASH_CACHE, i) +} + +func (s *Storage_clauseContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Storage_clauseContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Storage_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Storage_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Storage_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Storage_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Storage_clauseContext) AllKEEP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEEP) +} + +func (s *Storage_clauseContext) KEEP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, i) +} + +func (s *Storage_clauseContext) AllRECYCLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRECYCLE) +} + +func (s *Storage_clauseContext) RECYCLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLE, i) +} + +func (s *Storage_clauseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Storage_clauseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Storage_clauseContext) AllNONE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNONE) +} + +func (s *Storage_clauseContext) NONE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, i) +} + +func (s *Storage_clauseContext) AllUNLIMITED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNLIMITED) +} + +func (s *Storage_clauseContext) UNLIMITED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, i) +} + +func (s *Storage_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Storage_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStorage_clause(s) + } +} + +func (s *Storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStorage_clause(s) + } +} + +func (s *Storage_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStorage_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Storage_clause() (localctx IStorage_clauseContext) { + localctx = NewStorage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1190, PlSqlParserRULE_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11672) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11673) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBUFFER_POOL || _la == PlSqlParserCELL_FLASH_CACHE || _la == PlSqlParserENCRYPT || ((int64((_la-550)) & ^0x3f) == 0 && ((int64(1)<<(_la-550))&786433) != 0) || _la == PlSqlParserINITIAL || _la == PlSqlParserMAXEXTENTS || _la == PlSqlParserMINEXTENTS || _la == PlSqlParserNEXT || _la == PlSqlParserOPTIMAL || _la == PlSqlParserPCTINCREASE { + p.SetState(11701) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINITIAL: + { + p.SetState(11674) + p.Match(PlSqlParserINITIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11675) + + var _x = p.Size_clause() + + localctx.(*Storage_clauseContext).initial_size = _x + } + + case PlSqlParserNEXT: + { + p.SetState(11676) + p.Match(PlSqlParserNEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11677) + + var _x = p.Size_clause() + + localctx.(*Storage_clauseContext).next_size = _x + } + + case PlSqlParserMINEXTENTS: + { + p.SetState(11678) + p.Match(PlSqlParserMINEXTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11679) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Storage_clauseContext).minextents = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Storage_clauseContext).minextents = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserMAXEXTENTS: + { + p.SetState(11680) + p.Match(PlSqlParserMAXEXTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11681) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Storage_clauseContext).minextents = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNLIMITED || _la == PlSqlParserUNSIGNED_INTEGER) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Storage_clauseContext).minextents = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserPCTINCREASE: + { + p.SetState(11682) + p.Match(PlSqlParserPCTINCREASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11683) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).pctincrease = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREELISTS: + { + p.SetState(11684) + p.Match(PlSqlParserFREELISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11685) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).freelists = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREELIST: + { + p.SetState(11686) + p.Match(PlSqlParserFREELIST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11687) + p.Match(PlSqlParserGROUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11688) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Storage_clauseContext).freelist_groups = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOPTIMAL: + { + p.SetState(11689) + p.Match(PlSqlParserOPTIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11692) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(11690) + p.Size_clause() + } + + case PlSqlParserNULL_: + { + p.SetState(11691) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserBUFFER_POOL: + { + p.SetState(11694) + p.Match(PlSqlParserBUFFER_POOL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11695) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserRECYCLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserFLASH_CACHE: + { + p.SetState(11696) + p.Match(PlSqlParserFLASH_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11697) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserCELL_FLASH_CACHE: + { + p.SetState(11698) + p.Match(PlSqlParserCELL_FLASH_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11699) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserKEEP || _la == PlSqlParserNONE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserENCRYPT: + { + p.SetState(11700) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(11703) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11705) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeferred_segment_creationContext is an interface to support dynamic dispatch. +type IDeferred_segment_creationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + CREATION() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + + // IsDeferred_segment_creationContext differentiates from other interfaces. + IsDeferred_segment_creationContext() +} + +type Deferred_segment_creationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeferred_segment_creationContext() *Deferred_segment_creationContext { + var p = new(Deferred_segment_creationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation + return p +} + +func InitEmptyDeferred_segment_creationContext(p *Deferred_segment_creationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation +} + +func (*Deferred_segment_creationContext) IsDeferred_segment_creationContext() {} + +func NewDeferred_segment_creationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Deferred_segment_creationContext { + var p = new(Deferred_segment_creationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_deferred_segment_creation + + return p +} + +func (s *Deferred_segment_creationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Deferred_segment_creationContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Deferred_segment_creationContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Deferred_segment_creationContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Deferred_segment_creationContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Deferred_segment_creationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Deferred_segment_creationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Deferred_segment_creationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeferred_segment_creation(s) + } +} + +func (s *Deferred_segment_creationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeferred_segment_creation(s) + } +} + +func (s *Deferred_segment_creationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDeferred_segment_creation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Deferred_segment_creation() (localctx IDeferred_segment_creationContext) { + localctx = NewDeferred_segment_creationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1192, PlSqlParserRULE_deferred_segment_creation) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11707) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11708) + p.Match(PlSqlParserCREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11709) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + 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 +} + +// ISegment_attributes_clauseContext is an interface to support dynamic dispatch. +type ISegment_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + + // IsSegment_attributes_clauseContext differentiates from other interfaces. + IsSegment_attributes_clauseContext() +} + +type Segment_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptySegment_attributes_clauseContext() *Segment_attributes_clauseContext { + var p = new(Segment_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause + return p +} + +func InitEmptySegment_attributes_clauseContext(p *Segment_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause +} + +func (*Segment_attributes_clauseContext) IsSegment_attributes_clauseContext() {} + +func NewSegment_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_attributes_clauseContext { + var p = new(Segment_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_attributes_clause + + return p +} + +func (s *Segment_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_attributes_clauseContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Segment_attributes_clauseContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Segment_attributes_clauseContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Segment_attributes_clauseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Segment_attributes_clauseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Segment_attributes_clauseContext) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Segment_attributes_clauseContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Segment_attributes_clauseContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Segment_attributes_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Segment_attributes_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Segment_attributes_clauseContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSET) +} + +func (s *Segment_attributes_clauseContext) SET(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, i) +} + +func (s *Segment_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_attributes_clause(s) + } +} + +func (s *Segment_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_attributes_clause(s) + } +} + +func (s *Segment_attributes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSegment_attributes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Segment_attributes_clause() (localctx ISegment_attributes_clauseContext) { + localctx = NewSegment_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1194, PlSqlParserRULE_segment_attributes_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(11722) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(11711) + p.Physical_attributes_clause() + } + + case PlSqlParserTABLESPACE: + { + p.SetState(11712) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1439, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11713) + + var _x = p.Id_expression() + + localctx.(*Segment_attributes_clauseContext).tablespace_name = _x + } + + case 2: + p.SetState(11715) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1438, p.GetParserRuleContext()) == 1 { + { + p.SetState(11714) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11717) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(11720) + p.Table_compression() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(11721) + p.Logging_clause() + } + + 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 + } + + p.SetState(11724) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1441, 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 +} + +// IPhysical_propertiesContext is an interface to support dynamic dispatch. +type IPhysical_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Segment_attributes_clause() ISegment_attributes_clauseContext + Deferred_segment_creation() IDeferred_segment_creationContext + Table_compression() ITable_compressionContext + Inmemory_table_clause() IInmemory_table_clauseContext + Ilm_clause() IIlm_clauseContext + ORGANIZATION() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + PARTITION() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + External_table_clause() IExternal_table_clauseContext + HEAP() antlr.TerminalNode + Heap_org_table_clause() IHeap_org_table_clauseContext + INDEX() antlr.TerminalNode + Index_org_table_clause() IIndex_org_table_clauseContext + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPhysical_propertiesContext differentiates from other interfaces. + IsPhysical_propertiesContext() +} + +type Physical_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPhysical_propertiesContext() *Physical_propertiesContext { + var p = new(Physical_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_properties + return p +} + +func InitEmptyPhysical_propertiesContext(p *Physical_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_physical_properties +} + +func (*Physical_propertiesContext) IsPhysical_propertiesContext() {} + +func NewPhysical_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Physical_propertiesContext { + var p = new(Physical_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_physical_properties + + return p +} + +func (s *Physical_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Physical_propertiesContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Physical_propertiesContext) Deferred_segment_creation() IDeferred_segment_creationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeferred_segment_creationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeferred_segment_creationContext) +} + +func (s *Physical_propertiesContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Physical_propertiesContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Physical_propertiesContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Physical_propertiesContext) ORGANIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORGANIZATION, 0) +} + +func (s *Physical_propertiesContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Physical_propertiesContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Physical_propertiesContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Physical_propertiesContext) External_table_clause() IExternal_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_clauseContext) +} + +func (s *Physical_propertiesContext) HEAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEAP, 0) +} + +func (s *Physical_propertiesContext) Heap_org_table_clause() IHeap_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHeap_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHeap_org_table_clauseContext) +} + +func (s *Physical_propertiesContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Physical_propertiesContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Physical_propertiesContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Physical_propertiesContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Physical_propertiesContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Physical_propertiesContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Physical_propertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Physical_propertiesContext) 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 *Physical_propertiesContext) 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 *Physical_propertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Physical_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Physical_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Physical_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Physical_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Physical_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPhysical_properties(s) + } +} + +func (s *Physical_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPhysical_properties(s) + } +} + +func (s *Physical_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPhysical_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Physical_properties() (localctx IPhysical_propertiesContext) { + localctx = NewPhysical_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1196, PlSqlParserRULE_physical_properties) + var _la int + + p.SetState(11780) + 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(11727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEGMENT { + { + p.SetState(11726) + p.Deferred_segment_creation() + } + + } + { + p.SetState(11729) + p.Segment_attributes_clause() + } + p.SetState(11731) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1443, p.GetParserRuleContext()) == 1 { + { + p.SetState(11730) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11734) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1444, p.GetParserRuleContext()) == 1 { + { + p.SetState(11733) + p.Inmemory_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11737) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserILM { + { + p.SetState(11736) + p.Ilm_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(11740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEGMENT { + { + p.SetState(11739) + p.Deferred_segment_creation() + } + + } + p.SetState(11765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserORGANIZATION: + { + p.SetState(11742) + p.Match(PlSqlParserORGANIZATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserHEAP: + { + p.SetState(11743) + p.Match(PlSqlParserHEAP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11745) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1447, p.GetParserRuleContext()) == 1 { + { + p.SetState(11744) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11747) + p.Heap_org_table_clause() + } + + case PlSqlParserINDEX: + { + p.SetState(11748) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11750) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1448, p.GetParserRuleContext()) == 1 { + { + p.SetState(11749) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(11752) + p.Index_org_table_clause() + } + + case PlSqlParserEXTERNAL: + { + p.SetState(11753) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11754) + p.External_table_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserEXTERNAL: + { + p.SetState(11757) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11758) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11759) + p.Match(PlSqlParserATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11760) + p.External_table_clause() + } + p.SetState(11763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREJECT { + { + p.SetState(11761) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11762) + p.Match(PlSqlParserLIMIT) + 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(11767) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11768) + p.Cluster_name() + } + { + p.SetState(11769) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11770) + p.Column_name() + } + p.SetState(11775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11771) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11772) + p.Column_name() + } + + p.SetState(11777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11778) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_clauseContext is an interface to support dynamic dispatch. +type IIlm_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ILM() antlr.TerminalNode + ADD() antlr.TerminalNode + POLICY() antlr.TerminalNode + Ilm_policy_clause() IIlm_policy_clauseContext + DELETE_ALL() antlr.TerminalNode + ENABLE_ALL() antlr.TerminalNode + DISABLE_ALL() antlr.TerminalNode + DELETE() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsIlm_clauseContext differentiates from other interfaces. + IsIlm_clauseContext() +} + +type Ilm_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_clauseContext() *Ilm_clauseContext { + var p = new(Ilm_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_clause + return p +} + +func InitEmptyIlm_clauseContext(p *Ilm_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_clause +} + +func (*Ilm_clauseContext) IsIlm_clauseContext() {} + +func NewIlm_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_clauseContext { + var p = new(Ilm_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_clause + + return p +} + +func (s *Ilm_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_clauseContext) ILM() antlr.TerminalNode { + return s.GetToken(PlSqlParserILM, 0) +} + +func (s *Ilm_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Ilm_clauseContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Ilm_clauseContext) Ilm_policy_clause() IIlm_policy_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_policy_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_policy_clauseContext) +} + +func (s *Ilm_clauseContext) DELETE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE_ALL, 0) +} + +func (s *Ilm_clauseContext) ENABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_ALL, 0) +} + +func (s *Ilm_clauseContext) DISABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_ALL, 0) +} + +func (s *Ilm_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Ilm_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Ilm_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Ilm_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_clause(s) + } +} + +func (s *Ilm_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_clause(s) + } +} + +func (s *Ilm_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_clause() (localctx IIlm_clauseContext) { + localctx = NewIlm_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1198, PlSqlParserRULE_ilm_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11782) + p.Match(PlSqlParserILM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11792) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + { + p.SetState(11783) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11784) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11785) + p.Ilm_policy_clause() + } + + case PlSqlParserDELETE, PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(11786) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11787) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11788) + p.Ilm_policy_clause() + } + + case PlSqlParserDELETE_ALL: + { + p.SetState(11789) + p.Match(PlSqlParserDELETE_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserENABLE_ALL: + { + p.SetState(11790) + p.Match(PlSqlParserENABLE_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE_ALL: + { + p.SetState(11791) + p.Match(PlSqlParserDISABLE_ALL) + 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 +} + +// IIlm_policy_clauseContext is an interface to support dynamic dispatch. +type IIlm_policy_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ilm_compression_policy() IIlm_compression_policyContext + Ilm_tiering_policy() IIlm_tiering_policyContext + Ilm_inmemory_policy() IIlm_inmemory_policyContext + + // IsIlm_policy_clauseContext differentiates from other interfaces. + IsIlm_policy_clauseContext() +} + +type Ilm_policy_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_policy_clauseContext() *Ilm_policy_clauseContext { + var p = new(Ilm_policy_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause + return p +} + +func InitEmptyIlm_policy_clauseContext(p *Ilm_policy_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause +} + +func (*Ilm_policy_clauseContext) IsIlm_policy_clauseContext() {} + +func NewIlm_policy_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_policy_clauseContext { + var p = new(Ilm_policy_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_policy_clause + + return p +} + +func (s *Ilm_policy_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_policy_clauseContext) Ilm_compression_policy() IIlm_compression_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_compression_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_compression_policyContext) +} + +func (s *Ilm_policy_clauseContext) Ilm_tiering_policy() IIlm_tiering_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_tiering_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_tiering_policyContext) +} + +func (s *Ilm_policy_clauseContext) Ilm_inmemory_policy() IIlm_inmemory_policyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_inmemory_policyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_inmemory_policyContext) +} + +func (s *Ilm_policy_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_policy_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_policy_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_policy_clause(s) + } +} + +func (s *Ilm_policy_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_policy_clause(s) + } +} + +func (s *Ilm_policy_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_policy_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_policy_clause() (localctx IIlm_policy_clauseContext) { + localctx = NewIlm_policy_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1200, PlSqlParserRULE_ilm_policy_clause) + p.SetState(11797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN, PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS, PlSqlParserROW: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11794) + p.Ilm_compression_policy() + } + + case PlSqlParserTIER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11795) + p.Ilm_tiering_policy() + } + + case PlSqlParserMODIFY, PlSqlParserNO, PlSqlParserSET: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11796) + p.Ilm_inmemory_policy() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_compression_policyContext is an interface to support dynamic dispatch. +type IIlm_compression_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_compression() ITable_compressionContext + Segment_group() ISegment_groupContext + Ilm_after_on() IIlm_after_onContext + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AFTER() antlr.TerminalNode + Ilm_time_period() IIlm_time_periodContext + OF() antlr.TerminalNode + NO() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + STORE() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + COLUMN() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + FOR() antlr.TerminalNode + QUERY() antlr.TerminalNode + + // IsIlm_compression_policyContext differentiates from other interfaces. + IsIlm_compression_policyContext() +} + +type Ilm_compression_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_compression_policyContext() *Ilm_compression_policyContext { + var p = new(Ilm_compression_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy + return p +} + +func InitEmptyIlm_compression_policyContext(p *Ilm_compression_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy +} + +func (*Ilm_compression_policyContext) IsIlm_compression_policyContext() {} + +func NewIlm_compression_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_compression_policyContext { + var p = new(Ilm_compression_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_compression_policy + + return p +} + +func (s *Ilm_compression_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_compression_policyContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Ilm_compression_policyContext) Segment_group() ISegment_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_groupContext) +} + +func (s *Ilm_compression_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_compression_policyContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Ilm_compression_policyContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Ilm_compression_policyContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Ilm_compression_policyContext) Ilm_time_period() IIlm_time_periodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_time_periodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_time_periodContext) +} + +func (s *Ilm_compression_policyContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Ilm_compression_policyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_compression_policyContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Ilm_compression_policyContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Ilm_compression_policyContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Ilm_compression_policyContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Ilm_compression_policyContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Ilm_compression_policyContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Ilm_compression_policyContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Ilm_compression_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_compression_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_compression_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_compression_policy(s) + } +} + +func (s *Ilm_compression_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_compression_policy(s) + } +} + +func (s *Ilm_compression_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_compression_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_compression_policy() (localctx IIlm_compression_policyContext) { + localctx = NewIlm_compression_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1202, PlSqlParserRULE_ilm_compression_policy) + var _la int + + p.SetState(11818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11799) + p.Table_compression() + } + { + p.SetState(11800) + p.Segment_group() + } + { + p.SetState(11801) + p.Ilm_after_on() + } + + case PlSqlParserCOLUMN, PlSqlParserROW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11803) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOLUMN || _la == PlSqlParserROW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11804) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11805) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADVANCED: + { + p.SetState(11806) + p.Match(PlSqlParserADVANCED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(11807) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11808) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + { + p.SetState(11811) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11812) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11813) + p.Ilm_time_period() + } + { + p.SetState(11814) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11815) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11816) + p.Match(PlSqlParserMODIFICATION) + 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 +} + +// IIlm_tiering_policyContext is an interface to support dynamic dispatch. +type IIlm_tiering_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIER() antlr.TerminalNode + TO() antlr.TerminalNode + Tablespace() ITablespaceContext + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + Ilm_after_on() IIlm_after_onContext + Segment_group() ISegment_groupContext + ON() antlr.TerminalNode + Function_name() IFunction_nameContext + + // IsIlm_tiering_policyContext differentiates from other interfaces. + IsIlm_tiering_policyContext() +} + +type Ilm_tiering_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_tiering_policyContext() *Ilm_tiering_policyContext { + var p = new(Ilm_tiering_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy + return p +} + +func InitEmptyIlm_tiering_policyContext(p *Ilm_tiering_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy +} + +func (*Ilm_tiering_policyContext) IsIlm_tiering_policyContext() {} + +func NewIlm_tiering_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_tiering_policyContext { + var p = new(Ilm_tiering_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_tiering_policy + + return p +} + +func (s *Ilm_tiering_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_tiering_policyContext) TIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIER, 0) +} + +func (s *Ilm_tiering_policyContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Ilm_tiering_policyContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Ilm_tiering_policyContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Ilm_tiering_policyContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Ilm_tiering_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_tiering_policyContext) Segment_group() ISegment_groupContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_groupContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_groupContext) +} + +func (s *Ilm_tiering_policyContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Ilm_tiering_policyContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Ilm_tiering_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_tiering_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_tiering_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_tiering_policy(s) + } +} + +func (s *Ilm_tiering_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_tiering_policy(s) + } +} + +func (s *Ilm_tiering_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_tiering_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_tiering_policy() (localctx IIlm_tiering_policyContext) { + localctx = NewIlm_tiering_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1204, PlSqlParserRULE_ilm_tiering_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11820) + p.Match(PlSqlParserTIER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11821) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11822) + p.Tablespace() + } + p.SetState(11836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1461, p.GetParserRuleContext()) { + case 1: + p.SetState(11824) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1458, p.GetParserRuleContext()) == 1 { + { + p.SetState(11823) + p.Segment_group() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11828) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1459, p.GetParserRuleContext()) == 1 { + { + p.SetState(11826) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11827) + p.Function_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + { + p.SetState(11830) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11831) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP || _la == PlSqlParserSEGMENT { + { + p.SetState(11832) + p.Segment_group() + } + + } + { + p.SetState(11835) + p.Ilm_after_on() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_after_onContext is an interface to support dynamic dispatch. +type IIlm_after_onContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AFTER() antlr.TerminalNode + Ilm_time_period() IIlm_time_periodContext + OF() antlr.TerminalNode + NO() antlr.TerminalNode + CREATION() antlr.TerminalNode + ACCESS() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + ON() antlr.TerminalNode + Function_name() IFunction_nameContext + + // IsIlm_after_onContext differentiates from other interfaces. + IsIlm_after_onContext() +} + +type Ilm_after_onContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_after_onContext() *Ilm_after_onContext { + var p = new(Ilm_after_onContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_after_on + return p +} + +func InitEmptyIlm_after_onContext(p *Ilm_after_onContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_after_on +} + +func (*Ilm_after_onContext) IsIlm_after_onContext() {} + +func NewIlm_after_onContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_after_onContext { + var p = new(Ilm_after_onContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_after_on + + return p +} + +func (s *Ilm_after_onContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_after_onContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Ilm_after_onContext) Ilm_time_period() IIlm_time_periodContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_time_periodContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_time_periodContext) +} + +func (s *Ilm_after_onContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Ilm_after_onContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_after_onContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Ilm_after_onContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Ilm_after_onContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Ilm_after_onContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Ilm_after_onContext) Function_name() IFunction_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_nameContext) +} + +func (s *Ilm_after_onContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_after_onContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_after_onContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_after_on(s) + } +} + +func (s *Ilm_after_onContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_after_on(s) + } +} + +func (s *Ilm_after_onContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_after_on(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_after_on() (localctx IIlm_after_onContext) { + localctx = NewIlm_after_onContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1206, PlSqlParserRULE_ilm_after_on) + var _la int + + p.SetState(11848) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserAFTER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11838) + p.Match(PlSqlParserAFTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11839) + p.Ilm_time_period() + } + { + p.SetState(11840) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11844) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + { + p.SetState(11841) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11842) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserACCESS || _la == PlSqlParserMODIFICATION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserCREATION: + { + p.SetState(11843) + p.Match(PlSqlParserCREATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11846) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11847) + p.Function_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 +} + +// ISegment_groupContext is an interface to support dynamic dispatch. +type ISegment_groupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEGMENT() antlr.TerminalNode + GROUP() antlr.TerminalNode + + // IsSegment_groupContext differentiates from other interfaces. + IsSegment_groupContext() +} + +type Segment_groupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySegment_groupContext() *Segment_groupContext { + var p = new(Segment_groupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_group + return p +} + +func InitEmptySegment_groupContext(p *Segment_groupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_segment_group +} + +func (*Segment_groupContext) IsSegment_groupContext() {} + +func NewSegment_groupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Segment_groupContext { + var p = new(Segment_groupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_segment_group + + return p +} + +func (s *Segment_groupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Segment_groupContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Segment_groupContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Segment_groupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Segment_groupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Segment_groupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSegment_group(s) + } +} + +func (s *Segment_groupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSegment_group(s) + } +} + +func (s *Segment_groupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSegment_group(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Segment_group() (localctx ISegment_groupContext) { + localctx = NewSegment_groupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1208, PlSqlParserRULE_segment_group) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11850) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGROUP || _la == PlSqlParserSEGMENT) { + 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 +} + +// IIlm_inmemory_policyContext is an interface to support dynamic dispatch. +type IIlm_inmemory_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Ilm_after_on() IIlm_after_onContext + SET() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + MODIFY() antlr.TerminalNode + Inmemory_memcompress() IInmemory_memcompressContext + NO() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Inmemory_attributes() IInmemory_attributesContext + + // IsIlm_inmemory_policyContext differentiates from other interfaces. + IsIlm_inmemory_policyContext() +} + +type Ilm_inmemory_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_inmemory_policyContext() *Ilm_inmemory_policyContext { + var p = new(Ilm_inmemory_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy + return p +} + +func InitEmptyIlm_inmemory_policyContext(p *Ilm_inmemory_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy +} + +func (*Ilm_inmemory_policyContext) IsIlm_inmemory_policyContext() {} + +func NewIlm_inmemory_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_inmemory_policyContext { + var p = new(Ilm_inmemory_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_inmemory_policy + + return p +} + +func (s *Ilm_inmemory_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_inmemory_policyContext) Ilm_after_on() IIlm_after_onContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_after_onContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_after_onContext) +} + +func (s *Ilm_inmemory_policyContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Ilm_inmemory_policyContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Ilm_inmemory_policyContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Ilm_inmemory_policyContext) Inmemory_memcompress() IInmemory_memcompressContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_memcompressContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_memcompressContext) +} + +func (s *Ilm_inmemory_policyContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Ilm_inmemory_policyContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Ilm_inmemory_policyContext) Inmemory_attributes() IInmemory_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_attributesContext) +} + +func (s *Ilm_inmemory_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_inmemory_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_inmemory_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_inmemory_policy(s) + } +} + +func (s *Ilm_inmemory_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_inmemory_policy(s) + } +} + +func (s *Ilm_inmemory_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_inmemory_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_inmemory_policy() (localctx IIlm_inmemory_policyContext) { + localctx = NewIlm_inmemory_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1210, PlSqlParserRULE_ilm_inmemory_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSET: + { + p.SetState(11852) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11853) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISTRIBUTE || _la == PlSqlParserDUPLICATE || _la == PlSqlParserMEMCOMPRESS || _la == PlSqlParserNO || _la == PlSqlParserPRIORITY { + { + p.SetState(11854) + p.Inmemory_attributes() + } + + } + + case PlSqlParserMODIFY: + { + p.SetState(11857) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11858) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11859) + p.Inmemory_memcompress() + } + + case PlSqlParserNO: + { + p.SetState(11860) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11861) + p.Match(PlSqlParserINMEMORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEGMENT { + { + p.SetState(11864) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11867) + p.Ilm_after_on() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIlm_time_periodContext is an interface to support dynamic dispatch. +type IIlm_time_periodContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric() INumericContext + DAY() antlr.TerminalNode + DAYS() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTHS() antlr.TerminalNode + YEAR() antlr.TerminalNode + YEARS() antlr.TerminalNode + + // IsIlm_time_periodContext differentiates from other interfaces. + IsIlm_time_periodContext() +} + +type Ilm_time_periodContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIlm_time_periodContext() *Ilm_time_periodContext { + var p = new(Ilm_time_periodContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_time_period + return p +} + +func InitEmptyIlm_time_periodContext(p *Ilm_time_periodContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ilm_time_period +} + +func (*Ilm_time_periodContext) IsIlm_time_periodContext() {} + +func NewIlm_time_periodContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ilm_time_periodContext { + var p = new(Ilm_time_periodContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ilm_time_period + + return p +} + +func (s *Ilm_time_periodContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ilm_time_periodContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Ilm_time_periodContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Ilm_time_periodContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Ilm_time_periodContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Ilm_time_periodContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Ilm_time_periodContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Ilm_time_periodContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Ilm_time_periodContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ilm_time_periodContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ilm_time_periodContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIlm_time_period(s) + } +} + +func (s *Ilm_time_periodContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIlm_time_period(s) + } +} + +func (s *Ilm_time_periodContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIlm_time_period(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ilm_time_period() (localctx IIlm_time_periodContext) { + localctx = NewIlm_time_periodContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1212, PlSqlParserRULE_ilm_time_period) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11869) + p.Numeric() + } + { + p.SetState(11870) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserDAYS || _la == PlSqlParserMONTH || _la == PlSqlParserMONTHS || _la == PlSqlParserYEARS || _la == PlSqlParserYEAR) { + 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 +} + +// IHeap_org_table_clauseContext is an interface to support dynamic dispatch. +type IHeap_org_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_compression() ITable_compressionContext + Inmemory_table_clause() IInmemory_table_clauseContext + Ilm_clause() IIlm_clauseContext + + // IsHeap_org_table_clauseContext differentiates from other interfaces. + IsHeap_org_table_clauseContext() +} + +type Heap_org_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHeap_org_table_clauseContext() *Heap_org_table_clauseContext { + var p = new(Heap_org_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause + return p +} + +func InitEmptyHeap_org_table_clauseContext(p *Heap_org_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause +} + +func (*Heap_org_table_clauseContext) IsHeap_org_table_clauseContext() {} + +func NewHeap_org_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Heap_org_table_clauseContext { + var p = new(Heap_org_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_heap_org_table_clause + + return p +} + +func (s *Heap_org_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Heap_org_table_clauseContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Heap_org_table_clauseContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Heap_org_table_clauseContext) Ilm_clause() IIlm_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIlm_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIlm_clauseContext) +} + +func (s *Heap_org_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Heap_org_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Heap_org_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHeap_org_table_clause(s) + } +} + +func (s *Heap_org_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHeap_org_table_clause(s) + } +} + +func (s *Heap_org_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHeap_org_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Heap_org_table_clause() (localctx IHeap_org_table_clauseContext) { + localctx = NewHeap_org_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1214, PlSqlParserRULE_heap_org_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11873) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1467, p.GetParserRuleContext()) == 1 { + { + p.SetState(11872) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11876) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1468, p.GetParserRuleContext()) == 1 { + { + p.SetState(11875) + p.Inmemory_table_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserILM { + { + p.SetState(11878) + p.Ilm_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 +} + +// IExternal_table_clauseContext is an interface to support dynamic dispatch. +type IExternal_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + External_table_data_props() IExternal_table_data_propsContext + RIGHT_PAREN() antlr.TerminalNode + TYPE() antlr.TerminalNode + Access_driver_type() IAccess_driver_typeContext + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + Inmemory_table_clause() IInmemory_table_clauseContext + Numeric() INumericContext + UNLIMITED() antlr.TerminalNode + + // IsExternal_table_clauseContext differentiates from other interfaces. + IsExternal_table_clauseContext() +} + +type External_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_clauseContext() *External_table_clauseContext { + var p = new(External_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_clause + return p +} + +func InitEmptyExternal_table_clauseContext(p *External_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_clause +} + +func (*External_table_clauseContext) IsExternal_table_clauseContext() {} + +func NewExternal_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_clauseContext { + var p = new(External_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_clause + + return p +} + +func (s *External_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *External_table_clauseContext) External_table_data_props() IExternal_table_data_propsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExternal_table_data_propsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExternal_table_data_propsContext) +} + +func (s *External_table_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *External_table_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *External_table_clauseContext) Access_driver_type() IAccess_driver_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAccess_driver_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAccess_driver_typeContext) +} + +func (s *External_table_clauseContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *External_table_clauseContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *External_table_clauseContext) Inmemory_table_clause() IInmemory_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *External_table_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *External_table_clauseContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *External_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_clause(s) + } +} + +func (s *External_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_clause(s) + } +} + +func (s *External_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExternal_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) External_table_clause() (localctx IExternal_table_clauseContext) { + localctx = NewExternal_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1216, PlSqlParserRULE_external_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11881) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11884) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(11882) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11883) + p.Access_driver_type() + } + + } + { + p.SetState(11886) + p.External_table_data_props() + } + { + p.SetState(11887) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11894) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1472, p.GetParserRuleContext()) == 1 { + { + p.SetState(11888) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11889) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(11890) + p.Numeric() + } + + case PlSqlParserUNLIMITED: + { + p.SetState(11891) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(11897) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1473, p.GetParserRuleContext()) == 1 { + { + p.SetState(11896) + p.Inmemory_table_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 +} + +// IAccess_driver_typeContext is an interface to support dynamic dispatch. +type IAccess_driver_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORACLE_LOADER() antlr.TerminalNode + ORACLE_DATAPUMP() antlr.TerminalNode + ORACLE_HDFS() antlr.TerminalNode + ORACLE_HIVE() antlr.TerminalNode + + // IsAccess_driver_typeContext differentiates from other interfaces. + IsAccess_driver_typeContext() +} + +type Access_driver_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAccess_driver_typeContext() *Access_driver_typeContext { + var p = new(Access_driver_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_access_driver_type + return p +} + +func InitEmptyAccess_driver_typeContext(p *Access_driver_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_access_driver_type +} + +func (*Access_driver_typeContext) IsAccess_driver_typeContext() {} + +func NewAccess_driver_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Access_driver_typeContext { + var p = new(Access_driver_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_access_driver_type + + return p +} + +func (s *Access_driver_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Access_driver_typeContext) ORACLE_LOADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_LOADER, 0) +} + +func (s *Access_driver_typeContext) ORACLE_DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATAPUMP, 0) +} + +func (s *Access_driver_typeContext) ORACLE_HDFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HDFS, 0) +} + +func (s *Access_driver_typeContext) ORACLE_HIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HIVE, 0) +} + +func (s *Access_driver_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Access_driver_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Access_driver_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAccess_driver_type(s) + } +} + +func (s *Access_driver_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAccess_driver_type(s) + } +} + +func (s *Access_driver_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAccess_driver_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Access_driver_type() (localctx IAccess_driver_typeContext) { + localctx = NewAccess_driver_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1218, PlSqlParserRULE_access_driver_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11899) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2255)) & ^0x3f) == 0 && ((int64(1)<<(_la-2255))&15) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExternal_table_data_propsContext is an interface to support dynamic dispatch. +type IExternal_table_data_propsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + AllDirectory_name() []IDirectory_nameContext + Directory_name(i int) IDirectory_nameContext + ACCESS() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + LOCATION() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllCOLON() []antlr.TerminalNode + COLON(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Opaque_format_spec() IOpaque_format_specContext + USING() antlr.TerminalNode + CLOB() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExternal_table_data_propsContext differentiates from other interfaces. + IsExternal_table_data_propsContext() +} + +type External_table_data_propsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExternal_table_data_propsContext() *External_table_data_propsContext { + var p = new(External_table_data_propsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_props + return p +} + +func InitEmptyExternal_table_data_propsContext(p *External_table_data_propsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_external_table_data_props +} + +func (*External_table_data_propsContext) IsExternal_table_data_propsContext() {} + +func NewExternal_table_data_propsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *External_table_data_propsContext { + var p = new(External_table_data_propsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_external_table_data_props + + return p +} + +func (s *External_table_data_propsContext) GetParser() antlr.Parser { return s.parser } + +func (s *External_table_data_propsContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *External_table_data_propsContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *External_table_data_propsContext) AllDirectory_name() []IDirectory_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDirectory_nameContext); ok { + len++ + } + } + + tst := make([]IDirectory_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDirectory_nameContext); ok { + tst[i] = t.(IDirectory_nameContext) + i++ + } + } + + return tst +} + +func (s *External_table_data_propsContext) Directory_name(i int) IDirectory_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *External_table_data_propsContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *External_table_data_propsContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *External_table_data_propsContext) LOCATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATION, 0) +} + +func (s *External_table_data_propsContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *External_table_data_propsContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *External_table_data_propsContext) AllCOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLON) +} + +func (s *External_table_data_propsContext) COLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, i) +} + +func (s *External_table_data_propsContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *External_table_data_propsContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *External_table_data_propsContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *External_table_data_propsContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *External_table_data_propsContext) Opaque_format_spec() IOpaque_format_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpaque_format_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpaque_format_specContext) +} + +func (s *External_table_data_propsContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *External_table_data_propsContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *External_table_data_propsContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *External_table_data_propsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *External_table_data_propsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *External_table_data_propsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *External_table_data_propsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *External_table_data_propsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExternal_table_data_props(s) + } +} + +func (s *External_table_data_propsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExternal_table_data_props(s) + } +} + +func (s *External_table_data_propsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExternal_table_data_props(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) External_table_data_props() (localctx IExternal_table_data_propsContext) { + localctx = NewExternal_table_data_propsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1220, PlSqlParserRULE_external_table_data_props) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(11901) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11902) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11903) + p.Directory_name() + } + + } + p.SetState(11920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACCESS { + { + p.SetState(11906) + p.Match(PlSqlParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11907) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11918) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1475, p.GetParserRuleContext()) { + case 1: + { + p.SetState(11908) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11909) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11910) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(11911) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11912) + p.Opaque_format_spec() + } + { + p.SetState(11913) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(11915) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11916) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11917) + p.Select_only_statement() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(11939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCATION { + { + p.SetState(11922) + p.Match(PlSqlParserLOCATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11923) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11924) + p.Directory_name() + } + { + p.SetState(11925) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11926) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(11927) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11928) + p.Directory_name() + } + { + p.SetState(11929) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11930) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(11936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(11937) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOpaque_format_specContext is an interface to support dynamic dispatch. +type IOpaque_format_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Record_format_info() IRecord_format_infoContext + Field_definitions() IField_definitionsContext + Column_transforms() IColumn_transformsContext + + // IsOpaque_format_specContext differentiates from other interfaces. + IsOpaque_format_specContext() +} + +type Opaque_format_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpaque_format_specContext() *Opaque_format_specContext { + var p = new(Opaque_format_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_opaque_format_spec + return p +} + +func InitEmptyOpaque_format_specContext(p *Opaque_format_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_opaque_format_spec +} + +func (*Opaque_format_specContext) IsOpaque_format_specContext() {} + +func NewOpaque_format_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Opaque_format_specContext { + var p = new(Opaque_format_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_opaque_format_spec + + return p +} + +func (s *Opaque_format_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Opaque_format_specContext) Record_format_info() IRecord_format_infoContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecord_format_infoContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecord_format_infoContext) +} + +func (s *Opaque_format_specContext) Field_definitions() IField_definitionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_definitionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_definitionsContext) +} + +func (s *Opaque_format_specContext) Column_transforms() IColumn_transformsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_transformsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_transformsContext) +} + +func (s *Opaque_format_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Opaque_format_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Opaque_format_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpaque_format_spec(s) + } +} + +func (s *Opaque_format_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpaque_format_spec(s) + } +} + +func (s *Opaque_format_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOpaque_format_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Opaque_format_spec() (localctx IOpaque_format_specContext) { + localctx = NewOpaque_format_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1222, PlSqlParserRULE_opaque_format_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11942) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRECORDS { + { + p.SetState(11941) + p.Record_format_info() + } + + } + p.SetState(11945) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFIELDS { + { + p.SetState(11944) + p.Field_definitions() + } + + } + p.SetState(11948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN { + { + p.SetState(11947) + p.Column_transforms() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecord_format_infoContext is an interface to support dynamic dispatch. +type IRecord_format_infoContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORDS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + DELIMITED() antlr.TerminalNode + BY() antlr.TerminalNode + XMLTAG() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + FIXED() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + Et_record_spec_options() IEt_record_spec_optionsContext + NEWLINE_() antlr.TerminalNode + DETECTED() antlr.TerminalNode + + // IsRecord_format_infoContext differentiates from other interfaces. + IsRecord_format_infoContext() +} + +type Record_format_infoContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecord_format_infoContext() *Record_format_infoContext { + var p = new(Record_format_infoContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_format_info + return p +} + +func InitEmptyRecord_format_infoContext(p *Record_format_infoContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_format_info +} + +func (*Record_format_infoContext) IsRecord_format_infoContext() {} + +func NewRecord_format_infoContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Record_format_infoContext { + var p = new(Record_format_infoContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_record_format_info + + return p +} + +func (s *Record_format_infoContext) GetParser() antlr.Parser { return s.parser } + +func (s *Record_format_infoContext) RECORDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS, 0) +} + +func (s *Record_format_infoContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Record_format_infoContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED, 0) +} + +func (s *Record_format_infoContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Record_format_infoContext) XMLTAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTAG, 0) +} + +func (s *Record_format_infoContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Record_format_infoContext) FIXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIXED, 0) +} + +func (s *Record_format_infoContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *Record_format_infoContext) Et_record_spec_options() IEt_record_spec_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEt_record_spec_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEt_record_spec_optionsContext) +} + +func (s *Record_format_infoContext) NEWLINE_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEWLINE_, 0) +} + +func (s *Record_format_infoContext) DETECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETECTED, 0) +} + +func (s *Record_format_infoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Record_format_infoContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Record_format_infoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecord_format_info(s) + } +} + +func (s *Record_format_infoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecord_format_info(s) + } +} + +func (s *Record_format_infoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRecord_format_info(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Record_format_info() (localctx IRecord_format_infoContext) { + localctx = NewRecord_format_infoContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1224, PlSqlParserRULE_record_format_info) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11950) + p.Match(PlSqlParserRECORDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARIABLE, PlSqlParserFIXED: + { + p.SetState(11951) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserVARIABLE || _la == PlSqlParserFIXED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11952) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDELIMITED: + { + p.SetState(11953) + p.Match(PlSqlParserDELIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11954) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNEWLINE_, PlSqlParserDETECTED: + p.SetState(11956) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDETECTED { + { + p.SetState(11955) + p.Match(PlSqlParserDETECTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11958) + p.Match(PlSqlParserNEWLINE_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHAR_STRING: + { + p.SetState(11959) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserXMLTAG: + { + p.SetState(11962) + p.Match(PlSqlParserXMLTAG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11963) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(11967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATA || ((int64((_la-760)) & ^0x3f) == 0 && ((int64(1)<<(_la-760))&9007749010554881) != 0) || _la == PlSqlParserSKIP_ || _la == PlSqlParserSTRING || ((int64((_la-2314)) & ^0x3f) == 0 && ((int64(1)<<(_la-2314))&4281271393) != 0) { + { + p.SetState(11966) + p.Et_record_spec_options() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEt_stringContext is an interface to support dynamic dispatch. +type IEt_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + DELIMITED_ID() antlr.TerminalNode + HEX_STRING_LIT() antlr.TerminalNode + + // IsEt_stringContext differentiates from other interfaces. + IsEt_stringContext() +} + +type Et_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEt_stringContext() *Et_stringContext { + var p = new(Et_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_string + return p +} + +func InitEmptyEt_stringContext(p *Et_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_string +} + +func (*Et_stringContext) IsEt_stringContext() {} + +func NewEt_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Et_stringContext { + var p = new(Et_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_et_string + + return p +} + +func (s *Et_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Et_stringContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Et_stringContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Et_stringContext) HEX_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEX_STRING_LIT, 0) +} + +func (s *Et_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Et_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Et_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEt_string(s) + } +} + +func (s *Et_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEt_string(s) + } +} + +func (s *Et_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEt_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Et_string() (localctx IEt_stringContext) { + localctx = NewEt_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1226, PlSqlParserRULE_et_string) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11969) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2367)) & ^0x3f) == 0 && ((int64(1)<<(_la-2367))&97) != 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 +} + +// IEt_record_spec_optionsContext is an interface to support dynamic dispatch. +type IEt_record_spec_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllEt_record_spec_option() []IEt_record_spec_optionContext + Et_record_spec_option(i int) IEt_record_spec_optionContext + + // IsEt_record_spec_optionsContext differentiates from other interfaces. + IsEt_record_spec_optionsContext() +} + +type Et_record_spec_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEt_record_spec_optionsContext() *Et_record_spec_optionsContext { + var p = new(Et_record_spec_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_record_spec_options + return p +} + +func InitEmptyEt_record_spec_optionsContext(p *Et_record_spec_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_record_spec_options +} + +func (*Et_record_spec_optionsContext) IsEt_record_spec_optionsContext() {} + +func NewEt_record_spec_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Et_record_spec_optionsContext { + var p = new(Et_record_spec_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_et_record_spec_options + + return p +} + +func (s *Et_record_spec_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Et_record_spec_optionsContext) AllEt_record_spec_option() []IEt_record_spec_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEt_record_spec_optionContext); ok { + len++ + } + } + + tst := make([]IEt_record_spec_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEt_record_spec_optionContext); ok { + tst[i] = t.(IEt_record_spec_optionContext) + i++ + } + } + + return tst +} + +func (s *Et_record_spec_optionsContext) Et_record_spec_option(i int) IEt_record_spec_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEt_record_spec_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEt_record_spec_optionContext) +} + +func (s *Et_record_spec_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Et_record_spec_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Et_record_spec_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEt_record_spec_options(s) + } +} + +func (s *Et_record_spec_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEt_record_spec_options(s) + } +} + +func (s *Et_record_spec_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEt_record_spec_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Et_record_spec_options() (localctx IEt_record_spec_optionsContext) { + localctx = NewEt_record_spec_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1228, PlSqlParserRULE_et_record_spec_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(11972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDATA || ((int64((_la-760)) & ^0x3f) == 0 && ((int64(1)<<(_la-760))&9007749010554881) != 0) || _la == PlSqlParserSKIP_ || _la == PlSqlParserSTRING || ((int64((_la-2314)) & ^0x3f) == 0 && ((int64(1)<<(_la-2314))&4281271393) != 0) { + { + p.SetState(11971) + p.Et_record_spec_option() + } + + p.SetState(11974) + 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 +} + +// IEt_record_spec_optionContext is an interface to support dynamic dispatch. +type IEt_record_spec_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHARACTERSET() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + PREPROCESSOR() antlr.TerminalNode + File_spec() IFile_specContext + Directory_spec() IDirectory_specContext + COLON() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + TERRITORY() antlr.TerminalNode + DATA() antlr.TerminalNode + IS() antlr.TerminalNode + ENDIAN() antlr.TerminalNode + LITTLE() antlr.TerminalNode + BIG() antlr.TerminalNode + BYTEORDERMARK() antlr.TerminalNode + CHECK() antlr.TerminalNode + NOCHECK() antlr.TerminalNode + STRING() antlr.TerminalNode + SIZES() antlr.TerminalNode + ARE() antlr.TerminalNode + IN() antlr.TerminalNode + BYTES() antlr.TerminalNode + CHARACTERS() antlr.TerminalNode + LOAD() antlr.TerminalNode + WHEN() antlr.TerminalNode + Condition() IConditionContext + Et_output_files() IEt_output_filesContext + READSIZE() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode + DATE_CACHE() antlr.TerminalNode + SKIP_() antlr.TerminalNode + FIELD_NAMES() antlr.TerminalNode + FIRST() antlr.TerminalNode + FILE() antlr.TerminalNode + ALL() antlr.TerminalNode + FILES() antlr.TerminalNode + NONE() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IO_OPTIONS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + DIRECTIO() antlr.TerminalNode + NODIRECTIO() antlr.TerminalNode + DNFS_ENABLE() antlr.TerminalNode + DNFS_DISABLE() antlr.TerminalNode + DNFS_READBUFFERS() antlr.TerminalNode + + // IsEt_record_spec_optionContext differentiates from other interfaces. + IsEt_record_spec_optionContext() +} + +type Et_record_spec_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEt_record_spec_optionContext() *Et_record_spec_optionContext { + var p = new(Et_record_spec_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_record_spec_option + return p +} + +func InitEmptyEt_record_spec_optionContext(p *Et_record_spec_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_record_spec_option +} + +func (*Et_record_spec_optionContext) IsEt_record_spec_optionContext() {} + +func NewEt_record_spec_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Et_record_spec_optionContext { + var p = new(Et_record_spec_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_et_record_spec_option + + return p +} + +func (s *Et_record_spec_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Et_record_spec_optionContext) CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERSET, 0) +} + +func (s *Et_record_spec_optionContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Et_record_spec_optionContext) PREPROCESSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPROCESSOR, 0) +} + +func (s *Et_record_spec_optionContext) File_spec() IFile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *Et_record_spec_optionContext) Directory_spec() IDirectory_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_specContext) +} + +func (s *Et_record_spec_optionContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Et_record_spec_optionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Et_record_spec_optionContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Et_record_spec_optionContext) TERRITORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERRITORY, 0) +} + +func (s *Et_record_spec_optionContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Et_record_spec_optionContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Et_record_spec_optionContext) ENDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserENDIAN, 0) +} + +func (s *Et_record_spec_optionContext) LITTLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLITTLE, 0) +} + +func (s *Et_record_spec_optionContext) BIG() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIG, 0) +} + +func (s *Et_record_spec_optionContext) BYTEORDERMARK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTEORDERMARK, 0) +} + +func (s *Et_record_spec_optionContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Et_record_spec_optionContext) NOCHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCHECK, 0) +} + +func (s *Et_record_spec_optionContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *Et_record_spec_optionContext) SIZES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZES, 0) +} + +func (s *Et_record_spec_optionContext) ARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARE, 0) +} + +func (s *Et_record_spec_optionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Et_record_spec_optionContext) BYTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTES, 0) +} + +func (s *Et_record_spec_optionContext) CHARACTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERS, 0) +} + +func (s *Et_record_spec_optionContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Et_record_spec_optionContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Et_record_spec_optionContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Et_record_spec_optionContext) Et_output_files() IEt_output_filesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEt_output_filesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEt_output_filesContext) +} + +func (s *Et_record_spec_optionContext) READSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREADSIZE, 0) +} + +func (s *Et_record_spec_optionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Et_record_spec_optionContext) DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, 0) +} + +func (s *Et_record_spec_optionContext) DATE_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_CACHE, 0) +} + +func (s *Et_record_spec_optionContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Et_record_spec_optionContext) FIELD_NAMES() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD_NAMES, 0) +} + +func (s *Et_record_spec_optionContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Et_record_spec_optionContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Et_record_spec_optionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Et_record_spec_optionContext) FILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILES, 0) +} + +func (s *Et_record_spec_optionContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Et_record_spec_optionContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Et_record_spec_optionContext) IO_OPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIO_OPTIONS, 0) +} + +func (s *Et_record_spec_optionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Et_record_spec_optionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Et_record_spec_optionContext) DIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTIO, 0) +} + +func (s *Et_record_spec_optionContext) NODIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODIRECTIO, 0) +} + +func (s *Et_record_spec_optionContext) DNFS_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_ENABLE, 0) +} + +func (s *Et_record_spec_optionContext) DNFS_DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_DISABLE, 0) +} + +func (s *Et_record_spec_optionContext) DNFS_READBUFFERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_READBUFFERS, 0) +} + +func (s *Et_record_spec_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Et_record_spec_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Et_record_spec_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEt_record_spec_option(s) + } +} + +func (s *Et_record_spec_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEt_record_spec_option(s) + } +} + +func (s *Et_record_spec_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEt_record_spec_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Et_record_spec_option() (localctx IEt_record_spec_optionContext) { + localctx = NewEt_record_spec_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1230, PlSqlParserRULE_et_record_spec_option) + var _la int + + p.SetState(12028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHARACTERSET: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(11976) + p.Match(PlSqlParserCHARACTERSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11977) + p.Char_set_name() + } + + case PlSqlParserPREPROCESSOR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(11978) + p.Match(PlSqlParserPREPROCESSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(11982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(11979) + p.Directory_spec() + } + { + p.SetState(11980) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(11984) + p.File_spec() + } + + case PlSqlParserLANGUAGE, PlSqlParserTERRITORY: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(11985) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLANGUAGE || _la == PlSqlParserTERRITORY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11986) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATA: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(11987) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11988) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11989) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLITTLE || _la == PlSqlParserBIG) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(11990) + p.Match(PlSqlParserENDIAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBYTEORDERMARK: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(11991) + p.Match(PlSqlParserBYTEORDERMARK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11992) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCHECK || _la == PlSqlParserNOCHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserSTRING: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(11993) + p.Match(PlSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11994) + p.Match(PlSqlParserSIZES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11995) + p.Match(PlSqlParserARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11996) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11997) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTES || _la == PlSqlParserCHARACTERS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLOAD: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(11998) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(11999) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12000) + p.Condition() + } + + case PlSqlParserLOGFILE, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12001) + p.Et_output_files() + } + + case PlSqlParserREADSIZE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12002) + p.Match(PlSqlParserREADSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12003) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISABLE_DIRECTORY_LINK_CHECK: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12004) + p.Match(PlSqlParserDISABLE_DIRECTORY_LINK_CHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSKIP_, PlSqlParserDATE_CACHE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12005) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSKIP_ || _la == PlSqlParserDATE_CACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12006) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFIELD_NAMES: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(12007) + p.Match(PlSqlParserFIELD_NAMES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFIRST: + { + p.SetState(12008) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12009) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12011) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE { + { + p.SetState(12010) + p.Match(PlSqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserALL: + { + p.SetState(12013) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12014) + p.Match(PlSqlParserFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12016) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE { + { + p.SetState(12015) + p.Match(PlSqlParserIGNORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNONE: + { + p.SetState(12018) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserIO_OPTIONS: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(12021) + p.Match(PlSqlParserIO_OPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12022) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12023) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDIRECTIO || _la == PlSqlParserNODIRECTIO) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12024) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(12025) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDNFS_ENABLE || _la == PlSqlParserDNFS_DISABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDNFS_READBUFFERS: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(12026) + p.Match(PlSqlParserDNFS_READBUFFERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12027) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IEt_output_filesContext is an interface to support dynamic dispatch. +type IEt_output_filesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllEt_output_file() []IEt_output_fileContext + Et_output_file(i int) IEt_output_fileContext + + // IsEt_output_filesContext differentiates from other interfaces. + IsEt_output_filesContext() +} + +type Et_output_filesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEt_output_filesContext() *Et_output_filesContext { + var p = new(Et_output_filesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_output_files + return p +} + +func InitEmptyEt_output_filesContext(p *Et_output_filesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_output_files +} + +func (*Et_output_filesContext) IsEt_output_filesContext() {} + +func NewEt_output_filesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Et_output_filesContext { + var p = new(Et_output_filesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_et_output_files + + return p +} + +func (s *Et_output_filesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Et_output_filesContext) AllEt_output_file() []IEt_output_fileContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEt_output_fileContext); ok { + len++ + } + } + + tst := make([]IEt_output_fileContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEt_output_fileContext); ok { + tst[i] = t.(IEt_output_fileContext) + i++ + } + } + + return tst +} + +func (s *Et_output_filesContext) Et_output_file(i int) IEt_output_fileContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEt_output_fileContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEt_output_fileContext) +} + +func (s *Et_output_filesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Et_output_filesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Et_output_filesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEt_output_files(s) + } +} + +func (s *Et_output_filesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEt_output_files(s) + } +} + +func (s *Et_output_filesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEt_output_files(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Et_output_files() (localctx IEt_output_filesContext) { + localctx = NewEt_output_filesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1232, PlSqlParserRULE_et_output_files) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(12030) + p.Et_output_file() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12033) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1492, 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 +} + +// IEt_output_fileContext is an interface to support dynamic dispatch. +type IEt_output_fileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOBADFILE() antlr.TerminalNode + BADFILE() antlr.TerminalNode + Directory_spec() IDirectory_specContext + COLON() antlr.TerminalNode + File_spec() IFile_specContext + NODISCARDFILE() antlr.TerminalNode + DISCARDFILE() antlr.TerminalNode + NOLOGFILE() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + + // IsEt_output_fileContext differentiates from other interfaces. + IsEt_output_fileContext() +} + +type Et_output_fileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEt_output_fileContext() *Et_output_fileContext { + var p = new(Et_output_fileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_output_file + return p +} + +func InitEmptyEt_output_fileContext(p *Et_output_fileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_et_output_file +} + +func (*Et_output_fileContext) IsEt_output_fileContext() {} + +func NewEt_output_fileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Et_output_fileContext { + var p = new(Et_output_fileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_et_output_file + + return p +} + +func (s *Et_output_fileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Et_output_fileContext) NOBADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOBADFILE, 0) +} + +func (s *Et_output_fileContext) BADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBADFILE, 0) +} + +func (s *Et_output_fileContext) Directory_spec() IDirectory_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_specContext) +} + +func (s *Et_output_fileContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Et_output_fileContext) File_spec() IFile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *Et_output_fileContext) NODISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODISCARDFILE, 0) +} + +func (s *Et_output_fileContext) DISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCARDFILE, 0) +} + +func (s *Et_output_fileContext) NOLOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGFILE, 0) +} + +func (s *Et_output_fileContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Et_output_fileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Et_output_fileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Et_output_fileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEt_output_file(s) + } +} + +func (s *Et_output_fileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEt_output_file(s) + } +} + +func (s *Et_output_fileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEt_output_file(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Et_output_file() (localctx IEt_output_fileContext) { + localctx = NewEt_output_fileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1234, PlSqlParserRULE_et_output_file) + var _la int + + p.SetState(12065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOBADFILE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12035) + p.Match(PlSqlParserNOBADFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBADFILE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12036) + p.Match(PlSqlParserBADFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12040) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1493, p.GetParserRuleContext()) == 1 { + { + p.SetState(12037) + p.Directory_spec() + } + { + p.SetState(12038) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12042) + p.File_spec() + } + + } + + case PlSqlParserNODISCARDFILE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12045) + p.Match(PlSqlParserNODISCARDFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDISCARDFILE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12046) + p.Match(PlSqlParserDISCARDFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12050) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1495, p.GetParserRuleContext()) == 1 { + { + p.SetState(12047) + p.Directory_spec() + } + { + p.SetState(12048) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12053) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12052) + p.File_spec() + } + + } + + case PlSqlParserNOLOGFILE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12055) + p.Match(PlSqlParserNOLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOGFILE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12056) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12060) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1497, p.GetParserRuleContext()) == 1 { + { + p.SetState(12057) + p.Directory_spec() + } + { + p.SetState(12058) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12062) + p.File_spec() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_specContext is an interface to support dynamic dispatch. +type IDirectory_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Directory_name() IDirectory_nameContext + + // IsDirectory_specContext differentiates from other interfaces. + IsDirectory_specContext() +} + +type Directory_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDirectory_specContext() *Directory_specContext { + var p = new(Directory_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_spec + return p +} + +func InitEmptyDirectory_specContext(p *Directory_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_directory_spec +} + +func (*Directory_specContext) IsDirectory_specContext() {} + +func NewDirectory_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Directory_specContext { + var p = new(Directory_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_directory_spec + + return p +} + +func (s *Directory_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Directory_specContext) Directory_name() IDirectory_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_nameContext) +} + +func (s *Directory_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Directory_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Directory_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDirectory_spec(s) + } +} + +func (s *Directory_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDirectory_spec(s) + } +} + +func (s *Directory_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDirectory_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Directory_spec() (localctx IDirectory_specContext) { + localctx = NewDirectory_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1236, PlSqlParserRULE_directory_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12067) + p.Directory_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 +} + +// IFile_specContext is an interface to support dynamic dispatch. +type IFile_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsFile_specContext differentiates from other interfaces. + IsFile_specContext() +} + +type File_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_specContext() *File_specContext { + var p = new(File_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_spec + return p +} + +func InitEmptyFile_specContext(p *File_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_spec +} + +func (*File_specContext) IsFile_specContext() {} + +func NewFile_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_specContext { + var p = new(File_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_spec + + return p +} + +func (s *File_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *File_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_spec(s) + } +} + +func (s *File_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_spec(s) + } +} + +func (s *File_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_spec() (localctx IFile_specContext) { + localctx = NewFile_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1238, PlSqlParserRULE_file_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12069) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IField_definitionsContext is an interface to support dynamic dispatch. +type IField_definitionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FIELDS() antlr.TerminalNode + Field_options() IField_optionsContext + Field_list() IField_listContext + + // IsField_definitionsContext differentiates from other interfaces. + IsField_definitionsContext() +} + +type Field_definitionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_definitionsContext() *Field_definitionsContext { + var p = new(Field_definitionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_definitions + return p +} + +func InitEmptyField_definitionsContext(p *Field_definitionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_definitions +} + +func (*Field_definitionsContext) IsField_definitionsContext() {} + +func NewField_definitionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_definitionsContext { + var p = new(Field_definitionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_definitions + + return p +} + +func (s *Field_definitionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_definitionsContext) FIELDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, 0) +} + +func (s *Field_definitionsContext) Field_options() IField_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_optionsContext) +} + +func (s *Field_definitionsContext) Field_list() IField_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_listContext) +} + +func (s *Field_definitionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_definitionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_definitionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_definitions(s) + } +} + +func (s *Field_definitionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_definitions(s) + } +} + +func (s *Field_definitionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_definitions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_definitions() (localctx IField_definitionsContext) { + localctx = NewField_definitionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1240, PlSqlParserRULE_field_definitions) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12071) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL || _la == PlSqlParserLTRIM || _la == PlSqlParserMISSING || _la == PlSqlParserNULLIF || _la == PlSqlParserREJECT || _la == PlSqlParserRTRIM || ((int64((_la-2303)) & ^0x3f) == 0 && ((int64(1)<<(_la-2303))&1178676464975995) != 0) { + { + p.SetState(12072) + p.Field_options() + } + + } + p.SetState(12076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12075) + p.Field_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 +} + +// IField_optionsContext is an interface to support dynamic dispatch. +type IField_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllField_option() []IField_optionContext + Field_option(i int) IField_optionContext + + // IsField_optionsContext differentiates from other interfaces. + IsField_optionsContext() +} + +type Field_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_optionsContext() *Field_optionsContext { + var p = new(Field_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_options + return p +} + +func InitEmptyField_optionsContext(p *Field_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_options +} + +func (*Field_optionsContext) IsField_optionsContext() {} + +func NewField_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_optionsContext { + var p = new(Field_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_options + + return p +} + +func (s *Field_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_optionsContext) AllField_option() []IField_optionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IField_optionContext); ok { + len++ + } + } + + tst := make([]IField_optionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IField_optionContext); ok { + tst[i] = t.(IField_optionContext) + i++ + } + } + + return tst +} + +func (s *Field_optionsContext) Field_option(i int) IField_optionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_optionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IField_optionContext) +} + +func (s *Field_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_options(s) + } +} + +func (s *Field_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_options(s) + } +} + +func (s *Field_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_options() (localctx IField_optionsContext) { + localctx = NewField_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1242, PlSqlParserRULE_field_options) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12079) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALL || _la == PlSqlParserLTRIM || _la == PlSqlParserMISSING || _la == PlSqlParserNULLIF || _la == PlSqlParserREJECT || _la == PlSqlParserRTRIM || ((int64((_la-2303)) & ^0x3f) == 0 && ((int64(1)<<(_la-2303))&1178676464975995) != 0) { + { + p.SetState(12078) + p.Field_option() + } + + p.SetState(12081) + 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 +} + +// IField_optionContext is an interface to support dynamic dispatch. +type IField_optionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode + CSV() antlr.TerminalNode + EMBEDDED() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + Delim_spec() IDelim_specContext + Trim_spec() ITrim_specContext + ALL() antlr.TerminalNode + AllFIELDS() []antlr.TerminalNode + FIELDS(i int) antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + THESE() antlr.TerminalNode + MISSING() antlr.TerminalNode + FIELD() antlr.TerminalNode + VALUES() antlr.TerminalNode + ARE() antlr.TerminalNode + NULL_() antlr.TerminalNode + REJECT() antlr.TerminalNode + ROWS() antlr.TerminalNode + AllField_date_format() []IField_date_formatContext + Field_date_format(i int) IField_date_formatContext + NULLIF() antlr.TerminalNode + NONULLIF() antlr.TerminalNode + + // IsField_optionContext differentiates from other interfaces. + IsField_optionContext() +} + +type Field_optionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_optionContext() *Field_optionContext { + var p = new(Field_optionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_option + return p +} + +func InitEmptyField_optionContext(p *Field_optionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_option +} + +func (*Field_optionContext) IsField_optionContext() {} + +func NewField_optionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_optionContext { + var p = new(Field_optionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_option + + return p +} + +func (s *Field_optionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_optionContext) IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_CHARS_AFTER_EOR, 0) +} + +func (s *Field_optionContext) CSV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCSV, 0) +} + +func (s *Field_optionContext) EMBEDDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMBEDDED, 0) +} + +func (s *Field_optionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Field_optionContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Field_optionContext) Delim_spec() IDelim_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelim_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelim_specContext) +} + +func (s *Field_optionContext) Trim_spec() ITrim_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrim_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrim_specContext) +} + +func (s *Field_optionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Field_optionContext) AllFIELDS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFIELDS) +} + +func (s *Field_optionContext) FIELDS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, i) +} + +func (s *Field_optionContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDE, 0) +} + +func (s *Field_optionContext) THESE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHESE, 0) +} + +func (s *Field_optionContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Field_optionContext) FIELD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD, 0) +} + +func (s *Field_optionContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Field_optionContext) ARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARE, 0) +} + +func (s *Field_optionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Field_optionContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Field_optionContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Field_optionContext) AllField_date_format() []IField_date_formatContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IField_date_formatContext); ok { + len++ + } + } + + tst := make([]IField_date_formatContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IField_date_formatContext); ok { + tst[i] = t.(IField_date_formatContext) + i++ + } + } + + return tst +} + +func (s *Field_optionContext) Field_date_format(i int) IField_date_formatContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_date_formatContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IField_date_formatContext) +} + +func (s *Field_optionContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *Field_optionContext) NONULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONULLIF, 0) +} + +func (s *Field_optionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_optionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_optionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_option(s) + } +} + +func (s *Field_optionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_option(s) + } +} + +func (s *Field_optionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_option(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_option() (localctx IField_optionContext) { + localctx = NewField_optionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1244, PlSqlParserRULE_field_option) + var _la int + + var _alt int + + p.SetState(12113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIGNORE_CHARS_AFTER_EOR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12083) + p.Match(PlSqlParserIGNORE_CHARS_AFTER_EOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCSV: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12084) + p.Match(PlSqlParserCSV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(12085) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12086) + p.Match(PlSqlParserEMBEDDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserENCLOSED, PlSqlParserTERMINATED: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12089) + p.Delim_spec() + } + + case PlSqlParserLTRIM, PlSqlParserRTRIM, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12090) + p.Trim_spec() + } + + case PlSqlParserALL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12091) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12092) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12093) + p.Match(PlSqlParserOVERRIDE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12094) + p.Match(PlSqlParserTHESE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12095) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMISSING: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12096) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12097) + p.Match(PlSqlParserFIELD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12098) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12099) + p.Match(PlSqlParserARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12100) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREJECT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12101) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12102) + p.Match(PlSqlParserROWS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12103) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12104) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12105) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12106) + p.Match(PlSqlParserFIELDS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATE_FORMAT: + p.EnterOuterAlt(localctx, 8) + p.SetState(12108) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(12107) + p.Field_date_format() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12110) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1504, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserNULLIF, PlSqlParserNONULLIF: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12112) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNULLIF || _la == PlSqlParserNONULLIF) { + 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 +} + +// IField_listContext is an interface to support dynamic dispatch. +type IField_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllField_item() []IField_itemContext + Field_item(i int) IField_itemContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsField_listContext differentiates from other interfaces. + IsField_listContext() +} + +type Field_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_listContext() *Field_listContext { + var p = new(Field_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_list + return p +} + +func InitEmptyField_listContext(p *Field_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_list +} + +func (*Field_listContext) IsField_listContext() {} + +func NewField_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_listContext { + var p = new(Field_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_list + + return p +} + +func (s *Field_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Field_listContext) AllField_item() []IField_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IField_itemContext); ok { + len++ + } + } + + tst := make([]IField_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IField_itemContext); ok { + tst[i] = t.(IField_itemContext) + i++ + } + } + + return tst +} + +func (s *Field_listContext) Field_item(i int) IField_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IField_itemContext) +} + +func (s *Field_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Field_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Field_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Field_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_list(s) + } +} + +func (s *Field_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_list(s) + } +} + +func (s *Field_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_list() (localctx IField_listContext) { + localctx = NewField_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1246, PlSqlParserRULE_field_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12115) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12116) + p.Field_item() + } + p.SetState(12121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12117) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12118) + p.Field_item() + } + + p.SetState(12123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12124) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IField_itemContext is an interface to support dynamic dispatch. +type IField_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Field_name() IField_nameContext + Pos_spec() IPos_specContext + Datatype_spec() IDatatype_specContext + Init_spec() IInit_specContext + Lls_clause() ILls_clauseContext + + // IsField_itemContext differentiates from other interfaces. + IsField_itemContext() +} + +type Field_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_itemContext() *Field_itemContext { + var p = new(Field_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_item + return p +} + +func InitEmptyField_itemContext(p *Field_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_item +} + +func (*Field_itemContext) IsField_itemContext() {} + +func NewField_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_itemContext { + var p = new(Field_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_item + + return p +} + +func (s *Field_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_itemContext) Field_name() IField_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_nameContext) +} + +func (s *Field_itemContext) Pos_spec() IPos_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPos_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPos_specContext) +} + +func (s *Field_itemContext) Datatype_spec() IDatatype_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatype_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatype_specContext) +} + +func (s *Field_itemContext) Init_spec() IInit_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInit_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInit_specContext) +} + +func (s *Field_itemContext) Lls_clause() ILls_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILls_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILls_clauseContext) +} + +func (s *Field_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_item(s) + } +} + +func (s *Field_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_item(s) + } +} + +func (s *Field_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_item() (localctx IField_itemContext) { + localctx = NewField_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1248, PlSqlParserRULE_field_item) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12126) + p.Field_name() + } + p.SetState(12128) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOSITION || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12127) + p.Pos_spec() + } + + } + p.SetState(12131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBINARY_DOUBLE || _la == PlSqlParserBINARY_FLOAT || _la == PlSqlParserCHAR || _la == PlSqlParserDECIMAL || _la == PlSqlParserDOUBLE || _la == PlSqlParserFLOAT || _la == PlSqlParserINTEGER || _la == PlSqlParserRAW || _la == PlSqlParserVARCHAR || ((int64((_la-2357)) & ^0x3f) == 0 && ((int64(1)<<(_la-2357))&239) != 0) { + { + p.SetState(12130) + p.Datatype_spec() + } + + } + p.SetState(12134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLIF || _la == PlSqlParserDEFAULTIF { + { + p.SetState(12133) + p.Init_spec() + } + + } + p.SetState(12137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLLS { + { + p.SetState(12136) + p.Lls_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 +} + +// IField_nameContext is an interface to support dynamic dispatch. +type IField_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsField_nameContext differentiates from other interfaces. + IsField_nameContext() +} + +type Field_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_nameContext() *Field_nameContext { + var p = new(Field_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_name + return p +} + +func InitEmptyField_nameContext(p *Field_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_name +} + +func (*Field_nameContext) IsField_nameContext() {} + +func NewField_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_nameContext { + var p = new(Field_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_name + + return p +} + +func (s *Field_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_nameContext) 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 *Field_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_name(s) + } +} + +func (s *Field_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_name(s) + } +} + +func (s *Field_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_name() (localctx IField_nameContext) { + localctx = NewField_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1250, PlSqlParserRULE_field_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12139) + p.Column_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 +} + +// IPos_specContext is an interface to support dynamic dispatch. +type IPos_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Pos_start() IPos_startContext + ASTERISK() antlr.TerminalNode + Pos_increment() IPos_incrementContext + POSITION() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + AllMINUS_SIGN() []antlr.TerminalNode + MINUS_SIGN(i int) antlr.TerminalNode + COLON() antlr.TerminalNode + Pos_end() IPos_endContext + Pos_length() IPos_lengthContext + + // IsPos_specContext differentiates from other interfaces. + IsPos_specContext() +} + +type Pos_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPos_specContext() *Pos_specContext { + var p = new(Pos_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_spec + return p +} + +func InitEmptyPos_specContext(p *Pos_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_spec +} + +func (*Pos_specContext) IsPos_specContext() {} + +func NewPos_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pos_specContext { + var p = new(Pos_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pos_spec + + return p +} + +func (s *Pos_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pos_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pos_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pos_specContext) Pos_start() IPos_startContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPos_startContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPos_startContext) +} + +func (s *Pos_specContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Pos_specContext) Pos_increment() IPos_incrementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPos_incrementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPos_incrementContext) +} + +func (s *Pos_specContext) POSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITION, 0) +} + +func (s *Pos_specContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *Pos_specContext) AllMINUS_SIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUS_SIGN) +} + +func (s *Pos_specContext) MINUS_SIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, i) +} + +func (s *Pos_specContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Pos_specContext) Pos_end() IPos_endContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPos_endContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPos_endContext) +} + +func (s *Pos_specContext) Pos_length() IPos_lengthContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPos_lengthContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPos_lengthContext) +} + +func (s *Pos_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pos_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pos_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPos_spec(s) + } +} + +func (s *Pos_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPos_spec(s) + } +} + +func (s *Pos_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPos_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pos_spec() (localctx IPos_specContext) { + localctx = NewPos_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1252, PlSqlParserRULE_pos_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPOSITION { + { + p.SetState(12141) + p.Match(PlSqlParserPOSITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12144) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12149) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(12145) + p.Pos_start() + } + + case PlSqlParserASTERISK: + { + p.SetState(12146) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12147) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12148) + p.Pos_increment() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMINUS_SIGN || _la == PlSqlParserCOLON { + { + p.SetState(12151) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMINUS_SIGN || _la == PlSqlParserCOLON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1513, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12152) + p.Pos_end() + } + + case 2: + { + p.SetState(12153) + p.Pos_length() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + { + p.SetState(12158) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPos_startContext is an interface to support dynamic dispatch. +type IPos_startContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsPos_startContext differentiates from other interfaces. + IsPos_startContext() +} + +type Pos_startContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPos_startContext() *Pos_startContext { + var p = new(Pos_startContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_start + return p +} + +func InitEmptyPos_startContext(p *Pos_startContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_start +} + +func (*Pos_startContext) IsPos_startContext() {} + +func NewPos_startContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pos_startContext { + var p = new(Pos_startContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pos_start + + return p +} + +func (s *Pos_startContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pos_startContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Pos_startContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pos_startContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pos_startContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPos_start(s) + } +} + +func (s *Pos_startContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPos_start(s) + } +} + +func (s *Pos_startContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPos_start(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pos_start() (localctx IPos_startContext) { + localctx = NewPos_startContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1254, PlSqlParserRULE_pos_start) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12160) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IPos_incrementContext is an interface to support dynamic dispatch. +type IPos_incrementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsPos_incrementContext differentiates from other interfaces. + IsPos_incrementContext() +} + +type Pos_incrementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPos_incrementContext() *Pos_incrementContext { + var p = new(Pos_incrementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_increment + return p +} + +func InitEmptyPos_incrementContext(p *Pos_incrementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_increment +} + +func (*Pos_incrementContext) IsPos_incrementContext() {} + +func NewPos_incrementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pos_incrementContext { + var p = new(Pos_incrementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pos_increment + + return p +} + +func (s *Pos_incrementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pos_incrementContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Pos_incrementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pos_incrementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pos_incrementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPos_increment(s) + } +} + +func (s *Pos_incrementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPos_increment(s) + } +} + +func (s *Pos_incrementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPos_increment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pos_increment() (localctx IPos_incrementContext) { + localctx = NewPos_incrementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1256, PlSqlParserRULE_pos_increment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12162) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IPos_endContext is an interface to support dynamic dispatch. +type IPos_endContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsPos_endContext differentiates from other interfaces. + IsPos_endContext() +} + +type Pos_endContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPos_endContext() *Pos_endContext { + var p = new(Pos_endContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_end + return p +} + +func InitEmptyPos_endContext(p *Pos_endContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_end +} + +func (*Pos_endContext) IsPos_endContext() {} + +func NewPos_endContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pos_endContext { + var p = new(Pos_endContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pos_end + + return p +} + +func (s *Pos_endContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pos_endContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Pos_endContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pos_endContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pos_endContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPos_end(s) + } +} + +func (s *Pos_endContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPos_end(s) + } +} + +func (s *Pos_endContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPos_end(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pos_end() (localctx IPos_endContext) { + localctx = NewPos_endContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1258, PlSqlParserRULE_pos_end) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12164) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IPos_lengthContext is an interface to support dynamic dispatch. +type IPos_lengthContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsPos_lengthContext differentiates from other interfaces. + IsPos_lengthContext() +} + +type Pos_lengthContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPos_lengthContext() *Pos_lengthContext { + var p = new(Pos_lengthContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_length + return p +} + +func InitEmptyPos_lengthContext(p *Pos_lengthContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pos_length +} + +func (*Pos_lengthContext) IsPos_lengthContext() {} + +func NewPos_lengthContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pos_lengthContext { + var p = new(Pos_lengthContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pos_length + + return p +} + +func (s *Pos_lengthContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pos_lengthContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Pos_lengthContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pos_lengthContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pos_lengthContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPos_length(s) + } +} + +func (s *Pos_lengthContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPos_length(s) + } +} + +func (s *Pos_lengthContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPos_length(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pos_length() (localctx IPos_lengthContext) { + localctx = NewPos_lengthContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1260, PlSqlParserRULE_pos_length) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12166) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IDatatype_specContext is an interface to support dynamic dispatch. +type IDatatype_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTEGER() antlr.TerminalNode + UNSIGNED() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Delim_spec() IDelim_specContext + DECIMAL() antlr.TerminalNode + ZONED() antlr.TerminalNode + Precision_part() IPrecision_partContext + ORACLE_DATE() antlr.TerminalNode + ORACLE_NUMBER() antlr.TerminalNode + COUNTED() antlr.TerminalNode + FLOAT() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + RAW() antlr.TerminalNode + CHAR() antlr.TerminalNode + Trim_spec() ITrim_specContext + Field_date_format() IField_date_formatContext + AllNumeric() []INumericContext + Numeric(i int) INumericContext + VARCHAR() antlr.TerminalNode + VARRAW() antlr.TerminalNode + VARCHARC() antlr.TerminalNode + VARRAWC() antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsDatatype_specContext differentiates from other interfaces. + IsDatatype_specContext() +} + +type Datatype_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatype_specContext() *Datatype_specContext { + var p = new(Datatype_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype_spec + return p +} + +func InitEmptyDatatype_specContext(p *Datatype_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype_spec +} + +func (*Datatype_specContext) IsDatatype_specContext() {} + +func NewDatatype_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Datatype_specContext { + var p = new(Datatype_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datatype_spec + + return p +} + +func (s *Datatype_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Datatype_specContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *Datatype_specContext) UNSIGNED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED, 0) +} + +func (s *Datatype_specContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Datatype_specContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Datatype_specContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Datatype_specContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Datatype_specContext) Delim_spec() IDelim_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDelim_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDelim_specContext) +} + +func (s *Datatype_specContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *Datatype_specContext) ZONED() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONED, 0) +} + +func (s *Datatype_specContext) Precision_part() IPrecision_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrecision_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrecision_partContext) +} + +func (s *Datatype_specContext) ORACLE_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATE, 0) +} + +func (s *Datatype_specContext) ORACLE_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_NUMBER, 0) +} + +func (s *Datatype_specContext) COUNTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNTED, 0) +} + +func (s *Datatype_specContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *Datatype_specContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Datatype_specContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *Datatype_specContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *Datatype_specContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *Datatype_specContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Datatype_specContext) Trim_spec() ITrim_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrim_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrim_specContext) +} + +func (s *Datatype_specContext) Field_date_format() IField_date_formatContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_date_formatContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IField_date_formatContext) +} + +func (s *Datatype_specContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Datatype_specContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Datatype_specContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *Datatype_specContext) VARRAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAW, 0) +} + +func (s *Datatype_specContext) VARCHARC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHARC, 0) +} + +func (s *Datatype_specContext) VARRAWC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAWC, 0) +} + +func (s *Datatype_specContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Datatype_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Datatype_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Datatype_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatatype_spec(s) + } +} + +func (s *Datatype_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatatype_spec(s) + } +} + +func (s *Datatype_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatatype_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datatype_spec() (localctx IDatatype_specContext) { + localctx = NewDatatype_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1262, PlSqlParserRULE_datatype_spec) + var _la int + + p.SetState(12258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTEGER, PlSqlParserUNSIGNED: + p.EnterOuterAlt(localctx, 1) + p.SetState(12169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED { + { + p.SetState(12168) + p.Match(PlSqlParserUNSIGNED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12171) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12173) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(12172) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12175) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12176) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12177) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12180) + p.Delim_spec() + } + + } + + case PlSqlParserDECIMAL, PlSqlParserZONED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12183) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECIMAL || _la == PlSqlParserZONED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXTERNAL: + { + p.SetState(12184) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12188) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12185) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12186) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12187) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12191) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12190) + p.Delim_spec() + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(12193) + p.Precision_part() + } + + case PlSqlParserNULLIF, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + + case PlSqlParserORACLE_DATE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12196) + p.Match(PlSqlParserORACLE_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORACLE_NUMBER: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12197) + p.Match(PlSqlParserORACLE_NUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOUNTED { + { + p.SetState(12198) + p.Match(PlSqlParserCOUNTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFLOAT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(12201) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12203) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(12202) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12205) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12206) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12207) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12210) + p.Delim_spec() + } + + } + + case PlSqlParserDOUBLE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(12213) + p.Match(PlSqlParserDOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_FLOAT: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(12214) + p.Match(PlSqlParserBINARY_FLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXTERNAL { + { + p.SetState(12215) + p.Match(PlSqlParserEXTERNAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12218) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12219) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12220) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12223) + p.Delim_spec() + } + + } + + case PlSqlParserBINARY_DOUBLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(12226) + p.Match(PlSqlParserBINARY_DOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRAW: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(12227) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12231) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12228) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12229) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12230) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCHAR: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(12233) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12234) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12235) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12236) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12240) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCLOSED || _la == PlSqlParserTERMINATED { + { + p.SetState(12239) + p.Delim_spec() + } + + } + p.SetState(12243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLTRIM || _la == PlSqlParserRTRIM || ((int64((_la-2306)) & ^0x3f) == 0 && ((int64(1)<<(_la-2306))&7) != 0) { + { + p.SetState(12242) + p.Trim_spec() + } + + } + p.SetState(12246) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATE_FORMAT { + { + p.SetState(12245) + p.Field_date_format() + } + + } + + case PlSqlParserVARCHAR, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(12248) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserVARCHAR || ((int64((_la-2362)) & ^0x3f) == 0 && ((int64(1)<<(_la-2362))&7) != 0)) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12249) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12253) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1534, p.GetParserRuleContext()) == 1 { + { + p.SetState(12250) + p.Numeric() + } + { + p.SetState(12251) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12255) + p.Numeric() + } + { + p.SetState(12256) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInit_specContext is an interface to support dynamic dispatch. +type IInit_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Condition() IConditionContext + DEFAULTIF() antlr.TerminalNode + NULLIF() antlr.TerminalNode + + // IsInit_specContext differentiates from other interfaces. + IsInit_specContext() +} + +type Init_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInit_specContext() *Init_specContext { + var p = new(Init_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_init_spec + return p +} + +func InitEmptyInit_specContext(p *Init_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_init_spec +} + +func (*Init_specContext) IsInit_specContext() {} + +func NewInit_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Init_specContext { + var p = new(Init_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_init_spec + + return p +} + +func (s *Init_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Init_specContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Init_specContext) DEFAULTIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTIF, 0) +} + +func (s *Init_specContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *Init_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Init_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Init_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInit_spec(s) + } +} + +func (s *Init_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInit_spec(s) + } +} + +func (s *Init_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInit_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Init_spec() (localctx IInit_specContext) { + localctx = NewInit_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1264, PlSqlParserRULE_init_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12260) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNULLIF || _la == PlSqlParserDEFAULTIF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12261) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILls_clauseContext is an interface to support dynamic dispatch. +type ILls_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LLS() antlr.TerminalNode + Directory_spec() IDirectory_specContext + COLON() antlr.TerminalNode + File_spec() IFile_specContext + + // IsLls_clauseContext differentiates from other interfaces. + IsLls_clauseContext() +} + +type Lls_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLls_clauseContext() *Lls_clauseContext { + var p = new(Lls_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lls_clause + return p +} + +func InitEmptyLls_clauseContext(p *Lls_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lls_clause +} + +func (*Lls_clauseContext) IsLls_clauseContext() {} + +func NewLls_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lls_clauseContext { + var p = new(Lls_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lls_clause + + return p +} + +func (s *Lls_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lls_clauseContext) LLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLLS, 0) +} + +func (s *Lls_clauseContext) Directory_spec() IDirectory_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_specContext) +} + +func (s *Lls_clauseContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Lls_clauseContext) File_spec() IFile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *Lls_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lls_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lls_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLls_clause(s) + } +} + +func (s *Lls_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLls_clause(s) + } +} + +func (s *Lls_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLls_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lls_clause() (localctx ILls_clauseContext) { + localctx = NewLls_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1266, PlSqlParserRULE_lls_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12263) + p.Match(PlSqlParserLLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(12264) + p.Directory_spec() + } + { + p.SetState(12265) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12269) + p.File_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDelim_specContext is an interface to support dynamic dispatch. +type IDelim_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCLOSED() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllEt_string() []IEt_stringContext + Et_string(i int) IEt_stringContext + AND() antlr.TerminalNode + TERMINATED() antlr.TerminalNode + WHITESPACE() antlr.TerminalNode + OPTIONALLY() antlr.TerminalNode + + // IsDelim_specContext differentiates from other interfaces. + IsDelim_specContext() +} + +type Delim_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDelim_specContext() *Delim_specContext { + var p = new(Delim_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delim_spec + return p +} + +func InitEmptyDelim_specContext(p *Delim_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_delim_spec +} + +func (*Delim_specContext) IsDelim_specContext() {} + +func NewDelim_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Delim_specContext { + var p = new(Delim_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_delim_spec + + return p +} + +func (s *Delim_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delim_specContext) ENCLOSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCLOSED, 0) +} + +func (s *Delim_specContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Delim_specContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Delim_specContext) AllEt_string() []IEt_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEt_stringContext); ok { + len++ + } + } + + tst := make([]IEt_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEt_stringContext); ok { + tst[i] = t.(IEt_stringContext) + i++ + } + } + + return tst +} + +func (s *Delim_specContext) Et_string(i int) IEt_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEt_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEt_stringContext) +} + +func (s *Delim_specContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Delim_specContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERMINATED, 0) +} + +func (s *Delim_specContext) WHITESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHITESPACE, 0) +} + +func (s *Delim_specContext) OPTIONALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIONALLY, 0) +} + +func (s *Delim_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Delim_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Delim_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDelim_spec(s) + } +} + +func (s *Delim_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelim_spec(s) + } +} + +func (s *Delim_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDelim_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Delim_spec() (localctx IDelim_specContext) { + localctx = NewDelim_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1268, PlSqlParserRULE_delim_spec) + var _la int + + p.SetState(12297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCLOSED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12272) + p.Match(PlSqlParserENCLOSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12273) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12274) + p.Et_string() + } + p.SetState(12277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(12275) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12276) + p.Et_string() + } + + } + + case PlSqlParserTERMINATED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12279) + p.Match(PlSqlParserTERMINATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12280) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserHEX_STRING_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID: + { + p.SetState(12281) + p.Et_string() + } + + case PlSqlParserWHITESPACE: + { + p.SetState(12282) + p.Match(PlSqlParserWHITESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12295) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1542, p.GetParserRuleContext()) == 1 { + p.SetState(12286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOPTIONALLY { + { + p.SetState(12285) + p.Match(PlSqlParserOPTIONALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12288) + p.Match(PlSqlParserENCLOSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12289) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12290) + p.Et_string() + } + p.SetState(12293) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAND { + { + p.SetState(12291) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12292) + p.Et_string() + } + + } + + } 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 +} + +// ITrim_specContext is an interface to support dynamic dispatch. +type ITrim_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LRTRIM() antlr.TerminalNode + NOTRIM() antlr.TerminalNode + LTRIM() antlr.TerminalNode + RTRIM() antlr.TerminalNode + LDRTRIM() antlr.TerminalNode + + // IsTrim_specContext differentiates from other interfaces. + IsTrim_specContext() +} + +type Trim_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrim_specContext() *Trim_specContext { + var p = new(Trim_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trim_spec + return p +} + +func InitEmptyTrim_specContext(p *Trim_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trim_spec +} + +func (*Trim_specContext) IsTrim_specContext() {} + +func NewTrim_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trim_specContext { + var p = new(Trim_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trim_spec + + return p +} + +func (s *Trim_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trim_specContext) LRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLRTRIM, 0) +} + +func (s *Trim_specContext) NOTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTRIM, 0) +} + +func (s *Trim_specContext) LTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLTRIM, 0) +} + +func (s *Trim_specContext) RTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRTRIM, 0) +} + +func (s *Trim_specContext) LDRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDRTRIM, 0) +} + +func (s *Trim_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trim_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trim_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrim_spec(s) + } +} + +func (s *Trim_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrim_spec(s) + } +} + +func (s *Trim_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrim_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trim_spec() (localctx ITrim_specContext) { + localctx = NewTrim_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1270, PlSqlParserRULE_trim_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12299) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLTRIM || _la == PlSqlParserRTRIM || ((int64((_la-2306)) & ^0x3f) == 0 && ((int64(1)<<(_la-2306))&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 +} + +// IField_date_formatContext is an interface to support dynamic dispatch. +type IField_date_formatContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATE_FORMAT() antlr.TerminalNode + MASK() antlr.TerminalNode + Datetime_expr() IDatetime_exprContext + DATE() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + + // IsField_date_formatContext differentiates from other interfaces. + IsField_date_formatContext() +} + +type Field_date_formatContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_date_formatContext() *Field_date_formatContext { + var p = new(Field_date_formatContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_date_format + return p +} + +func InitEmptyField_date_formatContext(p *Field_date_formatContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_date_format +} + +func (*Field_date_formatContext) IsField_date_formatContext() {} + +func NewField_date_formatContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_date_formatContext { + var p = new(Field_date_formatContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_date_format + + return p +} + +func (s *Field_date_formatContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_date_formatContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_FORMAT, 0) +} + +func (s *Field_date_formatContext) MASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASK, 0) +} + +func (s *Field_date_formatContext) Datetime_expr() IDatetime_exprContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatetime_exprContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatetime_exprContext) +} + +func (s *Field_date_formatContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Field_date_formatContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Field_date_formatContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_date_formatContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_date_formatContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_date_format(s) + } +} + +func (s *Field_date_formatContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_date_format(s) + } +} + +func (s *Field_date_formatContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_date_format(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_date_format() (localctx IField_date_formatContext) { + localctx = NewField_date_formatContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1272, PlSqlParserRULE_field_date_format) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12301) + p.Match(PlSqlParserDATE_FORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12303) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDATE || _la == PlSqlParserTIMESTAMP { + { + p.SetState(12302) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDATE || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12305) + p.Match(PlSqlParserMASK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12306) + p.Datetime_expr() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_transformsContext is an interface to support dynamic dispatch. +type IColumn_transformsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMN() antlr.TerminalNode + TRANSFORMS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllTransform() []ITransformContext + Transform(i int) ITransformContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_transformsContext differentiates from other interfaces. + IsColumn_transformsContext() +} + +type Column_transformsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_transformsContext() *Column_transformsContext { + var p = new(Column_transformsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_transforms + return p +} + +func InitEmptyColumn_transformsContext(p *Column_transformsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_transforms +} + +func (*Column_transformsContext) IsColumn_transformsContext() {} + +func NewColumn_transformsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_transformsContext { + var p = new(Column_transformsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_transforms + + return p +} + +func (s *Column_transformsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_transformsContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Column_transformsContext) TRANSFORMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORMS, 0) +} + +func (s *Column_transformsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Column_transformsContext) AllTransform() []ITransformContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITransformContext); ok { + len++ + } + } + + tst := make([]ITransformContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITransformContext); ok { + tst[i] = t.(ITransformContext) + i++ + } + } + + return tst +} + +func (s *Column_transformsContext) Transform(i int) ITransformContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransformContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITransformContext) +} + +func (s *Column_transformsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Column_transformsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_transformsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_transformsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_transformsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_transformsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_transforms(s) + } +} + +func (s *Column_transformsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_transforms(s) + } +} + +func (s *Column_transformsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_transforms(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_transforms() (localctx IColumn_transformsContext) { + localctx = NewColumn_transformsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1274, PlSqlParserRULE_column_transforms) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12308) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12309) + p.Match(PlSqlParserTRANSFORMS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12310) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12311) + p.Transform() + } + p.SetState(12316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12312) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12313) + p.Transform() + } + + p.SetState(12318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12319) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITransformContext is an interface to support dynamic dispatch. +type ITransformContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + FROM() antlr.TerminalNode + NULL_() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + CONCAT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllConcat_item() []IConcat_itemContext + Concat_item(i int) IConcat_itemContext + RIGHT_PAREN() antlr.TerminalNode + LOBFILE() antlr.TerminalNode + AllLobfile_item() []ILobfile_itemContext + Lobfile_item(i int) ILobfile_itemContext + STARTOF() antlr.TerminalNode + Source_field() ISource_fieldContext + UNSIGNED_INTEGER() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Lobfile_attr_list() ILobfile_attr_listContext + + // IsTransformContext differentiates from other interfaces. + IsTransformContext() +} + +type TransformContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransformContext() *TransformContext { + var p = new(TransformContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transform + return p +} + +func InitEmptyTransformContext(p *TransformContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transform +} + +func (*TransformContext) IsTransformContext() {} + +func NewTransformContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TransformContext { + var p = new(TransformContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_transform + + return p +} + +func (s *TransformContext) GetParser() antlr.Parser { return s.parser } + +func (s *TransformContext) 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 *TransformContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *TransformContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *TransformContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *TransformContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *TransformContext) CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONCAT, 0) +} + +func (s *TransformContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *TransformContext) AllConcat_item() []IConcat_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcat_itemContext); ok { + len++ + } + } + + tst := make([]IConcat_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcat_itemContext); ok { + tst[i] = t.(IConcat_itemContext) + i++ + } + } + + return tst +} + +func (s *TransformContext) Concat_item(i int) IConcat_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcat_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcat_itemContext) +} + +func (s *TransformContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *TransformContext) LOBFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBFILE, 0) +} + +func (s *TransformContext) AllLobfile_item() []ILobfile_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILobfile_itemContext); ok { + len++ + } + } + + tst := make([]ILobfile_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILobfile_itemContext); ok { + tst[i] = t.(ILobfile_itemContext) + i++ + } + } + + return tst +} + +func (s *TransformContext) Lobfile_item(i int) ILobfile_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILobfile_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILobfile_itemContext) +} + +func (s *TransformContext) STARTOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTOF, 0) +} + +func (s *TransformContext) Source_field() ISource_fieldContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISource_fieldContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISource_fieldContext) +} + +func (s *TransformContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *TransformContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *TransformContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *TransformContext) Lobfile_attr_list() ILobfile_attr_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILobfile_attr_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILobfile_attr_listContext) +} + +func (s *TransformContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TransformContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TransformContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTransform(s) + } +} + +func (s *TransformContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTransform(s) + } +} + +func (s *TransformContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTransform(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Transform() (localctx ITransformContext) { + localctx = NewTransformContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1276, PlSqlParserRULE_transform) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12321) + p.Column_name() + } + { + p.SetState(12322) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(12323) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTANT: + { + p.SetState(12324) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12325) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONCAT: + { + p.SetState(12326) + p.Match(PlSqlParserCONCAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12327) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12328) + p.Concat_item() + } + p.SetState(12333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12329) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12330) + p.Concat_item() + } + + p.SetState(12335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12336) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOBFILE: + { + p.SetState(12338) + p.Match(PlSqlParserLOBFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12339) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12340) + p.Lobfile_item() + } + p.SetState(12345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12341) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12342) + p.Lobfile_item() + } + + p.SetState(12347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12348) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBLOB || _la == PlSqlParserCLOB || _la == PlSqlParserFROM || _la == PlSqlParserCHARACTERSET { + { + p.SetState(12349) + p.Lobfile_attr_list() + } + + } + + case PlSqlParserSTARTOF: + { + p.SetState(12352) + p.Match(PlSqlParserSTARTOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12353) + p.Source_field() + } + { + p.SetState(12354) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12355) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12356) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISource_fieldContext is an interface to support dynamic dispatch. +type ISource_fieldContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsSource_fieldContext differentiates from other interfaces. + IsSource_fieldContext() +} + +type Source_fieldContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySource_fieldContext() *Source_fieldContext { + var p = new(Source_fieldContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_field + return p +} + +func InitEmptySource_fieldContext(p *Source_fieldContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_source_field +} + +func (*Source_fieldContext) IsSource_fieldContext() {} + +func NewSource_fieldContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Source_fieldContext { + var p = new(Source_fieldContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_source_field + + return p +} + +func (s *Source_fieldContext) GetParser() antlr.Parser { return s.parser } + +func (s *Source_fieldContext) 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 *Source_fieldContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Source_fieldContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Source_fieldContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSource_field(s) + } +} + +func (s *Source_fieldContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSource_field(s) + } +} + +func (s *Source_fieldContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSource_field(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Source_field() (localctx ISource_fieldContext) { + localctx = NewSource_fieldContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1278, PlSqlParserRULE_source_field) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12360) + p.Column_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 +} + +// ILobfile_itemContext is an interface to support dynamic dispatch. +type ILobfile_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + CONSTANT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + COLON() antlr.TerminalNode + + // IsLobfile_itemContext differentiates from other interfaces. + IsLobfile_itemContext() +} + +type Lobfile_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLobfile_itemContext() *Lobfile_itemContext { + var p = new(Lobfile_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lobfile_item + return p +} + +func InitEmptyLobfile_itemContext(p *Lobfile_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lobfile_item +} + +func (*Lobfile_itemContext) IsLobfile_itemContext() {} + +func NewLobfile_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lobfile_itemContext { + var p = new(Lobfile_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lobfile_item + + return p +} + +func (s *Lobfile_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lobfile_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 *Lobfile_itemContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Lobfile_itemContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Lobfile_itemContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Lobfile_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lobfile_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lobfile_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLobfile_item(s) + } +} + +func (s *Lobfile_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLobfile_item(s) + } +} + +func (s *Lobfile_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLobfile_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lobfile_item() (localctx ILobfile_itemContext) { + localctx = NewLobfile_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1280, PlSqlParserRULE_lobfile_item) + p.SetState(12366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1550, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12362) + p.Column_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12363) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12364) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12365) + p.Match(PlSqlParserCOLON) + 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 +} + +// ILobfile_attr_listContext is an interface to support dynamic dispatch. +type ILobfile_attr_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FROM() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllDirectory_spec() []IDirectory_specContext + Directory_spec(i int) IDirectory_specContext + AllCOLON() []antlr.TerminalNode + COLON(i int) antlr.TerminalNode + AllFile_spec() []IFile_specContext + File_spec(i int) IFile_specContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + CHARACTERSET() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + + // IsLobfile_attr_listContext differentiates from other interfaces. + IsLobfile_attr_listContext() +} + +type Lobfile_attr_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLobfile_attr_listContext() *Lobfile_attr_listContext { + var p = new(Lobfile_attr_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lobfile_attr_list + return p +} + +func InitEmptyLobfile_attr_listContext(p *Lobfile_attr_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lobfile_attr_list +} + +func (*Lobfile_attr_listContext) IsLobfile_attr_listContext() {} + +func NewLobfile_attr_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lobfile_attr_listContext { + var p = new(Lobfile_attr_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lobfile_attr_list + + return p +} + +func (s *Lobfile_attr_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lobfile_attr_listContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Lobfile_attr_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Lobfile_attr_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Lobfile_attr_listContext) AllDirectory_spec() []IDirectory_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDirectory_specContext); ok { + len++ + } + } + + tst := make([]IDirectory_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDirectory_specContext); ok { + tst[i] = t.(IDirectory_specContext) + i++ + } + } + + return tst +} + +func (s *Lobfile_attr_listContext) Directory_spec(i int) IDirectory_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDirectory_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDirectory_specContext) +} + +func (s *Lobfile_attr_listContext) AllCOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLON) +} + +func (s *Lobfile_attr_listContext) COLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, i) +} + +func (s *Lobfile_attr_listContext) AllFile_spec() []IFile_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specContext); ok { + len++ + } + } + + tst := make([]IFile_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specContext); ok { + tst[i] = t.(IFile_specContext) + i++ + } + } + + return tst +} + +func (s *Lobfile_attr_listContext) File_spec(i int) IFile_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specContext) +} + +func (s *Lobfile_attr_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Lobfile_attr_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Lobfile_attr_listContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Lobfile_attr_listContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Lobfile_attr_listContext) CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERSET, 0) +} + +func (s *Lobfile_attr_listContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lobfile_attr_listContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Lobfile_attr_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lobfile_attr_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lobfile_attr_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLobfile_attr_list(s) + } +} + +func (s *Lobfile_attr_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLobfile_attr_list(s) + } +} + +func (s *Lobfile_attr_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLobfile_attr_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lobfile_attr_list() (localctx ILobfile_attr_listContext) { + localctx = NewLobfile_attr_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1282, PlSqlParserRULE_lobfile_attr_list) + var _la int + + p.SetState(12398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFROM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12368) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12369) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(12370) + p.Directory_spec() + } + { + p.SetState(12371) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12376) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12375) + p.File_spec() + } + + } + p.SetState(12389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12378) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12382) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(12379) + p.Directory_spec() + } + { + p.SetState(12380) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(12384) + p.File_spec() + } + + } + + p.SetState(12391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12392) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLOB: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12393) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(12394) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARACTERSET: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(12395) + p.Match(PlSqlParserCHARACTERSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12396) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12397) + p.Char_set_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 +} + +// IConcat_itemContext is an interface to support dynamic dispatch. +type IConcat_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + CONSTANT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsConcat_itemContext differentiates from other interfaces. + IsConcat_itemContext() +} + +type Concat_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConcat_itemContext() *Concat_itemContext { + var p = new(Concat_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concat_item + return p +} + +func InitEmptyConcat_itemContext(p *Concat_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concat_item +} + +func (*Concat_itemContext) IsConcat_itemContext() {} + +func NewConcat_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Concat_itemContext { + var p = new(Concat_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_concat_item + + return p +} + +func (s *Concat_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Concat_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 *Concat_itemContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Concat_itemContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Concat_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Concat_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Concat_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConcat_item(s) + } +} + +func (s *Concat_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConcat_item(s) + } +} + +func (s *Concat_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConcat_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Concat_item() (localctx IConcat_itemContext) { + localctx = NewConcat_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1284, PlSqlParserRULE_concat_item) + p.SetState(12403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1557, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12400) + p.Column_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12401) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12402) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IRow_movement_clauseContext is an interface to support dynamic dispatch. +type IRow_movement_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsRow_movement_clauseContext differentiates from other interfaces. + IsRow_movement_clauseContext() +} + +type Row_movement_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRow_movement_clauseContext() *Row_movement_clauseContext { + var p = new(Row_movement_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_row_movement_clause + return p +} + +func InitEmptyRow_movement_clauseContext(p *Row_movement_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_row_movement_clause +} + +func (*Row_movement_clauseContext) IsRow_movement_clauseContext() {} + +func NewRow_movement_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Row_movement_clauseContext { + var p = new(Row_movement_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_row_movement_clause + + return p +} + +func (s *Row_movement_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Row_movement_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Row_movement_clauseContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Row_movement_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Row_movement_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Row_movement_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Row_movement_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Row_movement_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRow_movement_clause(s) + } +} + +func (s *Row_movement_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRow_movement_clause(s) + } +} + +func (s *Row_movement_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRow_movement_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Row_movement_clause() (localctx IRow_movement_clauseContext) { + localctx = NewRow_movement_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1286, PlSqlParserRULE_row_movement_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12406) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + { + p.SetState(12405) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12408) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12409) + p.Match(PlSqlParserMOVEMENT) + 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 +} + +// IFlashback_archive_clauseContext is an interface to support dynamic dispatch. +type IFlashback_archive_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + Id_expression() IId_expressionContext + NO() antlr.TerminalNode + + // IsFlashback_archive_clauseContext differentiates from other interfaces. + IsFlashback_archive_clauseContext() +} + +type Flashback_archive_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext +} + +func NewEmptyFlashback_archive_clauseContext() *Flashback_archive_clauseContext { + var p = new(Flashback_archive_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause + return p +} + +func InitEmptyFlashback_archive_clauseContext(p *Flashback_archive_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause +} + +func (*Flashback_archive_clauseContext) IsFlashback_archive_clauseContext() {} + +func NewFlashback_archive_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_archive_clauseContext { + var p = new(Flashback_archive_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_archive_clause + + return p +} + +func (s *Flashback_archive_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_archive_clauseContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Flashback_archive_clauseContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Flashback_archive_clauseContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Flashback_archive_clauseContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Flashback_archive_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Flashback_archive_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Flashback_archive_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_archive_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_archive_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_archive_clause(s) + } +} + +func (s *Flashback_archive_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_archive_clause(s) + } +} + +func (s *Flashback_archive_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_archive_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_archive_clause() (localctx IFlashback_archive_clauseContext) { + localctx = NewFlashback_archive_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1288, PlSqlParserRULE_flashback_archive_clause) + p.SetState(12419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFLASHBACK: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12411) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12412) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12414) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1559, p.GetParserRuleContext()) == 1 { + { + p.SetState(12413) + + var _x = p.Id_expression() + + localctx.(*Flashback_archive_clauseContext).fa = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12416) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12417) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12418) + p.Match(PlSqlParserARCHIVE) + 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 +} + +// ILog_grpContext is an interface to support dynamic dispatch. +type ILog_grpContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsLog_grpContext differentiates from other interfaces. + IsLog_grpContext() +} + +type Log_grpContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLog_grpContext() *Log_grpContext { + var p = new(Log_grpContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_log_grp + return p +} + +func InitEmptyLog_grpContext(p *Log_grpContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_log_grp +} + +func (*Log_grpContext) IsLog_grpContext() {} + +func NewLog_grpContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Log_grpContext { + var p = new(Log_grpContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_log_grp + + return p +} + +func (s *Log_grpContext) GetParser() antlr.Parser { return s.parser } + +func (s *Log_grpContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Log_grpContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Log_grpContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Log_grpContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLog_grp(s) + } +} + +func (s *Log_grpContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLog_grp(s) + } +} + +func (s *Log_grpContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLog_grp(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Log_grp() (localctx ILog_grpContext) { + localctx = NewLog_grpContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1290, PlSqlParserRULE_log_grp) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12421) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// ISupplemental_table_loggingContext is an interface to support dynamic dispatch. +type ISupplemental_table_loggingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + AllSUPPLEMENTAL() []antlr.TerminalNode + SUPPLEMENTAL(i int) antlr.TerminalNode + AllLOG() []antlr.TerminalNode + LOG(i int) antlr.TerminalNode + AllSupplemental_log_grp_clause() []ISupplemental_log_grp_clauseContext + Supplemental_log_grp_clause(i int) ISupplemental_log_grp_clauseContext + AllSupplemental_id_key_clause() []ISupplemental_id_key_clauseContext + Supplemental_id_key_clause(i int) ISupplemental_id_key_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + AllGROUP() []antlr.TerminalNode + GROUP(i int) antlr.TerminalNode + AllLog_grp() []ILog_grpContext + Log_grp(i int) ILog_grpContext + + // IsSupplemental_table_loggingContext differentiates from other interfaces. + IsSupplemental_table_loggingContext() +} + +type Supplemental_table_loggingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_table_loggingContext() *Supplemental_table_loggingContext { + var p = new(Supplemental_table_loggingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging + return p +} + +func InitEmptySupplemental_table_loggingContext(p *Supplemental_table_loggingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging +} + +func (*Supplemental_table_loggingContext) IsSupplemental_table_loggingContext() {} + +func NewSupplemental_table_loggingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_table_loggingContext { + var p = new(Supplemental_table_loggingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_table_logging + + return p +} + +func (s *Supplemental_table_loggingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_table_loggingContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Supplemental_table_loggingContext) AllSUPPLEMENTAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSUPPLEMENTAL) +} + +func (s *Supplemental_table_loggingContext) SUPPLEMENTAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, i) +} + +func (s *Supplemental_table_loggingContext) AllLOG() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOG) +} + +func (s *Supplemental_table_loggingContext) LOG(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, i) +} + +func (s *Supplemental_table_loggingContext) AllSupplemental_log_grp_clause() []ISupplemental_log_grp_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + len++ + } + } + + tst := make([]ISupplemental_log_grp_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + tst[i] = t.(ISupplemental_log_grp_clauseContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Supplemental_log_grp_clause(i int) ISupplemental_log_grp_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_log_grp_clauseContext) +} + +func (s *Supplemental_table_loggingContext) AllSupplemental_id_key_clause() []ISupplemental_id_key_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + len++ + } + } + + tst := make([]ISupplemental_id_key_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + tst[i] = t.(ISupplemental_id_key_clauseContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Supplemental_id_key_clause(i int) ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_table_loggingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_table_loggingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_table_loggingContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Supplemental_table_loggingContext) AllGROUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGROUP) +} + +func (s *Supplemental_table_loggingContext) GROUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, i) +} + +func (s *Supplemental_table_loggingContext) AllLog_grp() []ILog_grpContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILog_grpContext); ok { + len++ + } + } + + tst := make([]ILog_grpContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILog_grpContext); ok { + tst[i] = t.(ILog_grpContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_table_loggingContext) Log_grp(i int) ILog_grpContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILog_grpContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILog_grpContext) +} + +func (s *Supplemental_table_loggingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_table_loggingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_table_loggingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_table_logging(s) + } +} + +func (s *Supplemental_table_loggingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_table_logging(s) + } +} + +func (s *Supplemental_table_loggingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_table_logging(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_table_logging() (localctx ISupplemental_table_loggingContext) { + localctx = NewSupplemental_table_loggingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1292, PlSqlParserRULE_supplemental_table_logging) + var _la int + + p.SetState(12463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12423) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12424) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12425) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(12426) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(12427) + p.Supplemental_id_key_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12430) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12431) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12432) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(12433) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(12434) + p.Supplemental_id_key_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12442) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12443) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12444) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12448) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(12445) + p.Supplemental_id_key_clause() + } + + case PlSqlParserGROUP: + { + p.SetState(12446) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12447) + p.Log_grp() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(12460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12450) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12451) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12452) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(12453) + p.Supplemental_id_key_clause() + } + + case PlSqlParserGROUP: + { + p.SetState(12454) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12455) + p.Log_grp() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12462) + 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 +} + +// ISupplemental_log_grp_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_log_grp_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + Log_grp() ILog_grpContext + LEFT_PAREN() antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + RIGHT_PAREN() antlr.TerminalNode + AllNO() []antlr.TerminalNode + NO(i int) antlr.TerminalNode + AllLOG() []antlr.TerminalNode + LOG(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ALWAYS() antlr.TerminalNode + + // IsSupplemental_log_grp_clauseContext differentiates from other interfaces. + IsSupplemental_log_grp_clauseContext() +} + +type Supplemental_log_grp_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_log_grp_clauseContext() *Supplemental_log_grp_clauseContext { + var p = new(Supplemental_log_grp_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause + return p +} + +func InitEmptySupplemental_log_grp_clauseContext(p *Supplemental_log_grp_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause +} + +func (*Supplemental_log_grp_clauseContext) IsSupplemental_log_grp_clauseContext() {} + +func NewSupplemental_log_grp_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_log_grp_clauseContext { + var p = new(Supplemental_log_grp_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_log_grp_clause + + return p +} + +func (s *Supplemental_log_grp_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_log_grp_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Supplemental_log_grp_clauseContext) Log_grp() ILog_grpContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILog_grpContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILog_grpContext) +} + +func (s *Supplemental_log_grp_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Supplemental_log_grp_clauseContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Supplemental_log_grp_clauseContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Supplemental_log_grp_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Supplemental_log_grp_clauseContext) AllNO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNO) +} + +func (s *Supplemental_log_grp_clauseContext) NO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, i) +} + +func (s *Supplemental_log_grp_clauseContext) AllLOG() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOG) +} + +func (s *Supplemental_log_grp_clauseContext) LOG(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, i) +} + +func (s *Supplemental_log_grp_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_log_grp_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_log_grp_clauseContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Supplemental_log_grp_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_log_grp_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_log_grp_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_log_grp_clause(s) + } +} + +func (s *Supplemental_log_grp_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_log_grp_clause(s) + } +} + +func (s *Supplemental_log_grp_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_log_grp_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_log_grp_clause() (localctx ISupplemental_log_grp_clauseContext) { + localctx = NewSupplemental_log_grp_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1294, PlSqlParserRULE_supplemental_log_grp_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12465) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12466) + p.Log_grp() + } + { + p.SetState(12467) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12468) + p.Regular_id() + } + p.SetState(12471) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(12469) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12470) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12481) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12473) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12474) + p.Regular_id() + } + p.SetState(12477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(12475) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12476) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(12483) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12484) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12486) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALWAYS { + { + p.SetState(12485) + p.Match(PlSqlParserALWAYS) + 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 +} + +// ISupplemental_id_key_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_id_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllPRIMARY() []antlr.TerminalNode + PRIMARY(i int) antlr.TerminalNode + AllKEY() []antlr.TerminalNode + KEY(i int) antlr.TerminalNode + AllUNIQUE() []antlr.TerminalNode + UNIQUE(i int) antlr.TerminalNode + AllFOREIGN() []antlr.TerminalNode + FOREIGN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSupplemental_id_key_clauseContext differentiates from other interfaces. + IsSupplemental_id_key_clauseContext() +} + +type Supplemental_id_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_id_key_clauseContext() *Supplemental_id_key_clauseContext { + var p = new(Supplemental_id_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause + return p +} + +func InitEmptySupplemental_id_key_clauseContext(p *Supplemental_id_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause +} + +func (*Supplemental_id_key_clauseContext) IsSupplemental_id_key_clauseContext() {} + +func NewSupplemental_id_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_id_key_clauseContext { + var p = new(Supplemental_id_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_id_key_clause + + return p +} + +func (s *Supplemental_id_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_id_key_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_id_key_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Supplemental_id_key_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Supplemental_id_key_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Supplemental_id_key_clauseContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Supplemental_id_key_clauseContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Supplemental_id_key_clauseContext) AllPRIMARY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPRIMARY) +} + +func (s *Supplemental_id_key_clauseContext) PRIMARY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, i) +} + +func (s *Supplemental_id_key_clauseContext) AllKEY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserKEY) +} + +func (s *Supplemental_id_key_clauseContext) KEY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, i) +} + +func (s *Supplemental_id_key_clauseContext) AllUNIQUE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNIQUE) +} + +func (s *Supplemental_id_key_clauseContext) UNIQUE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, i) +} + +func (s *Supplemental_id_key_clauseContext) AllFOREIGN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFOREIGN) +} + +func (s *Supplemental_id_key_clauseContext) FOREIGN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, i) +} + +func (s *Supplemental_id_key_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Supplemental_id_key_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Supplemental_id_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_id_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_id_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_id_key_clause(s) + } +} + +func (s *Supplemental_id_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_id_key_clause(s) + } +} + +func (s *Supplemental_id_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_id_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_id_key_clause() (localctx ISupplemental_id_key_clauseContext) { + localctx = NewSupplemental_id_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1296, PlSqlParserRULE_supplemental_id_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12488) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12489) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALL || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE || _la == PlSqlParserCOMMA { + p.SetState(12491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(12490) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12499) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(12493) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(12494) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12495) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(12496) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOREIGN: + { + p.SetState(12497) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12498) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12505) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12506) + p.Match(PlSqlParserCOLUMNS) + 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 +} + +// IAllocate_extent_clauseContext is an interface to support dynamic dispatch. +type IAllocate_extent_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDatafile returns the datafile token. + GetDatafile() antlr.Token + + // GetInst_num returns the inst_num token. + GetInst_num() antlr.Token + + // SetDatafile sets the datafile token. + SetDatafile(antlr.Token) + + // SetInst_num sets the inst_num token. + SetInst_num(antlr.Token) + + // Getter signatures + ALLOCATE() antlr.TerminalNode + EXTENT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllDATAFILE() []antlr.TerminalNode + DATAFILE(i int) antlr.TerminalNode + AllINSTANCE() []antlr.TerminalNode + INSTANCE(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + + // IsAllocate_extent_clauseContext differentiates from other interfaces. + IsAllocate_extent_clauseContext() +} + +type Allocate_extent_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + datafile antlr.Token + inst_num antlr.Token +} + +func NewEmptyAllocate_extent_clauseContext() *Allocate_extent_clauseContext { + var p = new(Allocate_extent_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause + return p +} + +func InitEmptyAllocate_extent_clauseContext(p *Allocate_extent_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause +} + +func (*Allocate_extent_clauseContext) IsAllocate_extent_clauseContext() {} + +func NewAllocate_extent_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Allocate_extent_clauseContext { + var p = new(Allocate_extent_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_allocate_extent_clause + + return p +} + +func (s *Allocate_extent_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Allocate_extent_clauseContext) GetDatafile() antlr.Token { return s.datafile } + +func (s *Allocate_extent_clauseContext) GetInst_num() antlr.Token { return s.inst_num } + +func (s *Allocate_extent_clauseContext) SetDatafile(v antlr.Token) { s.datafile = v } + +func (s *Allocate_extent_clauseContext) SetInst_num(v antlr.Token) { s.inst_num = v } + +func (s *Allocate_extent_clauseContext) ALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOCATE, 0) +} + +func (s *Allocate_extent_clauseContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Allocate_extent_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Allocate_extent_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Allocate_extent_clauseContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Allocate_extent_clauseContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Allocate_extent_clauseContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Allocate_extent_clauseContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Allocate_extent_clauseContext) AllDATAFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATAFILE) +} + +func (s *Allocate_extent_clauseContext) DATAFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, i) +} + +func (s *Allocate_extent_clauseContext) AllINSTANCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINSTANCE) +} + +func (s *Allocate_extent_clauseContext) INSTANCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, i) +} + +func (s *Allocate_extent_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Allocate_extent_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Allocate_extent_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Allocate_extent_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Allocate_extent_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Allocate_extent_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Allocate_extent_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAllocate_extent_clause(s) + } +} + +func (s *Allocate_extent_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAllocate_extent_clause(s) + } +} + +func (s *Allocate_extent_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAllocate_extent_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Allocate_extent_clause() (localctx IAllocate_extent_clauseContext) { + localctx = NewAllocate_extent_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1298, PlSqlParserRULE_allocate_extent_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12508) + p.Match(PlSqlParserALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12509) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(12510) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDATAFILE || _la == PlSqlParserINSTANCE || _la == PlSqlParserSIZE { + p.SetState(12517) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSIZE: + { + p.SetState(12511) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12512) + p.Size_clause() + } + + case PlSqlParserDATAFILE: + { + p.SetState(12513) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12514) + + var _m = p.Match(PlSqlParserCHAR_STRING) + + localctx.(*Allocate_extent_clauseContext).datafile = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINSTANCE: + { + p.SetState(12515) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12516) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Allocate_extent_clauseContext).inst_num = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12521) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDeallocate_unused_clauseContext is an interface to support dynamic dispatch. +type IDeallocate_unused_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEALLOCATE() antlr.TerminalNode + UNUSED() antlr.TerminalNode + KEEP() antlr.TerminalNode + Size_clause() ISize_clauseContext + + // IsDeallocate_unused_clauseContext differentiates from other interfaces. + IsDeallocate_unused_clauseContext() +} + +type Deallocate_unused_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeallocate_unused_clauseContext() *Deallocate_unused_clauseContext { + var p = new(Deallocate_unused_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause + return p +} + +func InitEmptyDeallocate_unused_clauseContext(p *Deallocate_unused_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause +} + +func (*Deallocate_unused_clauseContext) IsDeallocate_unused_clauseContext() {} + +func NewDeallocate_unused_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Deallocate_unused_clauseContext { + var p = new(Deallocate_unused_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_deallocate_unused_clause + + return p +} + +func (s *Deallocate_unused_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Deallocate_unused_clauseContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEALLOCATE, 0) +} + +func (s *Deallocate_unused_clauseContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Deallocate_unused_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Deallocate_unused_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Deallocate_unused_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Deallocate_unused_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Deallocate_unused_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeallocate_unused_clause(s) + } +} + +func (s *Deallocate_unused_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeallocate_unused_clause(s) + } +} + +func (s *Deallocate_unused_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDeallocate_unused_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Deallocate_unused_clause() (localctx IDeallocate_unused_clauseContext) { + localctx = NewDeallocate_unused_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1300, PlSqlParserRULE_deallocate_unused_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12524) + p.Match(PlSqlParserDEALLOCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12525) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12528) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(12526) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12527) + p.Size_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 +} + +// IShrink_clauseContext is an interface to support dynamic dispatch. +type IShrink_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + COMPACT() antlr.TerminalNode + CASCADE() antlr.TerminalNode + + // IsShrink_clauseContext differentiates from other interfaces. + IsShrink_clauseContext() +} + +type Shrink_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyShrink_clauseContext() *Shrink_clauseContext { + var p = new(Shrink_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_shrink_clause + return p +} + +func InitEmptyShrink_clauseContext(p *Shrink_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_shrink_clause +} + +func (*Shrink_clauseContext) IsShrink_clauseContext() {} + +func NewShrink_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Shrink_clauseContext { + var p = new(Shrink_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_shrink_clause + + return p +} + +func (s *Shrink_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Shrink_clauseContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Shrink_clauseContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Shrink_clauseContext) COMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPACT, 0) +} + +func (s *Shrink_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Shrink_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Shrink_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Shrink_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterShrink_clause(s) + } +} + +func (s *Shrink_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitShrink_clause(s) + } +} + +func (s *Shrink_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitShrink_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Shrink_clause() (localctx IShrink_clauseContext) { + localctx = NewShrink_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1302, PlSqlParserRULE_shrink_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12530) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12531) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPACT { + { + p.SetState(12532) + p.Match(PlSqlParserCOMPACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(12535) + p.Match(PlSqlParserCASCADE) + 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 +} + +// IRecords_per_block_clauseContext is an interface to support dynamic dispatch. +type IRecords_per_block_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORDS_PER_BLOCK() antlr.TerminalNode + MINIMIZE() antlr.TerminalNode + NOMINIMIZE() antlr.TerminalNode + + // IsRecords_per_block_clauseContext differentiates from other interfaces. + IsRecords_per_block_clauseContext() +} + +type Records_per_block_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecords_per_block_clauseContext() *Records_per_block_clauseContext { + var p = new(Records_per_block_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_records_per_block_clause + return p +} + +func InitEmptyRecords_per_block_clauseContext(p *Records_per_block_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_records_per_block_clause +} + +func (*Records_per_block_clauseContext) IsRecords_per_block_clauseContext() {} + +func NewRecords_per_block_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Records_per_block_clauseContext { + var p = new(Records_per_block_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_records_per_block_clause + + return p +} + +func (s *Records_per_block_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Records_per_block_clauseContext) RECORDS_PER_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS_PER_BLOCK, 0) +} + +func (s *Records_per_block_clauseContext) MINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMIZE, 0) +} + +func (s *Records_per_block_clauseContext) NOMINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINIMIZE, 0) +} + +func (s *Records_per_block_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Records_per_block_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Records_per_block_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecords_per_block_clause(s) + } +} + +func (s *Records_per_block_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecords_per_block_clause(s) + } +} + +func (s *Records_per_block_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRecords_per_block_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Records_per_block_clause() (localctx IRecords_per_block_clauseContext) { + localctx = NewRecords_per_block_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1304, PlSqlParserRULE_records_per_block_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMINIMIZE || _la == PlSqlParserNOMINIMIZE { + { + p.SetState(12538) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMINIMIZE || _la == PlSqlParserNOMINIMIZE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(12541) + p.Match(PlSqlParserRECORDS_PER_BLOCK) + 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 +} + +// IUpgrade_table_clauseContext is an interface to support dynamic dispatch. +type IUpgrade_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + Column_properties() IColumn_propertiesContext + INCLUDING() antlr.TerminalNode + DATA() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsUpgrade_table_clauseContext differentiates from other interfaces. + IsUpgrade_table_clauseContext() +} + +type Upgrade_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpgrade_table_clauseContext() *Upgrade_table_clauseContext { + var p = new(Upgrade_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause + return p +} + +func InitEmptyUpgrade_table_clauseContext(p *Upgrade_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause +} + +func (*Upgrade_table_clauseContext) IsUpgrade_table_clauseContext() {} + +func NewUpgrade_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upgrade_table_clauseContext { + var p = new(Upgrade_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upgrade_table_clause + + return p +} + +func (s *Upgrade_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upgrade_table_clauseContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Upgrade_table_clauseContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Upgrade_table_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Upgrade_table_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Upgrade_table_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Upgrade_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upgrade_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upgrade_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpgrade_table_clause(s) + } +} + +func (s *Upgrade_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpgrade_table_clause(s) + } +} + +func (s *Upgrade_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpgrade_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Upgrade_table_clause() (localctx IUpgrade_table_clauseContext) { + localctx = NewUpgrade_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1306, PlSqlParserRULE_upgrade_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12543) + p.Match(PlSqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(12545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(12544) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12547) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12548) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(12550) + p.Column_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 +} + +// 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 + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + PURGE() antlr.TerminalNode + + // 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 = PlSqlParserRULE_truncate_table + return p +} + +func InitEmptyTruncate_tableContext(p *Truncate_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_truncate_table + + return p +} + +func (s *Truncate_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_tableContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Truncate_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Truncate_tableContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Truncate_tableContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterTruncate_table(s) + } +} + +func (s *Truncate_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_table(s) + } +} + +func (s *Truncate_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTruncate_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Truncate_table() (localctx ITruncate_tableContext) { + localctx = NewTruncate_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1308, PlSqlParserRULE_truncate_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12552) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12553) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12554) + p.Tableview_name() + } + p.SetState(12556) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(12555) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12558) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// 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 + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + PURGE() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_table + return p +} + +func InitEmptyDrop_tableContext(p *Drop_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_table + + return p +} + +func (s *Drop_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tableContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Drop_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_tableContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_tableContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_tableContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Drop_tableContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_table(s) + } +} + +func (s *Drop_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_table(s) + } +} + +func (s *Drop_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_table() (localctx IDrop_tableContext) { + localctx = NewDrop_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1310, PlSqlParserRULE_drop_table) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12560) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12561) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12562) + p.Tableview_name() + } + p.SetState(12565) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(12563) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12564) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(12568) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPURGE { + { + p.SetState(12567) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12570) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDrop_tablespaceContext is an interface to support dynamic dispatch. +type IDrop_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTs returns the ts rule contexts. + GetTs() IId_expressionContext + + // SetTs sets the ts rule contexts. + SetTs(IId_expressionContext) + + // Getter signatures + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Including_contents_clause() IIncluding_contents_clauseContext + KEEP() antlr.TerminalNode + QUOTA() antlr.TerminalNode + + // IsDrop_tablespaceContext differentiates from other interfaces. + IsDrop_tablespaceContext() +} + +type Drop_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ts IId_expressionContext +} + +func NewEmptyDrop_tablespaceContext() *Drop_tablespaceContext { + var p = new(Drop_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace + return p +} + +func InitEmptyDrop_tablespaceContext(p *Drop_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace +} + +func (*Drop_tablespaceContext) IsDrop_tablespaceContext() {} + +func NewDrop_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tablespaceContext { + var p = new(Drop_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_tablespace + + return p +} + +func (s *Drop_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tablespaceContext) GetTs() IId_expressionContext { return s.ts } + +func (s *Drop_tablespaceContext) SetTs(v IId_expressionContext) { s.ts = v } + +func (s *Drop_tablespaceContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Drop_tablespaceContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Drop_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Drop_tablespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_tablespaceContext) Including_contents_clause() IIncluding_contents_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncluding_contents_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncluding_contents_clauseContext) +} + +func (s *Drop_tablespaceContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Drop_tablespaceContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Drop_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_tablespace(s) + } +} + +func (s *Drop_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_tablespace(s) + } +} + +func (s *Drop_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_tablespace() (localctx IDrop_tablespaceContext) { + localctx = NewDrop_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1312, PlSqlParserRULE_drop_tablespace) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12572) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12573) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12574) + + var _x = p.Id_expression() + + localctx.(*Drop_tablespaceContext).ts = _x + } + p.SetState(12579) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1587, p.GetParserRuleContext()) == 1 { + { + p.SetState(12575) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(12577) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1586, p.GetParserRuleContext()) == 1 { + { + p.SetState(12576) + p.Match(PlSqlParserQUOTA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12582) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1588, p.GetParserRuleContext()) == 1 { + { + p.SetState(12581) + p.Including_contents_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 +} + +// IDrop_tablespace_setContext is an interface to support dynamic dispatch. +type IDrop_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + Id_expression() IId_expressionContext + Including_contents_clause() IIncluding_contents_clauseContext + + // IsDrop_tablespace_setContext differentiates from other interfaces. + IsDrop_tablespace_setContext() +} + +type Drop_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext +} + +func NewEmptyDrop_tablespace_setContext() *Drop_tablespace_setContext { + var p = new(Drop_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set + return p +} + +func InitEmptyDrop_tablespace_setContext(p *Drop_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set +} + +func (*Drop_tablespace_setContext) IsDrop_tablespace_setContext() {} + +func NewDrop_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_tablespace_setContext { + var p = new(Drop_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_tablespace_set + + return p +} + +func (s *Drop_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Drop_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Drop_tablespace_setContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Drop_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Drop_tablespace_setContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_tablespace_setContext) Including_contents_clause() IIncluding_contents_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIncluding_contents_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIncluding_contents_clauseContext) +} + +func (s *Drop_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_tablespace_set(s) + } +} + +func (s *Drop_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_tablespace_set(s) + } +} + +func (s *Drop_tablespace_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_tablespace_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_tablespace_set() (localctx IDrop_tablespace_setContext) { + localctx = NewDrop_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1314, PlSqlParserRULE_drop_tablespace_set) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12584) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12585) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12586) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12587) + + var _x = p.Id_expression() + + localctx.(*Drop_tablespace_setContext).tss = _x + } + p.SetState(12589) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1589, p.GetParserRuleContext()) == 1 { + { + p.SetState(12588) + p.Including_contents_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 +} + +// IIncluding_contents_clauseContext is an interface to support dynamic dispatch. +type IIncluding_contents_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INCLUDING() antlr.TerminalNode + CONTENTS() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + AND() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsIncluding_contents_clauseContext differentiates from other interfaces. + IsIncluding_contents_clauseContext() +} + +type Including_contents_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIncluding_contents_clauseContext() *Including_contents_clauseContext { + var p = new(Including_contents_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_contents_clause + return p +} + +func InitEmptyIncluding_contents_clauseContext(p *Including_contents_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_including_contents_clause +} + +func (*Including_contents_clauseContext) IsIncluding_contents_clauseContext() {} + +func NewIncluding_contents_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Including_contents_clauseContext { + var p = new(Including_contents_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_including_contents_clause + + return p +} + +func (s *Including_contents_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Including_contents_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Including_contents_clauseContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Including_contents_clauseContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Including_contents_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Including_contents_clauseContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Including_contents_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Including_contents_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Including_contents_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Including_contents_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Including_contents_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIncluding_contents_clause(s) + } +} + +func (s *Including_contents_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIncluding_contents_clause(s) + } +} + +func (s *Including_contents_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIncluding_contents_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Including_contents_clause() (localctx IIncluding_contents_clauseContext) { + localctx = NewIncluding_contents_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1316, PlSqlParserRULE_including_contents_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12591) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12592) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12595) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1590, p.GetParserRuleContext()) == 1 { + { + p.SetState(12593) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAND || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12594) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12599) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1591, p.GetParserRuleContext()) == 1 { + { + p.SetState(12597) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12598) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_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 + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_view + return p +} + +func InitEmptyDrop_viewContext(p *Drop_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_view + + return p +} + +func (s *Drop_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_viewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Drop_viewContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Drop_viewContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_viewContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_view(s) + } +} + +func (s *Drop_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_view(s) + } +} + +func (s *Drop_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_view() (localctx IDrop_viewContext) { + localctx = NewDrop_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1318, PlSqlParserRULE_drop_view) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12601) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12602) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12603) + p.Tableview_name() + } + p.SetState(12606) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(12604) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12605) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12608) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IComment_on_columnContext is an interface to support dynamic dispatch. +type IComment_on_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_columnContext differentiates from other interfaces. + IsComment_on_columnContext() +} + +type Comment_on_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_columnContext() *Comment_on_columnContext { + var p = new(Comment_on_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_column + return p +} + +func InitEmptyComment_on_columnContext(p *Comment_on_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_column +} + +func (*Comment_on_columnContext) IsComment_on_columnContext() {} + +func NewComment_on_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_columnContext { + var p = new(Comment_on_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_column + + return p +} + +func (s *Comment_on_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_columnContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_columnContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_columnContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Comment_on_columnContext) 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 *Comment_on_columnContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_columnContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_column(s) + } +} + +func (s *Comment_on_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_column(s) + } +} + +func (s *Comment_on_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComment_on_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Comment_on_column() (localctx IComment_on_columnContext) { + localctx = NewComment_on_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1320, PlSqlParserRULE_comment_on_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12610) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12611) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12612) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12613) + p.Column_name() + } + { + p.SetState(12614) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12615) + p.Quoted_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 +} + +// IEnable_or_disableContext is an interface to support dynamic dispatch. +type IEnable_or_disableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsEnable_or_disableContext differentiates from other interfaces. + IsEnable_or_disableContext() +} + +type Enable_or_disableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_or_disableContext() *Enable_or_disableContext { + var p = new(Enable_or_disableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_or_disable + return p +} + +func InitEmptyEnable_or_disableContext(p *Enable_or_disableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_or_disable +} + +func (*Enable_or_disableContext) IsEnable_or_disableContext() {} + +func NewEnable_or_disableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_or_disableContext { + var p = new(Enable_or_disableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_or_disable + + return p +} + +func (s *Enable_or_disableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_or_disableContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_or_disableContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_or_disableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_or_disableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_or_disableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_or_disable(s) + } +} + +func (s *Enable_or_disableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_or_disable(s) + } +} + +func (s *Enable_or_disableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnable_or_disable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Enable_or_disable() (localctx IEnable_or_disableContext) { + localctx = NewEnable_or_disableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1322, PlSqlParserRULE_enable_or_disable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12617) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + 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 +} + +// IAllow_or_disallowContext is an interface to support dynamic dispatch. +type IAllow_or_disallowContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALLOW() antlr.TerminalNode + DISALLOW() antlr.TerminalNode + + // IsAllow_or_disallowContext differentiates from other interfaces. + IsAllow_or_disallowContext() +} + +type Allow_or_disallowContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAllow_or_disallowContext() *Allow_or_disallowContext { + var p = new(Allow_or_disallowContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allow_or_disallow + return p +} + +func InitEmptyAllow_or_disallowContext(p *Allow_or_disallowContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_allow_or_disallow +} + +func (*Allow_or_disallowContext) IsAllow_or_disallowContext() {} + +func NewAllow_or_disallowContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Allow_or_disallowContext { + var p = new(Allow_or_disallowContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_allow_or_disallow + + return p +} + +func (s *Allow_or_disallowContext) GetParser() antlr.Parser { return s.parser } + +func (s *Allow_or_disallowContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Allow_or_disallowContext) DISALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISALLOW, 0) +} + +func (s *Allow_or_disallowContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Allow_or_disallowContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Allow_or_disallowContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAllow_or_disallow(s) + } +} + +func (s *Allow_or_disallowContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAllow_or_disallow(s) + } +} + +func (s *Allow_or_disallowContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAllow_or_disallow(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Allow_or_disallow() (localctx IAllow_or_disallowContext) { + localctx = NewAllow_or_disallowContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1324, PlSqlParserRULE_allow_or_disallow) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12619) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW) { + 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_synonymContext is an interface to support dynamic dispatch. +type IAlter_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + EDITIONABLE() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + COMPILE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_synonymContext differentiates from other interfaces. + IsAlter_synonymContext() +} + +type Alter_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_synonymContext() *Alter_synonymContext { + var p = new(Alter_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_synonym + return p +} + +func InitEmptyAlter_synonymContext(p *Alter_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_synonym +} + +func (*Alter_synonymContext) IsAlter_synonymContext() {} + +func NewAlter_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_synonymContext { + var p = new(Alter_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_synonym + + return p +} + +func (s *Alter_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_synonymContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Alter_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Alter_synonymContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Alter_synonymContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Alter_synonymContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_synonymContext) 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 *Alter_synonymContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_synonym(s) + } +} + +func (s *Alter_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_synonym(s) + } +} + +func (s *Alter_synonymContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_synonym(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_synonym() (localctx IAlter_synonymContext) { + localctx = NewAlter_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1326, PlSqlParserRULE_alter_synonym) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12621) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12623) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(12622) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12625) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12629) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1594, p.GetParserRuleContext()) == 1 { + { + p.SetState(12626) + p.Schema_name() + } + { + p.SetState(12627) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12631) + p.Synonym_name() + } + { + p.SetState(12632) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMPILE || _la == PlSqlParserEDITIONABLE || _la == PlSqlParserNONEDITIONABLE) { + 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_synonymContext is an interface to support dynamic dispatch. +type ICreate_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + FOR() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + AllSchema_name() []ISchema_nameContext + Schema_name(i int) ISchema_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsCreate_synonymContext differentiates from other interfaces. + IsCreate_synonymContext() +} + +type Create_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_synonymContext() *Create_synonymContext { + var p = new(Create_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_synonym + return p +} + +func InitEmptyCreate_synonymContext(p *Create_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_synonym +} + +func (*Create_synonymContext) IsCreate_synonymContext() {} + +func NewCreate_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_synonymContext { + var p = new(Create_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_synonym + + return p +} + +func (s *Create_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_synonymContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Create_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Create_synonymContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Create_synonymContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Create_synonymContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Create_synonymContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Create_synonymContext) 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 *Create_synonymContext) 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 *Create_synonymContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Create_synonymContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Create_synonymContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Create_synonymContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Create_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_synonym(s) + } +} + +func (s *Create_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_synonym(s) + } +} + +func (s *Create_synonymContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_synonym(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_synonym() (localctx ICreate_synonymContext) { + localctx = NewCreate_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1328, PlSqlParserRULE_create_synonym) + var _la int + + p.SetState(12676) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1602, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12634) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(12635) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12636) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12639) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12640) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12641) + p.Synonym_name() + } + { + p.SetState(12642) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12646) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1596, p.GetParserRuleContext()) == 1 { + { + p.SetState(12643) + p.Schema_name() + } + { + p.SetState(12644) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12648) + p.Schema_object_name() + } + p.SetState(12651) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1597, p.GetParserRuleContext()) == 1 { + { + p.SetState(12649) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12650) + p.Link_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(12653) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12656) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(12654) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12655) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12658) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12662) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1599, p.GetParserRuleContext()) == 1 { + { + p.SetState(12659) + p.Schema_name() + } + { + p.SetState(12660) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12664) + p.Synonym_name() + } + { + p.SetState(12665) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1600, p.GetParserRuleContext()) == 1 { + { + p.SetState(12666) + p.Schema_name() + } + { + p.SetState(12667) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12671) + p.Schema_object_name() + } + p.SetState(12674) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1601, p.GetParserRuleContext()) == 1 { + { + p.SetState(12672) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12673) + p.Link_name() + } + + } 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 +} + +// IDrop_synonymContext is an interface to support dynamic dispatch. +type IDrop_synonymContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + Synonym_name() ISynonym_nameContext + PUBLIC() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_synonymContext differentiates from other interfaces. + IsDrop_synonymContext() +} + +type Drop_synonymContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_synonymContext() *Drop_synonymContext { + var p = new(Drop_synonymContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_synonym + return p +} + +func InitEmptyDrop_synonymContext(p *Drop_synonymContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_synonym +} + +func (*Drop_synonymContext) IsDrop_synonymContext() {} + +func NewDrop_synonymContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_synonymContext { + var p = new(Drop_synonymContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_synonym + + return p +} + +func (s *Drop_synonymContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_synonymContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_synonymContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *Drop_synonymContext) Synonym_name() ISynonym_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISynonym_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISynonym_nameContext) +} + +func (s *Drop_synonymContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Drop_synonymContext) 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_synonymContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_synonymContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_synonymContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_synonymContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_synonymContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_synonym(s) + } +} + +func (s *Drop_synonymContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_synonym(s) + } +} + +func (s *Drop_synonymContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_synonym(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_synonym() (localctx IDrop_synonymContext) { + localctx = NewDrop_synonymContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1330, PlSqlParserRULE_drop_synonym) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12678) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(12679) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12682) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12686) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1604, p.GetParserRuleContext()) == 1 { + { + p.SetState(12683) + p.Schema_name() + } + { + p.SetState(12684) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12688) + p.Synonym_name() + } + p.SetState(12690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1605, p.GetParserRuleContext()) == 1 { + { + p.SetState(12689) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_spfileContext is an interface to support dynamic dispatch. +type ICreate_spfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + SPFILE() antlr.TerminalNode + FROM() antlr.TerminalNode + PFILE() antlr.TerminalNode + MEMORY() antlr.TerminalNode + AllEQUALS_OP() []antlr.TerminalNode + EQUALS_OP(i int) antlr.TerminalNode + Spfile_name() ISpfile_nameContext + Pfile_name() IPfile_nameContext + AS() antlr.TerminalNode + COPY() antlr.TerminalNode + + // IsCreate_spfileContext differentiates from other interfaces. + IsCreate_spfileContext() +} + +type Create_spfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_spfileContext() *Create_spfileContext { + var p = new(Create_spfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_spfile + return p +} + +func InitEmptyCreate_spfileContext(p *Create_spfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_spfile +} + +func (*Create_spfileContext) IsCreate_spfileContext() {} + +func NewCreate_spfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_spfileContext { + var p = new(Create_spfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_spfile + + return p +} + +func (s *Create_spfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_spfileContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_spfileContext) SPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPFILE, 0) +} + +func (s *Create_spfileContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Create_spfileContext) PFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPFILE, 0) +} + +func (s *Create_spfileContext) MEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMORY, 0) +} + +func (s *Create_spfileContext) AllEQUALS_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEQUALS_OP) +} + +func (s *Create_spfileContext) EQUALS_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, i) +} + +func (s *Create_spfileContext) Spfile_name() ISpfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISpfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISpfile_nameContext) +} + +func (s *Create_spfileContext) Pfile_name() IPfile_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPfile_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPfile_nameContext) +} + +func (s *Create_spfileContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_spfileContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Create_spfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_spfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_spfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_spfile(s) + } +} + +func (s *Create_spfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_spfile(s) + } +} + +func (s *Create_spfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_spfile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_spfile() (localctx ICreate_spfileContext) { + localctx = NewCreate_spfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1332, PlSqlParserRULE_create_spfile) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12692) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12693) + p.Match(PlSqlParserSPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12696) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEQUALS_OP { + { + p.SetState(12694) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12695) + p.Spfile_name() + } + + } + { + p.SetState(12698) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPFILE: + { + p.SetState(12699) + p.Match(PlSqlParserPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12702) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1607, p.GetParserRuleContext()) == 1 { + { + p.SetState(12700) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12701) + p.Pfile_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12706) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1608, p.GetParserRuleContext()) == 1 { + { + p.SetState(12704) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12705) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserMEMORY: + { + p.SetState(12708) + p.Match(PlSqlParserMEMORY) + 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 +} + +// ISpfile_nameContext is an interface to support dynamic dispatch. +type ISpfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsSpfile_nameContext differentiates from other interfaces. + IsSpfile_nameContext() +} + +type Spfile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySpfile_nameContext() *Spfile_nameContext { + var p = new(Spfile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_spfile_name + return p +} + +func InitEmptySpfile_nameContext(p *Spfile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_spfile_name +} + +func (*Spfile_nameContext) IsSpfile_nameContext() {} + +func NewSpfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Spfile_nameContext { + var p = new(Spfile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_spfile_name + + return p +} + +func (s *Spfile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Spfile_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Spfile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Spfile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Spfile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSpfile_name(s) + } +} + +func (s *Spfile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSpfile_name(s) + } +} + +func (s *Spfile_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSpfile_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Spfile_name() (localctx ISpfile_nameContext) { + localctx = NewSpfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1334, PlSqlParserRULE_spfile_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12711) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IPfile_nameContext is an interface to support dynamic dispatch. +type IPfile_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsPfile_nameContext differentiates from other interfaces. + IsPfile_nameContext() +} + +type Pfile_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPfile_nameContext() *Pfile_nameContext { + var p = new(Pfile_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pfile_name + return p +} + +func InitEmptyPfile_nameContext(p *Pfile_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pfile_name +} + +func (*Pfile_nameContext) IsPfile_nameContext() {} + +func NewPfile_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pfile_nameContext { + var p = new(Pfile_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pfile_name + + return p +} + +func (s *Pfile_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pfile_nameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Pfile_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pfile_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pfile_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPfile_name(s) + } +} + +func (s *Pfile_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPfile_name(s) + } +} + +func (s *Pfile_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPfile_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pfile_name() (localctx IPfile_nameContext) { + localctx = NewPfile_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1336, PlSqlParserRULE_pfile_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12713) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IComment_on_tableContext is an interface to support dynamic dispatch. +type IComment_on_tableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_tableContext differentiates from other interfaces. + IsComment_on_tableContext() +} + +type Comment_on_tableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_tableContext() *Comment_on_tableContext { + var p = new(Comment_on_tableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_table + return p +} + +func InitEmptyComment_on_tableContext(p *Comment_on_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_table +} + +func (*Comment_on_tableContext) IsComment_on_tableContext() {} + +func NewComment_on_tableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_tableContext { + var p = new(Comment_on_tableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_table + + return p +} + +func (s *Comment_on_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_tableContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_tableContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_tableContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Comment_on_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Comment_on_tableContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_tableContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_tableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_tableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_tableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_table(s) + } +} + +func (s *Comment_on_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_table(s) + } +} + +func (s *Comment_on_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComment_on_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Comment_on_table() (localctx IComment_on_tableContext) { + localctx = NewComment_on_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1338, PlSqlParserRULE_comment_on_table) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12715) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12716) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12717) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12718) + p.Tableview_name() + } + { + p.SetState(12719) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12720) + p.Quoted_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 +} + +// IComment_on_materializedContext is an interface to support dynamic dispatch. +type IComment_on_materializedContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMENT() antlr.TerminalNode + ON() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + Tableview_name() ITableview_nameContext + IS() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + + // IsComment_on_materializedContext differentiates from other interfaces. + IsComment_on_materializedContext() +} + +type Comment_on_materializedContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyComment_on_materializedContext() *Comment_on_materializedContext { + var p = new(Comment_on_materializedContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_materialized + return p +} + +func InitEmptyComment_on_materializedContext(p *Comment_on_materializedContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_comment_on_materialized +} + +func (*Comment_on_materializedContext) IsComment_on_materializedContext() {} + +func NewComment_on_materializedContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Comment_on_materializedContext { + var p = new(Comment_on_materializedContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_comment_on_materialized + + return p +} + +func (s *Comment_on_materializedContext) GetParser() antlr.Parser { return s.parser } + +func (s *Comment_on_materializedContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Comment_on_materializedContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Comment_on_materializedContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Comment_on_materializedContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Comment_on_materializedContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Comment_on_materializedContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Comment_on_materializedContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Comment_on_materializedContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Comment_on_materializedContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Comment_on_materializedContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterComment_on_materialized(s) + } +} + +func (s *Comment_on_materializedContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitComment_on_materialized(s) + } +} + +func (s *Comment_on_materializedContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitComment_on_materialized(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Comment_on_materialized() (localctx IComment_on_materializedContext) { + localctx = NewComment_on_materializedContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1340, PlSqlParserRULE_comment_on_materialized) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12722) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12723) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12724) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12725) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12726) + p.Tableview_name() + } + { + p.SetState(12727) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12728) + p.Quoted_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 +} + +// IAlter_analytic_viewContext is an interface to support dynamic dispatch. +type IAlter_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Alter_add_cache_clause() IAlter_add_cache_clauseContext + Alter_drop_cache_clause() IAlter_drop_cache_clauseContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_analytic_viewContext differentiates from other interfaces. + IsAlter_analytic_viewContext() +} + +type Alter_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyAlter_analytic_viewContext() *Alter_analytic_viewContext { + var p = new(Alter_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_analytic_view + return p +} + +func InitEmptyAlter_analytic_viewContext(p *Alter_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_analytic_view +} + +func (*Alter_analytic_viewContext) IsAlter_analytic_viewContext() {} + +func NewAlter_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_analytic_viewContext { + var p = new(Alter_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_analytic_view + + return p +} + +func (s *Alter_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Alter_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Alter_analytic_viewContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Alter_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Alter_analytic_viewContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_analytic_viewContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_analytic_viewContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_analytic_viewContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_analytic_viewContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_analytic_viewContext) Alter_add_cache_clause() IAlter_add_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_add_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_add_cache_clauseContext) +} + +func (s *Alter_analytic_viewContext) Alter_drop_cache_clause() IAlter_drop_cache_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_drop_cache_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_drop_cache_clauseContext) +} + +func (s *Alter_analytic_viewContext) 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 *Alter_analytic_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_analytic_view(s) + } +} + +func (s *Alter_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_analytic_view(s) + } +} + +func (s *Alter_analytic_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_analytic_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_analytic_view() (localctx IAlter_analytic_viewContext) { + localctx = NewAlter_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1342, PlSqlParserRULE_alter_analytic_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12730) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12731) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12732) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12736) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1610, p.GetParserRuleContext()) == 1 { + { + p.SetState(12733) + p.Schema_name() + } + { + p.SetState(12734) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12738) + + var _x = p.Id_expression() + + localctx.(*Alter_analytic_viewContext).av = _x + } + p.SetState(12745) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(12739) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12740) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12741) + p.Id_expression() + } + + case PlSqlParserCOMPILE: + { + p.SetState(12742) + p.Match(PlSqlParserCOMPILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserADD: + { + p.SetState(12743) + p.Alter_add_cache_clause() + } + + case PlSqlParserDROP: + { + p.SetState(12744) + p.Alter_drop_cache_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 +} + +// IAlter_add_cache_clauseContext is an interface to support dynamic dispatch. +type IAlter_add_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + CACHE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + LEVELS() antlr.TerminalNode + AllLevels_item() []ILevels_itemContext + Levels_item(i int) ILevels_itemContext + ALL() antlr.TerminalNode + Measure_list() IMeasure_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_add_cache_clauseContext differentiates from other interfaces. + IsAlter_add_cache_clauseContext() +} + +type Alter_add_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_add_cache_clauseContext() *Alter_add_cache_clauseContext { + var p = new(Alter_add_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause + return p +} + +func InitEmptyAlter_add_cache_clauseContext(p *Alter_add_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause +} + +func (*Alter_add_cache_clauseContext) IsAlter_add_cache_clauseContext() {} + +func NewAlter_add_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_add_cache_clauseContext { + var p = new(Alter_add_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_add_cache_clause + + return p +} + +func (s *Alter_add_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_add_cache_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_add_cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Alter_add_cache_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Alter_add_cache_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_add_cache_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_add_cache_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_add_cache_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_add_cache_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_add_cache_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Alter_add_cache_clauseContext) AllLevels_item() []ILevels_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_itemContext); ok { + len++ + } + } + + tst := make([]ILevels_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_itemContext); ok { + tst[i] = t.(ILevels_itemContext) + i++ + } + } + + return tst +} + +func (s *Alter_add_cache_clauseContext) Levels_item(i int) ILevels_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_itemContext) +} + +func (s *Alter_add_cache_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_add_cache_clauseContext) Measure_list() IMeasure_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasure_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasure_listContext) +} + +func (s *Alter_add_cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_add_cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_add_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_add_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_add_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_add_cache_clause(s) + } +} + +func (s *Alter_add_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_add_cache_clause(s) + } +} + +func (s *Alter_add_cache_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_add_cache_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_add_cache_clause() (localctx IAlter_add_cache_clauseContext) { + localctx = NewAlter_add_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1344, PlSqlParserRULE_alter_add_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12747) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12748) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12749) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12750) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12751) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(12752) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(12753) + p.Measure_list() + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(12756) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12757) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12758) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12759) + p.Levels_item() + } + p.SetState(12764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12760) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12761) + p.Levels_item() + } + + p.SetState(12766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12767) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILevels_itemContext is an interface to support dynamic dispatch. +type ILevels_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // GetH returns the h rule contexts. + GetH() IId_expressionContext + + // GetL returns the l rule contexts. + GetL() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // SetH sets the h rule contexts. + SetH(IId_expressionContext) + + // SetL sets the l rule contexts. + SetL(IId_expressionContext) + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsLevels_itemContext differentiates from other interfaces. + IsLevels_itemContext() +} + +type Levels_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext + h IId_expressionContext + l IId_expressionContext +} + +func NewEmptyLevels_itemContext() *Levels_itemContext { + var p = new(Levels_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_item + return p +} + +func InitEmptyLevels_itemContext(p *Levels_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_levels_item +} + +func (*Levels_itemContext) IsLevels_itemContext() {} + +func NewLevels_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Levels_itemContext { + var p = new(Levels_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_levels_item + + return p +} + +func (s *Levels_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Levels_itemContext) GetD() IId_expressionContext { return s.d } + +func (s *Levels_itemContext) GetH() IId_expressionContext { return s.h } + +func (s *Levels_itemContext) GetL() IId_expressionContext { return s.l } + +func (s *Levels_itemContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *Levels_itemContext) SetH(v IId_expressionContext) { s.h = v } + +func (s *Levels_itemContext) SetL(v IId_expressionContext) { s.l = v } + +func (s *Levels_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Levels_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Levels_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Levels_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Levels_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Levels_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Levels_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLevels_item(s) + } +} + +func (s *Levels_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLevels_item(s) + } +} + +func (s *Levels_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLevels_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Levels_item() (localctx ILevels_itemContext) { + localctx = NewLevels_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1346, PlSqlParserRULE_levels_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(12777) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1615, p.GetParserRuleContext()) == 1 { + p.SetState(12772) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1614, p.GetParserRuleContext()) == 1 { + { + p.SetState(12769) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).d = _x + } + { + p.SetState(12770) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12774) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).h = _x + } + { + p.SetState(12775) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12779) + + var _x = p.Id_expression() + + localctx.(*Levels_itemContext).l = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMeasure_listContext is an interface to support dynamic dispatch. +type IMeasure_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsMeasure_listContext differentiates from other interfaces. + IsMeasure_listContext() +} + +type Measure_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMeasure_listContext() *Measure_listContext { + var p = new(Measure_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measure_list + return p +} + +func InitEmptyMeasure_listContext(p *Measure_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_measure_list +} + +func (*Measure_listContext) IsMeasure_listContext() {} + +func NewMeasure_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Measure_listContext { + var p = new(Measure_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_measure_list + + return p +} + +func (s *Measure_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Measure_listContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Measure_listContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Measure_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Measure_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Measure_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Measure_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Measure_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMeasure_list(s) + } +} + +func (s *Measure_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMeasure_list(s) + } +} + +func (s *Measure_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMeasure_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Measure_list() (localctx IMeasure_listContext) { + localctx = NewMeasure_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1348, PlSqlParserRULE_measure_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12781) + p.Id_expression() + } + p.SetState(12786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12782) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12783) + p.Id_expression() + } + + p.SetState(12788) + 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_drop_cache_clauseContext is an interface to support dynamic dispatch. +type IAlter_drop_cache_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CACHE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + GROUP() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + LEVELS() antlr.TerminalNode + AllLevels_item() []ILevels_itemContext + Levels_item(i int) ILevels_itemContext + ALL() antlr.TerminalNode + Measure_list() IMeasure_listContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAlter_drop_cache_clauseContext differentiates from other interfaces. + IsAlter_drop_cache_clauseContext() +} + +type Alter_drop_cache_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_drop_cache_clauseContext() *Alter_drop_cache_clauseContext { + var p = new(Alter_drop_cache_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause + return p +} + +func InitEmptyAlter_drop_cache_clauseContext(p *Alter_drop_cache_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause +} + +func (*Alter_drop_cache_clauseContext) IsAlter_drop_cache_clauseContext() {} + +func NewAlter_drop_cache_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_drop_cache_clauseContext { + var p = new(Alter_drop_cache_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_drop_cache_clause + + return p +} + +func (s *Alter_drop_cache_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_drop_cache_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_drop_cache_clauseContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Alter_drop_cache_clauseContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Alter_drop_cache_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Alter_drop_cache_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_drop_cache_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_drop_cache_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_drop_cache_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_drop_cache_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Alter_drop_cache_clauseContext) AllLevels_item() []ILevels_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILevels_itemContext); ok { + len++ + } + } + + tst := make([]ILevels_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILevels_itemContext); ok { + tst[i] = t.(ILevels_itemContext) + i++ + } + } + + return tst +} + +func (s *Alter_drop_cache_clauseContext) Levels_item(i int) ILevels_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILevels_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILevels_itemContext) +} + +func (s *Alter_drop_cache_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Alter_drop_cache_clauseContext) Measure_list() IMeasure_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMeasure_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMeasure_listContext) +} + +func (s *Alter_drop_cache_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_drop_cache_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_drop_cache_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_drop_cache_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_drop_cache_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_drop_cache_clause(s) + } +} + +func (s *Alter_drop_cache_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_drop_cache_clause(s) + } +} + +func (s *Alter_drop_cache_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_drop_cache_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_drop_cache_clause() (localctx IAlter_drop_cache_clauseContext) { + localctx = NewAlter_drop_cache_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1350, PlSqlParserRULE_alter_drop_cache_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12789) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12790) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12791) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12792) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12793) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(12794) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(12795) + p.Measure_list() + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + { + p.SetState(12798) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12799) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12800) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12801) + p.Levels_item() + } + p.SetState(12806) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(12802) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12803) + p.Levels_item() + } + + p.SetState(12808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(12809) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_attribute_dimensionContext is an interface to support dynamic dispatch. +type IAlter_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // GetNad returns the nad rule contexts. + GetNad() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // SetNad sets the nad rule contexts. + SetNad(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + COMPILE() antlr.TerminalNode + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsAlter_attribute_dimensionContext differentiates from other interfaces. + IsAlter_attribute_dimensionContext() +} + +type Alter_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext + nad IId_expressionContext +} + +func NewEmptyAlter_attribute_dimensionContext() *Alter_attribute_dimensionContext { + var p = new(Alter_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension + return p +} + +func InitEmptyAlter_attribute_dimensionContext(p *Alter_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension +} + +func (*Alter_attribute_dimensionContext) IsAlter_attribute_dimensionContext() {} + +func NewAlter_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_attribute_dimensionContext { + var p = new(Alter_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_attribute_dimension + + return p +} + +func (s *Alter_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Alter_attribute_dimensionContext) GetNad() IId_expressionContext { return s.nad } + +func (s *Alter_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Alter_attribute_dimensionContext) SetNad(v IId_expressionContext) { s.nad = v } + +func (s *Alter_attribute_dimensionContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Alter_attribute_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Alter_attribute_dimensionContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_attribute_dimensionContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_attribute_dimensionContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_attribute_dimensionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_attribute_dimensionContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Alter_attribute_dimensionContext) 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 *Alter_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Alter_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_attribute_dimension(s) + } +} + +func (s *Alter_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_attribute_dimension(s) + } +} + +func (s *Alter_attribute_dimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_attribute_dimension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_attribute_dimension() (localctx IAlter_attribute_dimensionContext) { + localctx = NewAlter_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1352, PlSqlParserRULE_alter_attribute_dimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12811) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12812) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12813) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12817) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1619, p.GetParserRuleContext()) == 1 { + { + p.SetState(12814) + p.Schema_name() + } + { + p.SetState(12815) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12819) + + var _x = p.Id_expression() + + localctx.(*Alter_attribute_dimensionContext).ad = _x + } + p.SetState(12824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + { + p.SetState(12820) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12821) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12822) + + var _x = p.Id_expression() + + localctx.(*Alter_attribute_dimensionContext).nad = _x + } + + case PlSqlParserCOMPILE: + { + p.SetState(12823) + p.Match(PlSqlParserCOMPILE) + 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_audit_policyContext is an interface to support dynamic dispatch. +type IAlter_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + ADD() antlr.TerminalNode + AllDROP() []antlr.TerminalNode + DROP(i int) antlr.TerminalNode + CONDITION() antlr.TerminalNode + AllPrivilege_audit_clause() []IPrivilege_audit_clauseContext + Privilege_audit_clause(i int) IPrivilege_audit_clauseContext + AllAction_audit_clause() []IAction_audit_clauseContext + Action_audit_clause(i int) IAction_audit_clauseContext + AllRole_audit_clause() []IRole_audit_clauseContext + Role_audit_clause(i int) IRole_audit_clauseContext + AllONLY() []antlr.TerminalNode + ONLY(i int) antlr.TerminalNode + AllTOPLEVEL() []antlr.TerminalNode + TOPLEVEL(i int) antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + EVALUATE() antlr.TerminalNode + PER() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + SESSION() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + + // IsAlter_audit_policyContext differentiates from other interfaces. + IsAlter_audit_policyContext() +} + +type Alter_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyAlter_audit_policyContext() *Alter_audit_policyContext { + var p = new(Alter_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_audit_policy + return p +} + +func InitEmptyAlter_audit_policyContext(p *Alter_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_audit_policy +} + +func (*Alter_audit_policyContext) IsAlter_audit_policyContext() {} + +func NewAlter_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_audit_policyContext { + var p = new(Alter_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_audit_policy + + return p +} + +func (s *Alter_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Alter_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Alter_audit_policyContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Alter_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Alter_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_audit_policyContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Alter_audit_policyContext) AllDROP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDROP) +} + +func (s *Alter_audit_policyContext) DROP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, i) +} + +func (s *Alter_audit_policyContext) CONDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITION, 0) +} + +func (s *Alter_audit_policyContext) AllPrivilege_audit_clause() []IPrivilege_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IPrivilege_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPrivilege_audit_clauseContext); ok { + tst[i] = t.(IPrivilege_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Privilege_audit_clause(i int) IPrivilege_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrivilege_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPrivilege_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllAction_audit_clause() []IAction_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IAction_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAction_audit_clauseContext); ok { + tst[i] = t.(IAction_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Action_audit_clause(i int) IAction_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAction_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAction_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllRole_audit_clause() []IRole_audit_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + len++ + } + } + + tst := make([]IRole_audit_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRole_audit_clauseContext); ok { + tst[i] = t.(IRole_audit_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_audit_policyContext) Role_audit_clause(i int) IRole_audit_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_audit_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRole_audit_clauseContext) +} + +func (s *Alter_audit_policyContext) AllONLY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLY) +} + +func (s *Alter_audit_policyContext) ONLY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, i) +} + +func (s *Alter_audit_policyContext) AllTOPLEVEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTOPLEVEL) +} + +func (s *Alter_audit_policyContext) TOPLEVEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, i) +} + +func (s *Alter_audit_policyContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Alter_audit_policyContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Alter_audit_policyContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Alter_audit_policyContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Alter_audit_policyContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Alter_audit_policyContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Alter_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_audit_policy(s) + } +} + +func (s *Alter_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_audit_policy(s) + } +} + +func (s *Alter_audit_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_audit_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_audit_policy() (localctx IAlter_audit_policyContext) { + localctx = NewAlter_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1354, PlSqlParserRULE_alter_audit_policy) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12826) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12827) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12828) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12829) + + var _x = p.Id_expression() + + localctx.(*Alter_audit_policyContext).p = _x + } + p.SetState(12831) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1621, p.GetParserRuleContext()) == 1 { + { + p.SetState(12830) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1626, p.GetParserRuleContext()) { + case 1: + p.SetState(12834) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1622, p.GetParserRuleContext()) == 1 { + { + p.SetState(12833) + p.Privilege_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12837) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1623, p.GetParserRuleContext()) == 1 { + { + p.SetState(12836) + p.Action_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12840) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1624, p.GetParserRuleContext()) == 1 { + { + p.SetState(12839) + p.Role_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(12844) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1625, p.GetParserRuleContext()) == 1 { + { + p.SetState(12842) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12843) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(12849) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1627, p.GetParserRuleContext()) == 1 { + { + p.SetState(12848) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1632, p.GetParserRuleContext()) { + case 1: + p.SetState(12852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1628, p.GetParserRuleContext()) == 1 { + { + p.SetState(12851) + p.Privilege_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12855) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1629, p.GetParserRuleContext()) == 1 { + { + p.SetState(12854) + p.Action_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(12858) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1630, p.GetParserRuleContext()) == 1 { + { + p.SetState(12857) + p.Role_audit_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.SetState(12862) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1631, p.GetParserRuleContext()) == 1 { + { + p.SetState(12860) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12861) + p.Match(PlSqlParserTOPLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(12874) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1634, p.GetParserRuleContext()) == 1 { + { + p.SetState(12866) + p.Match(PlSqlParserCONDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12872) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDROP: + { + p.SetState(12867) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHAR_STRING: + { + p.SetState(12868) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12869) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12870) + p.Match(PlSqlParserPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12871) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINSTANCE || _la == PlSqlParserSESSION || _la == PlSqlParserSTATEMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_clusterContext is an interface to support dynamic dispatch. +type IAlter_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + SEMICOLON() antlr.TerminalNode + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllCache_or_nocache() []ICache_or_nocacheContext + Cache_or_nocache(i int) ICache_or_nocacheContext + Parallel_clause() IParallel_clauseContext + + // IsAlter_clusterContext differentiates from other interfaces. + IsAlter_clusterContext() +} + +type Alter_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_clusterContext() *Alter_clusterContext { + var p = new(Alter_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_cluster + return p +} + +func InitEmptyAlter_clusterContext(p *Alter_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_cluster +} + +func (*Alter_clusterContext) IsAlter_clusterContext() {} + +func NewAlter_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_clusterContext { + var p = new(Alter_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_cluster + + return p +} + +func (s *Alter_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_clusterContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Alter_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Alter_clusterContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_clusterContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_clusterContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Alter_clusterContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Alter_clusterContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_clusterContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_clusterContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_clusterContext) AllCache_or_nocache() []ICache_or_nocacheContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + len++ + } + } + + tst := make([]ICache_or_nocacheContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICache_or_nocacheContext); ok { + tst[i] = t.(ICache_or_nocacheContext) + i++ + } + } + + return tst +} + +func (s *Alter_clusterContext) Cache_or_nocache(i int) ICache_or_nocacheContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICache_or_nocacheContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICache_or_nocacheContext) +} + +func (s *Alter_clusterContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_cluster(s) + } +} + +func (s *Alter_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_cluster(s) + } +} + +func (s *Alter_clusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_cluster(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_cluster() (localctx IAlter_clusterContext) { + localctx = NewAlter_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1356, PlSqlParserRULE_alter_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12876) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12877) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12878) + p.Cluster_name() + } + p.SetState(12885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCACHE || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserINITRANS || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCACHE || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSIZE || _la == PlSqlParserSTORAGE { + p.SetState(12885) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(12879) + p.Physical_attributes_clause() + } + + case PlSqlParserSIZE: + { + p.SetState(12880) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12881) + p.Size_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(12882) + p.Allocate_extent_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(12883) + p.Deallocate_unused_clause() + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + { + p.SetState(12884) + p.Cache_or_nocache() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(12887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(12890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(12889) + p.Parallel_clause() + } + + } + { + p.SetState(12892) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDrop_analytic_viewContext is an interface to support dynamic dispatch. +type IDrop_analytic_viewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAv returns the av rule contexts. + GetAv() IId_expressionContext + + // SetAv sets the av rule contexts. + SetAv(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + VIEW() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_analytic_viewContext differentiates from other interfaces. + IsDrop_analytic_viewContext() +} + +type Drop_analytic_viewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + av IId_expressionContext +} + +func NewEmptyDrop_analytic_viewContext() *Drop_analytic_viewContext { + var p = new(Drop_analytic_viewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_analytic_view + return p +} + +func InitEmptyDrop_analytic_viewContext(p *Drop_analytic_viewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_analytic_view +} + +func (*Drop_analytic_viewContext) IsDrop_analytic_viewContext() {} + +func NewDrop_analytic_viewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_analytic_viewContext { + var p = new(Drop_analytic_viewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_analytic_view + + return p +} + +func (s *Drop_analytic_viewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_analytic_viewContext) GetAv() IId_expressionContext { return s.av } + +func (s *Drop_analytic_viewContext) SetAv(v IId_expressionContext) { s.av = v } + +func (s *Drop_analytic_viewContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_analytic_viewContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Drop_analytic_viewContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Drop_analytic_viewContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_analytic_viewContext) 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_analytic_viewContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_analytic_viewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_analytic_viewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_analytic_viewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_analytic_view(s) + } +} + +func (s *Drop_analytic_viewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_analytic_view(s) + } +} + +func (s *Drop_analytic_viewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_analytic_view(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_analytic_view() (localctx IDrop_analytic_viewContext) { + localctx = NewDrop_analytic_viewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1358, PlSqlParserRULE_drop_analytic_view) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12894) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12895) + p.Match(PlSqlParserANALYTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12896) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12900) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1638, p.GetParserRuleContext()) == 1 { + { + p.SetState(12897) + p.Schema_name() + } + { + p.SetState(12898) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12902) + + var _x = p.Id_expression() + + localctx.(*Drop_analytic_viewContext).av = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_attribute_dimensionContext is an interface to support dynamic dispatch. +type IDrop_attribute_dimensionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAd returns the ad rule contexts. + GetAd() IId_expressionContext + + // SetAd sets the ad rule contexts. + SetAd(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + Id_expression() IId_expressionContext + Schema_name() ISchema_nameContext + PERIOD() antlr.TerminalNode + + // IsDrop_attribute_dimensionContext differentiates from other interfaces. + IsDrop_attribute_dimensionContext() +} + +type Drop_attribute_dimensionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ad IId_expressionContext +} + +func NewEmptyDrop_attribute_dimensionContext() *Drop_attribute_dimensionContext { + var p = new(Drop_attribute_dimensionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension + return p +} + +func InitEmptyDrop_attribute_dimensionContext(p *Drop_attribute_dimensionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension +} + +func (*Drop_attribute_dimensionContext) IsDrop_attribute_dimensionContext() {} + +func NewDrop_attribute_dimensionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_attribute_dimensionContext { + var p = new(Drop_attribute_dimensionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_attribute_dimension + + return p +} + +func (s *Drop_attribute_dimensionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_attribute_dimensionContext) GetAd() IId_expressionContext { return s.ad } + +func (s *Drop_attribute_dimensionContext) SetAd(v IId_expressionContext) { s.ad = v } + +func (s *Drop_attribute_dimensionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_attribute_dimensionContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Drop_attribute_dimensionContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Drop_attribute_dimensionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_attribute_dimensionContext) 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_attribute_dimensionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Drop_attribute_dimensionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_attribute_dimensionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_attribute_dimensionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_attribute_dimension(s) + } +} + +func (s *Drop_attribute_dimensionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_attribute_dimension(s) + } +} + +func (s *Drop_attribute_dimensionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_attribute_dimension(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_attribute_dimension() (localctx IDrop_attribute_dimensionContext) { + localctx = NewDrop_attribute_dimensionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1360, PlSqlParserRULE_drop_attribute_dimension) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12904) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12905) + p.Match(PlSqlParserATTRIBUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12906) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12910) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1639, p.GetParserRuleContext()) == 1 { + { + p.SetState(12907) + p.Schema_name() + } + { + p.SetState(12908) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(12912) + + var _x = p.Id_expression() + + localctx.(*Drop_attribute_dimensionContext).ad = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_audit_policyContext is an interface to support dynamic dispatch. +type IDrop_audit_policyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetP returns the p rule contexts. + GetP() IId_expressionContext + + // SetP sets the p rule contexts. + SetP(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + AUDIT() antlr.TerminalNode + POLICY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_audit_policyContext differentiates from other interfaces. + IsDrop_audit_policyContext() +} + +type Drop_audit_policyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + p IId_expressionContext +} + +func NewEmptyDrop_audit_policyContext() *Drop_audit_policyContext { + var p = new(Drop_audit_policyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_audit_policy + return p +} + +func InitEmptyDrop_audit_policyContext(p *Drop_audit_policyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_audit_policy +} + +func (*Drop_audit_policyContext) IsDrop_audit_policyContext() {} + +func NewDrop_audit_policyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_audit_policyContext { + var p = new(Drop_audit_policyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_audit_policy + + return p +} + +func (s *Drop_audit_policyContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_audit_policyContext) GetP() IId_expressionContext { return s.p } + +func (s *Drop_audit_policyContext) SetP(v IId_expressionContext) { s.p = v } + +func (s *Drop_audit_policyContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_audit_policyContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *Drop_audit_policyContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Drop_audit_policyContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_audit_policyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_audit_policyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_audit_policyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_audit_policy(s) + } +} + +func (s *Drop_audit_policyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_audit_policy(s) + } +} + +func (s *Drop_audit_policyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_audit_policy(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_audit_policy() (localctx IDrop_audit_policyContext) { + localctx = NewDrop_audit_policyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1362, PlSqlParserRULE_drop_audit_policy) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12914) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12915) + p.Match(PlSqlParserAUDIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12916) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12917) + + var _x = p.Id_expression() + + localctx.(*Drop_audit_policyContext).p = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_flashback_archiveContext is an interface to support dynamic dispatch. +type IDrop_flashback_archiveContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetFa returns the fa rule contexts. + GetFa() IId_expressionContext + + // SetFa sets the fa rule contexts. + SetFa(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_flashback_archiveContext differentiates from other interfaces. + IsDrop_flashback_archiveContext() +} + +type Drop_flashback_archiveContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fa IId_expressionContext +} + +func NewEmptyDrop_flashback_archiveContext() *Drop_flashback_archiveContext { + var p = new(Drop_flashback_archiveContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive + return p +} + +func InitEmptyDrop_flashback_archiveContext(p *Drop_flashback_archiveContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive +} + +func (*Drop_flashback_archiveContext) IsDrop_flashback_archiveContext() {} + +func NewDrop_flashback_archiveContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_flashback_archiveContext { + var p = new(Drop_flashback_archiveContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_flashback_archive + + return p +} + +func (s *Drop_flashback_archiveContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_flashback_archiveContext) GetFa() IId_expressionContext { return s.fa } + +func (s *Drop_flashback_archiveContext) SetFa(v IId_expressionContext) { s.fa = v } + +func (s *Drop_flashback_archiveContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_flashback_archiveContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Drop_flashback_archiveContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Drop_flashback_archiveContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_flashback_archiveContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_flashback_archiveContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_flashback_archiveContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_flashback_archive(s) + } +} + +func (s *Drop_flashback_archiveContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_flashback_archive(s) + } +} + +func (s *Drop_flashback_archiveContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_flashback_archive(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_flashback_archive() (localctx IDrop_flashback_archiveContext) { + localctx = NewDrop_flashback_archiveContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1364, PlSqlParserRULE_drop_flashback_archive) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12919) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12920) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12921) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12922) + + var _x = p.Id_expression() + + localctx.(*Drop_flashback_archiveContext).fa = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_clusterContext is an interface to support dynamic dispatch. +type IDrop_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + INCLUDING() antlr.TerminalNode + TABLES() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + + // IsDrop_clusterContext differentiates from other interfaces. + IsDrop_clusterContext() +} + +type Drop_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_clusterContext() *Drop_clusterContext { + var p = new(Drop_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_cluster + return p +} + +func InitEmptyDrop_clusterContext(p *Drop_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_cluster +} + +func (*Drop_clusterContext) IsDrop_clusterContext() {} + +func NewDrop_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_clusterContext { + var p = new(Drop_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_cluster + + return p +} + +func (s *Drop_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_clusterContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Drop_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Drop_clusterContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_clusterContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Drop_clusterContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_clusterContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Drop_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_cluster(s) + } +} + +func (s *Drop_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_cluster(s) + } +} + +func (s *Drop_clusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_cluster(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_cluster() (localctx IDrop_clusterContext) { + localctx = NewDrop_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1366, PlSqlParserRULE_drop_cluster) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12924) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12925) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12926) + p.Cluster_name() + } + p.SetState(12933) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1641, p.GetParserRuleContext()) == 1 { + { + p.SetState(12927) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12928) + p.Match(PlSqlParserTABLES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12931) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1640, p.GetParserRuleContext()) == 1 { + { + p.SetState(12929) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12930) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_contextContext is an interface to support dynamic dispatch. +type IDrop_contextContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNs returns the ns rule contexts. + GetNs() IId_expressionContext + + // SetNs sets the ns rule contexts. + SetNs(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_contextContext differentiates from other interfaces. + IsDrop_contextContext() +} + +type Drop_contextContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ns IId_expressionContext +} + +func NewEmptyDrop_contextContext() *Drop_contextContext { + var p = new(Drop_contextContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_context + return p +} + +func InitEmptyDrop_contextContext(p *Drop_contextContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_context +} + +func (*Drop_contextContext) IsDrop_contextContext() {} + +func NewDrop_contextContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_contextContext { + var p = new(Drop_contextContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_context + + return p +} + +func (s *Drop_contextContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_contextContext) GetNs() IId_expressionContext { return s.ns } + +func (s *Drop_contextContext) SetNs(v IId_expressionContext) { s.ns = v } + +func (s *Drop_contextContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_contextContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Drop_contextContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_contextContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_contextContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_contextContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_context(s) + } +} + +func (s *Drop_contextContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_context(s) + } +} + +func (s *Drop_contextContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_context(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_context() (localctx IDrop_contextContext) { + localctx = NewDrop_contextContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1368, PlSqlParserRULE_drop_context) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12935) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12936) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12937) + + var _x = p.Id_expression() + + localctx.(*Drop_contextContext).ns = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_directoryContext is an interface to support dynamic dispatch. +type IDrop_directoryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDn returns the dn rule contexts. + GetDn() IId_expressionContext + + // SetDn sets the dn rule contexts. + SetDn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_directoryContext differentiates from other interfaces. + IsDrop_directoryContext() +} + +type Drop_directoryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dn IId_expressionContext +} + +func NewEmptyDrop_directoryContext() *Drop_directoryContext { + var p = new(Drop_directoryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_directory + return p +} + +func InitEmptyDrop_directoryContext(p *Drop_directoryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_directory +} + +func (*Drop_directoryContext) IsDrop_directoryContext() {} + +func NewDrop_directoryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_directoryContext { + var p = new(Drop_directoryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_directory + + return p +} + +func (s *Drop_directoryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_directoryContext) GetDn() IId_expressionContext { return s.dn } + +func (s *Drop_directoryContext) SetDn(v IId_expressionContext) { s.dn = v } + +func (s *Drop_directoryContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_directoryContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Drop_directoryContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_directoryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_directoryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_directoryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_directory(s) + } +} + +func (s *Drop_directoryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_directory(s) + } +} + +func (s *Drop_directoryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_directory(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_directory() (localctx IDrop_directoryContext) { + localctx = NewDrop_directoryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1370, PlSqlParserRULE_drop_directory) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12939) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12940) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12941) + + var _x = p.Id_expression() + + localctx.(*Drop_directoryContext).dn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_diskgroupContext is an interface to support dynamic dispatch. +type IDrop_diskgroupContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetDgn returns the dgn rule contexts. + GetDgn() IId_expressionContext + + // SetDgn sets the dgn rule contexts. + SetDgn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + Id_expression() IId_expressionContext + CONTENTS() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsDrop_diskgroupContext differentiates from other interfaces. + IsDrop_diskgroupContext() +} + +type Drop_diskgroupContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + dgn IId_expressionContext +} + +func NewEmptyDrop_diskgroupContext() *Drop_diskgroupContext { + var p = new(Drop_diskgroupContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup + return p +} + +func InitEmptyDrop_diskgroupContext(p *Drop_diskgroupContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_diskgroup +} + +func (*Drop_diskgroupContext) IsDrop_diskgroupContext() {} + +func NewDrop_diskgroupContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_diskgroupContext { + var p = new(Drop_diskgroupContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_diskgroup + + return p +} + +func (s *Drop_diskgroupContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_diskgroupContext) GetDgn() IId_expressionContext { return s.dgn } + +func (s *Drop_diskgroupContext) SetDgn(v IId_expressionContext) { s.dgn = v } + +func (s *Drop_diskgroupContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_diskgroupContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Drop_diskgroupContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_diskgroupContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Drop_diskgroupContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_diskgroupContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Drop_diskgroupContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Drop_diskgroupContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_diskgroupContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_diskgroupContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_diskgroup(s) + } +} + +func (s *Drop_diskgroupContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_diskgroup(s) + } +} + +func (s *Drop_diskgroupContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_diskgroup(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_diskgroup() (localctx IDrop_diskgroupContext) { + localctx = NewDrop_diskgroupContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1372, PlSqlParserRULE_drop_diskgroup) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12943) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12944) + p.Match(PlSqlParserDISKGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12945) + + var _x = p.Id_expression() + + localctx.(*Drop_diskgroupContext).dgn = _x + } + p.SetState(12954) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1644, p.GetParserRuleContext()) == 1 { + p.SetState(12951) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFORCE, PlSqlParserINCLUDING: + p.SetState(12947) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(12946) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12949) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLUDING: + { + p.SetState(12950) + p.Match(PlSqlParserEXCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(12953) + p.Match(PlSqlParserCONTENTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_editionContext is an interface to support dynamic dispatch. +type IDrop_editionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetE returns the e rule contexts. + GetE() IId_expressionContext + + // SetE sets the e rule contexts. + SetE(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + EDITION() antlr.TerminalNode + Id_expression() IId_expressionContext + CASCADE() antlr.TerminalNode + + // IsDrop_editionContext differentiates from other interfaces. + IsDrop_editionContext() +} + +type Drop_editionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + e IId_expressionContext +} + +func NewEmptyDrop_editionContext() *Drop_editionContext { + var p = new(Drop_editionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_edition + return p +} + +func InitEmptyDrop_editionContext(p *Drop_editionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_edition +} + +func (*Drop_editionContext) IsDrop_editionContext() {} + +func NewDrop_editionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_editionContext { + var p = new(Drop_editionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_edition + + return p +} + +func (s *Drop_editionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_editionContext) GetE() IId_expressionContext { return s.e } + +func (s *Drop_editionContext) SetE(v IId_expressionContext) { s.e = v } + +func (s *Drop_editionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_editionContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Drop_editionContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_editionContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_editionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_editionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_editionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_edition(s) + } +} + +func (s *Drop_editionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_edition(s) + } +} + +func (s *Drop_editionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_edition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_edition() (localctx IDrop_editionContext) { + localctx = NewDrop_editionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1374, PlSqlParserRULE_drop_edition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12956) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12957) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12958) + + var _x = p.Id_expression() + + localctx.(*Drop_editionContext).e = _x + } + p.SetState(12960) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1645, p.GetParserRuleContext()) == 1 { + { + p.SetState(12959) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_clusterContext is an interface to support dynamic dispatch. +type ITruncate_clusterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + Cluster_name() ICluster_nameContext + STORAGE() antlr.TerminalNode + DROP() antlr.TerminalNode + REUSE() antlr.TerminalNode + + // IsTruncate_clusterContext differentiates from other interfaces. + IsTruncate_clusterContext() +} + +type Truncate_clusterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_clusterContext() *Truncate_clusterContext { + var p = new(Truncate_clusterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_cluster + return p +} + +func InitEmptyTruncate_clusterContext(p *Truncate_clusterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_cluster +} + +func (*Truncate_clusterContext) IsTruncate_clusterContext() {} + +func NewTruncate_clusterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_clusterContext { + var p = new(Truncate_clusterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_truncate_cluster + + return p +} + +func (s *Truncate_clusterContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_clusterContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_clusterContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Truncate_clusterContext) Cluster_name() ICluster_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICluster_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICluster_nameContext) +} + +func (s *Truncate_clusterContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Truncate_clusterContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Truncate_clusterContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Truncate_clusterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_clusterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_clusterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTruncate_cluster(s) + } +} + +func (s *Truncate_clusterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_cluster(s) + } +} + +func (s *Truncate_clusterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTruncate_cluster(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Truncate_cluster() (localctx ITruncate_clusterContext) { + localctx = NewTruncate_clusterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1376, PlSqlParserRULE_truncate_cluster) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12962) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12963) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12964) + p.Cluster_name() + } + p.SetState(12967) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1646, p.GetParserRuleContext()) == 1 { + { + p.SetState(12965) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserREUSE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(12966) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICache_or_nocacheContext is an interface to support dynamic dispatch. +type ICache_or_nocacheContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + + // IsCache_or_nocacheContext differentiates from other interfaces. + IsCache_or_nocacheContext() +} + +type Cache_or_nocacheContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCache_or_nocacheContext() *Cache_or_nocacheContext { + var p = new(Cache_or_nocacheContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_or_nocache + return p +} + +func InitEmptyCache_or_nocacheContext(p *Cache_or_nocacheContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cache_or_nocache +} + +func (*Cache_or_nocacheContext) IsCache_or_nocacheContext() {} + +func NewCache_or_nocacheContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cache_or_nocacheContext { + var p = new(Cache_or_nocacheContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cache_or_nocache + + return p +} + +func (s *Cache_or_nocacheContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cache_or_nocacheContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Cache_or_nocacheContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Cache_or_nocacheContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cache_or_nocacheContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cache_or_nocacheContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCache_or_nocache(s) + } +} + +func (s *Cache_or_nocacheContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCache_or_nocache(s) + } +} + +func (s *Cache_or_nocacheContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCache_or_nocache(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cache_or_nocache() (localctx ICache_or_nocacheContext) { + localctx = NewCache_or_nocacheContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1378, PlSqlParserRULE_cache_or_nocache) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12969) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + 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 +} + +// IDatabase_nameContext is an interface to support dynamic dispatch. +type IDatabase_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDatabase_nameContext differentiates from other interfaces. + IsDatabase_nameContext() +} + +type Database_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_nameContext() *Database_nameContext { + var p = new(Database_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_name + return p +} + +func InitEmptyDatabase_nameContext(p *Database_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_name +} + +func (*Database_nameContext) IsDatabase_nameContext() {} + +func NewDatabase_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_nameContext { + var p = new(Database_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_name + + return p +} + +func (s *Database_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Database_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_name(s) + } +} + +func (s *Database_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_name(s) + } +} + +func (s *Database_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database_name() (localctx IDatabase_nameContext) { + localctx = NewDatabase_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1380, PlSqlParserRULE_database_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12971) + p.Regular_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 +} + +// 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_clause() IDatabase_clauseContext + SEMICOLON() antlr.TerminalNode + Startup_clauses() IStartup_clausesContext + Recovery_clauses() IRecovery_clausesContext + Database_file_clauses() IDatabase_file_clausesContext + Logfile_clauses() ILogfile_clausesContext + Controlfile_clauses() IControlfile_clausesContext + Standby_database_clauses() IStandby_database_clausesContext + Default_settings_clause() IDefault_settings_clauseContext + Instance_clauses() IInstance_clausesContext + Security_clause() ISecurity_clauseContext + Prepare_clause() IPrepare_clauseContext + Drop_mirror_clause() IDrop_mirror_clauseContext + Lost_write_protection() ILost_write_protectionContext + Cdb_fleet_clauses() ICdb_fleet_clausesContext + Property_clauses() IProperty_clausesContext + Replay_upgrade_clauses() IReplay_upgrade_clausesContext + + // 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 = PlSqlParserRULE_alter_database + return p +} + +func InitEmptyAlter_databaseContext(p *Alter_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_database + + return p +} + +func (s *Alter_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_databaseContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_databaseContext) Database_clause() IDatabase_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_clauseContext) +} + +func (s *Alter_databaseContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_databaseContext) Startup_clauses() IStartup_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStartup_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStartup_clausesContext) +} + +func (s *Alter_databaseContext) Recovery_clauses() IRecovery_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecovery_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecovery_clausesContext) +} + +func (s *Alter_databaseContext) Database_file_clauses() IDatabase_file_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_file_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_file_clausesContext) +} + +func (s *Alter_databaseContext) Logfile_clauses() ILogfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_clausesContext) +} + +func (s *Alter_databaseContext) Controlfile_clauses() IControlfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IControlfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IControlfile_clausesContext) +} + +func (s *Alter_databaseContext) Standby_database_clauses() IStandby_database_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandby_database_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandby_database_clausesContext) +} + +func (s *Alter_databaseContext) Default_settings_clause() IDefault_settings_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_settings_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_settings_clauseContext) +} + +func (s *Alter_databaseContext) Instance_clauses() IInstance_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInstance_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInstance_clausesContext) +} + +func (s *Alter_databaseContext) Security_clause() ISecurity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISecurity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISecurity_clauseContext) +} + +func (s *Alter_databaseContext) Prepare_clause() IPrepare_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrepare_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrepare_clauseContext) +} + +func (s *Alter_databaseContext) Drop_mirror_clause() IDrop_mirror_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_mirror_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_mirror_clauseContext) +} + +func (s *Alter_databaseContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Alter_databaseContext) Cdb_fleet_clauses() ICdb_fleet_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICdb_fleet_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICdb_fleet_clausesContext) +} + +func (s *Alter_databaseContext) Property_clauses() IProperty_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProperty_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProperty_clausesContext) +} + +func (s *Alter_databaseContext) Replay_upgrade_clauses() IReplay_upgrade_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReplay_upgrade_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReplay_upgrade_clausesContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_database(s) + } +} + +func (s *Alter_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_database(s) + } +} + +func (s *Alter_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_database() (localctx IAlter_databaseContext) { + localctx = NewAlter_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1382, PlSqlParserRULE_alter_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(12973) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(12974) + p.Database_clause() + } + p.SetState(12990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1647, p.GetParserRuleContext()) { + case 1: + { + p.SetState(12975) + p.Startup_clauses() + } + + case 2: + { + p.SetState(12976) + p.Recovery_clauses() + } + + case 3: + { + p.SetState(12977) + p.Database_file_clauses() + } + + case 4: + { + p.SetState(12978) + p.Logfile_clauses() + } + + case 5: + { + p.SetState(12979) + p.Controlfile_clauses() + } + + case 6: + { + p.SetState(12980) + p.Standby_database_clauses() + } + + case 7: + { + p.SetState(12981) + p.Default_settings_clause() + } + + case 8: + { + p.SetState(12982) + p.Instance_clauses() + } + + case 9: + { + p.SetState(12983) + p.Security_clause() + } + + case 10: + { + p.SetState(12984) + p.Prepare_clause() + } + + case 11: + { + p.SetState(12985) + p.Drop_mirror_clause() + } + + case 12: + { + p.SetState(12986) + p.Lost_write_protection() + } + + case 13: + { + p.SetState(12987) + p.Cdb_fleet_clauses() + } + + case 14: + { + p.SetState(12988) + p.Property_clauses() + } + + case 15: + { + p.SetState(12989) + p.Replay_upgrade_clauses() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(12992) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IDatabase_clauseContext is an interface to support dynamic dispatch. +type IDatabase_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + Database_name() IDatabase_nameContext + + // IsDatabase_clauseContext differentiates from other interfaces. + IsDatabase_clauseContext() +} + +type Database_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_clauseContext() *Database_clauseContext { + var p = new(Database_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_clause + return p +} + +func InitEmptyDatabase_clauseContext(p *Database_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_clause +} + +func (*Database_clauseContext) IsDatabase_clauseContext() {} + +func NewDatabase_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_clauseContext { + var p = new(Database_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_clause + + return p +} + +func (s *Database_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Database_clauseContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Database_clauseContext) Database_name() IDatabase_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_nameContext) +} + +func (s *Database_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_clause(s) + } +} + +func (s *Database_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_clause(s) + } +} + +func (s *Database_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database_clause() (localctx IDatabase_clauseContext) { + localctx = NewDatabase_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1384, PlSqlParserRULE_database_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(12995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPLUGGABLE { + { + p.SetState(12994) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(12997) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(12999) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1649, p.GetParserRuleContext()) == 1 { + { + p.SetState(12998) + p.Database_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 +} + +// IStartup_clausesContext is an interface to support dynamic dispatch. +type IStartup_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOUNT() antlr.TerminalNode + DATABASE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + CLONE() antlr.TerminalNode + OPEN() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + Resetlogs_or_noresetlogs() IResetlogs_or_noresetlogsContext + Upgrade_or_downgrade() IUpgrade_or_downgradeContext + ONLY() antlr.TerminalNode + + // IsStartup_clausesContext differentiates from other interfaces. + IsStartup_clausesContext() +} + +type Startup_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStartup_clausesContext() *Startup_clausesContext { + var p = new(Startup_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_startup_clauses + return p +} + +func InitEmptyStartup_clausesContext(p *Startup_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_startup_clauses +} + +func (*Startup_clausesContext) IsStartup_clausesContext() {} + +func NewStartup_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Startup_clausesContext { + var p = new(Startup_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_startup_clauses + + return p +} + +func (s *Startup_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Startup_clausesContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Startup_clausesContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Startup_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Startup_clausesContext) CLONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLONE, 0) +} + +func (s *Startup_clausesContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Startup_clausesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Startup_clausesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Startup_clausesContext) Resetlogs_or_noresetlogs() IResetlogs_or_noresetlogsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IResetlogs_or_noresetlogsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IResetlogs_or_noresetlogsContext) +} + +func (s *Startup_clausesContext) Upgrade_or_downgrade() IUpgrade_or_downgradeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpgrade_or_downgradeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpgrade_or_downgradeContext) +} + +func (s *Startup_clausesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Startup_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Startup_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Startup_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStartup_clauses(s) + } +} + +func (s *Startup_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStartup_clauses(s) + } +} + +func (s *Startup_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStartup_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Startup_clauses() (localctx IStartup_clausesContext) { + localctx = NewStartup_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1386, PlSqlParserRULE_startup_clauses) + var _la int + + p.SetState(13020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1654, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13001) + p.Match(PlSqlParserMOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCLONE || _la == PlSqlParserSTANDBY { + { + p.SetState(13002) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLONE || _la == PlSqlParserSTANDBY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13003) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13006) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREAD { + { + p.SetState(13007) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13008) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS { + { + p.SetState(13011) + p.Resetlogs_or_noresetlogs() + } + + } + p.SetState(13015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDOWNGRADE || _la == PlSqlParserUPGRADE { + { + p.SetState(13014) + p.Upgrade_or_downgrade() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13017) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13018) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13019) + p.Match(PlSqlParserONLY) + 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 +} + +// IResetlogs_or_noresetlogsContext is an interface to support dynamic dispatch. +type IResetlogs_or_noresetlogsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + + // IsResetlogs_or_noresetlogsContext differentiates from other interfaces. + IsResetlogs_or_noresetlogsContext() +} + +type Resetlogs_or_noresetlogsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyResetlogs_or_noresetlogsContext() *Resetlogs_or_noresetlogsContext { + var p = new(Resetlogs_or_noresetlogsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs + return p +} + +func InitEmptyResetlogs_or_noresetlogsContext(p *Resetlogs_or_noresetlogsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs +} + +func (*Resetlogs_or_noresetlogsContext) IsResetlogs_or_noresetlogsContext() {} + +func NewResetlogs_or_noresetlogsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Resetlogs_or_noresetlogsContext { + var p = new(Resetlogs_or_noresetlogsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_resetlogs_or_noresetlogs + + return p +} + +func (s *Resetlogs_or_noresetlogsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Resetlogs_or_noresetlogsContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Resetlogs_or_noresetlogsContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Resetlogs_or_noresetlogsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Resetlogs_or_noresetlogsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Resetlogs_or_noresetlogsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterResetlogs_or_noresetlogs(s) + } +} + +func (s *Resetlogs_or_noresetlogsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitResetlogs_or_noresetlogs(s) + } +} + +func (s *Resetlogs_or_noresetlogsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitResetlogs_or_noresetlogs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Resetlogs_or_noresetlogs() (localctx IResetlogs_or_noresetlogsContext) { + localctx = NewResetlogs_or_noresetlogsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1388, PlSqlParserRULE_resetlogs_or_noresetlogs) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13022) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + 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 +} + +// IUpgrade_or_downgradeContext is an interface to support dynamic dispatch. +type IUpgrade_or_downgradeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + DOWNGRADE() antlr.TerminalNode + + // IsUpgrade_or_downgradeContext differentiates from other interfaces. + IsUpgrade_or_downgradeContext() +} + +type Upgrade_or_downgradeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpgrade_or_downgradeContext() *Upgrade_or_downgradeContext { + var p = new(Upgrade_or_downgradeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade + return p +} + +func InitEmptyUpgrade_or_downgradeContext(p *Upgrade_or_downgradeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade +} + +func (*Upgrade_or_downgradeContext) IsUpgrade_or_downgradeContext() {} + +func NewUpgrade_or_downgradeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upgrade_or_downgradeContext { + var p = new(Upgrade_or_downgradeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upgrade_or_downgrade + + return p +} + +func (s *Upgrade_or_downgradeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upgrade_or_downgradeContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Upgrade_or_downgradeContext) DOWNGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOWNGRADE, 0) +} + +func (s *Upgrade_or_downgradeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upgrade_or_downgradeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upgrade_or_downgradeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpgrade_or_downgrade(s) + } +} + +func (s *Upgrade_or_downgradeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpgrade_or_downgrade(s) + } +} + +func (s *Upgrade_or_downgradeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpgrade_or_downgrade(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Upgrade_or_downgrade() (localctx IUpgrade_or_downgradeContext) { + localctx = NewUpgrade_or_downgradeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1390, PlSqlParserRULE_upgrade_or_downgrade) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13024) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDOWNGRADE || _la == PlSqlParserUPGRADE) { + 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 +} + +// IRecovery_clausesContext is an interface to support dynamic dispatch. +type IRecovery_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + General_recovery() IGeneral_recoveryContext + Managed_standby_recovery() IManaged_standby_recoveryContext + Begin_or_end() IBegin_or_endContext + BACKUP() antlr.TerminalNode + + // IsRecovery_clausesContext differentiates from other interfaces. + IsRecovery_clausesContext() +} + +type Recovery_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecovery_clausesContext() *Recovery_clausesContext { + var p = new(Recovery_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_recovery_clauses + return p +} + +func InitEmptyRecovery_clausesContext(p *Recovery_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_recovery_clauses +} + +func (*Recovery_clausesContext) IsRecovery_clausesContext() {} + +func NewRecovery_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Recovery_clausesContext { + var p = new(Recovery_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_recovery_clauses + + return p +} + +func (s *Recovery_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Recovery_clausesContext) General_recovery() IGeneral_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_recoveryContext) +} + +func (s *Recovery_clausesContext) Managed_standby_recovery() IManaged_standby_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IManaged_standby_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IManaged_standby_recoveryContext) +} + +func (s *Recovery_clausesContext) Begin_or_end() IBegin_or_endContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBegin_or_endContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBegin_or_endContext) +} + +func (s *Recovery_clausesContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Recovery_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Recovery_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Recovery_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecovery_clauses(s) + } +} + +func (s *Recovery_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecovery_clauses(s) + } +} + +func (s *Recovery_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRecovery_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Recovery_clauses() (localctx IRecovery_clausesContext) { + localctx = NewRecovery_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1392, PlSqlParserRULE_recovery_clauses) + p.SetState(13031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1655, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13026) + p.General_recovery() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13027) + p.Managed_standby_recovery() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13028) + p.Begin_or_end() + } + { + p.SetState(13029) + p.Match(PlSqlParserBACKUP) + 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 +} + +// IBegin_or_endContext is an interface to support dynamic dispatch. +type IBegin_or_endContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + + // IsBegin_or_endContext differentiates from other interfaces. + IsBegin_or_endContext() +} + +type Begin_or_endContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBegin_or_endContext() *Begin_or_endContext { + var p = new(Begin_or_endContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_begin_or_end + return p +} + +func InitEmptyBegin_or_endContext(p *Begin_or_endContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_begin_or_end +} + +func (*Begin_or_endContext) IsBegin_or_endContext() {} + +func NewBegin_or_endContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Begin_or_endContext { + var p = new(Begin_or_endContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_begin_or_end + + return p +} + +func (s *Begin_or_endContext) GetParser() antlr.Parser { return s.parser } + +func (s *Begin_or_endContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Begin_or_endContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Begin_or_endContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Begin_or_endContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Begin_or_endContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBegin_or_end(s) + } +} + +func (s *Begin_or_endContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBegin_or_end(s) + } +} + +func (s *Begin_or_endContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBegin_or_end(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Begin_or_end() (localctx IBegin_or_endContext) { + localctx = NewBegin_or_endContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1394, PlSqlParserRULE_begin_or_end) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13033) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBEGIN || _la == PlSqlParserEND) { + 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 +} + +// IGeneral_recoveryContext is an interface to support dynamic dispatch. +type IGeneral_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECOVER() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + CANCEL() antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + FROM() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + Full_database_recovery() IFull_database_recoveryContext + Partial_database_recovery() IPartial_database_recoveryContext + LOGFILE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + AllTEST() []antlr.TerminalNode + TEST(i int) antlr.TerminalNode + AllALLOW() []antlr.TerminalNode + ALLOW(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCORRUPTION() []antlr.TerminalNode + CORRUPTION(i int) antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + + // IsGeneral_recoveryContext differentiates from other interfaces. + IsGeneral_recoveryContext() +} + +type General_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_recoveryContext() *General_recoveryContext { + var p = new(General_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_recovery + return p +} + +func InitEmptyGeneral_recoveryContext(p *General_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_recovery +} + +func (*General_recoveryContext) IsGeneral_recoveryContext() {} + +func NewGeneral_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_recoveryContext { + var p = new(General_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_recovery + + return p +} + +func (s *General_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_recoveryContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *General_recoveryContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *General_recoveryContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *General_recoveryContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *General_recoveryContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *General_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *General_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *General_recoveryContext) Full_database_recovery() IFull_database_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFull_database_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFull_database_recoveryContext) +} + +func (s *General_recoveryContext) Partial_database_recovery() IPartial_database_recoveryContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartial_database_recoveryContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartial_database_recoveryContext) +} + +func (s *General_recoveryContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *General_recoveryContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *General_recoveryContext) AllTEST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTEST) +} + +func (s *General_recoveryContext) TEST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTEST, i) +} + +func (s *General_recoveryContext) AllALLOW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALLOW) +} + +func (s *General_recoveryContext) ALLOW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, i) +} + +func (s *General_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *General_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *General_recoveryContext) AllCORRUPTION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCORRUPTION) +} + +func (s *General_recoveryContext) CORRUPTION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPTION, i) +} + +func (s *General_recoveryContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *General_recoveryContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *General_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_recovery(s) + } +} + +func (s *General_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_recovery(s) + } +} + +func (s *General_recoveryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGeneral_recovery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) General_recovery() (localctx IGeneral_recoveryContext) { + localctx = NewGeneral_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1396, PlSqlParserRULE_general_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13035) + p.Match(PlSqlParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13037) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1656, p.GetParserRuleContext()) == 1 { + { + p.SetState(13036) + p.Match(PlSqlParserAUTOMATIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13041) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1657, p.GetParserRuleContext()) == 1 { + { + p.SetState(13039) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13040) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1663, p.GetParserRuleContext()) { + case 1: + p.SetState(13047) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1658, p.GetParserRuleContext()) == 1 { + { + p.SetState(13043) + p.Full_database_recovery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1658, p.GetParserRuleContext()) == 2 { + { + p.SetState(13044) + p.Partial_database_recovery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1658, p.GetParserRuleContext()) == 3 { + { + p.SetState(13045) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13046) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserTEST { + p.SetState(13054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOW || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserTEST { + p.SetState(13054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTEST: + { + p.SetState(13049) + p.Match(PlSqlParserTEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOW: + { + p.SetState(13050) + p.Match(PlSqlParserALLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13051) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13052) + p.Match(PlSqlParserCORRUPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(13053) + p.Parallel_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13056) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + + case 2: + { + p.SetState(13060) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(13061) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + { + p.SetState(13064) + p.Match(PlSqlParserCANCEL) + 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 +} + +// IFull_database_recoveryContext is an interface to support dynamic dispatch. +type IFull_database_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATABASE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + AllUNTIL() []antlr.TerminalNode + UNTIL(i int) antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllBACKUP() []antlr.TerminalNode + BACKUP(i int) antlr.TerminalNode + AllCONTROLFILE() []antlr.TerminalNode + CONTROLFILE(i int) antlr.TerminalNode + AllSNAPSHOT() []antlr.TerminalNode + SNAPSHOT(i int) antlr.TerminalNode + AllTIME() []antlr.TerminalNode + TIME(i int) antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCANCEL() []antlr.TerminalNode + CANCEL(i int) antlr.TerminalNode + AllCHANGE() []antlr.TerminalNode + CHANGE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCONSISTENT() []antlr.TerminalNode + CONSISTENT(i int) antlr.TerminalNode + + // IsFull_database_recoveryContext differentiates from other interfaces. + IsFull_database_recoveryContext() +} + +type Full_database_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFull_database_recoveryContext() *Full_database_recoveryContext { + var p = new(Full_database_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_full_database_recovery + return p +} + +func InitEmptyFull_database_recoveryContext(p *Full_database_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_full_database_recovery +} + +func (*Full_database_recoveryContext) IsFull_database_recoveryContext() {} + +func NewFull_database_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Full_database_recoveryContext { + var p = new(Full_database_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_full_database_recovery + + return p +} + +func (s *Full_database_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Full_database_recoveryContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Full_database_recoveryContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Full_database_recoveryContext) AllUNTIL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNTIL) +} + +func (s *Full_database_recoveryContext) UNTIL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, i) +} + +func (s *Full_database_recoveryContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Full_database_recoveryContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Full_database_recoveryContext) AllBACKUP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBACKUP) +} + +func (s *Full_database_recoveryContext) BACKUP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, i) +} + +func (s *Full_database_recoveryContext) AllCONTROLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTROLFILE) +} + +func (s *Full_database_recoveryContext) CONTROLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, i) +} + +func (s *Full_database_recoveryContext) AllSNAPSHOT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSNAPSHOT) +} + +func (s *Full_database_recoveryContext) SNAPSHOT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, i) +} + +func (s *Full_database_recoveryContext) AllTIME() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTIME) +} + +func (s *Full_database_recoveryContext) TIME(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, i) +} + +func (s *Full_database_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Full_database_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Full_database_recoveryContext) AllCANCEL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCANCEL) +} + +func (s *Full_database_recoveryContext) CANCEL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, i) +} + +func (s *Full_database_recoveryContext) AllCHANGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHANGE) +} + +func (s *Full_database_recoveryContext) CHANGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, i) +} + +func (s *Full_database_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Full_database_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Full_database_recoveryContext) AllCONSISTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSISTENT) +} + +func (s *Full_database_recoveryContext) CONSISTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, i) +} + +func (s *Full_database_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Full_database_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Full_database_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFull_database_recovery(s) + } +} + +func (s *Full_database_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFull_database_recovery(s) + } +} + +func (s *Full_database_recoveryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFull_database_recovery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Full_database_recovery() (localctx IFull_database_recoveryContext) { + localctx = NewFull_database_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1398, PlSqlParserRULE_full_database_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13068) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13067) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13070) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSNAPSHOT || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserSNAPSHOT || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13086) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNTIL: + { + p.SetState(13071) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13078) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCANCEL: + { + p.SetState(13072) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIME: + { + p.SetState(13073) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13074) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHANGE: + { + p.SetState(13075) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13076) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSISTENT: + { + p.SetState(13077) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserUSING: + { + p.SetState(13080) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13081) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13082) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSNAPSHOT: + { + p.SetState(13083) + p.Match(PlSqlParserSNAPSHOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13084) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13085) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13088) + 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 +} + +// IPartial_database_recoveryContext is an interface to support dynamic dispatch. +type IPartial_database_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLESPACE() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + Partial_database_recovery_10g() IPartial_database_recovery_10gContext + + // IsPartial_database_recoveryContext differentiates from other interfaces. + IsPartial_database_recoveryContext() +} + +type Partial_database_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartial_database_recoveryContext() *Partial_database_recoveryContext { + var p = new(Partial_database_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery + return p +} + +func InitEmptyPartial_database_recoveryContext(p *Partial_database_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery +} + +func (*Partial_database_recoveryContext) IsPartial_database_recoveryContext() {} + +func NewPartial_database_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partial_database_recoveryContext { + var p = new(Partial_database_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partial_database_recovery + + return p +} + +func (s *Partial_database_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partial_database_recoveryContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Partial_database_recoveryContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recoveryContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partial_database_recoveryContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partial_database_recoveryContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partial_database_recoveryContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Partial_database_recoveryContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Partial_database_recoveryContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Partial_database_recoveryContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recoveryContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Partial_database_recoveryContext) Partial_database_recovery_10g() IPartial_database_recovery_10gContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartial_database_recovery_10gContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartial_database_recovery_10gContext) +} + +func (s *Partial_database_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partial_database_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partial_database_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartial_database_recovery(s) + } +} + +func (s *Partial_database_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartial_database_recovery(s) + } +} + +func (s *Partial_database_recoveryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartial_database_recovery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partial_database_recovery() (localctx IPartial_database_recoveryContext) { + localctx = NewPartial_database_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1400, PlSqlParserRULE_partial_database_recovery) + var _la int + + p.SetState(13113) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1672, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13092) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13093) + p.Tablespace() + } + p.SetState(13098) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13094) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13095) + p.Tablespace() + } + + p.SetState(13100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13101) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13102) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13103) + p.Filenumber() + } + p.SetState(13109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserCOMMA { + p.SetState(13107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMMA: + { + p.SetState(13104) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13105) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13106) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13111) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13112) + p.Partial_database_recovery_10g() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartial_database_recovery_10gContext is an interface to support dynamic dispatch. +type IPartial_database_recovery_10gContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STANDBY() antlr.TerminalNode + UNTIL() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + DATAFILE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + CONSISTENT() antlr.TerminalNode + WITH() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartial_database_recovery_10gContext differentiates from other interfaces. + IsPartial_database_recovery_10gContext() +} + +type Partial_database_recovery_10gContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartial_database_recovery_10gContext() *Partial_database_recovery_10gContext { + var p = new(Partial_database_recovery_10gContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g + return p +} + +func InitEmptyPartial_database_recovery_10gContext(p *Partial_database_recovery_10gContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g +} + +func (*Partial_database_recovery_10gContext) IsPartial_database_recovery_10gContext() {} + +func NewPartial_database_recovery_10gContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partial_database_recovery_10gContext { + var p = new(Partial_database_recovery_10gContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partial_database_recovery_10g + + return p +} + +func (s *Partial_database_recovery_10gContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partial_database_recovery_10gContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Partial_database_recovery_10gContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Partial_database_recovery_10gContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Partial_database_recovery_10gContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Partial_database_recovery_10gContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recovery_10gContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Partial_database_recovery_10gContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Partial_database_recovery_10gContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Partial_database_recovery_10gContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Partial_database_recovery_10gContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Partial_database_recovery_10gContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Partial_database_recovery_10gContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, 0) +} + +func (s *Partial_database_recovery_10gContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Partial_database_recovery_10gContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partial_database_recovery_10gContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partial_database_recovery_10gContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partial_database_recovery_10gContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partial_database_recovery_10gContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartial_database_recovery_10g(s) + } +} + +func (s *Partial_database_recovery_10gContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartial_database_recovery_10g(s) + } +} + +func (s *Partial_database_recovery_10gContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartial_database_recovery_10g(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partial_database_recovery_10g() (localctx IPartial_database_recovery_10gContext) { + localctx = NewPartial_database_recovery_10gContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1402, PlSqlParserRULE_partial_database_recovery_10g) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13115) + + if !(p.isVersion10()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion10()", "")) + goto errorExit + } + { + p.SetState(13116) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13137) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + { + p.SetState(13117) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13118) + p.Tablespace() + } + p.SetState(13123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13119) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13120) + p.Tablespace() + } + + p.SetState(13125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserDATAFILE: + { + p.SetState(13126) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13127) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13128) + p.Filenumber() + } + p.SetState(13134) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserCOMMA { + p.SetState(13132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMMA: + { + p.SetState(13129) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13130) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13131) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13136) + 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(13139) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13142) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSISTENT { + { + p.SetState(13140) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13141) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13144) + p.Match(PlSqlParserCONTROLFILE) + 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 +} + +// IManaged_standby_recoveryContext is an interface to support dynamic dispatch. +type IManaged_standby_recoveryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECOVER() antlr.TerminalNode + MANAGED() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + TO() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + Db_name() IDb_nameContext + KEEP() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + FINISH() antlr.TerminalNode + CANCEL() antlr.TerminalNode + AllUSING() []antlr.TerminalNode + USING(i int) antlr.TerminalNode + AllCURRENT() []antlr.TerminalNode + CURRENT(i int) antlr.TerminalNode + AllLOGFILE() []antlr.TerminalNode + LOGFILE(i int) antlr.TerminalNode + AllDISCONNECT() []antlr.TerminalNode + DISCONNECT(i int) antlr.TerminalNode + AllNODELAY() []antlr.TerminalNode + NODELAY(i int) antlr.TerminalNode + AllUNTIL() []antlr.TerminalNode + UNTIL(i int) antlr.TerminalNode + AllCHANGE() []antlr.TerminalNode + CHANGE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCONSISTENT() []antlr.TerminalNode + CONSISTENT(i int) antlr.TerminalNode + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllFROM() []antlr.TerminalNode + FROM(i int) antlr.TerminalNode + AllSESSION() []antlr.TerminalNode + SESSION(i int) antlr.TerminalNode + + // IsManaged_standby_recoveryContext differentiates from other interfaces. + IsManaged_standby_recoveryContext() +} + +type Managed_standby_recoveryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyManaged_standby_recoveryContext() *Managed_standby_recoveryContext { + var p = new(Managed_standby_recoveryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery + return p +} + +func InitEmptyManaged_standby_recoveryContext(p *Managed_standby_recoveryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery +} + +func (*Managed_standby_recoveryContext) IsManaged_standby_recoveryContext() {} + +func NewManaged_standby_recoveryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Managed_standby_recoveryContext { + var p = new(Managed_standby_recoveryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_managed_standby_recovery + + return p +} + +func (s *Managed_standby_recoveryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Managed_standby_recoveryContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *Managed_standby_recoveryContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Managed_standby_recoveryContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Managed_standby_recoveryContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Managed_standby_recoveryContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Managed_standby_recoveryContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Managed_standby_recoveryContext) Db_name() IDb_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDb_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDb_nameContext) +} + +func (s *Managed_standby_recoveryContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Managed_standby_recoveryContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Managed_standby_recoveryContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Managed_standby_recoveryContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Managed_standby_recoveryContext) AllUSING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSING) +} + +func (s *Managed_standby_recoveryContext) USING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, i) +} + +func (s *Managed_standby_recoveryContext) AllCURRENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT) +} + +func (s *Managed_standby_recoveryContext) CURRENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, i) +} + +func (s *Managed_standby_recoveryContext) AllLOGFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOGFILE) +} + +func (s *Managed_standby_recoveryContext) LOGFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, i) +} + +func (s *Managed_standby_recoveryContext) AllDISCONNECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISCONNECT) +} + +func (s *Managed_standby_recoveryContext) DISCONNECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCONNECT, i) +} + +func (s *Managed_standby_recoveryContext) AllNODELAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNODELAY) +} + +func (s *Managed_standby_recoveryContext) NODELAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, i) +} + +func (s *Managed_standby_recoveryContext) AllUNTIL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNTIL) +} + +func (s *Managed_standby_recoveryContext) UNTIL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, i) +} + +func (s *Managed_standby_recoveryContext) AllCHANGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHANGE) +} + +func (s *Managed_standby_recoveryContext) CHANGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, i) +} + +func (s *Managed_standby_recoveryContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Managed_standby_recoveryContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Managed_standby_recoveryContext) AllCONSISTENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSISTENT) +} + +func (s *Managed_standby_recoveryContext) CONSISTENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, i) +} + +func (s *Managed_standby_recoveryContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Managed_standby_recoveryContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Managed_standby_recoveryContext) AllFROM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFROM) +} + +func (s *Managed_standby_recoveryContext) FROM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, i) +} + +func (s *Managed_standby_recoveryContext) AllSESSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSESSION) +} + +func (s *Managed_standby_recoveryContext) SESSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, i) +} + +func (s *Managed_standby_recoveryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Managed_standby_recoveryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Managed_standby_recoveryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterManaged_standby_recovery(s) + } +} + +func (s *Managed_standby_recoveryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitManaged_standby_recovery(s) + } +} + +func (s *Managed_standby_recoveryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitManaged_standby_recovery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Managed_standby_recovery() (localctx IManaged_standby_recoveryContext) { + localctx = NewManaged_standby_recoveryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1404, PlSqlParserRULE_managed_standby_recovery) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13146) + p.Match(PlSqlParserRECOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMANAGED: + { + p.SetState(13147) + p.Match(PlSqlParserMANAGED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13148) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13149) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13171) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISCONNECT, PlSqlParserNODELAY, PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserUNTIL, PlSqlParserUSING: + p.SetState(13165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISCONNECT || _la == PlSqlParserNODELAY || _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL || _la == PlSqlParserUNTIL || _la == PlSqlParserUSING { + p.SetState(13165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1679, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13150) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13151) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13152) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13153) + p.Match(PlSqlParserDISCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFROM { + { + p.SetState(13154) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13155) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + { + p.SetState(13158) + p.Match(PlSqlParserNODELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(13159) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13160) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13161) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(13162) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13163) + p.Match(PlSqlParserCONSISTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(13164) + p.Parallel_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(13167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserFINISH: + { + p.SetState(13169) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCANCEL: + { + p.SetState(13170) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSEMICOLON: + + default: + } + + case PlSqlParserTO: + { + p.SetState(13173) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13174) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13175) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1682, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13176) + p.Db_name() + } + + case 2: + { + p.SetState(13177) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13178) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDb_nameContext is an interface to support dynamic dispatch. +type IDb_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDb_nameContext differentiates from other interfaces. + IsDb_nameContext() +} + +type Db_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDb_nameContext() *Db_nameContext { + var p = new(Db_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_db_name + return p +} + +func InitEmptyDb_nameContext(p *Db_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_db_name +} + +func (*Db_nameContext) IsDb_nameContext() {} + +func NewDb_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Db_nameContext { + var p = new(Db_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_db_name + + return p +} + +func (s *Db_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Db_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Db_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Db_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Db_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDb_name(s) + } +} + +func (s *Db_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDb_name(s) + } +} + +func (s *Db_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDb_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Db_name() (localctx IDb_nameContext) { + localctx = NewDb_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1406, PlSqlParserRULE_db_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13183) + p.Regular_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 +} + +// IDatabase_file_clausesContext is an interface to support dynamic dispatch. +type IDatabase_file_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Create_datafile_clause() ICreate_datafile_clauseContext + Alter_datafile_clause() IAlter_datafile_clauseContext + Alter_tempfile_clause() IAlter_tempfile_clauseContext + Move_datafile_clause() IMove_datafile_clauseContext + + // IsDatabase_file_clausesContext differentiates from other interfaces. + IsDatabase_file_clausesContext() +} + +type Database_file_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_file_clausesContext() *Database_file_clausesContext { + var p = new(Database_file_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_file_clauses + return p +} + +func InitEmptyDatabase_file_clausesContext(p *Database_file_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_file_clauses +} + +func (*Database_file_clausesContext) IsDatabase_file_clausesContext() {} + +func NewDatabase_file_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_file_clausesContext { + var p = new(Database_file_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_file_clauses + + return p +} + +func (s *Database_file_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_file_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Database_file_clausesContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Database_file_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Database_file_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Database_file_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Database_file_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Database_file_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Database_file_clausesContext) Create_datafile_clause() ICreate_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) Alter_datafile_clause() IAlter_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) Alter_tempfile_clause() IAlter_tempfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tempfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tempfile_clauseContext) +} + +func (s *Database_file_clausesContext) Move_datafile_clause() IMove_datafile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_datafile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_datafile_clauseContext) +} + +func (s *Database_file_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_file_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_file_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_file_clauses(s) + } +} + +func (s *Database_file_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_file_clauses(s) + } +} + +func (s *Database_file_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase_file_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database_file_clauses() (localctx IDatabase_file_clausesContext) { + localctx = NewDatabase_file_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1408, PlSqlParserRULE_database_file_clauses) + var _la int + + p.SetState(13202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRENAME: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13185) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13186) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13187) + p.Filename() + } + p.SetState(13192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13188) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13189) + p.Filename() + } + + p.SetState(13194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13195) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13196) + p.Filename() + } + + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13198) + p.Create_datafile_clause() + } + + case PlSqlParserDATAFILE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13199) + p.Alter_datafile_clause() + } + + case PlSqlParserTEMPFILE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13200) + p.Alter_tempfile_clause() + } + + case PlSqlParserMOVE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13201) + p.Move_datafile_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_datafile_clauseContext is an interface to support dynamic dispatch. +type ICreate_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AS() antlr.TerminalNode + NEW() antlr.TerminalNode + + // IsCreate_datafile_clauseContext differentiates from other interfaces. + IsCreate_datafile_clauseContext() +} + +type Create_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_datafile_clauseContext() *Create_datafile_clauseContext { + var p = new(Create_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_datafile_clause + return p +} + +func InitEmptyCreate_datafile_clauseContext(p *Create_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_datafile_clause +} + +func (*Create_datafile_clauseContext) IsCreate_datafile_clauseContext() {} + +func NewCreate_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_datafile_clauseContext { + var p = new(Create_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_datafile_clause + + return p +} + +func (s *Create_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_datafile_clauseContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Create_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Create_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Create_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Create_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Create_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Create_datafile_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Create_datafile_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Create_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_datafile_clause(s) + } +} + +func (s *Create_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_datafile_clause(s) + } +} + +func (s *Create_datafile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_datafile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_datafile_clause() (localctx ICreate_datafile_clauseContext) { + localctx = NewCreate_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1410, PlSqlParserRULE_create_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13204) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13205) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13208) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13206) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13207) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13210) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13213) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13211) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13212) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13219) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13220) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(13221) + p.Match(PlSqlParserNEW) + 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_datafile_clauseContext is an interface to support dynamic dispatch. +type IAlter_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + END() antlr.TerminalNode + BACKUP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + FOR() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAlter_datafile_clauseContext differentiates from other interfaces. + IsAlter_datafile_clauseContext() +} + +type Alter_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_datafile_clauseContext() *Alter_datafile_clauseContext { + var p = new(Alter_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause + return p +} + +func InitEmptyAlter_datafile_clauseContext(p *Alter_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause +} + +func (*Alter_datafile_clauseContext) IsAlter_datafile_clauseContext() {} + +func NewAlter_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_datafile_clauseContext { + var p = new(Alter_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_datafile_clause + + return p +} + +func (s *Alter_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Alter_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Alter_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Alter_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Alter_datafile_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_datafile_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_datafile_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_datafile_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_datafile_clauseContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_datafile_clauseContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Alter_datafile_clauseContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_datafile_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Alter_datafile_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_datafile_clause(s) + } +} + +func (s *Alter_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_datafile_clause(s) + } +} + +func (s *Alter_datafile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_datafile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_datafile_clause() (localctx IAlter_datafile_clauseContext) { + localctx = NewAlter_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1412, PlSqlParserRULE_alter_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13224) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13227) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13225) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13226) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13229) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13230) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13231) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13238) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLINE: + { + p.SetState(13239) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(13240) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13243) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(13241) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13242) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserRESIZE: + { + p.SetState(13245) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13246) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(13247) + p.Autoextend_clause() + } + + case PlSqlParserEND: + { + p.SetState(13248) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13249) + p.Match(PlSqlParserBACKUP) + 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_tempfile_clauseContext is an interface to support dynamic dispatch. +type IAlter_tempfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TEMPFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + RESIZE() antlr.TerminalNode + Size_clause() ISize_clauseContext + Autoextend_clause() IAutoextend_clauseContext + DROP() antlr.TerminalNode + ONLINE() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + INCLUDING() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + + // IsAlter_tempfile_clauseContext differentiates from other interfaces. + IsAlter_tempfile_clauseContext() +} + +type Alter_tempfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tempfile_clauseContext() *Alter_tempfile_clauseContext { + var p = new(Alter_tempfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause + return p +} + +func InitEmptyAlter_tempfile_clauseContext(p *Alter_tempfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause +} + +func (*Alter_tempfile_clauseContext) IsAlter_tempfile_clauseContext() {} + +func NewAlter_tempfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tempfile_clauseContext { + var p = new(Alter_tempfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tempfile_clause + + return p +} + +func (s *Alter_tempfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tempfile_clauseContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Alter_tempfile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Alter_tempfile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Alter_tempfile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Alter_tempfile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Alter_tempfile_clauseContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tempfile_clauseContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tempfile_clauseContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tempfile_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Alter_tempfile_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_tempfile_clauseContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_tempfile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Alter_tempfile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Alter_tempfile_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Alter_tempfile_clauseContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Alter_tempfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tempfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tempfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tempfile_clause(s) + } +} + +func (s *Alter_tempfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tempfile_clause(s) + } +} + +func (s *Alter_tempfile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_tempfile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_tempfile_clause() (localctx IAlter_tempfile_clauseContext) { + localctx = NewAlter_tempfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1414, PlSqlParserRULE_alter_tempfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13252) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13255) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13253) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13254) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13264) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13257) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13258) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13259) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserRESIZE: + { + p.SetState(13267) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13268) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(13269) + p.Autoextend_clause() + } + + case PlSqlParserDROP: + { + p.SetState(13270) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + { + p.SetState(13271) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13272) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserONLINE: + { + p.SetState(13273) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOFFLINE: + { + p.SetState(13274) + p.Match(PlSqlParserOFFLINE) + 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 +} + +// IMove_datafile_clauseContext is an interface to support dynamic dispatch. +type IMove_datafile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + AllFilenumber() []IFilenumberContext + Filenumber(i int) IFilenumberContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + TO() antlr.TerminalNode + REUSE() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsMove_datafile_clauseContext differentiates from other interfaces. + IsMove_datafile_clauseContext() +} + +type Move_datafile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_datafile_clauseContext() *Move_datafile_clauseContext { + var p = new(Move_datafile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_datafile_clause + return p +} + +func InitEmptyMove_datafile_clauseContext(p *Move_datafile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_datafile_clause +} + +func (*Move_datafile_clauseContext) IsMove_datafile_clauseContext() {} + +func NewMove_datafile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_datafile_clauseContext { + var p = new(Move_datafile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_datafile_clause + + return p +} + +func (s *Move_datafile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_datafile_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_datafile_clauseContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Move_datafile_clauseContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Move_datafile_clauseContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Move_datafile_clauseContext) AllFilenumber() []IFilenumberContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenumberContext); ok { + len++ + } + } + + tst := make([]IFilenumberContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenumberContext); ok { + tst[i] = t.(IFilenumberContext) + i++ + } + } + + return tst +} + +func (s *Move_datafile_clauseContext) Filenumber(i int) IFilenumberContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenumberContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenumberContext) +} + +func (s *Move_datafile_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Move_datafile_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Move_datafile_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Move_datafile_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Move_datafile_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Move_datafile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_datafile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_datafile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_datafile_clause(s) + } +} + +func (s *Move_datafile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_datafile_clause(s) + } +} + +func (s *Move_datafile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMove_datafile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Move_datafile_clause() (localctx IMove_datafile_clauseContext) { + localctx = NewMove_datafile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1416, PlSqlParserRULE_move_datafile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13277) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13278) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13279) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13280) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13283) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13284) + p.Filename() + } + + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(13285) + p.Filenumber() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTO { + { + p.SetState(13293) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13294) + p.Filename() + } + + } + p.SetState(13298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13297) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserKEEP { + { + p.SetState(13300) + p.Match(PlSqlParserKEEP) + 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 +} + +// ILogfile_clausesContext is an interface to support dynamic dispatch. +type ILogfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + MANUAL() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + NO() antlr.TerminalNode + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + FOR() antlr.TerminalNode + DATA() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + LOAD() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + RENAME() antlr.TerminalNode + FILE() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CLEAR() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + UNARCHIVED() antlr.TerminalNode + UNRECOVERABLE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + Add_logfile_clauses() IAdd_logfile_clausesContext + Drop_logfile_clauses() IDrop_logfile_clausesContext + Switch_logfile_clause() ISwitch_logfile_clauseContext + Supplemental_db_logging() ISupplemental_db_loggingContext + + // IsLogfile_clausesContext differentiates from other interfaces. + IsLogfile_clausesContext() +} + +type Logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_clausesContext() *Logfile_clausesContext { + var p = new(Logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clauses + return p +} + +func InitEmptyLogfile_clausesContext(p *Logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_clauses +} + +func (*Logfile_clausesContext) IsLogfile_clausesContext() {} + +func NewLogfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_clausesContext { + var p = new(Logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_clauses + + return p +} + +func (s *Logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_clausesContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Logfile_clausesContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Logfile_clausesContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Logfile_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Logfile_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Logfile_clausesContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Logfile_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Logfile_clausesContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Logfile_clausesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Logfile_clausesContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Logfile_clausesContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Logfile_clausesContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Logfile_clausesContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Logfile_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Logfile_clausesContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Logfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_clausesContext) CLEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAR, 0) +} + +func (s *Logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Logfile_clausesContext) UNARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNARCHIVED, 0) +} + +func (s *Logfile_clausesContext) UNRECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRECOVERABLE, 0) +} + +func (s *Logfile_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Logfile_clausesContext) Add_logfile_clauses() IAdd_logfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_logfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_logfile_clausesContext) +} + +func (s *Logfile_clausesContext) Drop_logfile_clauses() IDrop_logfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_logfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_logfile_clausesContext) +} + +func (s *Logfile_clausesContext) Switch_logfile_clause() ISwitch_logfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISwitch_logfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISwitch_logfile_clauseContext) +} + +func (s *Logfile_clausesContext) Supplemental_db_logging() ISupplemental_db_loggingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_db_loggingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_db_loggingContext) +} + +func (s *Logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_clauses(s) + } +} + +func (s *Logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_clauses(s) + } +} + +func (s *Logfile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogfile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logfile_clauses() (localctx ILogfile_clausesContext) { + localctx = NewLogfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1418, PlSqlParserRULE_logfile_clauses) + var _la int + + p.SetState(13359) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1713, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(13308) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserARCHIVELOG: + { + p.SetState(13303) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMANUAL { + { + p.SetState(13304) + p.Match(PlSqlParserMANUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserNOARCHIVELOG: + { + p.SetState(13307) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(13311) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(13310) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13313) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13314) + p.Match(PlSqlParserLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13315) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13316) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13317) + p.Match(PlSqlParserNOLOGGING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13318) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDATA: + { + p.SetState(13319) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13320) + p.Match(PlSqlParserAVAILABILITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOAD: + { + p.SetState(13321) + p.Match(PlSqlParserLOAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13322) + p.Match(PlSqlParserPERFORMANCE) + 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(13325) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13326) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13327) + p.Filename() + } + p.SetState(13332) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13328) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13329) + p.Filename() + } + + p.SetState(13334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13335) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13336) + p.Filename() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13338) + p.Match(PlSqlParserCLEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNARCHIVED { + { + p.SetState(13339) + p.Match(PlSqlParserUNARCHIVED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13342) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13343) + p.Logfile_descriptor() + } + p.SetState(13348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13344) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13345) + p.Logfile_descriptor() + } + + p.SetState(13350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(13353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNRECOVERABLE { + { + p.SetState(13351) + p.Match(PlSqlParserUNRECOVERABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13352) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13355) + p.Add_logfile_clauses() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13356) + p.Drop_logfile_clauses() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13357) + p.Switch_logfile_clause() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13358) + p.Supplemental_db_logging() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_logfile_clausesContext is an interface to support dynamic dispatch. +type IAdd_logfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + MEMBER() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + TO() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + STANDBY() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + THREAD() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AllGroup_redo_logfile() []IGroup_redo_logfileContext + Group_redo_logfile(i int) IGroup_redo_logfileContext + AllREUSE() []antlr.TerminalNode + REUSE(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_logfile_clausesContext differentiates from other interfaces. + IsAdd_logfile_clausesContext() +} + +type Add_logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_logfile_clausesContext() *Add_logfile_clausesContext { + var p = new(Add_logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses + return p +} + +func InitEmptyAdd_logfile_clausesContext(p *Add_logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses +} + +func (*Add_logfile_clausesContext) IsAdd_logfile_clausesContext() {} + +func NewAdd_logfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_logfile_clausesContext { + var p = new(Add_logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_logfile_clauses + + return p +} + +func (s *Add_logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_logfile_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Add_logfile_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Add_logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Add_logfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Add_logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Add_logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Add_logfile_clausesContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Add_logfile_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Add_logfile_clausesContext) THREAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHREAD, 0) +} + +func (s *Add_logfile_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Add_logfile_clausesContext) AllGroup_redo_logfile() []IGroup_redo_logfileContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_redo_logfileContext); ok { + len++ + } + } + + tst := make([]IGroup_redo_logfileContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_redo_logfileContext); ok { + tst[i] = t.(IGroup_redo_logfileContext) + i++ + } + } + + return tst +} + +func (s *Add_logfile_clausesContext) Group_redo_logfile(i int) IGroup_redo_logfileContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_redo_logfileContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_redo_logfileContext) +} + +func (s *Add_logfile_clausesContext) AllREUSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREUSE) +} + +func (s *Add_logfile_clausesContext) REUSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, i) +} + +func (s *Add_logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_logfile_clauses(s) + } +} + +func (s *Add_logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_logfile_clauses(s) + } +} + +func (s *Add_logfile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_logfile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_logfile_clauses() (localctx IAdd_logfile_clausesContext) { + localctx = NewAdd_logfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1420, PlSqlParserRULE_add_logfile_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13361) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13362) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13365) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13401) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP, PlSqlParserINSTANCE, PlSqlParserTHREAD, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + p.SetState(13370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINSTANCE: + { + p.SetState(13366) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13367) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTHREAD: + { + p.SetState(13368) + p.Match(PlSqlParserTHREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13369) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGROUP, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + + default: + } + p.SetState(13373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserGROUP || _la == PlSqlParserCHAR_STRING || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(13372) + p.Group_redo_logfile() + } + + p.SetState(13375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMEMBER: + { + p.SetState(13377) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13378) + p.Filename() + } + p.SetState(13380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13379) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13389) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13382) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13383) + p.Filename() + } + p.SetState(13385) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13384) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(13391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13392) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13393) + p.Logfile_descriptor() + } + p.SetState(13398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13394) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13395) + p.Logfile_descriptor() + } + + p.SetState(13400) + 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 +} + +// IGroup_redo_logfileContext is an interface to support dynamic dispatch. +type IGroup_redo_logfileContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Redo_log_file_spec() IRedo_log_file_specContext + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsGroup_redo_logfileContext differentiates from other interfaces. + IsGroup_redo_logfileContext() +} + +type Group_redo_logfileContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_redo_logfileContext() *Group_redo_logfileContext { + var p = new(Group_redo_logfileContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_redo_logfile + return p +} + +func InitEmptyGroup_redo_logfileContext(p *Group_redo_logfileContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_redo_logfile +} + +func (*Group_redo_logfileContext) IsGroup_redo_logfileContext() {} + +func NewGroup_redo_logfileContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_redo_logfileContext { + var p = new(Group_redo_logfileContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_group_redo_logfile + + return p +} + +func (s *Group_redo_logfileContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_redo_logfileContext) Redo_log_file_spec() IRedo_log_file_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRedo_log_file_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRedo_log_file_specContext) +} + +func (s *Group_redo_logfileContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Group_redo_logfileContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Group_redo_logfileContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_redo_logfileContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_redo_logfileContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGroup_redo_logfile(s) + } +} + +func (s *Group_redo_logfileContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_redo_logfile(s) + } +} + +func (s *Group_redo_logfileContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGroup_redo_logfile(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Group_redo_logfile() (localctx IGroup_redo_logfileContext) { + localctx = NewGroup_redo_logfileContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1422, PlSqlParserRULE_group_redo_logfile) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGROUP { + { + p.SetState(13403) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13404) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13407) + p.Redo_log_file_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_logfile_clausesContext is an interface to support dynamic dispatch. +type IDrop_logfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + AllLogfile_descriptor() []ILogfile_descriptorContext + Logfile_descriptor(i int) ILogfile_descriptorContext + MEMBER() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + STANDBY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDrop_logfile_clausesContext differentiates from other interfaces. + IsDrop_logfile_clausesContext() +} + +type Drop_logfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_logfile_clausesContext() *Drop_logfile_clausesContext { + var p = new(Drop_logfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses + return p +} + +func InitEmptyDrop_logfile_clausesContext(p *Drop_logfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses +} + +func (*Drop_logfile_clausesContext) IsDrop_logfile_clausesContext() {} + +func NewDrop_logfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_logfile_clausesContext { + var p = new(Drop_logfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_logfile_clauses + + return p +} + +func (s *Drop_logfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_logfile_clausesContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_logfile_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Drop_logfile_clausesContext) AllLogfile_descriptor() []ILogfile_descriptorContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + len++ + } + } + + tst := make([]ILogfile_descriptorContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogfile_descriptorContext); ok { + tst[i] = t.(ILogfile_descriptorContext) + i++ + } + } + + return tst +} + +func (s *Drop_logfile_clausesContext) Logfile_descriptor(i int) ILogfile_descriptorContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogfile_descriptorContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogfile_descriptorContext) +} + +func (s *Drop_logfile_clausesContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Drop_logfile_clausesContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Drop_logfile_clausesContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Drop_logfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Drop_logfile_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_logfile_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_logfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_logfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_logfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_logfile_clauses(s) + } +} + +func (s *Drop_logfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_logfile_clauses(s) + } +} + +func (s *Drop_logfile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_logfile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_logfile_clauses() (localctx IDrop_logfile_clausesContext) { + localctx = NewDrop_logfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1424, PlSqlParserRULE_drop_logfile_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13409) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13411) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTANDBY { + { + p.SetState(13410) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13413) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP, PlSqlParserCHAR_STRING, PlSqlParserLEFT_PAREN: + { + p.SetState(13414) + p.Logfile_descriptor() + } + p.SetState(13419) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13415) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13416) + p.Logfile_descriptor() + } + + p.SetState(13421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserMEMBER: + { + p.SetState(13422) + p.Match(PlSqlParserMEMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13423) + p.Filename() + } + p.SetState(13428) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13424) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13425) + p.Filename() + } + + p.SetState(13430) + 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 +} + +// ISwitch_logfile_clauseContext is an interface to support dynamic dispatch. +type ISwitch_logfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SWITCH() antlr.TerminalNode + ALL() antlr.TerminalNode + LOGFILES() antlr.TerminalNode + TO() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsSwitch_logfile_clauseContext differentiates from other interfaces. + IsSwitch_logfile_clauseContext() +} + +type Switch_logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwitch_logfile_clauseContext() *Switch_logfile_clauseContext { + var p = new(Switch_logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause + return p +} + +func InitEmptySwitch_logfile_clauseContext(p *Switch_logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause +} + +func (*Switch_logfile_clauseContext) IsSwitch_logfile_clauseContext() {} + +func NewSwitch_logfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Switch_logfile_clauseContext { + var p = new(Switch_logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_switch_logfile_clause + + return p +} + +func (s *Switch_logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Switch_logfile_clauseContext) SWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCH, 0) +} + +func (s *Switch_logfile_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Switch_logfile_clauseContext) LOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILES, 0) +} + +func (s *Switch_logfile_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Switch_logfile_clauseContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Switch_logfile_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Switch_logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Switch_logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Switch_logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSwitch_logfile_clause(s) + } +} + +func (s *Switch_logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSwitch_logfile_clause(s) + } +} + +func (s *Switch_logfile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSwitch_logfile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Switch_logfile_clause() (localctx ISwitch_logfile_clauseContext) { + localctx = NewSwitch_logfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1426, PlSqlParserRULE_switch_logfile_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13433) + p.Match(PlSqlParserSWITCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13434) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13435) + p.Match(PlSqlParserLOGFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13436) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13437) + p.Match(PlSqlParserBLOCKSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13438) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// ISupplemental_db_loggingContext is an interface to support dynamic dispatch. +type ISupplemental_db_loggingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_or_drop() IAdd_or_dropContext + SUPPLEMENTAL() antlr.TerminalNode + LOG() antlr.TerminalNode + DATA() antlr.TerminalNode + Supplemental_id_key_clause() ISupplemental_id_key_clauseContext + Supplemental_plsql_clause() ISupplemental_plsql_clauseContext + + // IsSupplemental_db_loggingContext differentiates from other interfaces. + IsSupplemental_db_loggingContext() +} + +type Supplemental_db_loggingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_db_loggingContext() *Supplemental_db_loggingContext { + var p = new(Supplemental_db_loggingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging + return p +} + +func InitEmptySupplemental_db_loggingContext(p *Supplemental_db_loggingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging +} + +func (*Supplemental_db_loggingContext) IsSupplemental_db_loggingContext() {} + +func NewSupplemental_db_loggingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_db_loggingContext { + var p = new(Supplemental_db_loggingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_db_logging + + return p +} + +func (s *Supplemental_db_loggingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_db_loggingContext) Add_or_drop() IAdd_or_dropContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_or_dropContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_or_dropContext) +} + +func (s *Supplemental_db_loggingContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Supplemental_db_loggingContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Supplemental_db_loggingContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_db_loggingContext) Supplemental_id_key_clause() ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_db_loggingContext) Supplemental_plsql_clause() ISupplemental_plsql_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_plsql_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_plsql_clauseContext) +} + +func (s *Supplemental_db_loggingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_db_loggingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_db_loggingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_db_logging(s) + } +} + +func (s *Supplemental_db_loggingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_db_logging(s) + } +} + +func (s *Supplemental_db_loggingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_db_logging(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_db_logging() (localctx ISupplemental_db_loggingContext) { + localctx = NewSupplemental_db_loggingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1428, PlSqlParserRULE_supplemental_db_logging) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13440) + p.Add_or_drop() + } + { + p.SetState(13441) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13442) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13446) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1727, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13443) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13444) + p.Supplemental_id_key_clause() + } + + case 3: + { + p.SetState(13445) + p.Supplemental_plsql_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 +} + +// IAdd_or_dropContext is an interface to support dynamic dispatch. +type IAdd_or_dropContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + DROP() antlr.TerminalNode + + // IsAdd_or_dropContext differentiates from other interfaces. + IsAdd_or_dropContext() +} + +type Add_or_dropContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_or_dropContext() *Add_or_dropContext { + var p = new(Add_or_dropContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_or_drop + return p +} + +func InitEmptyAdd_or_dropContext(p *Add_or_dropContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_or_drop +} + +func (*Add_or_dropContext) IsAdd_or_dropContext() {} + +func NewAdd_or_dropContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_or_dropContext { + var p = new(Add_or_dropContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_or_drop + + return p +} + +func (s *Add_or_dropContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_or_dropContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_or_dropContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Add_or_dropContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_or_dropContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_or_dropContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_or_drop(s) + } +} + +func (s *Add_or_dropContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_or_drop(s) + } +} + +func (s *Add_or_dropContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_or_drop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_or_drop() (localctx IAdd_or_dropContext) { + localctx = NewAdd_or_dropContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1430, PlSqlParserRULE_add_or_drop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13448) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + 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 +} + +// ISupplemental_plsql_clauseContext is an interface to support dynamic dispatch. +type ISupplemental_plsql_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATA() antlr.TerminalNode + FOR() antlr.TerminalNode + PROCEDURAL() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + + // IsSupplemental_plsql_clauseContext differentiates from other interfaces. + IsSupplemental_plsql_clauseContext() +} + +type Supplemental_plsql_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_plsql_clauseContext() *Supplemental_plsql_clauseContext { + var p = new(Supplemental_plsql_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause + return p +} + +func InitEmptySupplemental_plsql_clauseContext(p *Supplemental_plsql_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause +} + +func (*Supplemental_plsql_clauseContext) IsSupplemental_plsql_clauseContext() {} + +func NewSupplemental_plsql_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_plsql_clauseContext { + var p = new(Supplemental_plsql_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_plsql_clause + + return p +} + +func (s *Supplemental_plsql_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_plsql_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Supplemental_plsql_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Supplemental_plsql_clauseContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURAL, 0) +} + +func (s *Supplemental_plsql_clauseContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Supplemental_plsql_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_plsql_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_plsql_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_plsql_clause(s) + } +} + +func (s *Supplemental_plsql_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_plsql_clause(s) + } +} + +func (s *Supplemental_plsql_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_plsql_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_plsql_clause() (localctx ISupplemental_plsql_clauseContext) { + localctx = NewSupplemental_plsql_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1432, PlSqlParserRULE_supplemental_plsql_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13450) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13451) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13452) + p.Match(PlSqlParserPROCEDURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13453) + p.Match(PlSqlParserREPLICATION) + 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 +} + +// ILogfile_descriptorContext is an interface to support dynamic dispatch. +type ILogfile_descriptorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllFilename() []IFilenameContext + Filename(i int) IFilenameContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLogfile_descriptorContext differentiates from other interfaces. + IsLogfile_descriptorContext() +} + +type Logfile_descriptorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogfile_descriptorContext() *Logfile_descriptorContext { + var p = new(Logfile_descriptorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_descriptor + return p +} + +func InitEmptyLogfile_descriptorContext(p *Logfile_descriptorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logfile_descriptor +} + +func (*Logfile_descriptorContext) IsLogfile_descriptorContext() {} + +func NewLogfile_descriptorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logfile_descriptorContext { + var p = new(Logfile_descriptorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logfile_descriptor + + return p +} + +func (s *Logfile_descriptorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logfile_descriptorContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Logfile_descriptorContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Logfile_descriptorContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Logfile_descriptorContext) AllFilename() []IFilenameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilenameContext); ok { + len++ + } + } + + tst := make([]IFilenameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilenameContext); ok { + tst[i] = t.(IFilenameContext) + i++ + } + } + + return tst +} + +func (s *Logfile_descriptorContext) Filename(i int) IFilenameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Logfile_descriptorContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Logfile_descriptorContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logfile_descriptorContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logfile_descriptorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logfile_descriptorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logfile_descriptorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogfile_descriptor(s) + } +} + +func (s *Logfile_descriptorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogfile_descriptor(s) + } +} + +func (s *Logfile_descriptorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogfile_descriptor(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logfile_descriptor() (localctx ILogfile_descriptorContext) { + localctx = NewLogfile_descriptorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1434, PlSqlParserRULE_logfile_descriptor) + var _la int + + p.SetState(13469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13455) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13456) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13457) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13458) + p.Filename() + } + p.SetState(13463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13459) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13460) + p.Filename() + } + + p.SetState(13465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13466) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13468) + p.Filename() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IControlfile_clausesContext is an interface to support dynamic dispatch. +type IControlfile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + AS() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + BACKUP() antlr.TerminalNode + TO() antlr.TerminalNode + Trace_file_clause() ITrace_file_clauseContext + + // IsControlfile_clausesContext differentiates from other interfaces. + IsControlfile_clausesContext() +} + +type Controlfile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyControlfile_clausesContext() *Controlfile_clausesContext { + var p = new(Controlfile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_clauses + return p +} + +func InitEmptyControlfile_clausesContext(p *Controlfile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_controlfile_clauses +} + +func (*Controlfile_clausesContext) IsControlfile_clausesContext() {} + +func NewControlfile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Controlfile_clausesContext { + var p = new(Controlfile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_controlfile_clauses + + return p +} + +func (s *Controlfile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Controlfile_clausesContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Controlfile_clausesContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Controlfile_clausesContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Controlfile_clausesContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Controlfile_clausesContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Controlfile_clausesContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Controlfile_clausesContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Controlfile_clausesContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Controlfile_clausesContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Controlfile_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Controlfile_clausesContext) Trace_file_clause() ITrace_file_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITrace_file_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITrace_file_clauseContext) +} + +func (s *Controlfile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Controlfile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Controlfile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterControlfile_clauses(s) + } +} + +func (s *Controlfile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitControlfile_clauses(s) + } +} + +func (s *Controlfile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitControlfile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Controlfile_clauses() (localctx IControlfile_clausesContext) { + localctx = NewControlfile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1436, PlSqlParserRULE_controlfile_clauses) + var _la int + + p.SetState(13492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCREATE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13471) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(13472) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13475) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13476) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13477) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13478) + p.Filename() + } + p.SetState(13480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13479) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserBACKUP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13482) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13483) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13484) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(13485) + p.Filename() + } + p.SetState(13487) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13486) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserTRACE: + { + p.SetState(13489) + p.Trace_file_clause() + } + + 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 +} + +// ITrace_file_clauseContext is an interface to support dynamic dispatch. +type ITrace_file_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRACE() antlr.TerminalNode + AS() antlr.TerminalNode + Filename() IFilenameContext + RESETLOGS() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + REUSE() antlr.TerminalNode + + // IsTrace_file_clauseContext differentiates from other interfaces. + IsTrace_file_clauseContext() +} + +type Trace_file_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrace_file_clauseContext() *Trace_file_clauseContext { + var p = new(Trace_file_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trace_file_clause + return p +} + +func InitEmptyTrace_file_clauseContext(p *Trace_file_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trace_file_clause +} + +func (*Trace_file_clauseContext) IsTrace_file_clauseContext() {} + +func NewTrace_file_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trace_file_clauseContext { + var p = new(Trace_file_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trace_file_clause + + return p +} + +func (s *Trace_file_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trace_file_clauseContext) TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACE, 0) +} + +func (s *Trace_file_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Trace_file_clauseContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Trace_file_clauseContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Trace_file_clauseContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Trace_file_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Trace_file_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trace_file_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trace_file_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrace_file_clause(s) + } +} + +func (s *Trace_file_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrace_file_clause(s) + } +} + +func (s *Trace_file_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrace_file_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trace_file_clause() (localctx ITrace_file_clauseContext) { + localctx = NewTrace_file_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1438, PlSqlParserRULE_trace_file_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13494) + p.Match(PlSqlParserTRACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(13495) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13496) + p.Filename() + } + p.SetState(13498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13497) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + p.SetState(13503) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS { + { + p.SetState(13502) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNORESETLOGS || _la == PlSqlParserRESETLOGS) { + 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 +} + +// IStandby_database_clausesContext is an interface to support dynamic dispatch. +type IStandby_database_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Activate_standby_db_clause() IActivate_standby_db_clauseContext + Maximize_standby_db_clause() IMaximize_standby_db_clauseContext + Register_logfile_clause() IRegister_logfile_clauseContext + Commit_switchover_clause() ICommit_switchover_clauseContext + Start_standby_clause() IStart_standby_clauseContext + Stop_standby_clause() IStop_standby_clauseContext + Convert_database_clause() IConvert_database_clauseContext + Parallel_clause() IParallel_clauseContext + + // IsStandby_database_clausesContext differentiates from other interfaces. + IsStandby_database_clausesContext() +} + +type Standby_database_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandby_database_clausesContext() *Standby_database_clausesContext { + var p = new(Standby_database_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standby_database_clauses + return p +} + +func InitEmptyStandby_database_clausesContext(p *Standby_database_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standby_database_clauses +} + +func (*Standby_database_clausesContext) IsStandby_database_clausesContext() {} + +func NewStandby_database_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standby_database_clausesContext { + var p = new(Standby_database_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standby_database_clauses + + return p +} + +func (s *Standby_database_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standby_database_clausesContext) Activate_standby_db_clause() IActivate_standby_db_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IActivate_standby_db_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IActivate_standby_db_clauseContext) +} + +func (s *Standby_database_clausesContext) Maximize_standby_db_clause() IMaximize_standby_db_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMaximize_standby_db_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMaximize_standby_db_clauseContext) +} + +func (s *Standby_database_clausesContext) Register_logfile_clause() IRegister_logfile_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegister_logfile_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegister_logfile_clauseContext) +} + +func (s *Standby_database_clausesContext) Commit_switchover_clause() ICommit_switchover_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommit_switchover_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommit_switchover_clauseContext) +} + +func (s *Standby_database_clausesContext) Start_standby_clause() IStart_standby_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_standby_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_standby_clauseContext) +} + +func (s *Standby_database_clausesContext) Stop_standby_clause() IStop_standby_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStop_standby_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStop_standby_clauseContext) +} + +func (s *Standby_database_clausesContext) Convert_database_clause() IConvert_database_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConvert_database_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConvert_database_clauseContext) +} + +func (s *Standby_database_clausesContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Standby_database_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standby_database_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standby_database_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandby_database_clauses(s) + } +} + +func (s *Standby_database_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandby_database_clauses(s) + } +} + +func (s *Standby_database_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStandby_database_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Standby_database_clauses() (localctx IStandby_database_clausesContext) { + localctx = NewStandby_database_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1440, PlSqlParserRULE_standby_database_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserACTIVATE: + { + p.SetState(13505) + p.Activate_standby_db_clause() + } + + case PlSqlParserSET: + { + p.SetState(13506) + p.Maximize_standby_db_clause() + } + + case PlSqlParserREGISTER: + { + p.SetState(13507) + p.Register_logfile_clause() + } + + case PlSqlParserCOMMIT, PlSqlParserPREPARE: + { + p.SetState(13508) + p.Commit_switchover_clause() + } + + case PlSqlParserSTART: + { + p.SetState(13509) + p.Start_standby_clause() + } + + case PlSqlParserABORT, PlSqlParserSTOP: + { + p.SetState(13510) + p.Stop_standby_clause() + } + + case PlSqlParserCONVERT: + { + p.SetState(13511) + p.Convert_database_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(13515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(13514) + p.Parallel_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 +} + +// IActivate_standby_db_clauseContext is an interface to support dynamic dispatch. +type IActivate_standby_db_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACTIVATE() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + FINISH() antlr.TerminalNode + APPLY() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + + // IsActivate_standby_db_clauseContext differentiates from other interfaces. + IsActivate_standby_db_clauseContext() +} + +type Activate_standby_db_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyActivate_standby_db_clauseContext() *Activate_standby_db_clauseContext { + var p = new(Activate_standby_db_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause + return p +} + +func InitEmptyActivate_standby_db_clauseContext(p *Activate_standby_db_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause +} + +func (*Activate_standby_db_clauseContext) IsActivate_standby_db_clauseContext() {} + +func NewActivate_standby_db_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Activate_standby_db_clauseContext { + var p = new(Activate_standby_db_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_activate_standby_db_clause + + return p +} + +func (s *Activate_standby_db_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Activate_standby_db_clauseContext) ACTIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVATE, 0) +} + +func (s *Activate_standby_db_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Activate_standby_db_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Activate_standby_db_clauseContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Activate_standby_db_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Activate_standby_db_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Activate_standby_db_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Activate_standby_db_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Activate_standby_db_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Activate_standby_db_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterActivate_standby_db_clause(s) + } +} + +func (s *Activate_standby_db_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitActivate_standby_db_clause(s) + } +} + +func (s *Activate_standby_db_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitActivate_standby_db_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Activate_standby_db_clause() (localctx IActivate_standby_db_clauseContext) { + localctx = NewActivate_standby_db_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1442, PlSqlParserRULE_activate_standby_db_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13517) + p.Match(PlSqlParserACTIVATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(13518) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13521) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13522) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFINISH { + { + p.SetState(13523) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13524) + p.Match(PlSqlParserAPPLY) + 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 +} + +// IMaximize_standby_db_clauseContext is an interface to support dynamic dispatch. +type IMaximize_standby_db_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + STANDBY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + TO() antlr.TerminalNode + MAXIMIZE() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + + // IsMaximize_standby_db_clauseContext differentiates from other interfaces. + IsMaximize_standby_db_clauseContext() +} + +type Maximize_standby_db_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMaximize_standby_db_clauseContext() *Maximize_standby_db_clauseContext { + var p = new(Maximize_standby_db_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause + return p +} + +func InitEmptyMaximize_standby_db_clauseContext(p *Maximize_standby_db_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause +} + +func (*Maximize_standby_db_clauseContext) IsMaximize_standby_db_clauseContext() {} + +func NewMaximize_standby_db_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Maximize_standby_db_clauseContext { + var p = new(Maximize_standby_db_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_maximize_standby_db_clause + + return p +} + +func (s *Maximize_standby_db_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Maximize_standby_db_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Maximize_standby_db_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Maximize_standby_db_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Maximize_standby_db_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Maximize_standby_db_clauseContext) MAXIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXIMIZE, 0) +} + +func (s *Maximize_standby_db_clauseContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Maximize_standby_db_clauseContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Maximize_standby_db_clauseContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Maximize_standby_db_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Maximize_standby_db_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Maximize_standby_db_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMaximize_standby_db_clause(s) + } +} + +func (s *Maximize_standby_db_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMaximize_standby_db_clause(s) + } +} + +func (s *Maximize_standby_db_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMaximize_standby_db_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Maximize_standby_db_clause() (localctx IMaximize_standby_db_clauseContext) { + localctx = NewMaximize_standby_db_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1444, PlSqlParserRULE_maximize_standby_db_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13527) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13528) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13529) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13530) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13531) + p.Match(PlSqlParserMAXIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13532) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAVAILABILITY || _la == PlSqlParserPERFORMANCE || _la == PlSqlParserPROTECTION) { + 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 +} + +// IRegister_logfile_clauseContext is an interface to support dynamic dispatch. +type IRegister_logfile_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REGISTER() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + OR() antlr.TerminalNode + REPLACE() antlr.TerminalNode + + // IsRegister_logfile_clauseContext differentiates from other interfaces. + IsRegister_logfile_clauseContext() +} + +type Register_logfile_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegister_logfile_clauseContext() *Register_logfile_clauseContext { + var p = new(Register_logfile_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_register_logfile_clause + return p +} + +func InitEmptyRegister_logfile_clauseContext(p *Register_logfile_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_register_logfile_clause +} + +func (*Register_logfile_clauseContext) IsRegister_logfile_clauseContext() {} + +func NewRegister_logfile_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Register_logfile_clauseContext { + var p = new(Register_logfile_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_register_logfile_clause + + return p +} + +func (s *Register_logfile_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Register_logfile_clauseContext) REGISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGISTER, 0) +} + +func (s *Register_logfile_clauseContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Register_logfile_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Register_logfile_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Register_logfile_clauseContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Register_logfile_clauseContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Register_logfile_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Register_logfile_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Register_logfile_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRegister_logfile_clause(s) + } +} + +func (s *Register_logfile_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRegister_logfile_clause(s) + } +} + +func (s *Register_logfile_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRegister_logfile_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Register_logfile_clause() (localctx IRegister_logfile_clauseContext) { + localctx = NewRegister_logfile_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1446, PlSqlParserRULE_register_logfile_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13534) + p.Match(PlSqlParserREGISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13537) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOR { + { + p.SetState(13535) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13536) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13539) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13540) + p.Match(PlSqlParserLOGFILE) + 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 +} + +// ICommit_switchover_clauseContext is an interface to support dynamic dispatch. +type ICommit_switchover_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + SWITCHOVER() antlr.TerminalNode + PREPARE() antlr.TerminalNode + COMMIT() antlr.TerminalNode + CANCEL() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + SESSION() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsCommit_switchover_clauseContext differentiates from other interfaces. + IsCommit_switchover_clauseContext() +} + +type Commit_switchover_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommit_switchover_clauseContext() *Commit_switchover_clauseContext { + var p = new(Commit_switchover_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause + return p +} + +func InitEmptyCommit_switchover_clauseContext(p *Commit_switchover_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause +} + +func (*Commit_switchover_clauseContext) IsCommit_switchover_clauseContext() {} + +func NewCommit_switchover_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_switchover_clauseContext { + var p = new(Commit_switchover_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_commit_switchover_clause + + return p +} + +func (s *Commit_switchover_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Commit_switchover_clauseContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Commit_switchover_clauseContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Commit_switchover_clauseContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Commit_switchover_clauseContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Commit_switchover_clauseContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Commit_switchover_clauseContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Commit_switchover_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Commit_switchover_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Commit_switchover_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Commit_switchover_clauseContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Commit_switchover_clauseContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Commit_switchover_clauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Commit_switchover_clauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Commit_switchover_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Commit_switchover_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Commit_switchover_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Commit_switchover_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Commit_switchover_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Commit_switchover_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCommit_switchover_clause(s) + } +} + +func (s *Commit_switchover_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCommit_switchover_clause(s) + } +} + +func (s *Commit_switchover_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCommit_switchover_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Commit_switchover_clause() (localctx ICommit_switchover_clauseContext) { + localctx = NewCommit_switchover_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1448, PlSqlParserRULE_commit_switchover_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13542) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserPREPARE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13543) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13544) + p.Match(PlSqlParserSWITCHOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOGICAL, PlSqlParserTO: + p.SetState(13570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTO: + { + p.SetState(13545) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1748, p.GetParserRuleContext()) { + case 1: + p.SetState(13554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1745, p.GetParserRuleContext()) { + case 1: + p.SetState(13547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL { + { + p.SetState(13546) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOGICAL || _la == PlSqlParserPHYSICAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13549) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.SetState(13551) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPHYSICAL { + { + p.SetState(13550) + p.Match(PlSqlParserPHYSICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13553) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(13562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSESSION || _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + p.SetState(13557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(13556) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13559) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13560) + p.Match(PlSqlParserSHUTDOWN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13561) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + + case 2: + { + p.SetState(13564) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13565) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserLOGICAL: + { + p.SetState(13568) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13569) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCANCEL: + { + p.SetState(13572) + p.Match(PlSqlParserCANCEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_standby_clauseContext is an interface to support dynamic dispatch. +type IStart_standby_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetScn_value returns the scn_value token. + GetScn_value() antlr.Token + + // SetScn_value sets the scn_value token. + SetScn_value(antlr.Token) + + // Getter signatures + START() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + APPLY() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + NODELAY() antlr.TerminalNode + NEW() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + Regular_id() IRegular_idContext + INITIAL() antlr.TerminalNode + SKIP_() antlr.TerminalNode + FAILED() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + FINISH() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsStart_standby_clauseContext differentiates from other interfaces. + IsStart_standby_clauseContext() +} + +type Start_standby_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + scn_value antlr.Token +} + +func NewEmptyStart_standby_clauseContext() *Start_standby_clauseContext { + var p = new(Start_standby_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_standby_clause + return p +} + +func InitEmptyStart_standby_clauseContext(p *Start_standby_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_standby_clause +} + +func (*Start_standby_clauseContext) IsStart_standby_clauseContext() {} + +func NewStart_standby_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_standby_clauseContext { + var p = new(Start_standby_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_standby_clause + + return p +} + +func (s *Start_standby_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_standby_clauseContext) GetScn_value() antlr.Token { return s.scn_value } + +func (s *Start_standby_clauseContext) SetScn_value(v antlr.Token) { s.scn_value = v } + +func (s *Start_standby_clauseContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Start_standby_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Start_standby_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Start_standby_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Start_standby_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Start_standby_clauseContext) NODELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, 0) +} + +func (s *Start_standby_clauseContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Start_standby_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Start_standby_clauseContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Start_standby_clauseContext) INITIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, 0) +} + +func (s *Start_standby_clauseContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Start_standby_clauseContext) FAILED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED, 0) +} + +func (s *Start_standby_clauseContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Start_standby_clauseContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Start_standby_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Start_standby_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_standby_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_standby_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_standby_clause(s) + } +} + +func (s *Start_standby_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_standby_clause(s) + } +} + +func (s *Start_standby_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStart_standby_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Start_standby_clause() (localctx IStart_standby_clauseContext) { + localctx = NewStart_standby_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1450, PlSqlParserRULE_start_standby_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13575) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13576) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13577) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13578) + p.Match(PlSqlParserAPPLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIMMEDIATE { + { + p.SetState(13579) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNODELAY { + { + p.SetState(13582) + p.Match(PlSqlParserNODELAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13596) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserNEW: + { + p.SetState(13585) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13586) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13587) + p.Regular_id() + } + + case PlSqlParserINITIAL: + { + p.SetState(13588) + p.Match(PlSqlParserINITIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNSIGNED_INTEGER { + { + p.SetState(13589) + + var _m = p.Match(PlSqlParserUNSIGNED_INTEGER) + + localctx.(*Start_standby_clauseContext).scn_value = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserSKIP_: + { + p.SetState(13592) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13593) + p.Match(PlSqlParserFAILED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13594) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFINISH: + { + p.SetState(13595) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL, PlSqlParserSEMICOLON: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStop_standby_clauseContext is an interface to support dynamic dispatch. +type IStop_standby_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGICAL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + APPLY() antlr.TerminalNode + STOP() antlr.TerminalNode + ABORT() antlr.TerminalNode + + // IsStop_standby_clauseContext differentiates from other interfaces. + IsStop_standby_clauseContext() +} + +type Stop_standby_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStop_standby_clauseContext() *Stop_standby_clauseContext { + var p = new(Stop_standby_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_stop_standby_clause + return p +} + +func InitEmptyStop_standby_clauseContext(p *Stop_standby_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_stop_standby_clause +} + +func (*Stop_standby_clauseContext) IsStop_standby_clauseContext() {} + +func NewStop_standby_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Stop_standby_clauseContext { + var p = new(Stop_standby_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_stop_standby_clause + + return p +} + +func (s *Stop_standby_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Stop_standby_clauseContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Stop_standby_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Stop_standby_clauseContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Stop_standby_clauseContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Stop_standby_clauseContext) ABORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABORT, 0) +} + +func (s *Stop_standby_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Stop_standby_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Stop_standby_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStop_standby_clause(s) + } +} + +func (s *Stop_standby_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStop_standby_clause(s) + } +} + +func (s *Stop_standby_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStop_standby_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Stop_standby_clause() (localctx IStop_standby_clauseContext) { + localctx = NewStop_standby_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1452, PlSqlParserRULE_stop_standby_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13598) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABORT || _la == PlSqlParserSTOP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13599) + p.Match(PlSqlParserLOGICAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13600) + p.Match(PlSqlParserSTANDBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13601) + p.Match(PlSqlParserAPPLY) + 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 +} + +// IConvert_database_clauseContext is an interface to support dynamic dispatch. +type IConvert_database_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONVERT() antlr.TerminalNode + TO() antlr.TerminalNode + STANDBY() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + + // IsConvert_database_clauseContext differentiates from other interfaces. + IsConvert_database_clauseContext() +} + +type Convert_database_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConvert_database_clauseContext() *Convert_database_clauseContext { + var p = new(Convert_database_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_database_clause + return p +} + +func InitEmptyConvert_database_clauseContext(p *Convert_database_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_convert_database_clause +} + +func (*Convert_database_clauseContext) IsConvert_database_clauseContext() {} + +func NewConvert_database_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Convert_database_clauseContext { + var p = new(Convert_database_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_convert_database_clause + + return p +} + +func (s *Convert_database_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Convert_database_clauseContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Convert_database_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Convert_database_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Convert_database_clauseContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Convert_database_clauseContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Convert_database_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Convert_database_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Convert_database_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConvert_database_clause(s) + } +} + +func (s *Convert_database_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConvert_database_clause(s) + } +} + +func (s *Convert_database_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConvert_database_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Convert_database_clause() (localctx IConvert_database_clauseContext) { + localctx = NewConvert_database_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1454, PlSqlParserRULE_convert_database_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13603) + p.Match(PlSqlParserCONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13604) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13605) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPHYSICAL || _la == PlSqlParserSNAPSHOT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13606) + p.Match(PlSqlParserSTANDBY) + 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_settings_clauseContext is an interface to support dynamic dispatch. +type IDefault_settings_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + EDITION() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Edition_name() IEdition_nameContext + SET() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + Tablespace() ITablespaceContext + TEMPORARY() antlr.TerminalNode + Tablespace_group_name() ITablespace_group_nameContext + RENAME() antlr.TerminalNode + GLOBAL_NAME() antlr.TerminalNode + TO() antlr.TerminalNode + Database() IDatabaseContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllDomain() []IDomainContext + Domain(i int) IDomainContext + ENABLE() antlr.TerminalNode + BLOCK() antlr.TerminalNode + CHANGE() antlr.TerminalNode + TRACKING() antlr.TerminalNode + USING() antlr.TerminalNode + FILE() antlr.TerminalNode + Filename() IFilenameContext + REUSE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + Flashback_mode_clause() IFlashback_mode_clauseContext + Set_time_zone_clause() ISet_time_zone_clauseContext + + // IsDefault_settings_clauseContext differentiates from other interfaces. + IsDefault_settings_clauseContext() +} + +type Default_settings_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_settings_clauseContext() *Default_settings_clauseContext { + var p = new(Default_settings_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_settings_clause + return p +} + +func InitEmptyDefault_settings_clauseContext(p *Default_settings_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_settings_clause +} + +func (*Default_settings_clauseContext) IsDefault_settings_clauseContext() {} + +func NewDefault_settings_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_settings_clauseContext { + var p = new(Default_settings_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_settings_clause + + return p +} + +func (s *Default_settings_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_settings_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_settings_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Default_settings_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Default_settings_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Default_settings_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Default_settings_clauseContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_settings_clauseContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Default_settings_clauseContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Default_settings_clauseContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_settings_clauseContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Default_settings_clauseContext) Tablespace_group_name() ITablespace_group_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Default_settings_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Default_settings_clauseContext) GLOBAL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_NAME, 0) +} + +func (s *Default_settings_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Default_settings_clauseContext) Database() IDatabaseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabaseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabaseContext) +} + +func (s *Default_settings_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Default_settings_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Default_settings_clauseContext) AllDomain() []IDomainContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDomainContext); ok { + len++ + } + } + + tst := make([]IDomainContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDomainContext); ok { + tst[i] = t.(IDomainContext) + i++ + } + } + + return tst +} + +func (s *Default_settings_clauseContext) Domain(i int) IDomainContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDomainContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDomainContext) +} + +func (s *Default_settings_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Default_settings_clauseContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Default_settings_clauseContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Default_settings_clauseContext) TRACKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACKING, 0) +} + +func (s *Default_settings_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Default_settings_clauseContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Default_settings_clauseContext) Filename() IFilenameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilenameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFilenameContext) +} + +func (s *Default_settings_clauseContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Default_settings_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Default_settings_clauseContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Default_settings_clauseContext) Set_time_zone_clause() ISet_time_zone_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_time_zone_clauseContext) +} + +func (s *Default_settings_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_settings_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_settings_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_settings_clause(s) + } +} + +func (s *Default_settings_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_settings_clause(s) + } +} + +func (s *Default_settings_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_settings_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_settings_clause() (localctx IDefault_settings_clauseContext) { + localctx = NewDefault_settings_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1456, PlSqlParserRULE_default_settings_clause) + var _la int + + p.SetState(13654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1759, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13608) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13609) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13610) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13611) + p.Edition_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13612) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13613) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13614) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13615) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13616) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13617) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13618) + p.Tablespace() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13619) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13620) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13621) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1755, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13622) + p.Tablespace() + } + + case 2: + { + p.SetState(13623) + p.Tablespace_group_name() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13626) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13627) + p.Match(PlSqlParserGLOBAL_NAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13628) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13629) + p.Database() + } + p.SetState(13632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserPERIOD { + { + p.SetState(13630) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13631) + p.Domain() + } + + p.SetState(13634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(13636) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13637) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13638) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13639) + p.Match(PlSqlParserTRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(13640) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13641) + p.Match(PlSqlParserFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13642) + p.Filename() + } + p.SetState(13644) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREUSE { + { + p.SetState(13643) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(13648) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13649) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13650) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13651) + p.Match(PlSqlParserTRACKING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(13652) + p.Flashback_mode_clause() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(13653) + p.Set_time_zone_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 +} + +// ISet_time_zone_clauseContext is an interface to support dynamic dispatch. +type ISet_time_zone_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsSet_time_zone_clauseContext differentiates from other interfaces. + IsSet_time_zone_clauseContext() +} + +type Set_time_zone_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_time_zone_clauseContext() *Set_time_zone_clauseContext { + var p = new(Set_time_zone_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause + return p +} + +func InitEmptySet_time_zone_clauseContext(p *Set_time_zone_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause +} + +func (*Set_time_zone_clauseContext) IsSet_time_zone_clauseContext() {} + +func NewSet_time_zone_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_time_zone_clauseContext { + var p = new(Set_time_zone_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_time_zone_clause + + return p +} + +func (s *Set_time_zone_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_time_zone_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_time_zone_clauseContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Set_time_zone_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Set_time_zone_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Set_time_zone_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_time_zone_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_time_zone_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_time_zone_clause(s) + } +} + +func (s *Set_time_zone_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_time_zone_clause(s) + } +} + +func (s *Set_time_zone_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_time_zone_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_time_zone_clause() (localctx ISet_time_zone_clauseContext) { + localctx = NewSet_time_zone_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1458, PlSqlParserRULE_set_time_zone_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13656) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13657) + p.Match(PlSqlParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13658) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13659) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IInstance_clausesContext is an interface to support dynamic dispatch. +type IInstance_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Enable_or_disable() IEnable_or_disableContext + INSTANCE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsInstance_clausesContext differentiates from other interfaces. + IsInstance_clausesContext() +} + +type Instance_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInstance_clausesContext() *Instance_clausesContext { + var p = new(Instance_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_instance_clauses + return p +} + +func InitEmptyInstance_clausesContext(p *Instance_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_instance_clauses +} + +func (*Instance_clausesContext) IsInstance_clausesContext() {} + +func NewInstance_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Instance_clausesContext { + var p = new(Instance_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_instance_clauses + + return p +} + +func (s *Instance_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Instance_clausesContext) Enable_or_disable() IEnable_or_disableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Instance_clausesContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Instance_clausesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Instance_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Instance_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Instance_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInstance_clauses(s) + } +} + +func (s *Instance_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInstance_clauses(s) + } +} + +func (s *Instance_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInstance_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Instance_clauses() (localctx IInstance_clausesContext) { + localctx = NewInstance_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1460, PlSqlParserRULE_instance_clauses) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13661) + p.Enable_or_disable() + } + { + p.SetState(13662) + p.Match(PlSqlParserINSTANCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13663) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// ISecurity_clauseContext is an interface to support dynamic dispatch. +type ISecurity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GUARD() antlr.TerminalNode + ALL() antlr.TerminalNode + STANDBY() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsSecurity_clauseContext differentiates from other interfaces. + IsSecurity_clauseContext() +} + +type Security_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySecurity_clauseContext() *Security_clauseContext { + var p = new(Security_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_security_clause + return p +} + +func InitEmptySecurity_clauseContext(p *Security_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_security_clause +} + +func (*Security_clauseContext) IsSecurity_clauseContext() {} + +func NewSecurity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Security_clauseContext { + var p = new(Security_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_security_clause + + return p +} + +func (s *Security_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Security_clauseContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Security_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Security_clauseContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Security_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Security_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Security_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Security_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSecurity_clause(s) + } +} + +func (s *Security_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSecurity_clause(s) + } +} + +func (s *Security_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSecurity_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Security_clause() (localctx ISecurity_clauseContext) { + localctx = NewSecurity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1462, PlSqlParserRULE_security_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13665) + p.Match(PlSqlParserGUARD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13666) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserNONE || _la == PlSqlParserSTANDBY) { + 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 +} + +// IDomainContext is an interface to support dynamic dispatch. +type IDomainContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDomainContext differentiates from other interfaces. + IsDomainContext() +} + +type DomainContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDomainContext() *DomainContext { + var p = new(DomainContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain + return p +} + +func InitEmptyDomainContext(p *DomainContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_domain +} + +func (*DomainContext) IsDomainContext() {} + +func NewDomainContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DomainContext { + var p = new(DomainContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_domain + + return p +} + +func (s *DomainContext) GetParser() antlr.Parser { return s.parser } + +func (s *DomainContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *DomainContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DomainContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DomainContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDomain(s) + } +} + +func (s *DomainContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDomain(s) + } +} + +func (s *DomainContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDomain(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Domain() (localctx IDomainContext) { + localctx = NewDomainContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1464, PlSqlParserRULE_domain) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13668) + p.Regular_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 +} + +// IDatabaseContext is an interface to support dynamic dispatch. +type IDatabaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsDatabaseContext differentiates from other interfaces. + IsDatabaseContext() +} + +type DatabaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabaseContext() *DatabaseContext { + var p = new(DatabaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database + return p +} + +func InitEmptyDatabaseContext(p *DatabaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database +} + +func (*DatabaseContext) IsDatabaseContext() {} + +func NewDatabaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatabaseContext { + var p = new(DatabaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database + + return p +} + +func (s *DatabaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatabaseContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *DatabaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DatabaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DatabaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase(s) + } +} + +func (s *DatabaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase(s) + } +} + +func (s *DatabaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database() (localctx IDatabaseContext) { + localctx = NewDatabaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1466, PlSqlParserRULE_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13670) + p.Regular_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 +} + +// IEdition_nameContext is an interface to support dynamic dispatch. +type IEdition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsEdition_nameContext differentiates from other interfaces. + IsEdition_nameContext() +} + +type Edition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEdition_nameContext() *Edition_nameContext { + var p = new(Edition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_edition_name + return p +} + +func InitEmptyEdition_nameContext(p *Edition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_edition_name +} + +func (*Edition_nameContext) IsEdition_nameContext() {} + +func NewEdition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Edition_nameContext { + var p = new(Edition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_edition_name + + return p +} + +func (s *Edition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Edition_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Edition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Edition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Edition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEdition_name(s) + } +} + +func (s *Edition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEdition_name(s) + } +} + +func (s *Edition_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEdition_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Edition_name() (localctx IEdition_nameContext) { + localctx = NewEdition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1468, PlSqlParserRULE_edition_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13672) + p.Regular_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 +} + +// IFilenumberContext is an interface to support dynamic dispatch. +type IFilenumberContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsFilenumberContext differentiates from other interfaces. + IsFilenumberContext() +} + +type FilenumberContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilenumberContext() *FilenumberContext { + var p = new(FilenumberContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filenumber + return p +} + +func InitEmptyFilenumberContext(p *FilenumberContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filenumber +} + +func (*FilenumberContext) IsFilenumberContext() {} + +func NewFilenumberContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenumberContext { + var p = new(FilenumberContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filenumber + + return p +} + +func (s *FilenumberContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilenumberContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *FilenumberContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilenumberContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilenumberContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilenumber(s) + } +} + +func (s *FilenumberContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilenumber(s) + } +} + +func (s *FilenumberContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFilenumber(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Filenumber() (localctx IFilenumberContext) { + localctx = NewFilenumberContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1470, PlSqlParserRULE_filenumber) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13674) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IFilenameContext is an interface to support dynamic dispatch. +type IFilenameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + + // IsFilenameContext differentiates from other interfaces. + IsFilenameContext() +} + +type FilenameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilenameContext() *FilenameContext { + var p = new(FilenameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename + return p +} + +func InitEmptyFilenameContext(p *FilenameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename +} + +func (*FilenameContext) IsFilenameContext() {} + +func NewFilenameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *FilenameContext { + var p = new(FilenameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filename + + return p +} + +func (s *FilenameContext) GetParser() antlr.Parser { return s.parser } + +func (s *FilenameContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *FilenameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *FilenameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *FilenameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilename(s) + } +} + +func (s *FilenameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilename(s) + } +} + +func (s *FilenameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFilename(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Filename() (localctx IFilenameContext) { + localctx = NewFilenameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1472, PlSqlParserRULE_filename) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13676) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IPrepare_clauseContext is an interface to support dynamic dispatch. +type IPrepare_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetC returns the c rule contexts. + GetC() IId_expressionContext + + // SetC sets the c rule contexts. + SetC(IId_expressionContext) + + // Getter signatures + PREPARE() antlr.TerminalNode + AllMIRROR() []antlr.TerminalNode + MIRROR(i int) antlr.TerminalNode + COPY() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + WITH() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + FOR() antlr.TerminalNode + DATABASE() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + HIGH() antlr.TerminalNode + + // IsPrepare_clauseContext differentiates from other interfaces. + IsPrepare_clauseContext() +} + +type Prepare_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + c IId_expressionContext +} + +func NewEmptyPrepare_clauseContext() *Prepare_clauseContext { + var p = new(Prepare_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_prepare_clause + return p +} + +func InitEmptyPrepare_clauseContext(p *Prepare_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_prepare_clause +} + +func (*Prepare_clauseContext) IsPrepare_clauseContext() {} + +func NewPrepare_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Prepare_clauseContext { + var p = new(Prepare_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_prepare_clause + + return p +} + +func (s *Prepare_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Prepare_clauseContext) GetC() IId_expressionContext { return s.c } + +func (s *Prepare_clauseContext) SetC(v IId_expressionContext) { s.c = v } + +func (s *Prepare_clauseContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Prepare_clauseContext) AllMIRROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMIRROR) +} + +func (s *Prepare_clauseContext) MIRROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, i) +} + +func (s *Prepare_clauseContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Prepare_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Prepare_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Prepare_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Prepare_clauseContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Prepare_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Prepare_clauseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Prepare_clauseContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Prepare_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Prepare_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Prepare_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Prepare_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrepare_clause(s) + } +} + +func (s *Prepare_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrepare_clause(s) + } +} + +func (s *Prepare_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrepare_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Prepare_clause() (localctx IPrepare_clauseContext) { + localctx = NewPrepare_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1474, PlSqlParserRULE_prepare_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13678) + p.Match(PlSqlParserPREPARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13679) + p.Match(PlSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13680) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13681) + + var _x = p.Id_expression() + + localctx.(*Prepare_clauseContext).c = _x + } + p.SetState(13685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(13682) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13683) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserMIRROR || _la == PlSqlParserUNPROTECTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13684) + p.Match(PlSqlParserREDUNDANCY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(13687) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13688) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13689) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_mirror_clauseContext is an interface to support dynamic dispatch. +type IDrop_mirror_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMn returns the mn rule contexts. + GetMn() IId_expressionContext + + // SetMn sets the mn rule contexts. + SetMn(IId_expressionContext) + + // Getter signatures + DROP() antlr.TerminalNode + MIRROR() antlr.TerminalNode + COPY() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsDrop_mirror_clauseContext differentiates from other interfaces. + IsDrop_mirror_clauseContext() +} + +type Drop_mirror_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + mn IId_expressionContext +} + +func NewEmptyDrop_mirror_clauseContext() *Drop_mirror_clauseContext { + var p = new(Drop_mirror_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause + return p +} + +func InitEmptyDrop_mirror_clauseContext(p *Drop_mirror_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause +} + +func (*Drop_mirror_clauseContext) IsDrop_mirror_clauseContext() {} + +func NewDrop_mirror_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_mirror_clauseContext { + var p = new(Drop_mirror_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_mirror_clause + + return p +} + +func (s *Drop_mirror_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_mirror_clauseContext) GetMn() IId_expressionContext { return s.mn } + +func (s *Drop_mirror_clauseContext) SetMn(v IId_expressionContext) { s.mn = v } + +func (s *Drop_mirror_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_mirror_clauseContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Drop_mirror_clauseContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Drop_mirror_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Drop_mirror_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_mirror_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_mirror_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_mirror_clause(s) + } +} + +func (s *Drop_mirror_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_mirror_clause(s) + } +} + +func (s *Drop_mirror_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_mirror_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_mirror_clause() (localctx IDrop_mirror_clauseContext) { + localctx = NewDrop_mirror_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1476, PlSqlParserRULE_drop_mirror_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13692) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13693) + p.Match(PlSqlParserMIRROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13694) + p.Match(PlSqlParserCOPY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13695) + + var _x = p.Id_expression() + + localctx.(*Drop_mirror_clauseContext).mn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILost_write_protectionContext is an interface to support dynamic dispatch. +type ILost_write_protectionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOST() antlr.TerminalNode + WRITE() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + REMOVE() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + + // IsLost_write_protectionContext differentiates from other interfaces. + IsLost_write_protectionContext() +} + +type Lost_write_protectionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLost_write_protectionContext() *Lost_write_protectionContext { + var p = new(Lost_write_protectionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lost_write_protection + return p +} + +func InitEmptyLost_write_protectionContext(p *Lost_write_protectionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lost_write_protection +} + +func (*Lost_write_protectionContext) IsLost_write_protectionContext() {} + +func NewLost_write_protectionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lost_write_protectionContext { + var p = new(Lost_write_protectionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lost_write_protection + + return p +} + +func (s *Lost_write_protectionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lost_write_protectionContext) LOST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOST, 0) +} + +func (s *Lost_write_protectionContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Lost_write_protectionContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Lost_write_protectionContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Lost_write_protectionContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Lost_write_protectionContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Lost_write_protectionContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Lost_write_protectionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lost_write_protectionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lost_write_protectionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLost_write_protection(s) + } +} + +func (s *Lost_write_protectionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLost_write_protection(s) + } +} + +func (s *Lost_write_protectionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLost_write_protection(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lost_write_protection() (localctx ILost_write_protectionContext) { + localctx = NewLost_write_protectionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1478, PlSqlParserRULE_lost_write_protection) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13697) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE || _la == PlSqlParserREMOVE || _la == PlSqlParserSUSPEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13698) + p.Match(PlSqlParserLOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13699) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13700) + p.Match(PlSqlParserPROTECTION) + 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 +} + +// ICdb_fleet_clausesContext is an interface to support dynamic dispatch. +type ICdb_fleet_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Lead_cdb_clause() ILead_cdb_clauseContext + Lead_cdb_uri_clause() ILead_cdb_uri_clauseContext + + // IsCdb_fleet_clausesContext differentiates from other interfaces. + IsCdb_fleet_clausesContext() +} + +type Cdb_fleet_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCdb_fleet_clausesContext() *Cdb_fleet_clausesContext { + var p = new(Cdb_fleet_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses + return p +} + +func InitEmptyCdb_fleet_clausesContext(p *Cdb_fleet_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses +} + +func (*Cdb_fleet_clausesContext) IsCdb_fleet_clausesContext() {} + +func NewCdb_fleet_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cdb_fleet_clausesContext { + var p = new(Cdb_fleet_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cdb_fleet_clauses + + return p +} + +func (s *Cdb_fleet_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cdb_fleet_clausesContext) Lead_cdb_clause() ILead_cdb_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILead_cdb_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILead_cdb_clauseContext) +} + +func (s *Cdb_fleet_clausesContext) Lead_cdb_uri_clause() ILead_cdb_uri_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILead_cdb_uri_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILead_cdb_uri_clauseContext) +} + +func (s *Cdb_fleet_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cdb_fleet_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cdb_fleet_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCdb_fleet_clauses(s) + } +} + +func (s *Cdb_fleet_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCdb_fleet_clauses(s) + } +} + +func (s *Cdb_fleet_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCdb_fleet_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cdb_fleet_clauses() (localctx ICdb_fleet_clausesContext) { + localctx = NewCdb_fleet_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1480, PlSqlParserRULE_cdb_fleet_clauses) + p.SetState(13704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1762, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13702) + p.Lead_cdb_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13703) + p.Lead_cdb_uri_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 +} + +// ILead_cdb_clauseContext is an interface to support dynamic dispatch. +type ILead_cdb_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + LEAD_CDB() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + + // IsLead_cdb_clauseContext differentiates from other interfaces. + IsLead_cdb_clauseContext() +} + +type Lead_cdb_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLead_cdb_clauseContext() *Lead_cdb_clauseContext { + var p = new(Lead_cdb_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause + return p +} + +func InitEmptyLead_cdb_clauseContext(p *Lead_cdb_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause +} + +func (*Lead_cdb_clauseContext) IsLead_cdb_clauseContext() {} + +func NewLead_cdb_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lead_cdb_clauseContext { + var p = new(Lead_cdb_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lead_cdb_clause + + return p +} + +func (s *Lead_cdb_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lead_cdb_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Lead_cdb_clauseContext) LEAD_CDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB, 0) +} + +func (s *Lead_cdb_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lead_cdb_clauseContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *Lead_cdb_clauseContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *Lead_cdb_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lead_cdb_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lead_cdb_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLead_cdb_clause(s) + } +} + +func (s *Lead_cdb_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLead_cdb_clause(s) + } +} + +func (s *Lead_cdb_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLead_cdb_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lead_cdb_clause() (localctx ILead_cdb_clauseContext) { + localctx = NewLead_cdb_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1482, PlSqlParserRULE_lead_cdb_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13706) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13707) + p.Match(PlSqlParserLEAD_CDB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13708) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13709) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFALSE || _la == PlSqlParserTRUE) { + 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 +} + +// ILead_cdb_uri_clauseContext is an interface to support dynamic dispatch. +type ILead_cdb_uri_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + LEAD_CDB_URI() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsLead_cdb_uri_clauseContext differentiates from other interfaces. + IsLead_cdb_uri_clauseContext() +} + +type Lead_cdb_uri_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLead_cdb_uri_clauseContext() *Lead_cdb_uri_clauseContext { + var p = new(Lead_cdb_uri_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause + return p +} + +func InitEmptyLead_cdb_uri_clauseContext(p *Lead_cdb_uri_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause +} + +func (*Lead_cdb_uri_clauseContext) IsLead_cdb_uri_clauseContext() {} + +func NewLead_cdb_uri_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lead_cdb_uri_clauseContext { + var p = new(Lead_cdb_uri_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lead_cdb_uri_clause + + return p +} + +func (s *Lead_cdb_uri_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lead_cdb_uri_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Lead_cdb_uri_clauseContext) LEAD_CDB_URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB_URI, 0) +} + +func (s *Lead_cdb_uri_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Lead_cdb_uri_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Lead_cdb_uri_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lead_cdb_uri_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lead_cdb_uri_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLead_cdb_uri_clause(s) + } +} + +func (s *Lead_cdb_uri_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLead_cdb_uri_clause(s) + } +} + +func (s *Lead_cdb_uri_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLead_cdb_uri_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lead_cdb_uri_clause() (localctx ILead_cdb_uri_clauseContext) { + localctx = NewLead_cdb_uri_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1484, PlSqlParserRULE_lead_cdb_uri_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13711) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13712) + p.Match(PlSqlParserLEAD_CDB_URI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13713) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13714) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IProperty_clausesContext is an interface to support dynamic dispatch. +type IProperty_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetQcn returns the qcn rule contexts. + GetQcn() IId_expressionContext + + // SetQcn sets the qcn rule contexts. + SetQcn(IId_expressionContext) + + // Getter signatures + PROPERTY() antlr.TerminalNode + DEFAULT_CREDENTIAL() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + SET() antlr.TerminalNode + REMOVE() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProperty_clausesContext differentiates from other interfaces. + IsProperty_clausesContext() +} + +type Property_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + qcn IId_expressionContext +} + +func NewEmptyProperty_clausesContext() *Property_clausesContext { + var p = new(Property_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_clauses + return p +} + +func InitEmptyProperty_clausesContext(p *Property_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_property_clauses +} + +func (*Property_clausesContext) IsProperty_clausesContext() {} + +func NewProperty_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Property_clausesContext { + var p = new(Property_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_property_clauses + + return p +} + +func (s *Property_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Property_clausesContext) GetQcn() IId_expressionContext { return s.qcn } + +func (s *Property_clausesContext) SetQcn(v IId_expressionContext) { s.qcn = v } + +func (s *Property_clausesContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPERTY, 0) +} + +func (s *Property_clausesContext) DEFAULT_CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_CREDENTIAL, 0) +} + +func (s *Property_clausesContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Property_clausesContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Property_clausesContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Property_clausesContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Property_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Property_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Property_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProperty_clauses(s) + } +} + +func (s *Property_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProperty_clauses(s) + } +} + +func (s *Property_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProperty_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Property_clauses() (localctx IProperty_clausesContext) { + localctx = NewProperty_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1486, PlSqlParserRULE_property_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13716) + p.Match(PlSqlParserPROPERTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13717) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserREMOVE || _la == PlSqlParserSET) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13718) + p.Match(PlSqlParserDEFAULT_CREDENTIAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13719) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13720) + + var _x = p.Id_expression() + + localctx.(*Property_clausesContext).qcn = _x + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReplay_upgrade_clausesContext is an interface to support dynamic dispatch. +type IReplay_upgrade_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPGRADE() antlr.TerminalNode + SYNC() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsReplay_upgrade_clausesContext differentiates from other interfaces. + IsReplay_upgrade_clausesContext() +} + +type Replay_upgrade_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReplay_upgrade_clausesContext() *Replay_upgrade_clausesContext { + var p = new(Replay_upgrade_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses + return p +} + +func InitEmptyReplay_upgrade_clausesContext(p *Replay_upgrade_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses +} + +func (*Replay_upgrade_clausesContext) IsReplay_upgrade_clausesContext() {} + +func NewReplay_upgrade_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Replay_upgrade_clausesContext { + var p = new(Replay_upgrade_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_replay_upgrade_clauses + + return p +} + +func (s *Replay_upgrade_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Replay_upgrade_clausesContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Replay_upgrade_clausesContext) SYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNC, 0) +} + +func (s *Replay_upgrade_clausesContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Replay_upgrade_clausesContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Replay_upgrade_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Replay_upgrade_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Replay_upgrade_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReplay_upgrade_clauses(s) + } +} + +func (s *Replay_upgrade_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReplay_upgrade_clauses(s) + } +} + +func (s *Replay_upgrade_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReplay_upgrade_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Replay_upgrade_clauses() (localctx IReplay_upgrade_clausesContext) { + localctx = NewReplay_upgrade_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1488, PlSqlParserRULE_replay_upgrade_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13722) + p.Match(PlSqlParserUPGRADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13723) + p.Match(PlSqlParserSYNC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13724) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + 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_database_linkContext is an interface to support dynamic dispatch. +type IAlter_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALTER() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Link_name() ILink_nameContext + CONNECT() antlr.TerminalNode + TO() antlr.TerminalNode + User_object_name() IUser_object_nameContext + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Password_value() IPassword_valueContext + Link_authentication() ILink_authenticationContext + SHARED() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + + // IsAlter_database_linkContext differentiates from other interfaces. + IsAlter_database_linkContext() +} + +type Alter_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_database_linkContext() *Alter_database_linkContext { + var p = new(Alter_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database_link + return p +} + +func InitEmptyAlter_database_linkContext(p *Alter_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_database_link +} + +func (*Alter_database_linkContext) IsAlter_database_linkContext() {} + +func NewAlter_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_database_linkContext { + var p = new(Alter_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_database_link + + return p +} + +func (s *Alter_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_database_linkContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Alter_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Alter_database_linkContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Alter_database_linkContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Alter_database_linkContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_database_linkContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Alter_database_linkContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Alter_database_linkContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Alter_database_linkContext) Password_value() IPassword_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Alter_database_linkContext) Link_authentication() ILink_authenticationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_authenticationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_authenticationContext) +} + +func (s *Alter_database_linkContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Alter_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Alter_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_database_link(s) + } +} + +func (s *Alter_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_database_link(s) + } +} + +func (s *Alter_database_linkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_database_link(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_database_link() (localctx IAlter_database_linkContext) { + localctx = NewAlter_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1490, PlSqlParserRULE_alter_database_link) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13726) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARED { + { + p.SetState(13727) + p.Match(PlSqlParserSHARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(13730) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13733) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13734) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13735) + p.Link_name() + } + p.SetState(13746) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + { + p.SetState(13736) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13737) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13738) + p.User_object_name() + } + { + p.SetState(13739) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13740) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13741) + p.Password_value() + } + p.SetState(13743) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1765, p.GetParserRuleContext()) == 1 { + { + p.SetState(13742) + p.Link_authentication() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserAUTHENTICATED: + { + p.SetState(13745) + p.Link_authentication() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPassword_valueContext is an interface to support dynamic dispatch. +type IPassword_valueContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + Numeric() INumericContext + + // IsPassword_valueContext differentiates from other interfaces. + IsPassword_valueContext() +} + +type Password_valueContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPassword_valueContext() *Password_valueContext { + var p = new(Password_valueContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_value + return p +} + +func InitEmptyPassword_valueContext(p *Password_valueContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_password_value +} + +func (*Password_valueContext) IsPassword_valueContext() {} + +func NewPassword_valueContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Password_valueContext { + var p = new(Password_valueContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_password_value + + return p +} + +func (s *Password_valueContext) GetParser() antlr.Parser { return s.parser } + +func (s *Password_valueContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Password_valueContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Password_valueContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Password_valueContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Password_valueContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPassword_value(s) + } +} + +func (s *Password_valueContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPassword_value(s) + } +} + +func (s *Password_valueContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPassword_value(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Password_value() (localctx IPassword_valueContext) { + localctx = NewPassword_valueContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1492, PlSqlParserRULE_password_value) + p.SetState(13750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13748) + p.Id_expression() + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13749) + p.Numeric() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILink_authenticationContext is an interface to support dynamic dispatch. +type ILink_authenticationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHENTICATED() antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + User_object_name() IUser_object_nameContext + IDENTIFIED() antlr.TerminalNode + Password_value() IPassword_valueContext + + // IsLink_authenticationContext differentiates from other interfaces. + IsLink_authenticationContext() +} + +type Link_authenticationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLink_authenticationContext() *Link_authenticationContext { + var p = new(Link_authenticationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_authentication + return p +} + +func InitEmptyLink_authenticationContext(p *Link_authenticationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_authentication +} + +func (*Link_authenticationContext) IsLink_authenticationContext() {} + +func NewLink_authenticationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Link_authenticationContext { + var p = new(Link_authenticationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_link_authentication + + return p +} + +func (s *Link_authenticationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Link_authenticationContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Link_authenticationContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Link_authenticationContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Link_authenticationContext) User_object_name() IUser_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Link_authenticationContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Link_authenticationContext) Password_value() IPassword_valueContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Link_authenticationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Link_authenticationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Link_authenticationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLink_authentication(s) + } +} + +func (s *Link_authenticationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLink_authentication(s) + } +} + +func (s *Link_authenticationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLink_authentication(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Link_authentication() (localctx ILink_authenticationContext) { + localctx = NewLink_authenticationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1494, PlSqlParserRULE_link_authentication) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13752) + p.Match(PlSqlParserAUTHENTICATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13753) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13754) + p.User_object_name() + } + { + p.SetState(13755) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13756) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13757) + p.Password_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 +} + +// 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 + Database_name() IDatabase_nameContext + AllUSER() []antlr.TerminalNode + USER(i int) antlr.TerminalNode + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPassword_value() []IPassword_valueContext + Password_value(i int) IPassword_valueContext + AllCONTROLFILE() []antlr.TerminalNode + CONTROLFILE(i int) antlr.TerminalNode + AllREUSE() []antlr.TerminalNode + REUSE(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllCHARACTER() []antlr.TerminalNode + CHARACTER(i int) antlr.TerminalNode + AllSET() []antlr.TerminalNode + SET(i int) antlr.TerminalNode + AllChar_set_name() []IChar_set_nameContext + Char_set_name(i int) IChar_set_nameContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllDatabase_logging_clauses() []IDatabase_logging_clausesContext + Database_logging_clauses(i int) IDatabase_logging_clausesContext + AllTablespace_clauses() []ITablespace_clausesContext + Tablespace_clauses(i int) ITablespace_clausesContext + AllSet_time_zone_clause() []ISet_time_zone_clauseContext + Set_time_zone_clause(i int) ISet_time_zone_clauseContext + AllUSER_DATA() []antlr.TerminalNode + USER_DATA(i int) antlr.TerminalNode + AllTablespace_group_name() []ITablespace_group_nameContext + Tablespace_group_name(i int) ITablespace_group_nameContext + AllDATAFILE() []antlr.TerminalNode + DATAFILE(i int) antlr.TerminalNode + AllDatafile_tempfile_spec() []IDatafile_tempfile_specContext + Datafile_tempfile_spec(i int) IDatafile_tempfile_specContext + AllEnable_pluggable_database() []IEnable_pluggable_databaseContext + Enable_pluggable_database(i int) IEnable_pluggable_databaseContext + AllSYS() []antlr.TerminalNode + SYS(i int) antlr.TerminalNode + AllSYSTEM() []antlr.TerminalNode + SYSTEM(i int) antlr.TerminalNode + AllMAXDATAFILES() []antlr.TerminalNode + MAXDATAFILES(i int) antlr.TerminalNode + AllMAXINSTANCES() []antlr.TerminalNode + MAXINSTANCES(i int) antlr.TerminalNode + AllBIGFILE() []antlr.TerminalNode + BIGFILE(i int) antlr.TerminalNode + AllSMALLFILE() []antlr.TerminalNode + SMALLFILE(i int) antlr.TerminalNode + AllNATIONAL() []antlr.TerminalNode + NATIONAL(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // 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 = PlSqlParserRULE_create_database + return p +} + +func InitEmptyCreate_databaseContext(p *Create_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_create_database + + return p +} + +func (s *Create_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_databaseContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_databaseContext) Database_name() IDatabase_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_nameContext) +} + +func (s *Create_databaseContext) AllUSER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSER) +} + +func (s *Create_databaseContext) USER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, i) +} + +func (s *Create_databaseContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Create_databaseContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Create_databaseContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Create_databaseContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Create_databaseContext) AllPassword_value() []IPassword_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_valueContext); ok { + len++ + } + } + + tst := make([]IPassword_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_valueContext); ok { + tst[i] = t.(IPassword_valueContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Password_value(i int) IPassword_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Create_databaseContext) AllCONTROLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONTROLFILE) +} + +func (s *Create_databaseContext) CONTROLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, i) +} + +func (s *Create_databaseContext) AllREUSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREUSE) +} + +func (s *Create_databaseContext) REUSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, i) +} + +func (s *Create_databaseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Create_databaseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Create_databaseContext) AllCHARACTER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHARACTER) +} + +func (s *Create_databaseContext) CHARACTER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, i) +} + +func (s *Create_databaseContext) AllSET() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSET) +} + +func (s *Create_databaseContext) SET(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, i) +} + +func (s *Create_databaseContext) AllChar_set_name() []IChar_set_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IChar_set_nameContext); ok { + len++ + } + } + + tst := make([]IChar_set_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IChar_set_nameContext); ok { + tst[i] = t.(IChar_set_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Char_set_name(i int) IChar_set_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Create_databaseContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Create_databaseContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Create_databaseContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Create_databaseContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Create_databaseContext) AllDatabase_logging_clauses() []IDatabase_logging_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_logging_clausesContext); ok { + len++ + } + } + + tst := make([]IDatabase_logging_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_logging_clausesContext); ok { + tst[i] = t.(IDatabase_logging_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Database_logging_clauses(i int) IDatabase_logging_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_logging_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_logging_clausesContext) +} + +func (s *Create_databaseContext) AllTablespace_clauses() []ITablespace_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_clausesContext); ok { + len++ + } + } + + tst := make([]ITablespace_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_clausesContext); ok { + tst[i] = t.(ITablespace_clausesContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Tablespace_clauses(i int) ITablespace_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_clausesContext) +} + +func (s *Create_databaseContext) AllSet_time_zone_clause() []ISet_time_zone_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + len++ + } + } + + tst := make([]ISet_time_zone_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISet_time_zone_clauseContext); ok { + tst[i] = t.(ISet_time_zone_clauseContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Set_time_zone_clause(i int) ISet_time_zone_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_time_zone_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISet_time_zone_clauseContext) +} + +func (s *Create_databaseContext) AllUSER_DATA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUSER_DATA) +} + +func (s *Create_databaseContext) USER_DATA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DATA, i) +} + +func (s *Create_databaseContext) AllTablespace_group_name() []ITablespace_group_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + len++ + } + } + + tst := make([]ITablespace_group_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_group_nameContext); ok { + tst[i] = t.(ITablespace_group_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Tablespace_group_name(i int) ITablespace_group_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_nameContext) +} + +func (s *Create_databaseContext) AllDATAFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDATAFILE) +} + +func (s *Create_databaseContext) DATAFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, i) +} + +func (s *Create_databaseContext) AllDatafile_tempfile_spec() []IDatafile_tempfile_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + len++ + } + } + + tst := make([]IDatafile_tempfile_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatafile_tempfile_specContext); ok { + tst[i] = t.(IDatafile_tempfile_specContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Datafile_tempfile_spec(i int) IDatafile_tempfile_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Create_databaseContext) AllEnable_pluggable_database() []IEnable_pluggable_databaseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_pluggable_databaseContext); ok { + len++ + } + } + + tst := make([]IEnable_pluggable_databaseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_pluggable_databaseContext); ok { + tst[i] = t.(IEnable_pluggable_databaseContext) + i++ + } + } + + return tst +} + +func (s *Create_databaseContext) Enable_pluggable_database(i int) IEnable_pluggable_databaseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_pluggable_databaseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_pluggable_databaseContext) +} + +func (s *Create_databaseContext) AllSYS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSYS) +} + +func (s *Create_databaseContext) SYS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, i) +} + +func (s *Create_databaseContext) AllSYSTEM() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSYSTEM) +} + +func (s *Create_databaseContext) SYSTEM(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, i) +} + +func (s *Create_databaseContext) AllMAXDATAFILES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXDATAFILES) +} + +func (s *Create_databaseContext) MAXDATAFILES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, i) +} + +func (s *Create_databaseContext) AllMAXINSTANCES() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMAXINSTANCES) +} + +func (s *Create_databaseContext) MAXINSTANCES(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, i) +} + +func (s *Create_databaseContext) AllBIGFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBIGFILE) +} + +func (s *Create_databaseContext) BIGFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, i) +} + +func (s *Create_databaseContext) AllSMALLFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSMALLFILE) +} + +func (s *Create_databaseContext) SMALLFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, i) +} + +func (s *Create_databaseContext) AllNATIONAL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNATIONAL) +} + +func (s *Create_databaseContext) NATIONAL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL, i) +} + +func (s *Create_databaseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Create_databaseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterCreate_database(s) + } +} + +func (s *Create_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_database(s) + } +} + +func (s *Create_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_database() (localctx ICreate_databaseContext) { + localctx = NewCreate_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1496, PlSqlParserRULE_create_database) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13759) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13760) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13761) + p.Database_name() + } + p.SetState(13800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(13800) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1771, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13762) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13763) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSYS || _la == PlSqlParserSYSTEM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13764) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13765) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13766) + p.Password_value() + } + + case 2: + { + p.SetState(13767) + p.Match(PlSqlParserCONTROLFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13768) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(13769) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMAXDATAFILES || _la == PlSqlParserMAXINSTANCES) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13770) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.SetState(13772) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNATIONAL { + { + p.SetState(13771) + p.Match(PlSqlParserNATIONAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13774) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13775) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13776) + p.Char_set_name() + } + + case 5: + { + p.SetState(13777) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13778) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13779) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13780) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + { + p.SetState(13781) + p.Database_logging_clauses() + } + + case 7: + { + p.SetState(13782) + p.Tablespace_clauses() + } + + case 8: + { + p.SetState(13783) + p.Set_time_zone_clause() + } + + case 9: + p.SetState(13785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(13784) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13787) + p.Match(PlSqlParserUSER_DATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13788) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13789) + p.Tablespace_group_name() + } + { + p.SetState(13790) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13791) + p.Datafile_tempfile_spec() + } + p.SetState(13796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1770, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13792) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13793) + p.Datafile_tempfile_spec() + } + + } + p.SetState(13798) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1770, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 10: + { + p.SetState(13799) + p.Enable_pluggable_database() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(13802) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1772, 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 +} + +// IDatabase_logging_clausesContext is an interface to support dynamic dispatch. +type IDatabase_logging_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOGFILE() antlr.TerminalNode + AllDatabase_logging_sub_clause() []IDatabase_logging_sub_clauseContext + Database_logging_sub_clause(i int) IDatabase_logging_sub_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + MAXLOGFILES() antlr.TerminalNode + MAXLOGMEMBERS() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + FORCE() antlr.TerminalNode + LOGGING() antlr.TerminalNode + + // IsDatabase_logging_clausesContext differentiates from other interfaces. + IsDatabase_logging_clausesContext() +} + +type Database_logging_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_logging_clausesContext() *Database_logging_clausesContext { + var p = new(Database_logging_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_clauses + return p +} + +func InitEmptyDatabase_logging_clausesContext(p *Database_logging_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_clauses +} + +func (*Database_logging_clausesContext) IsDatabase_logging_clausesContext() {} + +func NewDatabase_logging_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_logging_clausesContext { + var p = new(Database_logging_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_logging_clauses + + return p +} + +func (s *Database_logging_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_logging_clausesContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Database_logging_clausesContext) AllDatabase_logging_sub_clause() []IDatabase_logging_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IDatabase_logging_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + tst[i] = t.(IDatabase_logging_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *Database_logging_clausesContext) Database_logging_sub_clause(i int) IDatabase_logging_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_logging_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_logging_sub_clauseContext) +} + +func (s *Database_logging_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Database_logging_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Database_logging_clausesContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Database_logging_clausesContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Database_logging_clausesContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Database_logging_clausesContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Database_logging_clausesContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Database_logging_clausesContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Database_logging_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_logging_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_logging_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_logging_clauses(s) + } +} + +func (s *Database_logging_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_logging_clauses(s) + } +} + +func (s *Database_logging_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase_logging_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database_logging_clauses() (localctx IDatabase_logging_clausesContext) { + localctx = NewDatabase_logging_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1498, PlSqlParserRULE_database_logging_clauses) + var _la int + + var _alt int + + p.SetState(13819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOGFILE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13804) + p.Match(PlSqlParserLOGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13805) + p.Database_logging_sub_clause() + } + p.SetState(13810) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1773, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13806) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13807) + p.Database_logging_sub_clause() + } + + } + p.SetState(13812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1773, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(13813) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-855)) & ^0x3f) == 0 && ((int64(1)<<(_la-855))&7) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(13814) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserARCHIVELOG: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13815) + p.Match(PlSqlParserARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOARCHIVELOG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13816) + p.Match(PlSqlParserNOARCHIVELOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFORCE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13817) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13818) + p.Match(PlSqlParserLOGGING) + 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 +} + +// IDatabase_logging_sub_clauseContext is an interface to support dynamic dispatch. +type IDatabase_logging_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + File_specification() IFile_specificationContext + GROUP() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsDatabase_logging_sub_clauseContext differentiates from other interfaces. + IsDatabase_logging_sub_clauseContext() +} + +type Database_logging_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatabase_logging_sub_clauseContext() *Database_logging_sub_clauseContext { + var p = new(Database_logging_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause + return p +} + +func InitEmptyDatabase_logging_sub_clauseContext(p *Database_logging_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause +} + +func (*Database_logging_sub_clauseContext) IsDatabase_logging_sub_clauseContext() {} + +func NewDatabase_logging_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Database_logging_sub_clauseContext { + var p = new(Database_logging_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_database_logging_sub_clause + + return p +} + +func (s *Database_logging_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Database_logging_sub_clauseContext) File_specification() IFile_specificationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Database_logging_sub_clauseContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Database_logging_sub_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Database_logging_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Database_logging_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Database_logging_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatabase_logging_sub_clause(s) + } +} + +func (s *Database_logging_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatabase_logging_sub_clause(s) + } +} + +func (s *Database_logging_sub_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatabase_logging_sub_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Database_logging_sub_clause() (localctx IDatabase_logging_sub_clauseContext) { + localctx = NewDatabase_logging_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1500, PlSqlParserRULE_database_logging_sub_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(13823) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1775, p.GetParserRuleContext()) == 1 { + { + p.SetState(13821) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13822) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(13825) + p.File_specification() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_clausesContext is an interface to support dynamic dispatch. +type ITablespace_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXTENT() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + LOCAL() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + SYSAUX() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Default_tablespace() IDefault_tablespaceContext + Default_temp_tablespace() IDefault_temp_tablespaceContext + Undo_tablespace() IUndo_tablespaceContext + + // IsTablespace_clausesContext differentiates from other interfaces. + IsTablespace_clausesContext() +} + +type Tablespace_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_clausesContext() *Tablespace_clausesContext { + var p = new(Tablespace_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_clauses + return p +} + +func InitEmptyTablespace_clausesContext(p *Tablespace_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_clauses +} + +func (*Tablespace_clausesContext) IsTablespace_clausesContext() {} + +func NewTablespace_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_clausesContext { + var p = new(Tablespace_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_clauses + + return p +} + +func (s *Tablespace_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_clausesContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Tablespace_clausesContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Tablespace_clausesContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Tablespace_clausesContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Tablespace_clausesContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_clausesContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Tablespace_clausesContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Tablespace_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Tablespace_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Tablespace_clausesContext) Default_tablespace() IDefault_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespaceContext) +} + +func (s *Tablespace_clausesContext) Default_temp_tablespace() IDefault_temp_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_temp_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_temp_tablespaceContext) +} + +func (s *Tablespace_clausesContext) Undo_tablespace() IUndo_tablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_tablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_tablespaceContext) +} + +func (s *Tablespace_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_clauses(s) + } +} + +func (s *Tablespace_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_clauses(s) + } +} + +func (s *Tablespace_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_clauses() (localctx ITablespace_clausesContext) { + localctx = NewTablespace_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1502, PlSqlParserRULE_tablespace_clauses) + var _la int + + var _alt int + + p.SetState(13845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1778, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13827) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13828) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13829) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(13831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSYSAUX { + { + p.SetState(13830) + p.Match(PlSqlParserSYSAUX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13833) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13834) + p.File_specification() + } + p.SetState(13839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1777, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13835) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13836) + p.File_specification() + } + + } + p.SetState(13841) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1777, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(13842) + p.Default_tablespace() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(13843) + p.Default_temp_tablespace() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(13844) + p.Undo_tablespace() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEnable_pluggable_databaseContext is an interface to support dynamic dispatch. +type IEnable_pluggable_databaseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + SEED() antlr.TerminalNode + Undo_mode_clause() IUndo_mode_clauseContext + File_name_convert() IFile_name_convertContext + SYSTEM() antlr.TerminalNode + AllTablespace_datafile_clauses() []ITablespace_datafile_clausesContext + Tablespace_datafile_clauses(i int) ITablespace_datafile_clausesContext + SYSAUX() antlr.TerminalNode + + // IsEnable_pluggable_databaseContext differentiates from other interfaces. + IsEnable_pluggable_databaseContext() +} + +type Enable_pluggable_databaseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_pluggable_databaseContext() *Enable_pluggable_databaseContext { + var p = new(Enable_pluggable_databaseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database + return p +} + +func InitEmptyEnable_pluggable_databaseContext(p *Enable_pluggable_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database +} + +func (*Enable_pluggable_databaseContext) IsEnable_pluggable_databaseContext() {} + +func NewEnable_pluggable_databaseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_pluggable_databaseContext { + var p = new(Enable_pluggable_databaseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_pluggable_database + + return p +} + +func (s *Enable_pluggable_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_pluggable_databaseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_pluggable_databaseContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Enable_pluggable_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Enable_pluggable_databaseContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Enable_pluggable_databaseContext) Undo_mode_clause() IUndo_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUndo_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUndo_mode_clauseContext) +} + +func (s *Enable_pluggable_databaseContext) File_name_convert() IFile_name_convertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_name_convertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFile_name_convertContext) +} + +func (s *Enable_pluggable_databaseContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Enable_pluggable_databaseContext) AllTablespace_datafile_clauses() []ITablespace_datafile_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespace_datafile_clausesContext); ok { + len++ + } + } + + tst := make([]ITablespace_datafile_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespace_datafile_clausesContext); ok { + tst[i] = t.(ITablespace_datafile_clausesContext) + i++ + } + } + + return tst +} + +func (s *Enable_pluggable_databaseContext) Tablespace_datafile_clauses(i int) ITablespace_datafile_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_datafile_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_datafile_clausesContext) +} + +func (s *Enable_pluggable_databaseContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Enable_pluggable_databaseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_pluggable_databaseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_pluggable_databaseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_pluggable_database(s) + } +} + +func (s *Enable_pluggable_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_pluggable_database(s) + } +} + +func (s *Enable_pluggable_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnable_pluggable_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Enable_pluggable_database() (localctx IEnable_pluggable_databaseContext) { + localctx = NewEnable_pluggable_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1504, PlSqlParserRULE_enable_pluggable_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13847) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13848) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13849) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13862) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1782, p.GetParserRuleContext()) == 1 { + { + p.SetState(13850) + p.Match(PlSqlParserSEED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13852) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1779, p.GetParserRuleContext()) == 1 { + { + p.SetState(13851) + p.File_name_convert() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13856) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1780, p.GetParserRuleContext()) == 1 { + { + p.SetState(13854) + p.Match(PlSqlParserSYSTEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13855) + p.Tablespace_datafile_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13860) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1781, p.GetParserRuleContext()) == 1 { + { + p.SetState(13858) + p.Match(PlSqlParserSYSAUX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13859) + p.Tablespace_datafile_clauses() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13865) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1783, p.GetParserRuleContext()) == 1 { + { + p.SetState(13864) + p.Undo_mode_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 +} + +// IFile_name_convertContext is an interface to support dynamic dispatch. +type IFile_name_convertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILE_NAME_CONVERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllFilename_convert_sub_clause() []IFilename_convert_sub_clauseContext + Filename_convert_sub_clause(i int) IFilename_convert_sub_clauseContext + RIGHT_PAREN() antlr.TerminalNode + NONE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFile_name_convertContext differentiates from other interfaces. + IsFile_name_convertContext() +} + +type File_name_convertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFile_name_convertContext() *File_name_convertContext { + var p = new(File_name_convertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_name_convert + return p +} + +func InitEmptyFile_name_convertContext(p *File_name_convertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_file_name_convert +} + +func (*File_name_convertContext) IsFile_name_convertContext() {} + +func NewFile_name_convertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *File_name_convertContext { + var p = new(File_name_convertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_file_name_convert + + return p +} + +func (s *File_name_convertContext) GetParser() antlr.Parser { return s.parser } + +func (s *File_name_convertContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *File_name_convertContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *File_name_convertContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *File_name_convertContext) AllFilename_convert_sub_clause() []IFilename_convert_sub_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + len++ + } + } + + tst := make([]IFilename_convert_sub_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + tst[i] = t.(IFilename_convert_sub_clauseContext) + i++ + } + } + + return tst +} + +func (s *File_name_convertContext) Filename_convert_sub_clause(i int) IFilename_convert_sub_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFilename_convert_sub_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFilename_convert_sub_clauseContext) +} + +func (s *File_name_convertContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *File_name_convertContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *File_name_convertContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *File_name_convertContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *File_name_convertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *File_name_convertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *File_name_convertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFile_name_convert(s) + } +} + +func (s *File_name_convertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFile_name_convert(s) + } +} + +func (s *File_name_convertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFile_name_convert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) File_name_convert() (localctx IFile_name_convertContext) { + localctx = NewFile_name_convertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1506, PlSqlParserRULE_file_name_convert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13867) + p.Match(PlSqlParserFILE_NAME_CONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13868) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13881) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(13869) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13870) + p.Filename_convert_sub_clause() + } + p.SetState(13875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(13871) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13872) + p.Filename_convert_sub_clause() + } + + p.SetState(13877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(13878) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(13880) + p.Match(PlSqlParserNONE) + 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 +} + +// IFilename_convert_sub_clauseContext is an interface to support dynamic dispatch. +type IFilename_convert_sub_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + + // IsFilename_convert_sub_clauseContext differentiates from other interfaces. + IsFilename_convert_sub_clauseContext() +} + +type Filename_convert_sub_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFilename_convert_sub_clauseContext() *Filename_convert_sub_clauseContext { + var p = new(Filename_convert_sub_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause + return p +} + +func InitEmptyFilename_convert_sub_clauseContext(p *Filename_convert_sub_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause +} + +func (*Filename_convert_sub_clauseContext) IsFilename_convert_sub_clauseContext() {} + +func NewFilename_convert_sub_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Filename_convert_sub_clauseContext { + var p = new(Filename_convert_sub_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_filename_convert_sub_clause + + return p +} + +func (s *Filename_convert_sub_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Filename_convert_sub_clauseContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Filename_convert_sub_clauseContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Filename_convert_sub_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Filename_convert_sub_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Filename_convert_sub_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Filename_convert_sub_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFilename_convert_sub_clause(s) + } +} + +func (s *Filename_convert_sub_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFilename_convert_sub_clause(s) + } +} + +func (s *Filename_convert_sub_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFilename_convert_sub_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Filename_convert_sub_clause() (localctx IFilename_convert_sub_clauseContext) { + localctx = NewFilename_convert_sub_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1508, PlSqlParserRULE_filename_convert_sub_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13883) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13886) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1786, p.GetParserRuleContext()) == 1 { + { + p.SetState(13884) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13885) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITablespace_datafile_clausesContext is an interface to support dynamic dispatch. +type ITablespace_datafile_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DATAFILES() antlr.TerminalNode + AllSIZE() []antlr.TerminalNode + SIZE(i int) antlr.TerminalNode + AllSize_clause() []ISize_clauseContext + Size_clause(i int) ISize_clauseContext + AllAutoextend_clause() []IAutoextend_clauseContext + Autoextend_clause(i int) IAutoextend_clauseContext + + // IsTablespace_datafile_clausesContext differentiates from other interfaces. + IsTablespace_datafile_clausesContext() +} + +type Tablespace_datafile_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespace_datafile_clausesContext() *Tablespace_datafile_clausesContext { + var p = new(Tablespace_datafile_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses + return p +} + +func InitEmptyTablespace_datafile_clausesContext(p *Tablespace_datafile_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses +} + +func (*Tablespace_datafile_clausesContext) IsTablespace_datafile_clausesContext() {} + +func NewTablespace_datafile_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tablespace_datafile_clausesContext { + var p = new(Tablespace_datafile_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace_datafile_clauses + + return p +} + +func (s *Tablespace_datafile_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tablespace_datafile_clausesContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Tablespace_datafile_clausesContext) AllSIZE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSIZE) +} + +func (s *Tablespace_datafile_clausesContext) SIZE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, i) +} + +func (s *Tablespace_datafile_clausesContext) AllSize_clause() []ISize_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISize_clauseContext); ok { + len++ + } + } + + tst := make([]ISize_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISize_clauseContext); ok { + tst[i] = t.(ISize_clauseContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_datafile_clausesContext) Size_clause(i int) ISize_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Tablespace_datafile_clausesContext) AllAutoextend_clause() []IAutoextend_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + len++ + } + } + + tst := make([]IAutoextend_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAutoextend_clauseContext); ok { + tst[i] = t.(IAutoextend_clauseContext) + i++ + } + } + + return tst +} + +func (s *Tablespace_datafile_clausesContext) Autoextend_clause(i int) IAutoextend_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Tablespace_datafile_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tablespace_datafile_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tablespace_datafile_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace_datafile_clauses(s) + } +} + +func (s *Tablespace_datafile_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace_datafile_clauses(s) + } +} + +func (s *Tablespace_datafile_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace_datafile_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace_datafile_clauses() (localctx ITablespace_datafile_clausesContext) { + localctx = NewTablespace_datafile_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1510, PlSqlParserRULE_tablespace_datafile_clauses) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13888) + p.Match(PlSqlParserDATAFILES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(13892) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSIZE: + { + p.SetState(13889) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13890) + p.Size_clause() + } + + case PlSqlParserAUTOEXTEND: + { + p.SetState(13891) + p.Autoextend_clause() + } + + 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 + } + + p.SetState(13894) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1788, 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 +} + +// IUndo_mode_clauseContext is an interface to support dynamic dispatch. +type IUndo_mode_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCAL() antlr.TerminalNode + UNDO() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + + // IsUndo_mode_clauseContext differentiates from other interfaces. + IsUndo_mode_clauseContext() +} + +type Undo_mode_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndo_mode_clauseContext() *Undo_mode_clauseContext { + var p = new(Undo_mode_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_mode_clause + return p +} + +func InitEmptyUndo_mode_clauseContext(p *Undo_mode_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_mode_clause +} + +func (*Undo_mode_clauseContext) IsUndo_mode_clauseContext() {} + +func NewUndo_mode_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_mode_clauseContext { + var p = new(Undo_mode_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_mode_clause + + return p +} + +func (s *Undo_mode_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_mode_clauseContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Undo_mode_clauseContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_mode_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Undo_mode_clauseContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Undo_mode_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_mode_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_mode_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_mode_clause(s) + } +} + +func (s *Undo_mode_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_mode_clause(s) + } +} + +func (s *Undo_mode_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUndo_mode_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Undo_mode_clause() (localctx IUndo_mode_clauseContext) { + localctx = NewUndo_mode_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1512, PlSqlParserRULE_undo_mode_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13896) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13897) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13898) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOFF || _la == PlSqlParserON) { + 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 +} + +// IDefault_tablespaceContext is an interface to support dynamic dispatch. +type IDefault_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + DATAFILE() antlr.TerminalNode + Datafile_tempfile_spec() IDatafile_tempfile_specContext + Extent_management_clause() IExtent_management_clauseContext + + // IsDefault_tablespaceContext differentiates from other interfaces. + IsDefault_tablespaceContext() +} + +type Default_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_tablespaceContext() *Default_tablespaceContext { + var p = new(Default_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace + return p +} + +func InitEmptyDefault_tablespaceContext(p *Default_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_tablespace +} + +func (*Default_tablespaceContext) IsDefault_tablespaceContext() {} + +func NewDefault_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_tablespaceContext { + var p = new(Default_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_tablespace + + return p +} + +func (s *Default_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_tablespaceContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Default_tablespaceContext) Datafile_tempfile_spec() IDatafile_tempfile_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_specContext) +} + +func (s *Default_tablespaceContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Default_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_tablespace(s) + } +} + +func (s *Default_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_tablespace(s) + } +} + +func (s *Default_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_tablespace() (localctx IDefault_tablespaceContext) { + localctx = NewDefault_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1514, PlSqlParserRULE_default_tablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13900) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13901) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13902) + p.Tablespace() + } + p.SetState(13905) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1789, p.GetParserRuleContext()) == 1 { + { + p.SetState(13903) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13904) + p.Datafile_tempfile_spec() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13908) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1790, p.GetParserRuleContext()) == 1 { + { + p.SetState(13907) + p.Extent_management_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 +} + +// IDefault_temp_tablespaceContext is an interface to support dynamic dispatch. +type IDefault_temp_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Tablespace() ITablespaceContext + TEMPORARY() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + FOR() antlr.TerminalNode + ALL() antlr.TerminalNode + LEAF() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + Extent_management_clause() IExtent_management_clauseContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsDefault_temp_tablespaceContext differentiates from other interfaces. + IsDefault_temp_tablespaceContext() +} + +type Default_temp_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_temp_tablespaceContext() *Default_temp_tablespaceContext { + var p = new(Default_temp_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace + return p +} + +func InitEmptyDefault_temp_tablespaceContext(p *Default_temp_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace +} + +func (*Default_temp_tablespaceContext) IsDefault_temp_tablespaceContext() {} + +func NewDefault_temp_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_temp_tablespaceContext { + var p = new(Default_temp_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_temp_tablespace + + return p +} + +func (s *Default_temp_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_temp_tablespaceContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_temp_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Default_temp_tablespaceContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Default_temp_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Default_temp_tablespaceContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Default_temp_tablespaceContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Default_temp_tablespaceContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Default_temp_tablespaceContext) LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAF, 0) +} + +func (s *Default_temp_tablespaceContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Default_temp_tablespaceContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Default_temp_tablespaceContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Default_temp_tablespaceContext) Extent_management_clause() IExtent_management_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExtent_management_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExtent_management_clauseContext) +} + +func (s *Default_temp_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Default_temp_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Default_temp_tablespaceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Default_temp_tablespaceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Default_temp_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_temp_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_temp_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_temp_tablespace(s) + } +} + +func (s *Default_temp_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_temp_tablespace(s) + } +} + +func (s *Default_temp_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_temp_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_temp_tablespace() (localctx IDefault_temp_tablespaceContext) { + localctx = NewDefault_temp_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1516, PlSqlParserRULE_default_temp_tablespace) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(13910) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13913) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTEMPORARY: + { + p.SetState(13914) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13915) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLOCAL: + { + p.SetState(13916) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13917) + p.Match(PlSqlParserTEMPORARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13918) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13919) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13920) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserLEAF) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(13923) + p.Tablespace() + } + p.SetState(13933) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1794, p.GetParserRuleContext()) == 1 { + { + p.SetState(13924) + p.Match(PlSqlParserTEMPFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13925) + p.File_specification() + } + p.SetState(13930) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1793, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13926) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13927) + p.File_specification() + } + + } + p.SetState(13932) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1793, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13936) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1795, p.GetParserRuleContext()) == 1 { + { + p.SetState(13935) + p.Extent_management_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 +} + +// IUndo_tablespaceContext is an interface to support dynamic dispatch. +type IUndo_tablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNDO() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + DATAFILE() antlr.TerminalNode + AllFile_specification() []IFile_specificationContext + File_specification(i int) IFile_specificationContext + BIGFILE() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUndo_tablespaceContext differentiates from other interfaces. + IsUndo_tablespaceContext() +} + +type Undo_tablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUndo_tablespaceContext() *Undo_tablespaceContext { + var p = new(Undo_tablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace + return p +} + +func InitEmptyUndo_tablespaceContext(p *Undo_tablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_undo_tablespace +} + +func (*Undo_tablespaceContext) IsUndo_tablespaceContext() {} + +func NewUndo_tablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Undo_tablespaceContext { + var p = new(Undo_tablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_undo_tablespace + + return p +} + +func (s *Undo_tablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *Undo_tablespaceContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Undo_tablespaceContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Undo_tablespaceContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Undo_tablespaceContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Undo_tablespaceContext) AllFile_specification() []IFile_specificationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFile_specificationContext); ok { + len++ + } + } + + tst := make([]IFile_specificationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFile_specificationContext); ok { + tst[i] = t.(IFile_specificationContext) + i++ + } + } + + return tst +} + +func (s *Undo_tablespaceContext) File_specification(i int) IFile_specificationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFile_specificationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFile_specificationContext) +} + +func (s *Undo_tablespaceContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Undo_tablespaceContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Undo_tablespaceContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Undo_tablespaceContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Undo_tablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Undo_tablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Undo_tablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUndo_tablespace(s) + } +} + +func (s *Undo_tablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUndo_tablespace(s) + } +} + +func (s *Undo_tablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUndo_tablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Undo_tablespace() (localctx IUndo_tablespaceContext) { + localctx = NewUndo_tablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1518, PlSqlParserRULE_undo_tablespace) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(13939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE { + { + p.SetState(13938) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBIGFILE || _la == PlSqlParserSMALLFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(13941) + p.Match(PlSqlParserUNDO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13942) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13943) + p.Tablespace() + } + p.SetState(13953) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1798, p.GetParserRuleContext()) == 1 { + { + p.SetState(13944) + p.Match(PlSqlParserDATAFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13945) + p.File_specification() + } + p.SetState(13950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1797, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13946) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13947) + p.File_specification() + } + + } + p.SetState(13952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1797, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_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 + INCLUDING() antlr.TerminalNode + BACKUPS() antlr.TerminalNode + NOPROMPT() antlr.TerminalNode + + // 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 = PlSqlParserRULE_drop_database + return p +} + +func InitEmptyDrop_databaseContext(p *Drop_databaseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_drop_database + + return p +} + +func (s *Drop_databaseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_databaseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_databaseContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_databaseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Drop_databaseContext) BACKUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUPS, 0) +} + +func (s *Drop_databaseContext) NOPROMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPROMPT, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDrop_database(s) + } +} + +func (s *Drop_databaseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_database(s) + } +} + +func (s *Drop_databaseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_database(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_database() (localctx IDrop_databaseContext) { + localctx = NewDrop_databaseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1520, PlSqlParserRULE_drop_database) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13955) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13956) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13959) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1799, p.GetParserRuleContext()) == 1 { + { + p.SetState(13957) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13958) + p.Match(PlSqlParserBACKUPS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(13962) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1800, p.GetParserRuleContext()) == 1 { + { + p.SetState(13961) + p.Match(PlSqlParserNOPROMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICreate_database_linkContext is an interface to support dynamic dispatch. +type ICreate_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CREATE() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Dblink() IDblinkContext + SHARED() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + AllCONNECT() []antlr.TerminalNode + CONNECT(i int) antlr.TerminalNode + AllTO() []antlr.TerminalNode + TO(i int) antlr.TerminalNode + AllLink_authentication() []ILink_authenticationContext + Link_authentication(i int) ILink_authenticationContext + USING() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + AllCURRENT_USER() []antlr.TerminalNode + CURRENT_USER(i int) antlr.TerminalNode + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + AllIDENTIFIED() []antlr.TerminalNode + IDENTIFIED(i int) antlr.TerminalNode + AllBY() []antlr.TerminalNode + BY(i int) antlr.TerminalNode + AllPassword_value() []IPassword_valueContext + Password_value(i int) IPassword_valueContext + + // IsCreate_database_linkContext differentiates from other interfaces. + IsCreate_database_linkContext() +} + +type Create_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCreate_database_linkContext() *Create_database_linkContext { + var p = new(Create_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database_link + return p +} + +func InitEmptyCreate_database_linkContext(p *Create_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_create_database_link +} + +func (*Create_database_linkContext) IsCreate_database_linkContext() {} + +func NewCreate_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Create_database_linkContext { + var p = new(Create_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_create_database_link + + return p +} + +func (s *Create_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Create_database_linkContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Create_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Create_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Create_database_linkContext) Dblink() IDblinkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDblinkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDblinkContext) +} + +func (s *Create_database_linkContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Create_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Create_database_linkContext) AllCONNECT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONNECT) +} + +func (s *Create_database_linkContext) CONNECT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, i) +} + +func (s *Create_database_linkContext) AllTO() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTO) +} + +func (s *Create_database_linkContext) TO(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, i) +} + +func (s *Create_database_linkContext) AllLink_authentication() []ILink_authenticationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILink_authenticationContext); ok { + len++ + } + } + + tst := make([]ILink_authenticationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILink_authenticationContext); ok { + tst[i] = t.(ILink_authenticationContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) Link_authentication(i int) ILink_authenticationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_authenticationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILink_authenticationContext) +} + +func (s *Create_database_linkContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Create_database_linkContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Create_database_linkContext) AllCURRENT_USER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT_USER) +} + +func (s *Create_database_linkContext) CURRENT_USER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, i) +} + +func (s *Create_database_linkContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Create_database_linkContext) AllIDENTIFIED() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIDENTIFIED) +} + +func (s *Create_database_linkContext) IDENTIFIED(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, i) +} + +func (s *Create_database_linkContext) AllBY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBY) +} + +func (s *Create_database_linkContext) BY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, i) +} + +func (s *Create_database_linkContext) AllPassword_value() []IPassword_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPassword_valueContext); ok { + len++ + } + } + + tst := make([]IPassword_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPassword_valueContext); ok { + tst[i] = t.(IPassword_valueContext) + i++ + } + } + + return tst +} + +func (s *Create_database_linkContext) Password_value(i int) IPassword_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPassword_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPassword_valueContext) +} + +func (s *Create_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Create_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Create_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCreate_database_link(s) + } +} + +func (s *Create_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCreate_database_link(s) + } +} + +func (s *Create_database_linkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCreate_database_link(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Create_database_link() (localctx ICreate_database_linkContext) { + localctx = NewCreate_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1522, PlSqlParserRULE_create_database_link) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13964) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSHARED { + { + p.SetState(13965) + p.Match(PlSqlParserSHARED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(13969) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(13968) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(13971) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13972) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13973) + p.Dblink() + } + p.SetState(13989) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(13987) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + { + p.SetState(13974) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13975) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(13984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1804, p.GetParserRuleContext()) { + case 1: + { + p.SetState(13976) + p.Match(PlSqlParserCURRENT_USER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(13977) + p.User_object_name() + } + { + p.SetState(13978) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13979) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13980) + p.Password_value() + } + p.SetState(13982) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1803, p.GetParserRuleContext()) == 1 { + { + p.SetState(13981) + p.Link_authentication() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case PlSqlParserAUTHENTICATED: + { + p.SetState(13986) + p.Link_authentication() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(13991) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1806, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(13994) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1807, p.GetParserRuleContext()) == 1 { + { + p.SetState(13992) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13993) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDblinkContext is an interface to support dynamic dispatch. +type IDblinkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetD returns the d rule contexts. + GetD() IId_expressionContext + + // GetCq returns the cq rule contexts. + GetCq() IId_expressionContext + + // SetD sets the d rule contexts. + SetD(IId_expressionContext) + + // SetCq sets the cq rule contexts. + SetCq(IId_expressionContext) + + // Getter signatures + Database_name() IDatabase_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AT_SIGN() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsDblinkContext differentiates from other interfaces. + IsDblinkContext() +} + +type DblinkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + d IId_expressionContext + cq IId_expressionContext +} + +func NewEmptyDblinkContext() *DblinkContext { + var p = new(DblinkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dblink + return p +} + +func InitEmptyDblinkContext(p *DblinkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dblink +} + +func (*DblinkContext) IsDblinkContext() {} + +func NewDblinkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DblinkContext { + var p = new(DblinkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dblink + + return p +} + +func (s *DblinkContext) GetParser() antlr.Parser { return s.parser } + +func (s *DblinkContext) GetD() IId_expressionContext { return s.d } + +func (s *DblinkContext) GetCq() IId_expressionContext { return s.cq } + +func (s *DblinkContext) SetD(v IId_expressionContext) { s.d = v } + +func (s *DblinkContext) SetCq(v IId_expressionContext) { s.cq = v } + +func (s *DblinkContext) Database_name() IDatabase_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatabase_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatabase_nameContext) +} + +func (s *DblinkContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *DblinkContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *DblinkContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *DblinkContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *DblinkContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *DblinkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DblinkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DblinkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDblink(s) + } +} + +func (s *DblinkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDblink(s) + } +} + +func (s *DblinkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDblink(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dblink() (localctx IDblinkContext) { + localctx = NewDblinkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1524, PlSqlParserRULE_dblink) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(13996) + p.Database_name() + } + p.SetState(14001) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1808, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(13997) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(13998) + + var _x = p.Id_expression() + + localctx.(*DblinkContext).d = _x + } + + } + p.SetState(14003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1808, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14006) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1809, p.GetParserRuleContext()) == 1 { + { + p.SetState(14004) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14005) + + var _x = p.Id_expression() + + localctx.(*DblinkContext).cq = _x + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_database_linkContext is an interface to support dynamic dispatch. +type IDrop_database_linkContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + Dblink() IDblinkContext + PUBLIC() antlr.TerminalNode + + // IsDrop_database_linkContext differentiates from other interfaces. + IsDrop_database_linkContext() +} + +type Drop_database_linkContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_database_linkContext() *Drop_database_linkContext { + var p = new(Drop_database_linkContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database_link + return p +} + +func InitEmptyDrop_database_linkContext(p *Drop_database_linkContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_database_link +} + +func (*Drop_database_linkContext) IsDrop_database_linkContext() {} + +func NewDrop_database_linkContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_database_linkContext { + var p = new(Drop_database_linkContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_database_link + + return p +} + +func (s *Drop_database_linkContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_database_linkContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_database_linkContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Drop_database_linkContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Drop_database_linkContext) Dblink() IDblinkContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDblinkContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDblinkContext) +} + +func (s *Drop_database_linkContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Drop_database_linkContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_database_linkContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_database_linkContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_database_link(s) + } +} + +func (s *Drop_database_linkContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_database_link(s) + } +} + +func (s *Drop_database_linkContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_database_link(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_database_link() (localctx IDrop_database_linkContext) { + localctx = NewDrop_database_linkContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1526, PlSqlParserRULE_drop_database_link) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14008) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14010) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(14009) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14012) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14013) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14014) + p.Dblink() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_tablespace_setContext is an interface to support dynamic dispatch. +type IAlter_tablespace_setContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTss returns the tss rule contexts. + GetTss() IId_expressionContext + + // SetTss sets the tss rule contexts. + SetTss(IId_expressionContext) + + // Getter signatures + ALTER() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + SET() antlr.TerminalNode + Alter_tablespace_attrs() IAlter_tablespace_attrsContext + Id_expression() IId_expressionContext + + // IsAlter_tablespace_setContext differentiates from other interfaces. + IsAlter_tablespace_setContext() +} + +type Alter_tablespace_setContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tss IId_expressionContext +} + +func NewEmptyAlter_tablespace_setContext() *Alter_tablespace_setContext { + var p = new(Alter_tablespace_setContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set + return p +} + +func InitEmptyAlter_tablespace_setContext(p *Alter_tablespace_setContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set +} + +func (*Alter_tablespace_setContext) IsAlter_tablespace_setContext() {} + +func NewAlter_tablespace_setContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_setContext { + var p = new(Alter_tablespace_setContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_set + + return p +} + +func (s *Alter_tablespace_setContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_setContext) GetTss() IId_expressionContext { return s.tss } + +func (s *Alter_tablespace_setContext) SetTss(v IId_expressionContext) { s.tss = v } + +func (s *Alter_tablespace_setContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tablespace_setContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Alter_tablespace_setContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_tablespace_setContext) Alter_tablespace_attrs() IAlter_tablespace_attrsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_attrsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_attrsContext) +} + +func (s *Alter_tablespace_setContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_tablespace_setContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_setContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_setContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_set(s) + } +} + +func (s *Alter_tablespace_setContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_set(s) + } +} + +func (s *Alter_tablespace_setContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_tablespace_set(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_set() (localctx IAlter_tablespace_setContext) { + localctx = NewAlter_tablespace_setContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1528, PlSqlParserRULE_alter_tablespace_set) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14016) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14017) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14018) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14019) + + var _x = p.Id_expression() + + localctx.(*Alter_tablespace_setContext).tss = _x + } + { + p.SetState(14020) + p.Alter_tablespace_attrs() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_tablespace_attrsContext is an interface to support dynamic dispatch. +type IAlter_tablespace_attrsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetNts returns the nts rule contexts. + GetNts() IId_expressionContext + + // SetNts sets the nts rule contexts. + SetNts(IId_expressionContext) + + // Getter signatures + Default_tablespace_params() IDefault_tablespace_paramsContext + MINIMUM() antlr.TerminalNode + EXTENT() antlr.TerminalNode + Size_clause() ISize_clauseContext + RESIZE() antlr.TerminalNode + COALESCE() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + KEEP() antlr.TerminalNode + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Id_expression() IId_expressionContext + BACKUP() antlr.TerminalNode + BEGIN() antlr.TerminalNode + END() antlr.TerminalNode + Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext + Tablespace_logging_clauses() ITablespace_logging_clausesContext + Tablespace_group_clause() ITablespace_group_clauseContext + Tablespace_state_clauses() ITablespace_state_clausesContext + Autoextend_clause() IAutoextend_clauseContext + Flashback_mode_clause() IFlashback_mode_clauseContext + Tablespace_retention_clause() ITablespace_retention_clauseContext + Alter_tablespace_encryption() IAlter_tablespace_encryptionContext + Lost_write_protection() ILost_write_protectionContext + + // IsAlter_tablespace_attrsContext differentiates from other interfaces. + IsAlter_tablespace_attrsContext() +} + +type Alter_tablespace_attrsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + nts IId_expressionContext +} + +func NewEmptyAlter_tablespace_attrsContext() *Alter_tablespace_attrsContext { + var p = new(Alter_tablespace_attrsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs + return p +} + +func InitEmptyAlter_tablespace_attrsContext(p *Alter_tablespace_attrsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs +} + +func (*Alter_tablespace_attrsContext) IsAlter_tablespace_attrsContext() {} + +func NewAlter_tablespace_attrsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_attrsContext { + var p = new(Alter_tablespace_attrsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_attrs + + return p +} + +func (s *Alter_tablespace_attrsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_attrsContext) GetNts() IId_expressionContext { return s.nts } + +func (s *Alter_tablespace_attrsContext) SetNts(v IId_expressionContext) { s.nts = v } + +func (s *Alter_tablespace_attrsContext) Default_tablespace_params() IDefault_tablespace_paramsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_tablespace_paramsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_tablespace_paramsContext) +} + +func (s *Alter_tablespace_attrsContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Alter_tablespace_attrsContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Alter_tablespace_attrsContext) Size_clause() ISize_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISize_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISize_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Alter_tablespace_attrsContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_tablespace_attrsContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Alter_tablespace_attrsContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Alter_tablespace_attrsContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Alter_tablespace_attrsContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_tablespace_attrsContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_tablespace_attrsContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Alter_tablespace_attrsContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Alter_tablespace_attrsContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Alter_tablespace_attrsContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Alter_tablespace_attrsContext) Datafile_tempfile_clauses() IDatafile_tempfile_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatafile_tempfile_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatafile_tempfile_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_logging_clauses() ITablespace_logging_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_logging_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_logging_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_group_clause() ITablespace_group_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_group_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_group_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_state_clauses() ITablespace_state_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_state_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_state_clausesContext) +} + +func (s *Alter_tablespace_attrsContext) Autoextend_clause() IAutoextend_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutoextend_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutoextend_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Flashback_mode_clause() IFlashback_mode_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_mode_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_mode_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Tablespace_retention_clause() ITablespace_retention_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_retention_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_retention_clauseContext) +} + +func (s *Alter_tablespace_attrsContext) Alter_tablespace_encryption() IAlter_tablespace_encryptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_tablespace_encryptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_tablespace_encryptionContext) +} + +func (s *Alter_tablespace_attrsContext) Lost_write_protection() ILost_write_protectionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILost_write_protectionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILost_write_protectionContext) +} + +func (s *Alter_tablespace_attrsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_attrsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_attrsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_attrs(s) + } +} + +func (s *Alter_tablespace_attrsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_attrs(s) + } +} + +func (s *Alter_tablespace_attrsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_tablespace_attrs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_attrs() (localctx IAlter_tablespace_attrsContext) { + localctx = NewAlter_tablespace_attrsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1530, PlSqlParserRULE_alter_tablespace_attrs) + var _la int + + p.SetState(14049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1812, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14022) + p.Default_tablespace_params() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14023) + p.Match(PlSqlParserMINIMUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14024) + p.Match(PlSqlParserEXTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14025) + p.Size_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14026) + p.Match(PlSqlParserRESIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14027) + p.Size_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14028) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14029) + p.Match(PlSqlParserSHRINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14030) + p.Match(PlSqlParserSPACE_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14033) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1811, p.GetParserRuleContext()) == 1 { + { + p.SetState(14031) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14032) + p.Size_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14035) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14036) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14037) + + var _x = p.Id_expression() + + localctx.(*Alter_tablespace_attrsContext).nts = _x + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14038) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBEGIN || _la == PlSqlParserEND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14039) + p.Match(PlSqlParserBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14040) + p.Datafile_tempfile_clauses() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14041) + p.Tablespace_logging_clauses() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(14042) + p.Tablespace_group_clause() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(14043) + p.Tablespace_state_clauses() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(14044) + p.Autoextend_clause() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(14045) + p.Flashback_mode_clause() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(14046) + p.Tablespace_retention_clause() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(14047) + p.Alter_tablespace_encryption() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(14048) + p.Lost_write_protection() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_tablespace_encryptionContext is an interface to support dynamic dispatch. +type IAlter_tablespace_encryptionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCRYPTION() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + FINISH() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + REKEY() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + Ts_file_name_convert() ITs_file_name_convertContext + Tablespace_encryption_spec() ITablespace_encryption_specContext + + // IsAlter_tablespace_encryptionContext differentiates from other interfaces. + IsAlter_tablespace_encryptionContext() +} + +type Alter_tablespace_encryptionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_tablespace_encryptionContext() *Alter_tablespace_encryptionContext { + var p = new(Alter_tablespace_encryptionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption + return p +} + +func InitEmptyAlter_tablespace_encryptionContext(p *Alter_tablespace_encryptionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption +} + +func (*Alter_tablespace_encryptionContext) IsAlter_tablespace_encryptionContext() {} + +func NewAlter_tablespace_encryptionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_tablespace_encryptionContext { + var p = new(Alter_tablespace_encryptionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_tablespace_encryption + + return p +} + +func (s *Alter_tablespace_encryptionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tablespace_encryptionContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Alter_tablespace_encryptionContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Alter_tablespace_encryptionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Alter_tablespace_encryptionContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Alter_tablespace_encryptionContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Alter_tablespace_encryptionContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Alter_tablespace_encryptionContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Alter_tablespace_encryptionContext) Ts_file_name_convert() ITs_file_name_convertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITs_file_name_convertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITs_file_name_convertContext) +} + +func (s *Alter_tablespace_encryptionContext) Tablespace_encryption_spec() ITablespace_encryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespace_encryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespace_encryption_specContext) +} + +func (s *Alter_tablespace_encryptionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_tablespace_encryptionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_tablespace_encryptionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_tablespace_encryption(s) + } +} + +func (s *Alter_tablespace_encryptionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_tablespace_encryption(s) + } +} + +func (s *Alter_tablespace_encryptionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_tablespace_encryption(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_tablespace_encryption() (localctx IAlter_tablespace_encryptionContext) { + localctx = NewAlter_tablespace_encryptionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1532, PlSqlParserRULE_alter_tablespace_encryption) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14051) + p.Match(PlSqlParserENCRYPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserOFFLINE: + { + p.SetState(14052) + p.Match(PlSqlParserOFFLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14058) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserUSING: + p.SetState(14054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14053) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(14056) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(14057) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserONLINE: + { + p.SetState(14060) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14066) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT, PlSqlParserREKEY, PlSqlParserUSING: + p.SetState(14062) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14061) + p.Tablespace_encryption_spec() + } + + } + { + p.SetState(14064) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENCRYPT || _la == PlSqlParserREKEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserDECRYPT: + { + p.SetState(14065) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14069) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1817, p.GetParserRuleContext()) == 1 { + { + p.SetState(14068) + p.Ts_file_name_convert() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserFINISH: + { + p.SetState(14071) + p.Match(PlSqlParserFINISH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14072) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECRYPT || _la == PlSqlParserENCRYPT || _la == PlSqlParserREKEY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14074) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1818, p.GetParserRuleContext()) == 1 { + { + p.SetState(14073) + p.Ts_file_name_convert() + } + + } 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 +} + +// ITs_file_name_convertContext is an interface to support dynamic dispatch. +type ITs_file_name_convertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FILE_NAME_CONVERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + KEEP() antlr.TerminalNode + + // IsTs_file_name_convertContext differentiates from other interfaces. + IsTs_file_name_convertContext() +} + +type Ts_file_name_convertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTs_file_name_convertContext() *Ts_file_name_convertContext { + var p = new(Ts_file_name_convertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert + return p +} + +func InitEmptyTs_file_name_convertContext(p *Ts_file_name_convertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert +} + +func (*Ts_file_name_convertContext) IsTs_file_name_convertContext() {} + +func NewTs_file_name_convertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ts_file_name_convertContext { + var p = new(Ts_file_name_convertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ts_file_name_convert + + return p +} + +func (s *Ts_file_name_convertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ts_file_name_convertContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *Ts_file_name_convertContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Ts_file_name_convertContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Ts_file_name_convertContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Ts_file_name_convertContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Ts_file_name_convertContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Ts_file_name_convertContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Ts_file_name_convertContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Ts_file_name_convertContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Ts_file_name_convertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ts_file_name_convertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ts_file_name_convertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTs_file_name_convert(s) + } +} + +func (s *Ts_file_name_convertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTs_file_name_convert(s) + } +} + +func (s *Ts_file_name_convertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTs_file_name_convert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ts_file_name_convert() (localctx ITs_file_name_convertContext) { + localctx = NewTs_file_name_convertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1534, PlSqlParserRULE_ts_file_name_convert) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14078) + p.Match(PlSqlParserFILE_NAME_CONVERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14079) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14080) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14081) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14082) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14083) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14084) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14085) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14086) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14087) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(14092) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14093) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14095) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1821, p.GetParserRuleContext()) == 1 { + { + p.SetState(14094) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Role_name() IRole_nameContext + Role_identified_clause() IRole_identified_clauseContext + Container_clause() IContainer_clauseContext + + // 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 = PlSqlParserRULE_alter_role + return p +} + +func InitEmptyAlter_roleContext(p *Alter_roleContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_role + + return p +} + +func (s *Alter_roleContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_roleContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_roleContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Alter_roleContext) Role_name() IRole_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_nameContext) +} + +func (s *Alter_roleContext) Role_identified_clause() IRole_identified_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRole_identified_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRole_identified_clauseContext) +} + +func (s *Alter_roleContext) Container_clause() IContainer_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContainer_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContainer_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_role(s) + } +} + +func (s *Alter_roleContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_role(s) + } +} + +func (s *Alter_roleContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_role(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_role() (localctx IAlter_roleContext) { + localctx = NewAlter_roleContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1536, PlSqlParserRULE_alter_role) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14097) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14098) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14099) + p.Role_name() + } + { + p.SetState(14100) + p.Role_identified_clause() + } + p.SetState(14102) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1822, p.GetParserRuleContext()) == 1 { + { + p.SetState(14101) + p.Container_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 +} + +// IRole_identified_clauseContext is an interface to support dynamic dispatch. +type IRole_identified_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOT() antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + Identifier() IIdentifierContext + USING() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + AS() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsRole_identified_clauseContext differentiates from other interfaces. + IsRole_identified_clauseContext() +} + +type Role_identified_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRole_identified_clauseContext() *Role_identified_clauseContext { + var p = new(Role_identified_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_identified_clause + return p +} + +func InitEmptyRole_identified_clauseContext(p *Role_identified_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_role_identified_clause +} + +func (*Role_identified_clauseContext) IsRole_identified_clauseContext() {} + +func NewRole_identified_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Role_identified_clauseContext { + var p = new(Role_identified_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_role_identified_clause + + return p +} + +func (s *Role_identified_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_identified_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Role_identified_clauseContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Role_identified_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Role_identified_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Role_identified_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Role_identified_clauseContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Role_identified_clauseContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Role_identified_clauseContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Role_identified_clauseContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Role_identified_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Role_identified_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Role_identified_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Role_identified_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Role_identified_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRole_identified_clause(s) + } +} + +func (s *Role_identified_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_identified_clause(s) + } +} + +func (s *Role_identified_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRole_identified_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Role_identified_clause() (localctx IRole_identified_clauseContext) { + localctx = NewRole_identified_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1538, PlSqlParserRULE_role_identified_clause) + p.SetState(14123) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14104) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14105) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserIDENTIFIED: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14106) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14121) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBY: + { + p.SetState(14107) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14108) + p.Identifier() + } + + case PlSqlParserUSING: + { + p.SetState(14109) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14110) + p.Identifier() + } + p.SetState(14113) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1823, p.GetParserRuleContext()) == 1 { + { + p.SetState(14111) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14112) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserEXTERNALLY: + { + p.SetState(14115) + p.Match(PlSqlParserEXTERNALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGLOBALLY: + { + p.SetState(14116) + p.Match(PlSqlParserGLOBALLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14119) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1824, p.GetParserRuleContext()) == 1 { + { + p.SetState(14117) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14118) + p.Match(PlSqlParserCHAR_STRING) + 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 + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + AllTABLE() []antlr.TerminalNode + TABLE(i int) antlr.TerminalNode + Tableview_name() ITableview_nameContext + SEMICOLON() antlr.TerminalNode + Alter_table_properties() IAlter_table_propertiesContext + Constraint_clauses() IConstraint_clausesContext + Column_clauses() IColumn_clausesContext + Alter_table_partitioning() IAlter_table_partitioningContext + Move_table_clause() IMove_table_clauseContext + AllMemoptimize_read_write_clause() []IMemoptimize_read_write_clauseContext + Memoptimize_read_write_clause(i int) IMemoptimize_read_write_clauseContext + AllEnable_disable_clause() []IEnable_disable_clauseContext + Enable_disable_clause(i int) IEnable_disable_clauseContext + AllEnable_or_disable() []IEnable_or_disableContext + Enable_or_disable(i int) IEnable_or_disableContext + AllLOCK() []antlr.TerminalNode + LOCK(i int) antlr.TerminalNode + AllALL() []antlr.TerminalNode + ALL(i int) antlr.TerminalNode + AllTRIGGERS() []antlr.TerminalNode + TRIGGERS(i int) 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 = PlSqlParserRULE_alter_table + return p +} + +func InitEmptyAlter_tableContext(p *Alter_tableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_alter_table + + return p +} + +func (s *Alter_tableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_tableContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Alter_tableContext) AllTABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLE) +} + +func (s *Alter_tableContext) TABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, i) +} + +func (s *Alter_tableContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_tableContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Alter_tableContext) Alter_table_properties() IAlter_table_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_propertiesContext) +} + +func (s *Alter_tableContext) Constraint_clauses() IConstraint_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_clausesContext) +} + +func (s *Alter_tableContext) Column_clauses() IColumn_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_clausesContext) +} + +func (s *Alter_tableContext) Alter_table_partitioning() IAlter_table_partitioningContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_partitioningContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_partitioningContext) +} + +func (s *Alter_tableContext) Move_table_clause() IMove_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMove_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMove_table_clauseContext) +} + +func (s *Alter_tableContext) AllMemoptimize_read_write_clause() []IMemoptimize_read_write_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + len++ + } + } + + tst := make([]IMemoptimize_read_write_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + tst[i] = t.(IMemoptimize_read_write_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Memoptimize_read_write_clause(i int) IMemoptimize_read_write_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMemoptimize_read_write_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMemoptimize_read_write_clauseContext) +} + +func (s *Alter_tableContext) AllEnable_disable_clause() []IEnable_disable_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + len++ + } + } + + tst := make([]IEnable_disable_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_disable_clauseContext); ok { + tst[i] = t.(IEnable_disable_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Enable_disable_clause(i int) IEnable_disable_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_disable_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_disable_clauseContext) +} + +func (s *Alter_tableContext) AllEnable_or_disable() []IEnable_or_disableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEnable_or_disableContext); ok { + len++ + } + } + + tst := make([]IEnable_or_disableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEnable_or_disableContext); ok { + tst[i] = t.(IEnable_or_disableContext) + i++ + } + } + + return tst +} + +func (s *Alter_tableContext) Enable_or_disable(i int) IEnable_or_disableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnable_or_disableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEnable_or_disableContext) +} + +func (s *Alter_tableContext) AllLOCK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOCK) +} + +func (s *Alter_tableContext) LOCK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, i) +} + +func (s *Alter_tableContext) AllALL() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserALL) +} + +func (s *Alter_tableContext) ALL(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, i) +} + +func (s *Alter_tableContext) AllTRIGGERS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTRIGGERS) +} + +func (s *Alter_tableContext) TRIGGERS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterAlter_table(s) + } +} + +func (s *Alter_tableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table(s) + } +} + +func (s *Alter_tableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_table(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_table() (localctx IAlter_tableContext) { + localctx = NewAlter_tableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1540, PlSqlParserRULE_alter_table) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14125) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14126) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14127) + p.Tableview_name() + } + p.SetState(14131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1827, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14128) + p.Memoptimize_read_write_clause() + } + + } + p.SetState(14133) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1827, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1828, p.GetParserRuleContext()) { + case 1: + + case 2: + { + p.SetState(14135) + p.Alter_table_properties() + } + + case 3: + { + p.SetState(14136) + p.Constraint_clauses() + } + + case 4: + { + p.SetState(14137) + p.Column_clauses() + } + + case 5: + { + p.SetState(14138) + p.Alter_table_partitioning() + } + + case 6: + { + p.SetState(14139) + p.Move_table_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14154) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + p.SetState(14150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserDISABLE || _la == PlSqlParserENABLE { + p.SetState(14150) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1830, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14142) + p.Enable_disable_clause() + } + + case 2: + { + p.SetState(14143) + p.Enable_or_disable() + } + p.SetState(14148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(14144) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14145) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALL: + { + p.SetState(14146) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14147) + p.Match(PlSqlParserTRIGGERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(14156) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IMemoptimize_read_write_clauseContext is an interface to support dynamic dispatch. +type IMemoptimize_read_write_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MEMOPTIMIZE() antlr.TerminalNode + FOR() antlr.TerminalNode + READ() antlr.TerminalNode + WRITE() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsMemoptimize_read_write_clauseContext differentiates from other interfaces. + IsMemoptimize_read_write_clauseContext() +} + +type Memoptimize_read_write_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMemoptimize_read_write_clauseContext() *Memoptimize_read_write_clauseContext { + var p = new(Memoptimize_read_write_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause + return p +} + +func InitEmptyMemoptimize_read_write_clauseContext(p *Memoptimize_read_write_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause +} + +func (*Memoptimize_read_write_clauseContext) IsMemoptimize_read_write_clauseContext() {} + +func NewMemoptimize_read_write_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Memoptimize_read_write_clauseContext { + var p = new(Memoptimize_read_write_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_memoptimize_read_write_clause + + return p +} + +func (s *Memoptimize_read_write_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Memoptimize_read_write_clauseContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Memoptimize_read_write_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Memoptimize_read_write_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Memoptimize_read_write_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Memoptimize_read_write_clauseContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Memoptimize_read_write_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Memoptimize_read_write_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Memoptimize_read_write_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMemoptimize_read_write_clause(s) + } +} + +func (s *Memoptimize_read_write_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMemoptimize_read_write_clause(s) + } +} + +func (s *Memoptimize_read_write_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMemoptimize_read_write_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Memoptimize_read_write_clause() (localctx IMemoptimize_read_write_clauseContext) { + localctx = NewMemoptimize_read_write_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1542, PlSqlParserRULE_memoptimize_read_write_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(14158) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14161) + p.Match(PlSqlParserMEMOPTIMIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14162) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14163) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserREAD || _la == PlSqlParserWRITE) { + 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_table_propertiesContext is an interface to support dynamic dispatch. +type IAlter_table_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Alter_table_properties_1() IAlter_table_properties_1Context + RENAME() antlr.TerminalNode + TO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Shrink_clause() IShrink_clauseContext + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + REKEY() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsAlter_table_propertiesContext differentiates from other interfaces. + IsAlter_table_propertiesContext() +} + +type Alter_table_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_propertiesContext() *Alter_table_propertiesContext { + var p = new(Alter_table_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties + return p +} + +func InitEmptyAlter_table_propertiesContext(p *Alter_table_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties +} + +func (*Alter_table_propertiesContext) IsAlter_table_propertiesContext() {} + +func NewAlter_table_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_propertiesContext { + var p = new(Alter_table_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_properties + + return p +} + +func (s *Alter_table_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_propertiesContext) Alter_table_properties_1() IAlter_table_properties_1Context { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_table_properties_1Context); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_table_properties_1Context) +} + +func (s *Alter_table_propertiesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Alter_table_propertiesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Alter_table_propertiesContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Alter_table_propertiesContext) Shrink_clause() IShrink_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_table_propertiesContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Alter_table_propertiesContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Alter_table_propertiesContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Alter_table_propertiesContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Alter_table_propertiesContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Alter_table_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_properties(s) + } +} + +func (s *Alter_table_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_properties(s) + } +} + +func (s *Alter_table_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_table_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_table_properties() (localctx IAlter_table_propertiesContext) { + localctx = NewAlter_table_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1544, PlSqlParserRULE_alter_table_properties) + p.SetState(14176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1834, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14165) + p.Alter_table_properties_1() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14166) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14167) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14168) + p.Tableview_name() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14169) + p.Shrink_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14170) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14171) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14172) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14173) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14174) + p.Match(PlSqlParserREKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14175) + p.Match(PlSqlParserCHAR_STRING) + 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_table_partitioningContext is an interface to support dynamic dispatch. +type IAlter_table_partitioningContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_table_partition() IAdd_table_partitionContext + Drop_table_partition() IDrop_table_partitionContext + Merge_table_partition() IMerge_table_partitionContext + Modify_table_partition() IModify_table_partitionContext + Split_table_partition() ISplit_table_partitionContext + Truncate_table_partition() ITruncate_table_partitionContext + Exchange_table_partition() IExchange_table_partitionContext + Coalesce_table_partition() ICoalesce_table_partitionContext + Alter_interval_partition() IAlter_interval_partitionContext + + // IsAlter_table_partitioningContext differentiates from other interfaces. + IsAlter_table_partitioningContext() +} + +type Alter_table_partitioningContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_partitioningContext() *Alter_table_partitioningContext { + var p = new(Alter_table_partitioningContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning + return p +} + +func InitEmptyAlter_table_partitioningContext(p *Alter_table_partitioningContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning +} + +func (*Alter_table_partitioningContext) IsAlter_table_partitioningContext() {} + +func NewAlter_table_partitioningContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_partitioningContext { + var p = new(Alter_table_partitioningContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_partitioning + + return p +} + +func (s *Alter_table_partitioningContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_partitioningContext) Add_table_partition() IAdd_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Drop_table_partition() IDrop_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Merge_table_partition() IMerge_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Modify_table_partition() IModify_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Split_table_partition() ISplit_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISplit_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISplit_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Truncate_table_partition() ITruncate_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITruncate_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITruncate_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Exchange_table_partition() IExchange_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExchange_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExchange_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Coalesce_table_partition() ICoalesce_table_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICoalesce_table_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICoalesce_table_partitionContext) +} + +func (s *Alter_table_partitioningContext) Alter_interval_partition() IAlter_interval_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_interval_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_interval_partitionContext) +} + +func (s *Alter_table_partitioningContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_partitioningContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_partitioningContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_partitioning(s) + } +} + +func (s *Alter_table_partitioningContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_partitioning(s) + } +} + +func (s *Alter_table_partitioningContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_table_partitioning(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_table_partitioning() (localctx IAlter_table_partitioningContext) { + localctx = NewAlter_table_partitioningContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1546, PlSqlParserRULE_alter_table_partitioning) + p.SetState(14187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14178) + p.Add_table_partition() + } + + case PlSqlParserDROP: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14179) + p.Drop_table_partition() + } + + case PlSqlParserMERGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14180) + p.Merge_table_partition() + } + + case PlSqlParserMODIFY: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14181) + p.Modify_table_partition() + } + + case PlSqlParserSPLIT: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(14182) + p.Split_table_partition() + } + + case PlSqlParserTRUNCATE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(14183) + p.Truncate_table_partition() + } + + case PlSqlParserEXCHANGE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(14184) + p.Exchange_table_partition() + } + + case PlSqlParserCOALESCE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(14185) + p.Coalesce_table_partition() + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(14186) + p.Alter_interval_partition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAdd_table_partitionContext is an interface to support dynamic dispatch. +type IAdd_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + Range_partition_desc() IRange_partition_descContext + List_partition_desc() IList_partition_descContext + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + Key_compression() IKey_compressionContext + UNUSABLE() antlr.TerminalNode + + // IsAdd_table_partitionContext differentiates from other interfaces. + IsAdd_table_partitionContext() +} + +type Add_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_table_partitionContext() *Add_table_partitionContext { + var p = new(Add_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_table_partition + return p +} + +func InitEmptyAdd_table_partitionContext(p *Add_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_table_partition +} + +func (*Add_table_partitionContext) IsAdd_table_partitionContext() {} + +func NewAdd_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_table_partitionContext { + var p = new(Add_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_table_partition + + return p +} + +func (s *Add_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_table_partitionContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_table_partitionContext) Range_partition_desc() IRange_partition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Add_table_partitionContext) List_partition_desc() IList_partition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Add_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Add_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Add_table_partitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Add_table_partitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Add_table_partitionContext) Key_compression() IKey_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Add_table_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Add_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_table_partition(s) + } +} + +func (s *Add_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_table_partition(s) + } +} + +func (s *Add_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_table_partition() (localctx IAdd_table_partitionContext) { + localctx = NewAdd_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1548, PlSqlParserRULE_add_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14189) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14206) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1840, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14190) + p.Range_partition_desc() + } + + case 2: + { + p.SetState(14191) + p.List_partition_desc() + } + + case 3: + { + p.SetState(14192) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14194) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1836, p.GetParserRuleContext()) == 1 { + { + p.SetState(14193) + p.Partition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(14196) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14197) + p.Tablespace() + } + + } + p.SetState(14201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserNOCOMPRESS { + { + p.SetState(14200) + p.Key_compression() + } + + } + p.SetState(14204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(14203) + p.Match(PlSqlParserUNUSABLE) + 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 +} + +// IDrop_table_partitionContext is an interface to support dynamic dispatch. +type IDrop_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + Subpartition_extended_names() ISubpartition_extended_namesContext + Update_index_clauses() IUpdate_index_clausesContext + Parallel_clause() IParallel_clauseContext + + // IsDrop_table_partitionContext differentiates from other interfaces. + IsDrop_table_partitionContext() +} + +type Drop_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_table_partitionContext() *Drop_table_partitionContext { + var p = new(Drop_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table_partition + return p +} + +func InitEmptyDrop_table_partitionContext(p *Drop_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_table_partition +} + +func (*Drop_table_partitionContext) IsDrop_table_partitionContext() {} + +func NewDrop_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_table_partitionContext { + var p = new(Drop_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_table_partition + + return p +} + +func (s *Drop_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Drop_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Drop_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Drop_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Drop_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_table_partition(s) + } +} + +func (s *Drop_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_table_partition(s) + } +} + +func (s *Drop_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_table_partition() (localctx IDrop_table_partitionContext) { + localctx = NewDrop_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1550, PlSqlParserRULE_drop_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14208) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14209) + p.Partition_extended_names() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14210) + p.Subpartition_extended_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE { + { + p.SetState(14213) + p.Update_index_clauses() + } + p.SetState(14215) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14214) + p.Parallel_clause() + } + + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_table_partitionContext is an interface to support dynamic dispatch. +type IMerge_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MERGE() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + AND() antlr.TerminalNode + INTO() antlr.TerminalNode + + // IsMerge_table_partitionContext differentiates from other interfaces. + IsMerge_table_partitionContext() +} + +type Merge_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_table_partitionContext() *Merge_table_partitionContext { + var p = new(Merge_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_table_partition + return p +} + +func InitEmptyMerge_table_partitionContext(p *Merge_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_table_partition +} + +func (*Merge_table_partitionContext) IsMerge_table_partitionContext() {} + +func NewMerge_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_table_partitionContext { + var p = new(Merge_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_table_partition + + return p +} + +func (s *Merge_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_table_partitionContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_table_partitionContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Merge_table_partitionContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Merge_table_partitionContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Merge_table_partitionContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Merge_table_partitionContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Merge_table_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_table_partition(s) + } +} + +func (s *Merge_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_table_partition(s) + } +} + +func (s *Merge_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_table_partition() (localctx IMerge_table_partitionContext) { + localctx = NewMerge_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1552, PlSqlParserRULE_merge_table_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14219) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14220) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14221) + p.Partition_name() + } + { + p.SetState(14222) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14223) + p.Partition_name() + } + { + p.SetState(14224) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14225) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14226) + p.Partition_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 +} + +// IModify_table_partitionContext is an interface to support dynamic dispatch. +type IModify_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + Table_partitioning_clauses() ITable_partitioning_clausesContext + ONLINE() antlr.TerminalNode + Update_index_clauses() IUpdate_index_clausesContext + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + Parallel_clause() IParallel_clauseContext + List_values_clause() IList_values_clauseContext + AllADD() []antlr.TerminalNode + ADD(i int) antlr.TerminalNode + Range_subpartition_desc() IRange_subpartition_descContext + UNUSABLE() antlr.TerminalNode + LOCAL() antlr.TerminalNode + INDEXES() antlr.TerminalNode + DROP() antlr.TerminalNode + REBUILD() antlr.TerminalNode + + // IsModify_table_partitionContext differentiates from other interfaces. + IsModify_table_partitionContext() +} + +type Modify_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_table_partitionContext() *Modify_table_partitionContext { + var p = new(Modify_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_table_partition + return p +} + +func InitEmptyModify_table_partitionContext(p *Modify_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_table_partition +} + +func (*Modify_table_partitionContext) IsModify_table_partitionContext() {} + +func NewModify_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_table_partitionContext { + var p = new(Modify_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_table_partition + + return p +} + +func (s *Modify_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_table_partitionContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_table_partitionContext) Table_partitioning_clauses() ITable_partitioning_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_partitioning_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_partitioning_clausesContext) +} + +func (s *Modify_table_partitionContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Modify_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Modify_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Modify_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Modify_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Modify_table_partitionContext) List_values_clause() IList_values_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_values_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IList_values_clauseContext) +} + +func (s *Modify_table_partitionContext) AllADD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserADD) +} + +func (s *Modify_table_partitionContext) ADD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, i) +} + +func (s *Modify_table_partitionContext) Range_subpartition_desc() IRange_subpartition_descContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_subpartition_descContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRange_subpartition_descContext) +} + +func (s *Modify_table_partitionContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Modify_table_partitionContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Modify_table_partitionContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Modify_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Modify_table_partitionContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Modify_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_table_partition(s) + } +} + +func (s *Modify_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_table_partition(s) + } +} + +func (s *Modify_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_table_partition() (localctx IModify_table_partitionContext) { + localctx = NewModify_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1554, PlSqlParserRULE_modify_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14228) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1848, p.GetParserRuleContext()) { + case 1: + + case 2: + { + p.SetState(14230) + p.Table_partitioning_clauses() + } + + case 3: + { + p.SetState(14231) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14232) + p.Partition_name() + } + p.SetState(14235) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1844, p.GetParserRuleContext()) == 1 { + { + p.SetState(14233) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserADD || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14234) + p.List_values_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD { + { + p.SetState(14237) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14238) + p.Range_subpartition_desc() + } + + } + p.SetState(14247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREBUILD || _la == PlSqlParserUNUSABLE { + p.SetState(14242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserREBUILD { + { + p.SetState(14241) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14244) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14245) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14246) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14252) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLINE { + { + p.SetState(14251) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE { + { + p.SetState(14254) + p.Update_index_clauses() + } + p.SetState(14256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14255) + p.Parallel_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 +} + +// ISplit_table_partitionContext is an interface to support dynamic dispatch. +type ISplit_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SPLIT() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + INTO() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllRange_partition_desc() []IRange_partition_descContext + Range_partition_desc(i int) IRange_partition_descContext + AllList_partition_desc() []IList_partition_descContext + List_partition_desc(i int) IList_partition_descContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSplit_table_partitionContext differentiates from other interfaces. + IsSplit_table_partitionContext() +} + +type Split_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySplit_table_partitionContext() *Split_table_partitionContext { + var p = new(Split_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_table_partition + return p +} + +func InitEmptySplit_table_partitionContext(p *Split_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_split_table_partition +} + +func (*Split_table_partitionContext) IsSplit_table_partitionContext() {} + +func NewSplit_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Split_table_partitionContext { + var p = new(Split_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_split_table_partition + + return p +} + +func (s *Split_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Split_table_partitionContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Split_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Split_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Split_table_partitionContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Split_table_partitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Split_table_partitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Split_table_partitionContext) AllRange_partition_desc() []IRange_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRange_partition_descContext); ok { + len++ + } + } + + tst := make([]IRange_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRange_partition_descContext); ok { + tst[i] = t.(IRange_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Split_table_partitionContext) Range_partition_desc(i int) IRange_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRange_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRange_partition_descContext) +} + +func (s *Split_table_partitionContext) AllList_partition_desc() []IList_partition_descContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IList_partition_descContext); ok { + len++ + } + } + + tst := make([]IList_partition_descContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IList_partition_descContext); ok { + tst[i] = t.(IList_partition_descContext) + i++ + } + } + + return tst +} + +func (s *Split_table_partitionContext) List_partition_desc(i int) IList_partition_descContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IList_partition_descContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IList_partition_descContext) +} + +func (s *Split_table_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Split_table_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Split_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Split_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Split_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSplit_table_partition(s) + } +} + +func (s *Split_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSplit_table_partition(s) + } +} + +func (s *Split_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSplit_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Split_table_partition() (localctx ISplit_table_partitionContext) { + localctx = NewSplit_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1556, PlSqlParserRULE_split_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14260) + p.Match(PlSqlParserSPLIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14261) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14262) + p.Partition_name() + } + { + p.SetState(14263) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14264) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1854, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14265) + p.Range_partition_desc() + } + p.SetState(14270) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14266) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14267) + p.Range_partition_desc() + } + + p.SetState(14272) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(14273) + p.List_partition_desc() + } + p.SetState(14278) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14274) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14275) + p.List_partition_desc() + } + + p.SetState(14280) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(14283) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITruncate_table_partitionContext is an interface to support dynamic dispatch. +type ITruncate_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TRUNCATE() antlr.TerminalNode + Partition_extended_names() IPartition_extended_namesContext + Subpartition_extended_names() ISubpartition_extended_namesContext + STORAGE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + Update_index_clauses() IUpdate_index_clausesContext + DROP() antlr.TerminalNode + REUSE() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + ALL() antlr.TerminalNode + + // IsTruncate_table_partitionContext differentiates from other interfaces. + IsTruncate_table_partitionContext() +} + +type Truncate_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTruncate_table_partitionContext() *Truncate_table_partitionContext { + var p = new(Truncate_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table_partition + return p +} + +func InitEmptyTruncate_table_partitionContext(p *Truncate_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_truncate_table_partition +} + +func (*Truncate_table_partitionContext) IsTruncate_table_partitionContext() {} + +func NewTruncate_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Truncate_table_partitionContext { + var p = new(Truncate_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_truncate_table_partition + + return p +} + +func (s *Truncate_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Truncate_table_partitionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Truncate_table_partitionContext) Partition_extended_names() IPartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extended_namesContext) +} + +func (s *Truncate_table_partitionContext) Subpartition_extended_names() ISubpartition_extended_namesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_extended_namesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_extended_namesContext) +} + +func (s *Truncate_table_partitionContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Truncate_table_partitionContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Truncate_table_partitionContext) Update_index_clauses() IUpdate_index_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_clausesContext) +} + +func (s *Truncate_table_partitionContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Truncate_table_partitionContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Truncate_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Truncate_table_partitionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Truncate_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Truncate_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Truncate_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTruncate_table_partition(s) + } +} + +func (s *Truncate_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTruncate_table_partition(s) + } +} + +func (s *Truncate_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTruncate_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Truncate_table_partition() (localctx ITruncate_table_partitionContext) { + localctx = NewTruncate_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1558, PlSqlParserRULE_truncate_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14285) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION, PlSqlParserPARTITIONS: + { + p.SetState(14286) + p.Partition_extended_names() + } + + case PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION: + { + p.SetState(14287) + p.Subpartition_extended_names() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserREUSE || _la == PlSqlParserSTORAGE { + p.SetState(14295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDROP: + { + p.SetState(14290) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(14291) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserREUSE: + { + p.SetState(14294) + p.Match(PlSqlParserREUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTORAGE: + + default: + } + { + p.SetState(14297) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(14300) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE { + { + p.SetState(14303) + p.Update_index_clauses() + } + p.SetState(14305) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14304) + p.Parallel_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 +} + +// IExchange_table_partitionContext is an interface to support dynamic dispatch. +type IExchange_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCHANGE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + AllWITH() []antlr.TerminalNode + WITH(i int) antlr.TerminalNode + TABLE() antlr.TerminalNode + Tableview_name() ITableview_nameContext + INDEXES() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsExchange_table_partitionContext differentiates from other interfaces. + IsExchange_table_partitionContext() +} + +type Exchange_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExchange_table_partitionContext() *Exchange_table_partitionContext { + var p = new(Exchange_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exchange_table_partition + return p +} + +func InitEmptyExchange_table_partitionContext(p *Exchange_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exchange_table_partition +} + +func (*Exchange_table_partitionContext) IsExchange_table_partitionContext() {} + +func NewExchange_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exchange_table_partitionContext { + var p = new(Exchange_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exchange_table_partition + + return p +} + +func (s *Exchange_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exchange_table_partitionContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Exchange_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Exchange_table_partitionContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Exchange_table_partitionContext) AllWITH() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserWITH) +} + +func (s *Exchange_table_partitionContext) WITH(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, i) +} + +func (s *Exchange_table_partitionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Exchange_table_partitionContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Exchange_table_partitionContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Exchange_table_partitionContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATION, 0) +} + +func (s *Exchange_table_partitionContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Exchange_table_partitionContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Exchange_table_partitionContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Exchange_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exchange_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exchange_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExchange_table_partition(s) + } +} + +func (s *Exchange_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExchange_table_partition(s) + } +} + +func (s *Exchange_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExchange_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exchange_table_partition() (localctx IExchange_table_partitionContext) { + localctx = NewExchange_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1560, PlSqlParserRULE_exchange_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14309) + p.Match(PlSqlParserEXCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14310) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14311) + p.Partition_name() + } + { + p.SetState(14312) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14313) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14314) + p.Tableview_name() + } + p.SetState(14317) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING { + { + p.SetState(14315) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDING || _la == PlSqlParserINCLUDING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14316) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(14319) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14320) + p.Match(PlSqlParserVALIDATION) + 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 +} + +// ICoalesce_table_partitionContext is an interface to support dynamic dispatch. +type ICoalesce_table_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COALESCE() antlr.TerminalNode + PARTITION() antlr.TerminalNode + Parallel_clause() IParallel_clauseContext + Allow_or_disallow() IAllow_or_disallowContext + CLUSTERING() antlr.TerminalNode + + // IsCoalesce_table_partitionContext differentiates from other interfaces. + IsCoalesce_table_partitionContext() +} + +type Coalesce_table_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCoalesce_table_partitionContext() *Coalesce_table_partitionContext { + var p = new(Coalesce_table_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition + return p +} + +func InitEmptyCoalesce_table_partitionContext(p *Coalesce_table_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition +} + +func (*Coalesce_table_partitionContext) IsCoalesce_table_partitionContext() {} + +func NewCoalesce_table_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Coalesce_table_partitionContext { + var p = new(Coalesce_table_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_coalesce_table_partition + + return p +} + +func (s *Coalesce_table_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Coalesce_table_partitionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Coalesce_table_partitionContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Coalesce_table_partitionContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Coalesce_table_partitionContext) Allow_or_disallow() IAllow_or_disallowContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllow_or_disallowContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllow_or_disallowContext) +} + +func (s *Coalesce_table_partitionContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Coalesce_table_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Coalesce_table_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Coalesce_table_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCoalesce_table_partition(s) + } +} + +func (s *Coalesce_table_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCoalesce_table_partition(s) + } +} + +func (s *Coalesce_table_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCoalesce_table_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Coalesce_table_partition() (localctx ICoalesce_table_partitionContext) { + localctx = NewCoalesce_table_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1562, PlSqlParserRULE_coalesce_table_partition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14323) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14324) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14325) + p.Parallel_clause() + } + + } + p.SetState(14331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALLOW || _la == PlSqlParserDISALLOW { + { + p.SetState(14328) + p.Allow_or_disallow() + } + { + p.SetState(14329) + p.Match(PlSqlParserCLUSTERING) + 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_interval_partitionContext is an interface to support dynamic dispatch. +type IAlter_interval_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Constant() IConstantContext + Expression() IExpressionContext + + // IsAlter_interval_partitionContext differentiates from other interfaces. + IsAlter_interval_partitionContext() +} + +type Alter_interval_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_interval_partitionContext() *Alter_interval_partitionContext { + var p = new(Alter_interval_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_interval_partition + return p +} + +func InitEmptyAlter_interval_partitionContext(p *Alter_interval_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_interval_partition +} + +func (*Alter_interval_partitionContext) IsAlter_interval_partitionContext() {} + +func NewAlter_interval_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_interval_partitionContext { + var p = new(Alter_interval_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_interval_partition + + return p +} + +func (s *Alter_interval_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_interval_partitionContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Alter_interval_partitionContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Alter_interval_partitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_interval_partitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_interval_partitionContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Alter_interval_partitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Alter_interval_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_interval_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_interval_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_interval_partition(s) + } +} + +func (s *Alter_interval_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_interval_partition(s) + } +} + +func (s *Alter_interval_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_interval_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_interval_partition() (localctx IAlter_interval_partitionContext) { + localctx = NewAlter_interval_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1564, PlSqlParserRULE_alter_interval_partition) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14333) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14334) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14335) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14338) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1866, p.GetParserRuleContext()) == 1 { + { + p.SetState(14336) + p.Constant() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1866, p.GetParserRuleContext()) == 2 { + { + p.SetState(14337) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(14340) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_extended_namesContext is an interface to support dynamic dispatch. +type IPartition_extended_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllPartition_key_value() []IPartition_key_valueContext + Partition_key_value(i int) IPartition_key_valueContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPartition_extended_namesContext differentiates from other interfaces. + IsPartition_extended_namesContext() +} + +type Partition_extended_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extended_namesContext() *Partition_extended_namesContext { + var p = new(Partition_extended_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extended_names + return p +} + +func InitEmptyPartition_extended_namesContext(p *Partition_extended_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extended_names +} + +func (*Partition_extended_namesContext) IsPartition_extended_namesContext() {} + +func NewPartition_extended_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extended_namesContext { + var p = new(Partition_extended_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extended_names + + return p +} + +func (s *Partition_extended_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extended_namesContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extended_namesContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Partition_extended_namesContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Partition_extended_namesContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Partition_extended_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extended_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extended_namesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extended_namesContext) AllPartition_key_value() []IPartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_key_valueContext); ok { + len++ + } + } + + tst := make([]IPartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_key_valueContext); ok { + tst[i] = t.(IPartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Partition_extended_namesContext) Partition_key_value(i int) IPartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_key_valueContext) +} + +func (s *Partition_extended_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Partition_extended_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Partition_extended_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extended_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extended_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extended_names(s) + } +} + +func (s *Partition_extended_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extended_names(s) + } +} + +func (s *Partition_extended_namesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_extended_names(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_extended_names() (localctx IPartition_extended_namesContext) { + localctx = NewPartition_extended_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1566, PlSqlParserRULE_partition_extended_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14342) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPARTITION || _la == PlSqlParserPARTITIONS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(14343) + p.Partition_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14344) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14345) + p.Partition_name() + } + p.SetState(14350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14346) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14347) + p.Partition_name() + } + + p.SetState(14352) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14353) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(14355) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14357) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14356) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14359) + p.Partition_key_value() + } + p.SetState(14364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14360) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14361) + p.Partition_key_value() + } + + p.SetState(14366) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(14367) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubpartition_extended_namesContext is an interface to support dynamic dispatch. +type ISubpartition_extended_namesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + AllPartition_name() []IPartition_nameContext + Partition_name(i int) IPartition_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FOR() antlr.TerminalNode + AllSubpartition_key_value() []ISubpartition_key_valueContext + Subpartition_key_value(i int) ISubpartition_key_valueContext + UPDATE() antlr.TerminalNode + INDEXES() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSubpartition_extended_namesContext differentiates from other interfaces. + IsSubpartition_extended_namesContext() +} + +type Subpartition_extended_namesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubpartition_extended_namesContext() *Subpartition_extended_namesContext { + var p = new(Subpartition_extended_namesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names + return p +} + +func InitEmptySubpartition_extended_namesContext(p *Subpartition_extended_namesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names +} + +func (*Subpartition_extended_namesContext) IsSubpartition_extended_namesContext() {} + +func NewSubpartition_extended_namesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subpartition_extended_namesContext { + var p = new(Subpartition_extended_namesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subpartition_extended_names + + return p +} + +func (s *Subpartition_extended_namesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subpartition_extended_namesContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Subpartition_extended_namesContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Subpartition_extended_namesContext) AllPartition_name() []IPartition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartition_nameContext); ok { + len++ + } + } + + tst := make([]IPartition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartition_nameContext); ok { + tst[i] = t.(IPartition_nameContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_extended_namesContext) Partition_name(i int) IPartition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Subpartition_extended_namesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subpartition_extended_namesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subpartition_extended_namesContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Subpartition_extended_namesContext) AllSubpartition_key_value() []ISubpartition_key_valueContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + len++ + } + } + + tst := make([]ISubpartition_key_valueContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubpartition_key_valueContext); ok { + tst[i] = t.(ISubpartition_key_valueContext) + i++ + } + } + + return tst +} + +func (s *Subpartition_extended_namesContext) Subpartition_key_value(i int) ISubpartition_key_valueContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_key_valueContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_key_valueContext) +} + +func (s *Subpartition_extended_namesContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Subpartition_extended_namesContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Subpartition_extended_namesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subpartition_extended_namesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subpartition_extended_namesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subpartition_extended_namesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subpartition_extended_namesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubpartition_extended_names(s) + } +} + +func (s *Subpartition_extended_namesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubpartition_extended_names(s) + } +} + +func (s *Subpartition_extended_namesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubpartition_extended_names(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subpartition_extended_names() (localctx ISubpartition_extended_namesContext) { + localctx = NewSubpartition_extended_namesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1568, PlSqlParserRULE_subpartition_extended_names) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14372) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSUBPARTITIONS || _la == PlSqlParserSUBPARTITION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14404) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(14373) + p.Partition_name() + } + p.SetState(14376) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1872, p.GetParserRuleContext()) == 1 { + { + p.SetState(14374) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14375) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14378) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14379) + p.Partition_name() + } + p.SetState(14384) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14380) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14381) + p.Partition_name() + } + + p.SetState(14386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14387) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFOR: + { + p.SetState(14389) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14390) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14393) + p.Subpartition_key_value() + } + p.SetState(14398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14394) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14395) + p.Subpartition_key_value() + } + + p.SetState(14400) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14402) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRIGHT_PAREN { + { + p.SetState(14401) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAlter_table_properties_1Context is an interface to support dynamic dispatch. +type IAlter_table_properties_1Context interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllTable_compression() []ITable_compressionContext + Table_compression(i int) ITable_compressionContext + AllInmemory_table_clause() []IInmemory_table_clauseContext + Inmemory_table_clause(i int) IInmemory_table_clauseContext + AllSupplemental_table_logging() []ISupplemental_table_loggingContext + Supplemental_table_logging(i int) ISupplemental_table_loggingContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllRESULT_CACHE() []antlr.TerminalNode + RESULT_CACHE(i int) antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllMODE() []antlr.TerminalNode + MODE(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllUpgrade_table_clause() []IUpgrade_table_clauseContext + Upgrade_table_clause(i int) IUpgrade_table_clauseContext + AllRecords_per_block_clause() []IRecords_per_block_clauseContext + Records_per_block_clause(i int) IRecords_per_block_clauseContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllRow_movement_clause() []IRow_movement_clauseContext + Row_movement_clause(i int) IRow_movement_clauseContext + AllFlashback_archive_clause() []IFlashback_archive_clauseContext + Flashback_archive_clause(i int) IFlashback_archive_clauseContext + Alter_iot_clauses() IAlter_iot_clausesContext + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllFORCE() []antlr.TerminalNode + FORCE(i int) antlr.TerminalNode + + // IsAlter_table_properties_1Context differentiates from other interfaces. + IsAlter_table_properties_1Context() +} + +type Alter_table_properties_1Context struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_table_properties_1Context() *Alter_table_properties_1Context { + var p = new(Alter_table_properties_1Context) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 + return p +} + +func InitEmptyAlter_table_properties_1Context(p *Alter_table_properties_1Context) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 +} + +func (*Alter_table_properties_1Context) IsAlter_table_properties_1Context() {} + +func NewAlter_table_properties_1Context(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_table_properties_1Context { + var p = new(Alter_table_properties_1Context) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_table_properties_1 + + return p +} + +func (s *Alter_table_properties_1Context) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_table_properties_1Context) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllTable_compression() []ITable_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_compressionContext); ok { + len++ + } + } + + tst := make([]ITable_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_compressionContext); ok { + tst[i] = t.(ITable_compressionContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Table_compression(i int) ITable_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Alter_table_properties_1Context) AllInmemory_table_clause() []IInmemory_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + len++ + } + } + + tst := make([]IInmemory_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IInmemory_table_clauseContext); ok { + tst[i] = t.(IInmemory_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Inmemory_table_clause(i int) IInmemory_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInmemory_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IInmemory_table_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllSupplemental_table_logging() []ISupplemental_table_loggingContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISupplemental_table_loggingContext); ok { + len++ + } + } + + tst := make([]ISupplemental_table_loggingContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISupplemental_table_loggingContext); ok { + tst[i] = t.(ISupplemental_table_loggingContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Supplemental_table_logging(i int) ISupplemental_table_loggingContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_table_loggingContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_table_loggingContext) +} + +func (s *Alter_table_properties_1Context) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRESULT_CACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRESULT_CACHE) +} + +func (s *Alter_table_properties_1Context) RESULT_CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, i) +} + +func (s *Alter_table_properties_1Context) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Alter_table_properties_1Context) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Alter_table_properties_1Context) AllMODE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMODE) +} + +func (s *Alter_table_properties_1Context) MODE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMODE, i) +} + +func (s *Alter_table_properties_1Context) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Alter_table_properties_1Context) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Alter_table_properties_1Context) AllUpgrade_table_clause() []IUpgrade_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpgrade_table_clauseContext); ok { + len++ + } + } + + tst := make([]IUpgrade_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpgrade_table_clauseContext); ok { + tst[i] = t.(IUpgrade_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Upgrade_table_clause(i int) IUpgrade_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpgrade_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpgrade_table_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRecords_per_block_clause() []IRecords_per_block_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRecords_per_block_clauseContext); ok { + len++ + } + } + + tst := make([]IRecords_per_block_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRecords_per_block_clauseContext); ok { + tst[i] = t.(IRecords_per_block_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Records_per_block_clause(i int) IRecords_per_block_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecords_per_block_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRecords_per_block_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllRow_movement_clause() []IRow_movement_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + len++ + } + } + + tst := make([]IRow_movement_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRow_movement_clauseContext); ok { + tst[i] = t.(IRow_movement_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Row_movement_clause(i int) IRow_movement_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRow_movement_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRow_movement_clauseContext) +} + +func (s *Alter_table_properties_1Context) AllFlashback_archive_clause() []IFlashback_archive_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_archive_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_archive_clauseContext); ok { + tst[i] = t.(IFlashback_archive_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_table_properties_1Context) Flashback_archive_clause(i int) IFlashback_archive_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_archive_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_archive_clauseContext) +} + +func (s *Alter_table_properties_1Context) Alter_iot_clauses() IAlter_iot_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_iot_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_iot_clausesContext) +} + +func (s *Alter_table_properties_1Context) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Alter_table_properties_1Context) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Alter_table_properties_1Context) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Alter_table_properties_1Context) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Alter_table_properties_1Context) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Alter_table_properties_1Context) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Alter_table_properties_1Context) AllFORCE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFORCE) +} + +func (s *Alter_table_properties_1Context) FORCE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, i) +} + +func (s *Alter_table_properties_1Context) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_table_properties_1Context) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_table_properties_1Context) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_table_properties_1(s) + } +} + +func (s *Alter_table_properties_1Context) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_table_properties_1(s) + } +} + +func (s *Alter_table_properties_1Context) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_table_properties_1(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_table_properties_1() (localctx IAlter_table_properties_1Context) { + localctx = NewAlter_table_properties_1Context(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1570, PlSqlParserRULE_alter_table_properties_1) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14424) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1878, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14406) + p.Physical_attributes_clause() + } + + case 2: + { + p.SetState(14407) + p.Logging_clause() + } + + case 3: + { + p.SetState(14408) + p.Table_compression() + } + + case 4: + { + p.SetState(14409) + p.Inmemory_table_clause() + } + + case 5: + { + p.SetState(14410) + p.Supplemental_table_logging() + } + + case 6: + { + p.SetState(14411) + p.Allocate_extent_clause() + } + + case 7: + { + p.SetState(14412) + p.Deallocate_unused_clause() + } + + case 8: + { + p.SetState(14413) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCACHE || _la == PlSqlParserNOCACHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 9: + { + p.SetState(14414) + p.Match(PlSqlParserRESULT_CACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14415) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14416) + p.Match(PlSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14417) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserFORCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14418) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + { + p.SetState(14419) + p.Upgrade_table_clause() + } + + case 11: + { + p.SetState(14420) + p.Records_per_block_clause() + } + + case 12: + { + p.SetState(14421) + p.Parallel_clause() + } + + case 13: + { + p.SetState(14422) + p.Row_movement_clause() + } + + case 14: + { + p.SetState(14423) + p.Flashback_archive_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14426) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1879, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14429) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserADD || _la == PlSqlParserCOALESCE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(14428) + p.Alter_iot_clauses() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_iot_clausesContext is an interface to support dynamic dispatch. +type IAlter_iot_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_org_table_clause() IIndex_org_table_clauseContext + Alter_overflow_clause() IAlter_overflow_clauseContext + Alter_mapping_table_clause() IAlter_mapping_table_clauseContext + COALESCE() antlr.TerminalNode + + // IsAlter_iot_clausesContext differentiates from other interfaces. + IsAlter_iot_clausesContext() +} + +type Alter_iot_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_iot_clausesContext() *Alter_iot_clausesContext { + var p = new(Alter_iot_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses + return p +} + +func InitEmptyAlter_iot_clausesContext(p *Alter_iot_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses +} + +func (*Alter_iot_clausesContext) IsAlter_iot_clausesContext() {} + +func NewAlter_iot_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_iot_clausesContext { + var p = new(Alter_iot_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_iot_clauses + + return p +} + +func (s *Alter_iot_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_iot_clausesContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Alter_iot_clausesContext) Alter_overflow_clause() IAlter_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_overflow_clauseContext) +} + +func (s *Alter_iot_clausesContext) Alter_mapping_table_clause() IAlter_mapping_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAlter_mapping_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAlter_mapping_table_clauseContext) +} + +func (s *Alter_iot_clausesContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Alter_iot_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_iot_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_iot_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_iot_clauses(s) + } +} + +func (s *Alter_iot_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_iot_clauses(s) + } +} + +func (s *Alter_iot_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_iot_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_iot_clauses() (localctx IAlter_iot_clausesContext) { + localctx = NewAlter_iot_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1572, PlSqlParserRULE_alter_iot_clauses) + p.SetState(14435) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1881, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14431) + p.Index_org_table_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14432) + p.Alter_overflow_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14433) + p.Alter_mapping_table_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14434) + p.Match(PlSqlParserCOALESCE) + 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_mapping_table_clauseContext is an interface to support dynamic dispatch. +type IAlter_mapping_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAPPING() antlr.TerminalNode + TABLE() antlr.TerminalNode + Allocate_extent_clause() IAllocate_extent_clauseContext + Deallocate_unused_clause() IDeallocate_unused_clauseContext + + // IsAlter_mapping_table_clauseContext differentiates from other interfaces. + IsAlter_mapping_table_clauseContext() +} + +type Alter_mapping_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_mapping_table_clauseContext() *Alter_mapping_table_clauseContext { + var p = new(Alter_mapping_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause + return p +} + +func InitEmptyAlter_mapping_table_clauseContext(p *Alter_mapping_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause +} + +func (*Alter_mapping_table_clauseContext) IsAlter_mapping_table_clauseContext() {} + +func NewAlter_mapping_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_mapping_table_clauseContext { + var p = new(Alter_mapping_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_mapping_table_clause + + return p +} + +func (s *Alter_mapping_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_mapping_table_clauseContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Alter_mapping_table_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Alter_mapping_table_clauseContext) Allocate_extent_clause() IAllocate_extent_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_mapping_table_clauseContext) Deallocate_unused_clause() IDeallocate_unused_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_mapping_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_mapping_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_mapping_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_mapping_table_clause(s) + } +} + +func (s *Alter_mapping_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_mapping_table_clause(s) + } +} + +func (s *Alter_mapping_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_mapping_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_mapping_table_clause() (localctx IAlter_mapping_table_clauseContext) { + localctx = NewAlter_mapping_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1574, PlSqlParserRULE_alter_mapping_table_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14437) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14438) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14441) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALLOCATE: + { + p.SetState(14439) + p.Allocate_extent_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(14440) + p.Deallocate_unused_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 +} + +// IAlter_overflow_clauseContext is an interface to support dynamic dispatch. +type IAlter_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_overflow_clause() IAdd_overflow_clauseContext + OVERFLOW() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + + // IsAlter_overflow_clauseContext differentiates from other interfaces. + IsAlter_overflow_clauseContext() +} + +type Alter_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_overflow_clauseContext() *Alter_overflow_clauseContext { + var p = new(Alter_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause + return p +} + +func InitEmptyAlter_overflow_clauseContext(p *Alter_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause +} + +func (*Alter_overflow_clauseContext) IsAlter_overflow_clauseContext() {} + +func NewAlter_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_overflow_clauseContext { + var p = new(Alter_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_overflow_clause + + return p +} + +func (s *Alter_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_overflow_clauseContext) Add_overflow_clause() IAdd_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_overflow_clauseContext) +} + +func (s *Alter_overflow_clauseContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Alter_overflow_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Alter_overflow_clauseContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Alter_overflow_clauseContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Alter_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_overflow_clause(s) + } +} + +func (s *Alter_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_overflow_clause(s) + } +} + +func (s *Alter_overflow_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_overflow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_overflow_clause() (localctx IAlter_overflow_clauseContext) { + localctx = NewAlter_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1576, PlSqlParserRULE_alter_overflow_clause) + var _la int + + p.SetState(14453) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserADD: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14443) + p.Add_overflow_clause() + } + + case PlSqlParserOVERFLOW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14444) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserDEALLOCATE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + p.SetState(14449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE, PlSqlParserTABLESPACE: + { + p.SetState(14445) + p.Segment_attributes_clause() + } + + case PlSqlParserALLOCATE: + { + p.SetState(14446) + p.Allocate_extent_clause() + } + + case PlSqlParserSHRINK: + { + p.SetState(14447) + p.Shrink_clause() + } + + case PlSqlParserDEALLOCATE: + { + p.SetState(14448) + p.Deallocate_unused_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14451) + 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 +} + +// IAdd_overflow_clauseContext is an interface to support dynamic dispatch. +type IAdd_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + OVERFLOW() antlr.TerminalNode + AllSegment_attributes_clause() []ISegment_attributes_clauseContext + Segment_attributes_clause(i int) ISegment_attributes_clauseContext + LEFT_PAREN() antlr.TerminalNode + AllPARTITION() []antlr.TerminalNode + PARTITION(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_overflow_clauseContext differentiates from other interfaces. + IsAdd_overflow_clauseContext() +} + +type Add_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_overflow_clauseContext() *Add_overflow_clauseContext { + var p = new(Add_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_overflow_clause + return p +} + +func InitEmptyAdd_overflow_clauseContext(p *Add_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_overflow_clause +} + +func (*Add_overflow_clauseContext) IsAdd_overflow_clauseContext() {} + +func NewAdd_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_overflow_clauseContext { + var p = new(Add_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_overflow_clause + + return p +} + +func (s *Add_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_overflow_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_overflow_clauseContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Add_overflow_clauseContext) AllSegment_attributes_clause() []ISegment_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]ISegment_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISegment_attributes_clauseContext); ok { + tst[i] = t.(ISegment_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_overflow_clauseContext) Segment_attributes_clause(i int) ISegment_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Add_overflow_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_overflow_clauseContext) AllPARTITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPARTITION) +} + +func (s *Add_overflow_clauseContext) PARTITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, i) +} + +func (s *Add_overflow_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_overflow_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_overflow_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_overflow_clause(s) + } +} + +func (s *Add_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_overflow_clause(s) + } +} + +func (s *Add_overflow_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_overflow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_overflow_clause() (localctx IAdd_overflow_clauseContext) { + localctx = NewAdd_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1578, PlSqlParserRULE_add_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14455) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14456) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(14457) + p.Segment_attributes_clause() + } + + } + p.SetState(14476) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14460) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14461) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(14462) + p.Segment_attributes_clause() + } + + } + p.SetState(14472) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14465) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14466) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserCOMPUTE || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || _la == PlSqlParserLOGGING || _la == PlSqlParserMAXTRANS || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || _la == PlSqlParserPCTFREE || _la == PlSqlParserPCTUSED || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(14467) + p.Segment_attributes_clause() + } + + } + + p.SetState(14474) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14475) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_index_clausesContext is an interface to support dynamic dispatch. +type IUpdate_index_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Update_global_index_clause() IUpdate_global_index_clauseContext + Update_all_indexes_clause() IUpdate_all_indexes_clauseContext + + // IsUpdate_index_clausesContext differentiates from other interfaces. + IsUpdate_index_clausesContext() +} + +type Update_index_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_clausesContext() *Update_index_clausesContext { + var p = new(Update_index_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_clauses + return p +} + +func InitEmptyUpdate_index_clausesContext(p *Update_index_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_clauses +} + +func (*Update_index_clausesContext) IsUpdate_index_clausesContext() {} + +func NewUpdate_index_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_clausesContext { + var p = new(Update_index_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_clauses + + return p +} + +func (s *Update_index_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_clausesContext) Update_global_index_clause() IUpdate_global_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_global_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_global_index_clauseContext) +} + +func (s *Update_index_clausesContext) Update_all_indexes_clause() IUpdate_all_indexes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_clauseContext) +} + +func (s *Update_index_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_clauses(s) + } +} + +func (s *Update_index_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_clauses(s) + } +} + +func (s *Update_index_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_index_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_index_clauses() (localctx IUpdate_index_clausesContext) { + localctx = NewUpdate_index_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1580, PlSqlParserRULE_update_index_clauses) + p.SetState(14480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1891, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14478) + p.Update_global_index_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14479) + p.Update_all_indexes_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 +} + +// IUpdate_global_index_clauseContext is an interface to support dynamic dispatch. +type IUpdate_global_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GLOBAL() antlr.TerminalNode + INDEXES() antlr.TerminalNode + UPDATE() antlr.TerminalNode + INVALIDATE() antlr.TerminalNode + + // IsUpdate_global_index_clauseContext differentiates from other interfaces. + IsUpdate_global_index_clauseContext() +} + +type Update_global_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_global_index_clauseContext() *Update_global_index_clauseContext { + var p = new(Update_global_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_global_index_clause + return p +} + +func InitEmptyUpdate_global_index_clauseContext(p *Update_global_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_global_index_clause +} + +func (*Update_global_index_clauseContext) IsUpdate_global_index_clauseContext() {} + +func NewUpdate_global_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_global_index_clauseContext { + var p = new(Update_global_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_global_index_clause + + return p +} + +func (s *Update_global_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_global_index_clauseContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Update_global_index_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Update_global_index_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_global_index_clauseContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Update_global_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_global_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_global_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_global_index_clause(s) + } +} + +func (s *Update_global_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_global_index_clause(s) + } +} + +func (s *Update_global_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_global_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_global_index_clause() (localctx IUpdate_global_index_clauseContext) { + localctx = NewUpdate_global_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1582, PlSqlParserRULE_update_global_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14482) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVALIDATE || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14483) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14484) + p.Match(PlSqlParserINDEXES) + 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_all_indexes_clauseContext is an interface to support dynamic dispatch. +type IUpdate_all_indexes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UPDATE() antlr.TerminalNode + INDEXES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Update_all_indexes_index_clause() IUpdate_all_indexes_index_clauseContext + RIGHT_PAREN() antlr.TerminalNode + + // IsUpdate_all_indexes_clauseContext differentiates from other interfaces. + IsUpdate_all_indexes_clauseContext() +} + +type Update_all_indexes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_all_indexes_clauseContext() *Update_all_indexes_clauseContext { + var p = new(Update_all_indexes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause + return p +} + +func InitEmptyUpdate_all_indexes_clauseContext(p *Update_all_indexes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause +} + +func (*Update_all_indexes_clauseContext) IsUpdate_all_indexes_clauseContext() {} + +func NewUpdate_all_indexes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_all_indexes_clauseContext { + var p = new(Update_all_indexes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_all_indexes_clause + + return p +} + +func (s *Update_all_indexes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_all_indexes_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_all_indexes_clauseContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Update_all_indexes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_all_indexes_clauseContext) Update_all_indexes_index_clause() IUpdate_all_indexes_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_index_clauseContext) +} + +func (s *Update_all_indexes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_all_indexes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_all_indexes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_all_indexes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_all_indexes_clause(s) + } +} + +func (s *Update_all_indexes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_all_indexes_clause(s) + } +} + +func (s *Update_all_indexes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_all_indexes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_all_indexes_clause() (localctx IUpdate_all_indexes_clauseContext) { + localctx = NewUpdate_all_indexes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1584, PlSqlParserRULE_update_all_indexes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14486) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14487) + p.Match(PlSqlParserINDEXES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14488) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14489) + p.Update_all_indexes_index_clause() + } + { + p.SetState(14490) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUpdate_all_indexes_index_clauseContext is an interface to support dynamic dispatch. +type IUpdate_all_indexes_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_name() IIndex_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Update_index_partition() IUpdate_index_partitionContext + Update_index_subpartition() IUpdate_index_subpartitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_all_indexes_clause() []IUpdate_all_indexes_clauseContext + Update_all_indexes_clause(i int) IUpdate_all_indexes_clauseContext + + // IsUpdate_all_indexes_index_clauseContext differentiates from other interfaces. + IsUpdate_all_indexes_index_clauseContext() +} + +type Update_all_indexes_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_all_indexes_index_clauseContext() *Update_all_indexes_index_clauseContext { + var p = new(Update_all_indexes_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause + return p +} + +func InitEmptyUpdate_all_indexes_index_clauseContext(p *Update_all_indexes_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause +} + +func (*Update_all_indexes_index_clauseContext) IsUpdate_all_indexes_index_clauseContext() {} + +func NewUpdate_all_indexes_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_all_indexes_index_clauseContext { + var p = new(Update_all_indexes_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_all_indexes_index_clause + + return p +} + +func (s *Update_all_indexes_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_all_indexes_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Update_all_indexes_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_all_indexes_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_all_indexes_index_clauseContext) Update_index_partition() IUpdate_index_partitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_partitionContext) +} + +func (s *Update_all_indexes_index_clauseContext) Update_index_subpartition() IUpdate_index_subpartitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_subpartitionContext) +} + +func (s *Update_all_indexes_index_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_all_indexes_index_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_all_indexes_index_clauseContext) AllUpdate_all_indexes_clause() []IUpdate_all_indexes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + len++ + } + } + + tst := make([]IUpdate_all_indexes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + tst[i] = t.(IUpdate_all_indexes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Update_all_indexes_index_clauseContext) Update_all_indexes_clause(i int) IUpdate_all_indexes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_all_indexes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_all_indexes_clauseContext) +} + +func (s *Update_all_indexes_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_all_indexes_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_all_indexes_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_all_indexes_index_clause(s) + } +} + +func (s *Update_all_indexes_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_all_indexes_index_clause(s) + } +} + +func (s *Update_all_indexes_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_all_indexes_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_all_indexes_index_clause() (localctx IUpdate_all_indexes_index_clauseContext) { + localctx = NewUpdate_all_indexes_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1586, PlSqlParserRULE_update_all_indexes_index_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14494) + p.Index_name() + } + { + p.SetState(14495) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPARTITION: + { + p.SetState(14496) + p.Update_index_partition() + } + + case PlSqlParserSUBPARTITION: + { + p.SetState(14497) + p.Update_index_subpartition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(14500) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14505) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14501) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14502) + p.Update_all_indexes_clause() + } + + p.SetState(14507) + 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 +} + +// IUpdate_index_partitionContext is an interface to support dynamic dispatch. +type IUpdate_index_partitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Index_partition_description() IIndex_partition_descriptionContext + Index_subpartition_clause() IIndex_subpartition_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_index_partition() []IUpdate_index_partitionContext + Update_index_partition(i int) IUpdate_index_partitionContext + + // IsUpdate_index_partitionContext differentiates from other interfaces. + IsUpdate_index_partitionContext() +} + +type Update_index_partitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_partitionContext() *Update_index_partitionContext { + var p = new(Update_index_partitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_partition + return p +} + +func InitEmptyUpdate_index_partitionContext(p *Update_index_partitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_partition +} + +func (*Update_index_partitionContext) IsUpdate_index_partitionContext() {} + +func NewUpdate_index_partitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_partitionContext { + var p = new(Update_index_partitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_partition + + return p +} + +func (s *Update_index_partitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_partitionContext) Index_partition_description() IIndex_partition_descriptionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_partition_descriptionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_partition_descriptionContext) +} + +func (s *Update_index_partitionContext) Index_subpartition_clause() IIndex_subpartition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_subpartition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_subpartition_clauseContext) +} + +func (s *Update_index_partitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_index_partitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_index_partitionContext) AllUpdate_index_partition() []IUpdate_index_partitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + len++ + } + } + + tst := make([]IUpdate_index_partitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_index_partitionContext); ok { + tst[i] = t.(IUpdate_index_partitionContext) + i++ + } + } + + return tst +} + +func (s *Update_index_partitionContext) Update_index_partition(i int) IUpdate_index_partitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_partitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_partitionContext) +} + +func (s *Update_index_partitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_partitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_partitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_partition(s) + } +} + +func (s *Update_index_partitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_partition(s) + } +} + +func (s *Update_index_partitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_index_partition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_index_partition() (localctx IUpdate_index_partitionContext) { + localctx = NewUpdate_index_partitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1588, PlSqlParserRULE_update_index_partition) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14508) + p.Index_partition_description() + } + p.SetState(14510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTORE || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(14509) + p.Index_subpartition_clause() + } + + } + p.SetState(14516) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1896, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14512) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14513) + p.Update_index_partition() + } + + } + p.SetState(14518) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1896, 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 +} + +// IUpdate_index_subpartitionContext is an interface to support dynamic dispatch. +type IUpdate_index_subpartitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBPARTITION() antlr.TerminalNode + Subpartition_name() ISubpartition_nameContext + TABLESPACE() antlr.TerminalNode + Tablespace() ITablespaceContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllUpdate_index_subpartition() []IUpdate_index_subpartitionContext + Update_index_subpartition(i int) IUpdate_index_subpartitionContext + + // IsUpdate_index_subpartitionContext differentiates from other interfaces. + IsUpdate_index_subpartitionContext() +} + +type Update_index_subpartitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_index_subpartitionContext() *Update_index_subpartitionContext { + var p = new(Update_index_subpartitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_subpartition + return p +} + +func InitEmptyUpdate_index_subpartitionContext(p *Update_index_subpartitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_index_subpartition +} + +func (*Update_index_subpartitionContext) IsUpdate_index_subpartitionContext() {} + +func NewUpdate_index_subpartitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_index_subpartitionContext { + var p = new(Update_index_subpartitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_index_subpartition + + return p +} + +func (s *Update_index_subpartitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_index_subpartitionContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Update_index_subpartitionContext) Subpartition_name() ISubpartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubpartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubpartition_nameContext) +} + +func (s *Update_index_subpartitionContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Update_index_subpartitionContext) Tablespace() ITablespaceContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Update_index_subpartitionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_index_subpartitionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_index_subpartitionContext) AllUpdate_index_subpartition() []IUpdate_index_subpartitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + len++ + } + } + + tst := make([]IUpdate_index_subpartitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUpdate_index_subpartitionContext); ok { + tst[i] = t.(IUpdate_index_subpartitionContext) + i++ + } + } + + return tst +} + +func (s *Update_index_subpartitionContext) Update_index_subpartition(i int) IUpdate_index_subpartitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_index_subpartitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_index_subpartitionContext) +} + +func (s *Update_index_subpartitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_index_subpartitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_index_subpartitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_index_subpartition(s) + } +} + +func (s *Update_index_subpartitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_index_subpartition(s) + } +} + +func (s *Update_index_subpartitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_index_subpartition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_index_subpartition() (localctx IUpdate_index_subpartitionContext) { + localctx = NewUpdate_index_subpartitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1590, PlSqlParserRULE_update_index_subpartition) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14519) + p.Match(PlSqlParserSUBPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14521) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1897, p.GetParserRuleContext()) == 1 { + { + p.SetState(14520) + p.Subpartition_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14525) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTABLESPACE { + { + p.SetState(14523) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14524) + p.Tablespace() + } + + } + p.SetState(14531) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1899, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(14527) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14528) + p.Update_index_subpartition() + } + + } + p.SetState(14533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1899, 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 +} + +// IEnable_disable_clauseContext is an interface to support dynamic dispatch. +type IEnable_disable_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + DISABLE() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + Using_index_clause() IUsing_index_clauseContext + Exceptions_clause() IExceptions_clauseContext + CASCADE() antlr.TerminalNode + INDEX() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + KEEP() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsEnable_disable_clauseContext differentiates from other interfaces. + IsEnable_disable_clauseContext() +} + +type Enable_disable_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_disable_clauseContext() *Enable_disable_clauseContext { + var p = new(Enable_disable_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_clause + return p +} + +func InitEmptyEnable_disable_clauseContext(p *Enable_disable_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_disable_clause +} + +func (*Enable_disable_clauseContext) IsEnable_disable_clauseContext() {} + +func NewEnable_disable_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_disable_clauseContext { + var p = new(Enable_disable_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_disable_clause + + return p +} + +func (s *Enable_disable_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_disable_clauseContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_disable_clauseContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Enable_disable_clauseContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Enable_disable_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Enable_disable_clauseContext) 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 *Enable_disable_clauseContext) 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 *Enable_disable_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Enable_disable_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Enable_disable_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Enable_disable_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Enable_disable_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Enable_disable_clauseContext) Using_index_clause() IUsing_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Enable_disable_clauseContext) Exceptions_clause() IExceptions_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExceptions_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExceptions_clauseContext) +} + +func (s *Enable_disable_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Enable_disable_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Enable_disable_clauseContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Enable_disable_clauseContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Enable_disable_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Enable_disable_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Enable_disable_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Enable_disable_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Enable_disable_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_disable_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_disable_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_disable_clause(s) + } +} + +func (s *Enable_disable_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_disable_clause(s) + } +} + +func (s *Enable_disable_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnable_disable_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Enable_disable_clause() (localctx IEnable_disable_clauseContext) { + localctx = NewEnable_disable_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1592, PlSqlParserRULE_enable_disable_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14534) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(14536) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE { + { + p.SetState(14535) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOVALIDATE || _la == PlSqlParserVALIDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(14554) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNIQUE: + { + p.SetState(14538) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14539) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14540) + p.Column_name() + } + p.SetState(14545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14541) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14542) + p.Column_name() + } + + p.SetState(14547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14548) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRIMARY: + { + p.SetState(14550) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14551) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCONSTRAINT: + { + p.SetState(14552) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14553) + p.Constraint_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(14556) + p.Using_index_clause() + } + + } + p.SetState(14560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTIONS { + { + p.SetState(14559) + p.Exceptions_clause() + } + + } + p.SetState(14563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(14562) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDROP || _la == PlSqlParserKEEP { + { + p.SetState(14565) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14566) + p.Match(PlSqlParserINDEX) + 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 +} + +// IUsing_index_clauseContext is an interface to support dynamic dispatch. +type IUsing_index_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + INDEX() antlr.TerminalNode + Index_name() IIndex_nameContext + LEFT_PAREN() antlr.TerminalNode + Create_index() ICreate_indexContext + RIGHT_PAREN() antlr.TerminalNode + Index_attributes() IIndex_attributesContext + + // IsUsing_index_clauseContext differentiates from other interfaces. + IsUsing_index_clauseContext() +} + +type Using_index_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_index_clauseContext() *Using_index_clauseContext { + var p = new(Using_index_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_index_clause + return p +} + +func InitEmptyUsing_index_clauseContext(p *Using_index_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_index_clause +} + +func (*Using_index_clauseContext) IsUsing_index_clauseContext() {} + +func NewUsing_index_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_index_clauseContext { + var p = new(Using_index_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_index_clause + + return p +} + +func (s *Using_index_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_index_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_index_clauseContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Using_index_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Using_index_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Using_index_clauseContext) Create_index() ICreate_indexContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICreate_indexContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICreate_indexContext) +} + +func (s *Using_index_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Using_index_clauseContext) Index_attributes() IIndex_attributesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_attributesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_attributesContext) +} + +func (s *Using_index_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_index_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_index_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_index_clause(s) + } +} + +func (s *Using_index_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_index_clause(s) + } +} + +func (s *Using_index_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_index_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_index_clause() (localctx IUsing_index_clauseContext) { + localctx = NewUsing_index_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1594, PlSqlParserRULE_using_index_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14569) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14570) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14577) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1907, p.GetParserRuleContext()) == 1 { + { + p.SetState(14571) + p.Index_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1907, p.GetParserRuleContext()) == 2 { + { + p.SetState(14572) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14573) + p.Create_index() + } + { + p.SetState(14574) + p.Match(PlSqlParserRIGHT_PAREN) + 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(), 1907, p.GetParserRuleContext()) == 3 { + { + p.SetState(14576) + p.Index_attributes() + } + + } 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 +} + +// IIndex_attributesContext is an interface to support dynamic dispatch. +type IIndex_attributesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext + Physical_attributes_clause(i int) IPhysical_attributes_clauseContext + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + AllONLINE() []antlr.TerminalNode + ONLINE(i int) antlr.TerminalNode + AllTABLESPACE() []antlr.TerminalNode + TABLESPACE(i int) antlr.TerminalNode + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + AllSort_or_nosort() []ISort_or_nosortContext + Sort_or_nosort(i int) ISort_or_nosortContext + AllREVERSE() []antlr.TerminalNode + REVERSE(i int) antlr.TerminalNode + AllVisible_or_invisible() []IVisible_or_invisibleContext + Visible_or_invisible(i int) IVisible_or_invisibleContext + AllPartial_index_clause() []IPartial_index_clauseContext + Partial_index_clause(i int) IPartial_index_clauseContext + AllParallel_clause() []IParallel_clauseContext + Parallel_clause(i int) IParallel_clauseContext + AllTablespace() []ITablespaceContext + Tablespace(i int) ITablespaceContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + + // IsIndex_attributesContext differentiates from other interfaces. + IsIndex_attributesContext() +} + +type Index_attributesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_attributesContext() *Index_attributesContext { + var p = new(Index_attributesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_attributes + return p +} + +func InitEmptyIndex_attributesContext(p *Index_attributesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_attributes +} + +func (*Index_attributesContext) IsIndex_attributesContext() {} + +func NewIndex_attributesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_attributesContext { + var p = new(Index_attributesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_attributes + + return p +} + +func (s *Index_attributesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_attributesContext) AllPhysical_attributes_clause() []IPhysical_attributes_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + len++ + } + } + + tst := make([]IPhysical_attributes_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_attributes_clauseContext); ok { + tst[i] = t.(IPhysical_attributes_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Physical_attributes_clause(i int) IPhysical_attributes_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_attributes_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_attributes_clauseContext) +} + +func (s *Index_attributesContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Index_attributesContext) AllONLINE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserONLINE) +} + +func (s *Index_attributesContext) ONLINE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, i) +} + +func (s *Index_attributesContext) AllTABLESPACE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserTABLESPACE) +} + +func (s *Index_attributesContext) TABLESPACE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, i) +} + +func (s *Index_attributesContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_attributesContext) AllSort_or_nosort() []ISort_or_nosortContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISort_or_nosortContext); ok { + len++ + } + } + + tst := make([]ISort_or_nosortContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISort_or_nosortContext); ok { + tst[i] = t.(ISort_or_nosortContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Sort_or_nosort(i int) ISort_or_nosortContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISort_or_nosortContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISort_or_nosortContext) +} + +func (s *Index_attributesContext) AllREVERSE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREVERSE) +} + +func (s *Index_attributesContext) REVERSE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, i) +} + +func (s *Index_attributesContext) AllVisible_or_invisible() []IVisible_or_invisibleContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + len++ + } + } + + tst := make([]IVisible_or_invisibleContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVisible_or_invisibleContext); ok { + tst[i] = t.(IVisible_or_invisibleContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Visible_or_invisible(i int) IVisible_or_invisibleContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVisible_or_invisibleContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVisible_or_invisibleContext) +} + +func (s *Index_attributesContext) AllPartial_index_clause() []IPartial_index_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPartial_index_clauseContext); ok { + len++ + } + } + + tst := make([]IPartial_index_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPartial_index_clauseContext); ok { + tst[i] = t.(IPartial_index_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Partial_index_clause(i int) IPartial_index_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartial_index_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPartial_index_clauseContext) +} + +func (s *Index_attributesContext) AllParallel_clause() []IParallel_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParallel_clauseContext); ok { + len++ + } + } + + tst := make([]IParallel_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParallel_clauseContext); ok { + tst[i] = t.(IParallel_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Parallel_clause(i int) IParallel_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Index_attributesContext) AllTablespace() []ITablespaceContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITablespaceContext); ok { + len++ + } + } + + tst := make([]ITablespaceContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITablespaceContext); ok { + tst[i] = t.(ITablespaceContext) + i++ + } + } + + return tst +} + +func (s *Index_attributesContext) Tablespace(i int) ITablespaceContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITablespaceContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITablespaceContext) +} + +func (s *Index_attributesContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Index_attributesContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Index_attributesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_attributesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_attributesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_attributes(s) + } +} + +func (s *Index_attributesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_attributes(s) + } +} + +func (s *Index_attributesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_attributes(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_attributes() (localctx IIndex_attributesContext) { + localctx = NewIndex_attributesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1596, PlSqlParserRULE_index_attributes) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPUTE, PlSqlParserINITRANS, PlSqlParserMAXTRANS, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSTORAGE: + { + p.SetState(14579) + p.Physical_attributes_clause() + } + + case PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserLOGGING, PlSqlParserNOLOGGING: + { + p.SetState(14580) + p.Logging_clause() + } + + case PlSqlParserONLINE: + { + p.SetState(14581) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTABLESPACE: + { + p.SetState(14582) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(14583) + p.Tablespace() + } + + case PlSqlParserDEFAULT: + { + p.SetState(14584) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(14587) + p.Key_compression() + } + + case PlSqlParserNOSORT, PlSqlParserSORT: + { + p.SetState(14588) + p.Sort_or_nosort() + } + + case PlSqlParserREVERSE: + { + p.SetState(14589) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVISIBLE, PlSqlParserVISIBLE: + { + p.SetState(14590) + p.Visible_or_invisible() + } + + case PlSqlParserINDEXING: + { + p.SetState(14591) + p.Partial_index_clause() + } + + case PlSqlParserNOPARALLEL, PlSqlParserPARALLEL: + { + p.SetState(14592) + p.Parallel_clause() + } + + 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 + } + + p.SetState(14595) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1910, 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 +} + +// ISort_or_nosortContext is an interface to support dynamic dispatch. +type ISort_or_nosortContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SORT() antlr.TerminalNode + NOSORT() antlr.TerminalNode + + // IsSort_or_nosortContext differentiates from other interfaces. + IsSort_or_nosortContext() +} + +type Sort_or_nosortContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySort_or_nosortContext() *Sort_or_nosortContext { + var p = new(Sort_or_nosortContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sort_or_nosort + return p +} + +func InitEmptySort_or_nosortContext(p *Sort_or_nosortContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sort_or_nosort +} + +func (*Sort_or_nosortContext) IsSort_or_nosortContext() {} + +func NewSort_or_nosortContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sort_or_nosortContext { + var p = new(Sort_or_nosortContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sort_or_nosort + + return p +} + +func (s *Sort_or_nosortContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sort_or_nosortContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Sort_or_nosortContext) NOSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSORT, 0) +} + +func (s *Sort_or_nosortContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sort_or_nosortContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sort_or_nosortContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSort_or_nosort(s) + } +} + +func (s *Sort_or_nosortContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSort_or_nosort(s) + } +} + +func (s *Sort_or_nosortContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSort_or_nosort(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sort_or_nosort() (localctx ISort_or_nosortContext) { + localctx = NewSort_or_nosortContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1598, PlSqlParserRULE_sort_or_nosort) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14597) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOSORT || _la == PlSqlParserSORT) { + 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 +} + +// IExceptions_clauseContext is an interface to support dynamic dispatch. +type IExceptions_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXCEPTIONS() antlr.TerminalNode + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsExceptions_clauseContext differentiates from other interfaces. + IsExceptions_clauseContext() +} + +type Exceptions_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExceptions_clauseContext() *Exceptions_clauseContext { + var p = new(Exceptions_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exceptions_clause + return p +} + +func InitEmptyExceptions_clauseContext(p *Exceptions_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exceptions_clause +} + +func (*Exceptions_clauseContext) IsExceptions_clauseContext() {} + +func NewExceptions_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exceptions_clauseContext { + var p = new(Exceptions_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exceptions_clause + + return p +} + +func (s *Exceptions_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exceptions_clauseContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Exceptions_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Exceptions_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Exceptions_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exceptions_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exceptions_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExceptions_clause(s) + } +} + +func (s *Exceptions_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExceptions_clause(s) + } +} + +func (s *Exceptions_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExceptions_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exceptions_clause() (localctx IExceptions_clauseContext) { + localctx = NewExceptions_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1600, PlSqlParserRULE_exceptions_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14599) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14600) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14601) + p.Tableview_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 +} + +// IMove_table_clauseContext is an interface to support dynamic dispatch. +type IMove_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MOVE() antlr.TerminalNode + ONLINE() antlr.TerminalNode + Segment_attributes_clause() ISegment_attributes_clauseContext + Table_compression() ITable_compressionContext + Index_org_table_clause() IIndex_org_table_clauseContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + Parallel_clause() IParallel_clauseContext + + // IsMove_table_clauseContext differentiates from other interfaces. + IsMove_table_clauseContext() +} + +type Move_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMove_table_clauseContext() *Move_table_clauseContext { + var p = new(Move_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_clause + return p +} + +func InitEmptyMove_table_clauseContext(p *Move_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_move_table_clause +} + +func (*Move_table_clauseContext) IsMove_table_clauseContext() {} + +func NewMove_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Move_table_clauseContext { + var p = new(Move_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_move_table_clause + + return p +} + +func (s *Move_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Move_table_clauseContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Move_table_clauseContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Move_table_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Move_table_clauseContext) Table_compression() ITable_compressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_compressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_compressionContext) +} + +func (s *Move_table_clauseContext) Index_org_table_clause() IIndex_org_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_table_clauseContext) +} + +func (s *Move_table_clauseContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Move_table_clauseContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Move_table_clauseContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Move_table_clauseContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Move_table_clauseContext) Parallel_clause() IParallel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParallel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParallel_clauseContext) +} + +func (s *Move_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Move_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Move_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMove_table_clause(s) + } +} + +func (s *Move_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMove_table_clause(s) + } +} + +func (s *Move_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMove_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Move_table_clause() (localctx IMove_table_clauseContext) { + localctx = NewMove_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1602, PlSqlParserRULE_move_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14603) + p.Match(PlSqlParserMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserONLINE { + { + p.SetState(14604) + p.Match(PlSqlParserONLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(14608) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1912, p.GetParserRuleContext()) == 1 { + { + p.SetState(14607) + p.Segment_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14611) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1913, p.GetParserRuleContext()) == 1 { + { + p.SetState(14610) + p.Table_compression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(14614) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMPRESS || _la == PlSqlParserINCLUDING || _la == PlSqlParserMAPPING || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOMAPPING || _la == PlSqlParserOVERFLOW || _la == PlSqlParserPCTTHRESHOLD { + { + p.SetState(14613) + p.Index_org_table_clause() + } + + } + p.SetState(14620) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserLOB || _la == PlSqlParserVARRAY { + p.SetState(14618) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOB: + { + p.SetState(14616) + p.Lob_storage_clause() + } + + case PlSqlParserVARRAY: + { + p.SetState(14617) + p.Varray_col_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14622) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14624) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOPARALLEL || _la == PlSqlParserPARALLEL { + { + p.SetState(14623) + p.Parallel_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 +} + +// IIndex_org_table_clauseContext is an interface to support dynamic dispatch. +type IIndex_org_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllMapping_table_clause() []IMapping_table_clauseContext + Mapping_table_clause(i int) IMapping_table_clauseContext + AllPCTTHRESHOLD() []antlr.TerminalNode + PCTTHRESHOLD(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllKey_compression() []IKey_compressionContext + Key_compression(i int) IKey_compressionContext + Index_org_overflow_clause() IIndex_org_overflow_clauseContext + + // IsIndex_org_table_clauseContext differentiates from other interfaces. + IsIndex_org_table_clauseContext() +} + +type Index_org_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_org_table_clauseContext() *Index_org_table_clauseContext { + var p = new(Index_org_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_table_clause + return p +} + +func InitEmptyIndex_org_table_clauseContext(p *Index_org_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_table_clause +} + +func (*Index_org_table_clauseContext) IsIndex_org_table_clauseContext() {} + +func NewIndex_org_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_org_table_clauseContext { + var p = new(Index_org_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_org_table_clause + + return p +} + +func (s *Index_org_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_org_table_clauseContext) AllMapping_table_clause() []IMapping_table_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMapping_table_clauseContext); ok { + len++ + } + } + + tst := make([]IMapping_table_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMapping_table_clauseContext); ok { + tst[i] = t.(IMapping_table_clauseContext) + i++ + } + } + + return tst +} + +func (s *Index_org_table_clauseContext) Mapping_table_clause(i int) IMapping_table_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMapping_table_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMapping_table_clauseContext) +} + +func (s *Index_org_table_clauseContext) AllPCTTHRESHOLD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTTHRESHOLD) +} + +func (s *Index_org_table_clauseContext) PCTTHRESHOLD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTTHRESHOLD, i) +} + +func (s *Index_org_table_clauseContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Index_org_table_clauseContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Index_org_table_clauseContext) AllKey_compression() []IKey_compressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IKey_compressionContext); ok { + len++ + } + } + + tst := make([]IKey_compressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IKey_compressionContext); ok { + tst[i] = t.(IKey_compressionContext) + i++ + } + } + + return tst +} + +func (s *Index_org_table_clauseContext) Key_compression(i int) IKey_compressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKey_compressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IKey_compressionContext) +} + +func (s *Index_org_table_clauseContext) Index_org_overflow_clause() IIndex_org_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_org_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_org_overflow_clauseContext) +} + +func (s *Index_org_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_org_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_org_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_org_table_clause(s) + } +} + +func (s *Index_org_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_org_table_clause(s) + } +} + +func (s *Index_org_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_org_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_org_table_clause() (localctx IIndex_org_table_clauseContext) { + localctx = NewIndex_org_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1604, PlSqlParserRULE_index_org_table_clause) + var _la int + + var _alt int + + p.SetState(14638) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOMPRESS, PlSqlParserMAPPING, PlSqlParserNOCOMPRESS, PlSqlParserNOMAPPING, PlSqlParserPCTTHRESHOLD: + p.EnterOuterAlt(localctx, 1) + p.SetState(14630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAPPING, PlSqlParserNOMAPPING: + { + p.SetState(14626) + p.Mapping_table_clause() + } + + case PlSqlParserPCTTHRESHOLD: + { + p.SetState(14627) + p.Match(PlSqlParserPCTTHRESHOLD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14628) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(14629) + p.Key_compression() + } + + 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 + } + + p.SetState(14632) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1919, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(14635) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING || _la == PlSqlParserOVERFLOW { + { + p.SetState(14634) + p.Index_org_overflow_clause() + } + + } + + case PlSqlParserINCLUDING, PlSqlParserOVERFLOW: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14637) + p.Index_org_overflow_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 +} + +// IMapping_table_clauseContext is an interface to support dynamic dispatch. +type IMapping_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MAPPING() antlr.TerminalNode + TABLE() antlr.TerminalNode + NOMAPPING() antlr.TerminalNode + + // IsMapping_table_clauseContext differentiates from other interfaces. + IsMapping_table_clauseContext() +} + +type Mapping_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMapping_table_clauseContext() *Mapping_table_clauseContext { + var p = new(Mapping_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mapping_table_clause + return p +} + +func InitEmptyMapping_table_clauseContext(p *Mapping_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_mapping_table_clause +} + +func (*Mapping_table_clauseContext) IsMapping_table_clauseContext() {} + +func NewMapping_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Mapping_table_clauseContext { + var p = new(Mapping_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_mapping_table_clause + + return p +} + +func (s *Mapping_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Mapping_table_clauseContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Mapping_table_clauseContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Mapping_table_clauseContext) NOMAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAPPING, 0) +} + +func (s *Mapping_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Mapping_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Mapping_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMapping_table_clause(s) + } +} + +func (s *Mapping_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMapping_table_clause(s) + } +} + +func (s *Mapping_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMapping_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Mapping_table_clause() (localctx IMapping_table_clauseContext) { + localctx = NewMapping_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1606, PlSqlParserRULE_mapping_table_clause) + p.SetState(14643) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAPPING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14640) + p.Match(PlSqlParserMAPPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14641) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOMAPPING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14642) + p.Match(PlSqlParserNOMAPPING) + 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 +} + +// IKey_compressionContext is an interface to support dynamic dispatch. +type IKey_compressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOCOMPRESS() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + + // IsKey_compressionContext differentiates from other interfaces. + IsKey_compressionContext() +} + +type Key_compressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKey_compressionContext() *Key_compressionContext { + var p = new(Key_compressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_compression + return p +} + +func InitEmptyKey_compressionContext(p *Key_compressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_key_compression +} + +func (*Key_compressionContext) IsKey_compressionContext() {} + +func NewKey_compressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Key_compressionContext { + var p = new(Key_compressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_key_compression + + return p +} + +func (s *Key_compressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Key_compressionContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Key_compressionContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Key_compressionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Key_compressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Key_compressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Key_compressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKey_compression(s) + } +} + +func (s *Key_compressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKey_compression(s) + } +} + +func (s *Key_compressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKey_compression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Key_compression() (localctx IKey_compressionContext) { + localctx = NewKey_compressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1608, PlSqlParserRULE_key_compression) + p.SetState(14648) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14645) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14646) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14647) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IIndex_org_overflow_clauseContext is an interface to support dynamic dispatch. +type IIndex_org_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OVERFLOW() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + Column_name() IColumn_nameContext + Segment_attributes_clause() ISegment_attributes_clauseContext + + // IsIndex_org_overflow_clauseContext differentiates from other interfaces. + IsIndex_org_overflow_clauseContext() +} + +type Index_org_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_org_overflow_clauseContext() *Index_org_overflow_clauseContext { + var p = new(Index_org_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause + return p +} + +func InitEmptyIndex_org_overflow_clauseContext(p *Index_org_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause +} + +func (*Index_org_overflow_clauseContext) IsIndex_org_overflow_clauseContext() {} + +func NewIndex_org_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_org_overflow_clauseContext { + var p = new(Index_org_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_org_overflow_clause + + return p +} + +func (s *Index_org_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_org_overflow_clauseContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Index_org_overflow_clauseContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Index_org_overflow_clauseContext) 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 *Index_org_overflow_clauseContext) Segment_attributes_clause() ISegment_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISegment_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISegment_attributes_clauseContext) +} + +func (s *Index_org_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_org_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_org_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_org_overflow_clause(s) + } +} + +func (s *Index_org_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_org_overflow_clause(s) + } +} + +func (s *Index_org_overflow_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_org_overflow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_org_overflow_clause() (localctx IIndex_org_overflow_clauseContext) { + localctx = NewIndex_org_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1610, PlSqlParserRULE_index_org_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINCLUDING { + { + p.SetState(14650) + p.Match(PlSqlParserINCLUDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14651) + p.Column_name() + } + + } + { + p.SetState(14654) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14656) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1925, p.GetParserRuleContext()) == 1 { + { + p.SetState(14655) + p.Segment_attributes_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 +} + +// IColumn_clausesContext is an interface to support dynamic dispatch. +type IColumn_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Add_modify_drop_column_clauses() IAdd_modify_drop_column_clausesContext + Rename_column_clause() IRename_column_clauseContext + Modify_collection_retrieval() IModify_collection_retrievalContext + Modify_lob_storage_clause() IModify_lob_storage_clauseContext + + // IsColumn_clausesContext differentiates from other interfaces. + IsColumn_clausesContext() +} + +type Column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_clausesContext() *Column_clausesContext { + var p = new(Column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_clauses + return p +} + +func InitEmptyColumn_clausesContext(p *Column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_clauses +} + +func (*Column_clausesContext) IsColumn_clausesContext() {} + +func NewColumn_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_clausesContext { + var p = new(Column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_clauses + + return p +} + +func (s *Column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_clausesContext) Add_modify_drop_column_clauses() IAdd_modify_drop_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_modify_drop_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAdd_modify_drop_column_clausesContext) +} + +func (s *Column_clausesContext) Rename_column_clause() IRename_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRename_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRename_column_clauseContext) +} + +func (s *Column_clausesContext) Modify_collection_retrieval() IModify_collection_retrievalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_collection_retrievalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_collection_retrievalContext) +} + +func (s *Column_clausesContext) Modify_lob_storage_clause() IModify_lob_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_storage_clauseContext) +} + +func (s *Column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_clauses(s) + } +} + +func (s *Column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_clauses(s) + } +} + +func (s *Column_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_clauses() (localctx IColumn_clausesContext) { + localctx = NewColumn_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1612, PlSqlParserRULE_column_clauses) + p.SetState(14662) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1926, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14658) + p.Add_modify_drop_column_clauses() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14659) + p.Rename_column_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14660) + p.Modify_collection_retrieval() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(14661) + p.Modify_lob_storage_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 +} + +// IModify_collection_retrievalContext is an interface to support dynamic dispatch. +type IModify_collection_retrievalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + Collection_item() ICollection_itemContext + RETURN() antlr.TerminalNode + AS() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsModify_collection_retrievalContext differentiates from other interfaces. + IsModify_collection_retrievalContext() +} + +type Modify_collection_retrievalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_collection_retrievalContext() *Modify_collection_retrievalContext { + var p = new(Modify_collection_retrievalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval + return p +} + +func InitEmptyModify_collection_retrievalContext(p *Modify_collection_retrievalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval +} + +func (*Modify_collection_retrievalContext) IsModify_collection_retrievalContext() {} + +func NewModify_collection_retrievalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_collection_retrievalContext { + var p = new(Modify_collection_retrievalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_collection_retrieval + + return p +} + +func (s *Modify_collection_retrievalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_collection_retrievalContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_collection_retrievalContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Modify_collection_retrievalContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Modify_collection_retrievalContext) Collection_item() ICollection_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_itemContext) +} + +func (s *Modify_collection_retrievalContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Modify_collection_retrievalContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Modify_collection_retrievalContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Modify_collection_retrievalContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Modify_collection_retrievalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_collection_retrievalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_collection_retrievalContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_collection_retrieval(s) + } +} + +func (s *Modify_collection_retrievalContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_collection_retrieval(s) + } +} + +func (s *Modify_collection_retrievalContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_collection_retrieval(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_collection_retrieval() (localctx IModify_collection_retrievalContext) { + localctx = NewModify_collection_retrievalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1614, PlSqlParserRULE_modify_collection_retrieval) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14664) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14665) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14666) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14667) + p.Collection_item() + } + { + p.SetState(14668) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14669) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14670) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCATOR || _la == PlSqlParserVALUE) { + 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 +} + +// ICollection_itemContext is an interface to support dynamic dispatch. +type ICollection_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + + // IsCollection_itemContext differentiates from other interfaces. + IsCollection_itemContext() +} + +type Collection_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollection_itemContext() *Collection_itemContext { + var p = new(Collection_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_item + return p +} + +func InitEmptyCollection_itemContext(p *Collection_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_item +} + +func (*Collection_itemContext) IsCollection_itemContext() {} + +func NewCollection_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collection_itemContext { + var p = new(Collection_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collection_item + + return p +} + +func (s *Collection_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collection_itemContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Collection_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collection_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collection_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollection_item(s) + } +} + +func (s *Collection_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollection_item(s) + } +} + +func (s *Collection_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCollection_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Collection_item() (localctx ICollection_itemContext) { + localctx = NewCollection_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1616, PlSqlParserRULE_collection_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14672) + p.Tableview_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 +} + +// IRename_column_clauseContext is an interface to support dynamic dispatch. +type IRename_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RENAME() antlr.TerminalNode + COLUMN() antlr.TerminalNode + Old_column_name() IOld_column_nameContext + TO() antlr.TerminalNode + New_column_name() INew_column_nameContext + + // IsRename_column_clauseContext differentiates from other interfaces. + IsRename_column_clauseContext() +} + +type Rename_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRename_column_clauseContext() *Rename_column_clauseContext { + var p = new(Rename_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_column_clause + return p +} + +func InitEmptyRename_column_clauseContext(p *Rename_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rename_column_clause +} + +func (*Rename_column_clauseContext) IsRename_column_clauseContext() {} + +func NewRename_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rename_column_clauseContext { + var p = new(Rename_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rename_column_clause + + return p +} + +func (s *Rename_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rename_column_clauseContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Rename_column_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Rename_column_clauseContext) Old_column_name() IOld_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_column_nameContext) +} + +func (s *Rename_column_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rename_column_clauseContext) New_column_name() INew_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_column_nameContext) +} + +func (s *Rename_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rename_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rename_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRename_column_clause(s) + } +} + +func (s *Rename_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRename_column_clause(s) + } +} + +func (s *Rename_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRename_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rename_column_clause() (localctx IRename_column_clauseContext) { + localctx = NewRename_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1618, PlSqlParserRULE_rename_column_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14674) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14675) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14676) + p.Old_column_name() + } + { + p.SetState(14677) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14678) + p.New_column_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 +} + +// IOld_column_nameContext is an interface to support dynamic dispatch. +type IOld_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsOld_column_nameContext differentiates from other interfaces. + IsOld_column_nameContext() +} + +type Old_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_column_nameContext() *Old_column_nameContext { + var p = new(Old_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_column_name + return p +} + +func InitEmptyOld_column_nameContext(p *Old_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_column_name +} + +func (*Old_column_nameContext) IsOld_column_nameContext() {} + +func NewOld_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_column_nameContext { + var p = new(Old_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_old_column_name + + return p +} + +func (s *Old_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_column_nameContext) 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 *Old_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOld_column_name(s) + } +} + +func (s *Old_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOld_column_name(s) + } +} + +func (s *Old_column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOld_column_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Old_column_name() (localctx IOld_column_nameContext) { + localctx = NewOld_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1620, PlSqlParserRULE_old_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14680) + p.Column_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 +} + +// INew_column_nameContext is an interface to support dynamic dispatch. +type INew_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsNew_column_nameContext differentiates from other interfaces. + IsNew_column_nameContext() +} + +type New_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_column_nameContext() *New_column_nameContext { + var p = new(New_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_column_name + return p +} + +func InitEmptyNew_column_nameContext(p *New_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_column_name +} + +func (*New_column_nameContext) IsNew_column_nameContext() {} + +func NewNew_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_column_nameContext { + var p = new(New_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_column_name + + return p +} + +func (s *New_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_column_nameContext) 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 *New_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_column_name(s) + } +} + +func (s *New_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_column_name(s) + } +} + +func (s *New_column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_column_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_column_name() (localctx INew_column_nameContext) { + localctx = NewNew_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1622, PlSqlParserRULE_new_column_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14682) + p.Column_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 +} + +// IAdd_modify_drop_column_clausesContext is an interface to support dynamic dispatch. +type IAdd_modify_drop_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConstraint_clauses() []IConstraint_clausesContext + Constraint_clauses(i int) IConstraint_clausesContext + AllAdd_column_clause() []IAdd_column_clauseContext + Add_column_clause(i int) IAdd_column_clauseContext + AllModify_column_clauses() []IModify_column_clausesContext + Modify_column_clauses(i int) IModify_column_clausesContext + AllDrop_column_clause() []IDrop_column_clauseContext + Drop_column_clause(i int) IDrop_column_clauseContext + + // IsAdd_modify_drop_column_clausesContext differentiates from other interfaces. + IsAdd_modify_drop_column_clausesContext() +} + +type Add_modify_drop_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_modify_drop_column_clausesContext() *Add_modify_drop_column_clausesContext { + var p = new(Add_modify_drop_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses + return p +} + +func InitEmptyAdd_modify_drop_column_clausesContext(p *Add_modify_drop_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses +} + +func (*Add_modify_drop_column_clausesContext) IsAdd_modify_drop_column_clausesContext() {} + +func NewAdd_modify_drop_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_modify_drop_column_clausesContext { + var p = new(Add_modify_drop_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_modify_drop_column_clauses + + return p +} + +func (s *Add_modify_drop_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_modify_drop_column_clausesContext) AllConstraint_clauses() []IConstraint_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraint_clausesContext); ok { + len++ + } + } + + tst := make([]IConstraint_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraint_clausesContext); ok { + tst[i] = t.(IConstraint_clausesContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Constraint_clauses(i int) IConstraint_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_clausesContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllAdd_column_clause() []IAdd_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_column_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_column_clauseContext); ok { + tst[i] = t.(IAdd_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Add_column_clause(i int) IAdd_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_column_clauseContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllModify_column_clauses() []IModify_column_clausesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_column_clausesContext); ok { + len++ + } + } + + tst := make([]IModify_column_clausesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_column_clausesContext); ok { + tst[i] = t.(IModify_column_clausesContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Modify_column_clauses(i int) IModify_column_clausesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_column_clausesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_column_clausesContext) +} + +func (s *Add_modify_drop_column_clausesContext) AllDrop_column_clause() []IDrop_column_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_column_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_column_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_column_clauseContext); ok { + tst[i] = t.(IDrop_column_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_modify_drop_column_clausesContext) Drop_column_clause(i int) IDrop_column_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_column_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_column_clauseContext) +} + +func (s *Add_modify_drop_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_modify_drop_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_modify_drop_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_modify_drop_column_clauses(s) + } +} + +func (s *Add_modify_drop_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_modify_drop_column_clauses(s) + } +} + +func (s *Add_modify_drop_column_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_modify_drop_column_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_modify_drop_column_clauses() (localctx IAdd_modify_drop_column_clausesContext) { + localctx = NewAdd_modify_drop_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1624, PlSqlParserRULE_add_modify_drop_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserADD || _la == PlSqlParserDROP || _la == PlSqlParserMODIFY || _la == PlSqlParserRENAME || _la == PlSqlParserSET { + p.SetState(14688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1927, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14684) + p.Constraint_clauses() + } + + case 2: + { + p.SetState(14685) + p.Add_column_clause() + } + + case 3: + { + p.SetState(14686) + p.Modify_column_clauses() + } + + case 4: + { + p.SetState(14687) + p.Drop_column_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_column_clauseContext is an interface to support dynamic dispatch. +type IDrop_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + UNUSED() antlr.TerminalNode + COLUMN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + AllCASCADE() []antlr.TerminalNode + CASCADE(i int) antlr.TerminalNode + AllCONSTRAINTS() []antlr.TerminalNode + CONSTRAINTS(i int) antlr.TerminalNode + AllINVALIDATE() []antlr.TerminalNode + INVALIDATE(i int) antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DROP() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + + // IsDrop_column_clauseContext differentiates from other interfaces. + IsDrop_column_clauseContext() +} + +type Drop_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_column_clauseContext() *Drop_column_clauseContext { + var p = new(Drop_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_column_clause + return p +} + +func InitEmptyDrop_column_clauseContext(p *Drop_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_column_clause +} + +func (*Drop_column_clauseContext) IsDrop_column_clauseContext() {} + +func NewDrop_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_column_clauseContext { + var p = new(Drop_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_column_clause + + return p +} + +func (s *Drop_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_column_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Drop_column_clauseContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Drop_column_clauseContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Drop_column_clauseContext) 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 *Drop_column_clauseContext) 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 *Drop_column_clauseContext) AllCASCADE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASCADE) +} + +func (s *Drop_column_clauseContext) CASCADE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, i) +} + +func (s *Drop_column_clauseContext) AllCONSTRAINTS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINTS) +} + +func (s *Drop_column_clauseContext) CONSTRAINTS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, i) +} + +func (s *Drop_column_clauseContext) AllINVALIDATE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINVALIDATE) +} + +func (s *Drop_column_clauseContext) INVALIDATE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, i) +} + +func (s *Drop_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_column_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_column_clauseContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECKPOINT, 0) +} + +func (s *Drop_column_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Drop_column_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Drop_column_clauseContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Drop_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_column_clause(s) + } +} + +func (s *Drop_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_column_clause(s) + } +} + +func (s *Drop_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_column_clause() (localctx IDrop_column_clauseContext) { + localctx = NewDrop_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1626, PlSqlParserRULE_drop_column_clause) + var _la int + + p.SetState(14754) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1939, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14692) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14693) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14707) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(14694) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14695) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14696) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14697) + p.Column_name() + } + p.SetState(14702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14698) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14699) + p.Column_name() + } + + p.SetState(14704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14705) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + p.SetState(14712) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(14709) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14710) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVALIDATE: + { + p.SetState(14711) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14716) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14717) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14731) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(14718) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14719) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14720) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14721) + p.Column_name() + } + p.SetState(14726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14722) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14723) + p.Column_name() + } + + p.SetState(14728) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14729) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14738) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCASCADE || _la == PlSqlParserINVALIDATE { + p.SetState(14736) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(14733) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14734) + p.Match(PlSqlParserCONSTRAINTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINVALIDATE: + { + p.SetState(14735) + p.Match(PlSqlParserINVALIDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14743) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHECKPOINT { + { + p.SetState(14741) + p.Match(PlSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14742) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14745) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14750) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNUSED: + { + p.SetState(14746) + p.Match(PlSqlParserUNUSED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14747) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLUMNS: + { + p.SetState(14748) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14749) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + { + p.SetState(14752) + p.Match(PlSqlParserCHECKPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14753) + p.Match(PlSqlParserUNSIGNED_INTEGER) + 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 +} + +// IModify_column_clausesContext is an interface to support dynamic dispatch. +type IModify_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllModify_col_properties() []IModify_col_propertiesContext + Modify_col_properties(i int) IModify_col_propertiesContext + RIGHT_PAREN() antlr.TerminalNode + AllModify_col_visibility() []IModify_col_visibilityContext + Modify_col_visibility(i int) IModify_col_visibilityContext + Modify_col_substitutable() IModify_col_substitutableContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModify_column_clausesContext differentiates from other interfaces. + IsModify_column_clausesContext() +} + +type Modify_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_column_clausesContext() *Modify_column_clausesContext { + var p = new(Modify_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_column_clauses + return p +} + +func InitEmptyModify_column_clausesContext(p *Modify_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_column_clauses +} + +func (*Modify_column_clausesContext) IsModify_column_clausesContext() {} + +func NewModify_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_column_clausesContext { + var p = new(Modify_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_column_clauses + + return p +} + +func (s *Modify_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_column_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_column_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Modify_column_clausesContext) AllModify_col_properties() []IModify_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IModify_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_col_propertiesContext); ok { + tst[i] = t.(IModify_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Modify_column_clausesContext) Modify_col_properties(i int) IModify_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_propertiesContext) +} + +func (s *Modify_column_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Modify_column_clausesContext) AllModify_col_visibility() []IModify_col_visibilityContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModify_col_visibilityContext); ok { + len++ + } + } + + tst := make([]IModify_col_visibilityContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModify_col_visibilityContext); ok { + tst[i] = t.(IModify_col_visibilityContext) + i++ + } + } + + return tst +} + +func (s *Modify_column_clausesContext) Modify_col_visibility(i int) IModify_col_visibilityContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_visibilityContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_visibilityContext) +} + +func (s *Modify_column_clausesContext) Modify_col_substitutable() IModify_col_substitutableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_col_substitutableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_col_substitutableContext) +} + +func (s *Modify_column_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Modify_column_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Modify_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_column_clauses(s) + } +} + +func (s *Modify_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_column_clauses(s) + } +} + +func (s *Modify_column_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_column_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_column_clauses() (localctx IModify_column_clausesContext) { + localctx = NewModify_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1628, PlSqlParserRULE_modify_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14756) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14778) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1941, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14757) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14758) + p.Modify_col_properties() + } + p.SetState(14763) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14759) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14760) + p.Modify_col_properties() + } + + p.SetState(14765) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14766) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(14768) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14769) + p.Modify_col_visibility() + } + + { + p.SetState(14770) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14771) + p.Modify_col_visibility() + } + + { + p.SetState(14773) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(14775) + p.Modify_col_properties() + } + + case 4: + { + p.SetState(14776) + p.Modify_col_visibility() + } + + case 5: + { + p.SetState(14777) + p.Modify_col_substitutable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_col_visibilityContext is an interface to support dynamic dispatch. +type IModify_col_visibilityContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + + // IsModify_col_visibilityContext differentiates from other interfaces. + IsModify_col_visibilityContext() +} + +type Modify_col_visibilityContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_visibilityContext() *Modify_col_visibilityContext { + var p = new(Modify_col_visibilityContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_visibility + return p +} + +func InitEmptyModify_col_visibilityContext(p *Modify_col_visibilityContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_visibility +} + +func (*Modify_col_visibilityContext) IsModify_col_visibilityContext() {} + +func NewModify_col_visibilityContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_visibilityContext { + var p = new(Modify_col_visibilityContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_visibility + + return p +} + +func (s *Modify_col_visibilityContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_visibilityContext) 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 *Modify_col_visibilityContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Modify_col_visibilityContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Modify_col_visibilityContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_visibilityContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_visibilityContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_visibility(s) + } +} + +func (s *Modify_col_visibilityContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_visibility(s) + } +} + +func (s *Modify_col_visibilityContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_col_visibility(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_col_visibility() (localctx IModify_col_visibilityContext) { + localctx = NewModify_col_visibilityContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1630, PlSqlParserRULE_modify_col_visibility) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14780) + p.Column_name() + } + { + p.SetState(14781) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + 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 +} + +// IModify_col_propertiesContext is an interface to support dynamic dispatch. +type IModify_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Datatype() IDatatypeContext + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + DECRYPT() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + Lob_storage_clause() ILob_storage_clauseContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsModify_col_propertiesContext differentiates from other interfaces. + IsModify_col_propertiesContext() +} + +type Modify_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_propertiesContext() *Modify_col_propertiesContext { + var p = new(Modify_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_properties + return p +} + +func InitEmptyModify_col_propertiesContext(p *Modify_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_properties +} + +func (*Modify_col_propertiesContext) IsModify_col_propertiesContext() {} + +func NewModify_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_propertiesContext { + var p = new(Modify_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_properties + + return p +} + +func (s *Modify_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_propertiesContext) 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 *Modify_col_propertiesContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Modify_col_propertiesContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Modify_col_propertiesContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *Modify_col_propertiesContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Modify_col_propertiesContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Modify_col_propertiesContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Modify_col_propertiesContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_col_propertiesContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Modify_col_propertiesContext) 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 *Modify_col_propertiesContext) 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 *Modify_col_propertiesContext) Lob_storage_clause() ILob_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Modify_col_propertiesContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Modify_col_propertiesContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Modify_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_properties(s) + } +} + +func (s *Modify_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_properties(s) + } +} + +func (s *Modify_col_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_col_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_col_properties() (localctx IModify_col_propertiesContext) { + localctx = NewModify_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1632, PlSqlParserRULE_modify_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14783) + p.Column_name() + } + p.SetState(14785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&68158609) != 0) || ((int64((_la-181)) & ^0x3f) == 0 && ((int64(1)<<(_la-181))&1048579) != 0) || ((int64((_la-339)) & ^0x3f) == 0 && ((int64(1)<<(_la-339))&98309) != 0) || _la == PlSqlParserDOUBLE || _la == PlSqlParserDSINTERVAL_UNCONSTRAINED || _la == PlSqlParserFLOAT || _la == PlSqlParserHOUR || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&385) != 0) || _la == PlSqlParserLONG || _la == PlSqlParserMINUTE || ((int64((_la-895)) & ^0x3f) == 0 && ((int64(1)<<(_la-895))&22814866800641) != 0) || ((int64((_la-1147)) & ^0x3f) == 0 && ((int64(1)<<(_la-1147))&35) != 0) || ((int64((_la-1309)) & ^0x3f) == 0 && ((int64(1)<<(_la-1309))&98305) != 0) || _la == PlSqlParserRAW || _la == PlSqlParserREAL || _la == PlSqlParserROWID || _la == PlSqlParserSECOND || ((int64((_la-1588)) & ^0x3f) == 0 && ((int64(1)<<(_la-1588))&8195) != 0) || _la == PlSqlParserSTRING || ((int64((_la-1996)) & ^0x3f) == 0 && ((int64(1)<<(_la-1996))&2959) != 0) || ((int64((_la-2098)) & ^0x3f) == 0 && ((int64(1)<<(_la-2098))&52776558133249) != 0) || _la == PlSqlParserYEAR || _la == PlSqlParserYMINTERVAL_UNCONSTRAINED { + { + p.SetState(14784) + p.Datatype() + } + + } + p.SetState(14789) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLLATE { + { + p.SetState(14787) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14788) + p.Column_collation_name() + } + + } + p.SetState(14797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(14791) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14794) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(14792) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14793) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14796) + p.Expression() + } + + } + p.SetState(14802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserENCRYPT: + { + p.SetState(14799) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14800) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(14801) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserADD, PlSqlParserCHECK, PlSqlParserCONSTRAINT, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserLOB, PlSqlParserMODIFY, PlSqlParserNOT, PlSqlParserNULL_, PlSqlParserPRIMARY, PlSqlParserREFERENCES, PlSqlParserRENAME, PlSqlParserSET, PlSqlParserUNIQUE, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSEMICOLON: + + default: + } + p.SetState(14807) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(14804) + p.Inline_constraint() + } + + p.SetState(14809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(14811) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOB { + { + p.SetState(14810) + p.Lob_storage_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 +} + +// IModify_col_substitutableContext is an interface to support dynamic dispatch. +type IModify_col_substitutableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMN() antlr.TerminalNode + Column_name() IColumn_nameContext + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + FORCE() antlr.TerminalNode + + // IsModify_col_substitutableContext differentiates from other interfaces. + IsModify_col_substitutableContext() +} + +type Modify_col_substitutableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_col_substitutableContext() *Modify_col_substitutableContext { + var p = new(Modify_col_substitutableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable + return p +} + +func InitEmptyModify_col_substitutableContext(p *Modify_col_substitutableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable +} + +func (*Modify_col_substitutableContext) IsModify_col_substitutableContext() {} + +func NewModify_col_substitutableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_col_substitutableContext { + var p = new(Modify_col_substitutableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_col_substitutable + + return p +} + +func (s *Modify_col_substitutableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_col_substitutableContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Modify_col_substitutableContext) 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 *Modify_col_substitutableContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Modify_col_substitutableContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Modify_col_substitutableContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Modify_col_substitutableContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Modify_col_substitutableContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Modify_col_substitutableContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Modify_col_substitutableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_col_substitutableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_col_substitutableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_col_substitutable(s) + } +} + +func (s *Modify_col_substitutableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_col_substitutable(s) + } +} + +func (s *Modify_col_substitutableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_col_substitutable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_col_substitutable() (localctx IModify_col_substitutableContext) { + localctx = NewModify_col_substitutableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1634, PlSqlParserRULE_modify_col_substitutable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14813) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14814) + p.Column_name() + } + p.SetState(14816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(14815) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(14818) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14819) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14820) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14821) + p.Match(PlSqlParserLEVELS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14823) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORCE { + { + p.SetState(14822) + p.Match(PlSqlParserFORCE) + 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 +} + +// IAdd_column_clauseContext is an interface to support dynamic dispatch. +type IAdd_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Column_properties() IColumn_propertiesContext + AllColumn_definition() []IColumn_definitionContext + Column_definition(i int) IColumn_definitionContext + AllVirtual_column_definition() []IVirtual_column_definitionContext + Virtual_column_definition(i int) IVirtual_column_definitionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_column_clauseContext differentiates from other interfaces. + IsAdd_column_clauseContext() +} + +type Add_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_column_clauseContext() *Add_column_clauseContext { + var p = new(Add_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_column_clause + return p +} + +func InitEmptyAdd_column_clauseContext(p *Add_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_column_clause +} + +func (*Add_column_clauseContext) IsAdd_column_clauseContext() {} + +func NewAdd_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_column_clauseContext { + var p = new(Add_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_column_clause + + return p +} + +func (s *Add_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_column_clauseContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Add_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Add_column_clauseContext) Column_properties() IColumn_propertiesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Add_column_clauseContext) AllColumn_definition() []IColumn_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_definitionContext); ok { + len++ + } + } + + tst := make([]IColumn_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_definitionContext); ok { + tst[i] = t.(IColumn_definitionContext) + i++ + } + } + + return tst +} + +func (s *Add_column_clauseContext) Column_definition(i int) IColumn_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_definitionContext) +} + +func (s *Add_column_clauseContext) AllVirtual_column_definition() []IVirtual_column_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + len++ + } + } + + tst := make([]IVirtual_column_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVirtual_column_definitionContext); ok { + tst[i] = t.(IVirtual_column_definitionContext) + i++ + } + } + + return tst +} + +func (s *Add_column_clauseContext) Virtual_column_definition(i int) IVirtual_column_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVirtual_column_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVirtual_column_definitionContext) +} + +func (s *Add_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_column_clause(s) + } +} + +func (s *Add_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_column_clause(s) + } +} + +func (s *Add_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_column_clause() (localctx IAdd_column_clauseContext) { + localctx = NewAdd_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1636, PlSqlParserRULE_add_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14825) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(14826) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14829) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1951, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14827) + p.Column_definition() + } + + case 2: + { + p.SetState(14828) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14831) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1952, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14832) + p.Column_definition() + } + + case 2: + { + p.SetState(14833) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14841) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(14845) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1954, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14843) + p.Column_definition() + } + + case 2: + { + p.SetState(14844) + p.Virtual_column_definition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(14850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMN || _la == PlSqlParserLOB || _la == PlSqlParserNESTED || _la == PlSqlParserVARRAY || _la == PlSqlParserXMLTYPE { + { + p.SetState(14849) + p.Column_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 +} + +// IAlter_varray_col_propertiesContext is an interface to support dynamic dispatch. +type IAlter_varray_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + VARRAY() antlr.TerminalNode + Varray_item() IVarray_itemContext + LEFT_PAREN() antlr.TerminalNode + Modify_lob_parameters() IModify_lob_parametersContext + RIGHT_PAREN() antlr.TerminalNode + + // IsAlter_varray_col_propertiesContext differentiates from other interfaces. + IsAlter_varray_col_propertiesContext() +} + +type Alter_varray_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAlter_varray_col_propertiesContext() *Alter_varray_col_propertiesContext { + var p = new(Alter_varray_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_varray_col_properties + return p +} + +func InitEmptyAlter_varray_col_propertiesContext(p *Alter_varray_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_alter_varray_col_properties +} + +func (*Alter_varray_col_propertiesContext) IsAlter_varray_col_propertiesContext() {} + +func NewAlter_varray_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Alter_varray_col_propertiesContext { + var p = new(Alter_varray_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_alter_varray_col_properties + + return p +} + +func (s *Alter_varray_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Alter_varray_col_propertiesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Alter_varray_col_propertiesContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Alter_varray_col_propertiesContext) Varray_item() IVarray_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_itemContext) +} + +func (s *Alter_varray_col_propertiesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Alter_varray_col_propertiesContext) Modify_lob_parameters() IModify_lob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_parametersContext) +} + +func (s *Alter_varray_col_propertiesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Alter_varray_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Alter_varray_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Alter_varray_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAlter_varray_col_properties(s) + } +} + +func (s *Alter_varray_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAlter_varray_col_properties(s) + } +} + +func (s *Alter_varray_col_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAlter_varray_col_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Alter_varray_col_properties() (localctx IAlter_varray_col_propertiesContext) { + localctx = NewAlter_varray_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1638, PlSqlParserRULE_alter_varray_col_properties) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14852) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14853) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14854) + p.Varray_item() + } + { + p.SetState(14855) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14856) + p.Modify_lob_parameters() + } + { + p.SetState(14857) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_col_propertiesContext is an interface to support dynamic dispatch. +type IVarray_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARRAY() antlr.TerminalNode + Varray_item() IVarray_itemContext + Varray_storage_clause() IVarray_storage_clauseContext + Substitutable_column_clause() ISubstitutable_column_clauseContext + + // IsVarray_col_propertiesContext differentiates from other interfaces. + IsVarray_col_propertiesContext() +} + +type Varray_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_col_propertiesContext() *Varray_col_propertiesContext { + var p = new(Varray_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_col_properties + return p +} + +func InitEmptyVarray_col_propertiesContext(p *Varray_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_col_properties +} + +func (*Varray_col_propertiesContext) IsVarray_col_propertiesContext() {} + +func NewVarray_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_col_propertiesContext { + var p = new(Varray_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_col_properties + + return p +} + +func (s *Varray_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_col_propertiesContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Varray_col_propertiesContext) Varray_item() IVarray_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_itemContext) +} + +func (s *Varray_col_propertiesContext) Varray_storage_clause() IVarray_storage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_storage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_storage_clauseContext) +} + +func (s *Varray_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Varray_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_col_properties(s) + } +} + +func (s *Varray_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_col_properties(s) + } +} + +func (s *Varray_col_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVarray_col_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Varray_col_properties() (localctx IVarray_col_propertiesContext) { + localctx = NewVarray_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1640, PlSqlParserRULE_varray_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14859) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14860) + p.Varray_item() + } + p.SetState(14866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1958, p.GetParserRuleContext()) { + case 1: + p.SetState(14862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserIS || _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(14861) + p.Substitutable_column_clause() + } + + } + { + p.SetState(14864) + p.Varray_storage_clause() + } + + case 2: + { + p.SetState(14865) + p.Substitutable_column_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 +} + +// IVarray_storage_clauseContext is an interface to support dynamic dispatch. +type IVarray_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + LOB() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Lob_storage_parameters() ILob_storage_parametersContext + RIGHT_PAREN() antlr.TerminalNode + Lob_segname() ILob_segnameContext + SECUREFILE() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + + // IsVarray_storage_clauseContext differentiates from other interfaces. + IsVarray_storage_clauseContext() +} + +type Varray_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_storage_clauseContext() *Varray_storage_clauseContext { + var p = new(Varray_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_storage_clause + return p +} + +func InitEmptyVarray_storage_clauseContext(p *Varray_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_storage_clause +} + +func (*Varray_storage_clauseContext) IsVarray_storage_clauseContext() {} + +func NewVarray_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_storage_clauseContext { + var p = new(Varray_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_storage_clause + + return p +} + +func (s *Varray_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_storage_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Varray_storage_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Varray_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Varray_storage_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Varray_storage_clauseContext) Lob_storage_parameters() ILob_storage_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Varray_storage_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Varray_storage_clauseContext) Lob_segname() ILob_segnameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Varray_storage_clauseContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Varray_storage_clauseContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Varray_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_storage_clause(s) + } +} + +func (s *Varray_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_storage_clause(s) + } +} + +func (s *Varray_storage_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVarray_storage_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Varray_storage_clause() (localctx IVarray_storage_clauseContext) { + localctx = NewVarray_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1642, PlSqlParserRULE_varray_storage_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14868) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14869) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE { + { + p.SetState(14870) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(14873) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1961, p.GetParserRuleContext()) { + case 1: + p.SetState(14875) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || _la == PlSqlParserPERIOD || _la == PlSqlParserREGULAR_ID { + { + p.SetState(14874) + p.Lob_segname() + } + + } + { + p.SetState(14877) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14878) + p.Lob_storage_parameters() + } + { + p.SetState(14879) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(14881) + p.Lob_segname() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILob_segnameContext is an interface to support dynamic dispatch. +type ILob_segnameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsLob_segnameContext differentiates from other interfaces. + IsLob_segnameContext() +} + +type Lob_segnameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_segnameContext() *Lob_segnameContext { + var p = new(Lob_segnameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_segname + return p +} + +func InitEmptyLob_segnameContext(p *Lob_segnameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_segname +} + +func (*Lob_segnameContext) IsLob_segnameContext() {} + +func NewLob_segnameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_segnameContext { + var p = new(Lob_segnameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_segname + + return p +} + +func (s *Lob_segnameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_segnameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Lob_segnameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_segnameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_segnameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_segname(s) + } +} + +func (s *Lob_segnameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_segname(s) + } +} + +func (s *Lob_segnameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_segname(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_segname() (localctx ILob_segnameContext) { + localctx = NewLob_segnameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1644, PlSqlParserRULE_lob_segname) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14884) + p.Regular_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 +} + +// ILob_itemContext is an interface to support dynamic dispatch. +type ILob_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + Quoted_string() IQuoted_stringContext + + // IsLob_itemContext differentiates from other interfaces. + IsLob_itemContext() +} + +type Lob_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_itemContext() *Lob_itemContext { + var p = new(Lob_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_item + return p +} + +func InitEmptyLob_itemContext(p *Lob_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_item +} + +func (*Lob_itemContext) IsLob_itemContext() {} + +func NewLob_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_itemContext { + var p = new(Lob_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_item + + return p +} + +func (s *Lob_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_itemContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Lob_itemContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Lob_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_item(s) + } +} + +func (s *Lob_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_item(s) + } +} + +func (s *Lob_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_item() (localctx ILob_itemContext) { + localctx = NewLob_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1646, PlSqlParserRULE_lob_item) + p.SetState(14888) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1962, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14886) + p.Regular_id() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14887) + p.Quoted_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 +} + +// ILob_storage_parametersContext is an interface to support dynamic dispatch. +type ILob_storage_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTablespace_name returns the tablespace_name rule contexts. + GetTablespace_name() IId_expressionContext + + // SetTablespace_name sets the tablespace_name rule contexts. + SetTablespace_name(IId_expressionContext) + + // Getter signatures + TABLESPACE() antlr.TerminalNode + Id_expression() IId_expressionContext + Lob_parameters() ILob_parametersContext + Storage_clause() IStorage_clauseContext + + // IsLob_storage_parametersContext differentiates from other interfaces. + IsLob_storage_parametersContext() +} + +type Lob_storage_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + tablespace_name IId_expressionContext +} + +func NewEmptyLob_storage_parametersContext() *Lob_storage_parametersContext { + var p = new(Lob_storage_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters + return p +} + +func InitEmptyLob_storage_parametersContext(p *Lob_storage_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters +} + +func (*Lob_storage_parametersContext) IsLob_storage_parametersContext() {} + +func NewLob_storage_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_storage_parametersContext { + var p = new(Lob_storage_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_storage_parameters + + return p +} + +func (s *Lob_storage_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_storage_parametersContext) GetTablespace_name() IId_expressionContext { + return s.tablespace_name +} + +func (s *Lob_storage_parametersContext) SetTablespace_name(v IId_expressionContext) { + s.tablespace_name = v +} + +func (s *Lob_storage_parametersContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Lob_storage_parametersContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Lob_storage_parametersContext) Lob_parameters() ILob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_parametersContext) +} + +func (s *Lob_storage_parametersContext) Storage_clause() IStorage_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Lob_storage_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_storage_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_storage_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_storage_parameters(s) + } +} + +func (s *Lob_storage_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_storage_parameters(s) + } +} + +func (s *Lob_storage_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_storage_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_storage_parameters() (localctx ILob_storage_parametersContext) { + localctx = NewLob_storage_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1648, PlSqlParserRULE_lob_storage_parameters) + p.SetState(14897) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLESPACE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14890) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14891) + + var _x = p.Id_expression() + + localctx.(*Lob_storage_parametersContext).tablespace_name = _x + } + + case PlSqlParserCACHE, PlSqlParserCHUNK, PlSqlParserCOMPRESS, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserFREEPOOLS, PlSqlParserKEEP_DUPLICATES, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserPCTVERSION, PlSqlParserRETENTION: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(14892) + p.Lob_parameters() + } + p.SetState(14894) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1963, p.GetParserRuleContext()) == 1 { + { + p.SetState(14893) + p.Storage_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSTORAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(14896) + p.Storage_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 +} + +// ILob_storage_clauseContext is an interface to support dynamic dispatch. +type ILob_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_item() []ILob_itemContext + Lob_item(i int) ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + AllLob_storage_parameters() []ILob_storage_parametersContext + Lob_storage_parameters(i int) ILob_storage_parametersContext + + // IsLob_storage_clauseContext differentiates from other interfaces. + IsLob_storage_clauseContext() +} + +type Lob_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_storage_clauseContext() *Lob_storage_clauseContext { + var p = new(Lob_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_clause + return p +} + +func InitEmptyLob_storage_clauseContext(p *Lob_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_storage_clause +} + +func (*Lob_storage_clauseContext) IsLob_storage_clauseContext() {} + +func NewLob_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_storage_clauseContext { + var p = new(Lob_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_storage_clause + + return p +} + +func (s *Lob_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_storage_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_storage_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_storage_clauseContext) AllLob_item() []ILob_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_itemContext); ok { + len++ + } + } + + tst := make([]ILob_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_itemContext); ok { + tst[i] = t.(ILob_itemContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_item(i int) ILob_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_storage_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_storage_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_storage_clauseContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_storage_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_storage_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Lob_storage_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Lob_storage_clauseContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_storage_clauseContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Lob_storage_clauseContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Lob_storage_clauseContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Lob_storage_clauseContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Lob_storage_clauseContext) AllLob_storage_parameters() []ILob_storage_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + len++ + } + } + + tst := make([]ILob_storage_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_parametersContext); ok { + tst[i] = t.(ILob_storage_parametersContext) + i++ + } + } + + return tst +} + +func (s *Lob_storage_clauseContext) Lob_storage_parameters(i int) ILob_storage_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Lob_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_storage_clause(s) + } +} + +func (s *Lob_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_storage_clause(s) + } +} + +func (s *Lob_storage_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_storage_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_storage_clause() (localctx ILob_storage_clauseContext) { + localctx = NewLob_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1650, PlSqlParserRULE_lob_storage_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14899) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1972, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14900) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14901) + p.Lob_item() + } + p.SetState(14906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(14902) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14903) + p.Lob_item() + } + + p.SetState(14908) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14909) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14910) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14911) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14921) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBASICFILE, PlSqlParserSECUREFILE: + { + p.SetState(14912) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(14913) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14917) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCHUNK || _la == PlSqlParserCOMPRESS || ((int64((_la-361)) & ^0x3f) == 0 && ((int64(1)<<(_la-361))&137438953475) != 0) || _la == PlSqlParserENABLE || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserRETENTION || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(14914) + p.Lob_storage_parameters() + } + + p.SetState(14919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14920) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14923) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1968, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(14925) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14926) + p.Lob_item() + } + { + p.SetState(14927) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14928) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14929) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(14940) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1970, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14930) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(14931) + p.Lob_segname() + } + + case 3: + { + p.SetState(14932) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(14936) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCHUNK || _la == PlSqlParserCOMPRESS || ((int64((_la-361)) & ^0x3f) == 0 && ((int64(1)<<(_la-361))&137438953475) != 0) || _la == PlSqlParserENABLE || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserRETENTION || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE { + { + p.SetState(14933) + p.Lob_storage_parameters() + } + + p.SetState(14938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(14939) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(14942) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1971, 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 +} + +// IModify_lob_storage_clauseContext is an interface to support dynamic dispatch. +type IModify_lob_storage_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODIFY() antlr.TerminalNode + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + Lob_item() ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Modify_lob_parameters() IModify_lob_parametersContext + + // IsModify_lob_storage_clauseContext differentiates from other interfaces. + IsModify_lob_storage_clauseContext() +} + +type Modify_lob_storage_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_lob_storage_clauseContext() *Modify_lob_storage_clauseContext { + var p = new(Modify_lob_storage_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause + return p +} + +func InitEmptyModify_lob_storage_clauseContext(p *Modify_lob_storage_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause +} + +func (*Modify_lob_storage_clauseContext) IsModify_lob_storage_clauseContext() {} + +func NewModify_lob_storage_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_lob_storage_clauseContext { + var p = new(Modify_lob_storage_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_lob_storage_clause + + return p +} + +func (s *Modify_lob_storage_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_lob_storage_clauseContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Modify_lob_storage_clauseContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Modify_lob_storage_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Modify_lob_storage_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Modify_lob_storage_clauseContext) Lob_item() ILob_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Modify_lob_storage_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Modify_lob_storage_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Modify_lob_storage_clauseContext) Modify_lob_parameters() IModify_lob_parametersContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModify_lob_parametersContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModify_lob_parametersContext) +} + +func (s *Modify_lob_storage_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_lob_storage_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_lob_storage_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_lob_storage_clause(s) + } +} + +func (s *Modify_lob_storage_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_lob_storage_clause(s) + } +} + +func (s *Modify_lob_storage_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_lob_storage_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_lob_storage_clause() (localctx IModify_lob_storage_clauseContext) { + localctx = NewModify_lob_storage_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1652, PlSqlParserRULE_modify_lob_storage_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(14946) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14947) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14948) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14949) + p.Lob_item() + } + { + p.SetState(14950) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14951) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14952) + p.Modify_lob_parameters() + } + { + p.SetState(14953) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModify_lob_parametersContext is an interface to support dynamic dispatch. +type IModify_lob_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStorage_clause() []IStorage_clauseContext + Storage_clause(i int) IStorage_clauseContext + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllREBUILD() []antlr.TerminalNode + REBUILD(i int) antlr.TerminalNode + AllFREEPOOLS() []antlr.TerminalNode + FREEPOOLS(i int) antlr.TerminalNode + AllLob_retention_clause() []ILob_retention_clauseContext + Lob_retention_clause(i int) ILob_retention_clauseContext + AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext + Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext + AllLob_compression_clause() []ILob_compression_clauseContext + Lob_compression_clause(i int) ILob_compression_clauseContext + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllEncryption_spec() []IEncryption_specContext + Encryption_spec(i int) IEncryption_specContext + AllDECRYPT() []antlr.TerminalNode + DECRYPT(i int) antlr.TerminalNode + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllAllocate_extent_clause() []IAllocate_extent_clauseContext + Allocate_extent_clause(i int) IAllocate_extent_clauseContext + AllShrink_clause() []IShrink_clauseContext + Shrink_clause(i int) IShrink_clauseContext + AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext + Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext + AllPCTVERSION() []antlr.TerminalNode + PCTVERSION(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllREADS() []antlr.TerminalNode + READS(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsModify_lob_parametersContext differentiates from other interfaces. + IsModify_lob_parametersContext() +} + +type Modify_lob_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModify_lob_parametersContext() *Modify_lob_parametersContext { + var p = new(Modify_lob_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters + return p +} + +func InitEmptyModify_lob_parametersContext(p *Modify_lob_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters +} + +func (*Modify_lob_parametersContext) IsModify_lob_parametersContext() {} + +func NewModify_lob_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Modify_lob_parametersContext { + var p = new(Modify_lob_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_modify_lob_parameters + + return p +} + +func (s *Modify_lob_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Modify_lob_parametersContext) AllStorage_clause() []IStorage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStorage_clauseContext); ok { + len++ + } + } + + tst := make([]IStorage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStorage_clauseContext); ok { + tst[i] = t.(IStorage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Storage_clause(i int) IStorage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStorage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStorage_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Modify_lob_parametersContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Modify_lob_parametersContext) AllREBUILD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREBUILD) +} + +func (s *Modify_lob_parametersContext) REBUILD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, i) +} + +func (s *Modify_lob_parametersContext) AllFREEPOOLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREEPOOLS) +} + +func (s *Modify_lob_parametersContext) FREEPOOLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, i) +} + +func (s *Modify_lob_parametersContext) AllLob_retention_clause() []ILob_retention_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_retention_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_retention_clauseContext); ok { + tst[i] = t.(ILob_retention_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_retention_clause(i int) ILob_retention_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_retention_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_deduplicate_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_deduplicate_clauseContext); ok { + tst[i] = t.(ILob_deduplicate_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_deduplicate_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllLob_compression_clause() []ILob_compression_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_compression_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_compression_clauseContext); ok { + tst[i] = t.(ILob_compression_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Lob_compression_clause(i int) ILob_compression_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_compression_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Modify_lob_parametersContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Modify_lob_parametersContext) AllEncryption_spec() []IEncryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEncryption_specContext); ok { + len++ + } + } + + tst := make([]IEncryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEncryption_specContext); ok { + tst[i] = t.(IEncryption_specContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Encryption_spec(i int) IEncryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Modify_lob_parametersContext) AllDECRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDECRYPT) +} + +func (s *Modify_lob_parametersContext) DECRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, i) +} + +func (s *Modify_lob_parametersContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Modify_lob_parametersContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Modify_lob_parametersContext) AllAllocate_extent_clause() []IAllocate_extent_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + len++ + } + } + + tst := make([]IAllocate_extent_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAllocate_extent_clauseContext); ok { + tst[i] = t.(IAllocate_extent_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Allocate_extent_clause(i int) IAllocate_extent_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAllocate_extent_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAllocate_extent_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllShrink_clause() []IShrink_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IShrink_clauseContext); ok { + len++ + } + } + + tst := make([]IShrink_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IShrink_clauseContext); ok { + tst[i] = t.(IShrink_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Shrink_clause(i int) IShrink_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IShrink_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IShrink_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllDeallocate_unused_clause() []IDeallocate_unused_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + len++ + } + } + + tst := make([]IDeallocate_unused_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeallocate_unused_clauseContext); ok { + tst[i] = t.(IDeallocate_unused_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Deallocate_unused_clause(i int) IDeallocate_unused_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeallocate_unused_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeallocate_unused_clauseContext) +} + +func (s *Modify_lob_parametersContext) AllPCTVERSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTVERSION) +} + +func (s *Modify_lob_parametersContext) PCTVERSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, i) +} + +func (s *Modify_lob_parametersContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Modify_lob_parametersContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Modify_lob_parametersContext) AllREADS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREADS) +} + +func (s *Modify_lob_parametersContext) READS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, i) +} + +func (s *Modify_lob_parametersContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Modify_lob_parametersContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Modify_lob_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Modify_lob_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Modify_lob_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModify_lob_parameters(s) + } +} + +func (s *Modify_lob_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModify_lob_parameters(s) + } +} + +func (s *Modify_lob_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModify_lob_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Modify_lob_parameters() (localctx IModify_lob_parametersContext) { + localctx = NewModify_lob_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1654, PlSqlParserRULE_modify_lob_parameters) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(14979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserALLOCATE || _la == PlSqlParserCACHE || _la == PlSqlParserCOMPRESS || ((int64((_la-351)) & ^0x3f) == 0 && ((int64(1)<<(_la-351))&3073) != 0) || _la == PlSqlParserENCRYPT || _la == PlSqlParserFREEPOOLS || _la == PlSqlParserKEEP_DUPLICATES || _la == PlSqlParserNOCACHE || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserPCTVERSION || _la == PlSqlParserREBUILD || _la == PlSqlParserRETENTION || _la == PlSqlParserSHRINK || _la == PlSqlParserSTORAGE { + p.SetState(14979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1975, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14955) + p.Storage_clause() + } + + case 2: + { + p.SetState(14956) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFREEPOOLS || _la == PlSqlParserPCTVERSION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14957) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(14958) + p.Match(PlSqlParserREBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14959) + p.Match(PlSqlParserFREEPOOLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(14960) + p.Lob_retention_clause() + } + + case 5: + { + p.SetState(14961) + p.Lob_deduplicate_clause() + } + + case 6: + { + p.SetState(14962) + p.Lob_compression_clause() + } + + case 7: + { + p.SetState(14963) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14964) + p.Encryption_spec() + } + + case 8: + { + p.SetState(14965) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + { + p.SetState(14966) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.SetState(14971) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1973, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14967) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(14968) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(14969) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14970) + p.Match(PlSqlParserREADS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(14974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING { + { + p.SetState(14973) + p.Logging_clause() + } + + } + + case 11: + { + p.SetState(14976) + p.Allocate_extent_clause() + } + + case 12: + { + p.SetState(14977) + p.Shrink_clause() + } + + case 13: + { + p.SetState(14978) + p.Deallocate_unused_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(14981) + 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 +} + +// ILob_parametersContext is an interface to support dynamic dispatch. +type ILob_parametersContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSTORAGE() []antlr.TerminalNode + STORAGE(i int) antlr.TerminalNode + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllROW() []antlr.TerminalNode + ROW(i int) antlr.TerminalNode + AllCHUNK() []antlr.TerminalNode + CHUNK(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + AllPCTVERSION() []antlr.TerminalNode + PCTVERSION(i int) antlr.TerminalNode + AllFREEPOOLS() []antlr.TerminalNode + FREEPOOLS(i int) antlr.TerminalNode + AllLob_retention_clause() []ILob_retention_clauseContext + Lob_retention_clause(i int) ILob_retention_clauseContext + AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext + Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext + AllLob_compression_clause() []ILob_compression_clauseContext + Lob_compression_clause(i int) ILob_compression_clauseContext + AllENCRYPT() []antlr.TerminalNode + ENCRYPT(i int) antlr.TerminalNode + AllEncryption_spec() []IEncryption_specContext + Encryption_spec(i int) IEncryption_specContext + AllDECRYPT() []antlr.TerminalNode + DECRYPT(i int) antlr.TerminalNode + AllENABLE() []antlr.TerminalNode + ENABLE(i int) antlr.TerminalNode + AllDISABLE() []antlr.TerminalNode + DISABLE(i int) antlr.TerminalNode + AllCACHE() []antlr.TerminalNode + CACHE(i int) antlr.TerminalNode + AllNOCACHE() []antlr.TerminalNode + NOCACHE(i int) antlr.TerminalNode + AllREADS() []antlr.TerminalNode + READS(i int) antlr.TerminalNode + AllLogging_clause() []ILogging_clauseContext + Logging_clause(i int) ILogging_clauseContext + + // IsLob_parametersContext differentiates from other interfaces. + IsLob_parametersContext() +} + +type Lob_parametersContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_parametersContext() *Lob_parametersContext { + var p = new(Lob_parametersContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_parameters + return p +} + +func InitEmptyLob_parametersContext(p *Lob_parametersContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_parameters +} + +func (*Lob_parametersContext) IsLob_parametersContext() {} + +func NewLob_parametersContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_parametersContext { + var p = new(Lob_parametersContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_parameters + + return p +} + +func (s *Lob_parametersContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_parametersContext) AllSTORAGE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSTORAGE) +} + +func (s *Lob_parametersContext) STORAGE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, i) +} + +func (s *Lob_parametersContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *Lob_parametersContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *Lob_parametersContext) AllROW() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserROW) +} + +func (s *Lob_parametersContext) ROW(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, i) +} + +func (s *Lob_parametersContext) AllCHUNK() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHUNK) +} + +func (s *Lob_parametersContext) CHUNK(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHUNK, i) +} + +func (s *Lob_parametersContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Lob_parametersContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Lob_parametersContext) AllPCTVERSION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPCTVERSION) +} + +func (s *Lob_parametersContext) PCTVERSION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, i) +} + +func (s *Lob_parametersContext) AllFREEPOOLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFREEPOOLS) +} + +func (s *Lob_parametersContext) FREEPOOLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, i) +} + +func (s *Lob_parametersContext) AllLob_retention_clause() []ILob_retention_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_retention_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_retention_clauseContext); ok { + tst[i] = t.(ILob_retention_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_retention_clause(i int) ILob_retention_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_retention_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_retention_clauseContext) +} + +func (s *Lob_parametersContext) AllLob_deduplicate_clause() []ILob_deduplicate_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_deduplicate_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_deduplicate_clauseContext); ok { + tst[i] = t.(ILob_deduplicate_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_deduplicate_clause(i int) ILob_deduplicate_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_deduplicate_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_deduplicate_clauseContext) +} + +func (s *Lob_parametersContext) AllLob_compression_clause() []ILob_compression_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_compression_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_compression_clauseContext); ok { + tst[i] = t.(ILob_compression_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Lob_compression_clause(i int) ILob_compression_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_compression_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_compression_clauseContext) +} + +func (s *Lob_parametersContext) AllENCRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENCRYPT) +} + +func (s *Lob_parametersContext) ENCRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, i) +} + +func (s *Lob_parametersContext) AllEncryption_spec() []IEncryption_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEncryption_specContext); ok { + len++ + } + } + + tst := make([]IEncryption_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEncryption_specContext); ok { + tst[i] = t.(IEncryption_specContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Encryption_spec(i int) IEncryption_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Lob_parametersContext) AllDECRYPT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDECRYPT) +} + +func (s *Lob_parametersContext) DECRYPT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, i) +} + +func (s *Lob_parametersContext) AllENABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserENABLE) +} + +func (s *Lob_parametersContext) ENABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, i) +} + +func (s *Lob_parametersContext) AllDISABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDISABLE) +} + +func (s *Lob_parametersContext) DISABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, i) +} + +func (s *Lob_parametersContext) AllCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCACHE) +} + +func (s *Lob_parametersContext) CACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, i) +} + +func (s *Lob_parametersContext) AllNOCACHE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCACHE) +} + +func (s *Lob_parametersContext) NOCACHE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, i) +} + +func (s *Lob_parametersContext) AllREADS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserREADS) +} + +func (s *Lob_parametersContext) READS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, i) +} + +func (s *Lob_parametersContext) AllLogging_clause() []ILogging_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogging_clauseContext); ok { + len++ + } + } + + tst := make([]ILogging_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogging_clauseContext); ok { + tst[i] = t.(ILogging_clauseContext) + i++ + } + } + + return tst +} + +func (s *Lob_parametersContext) Logging_clause(i int) ILogging_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogging_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogging_clauseContext) +} + +func (s *Lob_parametersContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_parametersContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_parametersContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_parameters(s) + } +} + +func (s *Lob_parametersContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_parameters(s) + } +} + +func (s *Lob_parametersContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_parameters(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_parameters() (localctx ILob_parametersContext) { + localctx = NewLob_parametersContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1656, PlSqlParserRULE_lob_parameters) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15008) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDISABLE, PlSqlParserENABLE: + { + p.SetState(14983) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISABLE || _la == PlSqlParserENABLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(14984) + p.Match(PlSqlParserSTORAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14985) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14986) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHUNK: + { + p.SetState(14987) + p.Match(PlSqlParserCHUNK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14988) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPCTVERSION: + { + p.SetState(14989) + p.Match(PlSqlParserPCTVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14990) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFREEPOOLS: + { + p.SetState(14991) + p.Match(PlSqlParserFREEPOOLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14992) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRETENTION: + { + p.SetState(14993) + p.Lob_retention_clause() + } + + case PlSqlParserDEDUPLICATE, PlSqlParserKEEP_DUPLICATES: + { + p.SetState(14994) + p.Lob_deduplicate_clause() + } + + case PlSqlParserCOMPRESS, PlSqlParserNOCOMPRESS: + { + p.SetState(14995) + p.Lob_compression_clause() + } + + case PlSqlParserENCRYPT: + { + p.SetState(14996) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(14997) + p.Encryption_spec() + } + + case PlSqlParserDECRYPT: + { + p.SetState(14998) + p.Match(PlSqlParserDECRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE, PlSqlParserNOCACHE: + p.SetState(15003) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1977, p.GetParserRuleContext()) { + case 1: + { + p.SetState(14999) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(15000) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(15001) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15002) + p.Match(PlSqlParserREADS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserLOGGING || _la == PlSqlParserNOLOGGING { + { + p.SetState(15005) + p.Logging_clause() + } + + } + + 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 + } + + p.SetState(15010) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1980, 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 +} + +// ILob_deduplicate_clauseContext is an interface to support dynamic dispatch. +type ILob_deduplicate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEDUPLICATE() antlr.TerminalNode + KEEP_DUPLICATES() antlr.TerminalNode + + // IsLob_deduplicate_clauseContext differentiates from other interfaces. + IsLob_deduplicate_clauseContext() +} + +type Lob_deduplicate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_deduplicate_clauseContext() *Lob_deduplicate_clauseContext { + var p = new(Lob_deduplicate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause + return p +} + +func InitEmptyLob_deduplicate_clauseContext(p *Lob_deduplicate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause +} + +func (*Lob_deduplicate_clauseContext) IsLob_deduplicate_clauseContext() {} + +func NewLob_deduplicate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_deduplicate_clauseContext { + var p = new(Lob_deduplicate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_deduplicate_clause + + return p +} + +func (s *Lob_deduplicate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_deduplicate_clauseContext) DEDUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEDUPLICATE, 0) +} + +func (s *Lob_deduplicate_clauseContext) KEEP_DUPLICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP_DUPLICATES, 0) +} + +func (s *Lob_deduplicate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_deduplicate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_deduplicate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_deduplicate_clause(s) + } +} + +func (s *Lob_deduplicate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_deduplicate_clause(s) + } +} + +func (s *Lob_deduplicate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_deduplicate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_deduplicate_clause() (localctx ILob_deduplicate_clauseContext) { + localctx = NewLob_deduplicate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1658, PlSqlParserRULE_lob_deduplicate_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15012) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEDUPLICATE || _la == PlSqlParserKEEP_DUPLICATES) { + 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 +} + +// ILob_compression_clauseContext is an interface to support dynamic dispatch. +type ILob_compression_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NOCOMPRESS() antlr.TerminalNode + COMPRESS() antlr.TerminalNode + HIGH() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + LOW() antlr.TerminalNode + + // IsLob_compression_clauseContext differentiates from other interfaces. + IsLob_compression_clauseContext() +} + +type Lob_compression_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_compression_clauseContext() *Lob_compression_clauseContext { + var p = new(Lob_compression_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_compression_clause + return p +} + +func InitEmptyLob_compression_clauseContext(p *Lob_compression_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_compression_clause +} + +func (*Lob_compression_clauseContext) IsLob_compression_clauseContext() {} + +func NewLob_compression_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_compression_clauseContext { + var p = new(Lob_compression_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_compression_clause + + return p +} + +func (s *Lob_compression_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_compression_clauseContext) NOCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOMPRESS, 0) +} + +func (s *Lob_compression_clauseContext) COMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPRESS, 0) +} + +func (s *Lob_compression_clauseContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Lob_compression_clauseContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Lob_compression_clauseContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Lob_compression_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_compression_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_compression_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_compression_clause(s) + } +} + +func (s *Lob_compression_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_compression_clause(s) + } +} + +func (s *Lob_compression_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_compression_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_compression_clause() (localctx ILob_compression_clauseContext) { + localctx = NewLob_compression_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1660, PlSqlParserRULE_lob_compression_clause) + var _la int + + p.SetState(15019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOCOMPRESS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15014) + p.Match(PlSqlParserNOCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOMPRESS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15015) + p.Match(PlSqlParserCOMPRESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM { + { + p.SetState(15016) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIGH || _la == PlSqlParserLOW || _la == PlSqlParserMEDIUM) { + 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 +} + +// ILob_retention_clauseContext is an interface to support dynamic dispatch. +type ILob_retention_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETENTION() antlr.TerminalNode + MAX() antlr.TerminalNode + MIN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AUTO() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsLob_retention_clauseContext differentiates from other interfaces. + IsLob_retention_clauseContext() +} + +type Lob_retention_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_retention_clauseContext() *Lob_retention_clauseContext { + var p = new(Lob_retention_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_retention_clause + return p +} + +func InitEmptyLob_retention_clauseContext(p *Lob_retention_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_retention_clause +} + +func (*Lob_retention_clauseContext) IsLob_retention_clauseContext() {} + +func NewLob_retention_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_retention_clauseContext { + var p = new(Lob_retention_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_retention_clause + + return p +} + +func (s *Lob_retention_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_retention_clauseContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Lob_retention_clauseContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Lob_retention_clauseContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Lob_retention_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Lob_retention_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Lob_retention_clauseContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Lob_retention_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_retention_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_retention_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_retention_clause(s) + } +} + +func (s *Lob_retention_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_retention_clause(s) + } +} + +func (s *Lob_retention_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_retention_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_retention_clause() (localctx ILob_retention_clauseContext) { + localctx = NewLob_retention_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1662, PlSqlParserRULE_lob_retention_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15021) + p.Match(PlSqlParserRETENTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserMAX: + { + p.SetState(15022) + p.Match(PlSqlParserMAX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMIN: + { + p.SetState(15023) + p.Match(PlSqlParserMIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15024) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTO: + { + p.SetState(15025) + p.Match(PlSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNONE: + { + p.SetState(15026) + p.Match(PlSqlParserNONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserALLOCATE, PlSqlParserCACHE, PlSqlParserCHUNK, PlSqlParserCOMPRESS, PlSqlParserDEALLOCATE, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDISABLE, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserFREEPOOLS, PlSqlParserKEEP_DUPLICATES, PlSqlParserNOCACHE, PlSqlParserNOCOMPRESS, PlSqlParserPCTVERSION, PlSqlParserREBUILD, PlSqlParserRETENTION, PlSqlParserSHRINK, PlSqlParserSTORAGE, PlSqlParserTABLESPACE, PlSqlParserRIGHT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEncryption_specContext is an interface to support dynamic dispatch. +type IEncryption_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + IDENTIFIED() antlr.TerminalNode + BY() antlr.TerminalNode + REGULAR_ID() antlr.TerminalNode + SALT() antlr.TerminalNode + NO() antlr.TerminalNode + + // IsEncryption_specContext differentiates from other interfaces. + IsEncryption_specContext() +} + +type Encryption_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEncryption_specContext() *Encryption_specContext { + var p = new(Encryption_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_encryption_spec + return p +} + +func InitEmptyEncryption_specContext(p *Encryption_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_encryption_spec +} + +func (*Encryption_specContext) IsEncryption_specContext() {} + +func NewEncryption_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Encryption_specContext { + var p = new(Encryption_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_encryption_spec + + return p +} + +func (s *Encryption_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Encryption_specContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Encryption_specContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Encryption_specContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Encryption_specContext) IDENTIFIED() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIED, 0) +} + +func (s *Encryption_specContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Encryption_specContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Encryption_specContext) SALT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSALT, 0) +} + +func (s *Encryption_specContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Encryption_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Encryption_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Encryption_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEncryption_spec(s) + } +} + +func (s *Encryption_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEncryption_spec(s) + } +} + +func (s *Encryption_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEncryption_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Encryption_spec() (localctx IEncryption_specContext) { + localctx = NewEncryption_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1664, PlSqlParserRULE_encryption_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(15029) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15030) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(15033) + p.Match(PlSqlParserIDENTIFIED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15034) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15035) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(15038) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO || _la == PlSqlParserSALT { + p.SetState(15042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNO { + { + p.SetState(15041) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15044) + p.Match(PlSqlParserSALT) + 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 +} + +// ITablespaceContext is an interface to support dynamic dispatch. +type ITablespaceContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsTablespaceContext differentiates from other interfaces. + IsTablespaceContext() +} + +type TablespaceContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTablespaceContext() *TablespaceContext { + var p = new(TablespaceContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace + return p +} + +func InitEmptyTablespaceContext(p *TablespaceContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tablespace +} + +func (*TablespaceContext) IsTablespaceContext() {} + +func NewTablespaceContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *TablespaceContext { + var p = new(TablespaceContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tablespace + + return p +} + +func (s *TablespaceContext) GetParser() antlr.Parser { return s.parser } + +func (s *TablespaceContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *TablespaceContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *TablespaceContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *TablespaceContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTablespace(s) + } +} + +func (s *TablespaceContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTablespace(s) + } +} + +func (s *TablespaceContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTablespace(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tablespace() (localctx ITablespaceContext) { + localctx = NewTablespaceContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1666, PlSqlParserRULE_tablespace) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15047) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_itemContext is an interface to support dynamic dispatch. +type IVarray_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsVarray_itemContext differentiates from other interfaces. + IsVarray_itemContext() +} + +type Varray_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_itemContext() *Varray_itemContext { + var p = new(Varray_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_item + return p +} + +func InitEmptyVarray_itemContext(p *Varray_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_item +} + +func (*Varray_itemContext) IsVarray_itemContext() {} + +func NewVarray_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_itemContext { + var p = new(Varray_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_item + + return p +} + +func (s *Varray_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_itemContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Varray_itemContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Varray_itemContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Varray_itemContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Varray_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_item(s) + } +} + +func (s *Varray_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_item(s) + } +} + +func (s *Varray_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVarray_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Varray_item() (localctx IVarray_itemContext) { + localctx = NewVarray_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1668, PlSqlParserRULE_varray_item) + p.EnterOuterAlt(localctx, 1) + p.SetState(15052) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1989, p.GetParserRuleContext()) == 1 { + { + p.SetState(15049) + p.Id_expression() + } + { + p.SetState(15050) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15057) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1990, p.GetParserRuleContext()) == 1 { + { + p.SetState(15054) + p.Id_expression() + } + { + p.SetState(15055) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15059) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_propertiesContext is an interface to support dynamic dispatch. +type IColumn_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllObject_type_col_properties() []IObject_type_col_propertiesContext + Object_type_col_properties(i int) IObject_type_col_propertiesContext + AllNested_table_col_properties() []INested_table_col_propertiesContext + Nested_table_col_properties(i int) INested_table_col_propertiesContext + AllXmltype_column_properties() []IXmltype_column_propertiesContext + Xmltype_column_properties(i int) IXmltype_column_propertiesContext + AllVarray_col_properties() []IVarray_col_propertiesContext + Varray_col_properties(i int) IVarray_col_propertiesContext + AllLob_storage_clause() []ILob_storage_clauseContext + Lob_storage_clause(i int) ILob_storage_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_partition_storage() []ILob_partition_storageContext + Lob_partition_storage(i int) ILob_partition_storageContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsColumn_propertiesContext differentiates from other interfaces. + IsColumn_propertiesContext() +} + +type Column_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_propertiesContext() *Column_propertiesContext { + var p = new(Column_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_properties + return p +} + +func InitEmptyColumn_propertiesContext(p *Column_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_properties +} + +func (*Column_propertiesContext) IsColumn_propertiesContext() {} + +func NewColumn_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_propertiesContext { + var p = new(Column_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_properties + + return p +} + +func (s *Column_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_propertiesContext) AllObject_type_col_properties() []IObject_type_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_type_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_type_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_type_col_propertiesContext); ok { + tst[i] = t.(IObject_type_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Object_type_col_properties(i int) IObject_type_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_type_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_type_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllNested_table_col_properties() []INested_table_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + len++ + } + } + + tst := make([]INested_table_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INested_table_col_propertiesContext); ok { + tst[i] = t.(INested_table_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Nested_table_col_properties(i int) INested_table_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_table_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INested_table_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllXmltype_column_properties() []IXmltype_column_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXmltype_column_propertiesContext); ok { + len++ + } + } + + tst := make([]IXmltype_column_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXmltype_column_propertiesContext); ok { + tst[i] = t.(IXmltype_column_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Xmltype_column_properties(i int) IXmltype_column_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltype_column_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXmltype_column_propertiesContext) +} + +func (s *Column_propertiesContext) AllVarray_col_properties() []IVarray_col_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + len++ + } + } + + tst := make([]IVarray_col_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVarray_col_propertiesContext); ok { + tst[i] = t.(IVarray_col_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Varray_col_properties(i int) IVarray_col_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_col_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVarray_col_propertiesContext) +} + +func (s *Column_propertiesContext) AllLob_storage_clause() []ILob_storage_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + len++ + } + } + + tst := make([]ILob_storage_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_clauseContext); ok { + tst[i] = t.(ILob_storage_clauseContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Lob_storage_clause(i int) ILob_storage_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_clauseContext) +} + +func (s *Column_propertiesContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Column_propertiesContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Column_propertiesContext) AllLob_partition_storage() []ILob_partition_storageContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_partition_storageContext); ok { + len++ + } + } + + tst := make([]ILob_partition_storageContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_partition_storageContext); ok { + tst[i] = t.(ILob_partition_storageContext) + i++ + } + } + + return tst +} + +func (s *Column_propertiesContext) Lob_partition_storage(i int) ILob_partition_storageContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_partition_storageContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_partition_storageContext) +} + +func (s *Column_propertiesContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Column_propertiesContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Column_propertiesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Column_propertiesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Column_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_properties(s) + } +} + +func (s *Column_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_properties(s) + } +} + +func (s *Column_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_properties() (localctx IColumn_propertiesContext) { + localctx = NewColumn_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1670, PlSqlParserRULE_column_properties) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15081) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCOLUMN: + { + p.SetState(15061) + p.Object_type_col_properties() + } + + case PlSqlParserNESTED: + { + p.SetState(15062) + p.Nested_table_col_properties() + } + + case PlSqlParserLOB, PlSqlParserVARRAY: + p.SetState(15065) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARRAY: + { + p.SetState(15063) + p.Varray_col_properties() + } + + case PlSqlParserLOB: + { + p.SetState(15064) + p.Lob_storage_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15078) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1993, p.GetParserRuleContext()) == 1 { + { + p.SetState(15067) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15068) + p.Lob_partition_storage() + } + p.SetState(15073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15069) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15070) + p.Lob_partition_storage() + } + + p.SetState(15075) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15076) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserXMLTYPE: + { + p.SetState(15080) + p.Xmltype_column_properties() + } + + 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 + } + + p.SetState(15083) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1995, 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 +} + +// ILob_partition_storageContext is an interface to support dynamic dispatch. +type ILob_partition_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOB() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllLob_item() []ILob_itemContext + Lob_item(i int) ILob_itemContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + STORE() antlr.TerminalNode + AS() antlr.TerminalNode + COMMA() antlr.TerminalNode + AllLob_storage_parameters() []ILob_storage_parametersContext + Lob_storage_parameters(i int) ILob_storage_parametersContext + AllLob_segname() []ILob_segnameContext + Lob_segname(i int) ILob_segnameContext + AllSECUREFILE() []antlr.TerminalNode + SECUREFILE(i int) antlr.TerminalNode + AllBASICFILE() []antlr.TerminalNode + BASICFILE(i int) antlr.TerminalNode + + // IsLob_partition_storageContext differentiates from other interfaces. + IsLob_partition_storageContext() +} + +type Lob_partition_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLob_partition_storageContext() *Lob_partition_storageContext { + var p = new(Lob_partition_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partition_storage + return p +} + +func InitEmptyLob_partition_storageContext(p *Lob_partition_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lob_partition_storage +} + +func (*Lob_partition_storageContext) IsLob_partition_storageContext() {} + +func NewLob_partition_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lob_partition_storageContext { + var p = new(Lob_partition_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lob_partition_storage + + return p +} + +func (s *Lob_partition_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lob_partition_storageContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Lob_partition_storageContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Lob_partition_storageContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Lob_partition_storageContext) AllLob_item() []ILob_itemContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_itemContext); ok { + len++ + } + } + + tst := make([]ILob_itemContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_itemContext); ok { + tst[i] = t.(ILob_itemContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_item(i int) ILob_itemContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_itemContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_itemContext) +} + +func (s *Lob_partition_storageContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Lob_partition_storageContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Lob_partition_storageContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Lob_partition_storageContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Lob_partition_storageContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Lob_partition_storageContext) AllLob_storage_parameters() []ILob_storage_parametersContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + len++ + } + } + + tst := make([]ILob_storage_parametersContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_storage_parametersContext); ok { + tst[i] = t.(ILob_storage_parametersContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_storage_parameters(i int) ILob_storage_parametersContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_storage_parametersContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_storage_parametersContext) +} + +func (s *Lob_partition_storageContext) AllLob_segname() []ILob_segnameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILob_segnameContext); ok { + len++ + } + } + + tst := make([]ILob_segnameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILob_segnameContext); ok { + tst[i] = t.(ILob_segnameContext) + i++ + } + } + + return tst +} + +func (s *Lob_partition_storageContext) Lob_segname(i int) ILob_segnameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILob_segnameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILob_segnameContext) +} + +func (s *Lob_partition_storageContext) AllSECUREFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECUREFILE) +} + +func (s *Lob_partition_storageContext) SECUREFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, i) +} + +func (s *Lob_partition_storageContext) AllBASICFILE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBASICFILE) +} + +func (s *Lob_partition_storageContext) BASICFILE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, i) +} + +func (s *Lob_partition_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lob_partition_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lob_partition_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLob_partition_storage(s) + } +} + +func (s *Lob_partition_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLob_partition_storage(s) + } +} + +func (s *Lob_partition_storageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLob_partition_storage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lob_partition_storage() (localctx ILob_partition_storageContext) { + localctx = NewLob_partition_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1672, PlSqlParserRULE_lob_partition_storage) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15085) + p.Match(PlSqlParserLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2000, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15086) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15087) + p.Lob_item() + } + + { + p.SetState(15088) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15089) + p.Lob_item() + } + + { + p.SetState(15091) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15092) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15093) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE || _la == PlSqlParserLEFT_PAREN { + p.SetState(15099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBASICFILE, PlSqlParserSECUREFILE: + { + p.SetState(15094) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15095) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15096) + p.Lob_storage_parameters() + } + { + p.SetState(15097) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15101) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(15103) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15104) + p.Lob_item() + } + { + p.SetState(15105) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15106) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15107) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877907073) != 0) { + p.SetState(15114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 1998, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15108) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBASICFILE || _la == PlSqlParserSECUREFILE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(15109) + p.Lob_segname() + } + + case 3: + { + p.SetState(15110) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15111) + p.Lob_storage_parameters() + } + { + p.SetState(15112) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(15116) + 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 +} + +// IPeriod_definitionContext is an interface to support dynamic dispatch. +type IPeriod_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PERIOD() antlr.TerminalNode + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + LEFT_PAREN() antlr.TerminalNode + Start_time_column() IStart_time_columnContext + COMMA() antlr.TerminalNode + End_time_column() IEnd_time_columnContext + RIGHT_PAREN() antlr.TerminalNode + + // IsPeriod_definitionContext differentiates from other interfaces. + IsPeriod_definitionContext() +} + +type Period_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPeriod_definitionContext() *Period_definitionContext { + var p = new(Period_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_period_definition + return p +} + +func InitEmptyPeriod_definitionContext(p *Period_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_period_definition +} + +func (*Period_definitionContext) IsPeriod_definitionContext() {} + +func NewPeriod_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Period_definitionContext { + var p = new(Period_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_period_definition + + return p +} + +func (s *Period_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Period_definitionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Period_definitionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Period_definitionContext) 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 *Period_definitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Period_definitionContext) Start_time_column() IStart_time_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_time_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_time_columnContext) +} + +func (s *Period_definitionContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Period_definitionContext) End_time_column() IEnd_time_columnContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEnd_time_columnContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEnd_time_columnContext) +} + +func (s *Period_definitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Period_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Period_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Period_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPeriod_definition(s) + } +} + +func (s *Period_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPeriod_definition(s) + } +} + +func (s *Period_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPeriod_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Period_definition() (localctx IPeriod_definitionContext) { + localctx = NewPeriod_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1674, PlSqlParserRULE_period_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15120) + + if !(p.isVersion12()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.isVersion12()", "")) + goto errorExit + } + { + p.SetState(15121) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15122) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15123) + p.Column_name() + } + p.SetState(15130) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15124) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15125) + p.Start_time_column() + } + { + p.SetState(15126) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15127) + p.End_time_column() + } + { + p.SetState(15128) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStart_time_columnContext is an interface to support dynamic dispatch. +type IStart_time_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsStart_time_columnContext differentiates from other interfaces. + IsStart_time_columnContext() +} + +type Start_time_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_time_columnContext() *Start_time_columnContext { + var p = new(Start_time_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_time_column + return p +} + +func InitEmptyStart_time_columnContext(p *Start_time_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_time_column +} + +func (*Start_time_columnContext) IsStart_time_columnContext() {} + +func NewStart_time_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_time_columnContext { + var p = new(Start_time_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_time_column + + return p +} + +func (s *Start_time_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_time_columnContext) 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 *Start_time_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_time_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_time_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_time_column(s) + } +} + +func (s *Start_time_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_time_column(s) + } +} + +func (s *Start_time_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStart_time_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Start_time_column() (localctx IStart_time_columnContext) { + localctx = NewStart_time_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1676, PlSqlParserRULE_start_time_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15132) + p.Column_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 +} + +// IEnd_time_columnContext is an interface to support dynamic dispatch. +type IEnd_time_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + + // IsEnd_time_columnContext differentiates from other interfaces. + IsEnd_time_columnContext() +} + +type End_time_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnd_time_columnContext() *End_time_columnContext { + var p = new(End_time_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_end_time_column + return p +} + +func InitEmptyEnd_time_columnContext(p *End_time_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_end_time_column +} + +func (*End_time_columnContext) IsEnd_time_columnContext() {} + +func NewEnd_time_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *End_time_columnContext { + var p = new(End_time_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_end_time_column + + return p +} + +func (s *End_time_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *End_time_columnContext) 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 *End_time_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *End_time_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *End_time_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnd_time_column(s) + } +} + +func (s *End_time_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnd_time_column(s) + } +} + +func (s *End_time_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnd_time_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) End_time_column() (localctx IEnd_time_columnContext) { + localctx = NewEnd_time_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1678, PlSqlParserRULE_end_time_column) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15134) + p.Column_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 +} + +// IColumn_definitionContext is an interface to support dynamic dispatch. +type IColumn_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + SORT() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Expression() IExpressionContext + Identity_clause() IIdentity_clauseContext + ENCRYPT() antlr.TerminalNode + Encryption_spec() IEncryption_specContext + Inline_ref_constraint() IInline_ref_constraintContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + Datatype() IDatatypeContext + Regular_id() IRegular_idContext + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + + // IsColumn_definitionContext differentiates from other interfaces. + IsColumn_definitionContext() +} + +type Column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_definitionContext() *Column_definitionContext { + var p = new(Column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_definition + return p +} + +func InitEmptyColumn_definitionContext(p *Column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_definition +} + +func (*Column_definitionContext) IsColumn_definitionContext() {} + +func NewColumn_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_definitionContext { + var p = new(Column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_definition + + return p +} + +func (s *Column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_definitionContext) 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_definitionContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Column_definitionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_definitionContext) Identity_clause() IIdentity_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_clauseContext) +} + +func (s *Column_definitionContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Column_definitionContext) Encryption_spec() IEncryption_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEncryption_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEncryption_specContext) +} + +func (s *Column_definitionContext) Inline_ref_constraint() IInline_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInline_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInline_ref_constraintContext) +} + +func (s *Column_definitionContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Column_definitionContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Column_definitionContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Column_definitionContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Column_definitionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Column_definitionContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *Column_definitionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Column_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Column_definitionContext) 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 *Column_definitionContext) 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 *Column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_definition(s) + } +} + +func (s *Column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_definition(s) + } +} + +func (s *Column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_definition() (localctx IColumn_definitionContext) { + localctx = NewColumn_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1680, PlSqlParserRULE_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15136) + p.Column_name() + } + p.SetState(15145) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2004, p.GetParserRuleContext()) == 1 { + p.SetState(15139) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2002, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15137) + p.Datatype() + } + + case 2: + { + p.SetState(15138) + p.Regular_id() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15143) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLLATE { + { + p.SetState(15141) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15142) + p.Column_collation_name() + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSORT { + { + p.SetState(15147) + p.Match(PlSqlParserSORT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE { + { + p.SetState(15150) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15160) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserDEFAULT: + { + p.SetState(15153) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15154) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15155) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15158) + p.Expression() + } + + case PlSqlParserGENERATED: + { + p.SetState(15159) + p.Identity_clause() + } + + case PlSqlParserADD, PlSqlParserCHECK, PlSqlParserCOLUMN, PlSqlParserCONSTRAINT, PlSqlParserDISABLE, PlSqlParserDROP, PlSqlParserENABLE, PlSqlParserENCRYPT, PlSqlParserLOB, PlSqlParserMODIFY, PlSqlParserNESTED, PlSqlParserNOT, PlSqlParserNULL_, PlSqlParserPRIMARY, PlSqlParserREFERENCES, PlSqlParserRENAME, PlSqlParserSCOPE, PlSqlParserSET, PlSqlParserUNIQUE, PlSqlParserVARRAY, PlSqlParserWITH, PlSqlParserXMLTYPE, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA, PlSqlParserSEMICOLON: + + default: + } + p.SetState(15164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCRYPT { + { + p.SetState(15162) + p.Match(PlSqlParserENCRYPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15163) + p.Encryption_spec() + } + + } + p.SetState(15172) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2011, p.GetParserRuleContext()) == 1 { + p.SetState(15167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(15166) + p.Inline_constraint() + } + + p.SetState(15169) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2011, p.GetParserRuleContext()) == 2 { + { + p.SetState(15171) + p.Inline_ref_constraint() + } + + } 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_collation_nameContext is an interface to support dynamic dispatch. +type IColumn_collation_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsColumn_collation_nameContext differentiates from other interfaces. + IsColumn_collation_nameContext() +} + +type Column_collation_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_collation_nameContext() *Column_collation_nameContext { + var p = new(Column_collation_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_collation_name + return p +} + +func InitEmptyColumn_collation_nameContext(p *Column_collation_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_collation_name +} + +func (*Column_collation_nameContext) IsColumn_collation_nameContext() {} + +func NewColumn_collation_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_collation_nameContext { + var p = new(Column_collation_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_collation_name + + return p +} + +func (s *Column_collation_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_collation_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Column_collation_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_collation_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_collation_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_collation_name(s) + } +} + +func (s *Column_collation_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_collation_name(s) + } +} + +func (s *Column_collation_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_collation_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_collation_name() (localctx IColumn_collation_nameContext) { + localctx = NewColumn_collation_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1682, PlSqlParserRULE_column_collation_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15174) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_clauseContext is an interface to support dynamic dispatch. +type IIdentity_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GENERATED() antlr.TerminalNode + AS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + BY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + Identity_options_parentheses() IIdentity_options_parenthesesContext + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsIdentity_clauseContext differentiates from other interfaces. + IsIdentity_clauseContext() +} + +type Identity_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_clauseContext() *Identity_clauseContext { + var p = new(Identity_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_clause + return p +} + +func InitEmptyIdentity_clauseContext(p *Identity_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_clause +} + +func (*Identity_clauseContext) IsIdentity_clauseContext() {} + +func NewIdentity_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_clauseContext { + var p = new(Identity_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_clause + + return p +} + +func (s *Identity_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_clauseContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Identity_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Identity_clauseContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Identity_clauseContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Identity_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identity_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Identity_clauseContext) Identity_options_parentheses() IIdentity_options_parenthesesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_options_parenthesesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_options_parenthesesContext) +} + +func (s *Identity_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Identity_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Identity_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_clause(s) + } +} + +func (s *Identity_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_clause(s) + } +} + +func (s *Identity_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentity_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identity_clause() (localctx IIdentity_clauseContext) { + localctx = NewIdentity_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1684, PlSqlParserRULE_identity_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15176) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALWAYS: + { + p.SetState(15177) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBY: + { + p.SetState(15178) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15179) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15182) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15180) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15181) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAS: + + default: + } + { + p.SetState(15186) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15187) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15189) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER || _la == PlSqlParserSTART || _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15188) + p.Identity_options_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 +} + +// IIdentity_options_parenthesesContext is an interface to support dynamic dispatch. +type IIdentity_options_parenthesesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIdentity_options() []IIdentity_optionsContext + Identity_options(i int) IIdentity_optionsContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsIdentity_options_parenthesesContext differentiates from other interfaces. + IsIdentity_options_parenthesesContext() +} + +type Identity_options_parenthesesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_options_parenthesesContext() *Identity_options_parenthesesContext { + var p = new(Identity_options_parenthesesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses + return p +} + +func InitEmptyIdentity_options_parenthesesContext(p *Identity_options_parenthesesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses +} + +func (*Identity_options_parenthesesContext) IsIdentity_options_parenthesesContext() {} + +func NewIdentity_options_parenthesesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_options_parenthesesContext { + var p = new(Identity_options_parenthesesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_options_parentheses + + return p +} + +func (s *Identity_options_parenthesesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_options_parenthesesContext) AllIdentity_options() []IIdentity_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentity_optionsContext); ok { + len++ + } + } + + tst := make([]IIdentity_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentity_optionsContext); ok { + tst[i] = t.(IIdentity_optionsContext) + i++ + } + } + + return tst +} + +func (s *Identity_options_parenthesesContext) Identity_options(i int) IIdentity_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentity_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentity_optionsContext) +} + +func (s *Identity_options_parenthesesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Identity_options_parenthesesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Identity_options_parenthesesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_options_parenthesesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_options_parenthesesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_options_parentheses(s) + } +} + +func (s *Identity_options_parenthesesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_options_parentheses(s) + } +} + +func (s *Identity_options_parenthesesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentity_options_parentheses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identity_options_parentheses() (localctx IIdentity_options_parenthesesContext) { + localctx = NewIdentity_options_parenthesesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1686, PlSqlParserRULE_identity_options_parentheses) + var _la int + + p.SetState(15204) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCACHE, PlSqlParserCYCLE, PlSqlParserINCREMENT, PlSqlParserMAXVALUE, PlSqlParserMINVALUE, PlSqlParserNOCACHE, PlSqlParserNOCYCLE, PlSqlParserNOMAXVALUE, PlSqlParserNOMINVALUE, PlSqlParserNOORDER, PlSqlParserORDER, PlSqlParserSTART: + p.EnterOuterAlt(localctx, 1) + p.SetState(15192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER || _la == PlSqlParserSTART { + { + p.SetState(15191) + p.Identity_options() + } + + p.SetState(15194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15196) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15198) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER || _la == PlSqlParserSTART { + { + p.SetState(15197) + p.Identity_options() + } + + p.SetState(15200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15202) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIdentity_optionsContext is an interface to support dynamic dispatch. +type IIdentity_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + Numeric() INumericContext + LIMIT() antlr.TerminalNode + VALUE() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + BY() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + CYCLE() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + CACHE() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + ORDER() antlr.TerminalNode + NOORDER() antlr.TerminalNode + + // IsIdentity_optionsContext differentiates from other interfaces. + IsIdentity_optionsContext() +} + +type Identity_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentity_optionsContext() *Identity_optionsContext { + var p = new(Identity_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options + return p +} + +func InitEmptyIdentity_optionsContext(p *Identity_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identity_options +} + +func (*Identity_optionsContext) IsIdentity_optionsContext() {} + +func NewIdentity_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Identity_optionsContext { + var p = new(Identity_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identity_options + + return p +} + +func (s *Identity_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Identity_optionsContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Identity_optionsContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Identity_optionsContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Identity_optionsContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Identity_optionsContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Identity_optionsContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Identity_optionsContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Identity_optionsContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Identity_optionsContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Identity_optionsContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Identity_optionsContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Identity_optionsContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Identity_optionsContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Identity_optionsContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Identity_optionsContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Identity_optionsContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Identity_optionsContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Identity_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Identity_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Identity_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentity_options(s) + } +} + +func (s *Identity_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentity_options(s) + } +} + +func (s *Identity_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentity_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identity_options() (localctx IIdentity_optionsContext) { + localctx = NewIdentity_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1688, PlSqlParserRULE_identity_options) + p.SetState(15229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15206) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15207) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(15208) + p.Numeric() + } + + case PlSqlParserLIMIT: + { + p.SetState(15209) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15210) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case PlSqlParserINCREMENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15213) + p.Match(PlSqlParserINCREMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15214) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15215) + p.Numeric() + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15216) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15217) + p.Numeric() + } + + case PlSqlParserNOMAXVALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15218) + p.Match(PlSqlParserNOMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(15219) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15220) + p.Numeric() + } + + case PlSqlParserNOMINVALUE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(15221) + p.Match(PlSqlParserNOMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCYCLE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(15222) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOCYCLE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(15223) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCACHE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(15224) + p.Match(PlSqlParserCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15225) + p.Numeric() + } + + case PlSqlParserNOCACHE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(15226) + p.Match(PlSqlParserNOCACHE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserORDER: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(15227) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOORDER: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(15228) + p.Match(PlSqlParserNOORDER) + 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 +} + +// IVirtual_column_definitionContext is an interface to support dynamic dispatch. +type IVirtual_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Datatype() IDatatypeContext + COLLATE() antlr.TerminalNode + Column_collation_name() IColumn_collation_nameContext + Autogenerated_sequence_definition() IAutogenerated_sequence_definitionContext + VIRTUAL() antlr.TerminalNode + Evaluation_edition_clause() IEvaluation_edition_clauseContext + AllUNUSABLE() []antlr.TerminalNode + UNUSABLE(i int) antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGINNING() antlr.TerminalNode + WITH() antlr.TerminalNode + AllInline_constraint() []IInline_constraintContext + Inline_constraint(i int) IInline_constraintContext + VISIBLE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + AllCURRENT() []antlr.TerminalNode + CURRENT(i int) antlr.TerminalNode + AllEDITION() []antlr.TerminalNode + EDITION(i int) antlr.TerminalNode + AllEdition_name() []IEdition_nameContext + Edition_name(i int) IEdition_nameContext + NULL_() antlr.TerminalNode + + // IsVirtual_column_definitionContext differentiates from other interfaces. + IsVirtual_column_definitionContext() +} + +type Virtual_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVirtual_column_definitionContext() *Virtual_column_definitionContext { + var p = new(Virtual_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_definition + return p +} + +func InitEmptyVirtual_column_definitionContext(p *Virtual_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_virtual_column_definition +} + +func (*Virtual_column_definitionContext) IsVirtual_column_definitionContext() {} + +func NewVirtual_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Virtual_column_definitionContext { + var p = new(Virtual_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_virtual_column_definition + + return p +} + +func (s *Virtual_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Virtual_column_definitionContext) 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 *Virtual_column_definitionContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Virtual_column_definitionContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Virtual_column_definitionContext) Column_collation_name() IColumn_collation_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_collation_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_collation_nameContext) +} + +func (s *Virtual_column_definitionContext) Autogenerated_sequence_definition() IAutogenerated_sequence_definitionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAutogenerated_sequence_definitionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAutogenerated_sequence_definitionContext) +} + +func (s *Virtual_column_definitionContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Virtual_column_definitionContext) Evaluation_edition_clause() IEvaluation_edition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEvaluation_edition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEvaluation_edition_clauseContext) +} + +func (s *Virtual_column_definitionContext) AllUNUSABLE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNUSABLE) +} + +func (s *Virtual_column_definitionContext) UNUSABLE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, i) +} + +func (s *Virtual_column_definitionContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Virtual_column_definitionContext) BEGINNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGINNING, 0) +} + +func (s *Virtual_column_definitionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Virtual_column_definitionContext) 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 *Virtual_column_definitionContext) 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 *Virtual_column_definitionContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Virtual_column_definitionContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Virtual_column_definitionContext) AllCURRENT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCURRENT) +} + +func (s *Virtual_column_definitionContext) CURRENT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, i) +} + +func (s *Virtual_column_definitionContext) AllEDITION() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEDITION) +} + +func (s *Virtual_column_definitionContext) EDITION(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, i) +} + +func (s *Virtual_column_definitionContext) AllEdition_name() []IEdition_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IEdition_nameContext); ok { + len++ + } + } + + tst := make([]IEdition_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IEdition_nameContext); ok { + tst[i] = t.(IEdition_nameContext) + i++ + } + } + + return tst +} + +func (s *Virtual_column_definitionContext) Edition_name(i int) IEdition_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Virtual_column_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Virtual_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Virtual_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Virtual_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVirtual_column_definition(s) + } +} + +func (s *Virtual_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVirtual_column_definition(s) + } +} + +func (s *Virtual_column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVirtual_column_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Virtual_column_definition() (localctx IVirtual_column_definitionContext) { + localctx = NewVirtual_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1690, PlSqlParserRULE_virtual_column_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15231) + p.Column_name() + } + p.SetState(15236) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64((_la-113)) & ^0x3f) == 0 && ((int64(1)<<(_la-113))&68158609) != 0) || ((int64((_la-181)) & ^0x3f) == 0 && ((int64(1)<<(_la-181))&1048579) != 0) || ((int64((_la-339)) & ^0x3f) == 0 && ((int64(1)<<(_la-339))&98309) != 0) || _la == PlSqlParserDOUBLE || _la == PlSqlParserDSINTERVAL_UNCONSTRAINED || _la == PlSqlParserFLOAT || _la == PlSqlParserHOUR || ((int64((_la-710)) & ^0x3f) == 0 && ((int64(1)<<(_la-710))&385) != 0) || _la == PlSqlParserLONG || _la == PlSqlParserMINUTE || ((int64((_la-895)) & ^0x3f) == 0 && ((int64(1)<<(_la-895))&22814866800641) != 0) || ((int64((_la-1147)) & ^0x3f) == 0 && ((int64(1)<<(_la-1147))&35) != 0) || ((int64((_la-1309)) & ^0x3f) == 0 && ((int64(1)<<(_la-1309))&98305) != 0) || _la == PlSqlParserRAW || _la == PlSqlParserREAL || _la == PlSqlParserROWID || _la == PlSqlParserSECOND || ((int64((_la-1588)) & ^0x3f) == 0 && ((int64(1)<<(_la-1588))&8195) != 0) || _la == PlSqlParserSTRING || ((int64((_la-1996)) & ^0x3f) == 0 && ((int64(1)<<(_la-1996))&2959) != 0) || ((int64((_la-2098)) & ^0x3f) == 0 && ((int64(1)<<(_la-2098))&52776558133249) != 0) || _la == PlSqlParserYEAR || _la == PlSqlParserYMINTERVAL_UNCONSTRAINED { + { + p.SetState(15232) + p.Datatype() + } + { + p.SetState(15233) + p.Match(PlSqlParserCOLLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15234) + p.Column_collation_name() + } + + } + p.SetState(15239) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE { + { + p.SetState(15238) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserINVISIBLE || _la == PlSqlParserVISIBLE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGENERATED { + { + p.SetState(15241) + p.Autogenerated_sequence_definition() + } + + } + p.SetState(15245) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVIRTUAL { + { + p.SetState(15244) + p.Match(PlSqlParserVIRTUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15248) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEVALUATE { + { + p.SetState(15247) + p.Evaluation_edition_clause() + } + + } + p.SetState(15258) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2026, p.GetParserRuleContext()) == 1 { + { + p.SetState(15250) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15251) + p.Match(PlSqlParserBEFORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15256) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT: + { + p.SetState(15252) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15253) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15254) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15255) + p.Edition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNUSABLE { + { + p.SetState(15260) + p.Match(PlSqlParserUNUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15261) + p.Match(PlSqlParserBEGINNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15262) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15267) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT, PlSqlParserNULL_: + { + p.SetState(15263) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15264) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15265) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15266) + p.Edition_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(15274) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserNOT || _la == PlSqlParserNULL_ || _la == PlSqlParserPRIMARY || _la == PlSqlParserREFERENCES || _la == PlSqlParserUNIQUE { + { + p.SetState(15271) + p.Inline_constraint() + } + + p.SetState(15276) + 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 +} + +// IAutogenerated_sequence_definitionContext is an interface to support dynamic dispatch. +type IAutogenerated_sequence_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GENERATED() antlr.TerminalNode + AS() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + BY() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + ON() antlr.TerminalNode + NULL_() antlr.TerminalNode + AllSequence_start_clause() []ISequence_start_clauseContext + Sequence_start_clause(i int) ISequence_start_clauseContext + AllSequence_spec() []ISequence_specContext + Sequence_spec(i int) ISequence_specContext + + // IsAutogenerated_sequence_definitionContext differentiates from other interfaces. + IsAutogenerated_sequence_definitionContext() +} + +type Autogenerated_sequence_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAutogenerated_sequence_definitionContext() *Autogenerated_sequence_definitionContext { + var p = new(Autogenerated_sequence_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition + return p +} + +func InitEmptyAutogenerated_sequence_definitionContext(p *Autogenerated_sequence_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition +} + +func (*Autogenerated_sequence_definitionContext) IsAutogenerated_sequence_definitionContext() {} + +func NewAutogenerated_sequence_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Autogenerated_sequence_definitionContext { + var p = new(Autogenerated_sequence_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_autogenerated_sequence_definition + + return p +} + +func (s *Autogenerated_sequence_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Autogenerated_sequence_definitionContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Autogenerated_sequence_definitionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Autogenerated_sequence_definitionContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Autogenerated_sequence_definitionContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Autogenerated_sequence_definitionContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Autogenerated_sequence_definitionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Autogenerated_sequence_definitionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Autogenerated_sequence_definitionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Autogenerated_sequence_definitionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Autogenerated_sequence_definitionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Autogenerated_sequence_definitionContext) AllSequence_start_clause() []ISequence_start_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + len++ + } + } + + tst := make([]ISequence_start_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_start_clauseContext); ok { + tst[i] = t.(ISequence_start_clauseContext) + i++ + } + } + + return tst +} + +func (s *Autogenerated_sequence_definitionContext) Sequence_start_clause(i int) ISequence_start_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_start_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_start_clauseContext) +} + +func (s *Autogenerated_sequence_definitionContext) AllSequence_spec() []ISequence_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISequence_specContext); ok { + len++ + } + } + + tst := make([]ISequence_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISequence_specContext); ok { + tst[i] = t.(ISequence_specContext) + i++ + } + } + + return tst +} + +func (s *Autogenerated_sequence_definitionContext) Sequence_spec(i int) ISequence_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISequence_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISequence_specContext) +} + +func (s *Autogenerated_sequence_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Autogenerated_sequence_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Autogenerated_sequence_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAutogenerated_sequence_definition(s) + } +} + +func (s *Autogenerated_sequence_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAutogenerated_sequence_definition(s) + } +} + +func (s *Autogenerated_sequence_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAutogenerated_sequence_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Autogenerated_sequence_definition() (localctx IAutogenerated_sequence_definitionContext) { + localctx = NewAutogenerated_sequence_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1692, PlSqlParserRULE_autogenerated_sequence_definition) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15277) + p.Match(PlSqlParserGENERATED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserALWAYS: + { + p.SetState(15278) + p.Match(PlSqlParserALWAYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBY: + { + p.SetState(15279) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15280) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15283) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15281) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15282) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAS: + + default: + } + { + p.SetState(15287) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15288) + p.Match(PlSqlParserIDENTITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15298) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15289) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCACHE || _la == PlSqlParserCYCLE || _la == PlSqlParserINCREMENT || _la == PlSqlParserMAXVALUE || _la == PlSqlParserMINVALUE || ((int64((_la-993)) & ^0x3f) == 0 && ((int64(1)<<(_la-993))&5066549580922881) != 0) || _la == PlSqlParserNOORDER || _la == PlSqlParserORDER || _la == PlSqlParserSTART { + p.SetState(15292) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSTART: + { + p.SetState(15290) + p.Sequence_start_clause() + } + + case PlSqlParserCACHE, PlSqlParserCYCLE, PlSqlParserINCREMENT, PlSqlParserMAXVALUE, PlSqlParserMINVALUE, PlSqlParserNOCACHE, PlSqlParserNOCYCLE, PlSqlParserNOMAXVALUE, PlSqlParserNOMINVALUE, PlSqlParserNOORDER, PlSqlParserORDER: + { + p.SetState(15291) + p.Sequence_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15296) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15297) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IEvaluation_edition_clauseContext is an interface to support dynamic dispatch. +type IEvaluation_edition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EVALUATE() antlr.TerminalNode + USING() antlr.TerminalNode + EDITION() antlr.TerminalNode + Edition_name() IEdition_nameContext + CURRENT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsEvaluation_edition_clauseContext differentiates from other interfaces. + IsEvaluation_edition_clauseContext() +} + +type Evaluation_edition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEvaluation_edition_clauseContext() *Evaluation_edition_clauseContext { + var p = new(Evaluation_edition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause + return p +} + +func InitEmptyEvaluation_edition_clauseContext(p *Evaluation_edition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause +} + +func (*Evaluation_edition_clauseContext) IsEvaluation_edition_clauseContext() {} + +func NewEvaluation_edition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Evaluation_edition_clauseContext { + var p = new(Evaluation_edition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_evaluation_edition_clause + + return p +} + +func (s *Evaluation_edition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Evaluation_edition_clauseContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Evaluation_edition_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Evaluation_edition_clauseContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Evaluation_edition_clauseContext) Edition_name() IEdition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IEdition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IEdition_nameContext) +} + +func (s *Evaluation_edition_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Evaluation_edition_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Evaluation_edition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Evaluation_edition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Evaluation_edition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEvaluation_edition_clause(s) + } +} + +func (s *Evaluation_edition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEvaluation_edition_clause(s) + } +} + +func (s *Evaluation_edition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEvaluation_edition_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Evaluation_edition_clause() (localctx IEvaluation_edition_clauseContext) { + localctx = NewEvaluation_edition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1694, PlSqlParserRULE_evaluation_edition_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15300) + p.Match(PlSqlParserEVALUATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15301) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15306) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCURRENT, PlSqlParserNULL_: + { + p.SetState(15302) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15303) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEDITION: + { + p.SetState(15304) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15305) + p.Edition_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 +} + +// IOut_of_line_part_storageContext is an interface to support dynamic dispatch. +type IOut_of_line_part_storageContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + Partition_name() IPartition_nameContext + + // IsOut_of_line_part_storageContext differentiates from other interfaces. + IsOut_of_line_part_storageContext() +} + +type Out_of_line_part_storageContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOut_of_line_part_storageContext() *Out_of_line_part_storageContext { + var p = new(Out_of_line_part_storageContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_part_storage + return p +} + +func InitEmptyOut_of_line_part_storageContext(p *Out_of_line_part_storageContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_out_of_line_part_storage +} + +func (*Out_of_line_part_storageContext) IsOut_of_line_part_storageContext() {} + +func NewOut_of_line_part_storageContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Out_of_line_part_storageContext { + var p = new(Out_of_line_part_storageContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_out_of_line_part_storage + + return p +} + +func (s *Out_of_line_part_storageContext) GetParser() antlr.Parser { return s.parser } + +func (s *Out_of_line_part_storageContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Out_of_line_part_storageContext) Partition_name() IPartition_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_nameContext) +} + +func (s *Out_of_line_part_storageContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Out_of_line_part_storageContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Out_of_line_part_storageContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOut_of_line_part_storage(s) + } +} + +func (s *Out_of_line_part_storageContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOut_of_line_part_storage(s) + } +} + +func (s *Out_of_line_part_storageContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOut_of_line_part_storage(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Out_of_line_part_storage() (localctx IOut_of_line_part_storageContext) { + localctx = NewOut_of_line_part_storageContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1696, PlSqlParserRULE_out_of_line_part_storage) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15308) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15309) + p.Partition_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 +} + +// INested_table_col_propertiesContext is an interface to support dynamic dispatch. +type INested_table_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NESTED() antlr.TerminalNode + TABLE() antlr.TerminalNode + STORE() antlr.TerminalNode + AllAS() []antlr.TerminalNode + AS(i int) antlr.TerminalNode + Tableview_name() ITableview_nameContext + Nested_item() INested_itemContext + COLUMN_VALUE() antlr.TerminalNode + Substitutable_column_clause() ISubstitutable_column_clauseContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + RETURN() antlr.TerminalNode + LOCAL() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + VALUE() antlr.TerminalNode + AllObject_properties() []IObject_propertiesContext + Object_properties(i int) IObject_propertiesContext + AllPhysical_properties() []IPhysical_propertiesContext + Physical_properties(i int) IPhysical_propertiesContext + AllColumn_properties() []IColumn_propertiesContext + Column_properties(i int) IColumn_propertiesContext + + // IsNested_table_col_propertiesContext differentiates from other interfaces. + IsNested_table_col_propertiesContext() +} + +type Nested_table_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_table_col_propertiesContext() *Nested_table_col_propertiesContext { + var p = new(Nested_table_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties + return p +} + +func InitEmptyNested_table_col_propertiesContext(p *Nested_table_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties +} + +func (*Nested_table_col_propertiesContext) IsNested_table_col_propertiesContext() {} + +func NewNested_table_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_table_col_propertiesContext { + var p = new(Nested_table_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_table_col_properties + + return p +} + +func (s *Nested_table_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_table_col_propertiesContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Nested_table_col_propertiesContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Nested_table_col_propertiesContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Nested_table_col_propertiesContext) AllAS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserAS) +} + +func (s *Nested_table_col_propertiesContext) AS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, i) +} + +func (s *Nested_table_col_propertiesContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Nested_table_col_propertiesContext) Nested_item() INested_itemContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INested_itemContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INested_itemContext) +} + +func (s *Nested_table_col_propertiesContext) COLUMN_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_VALUE, 0) +} + +func (s *Nested_table_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Nested_table_col_propertiesContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Nested_table_col_propertiesContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Nested_table_col_propertiesContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Nested_table_col_propertiesContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Nested_table_col_propertiesContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Nested_table_col_propertiesContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Nested_table_col_propertiesContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Nested_table_col_propertiesContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Nested_table_col_propertiesContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Nested_table_col_propertiesContext) AllObject_properties() []IObject_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IObject_propertiesContext); ok { + len++ + } + } + + tst := make([]IObject_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IObject_propertiesContext); ok { + tst[i] = t.(IObject_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Object_properties(i int) IObject_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IObject_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IObject_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) AllPhysical_properties() []IPhysical_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + len++ + } + } + + tst := make([]IPhysical_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPhysical_propertiesContext); ok { + tst[i] = t.(IPhysical_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Physical_properties(i int) IPhysical_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPhysical_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPhysical_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) AllColumn_properties() []IColumn_propertiesContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_propertiesContext); ok { + len++ + } + } + + tst := make([]IColumn_propertiesContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_propertiesContext); ok { + tst[i] = t.(IColumn_propertiesContext) + i++ + } + } + + return tst +} + +func (s *Nested_table_col_propertiesContext) Column_properties(i int) IColumn_propertiesContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_propertiesContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_propertiesContext) +} + +func (s *Nested_table_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_table_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_table_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_table_col_properties(s) + } +} + +func (s *Nested_table_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_table_col_properties(s) + } +} + +func (s *Nested_table_col_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNested_table_col_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Nested_table_col_properties() (localctx INested_table_col_propertiesContext) { + localctx = NewNested_table_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1698, PlSqlParserRULE_nested_table_col_properties) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15311) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15312) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2036, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15313) + p.Nested_item() + } + + case 2: + { + p.SetState(15314) + p.Match(PlSqlParserCOLUMN_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(15318) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT || _la == PlSqlParserIS || _la == PlSqlParserNOT || _la == PlSqlParserSUBSTITUTABLE { + { + p.SetState(15317) + p.Substitutable_column_clause() + } + + } + p.SetState(15321) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGLOBAL || _la == PlSqlParserLOCAL { + { + p.SetState(15320) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGLOBAL || _la == PlSqlParserLOCAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(15323) + p.Match(PlSqlParserSTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15324) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15325) + p.Tableview_name() + } + p.SetState(15339) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2041, p.GetParserRuleContext()) == 1 { + { + p.SetState(15326) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64((_la-206)) & ^0x3f) == 0 && ((int64(1)<<(_la-206))&206158495745) != 0) || _la == PlSqlParserEXTERNAL || _la == PlSqlParserFILESYSTEM_LIKE_LOGGING || _la == PlSqlParserINITRANS || ((int64((_la-800)) & ^0x3f) == 0 && ((int64(1)<<(_la-800))&1152921504606879745) != 0) || _la == PlSqlParserNESTED || _la == PlSqlParserNOCOMPRESS || _la == PlSqlParserNOLOGGING || ((int64((_la-1218)) & ^0x3f) == 0 && ((int64(1)<<(_la-1218))&5188146770730811393) != 0) || _la == PlSqlParserSEGMENT || _la == PlSqlParserSTORAGE || _la == PlSqlParserTABLESPACE || _la == PlSqlParserVARRAY || _la == PlSqlParserXMLTYPE || _la == PlSqlParserLEFT_PAREN { + p.SetState(15333) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(15327) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15328) + p.Object_properties() + } + { + p.SetState(15329) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLUSTER, PlSqlParserCOMPRESS, PlSqlParserCOMPUTE, PlSqlParserEXTERNAL, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserINITRANS, PlSqlParserLOGGING, PlSqlParserMAXTRANS, PlSqlParserNOCOMPRESS, PlSqlParserNOLOGGING, PlSqlParserORGANIZATION, PlSqlParserPCTFREE, PlSqlParserPCTUSED, PlSqlParserSEGMENT, PlSqlParserSTORAGE, PlSqlParserTABLESPACE: + { + p.SetState(15331) + p.Physical_properties() + } + + case PlSqlParserCOLUMN, PlSqlParserLOB, PlSqlParserNESTED, PlSqlParserVARRAY, PlSqlParserXMLTYPE: + { + p.SetState(15332) + p.Column_properties() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15335) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15337) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(15341) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(15342) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15345) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLOCATOR || _la == PlSqlParserVALUE) { + 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 +} + +// INested_itemContext is an interface to support dynamic dispatch. +type INested_itemContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsNested_itemContext differentiates from other interfaces. + IsNested_itemContext() +} + +type Nested_itemContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNested_itemContext() *Nested_itemContext { + var p = new(Nested_itemContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_item + return p +} + +func InitEmptyNested_itemContext(p *Nested_itemContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_nested_item +} + +func (*Nested_itemContext) IsNested_itemContext() {} + +func NewNested_itemContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Nested_itemContext { + var p = new(Nested_itemContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_nested_item + + return p +} + +func (s *Nested_itemContext) GetParser() antlr.Parser { return s.parser } + +func (s *Nested_itemContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Nested_itemContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Nested_itemContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Nested_itemContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNested_item(s) + } +} + +func (s *Nested_itemContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNested_item(s) + } +} + +func (s *Nested_itemContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNested_item(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Nested_item() (localctx INested_itemContext) { + localctx = NewNested_itemContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1700, PlSqlParserRULE_nested_item) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15348) + p.Regular_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 +} + +// ISubstitutable_column_clauseContext is an interface to support dynamic dispatch. +type ISubstitutable_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IS() antlr.TerminalNode + OF() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Type_name() IType_nameContext + RIGHT_PAREN() antlr.TerminalNode + ELEMENT() antlr.TerminalNode + TYPE() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + AT() antlr.TerminalNode + ALL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + NOT() antlr.TerminalNode + + // IsSubstitutable_column_clauseContext differentiates from other interfaces. + IsSubstitutable_column_clauseContext() +} + +type Substitutable_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubstitutable_column_clauseContext() *Substitutable_column_clauseContext { + var p = new(Substitutable_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause + return p +} + +func InitEmptySubstitutable_column_clauseContext(p *Substitutable_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause +} + +func (*Substitutable_column_clauseContext) IsSubstitutable_column_clauseContext() {} + +func NewSubstitutable_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Substitutable_column_clauseContext { + var p = new(Substitutable_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_substitutable_column_clause + + return p +} + +func (s *Substitutable_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Substitutable_column_clauseContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Substitutable_column_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Substitutable_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Substitutable_column_clauseContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Substitutable_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Substitutable_column_clauseContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Substitutable_column_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Substitutable_column_clauseContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Substitutable_column_clauseContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Substitutable_column_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Substitutable_column_clauseContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Substitutable_column_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Substitutable_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Substitutable_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Substitutable_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubstitutable_column_clause(s) + } +} + +func (s *Substitutable_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubstitutable_column_clause(s) + } +} + +func (s *Substitutable_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubstitutable_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Substitutable_column_clause() (localctx ISubstitutable_column_clauseContext) { + localctx = NewSubstitutable_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1702, PlSqlParserRULE_substitutable_column_clause) + var _la int + + p.SetState(15369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserELEMENT, PlSqlParserIS: + p.EnterOuterAlt(localctx, 1) + p.SetState(15351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELEMENT { + { + p.SetState(15350) + p.Match(PlSqlParserELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15353) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15354) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15356) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(15355) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15358) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15359) + p.Type_name() + } + { + p.SetState(15360) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOT, PlSqlParserSUBSTITUTABLE: + p.EnterOuterAlt(localctx, 2) + p.SetState(15363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15362) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15365) + p.Match(PlSqlParserSUBSTITUTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15366) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15367) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15368) + p.Match(PlSqlParserLEVELS) + 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_nameContext is an interface to support dynamic dispatch. +type IPartition_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + DELIMITED_ID() antlr.TerminalNode + + // IsPartition_nameContext differentiates from other interfaces. + IsPartition_nameContext() +} + +type Partition_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_nameContext() *Partition_nameContext { + var p = new(Partition_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name + return p +} + +func InitEmptyPartition_nameContext(p *Partition_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_name +} + +func (*Partition_nameContext) IsPartition_nameContext() {} + +func NewPartition_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_nameContext { + var p = new(Partition_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_name + + return p +} + +func (s *Partition_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_nameContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Partition_nameContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Partition_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_name(s) + } +} + +func (s *Partition_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_name(s) + } +} + +func (s *Partition_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_name() (localctx IPartition_nameContext) { + localctx = NewPartition_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1704, PlSqlParserRULE_partition_name) + p.SetState(15373) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15371) + p.Regular_id() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15372) + p.Match(PlSqlParserDELIMITED_ID) + 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 +} + +// ISupplemental_logging_propsContext is an interface to support dynamic dispatch. +type ISupplemental_logging_propsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUPPLEMENTAL() antlr.TerminalNode + LOG() antlr.TerminalNode + Supplemental_log_grp_clause() ISupplemental_log_grp_clauseContext + Supplemental_id_key_clause() ISupplemental_id_key_clauseContext + + // IsSupplemental_logging_propsContext differentiates from other interfaces. + IsSupplemental_logging_propsContext() +} + +type Supplemental_logging_propsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySupplemental_logging_propsContext() *Supplemental_logging_propsContext { + var p = new(Supplemental_logging_propsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props + return p +} + +func InitEmptySupplemental_logging_propsContext(p *Supplemental_logging_propsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props +} + +func (*Supplemental_logging_propsContext) IsSupplemental_logging_propsContext() {} + +func NewSupplemental_logging_propsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Supplemental_logging_propsContext { + var p = new(Supplemental_logging_propsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_supplemental_logging_props + + return p +} + +func (s *Supplemental_logging_propsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Supplemental_logging_propsContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Supplemental_logging_propsContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Supplemental_logging_propsContext) Supplemental_log_grp_clause() ISupplemental_log_grp_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_log_grp_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_log_grp_clauseContext) +} + +func (s *Supplemental_logging_propsContext) Supplemental_id_key_clause() ISupplemental_id_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISupplemental_id_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISupplemental_id_key_clauseContext) +} + +func (s *Supplemental_logging_propsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Supplemental_logging_propsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Supplemental_logging_propsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSupplemental_logging_props(s) + } +} + +func (s *Supplemental_logging_propsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSupplemental_logging_props(s) + } +} + +func (s *Supplemental_logging_propsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSupplemental_logging_props(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Supplemental_logging_props() (localctx ISupplemental_logging_propsContext) { + localctx = NewSupplemental_logging_propsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1706, PlSqlParserRULE_supplemental_logging_props) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15375) + p.Match(PlSqlParserSUPPLEMENTAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15376) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + { + p.SetState(15377) + p.Supplemental_log_grp_clause() + } + + case PlSqlParserDATA: + { + p.SetState(15378) + p.Supplemental_id_key_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 +} + +// IColumn_or_attributeContext is an interface to support dynamic dispatch. +type IColumn_or_attributeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + + // IsColumn_or_attributeContext differentiates from other interfaces. + IsColumn_or_attributeContext() +} + +type Column_or_attributeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_or_attributeContext() *Column_or_attributeContext { + var p = new(Column_or_attributeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_or_attribute + return p +} + +func InitEmptyColumn_or_attributeContext(p *Column_or_attributeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_or_attribute +} + +func (*Column_or_attributeContext) IsColumn_or_attributeContext() {} + +func NewColumn_or_attributeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_or_attributeContext { + var p = new(Column_or_attributeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_or_attribute + + return p +} + +func (s *Column_or_attributeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_or_attributeContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Column_or_attributeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_or_attributeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_or_attributeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_or_attribute(s) + } +} + +func (s *Column_or_attributeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_or_attribute(s) + } +} + +func (s *Column_or_attributeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_or_attribute(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_or_attribute() (localctx IColumn_or_attributeContext) { + localctx = NewColumn_or_attributeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1708, PlSqlParserRULE_column_or_attribute) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15381) + p.Regular_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_type_col_propertiesContext is an interface to support dynamic dispatch. +type IObject_type_col_propertiesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetColumn returns the column rule contexts. + GetColumn() IRegular_idContext + + // SetColumn sets the column rule contexts. + SetColumn(IRegular_idContext) + + // Getter signatures + COLUMN() antlr.TerminalNode + Substitutable_column_clause() ISubstitutable_column_clauseContext + Regular_id() IRegular_idContext + + // IsObject_type_col_propertiesContext differentiates from other interfaces. + IsObject_type_col_propertiesContext() +} + +type Object_type_col_propertiesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + column IRegular_idContext +} + +func NewEmptyObject_type_col_propertiesContext() *Object_type_col_propertiesContext { + var p = new(Object_type_col_propertiesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_col_properties + return p +} + +func InitEmptyObject_type_col_propertiesContext(p *Object_type_col_propertiesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_object_type_col_properties +} + +func (*Object_type_col_propertiesContext) IsObject_type_col_propertiesContext() {} + +func NewObject_type_col_propertiesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Object_type_col_propertiesContext { + var p = new(Object_type_col_propertiesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_object_type_col_properties + + return p +} + +func (s *Object_type_col_propertiesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_type_col_propertiesContext) GetColumn() IRegular_idContext { return s.column } + +func (s *Object_type_col_propertiesContext) SetColumn(v IRegular_idContext) { s.column = v } + +func (s *Object_type_col_propertiesContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Object_type_col_propertiesContext) Substitutable_column_clause() ISubstitutable_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubstitutable_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubstitutable_column_clauseContext) +} + +func (s *Object_type_col_propertiesContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Object_type_col_propertiesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Object_type_col_propertiesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Object_type_col_propertiesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterObject_type_col_properties(s) + } +} + +func (s *Object_type_col_propertiesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_type_col_properties(s) + } +} + +func (s *Object_type_col_propertiesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_type_col_properties(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_type_col_properties() (localctx IObject_type_col_propertiesContext) { + localctx = NewObject_type_col_propertiesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1710, PlSqlParserRULE_object_type_col_properties) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15383) + p.Match(PlSqlParserCOLUMN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15384) + + var _x = p.Regular_id() + + localctx.(*Object_type_col_propertiesContext).column = _x + } + { + p.SetState(15385) + p.Substitutable_column_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 +} + +// IConstraint_clausesContext is an interface to support dynamic dispatch. +type IConstraint_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext + AllOut_of_line_constraint() []IOut_of_line_constraintContext + Out_of_line_constraint(i int) IOut_of_line_constraintContext + MODIFY() antlr.TerminalNode + Constraint_state() IConstraint_stateContext + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + CASCADE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RENAME() antlr.TerminalNode + Old_constraint_name() IOld_constraint_nameContext + TO() antlr.TerminalNode + New_constraint_name() INew_constraint_nameContext + AllDrop_constraint_clause() []IDrop_constraint_clauseContext + Drop_constraint_clause(i int) IDrop_constraint_clauseContext + + // IsConstraint_clausesContext differentiates from other interfaces. + IsConstraint_clausesContext() +} + +type Constraint_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_clausesContext() *Constraint_clausesContext { + var p = new(Constraint_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_clauses + return p +} + +func InitEmptyConstraint_clausesContext(p *Constraint_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_clauses +} + +func (*Constraint_clausesContext) IsConstraint_clausesContext() {} + +func NewConstraint_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_clausesContext { + var p = new(Constraint_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_clauses + + return p +} + +func (s *Constraint_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_clausesContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Constraint_clausesContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Constraint_clausesContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Constraint_clausesContext) Out_of_line_ref_constraint() IOut_of_line_ref_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_ref_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_ref_constraintContext) +} + +func (s *Constraint_clausesContext) AllOut_of_line_constraint() []IOut_of_line_constraintContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + len++ + } + } + + tst := make([]IOut_of_line_constraintContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOut_of_line_constraintContext); ok { + tst[i] = t.(IOut_of_line_constraintContext) + i++ + } + } + + return tst +} + +func (s *Constraint_clausesContext) Out_of_line_constraint(i int) IOut_of_line_constraintContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOut_of_line_constraintContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOut_of_line_constraintContext) +} + +func (s *Constraint_clausesContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Constraint_clausesContext) Constraint_state() IConstraint_stateContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_stateContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_stateContext) +} + +func (s *Constraint_clausesContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Constraint_clausesContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Constraint_clausesContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Constraint_clausesContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Constraint_clausesContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Constraint_clausesContext) 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 *Constraint_clausesContext) 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 *Constraint_clausesContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Constraint_clausesContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Constraint_clausesContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Constraint_clausesContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Constraint_clausesContext) Old_constraint_name() IOld_constraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOld_constraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOld_constraint_nameContext) +} + +func (s *Constraint_clausesContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Constraint_clausesContext) New_constraint_name() INew_constraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INew_constraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INew_constraint_nameContext) +} + +func (s *Constraint_clausesContext) AllDrop_constraint_clause() []IDrop_constraint_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDrop_constraint_clauseContext); ok { + len++ + } + } + + tst := make([]IDrop_constraint_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDrop_constraint_clauseContext); ok { + tst[i] = t.(IDrop_constraint_clauseContext) + i++ + } + } + + return tst +} + +func (s *Constraint_clausesContext) Drop_constraint_clause(i int) IDrop_constraint_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_constraint_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDrop_constraint_clauseContext) +} + +func (s *Constraint_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_clauses(s) + } +} + +func (s *Constraint_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_clauses(s) + } +} + +func (s *Constraint_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstraint_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constraint_clauses() (localctx IConstraint_clausesContext) { + localctx = NewConstraint_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1712, PlSqlParserRULE_constraint_clauses) + var _la int + + var _alt int + + p.SetState(15443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2058, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15387) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15388) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2051, p.GetParserRuleContext()) { + case 1: + p.SetState(15392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE { + { + p.SetState(15389) + p.Out_of_line_constraint() + } + + p.SetState(15394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(15395) + p.Out_of_line_ref_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(15398) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15399) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15407) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2053, p.GetParserRuleContext()) { + case 1: + p.SetState(15403) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCHECK || _la == PlSqlParserCONSTRAINT || _la == PlSqlParserFOREIGN || _la == PlSqlParserPRIMARY || _la == PlSqlParserUNIQUE { + { + p.SetState(15400) + p.Out_of_line_constraint() + } + + p.SetState(15405) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(15406) + p.Out_of_line_ref_constraint() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15409) + p.Match(PlSqlParserMODIFY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15426) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONSTRAINT: + { + p.SetState(15410) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15411) + p.Constraint_name() + } + + case PlSqlParserPRIMARY: + { + p.SetState(15412) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15413) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(15414) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15415) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15416) + p.Column_name() + } + p.SetState(15421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15417) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15418) + p.Column_name() + } + + p.SetState(15423) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15424) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15428) + p.Constraint_state() + } + p.SetState(15430) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(15429) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15432) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15433) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15434) + p.Old_constraint_name() + } + { + p.SetState(15435) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15436) + p.New_constraint_name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + p.SetState(15439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(15438) + p.Drop_constraint_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15441) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2057, 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 +} + +// IOld_constraint_nameContext is an interface to support dynamic dispatch. +type IOld_constraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constraint_name() IConstraint_nameContext + + // IsOld_constraint_nameContext differentiates from other interfaces. + IsOld_constraint_nameContext() +} + +type Old_constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOld_constraint_nameContext() *Old_constraint_nameContext { + var p = new(Old_constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_constraint_name + return p +} + +func InitEmptyOld_constraint_nameContext(p *Old_constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_old_constraint_name +} + +func (*Old_constraint_nameContext) IsOld_constraint_nameContext() {} + +func NewOld_constraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Old_constraint_nameContext { + var p = new(Old_constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_old_constraint_name + + return p +} + +func (s *Old_constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Old_constraint_nameContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Old_constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Old_constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Old_constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOld_constraint_name(s) + } +} + +func (s *Old_constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOld_constraint_name(s) + } +} + +func (s *Old_constraint_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOld_constraint_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Old_constraint_name() (localctx IOld_constraint_nameContext) { + localctx = NewOld_constraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1714, PlSqlParserRULE_old_constraint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15445) + p.Constraint_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 +} + +// INew_constraint_nameContext is an interface to support dynamic dispatch. +type INew_constraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Constraint_name() IConstraint_nameContext + + // IsNew_constraint_nameContext differentiates from other interfaces. + IsNew_constraint_nameContext() +} + +type New_constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNew_constraint_nameContext() *New_constraint_nameContext { + var p = new(New_constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_constraint_name + return p +} + +func InitEmptyNew_constraint_nameContext(p *New_constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_new_constraint_name +} + +func (*New_constraint_nameContext) IsNew_constraint_nameContext() {} + +func NewNew_constraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *New_constraint_nameContext { + var p = new(New_constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_new_constraint_name + + return p +} + +func (s *New_constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *New_constraint_nameContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *New_constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *New_constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *New_constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNew_constraint_name(s) + } +} + +func (s *New_constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNew_constraint_name(s) + } +} + +func (s *New_constraint_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNew_constraint_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) New_constraint_name() (localctx INew_constraint_nameContext) { + localctx = NewNew_constraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1716, PlSqlParserRULE_new_constraint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15447) + p.Constraint_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_constraint_clauseContext is an interface to support dynamic dispatch. +type IDrop_constraint_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + Drop_primary_key_or_unique_or_generic_clause() IDrop_primary_key_or_unique_or_generic_clauseContext + + // IsDrop_constraint_clauseContext differentiates from other interfaces. + IsDrop_constraint_clauseContext() +} + +type Drop_constraint_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_constraint_clauseContext() *Drop_constraint_clauseContext { + var p = new(Drop_constraint_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause + return p +} + +func InitEmptyDrop_constraint_clauseContext(p *Drop_constraint_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause +} + +func (*Drop_constraint_clauseContext) IsDrop_constraint_clauseContext() {} + +func NewDrop_constraint_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_constraint_clauseContext { + var p = new(Drop_constraint_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_constraint_clause + + return p +} + +func (s *Drop_constraint_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_constraint_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_constraint_clauseContext) Drop_primary_key_or_unique_or_generic_clause() IDrop_primary_key_or_unique_or_generic_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDrop_primary_key_or_unique_or_generic_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDrop_primary_key_or_unique_or_generic_clauseContext) +} + +func (s *Drop_constraint_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_constraint_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_constraint_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_constraint_clause(s) + } +} + +func (s *Drop_constraint_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_constraint_clause(s) + } +} + +func (s *Drop_constraint_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_constraint_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_constraint_clause() (localctx IDrop_constraint_clauseContext) { + localctx = NewDrop_constraint_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1718, PlSqlParserRULE_drop_constraint_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15449) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15450) + p.Drop_primary_key_or_unique_or_generic_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 +} + +// IDrop_primary_key_or_unique_or_generic_clauseContext is an interface to support dynamic dispatch. +type IDrop_primary_key_or_unique_or_generic_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + RIGHT_PAREN() antlr.TerminalNode + CASCADE() antlr.TerminalNode + KEEP() antlr.TerminalNode + DROP() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsDrop_primary_key_or_unique_or_generic_clauseContext differentiates from other interfaces. + IsDrop_primary_key_or_unique_or_generic_clauseContext() +} + +type Drop_primary_key_or_unique_or_generic_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_primary_key_or_unique_or_generic_clauseContext() *Drop_primary_key_or_unique_or_generic_clauseContext { + var p = new(Drop_primary_key_or_unique_or_generic_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_primary_key_or_unique_or_generic_clause + return p +} + +func InitEmptyDrop_primary_key_or_unique_or_generic_clauseContext(p *Drop_primary_key_or_unique_or_generic_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_primary_key_or_unique_or_generic_clause +} + +func (*Drop_primary_key_or_unique_or_generic_clauseContext) IsDrop_primary_key_or_unique_or_generic_clauseContext() { +} + +func NewDrop_primary_key_or_unique_or_generic_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_primary_key_or_unique_or_generic_clauseContext { + var p = new(Drop_primary_key_or_unique_or_generic_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_primary_key_or_unique_or_generic_clause + + return p +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) GetParser() antlr.Parser { + return s.parser +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) 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 *Drop_primary_key_or_unique_or_generic_clauseContext) 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 *Drop_primary_key_or_unique_or_generic_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_primary_key_or_unique_or_generic_clause(s) + } +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_primary_key_or_unique_or_generic_clause(s) + } +} + +func (s *Drop_primary_key_or_unique_or_generic_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_primary_key_or_unique_or_generic_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_primary_key_or_unique_or_generic_clause() (localctx IDrop_primary_key_or_unique_or_generic_clauseContext) { + localctx = NewDrop_primary_key_or_unique_or_generic_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1720, PlSqlParserRULE_drop_primary_key_or_unique_or_generic_clause) + var _la int + + p.SetState(15479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY, PlSqlParserUNIQUE: + p.EnterOuterAlt(localctx, 1) + p.SetState(15466) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY: + { + p.SetState(15452) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15453) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + { + p.SetState(15454) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15455) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15456) + p.Column_name() + } + p.SetState(15461) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15457) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15458) + p.Column_name() + } + + p.SetState(15463) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15464) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15469) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(15468) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15472) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2062, p.GetParserRuleContext()) == 1 { + { + p.SetState(15471) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCONSTRAINT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15474) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15475) + p.Constraint_name() + } + p.SetState(15477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCASCADE { + { + p.SetState(15476) + p.Match(PlSqlParserCASCADE) + 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 +} + +// IAdd_constraintContext is an interface to support dynamic dispatch. +type IAdd_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ADD() antlr.TerminalNode + AllAdd_constraint_clause() []IAdd_constraint_clauseContext + Add_constraint_clause(i int) IAdd_constraint_clauseContext + AllCONSTRAINT() []antlr.TerminalNode + CONSTRAINT(i int) antlr.TerminalNode + AllConstraint_name() []IConstraint_nameContext + Constraint_name(i int) IConstraint_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsAdd_constraintContext differentiates from other interfaces. + IsAdd_constraintContext() +} + +type Add_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_constraintContext() *Add_constraintContext { + var p = new(Add_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_constraint + return p +} + +func InitEmptyAdd_constraintContext(p *Add_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_constraint +} + +func (*Add_constraintContext) IsAdd_constraintContext() {} + +func NewAdd_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_constraintContext { + var p = new(Add_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_constraint + + return p +} + +func (s *Add_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_constraintContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Add_constraintContext) AllAdd_constraint_clause() []IAdd_constraint_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IAdd_constraint_clauseContext); ok { + len++ + } + } + + tst := make([]IAdd_constraint_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IAdd_constraint_clauseContext); ok { + tst[i] = t.(IAdd_constraint_clauseContext) + i++ + } + } + + return tst +} + +func (s *Add_constraintContext) Add_constraint_clause(i int) IAdd_constraint_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAdd_constraint_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IAdd_constraint_clauseContext) +} + +func (s *Add_constraintContext) AllCONSTRAINT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCONSTRAINT) +} + +func (s *Add_constraintContext) CONSTRAINT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, i) +} + +func (s *Add_constraintContext) AllConstraint_name() []IConstraint_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraint_nameContext); ok { + len++ + } + } + + tst := make([]IConstraint_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraint_nameContext); ok { + tst[i] = t.(IConstraint_nameContext) + i++ + } + } + + return tst +} + +func (s *Add_constraintContext) Constraint_name(i int) IConstraint_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Add_constraintContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Add_constraintContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Add_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_constraint(s) + } +} + +func (s *Add_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_constraint(s) + } +} + +func (s *Add_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_constraint() (localctx IAdd_constraintContext) { + localctx = NewAdd_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1722, PlSqlParserRULE_add_constraint) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15481) + p.Match(PlSqlParserADD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15484) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(15482) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15483) + p.Constraint_name() + } + + } + { + p.SetState(15486) + p.Add_constraint_clause() + } + p.SetState(15493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(15487) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONSTRAINT { + { + p.SetState(15488) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15489) + p.Constraint_name() + } + + } + { + p.SetState(15492) + p.Add_constraint_clause() + } + + p.SetState(15495) + 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 +} + +// IAdd_constraint_clauseContext is an interface to support dynamic dispatch. +type IAdd_constraint_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Primary_key_clause() IPrimary_key_clauseContext + Foreign_key_clause() IForeign_key_clauseContext + Unique_key_clause() IUnique_key_clauseContext + Check_constraint() ICheck_constraintContext + + // IsAdd_constraint_clauseContext differentiates from other interfaces. + IsAdd_constraint_clauseContext() +} + +type Add_constraint_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAdd_constraint_clauseContext() *Add_constraint_clauseContext { + var p = new(Add_constraint_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_constraint_clause + return p +} + +func InitEmptyAdd_constraint_clauseContext(p *Add_constraint_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_add_constraint_clause +} + +func (*Add_constraint_clauseContext) IsAdd_constraint_clauseContext() {} + +func NewAdd_constraint_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Add_constraint_clauseContext { + var p = new(Add_constraint_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_add_constraint_clause + + return p +} + +func (s *Add_constraint_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Add_constraint_clauseContext) Primary_key_clause() IPrimary_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrimary_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrimary_key_clauseContext) +} + +func (s *Add_constraint_clauseContext) Foreign_key_clause() IForeign_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForeign_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForeign_key_clauseContext) +} + +func (s *Add_constraint_clauseContext) Unique_key_clause() IUnique_key_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnique_key_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnique_key_clauseContext) +} + +func (s *Add_constraint_clauseContext) Check_constraint() ICheck_constraintContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICheck_constraintContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICheck_constraintContext) +} + +func (s *Add_constraint_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Add_constraint_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Add_constraint_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAdd_constraint_clause(s) + } +} + +func (s *Add_constraint_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAdd_constraint_clause(s) + } +} + +func (s *Add_constraint_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAdd_constraint_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Add_constraint_clause() (localctx IAdd_constraint_clauseContext) { + localctx = NewAdd_constraint_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1724, PlSqlParserRULE_add_constraint_clause) + p.SetState(15501) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserPRIMARY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15497) + p.Primary_key_clause() + } + + case PlSqlParserFOREIGN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15498) + p.Foreign_key_clause() + } + + case PlSqlParserUNIQUE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15499) + p.Unique_key_clause() + } + + case PlSqlParserCHECK: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15500) + p.Check_constraint() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICheck_constraintContext is an interface to support dynamic dispatch. +type ICheck_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHECK() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + DISABLE() antlr.TerminalNode + + // IsCheck_constraintContext differentiates from other interfaces. + IsCheck_constraintContext() +} + +type Check_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCheck_constraintContext() *Check_constraintContext { + var p = new(Check_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_constraint + return p +} + +func InitEmptyCheck_constraintContext(p *Check_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_check_constraint +} + +func (*Check_constraintContext) IsCheck_constraintContext() {} + +func NewCheck_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Check_constraintContext { + var p = new(Check_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_check_constraint + + return p +} + +func (s *Check_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Check_constraintContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Check_constraintContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Check_constraintContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Check_constraintContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Check_constraintContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Check_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Check_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Check_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCheck_constraint(s) + } +} + +func (s *Check_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCheck_constraint(s) + } +} + +func (s *Check_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCheck_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Check_constraint() (localctx ICheck_constraintContext) { + localctx = NewCheck_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1726, PlSqlParserRULE_check_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15503) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15504) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15505) + p.Condition() + } + { + p.SetState(15506) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15508) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2069, p.GetParserRuleContext()) == 1 { + { + p.SetState(15507) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDrop_constraintContext is an interface to support dynamic dispatch. +type IDrop_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DROP() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsDrop_constraintContext differentiates from other interfaces. + IsDrop_constraintContext() +} + +type Drop_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDrop_constraintContext() *Drop_constraintContext { + var p = new(Drop_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint + return p +} + +func InitEmptyDrop_constraintContext(p *Drop_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_drop_constraint +} + +func (*Drop_constraintContext) IsDrop_constraintContext() {} + +func NewDrop_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Drop_constraintContext { + var p = new(Drop_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_drop_constraint + + return p +} + +func (s *Drop_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Drop_constraintContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *Drop_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Drop_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Drop_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Drop_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Drop_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDrop_constraint(s) + } +} + +func (s *Drop_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDrop_constraint(s) + } +} + +func (s *Drop_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDrop_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Drop_constraint() (localctx IDrop_constraintContext) { + localctx = NewDrop_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1728, PlSqlParserRULE_drop_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15510) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15511) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15512) + p.Constraint_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 +} + +// IEnable_constraintContext is an interface to support dynamic dispatch. +type IEnable_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENABLE() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsEnable_constraintContext differentiates from other interfaces. + IsEnable_constraintContext() +} + +type Enable_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyEnable_constraintContext() *Enable_constraintContext { + var p = new(Enable_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_constraint + return p +} + +func InitEmptyEnable_constraintContext(p *Enable_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_enable_constraint +} + +func (*Enable_constraintContext) IsEnable_constraintContext() {} + +func NewEnable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Enable_constraintContext { + var p = new(Enable_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_enable_constraint + + return p +} + +func (s *Enable_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Enable_constraintContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Enable_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Enable_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Enable_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Enable_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Enable_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterEnable_constraint(s) + } +} + +func (s *Enable_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitEnable_constraint(s) + } +} + +func (s *Enable_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitEnable_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Enable_constraint() (localctx IEnable_constraintContext) { + localctx = NewEnable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1730, PlSqlParserRULE_enable_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15514) + p.Match(PlSqlParserENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15515) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15516) + p.Constraint_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 +} + +// IDisable_constraintContext is an interface to support dynamic dispatch. +type IDisable_constraintContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DISABLE() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsDisable_constraintContext differentiates from other interfaces. + IsDisable_constraintContext() +} + +type Disable_constraintContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDisable_constraintContext() *Disable_constraintContext { + var p = new(Disable_constraintContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_constraint + return p +} + +func InitEmptyDisable_constraintContext(p *Disable_constraintContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_disable_constraint +} + +func (*Disable_constraintContext) IsDisable_constraintContext() {} + +func NewDisable_constraintContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Disable_constraintContext { + var p = new(Disable_constraintContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_disable_constraint + + return p +} + +func (s *Disable_constraintContext) GetParser() antlr.Parser { return s.parser } + +func (s *Disable_constraintContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Disable_constraintContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Disable_constraintContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Disable_constraintContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Disable_constraintContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Disable_constraintContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDisable_constraint(s) + } +} + +func (s *Disable_constraintContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDisable_constraint(s) + } +} + +func (s *Disable_constraintContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDisable_constraint(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Disable_constraint() (localctx IDisable_constraintContext) { + localctx = NewDisable_constraintContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1732, PlSqlParserRULE_disable_constraint) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15518) + p.Match(PlSqlParserDISABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15519) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15520) + p.Constraint_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 +} + +// IForeign_key_clauseContext is an interface to support dynamic dispatch. +type IForeign_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOREIGN() antlr.TerminalNode + KEY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + References_clause() IReferences_clauseContext + On_delete_clause() IOn_delete_clauseContext + + // IsForeign_key_clauseContext differentiates from other interfaces. + IsForeign_key_clauseContext() +} + +type Foreign_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForeign_key_clauseContext() *Foreign_key_clauseContext { + var p = new(Foreign_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_foreign_key_clause + return p +} + +func InitEmptyForeign_key_clauseContext(p *Foreign_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_foreign_key_clause +} + +func (*Foreign_key_clauseContext) IsForeign_key_clauseContext() {} + +func NewForeign_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Foreign_key_clauseContext { + var p = new(Foreign_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_foreign_key_clause + + return p +} + +func (s *Foreign_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Foreign_key_clauseContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Foreign_key_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Foreign_key_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Foreign_key_clauseContext) References_clause() IReferences_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReferences_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReferences_clauseContext) +} + +func (s *Foreign_key_clauseContext) On_delete_clause() IOn_delete_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOn_delete_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOn_delete_clauseContext) +} + +func (s *Foreign_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Foreign_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Foreign_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForeign_key_clause(s) + } +} + +func (s *Foreign_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForeign_key_clause(s) + } +} + +func (s *Foreign_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitForeign_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Foreign_key_clause() (localctx IForeign_key_clauseContext) { + localctx = NewForeign_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1734, PlSqlParserRULE_foreign_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15522) + p.Match(PlSqlParserFOREIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15523) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15524) + p.Paren_column_list() + } + { + p.SetState(15525) + p.References_clause() + } + p.SetState(15527) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(15526) + p.On_delete_clause() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReferences_clauseContext is an interface to support dynamic dispatch. +type IReferences_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCES() antlr.TerminalNode + Tableview_name() ITableview_nameContext + Paren_column_list() IParen_column_listContext + ON() antlr.TerminalNode + DELETE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsReferences_clauseContext differentiates from other interfaces. + IsReferences_clauseContext() +} + +type References_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReferences_clauseContext() *References_clauseContext { + var p = new(References_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_references_clause + return p +} + +func InitEmptyReferences_clauseContext(p *References_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_references_clause +} + +func (*References_clauseContext) IsReferences_clauseContext() {} + +func NewReferences_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *References_clauseContext { + var p = new(References_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_references_clause + + return p +} + +func (s *References_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *References_clauseContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *References_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *References_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *References_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *References_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *References_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *References_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *References_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *References_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *References_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *References_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReferences_clause(s) + } +} + +func (s *References_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReferences_clause(s) + } +} + +func (s *References_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReferences_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) References_clause() (localctx IReferences_clauseContext) { + localctx = NewReferences_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1736, PlSqlParserRULE_references_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15529) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15530) + p.Tableview_name() + } + p.SetState(15532) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15531) + p.Paren_column_list() + } + + } + p.SetState(15541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2073, p.GetParserRuleContext()) == 1 { + { + p.SetState(15534) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15535) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15539) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(15536) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + { + p.SetState(15537) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15538) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IOn_delete_clauseContext is an interface to support dynamic dispatch. +type IOn_delete_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + DELETE() antlr.TerminalNode + CASCADE() antlr.TerminalNode + SET() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsOn_delete_clauseContext differentiates from other interfaces. + IsOn_delete_clauseContext() +} + +type On_delete_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOn_delete_clauseContext() *On_delete_clauseContext { + var p = new(On_delete_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_delete_clause + return p +} + +func InitEmptyOn_delete_clauseContext(p *On_delete_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_on_delete_clause +} + +func (*On_delete_clauseContext) IsOn_delete_clauseContext() {} + +func NewOn_delete_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *On_delete_clauseContext { + var p = new(On_delete_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_on_delete_clause + + return p +} + +func (s *On_delete_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *On_delete_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *On_delete_clauseContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *On_delete_clauseContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *On_delete_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *On_delete_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *On_delete_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *On_delete_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *On_delete_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOn_delete_clause(s) + } +} + +func (s *On_delete_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOn_delete_clause(s) + } +} + +func (s *On_delete_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOn_delete_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) On_delete_clause() (localctx IOn_delete_clauseContext) { + localctx = NewOn_delete_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1738, PlSqlParserRULE_on_delete_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15543) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15544) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15548) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCASCADE: + { + p.SetState(15545) + p.Match(PlSqlParserCASCADE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSET: + { + p.SetState(15546) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15547) + p.Match(PlSqlParserNULL_) + 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 +} + +// IUnique_key_clauseContext is an interface to support dynamic dispatch. +type IUnique_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNIQUE() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + Using_index_clause() IUsing_index_clauseContext + + // IsUnique_key_clauseContext differentiates from other interfaces. + IsUnique_key_clauseContext() +} + +type Unique_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnique_key_clauseContext() *Unique_key_clauseContext { + var p = new(Unique_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unique_key_clause + return p +} + +func InitEmptyUnique_key_clauseContext(p *Unique_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unique_key_clause +} + +func (*Unique_key_clauseContext) IsUnique_key_clauseContext() {} + +func NewUnique_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unique_key_clauseContext { + var p = new(Unique_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unique_key_clause + + return p +} + +func (s *Unique_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unique_key_clauseContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Unique_key_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Unique_key_clauseContext) Using_index_clause() IUsing_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Unique_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unique_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unique_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnique_key_clause(s) + } +} + +func (s *Unique_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnique_key_clause(s) + } +} + +func (s *Unique_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnique_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unique_key_clause() (localctx IUnique_key_clauseContext) { + localctx = NewUnique_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1740, PlSqlParserRULE_unique_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15550) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15551) + p.Paren_column_list() + } + p.SetState(15553) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(15552) + p.Using_index_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 +} + +// IPrimary_key_clauseContext is an interface to support dynamic dispatch. +type IPrimary_key_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PRIMARY() antlr.TerminalNode + KEY() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + Using_index_clause() IUsing_index_clauseContext + + // IsPrimary_key_clauseContext differentiates from other interfaces. + IsPrimary_key_clauseContext() +} + +type Primary_key_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrimary_key_clauseContext() *Primary_key_clauseContext { + var p = new(Primary_key_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_key_clause + return p +} + +func InitEmptyPrimary_key_clauseContext(p *Primary_key_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_primary_key_clause +} + +func (*Primary_key_clauseContext) IsPrimary_key_clauseContext() {} + +func NewPrimary_key_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Primary_key_clauseContext { + var p = new(Primary_key_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_primary_key_clause + + return p +} + +func (s *Primary_key_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Primary_key_clauseContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Primary_key_clauseContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Primary_key_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Primary_key_clauseContext) Using_index_clause() IUsing_index_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_index_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_index_clauseContext) +} + +func (s *Primary_key_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Primary_key_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Primary_key_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrimary_key_clause(s) + } +} + +func (s *Primary_key_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrimary_key_clause(s) + } +} + +func (s *Primary_key_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrimary_key_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Primary_key_clause() (localctx IPrimary_key_clauseContext) { + localctx = NewPrimary_key_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1742, PlSqlParserRULE_primary_key_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15555) + p.Match(PlSqlParserPRIMARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15556) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15557) + p.Paren_column_list() + } + p.SetState(15559) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(15558) + p.Using_index_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 +} + +// IAnonymous_blockContext is an interface to support dynamic dispatch. +type IAnonymous_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + DECLARE() antlr.TerminalNode + Seq_of_declare_specs() ISeq_of_declare_specsContext + EXCEPTION() antlr.TerminalNode + AllException_handler() []IException_handlerContext + Exception_handler(i int) IException_handlerContext + + // IsAnonymous_blockContext differentiates from other interfaces. + IsAnonymous_blockContext() +} + +type Anonymous_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAnonymous_blockContext() *Anonymous_blockContext { + var p = new(Anonymous_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_anonymous_block + return p +} + +func InitEmptyAnonymous_blockContext(p *Anonymous_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_anonymous_block +} + +func (*Anonymous_blockContext) IsAnonymous_blockContext() {} + +func NewAnonymous_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Anonymous_blockContext { + var p = new(Anonymous_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_anonymous_block + + return p +} + +func (s *Anonymous_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Anonymous_blockContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Anonymous_blockContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Anonymous_blockContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Anonymous_blockContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Anonymous_blockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Anonymous_blockContext) Seq_of_declare_specs() ISeq_of_declare_specsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_declare_specsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_declare_specsContext) +} + +func (s *Anonymous_blockContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Anonymous_blockContext) AllException_handler() []IException_handlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_handlerContext); ok { + len++ + } + } + + tst := make([]IException_handlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_handlerContext); ok { + tst[i] = t.(IException_handlerContext) + i++ + } + } + + return tst +} + +func (s *Anonymous_blockContext) Exception_handler(i int) IException_handlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_handlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_handlerContext) +} + +func (s *Anonymous_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Anonymous_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Anonymous_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAnonymous_block(s) + } +} + +func (s *Anonymous_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAnonymous_block(s) + } +} + +func (s *Anonymous_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAnonymous_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Anonymous_block() (localctx IAnonymous_blockContext) { + localctx = NewAnonymous_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1744, PlSqlParserRULE_anonymous_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15563) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(15561) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15562) + p.Seq_of_declare_specs() + } + + } + { + p.SetState(15565) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15566) + p.Seq_of_statements() + } + p.SetState(15573) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTION { + { + p.SetState(15567) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(15568) + p.Exception_handler() + } + + p.SetState(15571) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(15575) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15576) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IInvoker_rights_clauseContext is an interface to support dynamic dispatch. +type IInvoker_rights_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AUTHID() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + DEFINER() antlr.TerminalNode + + // IsInvoker_rights_clauseContext differentiates from other interfaces. + IsInvoker_rights_clauseContext() +} + +type Invoker_rights_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInvoker_rights_clauseContext() *Invoker_rights_clauseContext { + var p = new(Invoker_rights_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause + return p +} + +func InitEmptyInvoker_rights_clauseContext(p *Invoker_rights_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause +} + +func (*Invoker_rights_clauseContext) IsInvoker_rights_clauseContext() {} + +func NewInvoker_rights_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Invoker_rights_clauseContext { + var p = new(Invoker_rights_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_invoker_rights_clause + + return p +} + +func (s *Invoker_rights_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Invoker_rights_clauseContext) AUTHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHID, 0) +} + +func (s *Invoker_rights_clauseContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Invoker_rights_clauseContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Invoker_rights_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Invoker_rights_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Invoker_rights_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInvoker_rights_clause(s) + } +} + +func (s *Invoker_rights_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInvoker_rights_clause(s) + } +} + +func (s *Invoker_rights_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInvoker_rights_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Invoker_rights_clause() (localctx IInvoker_rights_clauseContext) { + localctx = NewInvoker_rights_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1746, PlSqlParserRULE_invoker_rights_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15578) + p.Match(PlSqlParserAUTHID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15579) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCURRENT_USER || _la == PlSqlParserDEFINER) { + 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 +} + +// ICall_specContext is an interface to support dynamic dispatch. +type ICall_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LANGUAGE() antlr.TerminalNode + Java_spec() IJava_specContext + C_spec() IC_specContext + + // IsCall_specContext differentiates from other interfaces. + IsCall_specContext() +} + +type Call_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCall_specContext() *Call_specContext { + var p = new(Call_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_spec + return p +} + +func InitEmptyCall_specContext(p *Call_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_spec +} + +func (*Call_specContext) IsCall_specContext() {} + +func NewCall_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Call_specContext { + var p = new(Call_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_call_spec + + return p +} + +func (s *Call_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Call_specContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Call_specContext) Java_spec() IJava_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJava_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJava_specContext) +} + +func (s *Call_specContext) C_spec() IC_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_specContext) +} + +func (s *Call_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Call_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Call_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCall_spec(s) + } +} + +func (s *Call_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCall_spec(s) + } +} + +func (s *Call_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCall_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Call_spec() (localctx ICall_specContext) { + localctx = NewCall_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1748, PlSqlParserRULE_call_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15581) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserJAVA: + { + p.SetState(15582) + p.Java_spec() + } + + case PlSqlParserC_LETTER: + { + p.SetState(15583) + p.C_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJava_specContext is an interface to support dynamic dispatch. +type IJava_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JAVA() antlr.TerminalNode + NAME() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + + // IsJava_specContext differentiates from other interfaces. + IsJava_specContext() +} + +type Java_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJava_specContext() *Java_specContext { + var p = new(Java_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_java_spec + return p +} + +func InitEmptyJava_specContext(p *Java_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_java_spec +} + +func (*Java_specContext) IsJava_specContext() {} + +func NewJava_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Java_specContext { + var p = new(Java_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_java_spec + + return p +} + +func (s *Java_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Java_specContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Java_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Java_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Java_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Java_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Java_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJava_spec(s) + } +} + +func (s *Java_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJava_spec(s) + } +} + +func (s *Java_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJava_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Java_spec() (localctx IJava_specContext) { + localctx = NewJava_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1750, PlSqlParserRULE_java_spec) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15586) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15587) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15588) + p.Match(PlSqlParserCHAR_STRING) + 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 +} + +// IC_specContext is an interface to support dynamic dispatch. +type IC_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + C_LETTER() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + Identifier() IIdentifierContext + NAME() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + C_agent_in_clause() IC_agent_in_clauseContext + WITH() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + C_parameters_clause() IC_parameters_clauseContext + + // IsC_specContext differentiates from other interfaces. + IsC_specContext() +} + +type C_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_specContext() *C_specContext { + var p = new(C_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_spec + return p +} + +func InitEmptyC_specContext(p *C_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_spec +} + +func (*C_specContext) IsC_specContext() {} + +func NewC_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_specContext { + var p = new(C_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_spec + + return p +} + +func (s *C_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_specContext) C_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserC_LETTER, 0) +} + +func (s *C_specContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *C_specContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *C_specContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *C_specContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *C_specContext) C_agent_in_clause() IC_agent_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_agent_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_agent_in_clauseContext) +} + +func (s *C_specContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *C_specContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *C_specContext) C_parameters_clause() IC_parameters_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IC_parameters_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IC_parameters_clauseContext) +} + +func (s *C_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_spec(s) + } +} + +func (s *C_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_spec(s) + } +} + +func (s *C_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitC_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) C_spec() (localctx IC_specContext) { + localctx = NewC_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1752, PlSqlParserRULE_c_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15590) + p.Match(PlSqlParserC_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNAME { + { + p.SetState(15591) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15592) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15595) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15596) + p.Identifier() + } + p.SetState(15598) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAGENT { + { + p.SetState(15597) + p.C_agent_in_clause() + } + + } + p.SetState(15602) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(15600) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15601) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15605) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARAMETERS { + { + p.SetState(15604) + p.C_parameters_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 +} + +// IC_agent_in_clauseContext is an interface to support dynamic dispatch. +type IC_agent_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AGENT() antlr.TerminalNode + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + RIGHT_PAREN() antlr.TerminalNode + + // IsC_agent_in_clauseContext differentiates from other interfaces. + IsC_agent_in_clauseContext() +} + +type C_agent_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_agent_in_clauseContext() *C_agent_in_clauseContext { + var p = new(C_agent_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause + return p +} + +func InitEmptyC_agent_in_clauseContext(p *C_agent_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause +} + +func (*C_agent_in_clauseContext) IsC_agent_in_clauseContext() {} + +func NewC_agent_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_agent_in_clauseContext { + var p = new(C_agent_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_agent_in_clause + + return p +} + +func (s *C_agent_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_agent_in_clauseContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *C_agent_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *C_agent_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *C_agent_in_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *C_agent_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *C_agent_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_agent_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_agent_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_agent_in_clause(s) + } +} + +func (s *C_agent_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_agent_in_clause(s) + } +} + +func (s *C_agent_in_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitC_agent_in_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) C_agent_in_clause() (localctx IC_agent_in_clauseContext) { + localctx = NewC_agent_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1754, PlSqlParserRULE_c_agent_in_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15607) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15608) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15609) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15610) + p.Expressions() + } + { + p.SetState(15611) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IC_parameters_clauseContext is an interface to support dynamic dispatch. +type IC_parameters_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARAMETERS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsC_parameters_clauseContext differentiates from other interfaces. + IsC_parameters_clauseContext() +} + +type C_parameters_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyC_parameters_clauseContext() *C_parameters_clauseContext { + var p = new(C_parameters_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_parameters_clause + return p +} + +func InitEmptyC_parameters_clauseContext(p *C_parameters_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_c_parameters_clause +} + +func (*C_parameters_clauseContext) IsC_parameters_clauseContext() {} + +func NewC_parameters_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *C_parameters_clauseContext { + var p = new(C_parameters_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_c_parameters_clause + + return p +} + +func (s *C_parameters_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *C_parameters_clauseContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *C_parameters_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *C_parameters_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *C_parameters_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *C_parameters_clauseContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *C_parameters_clauseContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *C_parameters_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *C_parameters_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *C_parameters_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterC_parameters_clause(s) + } +} + +func (s *C_parameters_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitC_parameters_clause(s) + } +} + +func (s *C_parameters_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitC_parameters_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) C_parameters_clause() (localctx IC_parameters_clauseContext) { + localctx = NewC_parameters_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1756, PlSqlParserRULE_c_parameters_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15613) + p.Match(PlSqlParserPARAMETERS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15614) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2085, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15615) + p.Expressions() + } + + case 2: + { + p.SetState(15616) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15617) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15618) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(15621) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameterContext is an interface to support dynamic dispatch. +type IParameterContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + Default_value_part() IDefault_value_partContext + AllIN() []antlr.TerminalNode + IN(i int) antlr.TerminalNode + AllOUT() []antlr.TerminalNode + OUT(i int) antlr.TerminalNode + AllINOUT() []antlr.TerminalNode + INOUT(i int) antlr.TerminalNode + AllNOCOPY() []antlr.TerminalNode + NOCOPY(i int) antlr.TerminalNode + + // IsParameterContext differentiates from other interfaces. + IsParameterContext() +} + +type ParameterContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameterContext() *ParameterContext { + var p = new(ParameterContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter + return p +} + +func InitEmptyParameterContext(p *ParameterContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter +} + +func (*ParameterContext) IsParameterContext() {} + +func NewParameterContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParameterContext { + var p = new(ParameterContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter + + return p +} + +func (s *ParameterContext) GetParser() antlr.Parser { return s.parser } + +func (s *ParameterContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *ParameterContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *ParameterContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *ParameterContext) AllIN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIN) +} + +func (s *ParameterContext) IN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, i) +} + +func (s *ParameterContext) AllOUT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOUT) +} + +func (s *ParameterContext) OUT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, i) +} + +func (s *ParameterContext) AllINOUT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINOUT) +} + +func (s *ParameterContext) INOUT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINOUT, i) +} + +func (s *ParameterContext) AllNOCOPY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOCOPY) +} + +func (s *ParameterContext) NOCOPY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOPY, i) +} + +func (s *ParameterContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ParameterContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ParameterContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter(s) + } +} + +func (s *ParameterContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter(s) + } +} + +func (s *ParameterContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParameter(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parameter() (localctx IParameterContext) { + localctx = NewParameterContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1758, PlSqlParserRULE_parameter) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15623) + p.Parameter_name() + } + p.SetState(15627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2086, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(15624) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIN || _la == PlSqlParserINOUT || _la == PlSqlParserNOCOPY || _la == PlSqlParserOUT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(15629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2086, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(15631) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864812498945) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1025) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(15630) + p.Type_spec() + } + + } + p.SetState(15634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(15633) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_value_partContext is an interface to support dynamic dispatch. +type IDefault_value_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + ASSIGN_OP() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsDefault_value_partContext differentiates from other interfaces. + IsDefault_value_partContext() +} + +type Default_value_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDefault_value_partContext() *Default_value_partContext { + var p = new(Default_value_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_value_part + return p +} + +func InitEmptyDefault_value_partContext(p *Default_value_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_default_value_part +} + +func (*Default_value_partContext) IsDefault_value_partContext() {} + +func NewDefault_value_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Default_value_partContext { + var p = new(Default_value_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_default_value_part + + return p +} + +func (s *Default_value_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Default_value_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Default_value_partContext) ASSIGN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN_OP, 0) +} + +func (s *Default_value_partContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Default_value_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Default_value_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Default_value_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDefault_value_part(s) + } +} + +func (s *Default_value_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDefault_value_part(s) + } +} + +func (s *Default_value_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDefault_value_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Default_value_part() (localctx IDefault_value_partContext) { + localctx = NewDefault_value_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1760, PlSqlParserRULE_default_value_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15636) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(15637) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeq_of_declare_specsContext is an interface to support dynamic dispatch. +type ISeq_of_declare_specsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsSeq_of_declare_specsContext differentiates from other interfaces. + IsSeq_of_declare_specsContext() +} + +type Seq_of_declare_specsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeq_of_declare_specsContext() *Seq_of_declare_specsContext { + var p = new(Seq_of_declare_specsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs + return p +} + +func InitEmptySeq_of_declare_specsContext(p *Seq_of_declare_specsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs +} + +func (*Seq_of_declare_specsContext) IsSeq_of_declare_specsContext() {} + +func NewSeq_of_declare_specsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seq_of_declare_specsContext { + var p = new(Seq_of_declare_specsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seq_of_declare_specs + + return p +} + +func (s *Seq_of_declare_specsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seq_of_declare_specsContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_declare_specsContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *Seq_of_declare_specsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seq_of_declare_specsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seq_of_declare_specsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeq_of_declare_specs(s) + } +} + +func (s *Seq_of_declare_specsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeq_of_declare_specs(s) + } +} + +func (s *Seq_of_declare_specsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSeq_of_declare_specs(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Seq_of_declare_specs() (localctx ISeq_of_declare_specsContext) { + localctx = NewSeq_of_declare_specsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1762, PlSqlParserRULE_seq_of_declare_specs) + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(15639) + p.Declare_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15642) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2089, 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 +} + +// IDeclare_specContext is an interface to support dynamic dispatch. +type IDeclare_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pragma_declaration() IPragma_declarationContext + Exception_declaration() IException_declarationContext + Variable_declaration() IVariable_declarationContext + Subtype_declaration() ISubtype_declarationContext + Cursor_declaration() ICursor_declarationContext + Type_declaration() IType_declarationContext + Procedure_spec() IProcedure_specContext + Function_spec() IFunction_specContext + Procedure_body() IProcedure_bodyContext + Function_body() IFunction_bodyContext + + // IsDeclare_specContext differentiates from other interfaces. + IsDeclare_specContext() +} + +type Declare_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDeclare_specContext() *Declare_specContext { + var p = new(Declare_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_declare_spec + return p +} + +func InitEmptyDeclare_specContext(p *Declare_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_declare_spec +} + +func (*Declare_specContext) IsDeclare_specContext() {} + +func NewDeclare_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Declare_specContext { + var p = new(Declare_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_declare_spec + + return p +} + +func (s *Declare_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Declare_specContext) Pragma_declaration() IPragma_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPragma_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPragma_declarationContext) +} + +func (s *Declare_specContext) Exception_declaration() IException_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_declarationContext) +} + +func (s *Declare_specContext) Variable_declaration() IVariable_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_declarationContext) +} + +func (s *Declare_specContext) Subtype_declaration() ISubtype_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubtype_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubtype_declarationContext) +} + +func (s *Declare_specContext) Cursor_declaration() ICursor_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_declarationContext) +} + +func (s *Declare_specContext) Type_declaration() IType_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_declarationContext) +} + +func (s *Declare_specContext) Procedure_spec() IProcedure_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_specContext) +} + +func (s *Declare_specContext) Function_spec() IFunction_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_specContext) +} + +func (s *Declare_specContext) Procedure_body() IProcedure_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IProcedure_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IProcedure_bodyContext) +} + +func (s *Declare_specContext) Function_body() IFunction_bodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_bodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_bodyContext) +} + +func (s *Declare_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Declare_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Declare_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDeclare_spec(s) + } +} + +func (s *Declare_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDeclare_spec(s) + } +} + +func (s *Declare_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDeclare_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Declare_spec() (localctx IDeclare_specContext) { + localctx = NewDeclare_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1764, PlSqlParserRULE_declare_spec) + p.SetState(15654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2090, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15644) + p.Pragma_declaration() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15645) + p.Exception_declaration() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15646) + p.Variable_declaration() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15647) + p.Subtype_declaration() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(15648) + p.Cursor_declaration() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(15649) + p.Type_declaration() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(15650) + p.Procedure_spec() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(15651) + p.Function_spec() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(15652) + p.Procedure_body() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(15653) + p.Function_body() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_declarationContext is an interface to support dynamic dispatch. +type IVariable_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Default_value_part() IDefault_value_partContext + + // IsVariable_declarationContext differentiates from other interfaces. + IsVariable_declarationContext() +} + +type Variable_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_declarationContext() *Variable_declarationContext { + var p = new(Variable_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_declaration + return p +} + +func InitEmptyVariable_declarationContext(p *Variable_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_declaration +} + +func (*Variable_declarationContext) IsVariable_declarationContext() {} + +func NewVariable_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_declarationContext { + var p = new(Variable_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_variable_declaration + + return p +} + +func (s *Variable_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Variable_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Variable_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Variable_declarationContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Variable_declarationContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Variable_declarationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Variable_declarationContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Variable_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVariable_declaration(s) + } +} + +func (s *Variable_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVariable_declaration(s) + } +} + +func (s *Variable_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVariable_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Variable_declaration() (localctx IVariable_declarationContext) { + localctx = NewVariable_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1766, PlSqlParserRULE_variable_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15656) + p.Identifier() + } + p.SetState(15658) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2091, p.GetParserRuleContext()) == 1 { + { + p.SetState(15657) + p.Match(PlSqlParserCONSTANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15660) + p.Type_spec() + } + p.SetState(15663) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15661) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15662) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15666) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(15665) + p.Default_value_part() + } + + } + { + p.SetState(15668) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ISubtype_declarationContext is an interface to support dynamic dispatch. +type ISubtype_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBTYPE() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + Type_spec() IType_specContext + SEMICOLON() antlr.TerminalNode + RANGE() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + DOUBLE_PERIOD() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsSubtype_declarationContext differentiates from other interfaces. + IsSubtype_declarationContext() +} + +type Subtype_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubtype_declarationContext() *Subtype_declarationContext { + var p = new(Subtype_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subtype_declaration + return p +} + +func InitEmptySubtype_declarationContext(p *Subtype_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subtype_declaration +} + +func (*Subtype_declarationContext) IsSubtype_declarationContext() {} + +func NewSubtype_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subtype_declarationContext { + var p = new(Subtype_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subtype_declaration + + return p +} + +func (s *Subtype_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subtype_declarationContext) SUBTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBTYPE, 0) +} + +func (s *Subtype_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Subtype_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Subtype_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Subtype_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Subtype_declarationContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Subtype_declarationContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Subtype_declarationContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Subtype_declarationContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Subtype_declarationContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Subtype_declarationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Subtype_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subtype_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subtype_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubtype_declaration(s) + } +} + +func (s *Subtype_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubtype_declaration(s) + } +} + +func (s *Subtype_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubtype_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subtype_declaration() (localctx ISubtype_declarationContext) { + localctx = NewSubtype_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1768, PlSqlParserRULE_subtype_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15670) + p.Match(PlSqlParserSUBTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15671) + p.Identifier() + } + { + p.SetState(15672) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15673) + p.Type_spec() + } + p.SetState(15679) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRANGE { + { + p.SetState(15674) + p.Match(PlSqlParserRANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15675) + p.Expression() + } + { + p.SetState(15676) + p.Match(PlSqlParserDOUBLE_PERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15677) + p.Expression() + } + + } + p.SetState(15683) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15681) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15682) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15685) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ICursor_declarationContext is an interface to support dynamic dispatch. +type ICursor_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURSOR() antlr.TerminalNode + Identifier() IIdentifierContext + SEMICOLON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllParameter_spec() []IParameter_specContext + Parameter_spec(i int) IParameter_specContext + RIGHT_PAREN() antlr.TerminalNode + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + IS() antlr.TerminalNode + Select_statement() ISelect_statementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsCursor_declarationContext differentiates from other interfaces. + IsCursor_declarationContext() +} + +type Cursor_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_declarationContext() *Cursor_declarationContext { + var p = new(Cursor_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_declaration + return p +} + +func InitEmptyCursor_declarationContext(p *Cursor_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_declaration +} + +func (*Cursor_declarationContext) IsCursor_declarationContext() {} + +func NewCursor_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_declarationContext { + var p = new(Cursor_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_declaration + + return p +} + +func (s *Cursor_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_declarationContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Cursor_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Cursor_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Cursor_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_declarationContext) AllParameter_spec() []IParameter_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IParameter_specContext); ok { + len++ + } + } + + tst := make([]IParameter_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IParameter_specContext); ok { + tst[i] = t.(IParameter_specContext) + i++ + } + } + + return tst +} + +func (s *Cursor_declarationContext) Parameter_spec(i int) IParameter_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IParameter_specContext) +} + +func (s *Cursor_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_declarationContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Cursor_declarationContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Cursor_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Cursor_declarationContext) 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 *Cursor_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cursor_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cursor_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_declaration(s) + } +} + +func (s *Cursor_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_declaration(s) + } +} + +func (s *Cursor_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCursor_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cursor_declaration() (localctx ICursor_declarationContext) { + localctx = NewCursor_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1770, PlSqlParserRULE_cursor_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15687) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15688) + p.Identifier() + } + p.SetState(15700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15689) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15690) + p.Parameter_spec() + } + p.SetState(15695) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15691) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15692) + p.Parameter_spec() + } + + p.SetState(15697) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15698) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(15702) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15703) + p.Type_spec() + } + + } + p.SetState(15708) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIS { + { + p.SetState(15706) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15707) + p.Select_statement() + } + + } + { + p.SetState(15710) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IParameter_specContext is an interface to support dynamic dispatch. +type IParameter_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Parameter_name() IParameter_nameContext + Type_spec() IType_specContext + Default_value_part() IDefault_value_partContext + IN() antlr.TerminalNode + + // IsParameter_specContext differentiates from other interfaces. + IsParameter_specContext() +} + +type Parameter_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_specContext() *Parameter_specContext { + var p = new(Parameter_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_spec + return p +} + +func InitEmptyParameter_specContext(p *Parameter_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_spec +} + +func (*Parameter_specContext) IsParameter_specContext() {} + +func NewParameter_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_specContext { + var p = new(Parameter_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_spec + + return p +} + +func (s *Parameter_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_specContext) Parameter_name() IParameter_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParameter_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParameter_nameContext) +} + +func (s *Parameter_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Parameter_specContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Parameter_specContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Parameter_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_spec(s) + } +} + +func (s *Parameter_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_spec(s) + } +} + +func (s *Parameter_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParameter_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parameter_spec() (localctx IParameter_specContext) { + localctx = NewParameter_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1772, PlSqlParserRULE_parameter_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15712) + p.Parameter_name() + } + p.SetState(15717) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864812498945) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144115188076380161) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1025) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + p.SetState(15714) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIN { + { + p.SetState(15713) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(15716) + p.Type_spec() + } + + } + p.SetState(15720) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(15719) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IException_declarationContext is an interface to support dynamic dispatch. +type IException_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + EXCEPTION() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + + // IsException_declarationContext differentiates from other interfaces. + IsException_declarationContext() +} + +type Exception_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_declarationContext() *Exception_declarationContext { + var p = new(Exception_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_declaration + return p +} + +func InitEmptyException_declarationContext(p *Exception_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_declaration +} + +func (*Exception_declarationContext) IsException_declarationContext() {} + +func NewException_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_declarationContext { + var p = new(Exception_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_declaration + + return p +} + +func (s *Exception_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Exception_declarationContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Exception_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Exception_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_declaration(s) + } +} + +func (s *Exception_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_declaration(s) + } +} + +func (s *Exception_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitException_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exception_declaration() (localctx IException_declarationContext) { + localctx = NewException_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1774, PlSqlParserRULE_exception_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15722) + p.Identifier() + } + { + p.SetState(15723) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15724) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IPragma_declarationContext is an interface to support dynamic dispatch. +type IPragma_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetId1 returns the id1 rule contexts. + GetId1() IIdentifierContext + + // SetId1 sets the id1 rule contexts. + SetId1(IIdentifierContext) + + // Getter signatures + PRAGMA() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + SERIALLY_REUSABLE() antlr.TerminalNode + AUTONOMOUS_TRANSACTION() antlr.TerminalNode + EXCEPTION_INIT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Exception_name() IException_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Numeric_negative() INumeric_negativeContext + RIGHT_PAREN() antlr.TerminalNode + INLINE() antlr.TerminalNode + Expression() IExpressionContext + RESTRICT_REFERENCES() antlr.TerminalNode + AllIdentifier() []IIdentifierContext + Identifier(i int) IIdentifierContext + DEFAULT() antlr.TerminalNode + + // IsPragma_declarationContext differentiates from other interfaces. + IsPragma_declarationContext() +} + +type Pragma_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + id1 IIdentifierContext +} + +func NewEmptyPragma_declarationContext() *Pragma_declarationContext { + var p = new(Pragma_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_declaration + return p +} + +func InitEmptyPragma_declarationContext(p *Pragma_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pragma_declaration +} + +func (*Pragma_declarationContext) IsPragma_declarationContext() {} + +func NewPragma_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pragma_declarationContext { + var p = new(Pragma_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pragma_declaration + + return p +} + +func (s *Pragma_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pragma_declarationContext) GetId1() IIdentifierContext { return s.id1 } + +func (s *Pragma_declarationContext) SetId1(v IIdentifierContext) { s.id1 = v } + +func (s *Pragma_declarationContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Pragma_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Pragma_declarationContext) SERIALLY_REUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALLY_REUSABLE, 0) +} + +func (s *Pragma_declarationContext) AUTONOMOUS_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTONOMOUS_TRANSACTION, 0) +} + +func (s *Pragma_declarationContext) EXCEPTION_INIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION_INIT, 0) +} + +func (s *Pragma_declarationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pragma_declarationContext) Exception_name() IException_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Pragma_declarationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pragma_declarationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pragma_declarationContext) Numeric_negative() INumeric_negativeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_negativeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_negativeContext) +} + +func (s *Pragma_declarationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pragma_declarationContext) INLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE, 0) +} + +func (s *Pragma_declarationContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pragma_declarationContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Pragma_declarationContext) AllIdentifier() []IIdentifierContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IIdentifierContext); ok { + len++ + } + } + + tst := make([]IIdentifierContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IIdentifierContext); ok { + tst[i] = t.(IIdentifierContext) + i++ + } + } + + return tst +} + +func (s *Pragma_declarationContext) Identifier(i int) IIdentifierContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Pragma_declarationContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Pragma_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pragma_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pragma_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPragma_declaration(s) + } +} + +func (s *Pragma_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPragma_declaration(s) + } +} + +func (s *Pragma_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPragma_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pragma_declaration() (localctx IPragma_declarationContext) { + localctx = NewPragma_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1776, PlSqlParserRULE_pragma_declaration) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15726) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSERIALLY_REUSABLE: + { + p.SetState(15727) + p.Match(PlSqlParserSERIALLY_REUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAUTONOMOUS_TRANSACTION: + { + p.SetState(15728) + p.Match(PlSqlParserAUTONOMOUS_TRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCEPTION_INIT: + { + p.SetState(15729) + p.Match(PlSqlParserEXCEPTION_INIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15730) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15731) + p.Exception_name() + } + { + p.SetState(15732) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15733) + p.Numeric_negative() + } + { + p.SetState(15734) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINLINE: + { + p.SetState(15736) + p.Match(PlSqlParserINLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15737) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15738) + + var _x = p.Identifier() + + localctx.(*Pragma_declarationContext).id1 = _x + } + { + p.SetState(15739) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15740) + p.Expression() + } + { + p.SetState(15741) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRESTRICT_REFERENCES: + { + p.SetState(15743) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15744) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15747) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(15745) + p.Identifier() + } + + case PlSqlParserDEFAULT: + { + p.SetState(15746) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(15751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserCOMMA { + { + p.SetState(15749) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15750) + p.Identifier() + } + + p.SetState(15753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15755) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15759) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// IRecord_type_defContext is an interface to support dynamic dispatch. +type IRecord_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RECORD() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllField_spec() []IField_specContext + Field_spec(i int) IField_specContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRecord_type_defContext differentiates from other interfaces. + IsRecord_type_defContext() +} + +type Record_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecord_type_defContext() *Record_type_defContext { + var p = new(Record_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_type_def + return p +} + +func InitEmptyRecord_type_defContext(p *Record_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_type_def +} + +func (*Record_type_defContext) IsRecord_type_defContext() {} + +func NewRecord_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Record_type_defContext { + var p = new(Record_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_record_type_def + + return p +} + +func (s *Record_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Record_type_defContext) RECORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORD, 0) +} + +func (s *Record_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Record_type_defContext) AllField_spec() []IField_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IField_specContext); ok { + len++ + } + } + + tst := make([]IField_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IField_specContext); ok { + tst[i] = t.(IField_specContext) + i++ + } + } + + return tst +} + +func (s *Record_type_defContext) Field_spec(i int) IField_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IField_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IField_specContext) +} + +func (s *Record_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Record_type_defContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Record_type_defContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Record_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Record_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Record_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecord_type_def(s) + } +} + +func (s *Record_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecord_type_def(s) + } +} + +func (s *Record_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRecord_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Record_type_def() (localctx IRecord_type_defContext) { + localctx = NewRecord_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1778, PlSqlParserRULE_record_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15761) + p.Match(PlSqlParserRECORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15762) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15763) + p.Field_spec() + } + p.SetState(15768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(15764) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15765) + p.Field_spec() + } + + p.SetState(15770) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(15771) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IField_specContext is an interface to support dynamic dispatch. +type IField_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Type_spec() IType_specContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + Default_value_part() IDefault_value_partContext + + // IsField_specContext differentiates from other interfaces. + IsField_specContext() +} + +type Field_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyField_specContext() *Field_specContext { + var p = new(Field_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_spec + return p +} + +func InitEmptyField_specContext(p *Field_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_field_spec +} + +func (*Field_specContext) IsField_specContext() {} + +func NewField_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Field_specContext { + var p = new(Field_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_field_spec + + return p +} + +func (s *Field_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Field_specContext) 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 *Field_specContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Field_specContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Field_specContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Field_specContext) Default_value_part() IDefault_value_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDefault_value_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDefault_value_partContext) +} + +func (s *Field_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Field_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Field_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterField_spec(s) + } +} + +func (s *Field_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitField_spec(s) + } +} + +func (s *Field_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitField_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Field_spec() (localctx IField_specContext) { + localctx = NewField_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1780, PlSqlParserRULE_field_spec) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15773) + p.Column_name() + } + p.SetState(15775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864812498945) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1025) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&2305843009213693951) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&274877906961) != 0) { + { + p.SetState(15774) + p.Type_spec() + } + + } + p.SetState(15779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15777) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15778) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(15782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT || _la == PlSqlParserASSIGN_OP { + { + p.SetState(15781) + p.Default_value_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRef_cursor_type_defContext is an interface to support dynamic dispatch. +type IRef_cursor_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REF() antlr.TerminalNode + CURSOR() antlr.TerminalNode + RETURN() antlr.TerminalNode + Type_spec() IType_specContext + + // IsRef_cursor_type_defContext differentiates from other interfaces. + IsRef_cursor_type_defContext() +} + +type Ref_cursor_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRef_cursor_type_defContext() *Ref_cursor_type_defContext { + var p = new(Ref_cursor_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def + return p +} + +func InitEmptyRef_cursor_type_defContext(p *Ref_cursor_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def +} + +func (*Ref_cursor_type_defContext) IsRef_cursor_type_defContext() {} + +func NewRef_cursor_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Ref_cursor_type_defContext { + var p = new(Ref_cursor_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_ref_cursor_type_def + + return p +} + +func (s *Ref_cursor_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Ref_cursor_type_defContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Ref_cursor_type_defContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Ref_cursor_type_defContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Ref_cursor_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Ref_cursor_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Ref_cursor_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Ref_cursor_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRef_cursor_type_def(s) + } +} + +func (s *Ref_cursor_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRef_cursor_type_def(s) + } +} + +func (s *Ref_cursor_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRef_cursor_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Ref_cursor_type_def() (localctx IRef_cursor_type_defContext) { + localctx = NewRef_cursor_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1782, PlSqlParserRULE_ref_cursor_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15784) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15785) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15788) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(15786) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15787) + p.Type_spec() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_declarationContext is an interface to support dynamic dispatch. +type IType_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TYPE() antlr.TerminalNode + Identifier() IIdentifierContext + IS() antlr.TerminalNode + SEMICOLON() antlr.TerminalNode + Table_type_def() ITable_type_defContext + Varray_type_def() IVarray_type_defContext + Record_type_def() IRecord_type_defContext + Ref_cursor_type_def() IRef_cursor_type_defContext + + // IsType_declarationContext differentiates from other interfaces. + IsType_declarationContext() +} + +type Type_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_declarationContext() *Type_declarationContext { + var p = new(Type_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_declaration + return p +} + +func InitEmptyType_declarationContext(p *Type_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_declaration +} + +func (*Type_declarationContext) IsType_declarationContext() {} + +func NewType_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_declarationContext { + var p = new(Type_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_declaration + + return p +} + +func (s *Type_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_declarationContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Type_declarationContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Type_declarationContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Type_declarationContext) SEMICOLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, 0) +} + +func (s *Type_declarationContext) Table_type_def() ITable_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_type_defContext) +} + +func (s *Type_declarationContext) Varray_type_def() IVarray_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVarray_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVarray_type_defContext) +} + +func (s *Type_declarationContext) Record_type_def() IRecord_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecord_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecord_type_defContext) +} + +func (s *Type_declarationContext) Ref_cursor_type_def() IRef_cursor_type_defContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRef_cursor_type_defContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRef_cursor_type_defContext) +} + +func (s *Type_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_declaration(s) + } +} + +func (s *Type_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_declaration(s) + } +} + +func (s *Type_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_declaration() (localctx IType_declarationContext) { + localctx = NewType_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1784, PlSqlParserRULE_type_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15790) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15791) + p.Identifier() + } + { + p.SetState(15792) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTABLE: + { + p.SetState(15793) + p.Table_type_def() + } + + case PlSqlParserVARRAY, PlSqlParserVARYING: + { + p.SetState(15794) + p.Varray_type_def() + } + + case PlSqlParserRECORD: + { + p.SetState(15795) + p.Record_type_def() + } + + case PlSqlParserREF: + { + p.SetState(15796) + p.Ref_cursor_type_def() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15799) + p.Match(PlSqlParserSEMICOLON) + 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 +} + +// ITable_type_defContext is an interface to support dynamic dispatch. +type ITable_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + Table_indexed_by_part() ITable_indexed_by_partContext + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsTable_type_defContext differentiates from other interfaces. + IsTable_type_defContext() +} + +type Table_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_type_defContext() *Table_type_defContext { + var p = new(Table_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_type_def + return p +} + +func InitEmptyTable_type_defContext(p *Table_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_type_def +} + +func (*Table_type_defContext) IsTable_type_defContext() {} + +func NewTable_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_type_defContext { + var p = new(Table_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_type_def + + return p +} + +func (s *Table_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_type_defContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Table_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Table_type_defContext) Table_indexed_by_part() ITable_indexed_by_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_indexed_by_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_indexed_by_partContext) +} + +func (s *Table_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Table_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Table_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_type_def(s) + } +} + +func (s *Table_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_type_def(s) + } +} + +func (s *Table_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_type_def() (localctx ITable_type_defContext) { + localctx = NewTable_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1786, PlSqlParserRULE_table_type_def) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15801) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15802) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15803) + p.Type_spec() + } + p.SetState(15805) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDEXED || _la == PlSqlParserINDEX { + { + p.SetState(15804) + p.Table_indexed_by_part() + } + + } + p.SetState(15809) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(15807) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15808) + p.Match(PlSqlParserNULL_) + 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 +} + +// ITable_indexed_by_partContext is an interface to support dynamic dispatch. +type ITable_indexed_by_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIdx1 returns the idx1 token. + GetIdx1() antlr.Token + + // GetIdx2 returns the idx2 token. + GetIdx2() antlr.Token + + // SetIdx1 sets the idx1 token. + SetIdx1(antlr.Token) + + // SetIdx2 sets the idx2 token. + SetIdx2(antlr.Token) + + // Getter signatures + BY() antlr.TerminalNode + Type_spec() IType_specContext + INDEXED() antlr.TerminalNode + INDEX() antlr.TerminalNode + + // IsTable_indexed_by_partContext differentiates from other interfaces. + IsTable_indexed_by_partContext() +} + +type Table_indexed_by_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + idx1 antlr.Token + idx2 antlr.Token +} + +func NewEmptyTable_indexed_by_partContext() *Table_indexed_by_partContext { + var p = new(Table_indexed_by_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part + return p +} + +func InitEmptyTable_indexed_by_partContext(p *Table_indexed_by_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part +} + +func (*Table_indexed_by_partContext) IsTable_indexed_by_partContext() {} + +func NewTable_indexed_by_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_indexed_by_partContext { + var p = new(Table_indexed_by_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_indexed_by_part + + return p +} + +func (s *Table_indexed_by_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_indexed_by_partContext) GetIdx1() antlr.Token { return s.idx1 } + +func (s *Table_indexed_by_partContext) GetIdx2() antlr.Token { return s.idx2 } + +func (s *Table_indexed_by_partContext) SetIdx1(v antlr.Token) { s.idx1 = v } + +func (s *Table_indexed_by_partContext) SetIdx2(v antlr.Token) { s.idx2 = v } + +func (s *Table_indexed_by_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Table_indexed_by_partContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Table_indexed_by_partContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *Table_indexed_by_partContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Table_indexed_by_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_indexed_by_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_indexed_by_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_indexed_by_part(s) + } +} + +func (s *Table_indexed_by_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_indexed_by_part(s) + } +} + +func (s *Table_indexed_by_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_indexed_by_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_indexed_by_part() (localctx ITable_indexed_by_partContext) { + localctx = NewTable_indexed_by_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1788, PlSqlParserRULE_table_indexed_by_part) + p.EnterOuterAlt(localctx, 1) + p.SetState(15813) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINDEXED: + { + p.SetState(15811) + + var _m = p.Match(PlSqlParserINDEXED) + + localctx.(*Table_indexed_by_partContext).idx1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDEX: + { + p.SetState(15812) + + var _m = p.Match(PlSqlParserINDEX) + + localctx.(*Table_indexed_by_partContext).idx2 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15815) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15816) + p.Type_spec() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVarray_type_defContext is an interface to support dynamic dispatch. +type IVarray_type_defContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + OF() antlr.TerminalNode + Type_spec() IType_specContext + VARRAY() antlr.TerminalNode + VARYING() antlr.TerminalNode + ARRAY() antlr.TerminalNode + NOT() antlr.TerminalNode + NULL_() antlr.TerminalNode + + // IsVarray_type_defContext differentiates from other interfaces. + IsVarray_type_defContext() +} + +type Varray_type_defContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVarray_type_defContext() *Varray_type_defContext { + var p = new(Varray_type_defContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_type_def + return p +} + +func InitEmptyVarray_type_defContext(p *Varray_type_defContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_varray_type_def +} + +func (*Varray_type_defContext) IsVarray_type_defContext() {} + +func NewVarray_type_defContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Varray_type_defContext { + var p = new(Varray_type_defContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_varray_type_def + + return p +} + +func (s *Varray_type_defContext) GetParser() antlr.Parser { return s.parser } + +func (s *Varray_type_defContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Varray_type_defContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Varray_type_defContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Varray_type_defContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Varray_type_defContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Varray_type_defContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Varray_type_defContext) VARYING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARYING, 0) +} + +func (s *Varray_type_defContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Varray_type_defContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Varray_type_defContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Varray_type_defContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Varray_type_defContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Varray_type_defContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVarray_type_def(s) + } +} + +func (s *Varray_type_defContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVarray_type_def(s) + } +} + +func (s *Varray_type_defContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVarray_type_def(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Varray_type_def() (localctx IVarray_type_defContext) { + localctx = NewVarray_type_defContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1790, PlSqlParserRULE_varray_type_def) + p.EnterOuterAlt(localctx, 1) + p.SetState(15821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARRAY: + { + p.SetState(15818) + p.Match(PlSqlParserVARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARYING: + { + p.SetState(15819) + p.Match(PlSqlParserVARYING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15820) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15823) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15824) + p.Expression() + } + { + p.SetState(15825) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15826) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15827) + p.Type_spec() + } + p.SetState(15830) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2116, p.GetParserRuleContext()) == 1 { + { + p.SetState(15828) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15829) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISeq_of_statementsContext is an interface to support dynamic dispatch. +type ISeq_of_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllStatement() []IStatementContext + Statement(i int) IStatementContext + AllLabel_declaration() []ILabel_declarationContext + Label_declaration(i int) ILabel_declarationContext + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + AllEOF() []antlr.TerminalNode + EOF(i int) antlr.TerminalNode + + // IsSeq_of_statementsContext differentiates from other interfaces. + IsSeq_of_statementsContext() +} + +type Seq_of_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeq_of_statementsContext() *Seq_of_statementsContext { + var p = new(Seq_of_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_statements + return p +} + +func InitEmptySeq_of_statementsContext(p *Seq_of_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seq_of_statements +} + +func (*Seq_of_statementsContext) IsSeq_of_statementsContext() {} + +func NewSeq_of_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seq_of_statementsContext { + var p = new(Seq_of_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seq_of_statements + + return p +} + +func (s *Seq_of_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seq_of_statementsContext) AllStatement() []IStatementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IStatementContext); ok { + len++ + } + } + + tst := make([]IStatementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IStatementContext); ok { + tst[i] = t.(IStatementContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Statement(i int) IStatementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IStatementContext) +} + +func (s *Seq_of_statementsContext) AllLabel_declaration() []ILabel_declarationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_declarationContext); ok { + len++ + } + } + + tst := make([]ILabel_declarationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_declarationContext); ok { + tst[i] = t.(ILabel_declarationContext) + i++ + } + } + + return tst +} + +func (s *Seq_of_statementsContext) Label_declaration(i int) ILabel_declarationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Seq_of_statementsContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Seq_of_statementsContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Seq_of_statementsContext) AllEOF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEOF) +} + +func (s *Seq_of_statementsContext) EOF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEOF, i) +} + +func (s *Seq_of_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seq_of_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seq_of_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeq_of_statements(s) + } +} + +func (s *Seq_of_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeq_of_statements(s) + } +} + +func (s *Seq_of_statementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSeq_of_statements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Seq_of_statements() (localctx ISeq_of_statementsContext) { + localctx = NewSeq_of_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1792, PlSqlParserRULE_seq_of_statements) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + p.SetState(15836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2117, p.GetParserRuleContext()) { + case 1: + { + p.SetState(15832) + p.Statement() + } + { + p.SetState(15833) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEOF || _la == PlSqlParserSEMICOLON) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 2: + { + p.SetState(15835) + p.Label_declaration() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(15838) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2118, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILabel_declarationContext is an interface to support dynamic dispatch. +type ILabel_declarationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLtp1 returns the ltp1 token. + GetLtp1() antlr.Token + + // SetLtp1 sets the ltp1 token. + SetLtp1(antlr.Token) + + // Getter signatures + AllLESS_THAN_OP() []antlr.TerminalNode + LESS_THAN_OP(i int) antlr.TerminalNode + Label_name() ILabel_nameContext + AllGREATER_THAN_OP() []antlr.TerminalNode + GREATER_THAN_OP(i int) antlr.TerminalNode + + // IsLabel_declarationContext differentiates from other interfaces. + IsLabel_declarationContext() +} + +type Label_declarationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ltp1 antlr.Token +} + +func NewEmptyLabel_declarationContext() *Label_declarationContext { + var p = new(Label_declarationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_declaration + return p +} + +func InitEmptyLabel_declarationContext(p *Label_declarationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_declaration +} + +func (*Label_declarationContext) IsLabel_declarationContext() {} + +func NewLabel_declarationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_declarationContext { + var p = new(Label_declarationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_label_declaration + + return p +} + +func (s *Label_declarationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_declarationContext) GetLtp1() antlr.Token { return s.ltp1 } + +func (s *Label_declarationContext) SetLtp1(v antlr.Token) { s.ltp1 = v } + +func (s *Label_declarationContext) AllLESS_THAN_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLESS_THAN_OP) +} + +func (s *Label_declarationContext) LESS_THAN_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS_THAN_OP, i) +} + +func (s *Label_declarationContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Label_declarationContext) AllGREATER_THAN_OP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserGREATER_THAN_OP) +} + +func (s *Label_declarationContext) GREATER_THAN_OP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, i) +} + +func (s *Label_declarationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_declarationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_declarationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLabel_declaration(s) + } +} + +func (s *Label_declarationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLabel_declaration(s) + } +} + +func (s *Label_declarationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLabel_declaration(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Label_declaration() (localctx ILabel_declarationContext) { + localctx = NewLabel_declarationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1794, PlSqlParserRULE_label_declaration) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15840) + + var _m = p.Match(PlSqlParserLESS_THAN_OP) + + localctx.(*Label_declarationContext).ltp1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15841) + p.Match(PlSqlParserLESS_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15842) + p.Label_name() + } + { + p.SetState(15843) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15844) + p.Match(PlSqlParserGREATER_THAN_OP) + 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 +} + +// IStatementContext is an interface to support dynamic dispatch. +type IStatementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + Block() IBlockContext + Assignment_statement() IAssignment_statementContext + Continue_statement() IContinue_statementContext + Exit_statement() IExit_statementContext + Goto_statement() IGoto_statementContext + If_statement() IIf_statementContext + Loop_statement() ILoop_statementContext + Forall_statement() IForall_statementContext + Null_statement() INull_statementContext + Raise_statement() IRaise_statementContext + Return_statement() IReturn_statementContext + Case_statement() ICase_statementContext + Sql_statement() ISql_statementContext + Pipe_row_statement() IPipe_row_statementContext + Call_statement() ICall_statementContext + + // IsStatementContext differentiates from other interfaces. + IsStatementContext() +} + +type StatementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatementContext() *StatementContext { + var p = new(StatementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement + return p +} + +func InitEmptyStatementContext(p *StatementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_statement +} + +func (*StatementContext) IsStatementContext() {} + +func NewStatementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *StatementContext { + var p = new(StatementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_statement + + return p +} + +func (s *StatementContext) GetParser() antlr.Parser { return s.parser } + +func (s *StatementContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *StatementContext) Block() IBlockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBlockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBlockContext) +} + +func (s *StatementContext) Assignment_statement() IAssignment_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAssignment_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAssignment_statementContext) +} + +func (s *StatementContext) Continue_statement() IContinue_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IContinue_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IContinue_statementContext) +} + +func (s *StatementContext) Exit_statement() IExit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExit_statementContext) +} + +func (s *StatementContext) Goto_statement() IGoto_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGoto_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGoto_statementContext) +} + +func (s *StatementContext) If_statement() IIf_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIf_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIf_statementContext) +} + +func (s *StatementContext) Loop_statement() ILoop_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILoop_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILoop_statementContext) +} + +func (s *StatementContext) Forall_statement() IForall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IForall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IForall_statementContext) +} + +func (s *StatementContext) Null_statement() INull_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INull_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INull_statementContext) +} + +func (s *StatementContext) Raise_statement() IRaise_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRaise_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRaise_statementContext) +} + +func (s *StatementContext) Return_statement() IReturn_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_statementContext) +} + +func (s *StatementContext) Case_statement() ICase_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_statementContext) +} + +func (s *StatementContext) Sql_statement() ISql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_statementContext) +} + +func (s *StatementContext) Pipe_row_statement() IPipe_row_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPipe_row_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPipe_row_statementContext) +} + +func (s *StatementContext) Call_statement() ICall_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICall_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICall_statementContext) +} + +func (s *StatementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *StatementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *StatementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatement(s) + } +} + +func (s *StatementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatement(s) + } +} + +func (s *StatementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStatement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Statement() (localctx IStatementContext) { + localctx = NewStatementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1796, PlSqlParserRULE_statement) + p.SetState(15862) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2119, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15846) + p.Body() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15847) + p.Block() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15848) + p.Assignment_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(15849) + p.Continue_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(15850) + p.Exit_statement() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(15851) + p.Goto_statement() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(15852) + p.If_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(15853) + p.Loop_statement() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(15854) + p.Forall_statement() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(15855) + p.Null_statement() + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(15856) + p.Raise_statement() + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(15857) + p.Return_statement() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(15858) + p.Case_statement() + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(15859) + p.Sql_statement() + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(15860) + p.Pipe_row_statement() + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(15861) + p.Call_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 +} + +// ISwallow_to_semiContext is an interface to support dynamic dispatch. +type ISwallow_to_semiContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllSEMICOLON() []antlr.TerminalNode + SEMICOLON(i int) antlr.TerminalNode + + // IsSwallow_to_semiContext differentiates from other interfaces. + IsSwallow_to_semiContext() +} + +type Swallow_to_semiContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySwallow_to_semiContext() *Swallow_to_semiContext { + var p = new(Swallow_to_semiContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_swallow_to_semi + return p +} + +func InitEmptySwallow_to_semiContext(p *Swallow_to_semiContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_swallow_to_semi +} + +func (*Swallow_to_semiContext) IsSwallow_to_semiContext() {} + +func NewSwallow_to_semiContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Swallow_to_semiContext { + var p = new(Swallow_to_semiContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_swallow_to_semi + + return p +} + +func (s *Swallow_to_semiContext) GetParser() antlr.Parser { return s.parser } + +func (s *Swallow_to_semiContext) AllSEMICOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSEMICOLON) +} + +func (s *Swallow_to_semiContext) SEMICOLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMICOLON, i) +} + +func (s *Swallow_to_semiContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Swallow_to_semiContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Swallow_to_semiContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSwallow_to_semi(s) + } +} + +func (s *Swallow_to_semiContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSwallow_to_semi(s) + } +} + +func (s *Swallow_to_semiContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSwallow_to_semi(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Swallow_to_semi() (localctx ISwallow_to_semiContext) { + localctx = NewSwallow_to_semiContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1798, PlSqlParserRULE_swallow_to_semi) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15865) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-2) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-1) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-1) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-1) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-1) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&-1) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-1) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-1) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-1) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-1) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-1) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-1) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-1) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&-1) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-1) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-1) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&-1) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-1) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-1) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-1) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-1) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-1) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-1) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-1) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-1) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-1) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&-1) != 0) || ((int64((_la-2368)) & ^0x3f) == 0 && ((int64(1)<<(_la-2368))&2198754820095) != 0) { + { + p.SetState(15864) + _la = p.GetTokenStream().LA(1) + + if _la <= 0 || _la == PlSqlParserSEMICOLON { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + p.SetState(15867) + 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 +} + +// IAssignment_statementContext is an interface to support dynamic dispatch. +type IAssignment_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASSIGN_OP() antlr.TerminalNode + Expression() IExpressionContext + General_element() IGeneral_elementContext + Bind_variable() IBind_variableContext + + // IsAssignment_statementContext differentiates from other interfaces. + IsAssignment_statementContext() +} + +type Assignment_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAssignment_statementContext() *Assignment_statementContext { + var p = new(Assignment_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignment_statement + return p +} + +func InitEmptyAssignment_statementContext(p *Assignment_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_assignment_statement +} + +func (*Assignment_statementContext) IsAssignment_statementContext() {} + +func NewAssignment_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Assignment_statementContext { + var p = new(Assignment_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_assignment_statement + + return p +} + +func (s *Assignment_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Assignment_statementContext) ASSIGN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN_OP, 0) +} + +func (s *Assignment_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Assignment_statementContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Assignment_statementContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Assignment_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Assignment_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Assignment_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAssignment_statement(s) + } +} + +func (s *Assignment_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAssignment_statement(s) + } +} + +func (s *Assignment_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAssignment_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Assignment_statement() (localctx IAssignment_statementContext) { + localctx = NewAssignment_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1800, PlSqlParserRULE_assignment_statement) + p.EnterOuterAlt(localctx, 1) + p.SetState(15871) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(15869) + p.General_element() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(15870) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(15873) + p.Match(PlSqlParserASSIGN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15874) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContinue_statementContext is an interface to support dynamic dispatch. +type IContinue_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONTINUE() antlr.TerminalNode + Label_name() ILabel_nameContext + WHEN() antlr.TerminalNode + Condition() IConditionContext + + // IsContinue_statementContext differentiates from other interfaces. + IsContinue_statementContext() +} + +type Continue_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContinue_statementContext() *Continue_statementContext { + var p = new(Continue_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_continue_statement + return p +} + +func InitEmptyContinue_statementContext(p *Continue_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_continue_statement +} + +func (*Continue_statementContext) IsContinue_statementContext() {} + +func NewContinue_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Continue_statementContext { + var p = new(Continue_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_continue_statement + + return p +} + +func (s *Continue_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Continue_statementContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Continue_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Continue_statementContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Continue_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Continue_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Continue_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Continue_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContinue_statement(s) + } +} + +func (s *Continue_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContinue_statement(s) + } +} + +func (s *Continue_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitContinue_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Continue_statement() (localctx IContinue_statementContext) { + localctx = NewContinue_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1802, PlSqlParserRULE_continue_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15876) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15878) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2122, p.GetParserRuleContext()) == 1 { + { + p.SetState(15877) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15882) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2123, p.GetParserRuleContext()) == 1 { + { + p.SetState(15880) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15881) + p.Condition() + } + + } 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 +} + +// IExit_statementContext is an interface to support dynamic dispatch. +type IExit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXIT() antlr.TerminalNode + Label_name() ILabel_nameContext + WHEN() antlr.TerminalNode + Condition() IConditionContext + + // IsExit_statementContext differentiates from other interfaces. + IsExit_statementContext() +} + +type Exit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExit_statementContext() *Exit_statementContext { + var p = new(Exit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exit_statement + return p +} + +func InitEmptyExit_statementContext(p *Exit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exit_statement +} + +func (*Exit_statementContext) IsExit_statementContext() {} + +func NewExit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exit_statementContext { + var p = new(Exit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exit_statement + + return p +} + +func (s *Exit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exit_statementContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Exit_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Exit_statementContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Exit_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Exit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExit_statement(s) + } +} + +func (s *Exit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExit_statement(s) + } +} + +func (s *Exit_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExit_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exit_statement() (localctx IExit_statementContext) { + localctx = NewExit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1804, PlSqlParserRULE_exit_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15884) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15886) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2124, p.GetParserRuleContext()) == 1 { + { + p.SetState(15885) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(15890) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2125, p.GetParserRuleContext()) == 1 { + { + p.SetState(15888) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15889) + p.Condition() + } + + } 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 +} + +// IGoto_statementContext is an interface to support dynamic dispatch. +type IGoto_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GOTO() antlr.TerminalNode + Label_name() ILabel_nameContext + + // IsGoto_statementContext differentiates from other interfaces. + IsGoto_statementContext() +} + +type Goto_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGoto_statementContext() *Goto_statementContext { + var p = new(Goto_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_goto_statement + return p +} + +func InitEmptyGoto_statementContext(p *Goto_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_goto_statement +} + +func (*Goto_statementContext) IsGoto_statementContext() {} + +func NewGoto_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Goto_statementContext { + var p = new(Goto_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_goto_statement + + return p +} + +func (s *Goto_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Goto_statementContext) GOTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserGOTO, 0) +} + +func (s *Goto_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Goto_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Goto_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Goto_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGoto_statement(s) + } +} + +func (s *Goto_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGoto_statement(s) + } +} + +func (s *Goto_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGoto_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Goto_statement() (localctx IGoto_statementContext) { + localctx = NewGoto_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1806, PlSqlParserRULE_goto_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15892) + p.Match(PlSqlParserGOTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15893) + p.Label_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 +} + +// IIf_statementContext is an interface to support dynamic dispatch. +type IIf_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllIF() []antlr.TerminalNode + IF(i int) antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + AllElsif_part() []IElsif_partContext + Elsif_part(i int) IElsif_partContext + Else_part() IElse_partContext + + // IsIf_statementContext differentiates from other interfaces. + IsIf_statementContext() +} + +type If_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIf_statementContext() *If_statementContext { + var p = new(If_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_if_statement + return p +} + +func InitEmptyIf_statementContext(p *If_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_if_statement +} + +func (*If_statementContext) IsIf_statementContext() {} + +func NewIf_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *If_statementContext { + var p = new(If_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_if_statement + + return p +} + +func (s *If_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *If_statementContext) AllIF() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIF) +} + +func (s *If_statementContext) IF(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, i) +} + +func (s *If_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *If_statementContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *If_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *If_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *If_statementContext) AllElsif_part() []IElsif_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IElsif_partContext); ok { + len++ + } + } + + tst := make([]IElsif_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IElsif_partContext); ok { + tst[i] = t.(IElsif_partContext) + i++ + } + } + + return tst +} + +func (s *If_statementContext) Elsif_part(i int) IElsif_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElsif_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IElsif_partContext) +} + +func (s *If_statementContext) Else_part() IElse_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IElse_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IElse_partContext) +} + +func (s *If_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *If_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *If_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIf_statement(s) + } +} + +func (s *If_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIf_statement(s) + } +} + +func (s *If_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIf_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) If_statement() (localctx IIf_statementContext) { + localctx = NewIf_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1808, PlSqlParserRULE_if_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15895) + p.Match(PlSqlParserIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15896) + p.Condition() + } + { + p.SetState(15897) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15898) + p.Seq_of_statements() + } + p.SetState(15902) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserELSIF { + { + p.SetState(15899) + p.Elsif_part() + } + + p.SetState(15904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(15906) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(15905) + p.Else_part() + } + + } + { + p.SetState(15908) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15909) + p.Match(PlSqlParserIF) + 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 +} + +// IElsif_partContext is an interface to support dynamic dispatch. +type IElsif_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSIF() antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsElsif_partContext differentiates from other interfaces. + IsElsif_partContext() +} + +type Elsif_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElsif_partContext() *Elsif_partContext { + var p = new(Elsif_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_elsif_part + return p +} + +func InitEmptyElsif_partContext(p *Elsif_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_elsif_part +} + +func (*Elsif_partContext) IsElsif_partContext() {} + +func NewElsif_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Elsif_partContext { + var p = new(Elsif_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_elsif_part + + return p +} + +func (s *Elsif_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Elsif_partContext) ELSIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSIF, 0) +} + +func (s *Elsif_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Elsif_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Elsif_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Elsif_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Elsif_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Elsif_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElsif_part(s) + } +} + +func (s *Elsif_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElsif_part(s) + } +} + +func (s *Elsif_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitElsif_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Elsif_part() (localctx IElsif_partContext) { + localctx = NewElsif_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1810, PlSqlParserRULE_elsif_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15911) + p.Match(PlSqlParserELSIF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15912) + p.Condition() + } + { + p.SetState(15913) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15914) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IElse_partContext is an interface to support dynamic dispatch. +type IElse_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsElse_partContext differentiates from other interfaces. + IsElse_partContext() +} + +type Else_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyElse_partContext() *Else_partContext { + var p = new(Else_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_else_part + return p +} + +func InitEmptyElse_partContext(p *Else_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_else_part +} + +func (*Else_partContext) IsElse_partContext() {} + +func NewElse_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Else_partContext { + var p = new(Else_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_else_part + + return p +} + +func (s *Else_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Else_partContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Else_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Else_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Else_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Else_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterElse_part(s) + } +} + +func (s *Else_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitElse_part(s) + } +} + +func (s *Else_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitElse_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Else_part() (localctx IElse_partContext) { + localctx = NewElse_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1812, PlSqlParserRULE_else_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15916) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15917) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILoop_statementContext is an interface to support dynamic dispatch. +type ILoop_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllLOOP() []antlr.TerminalNode + LOOP(i int) antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + Label_declaration() ILabel_declarationContext + WHILE() antlr.TerminalNode + Condition() IConditionContext + FOR() antlr.TerminalNode + Cursor_loop_param() ICursor_loop_paramContext + Label_name() ILabel_nameContext + + // IsLoop_statementContext differentiates from other interfaces. + IsLoop_statementContext() +} + +type Loop_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLoop_statementContext() *Loop_statementContext { + var p = new(Loop_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_loop_statement + return p +} + +func InitEmptyLoop_statementContext(p *Loop_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_loop_statement +} + +func (*Loop_statementContext) IsLoop_statementContext() {} + +func NewLoop_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Loop_statementContext { + var p = new(Loop_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_loop_statement + + return p +} + +func (s *Loop_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Loop_statementContext) AllLOOP() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLOOP) +} + +func (s *Loop_statementContext) LOOP(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLOOP, i) +} + +func (s *Loop_statementContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Loop_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Loop_statementContext) Label_declaration() ILabel_declarationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_declarationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_declarationContext) +} + +func (s *Loop_statementContext) WHILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHILE, 0) +} + +func (s *Loop_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Loop_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Loop_statementContext) Cursor_loop_param() ICursor_loop_paramContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_loop_paramContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_loop_paramContext) +} + +func (s *Loop_statementContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Loop_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Loop_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Loop_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLoop_statement(s) + } +} + +func (s *Loop_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLoop_statement(s) + } +} + +func (s *Loop_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLoop_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Loop_statement() (localctx ILoop_statementContext) { + localctx = NewLoop_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1814, PlSqlParserRULE_loop_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(15920) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLESS_THAN_OP { + { + p.SetState(15919) + p.Label_declaration() + } + + } + p.SetState(15926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserWHILE: + { + p.SetState(15922) + p.Match(PlSqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15923) + p.Condition() + } + + case PlSqlParserFOR: + { + p.SetState(15924) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15925) + p.Cursor_loop_param() + } + + case PlSqlParserLOOP: + + default: + } + { + p.SetState(15928) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15929) + p.Seq_of_statements() + } + { + p.SetState(15930) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15931) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15933) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2130, p.GetParserRuleContext()) == 1 { + { + p.SetState(15932) + p.Label_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 +} + +// ICursor_loop_paramContext is an interface to support dynamic dispatch. +type ICursor_loop_paramContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetRange_separator returns the range_separator token. + GetRange_separator() antlr.Token + + // SetRange_separator sets the range_separator token. + SetRange_separator(antlr.Token) + + // Getter signatures + Index_name() IIndex_nameContext + IN() antlr.TerminalNode + Lower_bound() ILower_boundContext + Upper_bound() IUpper_boundContext + DOUBLE_PERIOD() antlr.TerminalNode + REVERSE() antlr.TerminalNode + Record_name() IRecord_nameContext + Cursor_name() ICursor_nameContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + + // IsCursor_loop_paramContext differentiates from other interfaces. + IsCursor_loop_paramContext() +} + +type Cursor_loop_paramContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + range_separator antlr.Token +} + +func NewEmptyCursor_loop_paramContext() *Cursor_loop_paramContext { + var p = new(Cursor_loop_paramContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_loop_param + return p +} + +func InitEmptyCursor_loop_paramContext(p *Cursor_loop_paramContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_loop_param +} + +func (*Cursor_loop_paramContext) IsCursor_loop_paramContext() {} + +func NewCursor_loop_paramContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_loop_paramContext { + var p = new(Cursor_loop_paramContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_loop_param + + return p +} + +func (s *Cursor_loop_paramContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_loop_paramContext) GetRange_separator() antlr.Token { return s.range_separator } + +func (s *Cursor_loop_paramContext) SetRange_separator(v antlr.Token) { s.range_separator = v } + +func (s *Cursor_loop_paramContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Cursor_loop_paramContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Cursor_loop_paramContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Cursor_loop_paramContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Cursor_loop_paramContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Cursor_loop_paramContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Cursor_loop_paramContext) Record_name() IRecord_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRecord_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRecord_nameContext) +} + +func (s *Cursor_loop_paramContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Cursor_loop_paramContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_loop_paramContext) 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 *Cursor_loop_paramContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_loop_paramContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Cursor_loop_paramContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_loop_paramContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_loop_paramContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_loop_param(s) + } +} + +func (s *Cursor_loop_paramContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_loop_param(s) + } +} + +func (s *Cursor_loop_paramContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCursor_loop_param(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cursor_loop_param() (localctx ICursor_loop_paramContext) { + localctx = NewCursor_loop_paramContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1816, PlSqlParserRULE_cursor_loop_param) + var _la int + + p.SetState(15960) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2135, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15935) + p.Index_name() + } + { + p.SetState(15936) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15938) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2131, p.GetParserRuleContext()) == 1 { + { + p.SetState(15937) + p.Match(PlSqlParserREVERSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(15940) + p.Lower_bound() + } + { + p.SetState(15941) + + var _m = p.Match(PlSqlParserDOUBLE_PERIOD) + + localctx.(*Cursor_loop_paramContext).range_separator = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15942) + p.Upper_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15944) + p.Record_name() + } + { + p.SetState(15945) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15958) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(15946) + p.Cursor_name() + } + p.SetState(15952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(15947) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15949) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(15948) + p.Expressions() + } + + } + { + p.SetState(15951) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(15954) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15955) + p.Select_statement() + } + { + p.SetState(15956) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IForall_statementContext is an interface to support dynamic dispatch. +type IForall_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FORALL() antlr.TerminalNode + Index_name() IIndex_nameContext + IN() antlr.TerminalNode + Bounds_clause() IBounds_clauseContext + Sql_statement() ISql_statementContext + SAVE() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + + // IsForall_statementContext differentiates from other interfaces. + IsForall_statementContext() +} + +type Forall_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyForall_statementContext() *Forall_statementContext { + var p = new(Forall_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_forall_statement + return p +} + +func InitEmptyForall_statementContext(p *Forall_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_forall_statement +} + +func (*Forall_statementContext) IsForall_statementContext() {} + +func NewForall_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Forall_statementContext { + var p = new(Forall_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_forall_statement + + return p +} + +func (s *Forall_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Forall_statementContext) FORALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORALL, 0) +} + +func (s *Forall_statementContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Forall_statementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Forall_statementContext) Bounds_clause() IBounds_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBounds_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBounds_clauseContext) +} + +func (s *Forall_statementContext) Sql_statement() ISql_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISql_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISql_statementContext) +} + +func (s *Forall_statementContext) SAVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE, 0) +} + +func (s *Forall_statementContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Forall_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Forall_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Forall_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterForall_statement(s) + } +} + +func (s *Forall_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitForall_statement(s) + } +} + +func (s *Forall_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitForall_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Forall_statement() (localctx IForall_statementContext) { + localctx = NewForall_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1818, PlSqlParserRULE_forall_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15962) + p.Match(PlSqlParserFORALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15963) + p.Index_name() + } + { + p.SetState(15964) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15965) + p.Bounds_clause() + } + { + p.SetState(15966) + p.Sql_statement() + } + p.SetState(15969) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2136, p.GetParserRuleContext()) == 1 { + { + p.SetState(15967) + p.Match(PlSqlParserSAVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15968) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBounds_clauseContext is an interface to support dynamic dispatch. +type IBounds_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Lower_bound() ILower_boundContext + DOUBLE_PERIOD() antlr.TerminalNode + Upper_bound() IUpper_boundContext + INDICES() antlr.TerminalNode + OF() antlr.TerminalNode + Collection_name() ICollection_nameContext + Between_bound() IBetween_boundContext + VALUES() antlr.TerminalNode + Index_name() IIndex_nameContext + + // IsBounds_clauseContext differentiates from other interfaces. + IsBounds_clauseContext() +} + +type Bounds_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBounds_clauseContext() *Bounds_clauseContext { + var p = new(Bounds_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bounds_clause + return p +} + +func InitEmptyBounds_clauseContext(p *Bounds_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bounds_clause +} + +func (*Bounds_clauseContext) IsBounds_clauseContext() {} + +func NewBounds_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bounds_clauseContext { + var p = new(Bounds_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bounds_clause + + return p +} + +func (s *Bounds_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bounds_clauseContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Bounds_clauseContext) DOUBLE_PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE_PERIOD, 0) +} + +func (s *Bounds_clauseContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Bounds_clauseContext) INDICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICES, 0) +} + +func (s *Bounds_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Bounds_clauseContext) Collection_name() ICollection_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollection_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollection_nameContext) +} + +func (s *Bounds_clauseContext) Between_bound() IBetween_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_boundContext) +} + +func (s *Bounds_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Bounds_clauseContext) Index_name() IIndex_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIndex_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIndex_nameContext) +} + +func (s *Bounds_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bounds_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bounds_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBounds_clause(s) + } +} + +func (s *Bounds_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBounds_clause(s) + } +} + +func (s *Bounds_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBounds_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Bounds_clause() (localctx IBounds_clauseContext) { + localctx = NewBounds_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1820, PlSqlParserRULE_bounds_clause) + var _la int + + p.SetState(15984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2138, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15971) + p.Lower_bound() + } + { + p.SetState(15972) + p.Match(PlSqlParserDOUBLE_PERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15973) + p.Upper_bound() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(15975) + p.Match(PlSqlParserINDICES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15976) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15977) + p.Collection_name() + } + p.SetState(15979) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBETWEEN { + { + p.SetState(15978) + p.Between_bound() + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(15981) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15982) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15983) + p.Index_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 +} + +// IBetween_boundContext is an interface to support dynamic dispatch. +type IBetween_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BETWEEN() antlr.TerminalNode + Lower_bound() ILower_boundContext + AND() antlr.TerminalNode + Upper_bound() IUpper_boundContext + + // IsBetween_boundContext differentiates from other interfaces. + IsBetween_boundContext() +} + +type Between_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBetween_boundContext() *Between_boundContext { + var p = new(Between_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_bound + return p +} + +func InitEmptyBetween_boundContext(p *Between_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_bound +} + +func (*Between_boundContext) IsBetween_boundContext() {} + +func NewBetween_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Between_boundContext { + var p = new(Between_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_between_bound + + return p +} + +func (s *Between_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Between_boundContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Between_boundContext) Lower_bound() ILower_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILower_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILower_boundContext) +} + +func (s *Between_boundContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Between_boundContext) Upper_bound() IUpper_boundContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpper_boundContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpper_boundContext) +} + +func (s *Between_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Between_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Between_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBetween_bound(s) + } +} + +func (s *Between_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBetween_bound(s) + } +} + +func (s *Between_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBetween_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Between_bound() (localctx IBetween_boundContext) { + localctx = NewBetween_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1822, PlSqlParserRULE_between_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15986) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15987) + p.Lower_bound() + } + { + p.SetState(15988) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(15989) + p.Upper_bound() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILower_boundContext is an interface to support dynamic dispatch. +type ILower_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Concatenation() IConcatenationContext + + // IsLower_boundContext differentiates from other interfaces. + IsLower_boundContext() +} + +type Lower_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLower_boundContext() *Lower_boundContext { + var p = new(Lower_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lower_bound + return p +} + +func InitEmptyLower_boundContext(p *Lower_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lower_bound +} + +func (*Lower_boundContext) IsLower_boundContext() {} + +func NewLower_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lower_boundContext { + var p = new(Lower_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lower_bound + + return p +} + +func (s *Lower_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lower_boundContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Lower_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lower_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lower_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLower_bound(s) + } +} + +func (s *Lower_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLower_bound(s) + } +} + +func (s *Lower_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLower_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lower_bound() (localctx ILower_boundContext) { + localctx = NewLower_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1824, PlSqlParserRULE_lower_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15991) + p.concatenation(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 +} + +// IUpper_boundContext is an interface to support dynamic dispatch. +type IUpper_boundContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Concatenation() IConcatenationContext + + // IsUpper_boundContext differentiates from other interfaces. + IsUpper_boundContext() +} + +type Upper_boundContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpper_boundContext() *Upper_boundContext { + var p = new(Upper_boundContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upper_bound + return p +} + +func InitEmptyUpper_boundContext(p *Upper_boundContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_upper_bound +} + +func (*Upper_boundContext) IsUpper_boundContext() {} + +func NewUpper_boundContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Upper_boundContext { + var p = new(Upper_boundContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_upper_bound + + return p +} + +func (s *Upper_boundContext) GetParser() antlr.Parser { return s.parser } + +func (s *Upper_boundContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Upper_boundContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Upper_boundContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Upper_boundContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpper_bound(s) + } +} + +func (s *Upper_boundContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpper_bound(s) + } +} + +func (s *Upper_boundContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpper_bound(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Upper_bound() (localctx IUpper_boundContext) { + localctx = NewUpper_boundContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1826, PlSqlParserRULE_upper_bound) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15993) + p.concatenation(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 +} + +// INull_statementContext is an interface to support dynamic dispatch. +type INull_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + + // IsNull_statementContext differentiates from other interfaces. + IsNull_statementContext() +} + +type Null_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNull_statementContext() *Null_statementContext { + var p = new(Null_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_null_statement + return p +} + +func InitEmptyNull_statementContext(p *Null_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_null_statement +} + +func (*Null_statementContext) IsNull_statementContext() {} + +func NewNull_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Null_statementContext { + var p = new(Null_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_null_statement + + return p +} + +func (s *Null_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Null_statementContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Null_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Null_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Null_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNull_statement(s) + } +} + +func (s *Null_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNull_statement(s) + } +} + +func (s *Null_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNull_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Null_statement() (localctx INull_statementContext) { + localctx = NewNull_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1828, PlSqlParserRULE_null_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15995) + p.Match(PlSqlParserNULL_) + 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 +} + +// IRaise_statementContext is an interface to support dynamic dispatch. +type IRaise_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RAISE() antlr.TerminalNode + Exception_name() IException_nameContext + + // IsRaise_statementContext differentiates from other interfaces. + IsRaise_statementContext() +} + +type Raise_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRaise_statementContext() *Raise_statementContext { + var p = new(Raise_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_raise_statement + return p +} + +func InitEmptyRaise_statementContext(p *Raise_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_raise_statement +} + +func (*Raise_statementContext) IsRaise_statementContext() {} + +func NewRaise_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Raise_statementContext { + var p = new(Raise_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_raise_statement + + return p +} + +func (s *Raise_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Raise_statementContext) RAISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAISE, 0) +} + +func (s *Raise_statementContext) Exception_name() IException_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Raise_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Raise_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Raise_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRaise_statement(s) + } +} + +func (s *Raise_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRaise_statement(s) + } +} + +func (s *Raise_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRaise_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Raise_statement() (localctx IRaise_statementContext) { + localctx = NewRaise_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1830, PlSqlParserRULE_raise_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(15997) + p.Match(PlSqlParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(15999) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2139, p.GetParserRuleContext()) == 1 { + { + p.SetState(15998) + p.Exception_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 +} + +// IReturn_statementContext is an interface to support dynamic dispatch. +type IReturn_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + Expression() IExpressionContext + + // IsReturn_statementContext differentiates from other interfaces. + IsReturn_statementContext() +} + +type Return_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_statementContext() *Return_statementContext { + var p = new(Return_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_statement + return p +} + +func InitEmptyReturn_statementContext(p *Return_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_statement +} + +func (*Return_statementContext) IsReturn_statementContext() {} + +func NewReturn_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_statementContext { + var p = new(Return_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_return_statement + + return p +} + +func (s *Return_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_statementContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Return_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Return_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReturn_statement(s) + } +} + +func (s *Return_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReturn_statement(s) + } +} + +func (s *Return_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReturn_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Return_statement() (localctx IReturn_statementContext) { + localctx = NewReturn_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1832, PlSqlParserRULE_return_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16001) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16003) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2140, p.GetParserRuleContext()) == 1 { + { + p.SetState(16002) + p.Expression() + } + + } 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 +} + +// ICall_statementContext is an interface to support dynamic dispatch. +type ICall_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Routine_name() IRoutine_nameContext + CALL() antlr.TerminalNode + Function_argument() IFunction_argumentContext + INTO() antlr.TerminalNode + Bind_variable() IBind_variableContext + + // IsCall_statementContext differentiates from other interfaces. + IsCall_statementContext() +} + +type Call_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCall_statementContext() *Call_statementContext { + var p = new(Call_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_statement + return p +} + +func InitEmptyCall_statementContext(p *Call_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_call_statement +} + +func (*Call_statementContext) IsCall_statementContext() {} + +func NewCall_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Call_statementContext { + var p = new(Call_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_call_statement + + return p +} + +func (s *Call_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Call_statementContext) Routine_name() IRoutine_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRoutine_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRoutine_nameContext) +} + +func (s *Call_statementContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Call_statementContext) Function_argument() IFunction_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *Call_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Call_statementContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Call_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Call_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Call_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCall_statement(s) + } +} + +func (s *Call_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCall_statement(s) + } +} + +func (s *Call_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCall_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Call_statement() (localctx ICall_statementContext) { + localctx = NewCall_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1834, PlSqlParserRULE_call_statement) + p.EnterOuterAlt(localctx, 1) + p.SetState(16006) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2141, p.GetParserRuleContext()) == 1 { + { + p.SetState(16005) + p.Match(PlSqlParserCALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16008) + p.Routine_name() + } + p.SetState(16010) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2142, p.GetParserRuleContext()) == 1 { + { + p.SetState(16009) + p.Function_argument() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16014) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2143, p.GetParserRuleContext()) == 1 { + { + p.SetState(16012) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16013) + p.Bind_variable() + } + + } 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 +} + +// IPipe_row_statementContext is an interface to support dynamic dispatch. +type IPipe_row_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIPE() antlr.TerminalNode + ROW() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsPipe_row_statementContext differentiates from other interfaces. + IsPipe_row_statementContext() +} + +type Pipe_row_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPipe_row_statementContext() *Pipe_row_statementContext { + var p = new(Pipe_row_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipe_row_statement + return p +} + +func InitEmptyPipe_row_statementContext(p *Pipe_row_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pipe_row_statement +} + +func (*Pipe_row_statementContext) IsPipe_row_statementContext() {} + +func NewPipe_row_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pipe_row_statementContext { + var p = new(Pipe_row_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pipe_row_statement + + return p +} + +func (s *Pipe_row_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pipe_row_statementContext) PIPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPE, 0) +} + +func (s *Pipe_row_statementContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Pipe_row_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pipe_row_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pipe_row_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pipe_row_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pipe_row_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pipe_row_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPipe_row_statement(s) + } +} + +func (s *Pipe_row_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPipe_row_statement(s) + } +} + +func (s *Pipe_row_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPipe_row_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pipe_row_statement() (localctx IPipe_row_statementContext) { + localctx = NewPipe_row_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1836, PlSqlParserRULE_pipe_row_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16016) + p.Match(PlSqlParserPIPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16017) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16018) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16019) + p.Expression() + } + { + p.SetState(16020) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBodyContext is an interface to support dynamic dispatch. +type IBodyContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BEGIN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + END() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + Label_name() ILabel_nameContext + AllException_handler() []IException_handlerContext + Exception_handler(i int) IException_handlerContext + + // IsBodyContext differentiates from other interfaces. + IsBodyContext() +} + +type BodyContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBodyContext() *BodyContext { + var p = new(BodyContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_body + return p +} + +func InitEmptyBodyContext(p *BodyContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_body +} + +func (*BodyContext) IsBodyContext() {} + +func NewBodyContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BodyContext { + var p = new(BodyContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_body + + return p +} + +func (s *BodyContext) GetParser() antlr.Parser { return s.parser } + +func (s *BodyContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *BodyContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *BodyContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *BodyContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *BodyContext) Label_name() ILabel_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *BodyContext) AllException_handler() []IException_handlerContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_handlerContext); ok { + len++ + } + } + + tst := make([]IException_handlerContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_handlerContext); ok { + tst[i] = t.(IException_handlerContext) + i++ + } + } + + return tst +} + +func (s *BodyContext) Exception_handler(i int) IException_handlerContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_handlerContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_handlerContext) +} + +func (s *BodyContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BodyContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BodyContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBody(s) + } +} + +func (s *BodyContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBody(s) + } +} + +func (s *BodyContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBody(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Body() (localctx IBodyContext) { + localctx = NewBodyContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1838, PlSqlParserRULE_body) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16022) + p.Match(PlSqlParserBEGIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16023) + p.Seq_of_statements() + } + p.SetState(16030) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCEPTION { + { + p.SetState(16024) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16026) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(16025) + p.Exception_handler() + } + + p.SetState(16028) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(16032) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16034) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2146, p.GetParserRuleContext()) == 1 { + { + p.SetState(16033) + p.Label_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 +} + +// IException_handlerContext is an interface to support dynamic dispatch. +type IException_handlerContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllException_name() []IException_nameContext + Exception_name(i int) IException_nameContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + AllOR() []antlr.TerminalNode + OR(i int) antlr.TerminalNode + + // IsException_handlerContext differentiates from other interfaces. + IsException_handlerContext() +} + +type Exception_handlerContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_handlerContext() *Exception_handlerContext { + var p = new(Exception_handlerContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_handler + return p +} + +func InitEmptyException_handlerContext(p *Exception_handlerContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_handler +} + +func (*Exception_handlerContext) IsException_handlerContext() {} + +func NewException_handlerContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_handlerContext { + var p = new(Exception_handlerContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_handler + + return p +} + +func (s *Exception_handlerContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_handlerContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Exception_handlerContext) AllException_name() []IException_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IException_nameContext); ok { + len++ + } + } + + tst := make([]IException_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IException_nameContext); ok { + tst[i] = t.(IException_nameContext) + i++ + } + } + + return tst +} + +func (s *Exception_handlerContext) Exception_name(i int) IException_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IException_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IException_nameContext) +} + +func (s *Exception_handlerContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Exception_handlerContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Exception_handlerContext) AllOR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserOR) +} + +func (s *Exception_handlerContext) OR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, i) +} + +func (s *Exception_handlerContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_handlerContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_handlerContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_handler(s) + } +} + +func (s *Exception_handlerContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_handler(s) + } +} + +func (s *Exception_handlerContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitException_handler(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exception_handler() (localctx IException_handlerContext) { + localctx = NewException_handlerContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1840, PlSqlParserRULE_exception_handler) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16036) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16037) + p.Exception_name() + } + p.SetState(16042) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserOR { + { + p.SetState(16038) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16039) + p.Exception_name() + } + + p.SetState(16044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16045) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16046) + p.Seq_of_statements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_blockContext is an interface to support dynamic dispatch. +type ITrigger_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + DECLARE() antlr.TerminalNode + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsTrigger_blockContext differentiates from other interfaces. + IsTrigger_blockContext() +} + +type Trigger_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_blockContext() *Trigger_blockContext { + var p = new(Trigger_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_block + return p +} + +func InitEmptyTrigger_blockContext(p *Trigger_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_block +} + +func (*Trigger_blockContext) IsTrigger_blockContext() {} + +func NewTrigger_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_blockContext { + var p = new(Trigger_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_block + + return p +} + +func (s *Trigger_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_blockContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *Trigger_blockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *Trigger_blockContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *Trigger_blockContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *Trigger_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_block(s) + } +} + +func (s *Trigger_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_block(s) + } +} + +func (s *Trigger_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrigger_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trigger_block() (localctx ITrigger_blockContext) { + localctx = NewTrigger_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1842, PlSqlParserRULE_trigger_block) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16055) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(16048) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2148, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16049) + p.Declare_spec() + } + + } + p.SetState(16054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2148, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } + { + p.SetState(16057) + p.Body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBlockContext is an interface to support dynamic dispatch. +type IBlockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Body() IBodyContext + DECLARE() antlr.TerminalNode + AllDeclare_spec() []IDeclare_specContext + Declare_spec(i int) IDeclare_specContext + + // IsBlockContext differentiates from other interfaces. + IsBlockContext() +} + +type BlockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBlockContext() *BlockContext { + var p = new(BlockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_block + return p +} + +func InitEmptyBlockContext(p *BlockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_block +} + +func (*BlockContext) IsBlockContext() {} + +func NewBlockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *BlockContext { + var p = new(BlockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_block + + return p +} + +func (s *BlockContext) GetParser() antlr.Parser { return s.parser } + +func (s *BlockContext) Body() IBodyContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBodyContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBodyContext) +} + +func (s *BlockContext) DECLARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECLARE, 0) +} + +func (s *BlockContext) AllDeclare_spec() []IDeclare_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IDeclare_specContext); ok { + len++ + } + } + + tst := make([]IDeclare_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IDeclare_specContext); ok { + tst[i] = t.(IDeclare_specContext) + i++ + } + } + + return tst +} + +func (s *BlockContext) Declare_spec(i int) IDeclare_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDeclare_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IDeclare_specContext) +} + +func (s *BlockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *BlockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *BlockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBlock(s) + } +} + +func (s *BlockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBlock(s) + } +} + +func (s *BlockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBlock(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Block() (localctx IBlockContext) { + localctx = NewBlockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1844, PlSqlParserRULE_block) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDECLARE { + { + p.SetState(16059) + p.Match(PlSqlParserDECLARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(16062) + p.Declare_spec() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(16065) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2151, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + { + p.SetState(16067) + p.Body() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISql_statementContext is an interface to support dynamic dispatch. +type ISql_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Execute_immediate() IExecute_immediateContext + Data_manipulation_language_statements() IData_manipulation_language_statementsContext + Cursor_manipulation_statements() ICursor_manipulation_statementsContext + Transaction_control_statements() ITransaction_control_statementsContext + + // IsSql_statementContext differentiates from other interfaces. + IsSql_statementContext() +} + +type Sql_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_statementContext() *Sql_statementContext { + var p = new(Sql_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement + return p +} + +func InitEmptySql_statementContext(p *Sql_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_statement +} + +func (*Sql_statementContext) IsSql_statementContext() {} + +func NewSql_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_statementContext { + var p = new(Sql_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_statement + + return p +} + +func (s *Sql_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_statementContext) 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 *Sql_statementContext) Data_manipulation_language_statements() IData_manipulation_language_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IData_manipulation_language_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IData_manipulation_language_statementsContext) +} + +func (s *Sql_statementContext) Cursor_manipulation_statements() ICursor_manipulation_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_manipulation_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_manipulation_statementsContext) +} + +func (s *Sql_statementContext) Transaction_control_statements() ITransaction_control_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITransaction_control_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITransaction_control_statementsContext) +} + +func (s *Sql_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_statement(s) + } +} + +func (s *Sql_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_statement(s) + } +} + +func (s *Sql_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_statement() (localctx ISql_statementContext) { + localctx = NewSql_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1846, PlSqlParserRULE_sql_statement) + p.SetState(16073) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16069) + p.Execute_immediate() + } + + case PlSqlParserDELETE, PlSqlParserEXPLAIN, PlSqlParserINSERT, PlSqlParserLOCK, PlSqlParserMERGE, PlSqlParserSELECT, PlSqlParserUPDATE, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16070) + p.Data_manipulation_language_statements() + } + + case PlSqlParserCLOSE, PlSqlParserFETCH, PlSqlParserOPEN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16071) + p.Cursor_manipulation_statements() + } + + case PlSqlParserCOMMIT, PlSqlParserROLLBACK, PlSqlParserSAVEPOINT, PlSqlParserSET: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16072) + p.Transaction_control_statements() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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 + Expression() IExpressionContext + Into_clause() IInto_clauseContext + Using_clause() IUsing_clauseContext + Dynamic_returning_clause() IDynamic_returning_clauseContext + + // 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 = PlSqlParserRULE_execute_immediate + return p +} + +func InitEmptyExecute_immediateContext(p *Execute_immediateContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_execute_immediate + + return p +} + +func (s *Execute_immediateContext) GetParser() antlr.Parser { return s.parser } + +func (s *Execute_immediateContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Execute_immediateContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Execute_immediateContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Execute_immediateContext) 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 *Execute_immediateContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Execute_immediateContext) Dynamic_returning_clause() IDynamic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDynamic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDynamic_returning_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExecute_immediate(s) + } +} + +func (s *Execute_immediateContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExecute_immediate(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Execute_immediate() (localctx IExecute_immediateContext) { + localctx = NewExecute_immediateContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1848, PlSqlParserRULE_execute_immediate) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16075) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16076) + p.Match(PlSqlParserIMMEDIATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16077) + p.Expression() + } + p.SetState(16087) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2155, p.GetParserRuleContext()) == 1 { + { + p.SetState(16078) + p.Into_clause() + } + p.SetState(16080) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2153, p.GetParserRuleContext()) == 1 { + { + p.SetState(16079) + p.Using_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2155, p.GetParserRuleContext()) == 2 { + { + p.SetState(16082) + p.Using_clause() + } + p.SetState(16084) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2154, p.GetParserRuleContext()) == 1 { + { + p.SetState(16083) + p.Dynamic_returning_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2155, p.GetParserRuleContext()) == 3 { + { + p.SetState(16086) + p.Dynamic_returning_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 +} + +// IDynamic_returning_clauseContext is an interface to support dynamic dispatch. +type IDynamic_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Into_clause() IInto_clauseContext + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + + // IsDynamic_returning_clauseContext differentiates from other interfaces. + IsDynamic_returning_clauseContext() +} + +type Dynamic_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDynamic_returning_clauseContext() *Dynamic_returning_clauseContext { + var p = new(Dynamic_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause + return p +} + +func InitEmptyDynamic_returning_clauseContext(p *Dynamic_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause +} + +func (*Dynamic_returning_clauseContext) IsDynamic_returning_clauseContext() {} + +func NewDynamic_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dynamic_returning_clauseContext { + var p = new(Dynamic_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dynamic_returning_clause + + return p +} + +func (s *Dynamic_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dynamic_returning_clauseContext) 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 *Dynamic_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Dynamic_returning_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Dynamic_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dynamic_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dynamic_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDynamic_returning_clause(s) + } +} + +func (s *Dynamic_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDynamic_returning_clause(s) + } +} + +func (s *Dynamic_returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDynamic_returning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dynamic_returning_clause() (localctx IDynamic_returning_clauseContext) { + localctx = NewDynamic_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1850, PlSqlParserRULE_dynamic_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16089) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRETURNING || _la == PlSqlParserRETURN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16090) + p.Into_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 +} + +// IData_manipulation_language_statementsContext is an interface to support dynamic dispatch. +type IData_manipulation_language_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Merge_statement() IMerge_statementContext + Lock_table_statement() ILock_table_statementContext + Select_statement() ISelect_statementContext + Update_statement() IUpdate_statementContext + Delete_statement() IDelete_statementContext + Insert_statement() IInsert_statementContext + Explain_statement() IExplain_statementContext + + // IsData_manipulation_language_statementsContext differentiates from other interfaces. + IsData_manipulation_language_statementsContext() +} + +type Data_manipulation_language_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyData_manipulation_language_statementsContext() *Data_manipulation_language_statementsContext { + var p = new(Data_manipulation_language_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements + return p +} + +func InitEmptyData_manipulation_language_statementsContext(p *Data_manipulation_language_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements +} + +func (*Data_manipulation_language_statementsContext) IsData_manipulation_language_statementsContext() { +} + +func NewData_manipulation_language_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Data_manipulation_language_statementsContext { + var p = new(Data_manipulation_language_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_data_manipulation_language_statements + + return p +} + +func (s *Data_manipulation_language_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Data_manipulation_language_statementsContext) 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 *Data_manipulation_language_statementsContext) Lock_table_statement() ILock_table_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_table_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_table_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) 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 *Data_manipulation_language_statementsContext) 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 *Data_manipulation_language_statementsContext) 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 *Data_manipulation_language_statementsContext) 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 *Data_manipulation_language_statementsContext) Explain_statement() IExplain_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExplain_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExplain_statementContext) +} + +func (s *Data_manipulation_language_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Data_manipulation_language_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Data_manipulation_language_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterData_manipulation_language_statements(s) + } +} + +func (s *Data_manipulation_language_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitData_manipulation_language_statements(s) + } +} + +func (s *Data_manipulation_language_statementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitData_manipulation_language_statements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Data_manipulation_language_statements() (localctx IData_manipulation_language_statementsContext) { + localctx = NewData_manipulation_language_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1852, PlSqlParserRULE_data_manipulation_language_statements) + p.SetState(16099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMERGE: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16092) + p.Merge_statement() + } + + case PlSqlParserLOCK: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16093) + p.Lock_table_statement() + } + + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16094) + p.Select_statement() + } + + case PlSqlParserUPDATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16095) + p.Update_statement() + } + + case PlSqlParserDELETE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16096) + p.Delete_statement() + } + + case PlSqlParserINSERT: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(16097) + p.Insert_statement() + } + + case PlSqlParserEXPLAIN: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(16098) + p.Explain_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 +} + +// ICursor_manipulation_statementsContext is an interface to support dynamic dispatch. +type ICursor_manipulation_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Close_statement() IClose_statementContext + Open_statement() IOpen_statementContext + Fetch_statement() IFetch_statementContext + Open_for_statement() IOpen_for_statementContext + + // IsCursor_manipulation_statementsContext differentiates from other interfaces. + IsCursor_manipulation_statementsContext() +} + +type Cursor_manipulation_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_manipulation_statementsContext() *Cursor_manipulation_statementsContext { + var p = new(Cursor_manipulation_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements + return p +} + +func InitEmptyCursor_manipulation_statementsContext(p *Cursor_manipulation_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements +} + +func (*Cursor_manipulation_statementsContext) IsCursor_manipulation_statementsContext() {} + +func NewCursor_manipulation_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_manipulation_statementsContext { + var p = new(Cursor_manipulation_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_manipulation_statements + + return p +} + +func (s *Cursor_manipulation_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_manipulation_statementsContext) Close_statement() IClose_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IClose_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IClose_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Open_statement() IOpen_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Fetch_statement() IFetch_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) Open_for_statement() IOpen_for_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOpen_for_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOpen_for_statementContext) +} + +func (s *Cursor_manipulation_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_manipulation_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_manipulation_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_manipulation_statements(s) + } +} + +func (s *Cursor_manipulation_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_manipulation_statements(s) + } +} + +func (s *Cursor_manipulation_statementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCursor_manipulation_statements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cursor_manipulation_statements() (localctx ICursor_manipulation_statementsContext) { + localctx = NewCursor_manipulation_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1854, PlSqlParserRULE_cursor_manipulation_statements) + p.SetState(16105) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2157, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16101) + p.Close_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16102) + p.Open_statement() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16103) + p.Fetch_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16104) + p.Open_for_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 +} + +// IClose_statementContext is an interface to support dynamic dispatch. +type IClose_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CLOSE() antlr.TerminalNode + Cursor_name() ICursor_nameContext + + // IsClose_statementContext differentiates from other interfaces. + IsClose_statementContext() +} + +type Close_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyClose_statementContext() *Close_statementContext { + var p = new(Close_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_statement + return p +} + +func InitEmptyClose_statementContext(p *Close_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_close_statement +} + +func (*Close_statementContext) IsClose_statementContext() {} + +func NewClose_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Close_statementContext { + var p = new(Close_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_close_statement + + return p +} + +func (s *Close_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Close_statementContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Close_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Close_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Close_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Close_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterClose_statement(s) + } +} + +func (s *Close_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitClose_statement(s) + } +} + +func (s *Close_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitClose_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Close_statement() (localctx IClose_statementContext) { + localctx = NewClose_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1856, PlSqlParserRULE_close_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16107) + p.Match(PlSqlParserCLOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16108) + p.Cursor_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 +} + +// IOpen_statementContext is an interface to support dynamic dispatch. +type IOpen_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN() antlr.TerminalNode + Cursor_name() ICursor_nameContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + + // IsOpen_statementContext differentiates from other interfaces. + IsOpen_statementContext() +} + +type Open_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_statementContext() *Open_statementContext { + var p = new(Open_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_statement + return p +} + +func InitEmptyOpen_statementContext(p *Open_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_statement +} + +func (*Open_statementContext) IsOpen_statementContext() {} + +func NewOpen_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_statementContext { + var p = new(Open_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_statement + + return p +} + +func (s *Open_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_statementContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Open_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Open_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Open_statementContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Open_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_statement(s) + } +} + +func (s *Open_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_statement(s) + } +} + +func (s *Open_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOpen_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Open_statement() (localctx IOpen_statementContext) { + localctx = NewOpen_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1858, PlSqlParserRULE_open_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16110) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16111) + p.Cursor_name() + } + p.SetState(16117) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2159, p.GetParserRuleContext()) == 1 { + { + p.SetState(16112) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16114) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(16113) + p.Expressions() + } + + } + { + p.SetState(16116) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFetch_statementContext is an interface to support dynamic dispatch. +type IFetch_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetIt1 returns the it1 token. + GetIt1() antlr.Token + + // SetIt1 sets the it1 token. + SetIt1(antlr.Token) + + // Getter signatures + FETCH() antlr.TerminalNode + Cursor_name() ICursor_nameContext + AllVariable_name() []IVariable_nameContext + Variable_name(i int) IVariable_nameContext + BULK() antlr.TerminalNode + COLLECT() antlr.TerminalNode + INTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + LIMIT() antlr.TerminalNode + Numeric() INumericContext + + // IsFetch_statementContext differentiates from other interfaces. + IsFetch_statementContext() +} + +type Fetch_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + it1 antlr.Token +} + +func NewEmptyFetch_statementContext() *Fetch_statementContext { + var p = new(Fetch_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_statement + return p +} + +func InitEmptyFetch_statementContext(p *Fetch_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_statement +} + +func (*Fetch_statementContext) IsFetch_statementContext() {} + +func NewFetch_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_statementContext { + var p = new(Fetch_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fetch_statement + + return p +} + +func (s *Fetch_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_statementContext) GetIt1() antlr.Token { return s.it1 } + +func (s *Fetch_statementContext) SetIt1(v antlr.Token) { s.it1 = v } + +func (s *Fetch_statementContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Fetch_statementContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Fetch_statementContext) AllVariable_name() []IVariable_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IVariable_nameContext); ok { + len++ + } + } + + tst := make([]IVariable_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IVariable_nameContext); ok { + tst[i] = t.(IVariable_nameContext) + i++ + } + } + + return tst +} + +func (s *Fetch_statementContext) Variable_name(i int) IVariable_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Fetch_statementContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Fetch_statementContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Fetch_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Fetch_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Fetch_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Fetch_statementContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Fetch_statementContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Fetch_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFetch_statement(s) + } +} + +func (s *Fetch_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFetch_statement(s) + } +} + +func (s *Fetch_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFetch_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Fetch_statement() (localctx IFetch_statementContext) { + localctx = NewFetch_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1860, PlSqlParserRULE_fetch_statement) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16119) + p.Match(PlSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16120) + p.Cursor_name() + } + p.SetState(16148) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTO: + { + p.SetState(16121) + + var _m = p.Match(PlSqlParserINTO) + + localctx.(*Fetch_statementContext).it1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16122) + p.Variable_name() + } + p.SetState(16127) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2160, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16123) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16124) + p.Variable_name() + } + + } + p.SetState(16129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2160, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case PlSqlParserBULK: + { + p.SetState(16130) + p.Match(PlSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16131) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16132) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16133) + p.Variable_name() + } + p.SetState(16138) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2161, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16134) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16135) + p.Variable_name() + } + + } + p.SetState(16140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2161, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16146) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2163, p.GetParserRuleContext()) == 1 { + { + p.SetState(16141) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(16142) + p.Numeric() + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16143) + p.Variable_name() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + 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 +} + +// IOpen_for_statementContext is an interface to support dynamic dispatch. +type IOpen_for_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OPEN() antlr.TerminalNode + Variable_name() IVariable_nameContext + FOR() antlr.TerminalNode + Select_statement() ISelect_statementContext + Expression() IExpressionContext + Using_clause() IUsing_clauseContext + + // IsOpen_for_statementContext differentiates from other interfaces. + IsOpen_for_statementContext() +} + +type Open_for_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOpen_for_statementContext() *Open_for_statementContext { + var p = new(Open_for_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_for_statement + return p +} + +func InitEmptyOpen_for_statementContext(p *Open_for_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_open_for_statement +} + +func (*Open_for_statementContext) IsOpen_for_statementContext() {} + +func NewOpen_for_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Open_for_statementContext { + var p = new(Open_for_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_open_for_statement + + return p +} + +func (s *Open_for_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Open_for_statementContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Open_for_statementContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Open_for_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Open_for_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 *Open_for_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Open_for_statementContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Open_for_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Open_for_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Open_for_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOpen_for_statement(s) + } +} + +func (s *Open_for_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOpen_for_statement(s) + } +} + +func (s *Open_for_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOpen_for_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Open_for_statement() (localctx IOpen_for_statementContext) { + localctx = NewOpen_for_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1862, PlSqlParserRULE_open_for_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16150) + p.Match(PlSqlParserOPEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16151) + p.Variable_name() + } + { + p.SetState(16152) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2165, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16153) + p.Select_statement() + } + + case 2: + { + p.SetState(16154) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(16158) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2166, p.GetParserRuleContext()) == 1 { + { + p.SetState(16157) + p.Using_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 +} + +// ITransaction_control_statementsContext is an interface to support dynamic dispatch. +type ITransaction_control_statementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Set_transaction_command() ISet_transaction_commandContext + Set_constraint_command() ISet_constraint_commandContext + Commit_statement() ICommit_statementContext + Rollback_statement() IRollback_statementContext + Savepoint_statement() ISavepoint_statementContext + + // IsTransaction_control_statementsContext differentiates from other interfaces. + IsTransaction_control_statementsContext() +} + +type Transaction_control_statementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTransaction_control_statementsContext() *Transaction_control_statementsContext { + var p = new(Transaction_control_statementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transaction_control_statements + return p +} + +func InitEmptyTransaction_control_statementsContext(p *Transaction_control_statementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_transaction_control_statements +} + +func (*Transaction_control_statementsContext) IsTransaction_control_statementsContext() {} + +func NewTransaction_control_statementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Transaction_control_statementsContext { + var p = new(Transaction_control_statementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_transaction_control_statements + + return p +} + +func (s *Transaction_control_statementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Transaction_control_statementsContext) Set_transaction_command() ISet_transaction_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_transaction_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_transaction_commandContext) +} + +func (s *Transaction_control_statementsContext) Set_constraint_command() ISet_constraint_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_constraint_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_constraint_commandContext) +} + +func (s *Transaction_control_statementsContext) Commit_statement() ICommit_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICommit_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICommit_statementContext) +} + +func (s *Transaction_control_statementsContext) Rollback_statement() IRollback_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_statementContext) +} + +func (s *Transaction_control_statementsContext) Savepoint_statement() ISavepoint_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_statementContext) +} + +func (s *Transaction_control_statementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Transaction_control_statementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Transaction_control_statementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTransaction_control_statements(s) + } +} + +func (s *Transaction_control_statementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTransaction_control_statements(s) + } +} + +func (s *Transaction_control_statementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTransaction_control_statements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Transaction_control_statements() (localctx ITransaction_control_statementsContext) { + localctx = NewTransaction_control_statementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1864, PlSqlParserRULE_transaction_control_statements) + p.SetState(16165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2167, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16160) + p.Set_transaction_command() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16161) + p.Set_constraint_command() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16162) + p.Commit_statement() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(16163) + p.Rollback_statement() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(16164) + p.Savepoint_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 +} + +// ISet_transaction_commandContext is an interface to support dynamic dispatch. +type ISet_transaction_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + READ() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + LEVEL() antlr.TerminalNode + USE() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + Rollback_segment_name() IRollback_segment_nameContext + NAME() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + ONLY() antlr.TerminalNode + WRITE() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + + // IsSet_transaction_commandContext differentiates from other interfaces. + IsSet_transaction_commandContext() +} + +type Set_transaction_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_transaction_commandContext() *Set_transaction_commandContext { + var p = new(Set_transaction_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_transaction_command + return p +} + +func InitEmptySet_transaction_commandContext(p *Set_transaction_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_transaction_command +} + +func (*Set_transaction_commandContext) IsSet_transaction_commandContext() {} + +func NewSet_transaction_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_transaction_commandContext { + var p = new(Set_transaction_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_transaction_command + + return p +} + +func (s *Set_transaction_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_transaction_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_transaction_commandContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Set_transaction_commandContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Set_transaction_commandContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION, 0) +} + +func (s *Set_transaction_commandContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Set_transaction_commandContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Set_transaction_commandContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Set_transaction_commandContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Set_transaction_commandContext) Rollback_segment_name() IRollback_segment_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollback_segment_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollback_segment_nameContext) +} + +func (s *Set_transaction_commandContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Set_transaction_commandContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Set_transaction_commandContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Set_transaction_commandContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Set_transaction_commandContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALIZABLE, 0) +} + +func (s *Set_transaction_commandContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMITTED, 0) +} + +func (s *Set_transaction_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_transaction_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_transaction_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_transaction_command(s) + } +} + +func (s *Set_transaction_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_transaction_command(s) + } +} + +func (s *Set_transaction_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_transaction_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_transaction_command() (localctx ISet_transaction_commandContext) { + localctx = NewSet_transaction_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1866, PlSqlParserRULE_set_transaction_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16167) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16168) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16182) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2169, p.GetParserRuleContext()) == 1 { + { + p.SetState(16169) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16170) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserONLY || _la == PlSqlParserWRITE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2169, p.GetParserRuleContext()) == 2 { + { + p.SetState(16171) + p.Match(PlSqlParserISOLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16172) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSERIALIZABLE: + { + p.SetState(16173) + p.Match(PlSqlParserSERIALIZABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + { + p.SetState(16174) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16175) + p.Match(PlSqlParserCOMMITTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2169, p.GetParserRuleContext()) == 3 { + { + p.SetState(16178) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16179) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16180) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16181) + p.Rollback_segment_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16186) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2170, p.GetParserRuleContext()) == 1 { + { + p.SetState(16184) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16185) + p.Quoted_string() + } + + } 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 +} + +// ISet_constraint_commandContext is an interface to support dynamic dispatch. +type ISet_constraint_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + ALL() antlr.TerminalNode + AllConstraint_name() []IConstraint_nameContext + Constraint_name(i int) IConstraint_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSet_constraint_commandContext differentiates from other interfaces. + IsSet_constraint_commandContext() +} + +type Set_constraint_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_constraint_commandContext() *Set_constraint_commandContext { + var p = new(Set_constraint_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_constraint_command + return p +} + +func InitEmptySet_constraint_commandContext(p *Set_constraint_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_constraint_command +} + +func (*Set_constraint_commandContext) IsSet_constraint_commandContext() {} + +func NewSet_constraint_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_constraint_commandContext { + var p = new(Set_constraint_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_constraint_command + + return p +} + +func (s *Set_constraint_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_constraint_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_constraint_commandContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Set_constraint_commandContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Set_constraint_commandContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Set_constraint_commandContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Set_constraint_commandContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Set_constraint_commandContext) AllConstraint_name() []IConstraint_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstraint_nameContext); ok { + len++ + } + } + + tst := make([]IConstraint_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstraint_nameContext); ok { + tst[i] = t.(IConstraint_nameContext) + i++ + } + } + + return tst +} + +func (s *Set_constraint_commandContext) Constraint_name(i int) IConstraint_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Set_constraint_commandContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Set_constraint_commandContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Set_constraint_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_constraint_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_constraint_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_constraint_command(s) + } +} + +func (s *Set_constraint_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_constraint_command(s) + } +} + +func (s *Set_constraint_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_constraint_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_constraint_command() (localctx ISet_constraint_commandContext) { + localctx = NewSet_constraint_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1868, PlSqlParserRULE_set_constraint_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16188) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16189) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONSTRAINT || _la == PlSqlParserCONSTRAINTS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16199) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + { + p.SetState(16190) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16191) + p.Constraint_name() + } + p.SetState(16196) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16192) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16193) + p.Constraint_name() + } + + p.SetState(16198) + 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(16201) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDEFERRED || _la == PlSqlParserIMMEDIATE) { + 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 +} + +// ICommit_statementContext is an interface to support dynamic dispatch. +type ICommit_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COMMIT() antlr.TerminalNode + WORK() antlr.TerminalNode + COMMENT() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + FORCE() antlr.TerminalNode + CORRUPT_XID() antlr.TerminalNode + CORRUPT_XID_ALL() antlr.TerminalNode + Write_clause() IWrite_clauseContext + COMMA() antlr.TerminalNode + Numeric() INumericContext + + // IsCommit_statementContext differentiates from other interfaces. + IsCommit_statementContext() +} + +type Commit_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCommit_statementContext() *Commit_statementContext { + var p = new(Commit_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_statement + return p +} + +func InitEmptyCommit_statementContext(p *Commit_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_commit_statement +} + +func (*Commit_statementContext) IsCommit_statementContext() {} + +func NewCommit_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Commit_statementContext { + var p = new(Commit_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_commit_statement + + return p +} + +func (s *Commit_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Commit_statementContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Commit_statementContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Commit_statementContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Commit_statementContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Commit_statementContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Commit_statementContext) CORRUPT_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID, 0) +} + +func (s *Commit_statementContext) CORRUPT_XID_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID_ALL, 0) +} + +func (s *Commit_statementContext) Write_clause() IWrite_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWrite_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWrite_clauseContext) +} + +func (s *Commit_statementContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Commit_statementContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Commit_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Commit_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Commit_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCommit_statement(s) + } +} + +func (s *Commit_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCommit_statement(s) + } +} + +func (s *Commit_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCommit_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Commit_statement() (localctx ICommit_statementContext) { + localctx = NewCommit_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1870, PlSqlParserRULE_commit_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16203) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16205) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2173, p.GetParserRuleContext()) == 1 { + { + p.SetState(16204) + p.Match(PlSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16223) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2177, p.GetParserRuleContext()) == 1 { + { + p.SetState(16207) + p.Match(PlSqlParserCOMMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16208) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16210) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2174, p.GetParserRuleContext()) == 1 { + { + p.SetState(16209) + p.Write_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2177, p.GetParserRuleContext()) == 2 { + { + p.SetState(16212) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + { + p.SetState(16213) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16216) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2175, p.GetParserRuleContext()) == 1 { + { + p.SetState(16214) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16215) + p.Numeric() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCORRUPT_XID: + { + p.SetState(16218) + p.Match(PlSqlParserCORRUPT_XID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16219) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCORRUPT_XID_ALL: + { + p.SetState(16220) + p.Match(PlSqlParserCORRUPT_XID_ALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWrite_clauseContext is an interface to support dynamic dispatch. +type IWrite_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WRITE() antlr.TerminalNode + WAIT() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + BATCH() antlr.TerminalNode + + // IsWrite_clauseContext differentiates from other interfaces. + IsWrite_clauseContext() +} + +type Write_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWrite_clauseContext() *Write_clauseContext { + var p = new(Write_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_write_clause + return p +} + +func InitEmptyWrite_clauseContext(p *Write_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_write_clause +} + +func (*Write_clauseContext) IsWrite_clauseContext() {} + +func NewWrite_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Write_clauseContext { + var p = new(Write_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_write_clause + + return p +} + +func (s *Write_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Write_clauseContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Write_clauseContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Write_clauseContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Write_clauseContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Write_clauseContext) BATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, 0) +} + +func (s *Write_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Write_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Write_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWrite_clause(s) + } +} + +func (s *Write_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWrite_clause(s) + } +} + +func (s *Write_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWrite_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Write_clause() (localctx IWrite_clauseContext) { + localctx = NewWrite_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1872, PlSqlParserRULE_write_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16225) + p.Match(PlSqlParserWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16227) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2178, p.GetParserRuleContext()) == 1 { + { + p.SetState(16226) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOWAIT || _la == PlSqlParserWAIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16230) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2179, p.GetParserRuleContext()) == 1 { + { + p.SetState(16229) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBATCH || _la == PlSqlParserIMMEDIATE) { + 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 +} + +// IRollback_statementContext is an interface to support dynamic dispatch. +type IRollback_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROLLBACK() antlr.TerminalNode + WORK() antlr.TerminalNode + TO() antlr.TerminalNode + Savepoint_name() ISavepoint_nameContext + FORCE() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + SAVEPOINT() antlr.TerminalNode + + // IsRollback_statementContext differentiates from other interfaces. + IsRollback_statementContext() +} + +type Rollback_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_statementContext() *Rollback_statementContext { + var p = new(Rollback_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_statement + return p +} + +func InitEmptyRollback_statementContext(p *Rollback_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_statement +} + +func (*Rollback_statementContext) IsRollback_statementContext() {} + +func NewRollback_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_statementContext { + var p = new(Rollback_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_statement + + return p +} + +func (s *Rollback_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_statementContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Rollback_statementContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Rollback_statementContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Rollback_statementContext) Savepoint_name() ISavepoint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_nameContext) +} + +func (s *Rollback_statementContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Rollback_statementContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Rollback_statementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Rollback_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_statement(s) + } +} + +func (s *Rollback_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_statement(s) + } +} + +func (s *Rollback_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRollback_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rollback_statement() (localctx IRollback_statementContext) { + localctx = NewRollback_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1874, PlSqlParserRULE_rollback_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16232) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16234) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2180, p.GetParserRuleContext()) == 1 { + { + p.SetState(16233) + p.Match(PlSqlParserWORK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16243) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2182, p.GetParserRuleContext()) == 1 { + { + p.SetState(16236) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16238) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2181, p.GetParserRuleContext()) == 1 { + { + p.SetState(16237) + p.Match(PlSqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16240) + p.Savepoint_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2182, p.GetParserRuleContext()) == 2 { + { + p.SetState(16241) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16242) + p.Quoted_string() + } + + } 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 +} + +// ISavepoint_statementContext is an interface to support dynamic dispatch. +type ISavepoint_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SAVEPOINT() antlr.TerminalNode + Savepoint_name() ISavepoint_nameContext + + // IsSavepoint_statementContext differentiates from other interfaces. + IsSavepoint_statementContext() +} + +type Savepoint_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySavepoint_statementContext() *Savepoint_statementContext { + var p = new(Savepoint_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_statement + return p +} + +func InitEmptySavepoint_statementContext(p *Savepoint_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_statement +} + +func (*Savepoint_statementContext) IsSavepoint_statementContext() {} + +func NewSavepoint_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_statementContext { + var p = new(Savepoint_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_savepoint_statement + + return p +} + +func (s *Savepoint_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Savepoint_statementContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Savepoint_statementContext) Savepoint_name() ISavepoint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISavepoint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISavepoint_nameContext) +} + +func (s *Savepoint_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Savepoint_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Savepoint_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSavepoint_statement(s) + } +} + +func (s *Savepoint_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSavepoint_statement(s) + } +} + +func (s *Savepoint_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSavepoint_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Savepoint_statement() (localctx ISavepoint_statementContext) { + localctx = NewSavepoint_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1876, PlSqlParserRULE_savepoint_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16245) + p.Match(PlSqlParserSAVEPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16246) + p.Savepoint_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 +} + +// IExplain_statementContext is an interface to support dynamic dispatch. +type IExplain_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EXPLAIN() antlr.TerminalNode + PLAN() antlr.TerminalNode + FOR() antlr.TerminalNode + Select_statement() ISelect_statementContext + Update_statement() IUpdate_statementContext + Delete_statement() IDelete_statementContext + Insert_statement() IInsert_statementContext + Merge_statement() IMerge_statementContext + SET() antlr.TerminalNode + STATEMENT_ID() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Quoted_string() IQuoted_stringContext + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsExplain_statementContext differentiates from other interfaces. + IsExplain_statementContext() +} + +type Explain_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExplain_statementContext() *Explain_statementContext { + var p = new(Explain_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_explain_statement + return p +} + +func InitEmptyExplain_statementContext(p *Explain_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_explain_statement +} + +func (*Explain_statementContext) IsExplain_statementContext() {} + +func NewExplain_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Explain_statementContext { + var p = new(Explain_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_explain_statement + + return p +} + +func (s *Explain_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Explain_statementContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLAIN, 0) +} + +func (s *Explain_statementContext) PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLAN, 0) +} + +func (s *Explain_statementContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Explain_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 *Explain_statementContext) 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 *Explain_statementContext) 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 *Explain_statementContext) 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 *Explain_statementContext) 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 *Explain_statementContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Explain_statementContext) STATEMENT_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_ID, 0) +} + +func (s *Explain_statementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Explain_statementContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Explain_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Explain_statementContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Explain_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Explain_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Explain_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExplain_statement(s) + } +} + +func (s *Explain_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExplain_statement(s) + } +} + +func (s *Explain_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExplain_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Explain_statement() (localctx IExplain_statementContext) { + localctx = NewExplain_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1878, PlSqlParserRULE_explain_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16248) + p.Match(PlSqlParserEXPLAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16249) + p.Match(PlSqlParserPLAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSET { + { + p.SetState(16250) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16251) + p.Match(PlSqlParserSTATEMENT_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16252) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16253) + p.Quoted_string() + } + + } + p.SetState(16258) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTO { + { + p.SetState(16256) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16257) + p.Tableview_name() + } + + } + { + p.SetState(16260) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(16261) + p.Select_statement() + } + + case PlSqlParserUPDATE: + { + p.SetState(16262) + p.Update_statement() + } + + case PlSqlParserDELETE: + { + p.SetState(16263) + p.Delete_statement() + } + + case PlSqlParserINSERT: + { + p.SetState(16264) + p.Insert_statement() + } + + case PlSqlParserMERGE: + { + p.SetState(16265) + p.Merge_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 +} + +// ISelect_only_statementContext is an interface to support dynamic dispatch. +type ISelect_only_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery() ISubqueryContext + + // IsSelect_only_statementContext differentiates from other interfaces. + IsSelect_only_statementContext() +} + +type Select_only_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_only_statementContext() *Select_only_statementContext { + var p = new(Select_only_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_only_statement + return p +} + +func InitEmptySelect_only_statementContext(p *Select_only_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_only_statement +} + +func (*Select_only_statementContext) IsSelect_only_statementContext() {} + +func NewSelect_only_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_only_statementContext { + var p = new(Select_only_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_select_only_statement + + return p +} + +func (s *Select_only_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_only_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 *Select_only_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_only_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_only_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelect_only_statement(s) + } +} + +func (s *Select_only_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_only_statement(s) + } +} + +func (s *Select_only_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSelect_only_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Select_only_statement() (localctx ISelect_only_statementContext) { + localctx = NewSelect_only_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1880, PlSqlParserRULE_select_only_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16268) + p.Subquery() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_only_statement() ISelect_only_statementContext + AllFor_update_clause() []IFor_update_clauseContext + For_update_clause(i int) IFor_update_clauseContext + AllOrder_by_clause() []IOrder_by_clauseContext + Order_by_clause(i int) IOrder_by_clauseContext + AllOffset_clause() []IOffset_clauseContext + Offset_clause(i int) IOffset_clauseContext + AllFetch_clause() []IFetch_clauseContext + Fetch_clause(i int) IFetch_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 = PlSqlParserRULE_select_statement + return p +} + +func InitEmptySelect_statementContext(p *Select_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_select_statement + + return p +} + +func (s *Select_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_statementContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Select_statementContext) AllFor_update_clause() []IFor_update_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFor_update_clauseContext); ok { + len++ + } + } + + tst := make([]IFor_update_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFor_update_clauseContext); ok { + tst[i] = t.(IFor_update_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) For_update_clause(i int) IFor_update_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_clauseContext) +} + +func (s *Select_statementContext) AllOrder_by_clause() []IOrder_by_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + len++ + } + } + + tst := make([]IOrder_by_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_by_clauseContext); ok { + tst[i] = t.(IOrder_by_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Order_by_clause(i int) IOrder_by_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_clauseContext) +} + +func (s *Select_statementContext) AllOffset_clause() []IOffset_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOffset_clauseContext); ok { + len++ + } + } + + tst := make([]IOffset_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOffset_clauseContext); ok { + tst[i] = t.(IOffset_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Offset_clause(i int) IOffset_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOffset_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOffset_clauseContext) +} + +func (s *Select_statementContext) AllFetch_clause() []IFetch_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFetch_clauseContext); ok { + len++ + } + } + + tst := make([]IFetch_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFetch_clauseContext); ok { + tst[i] = t.(IFetch_clauseContext) + i++ + } + } + + return tst +} + +func (s *Select_statementContext) Fetch_clause(i int) IFetch_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFetch_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.(PlSqlParserListener); ok { + listenerT.EnterSelect_statement(s) + } +} + +func (s *Select_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_statement(s) + } +} + +func (s *Select_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSelect_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Select_statement() (localctx ISelect_statementContext) { + localctx = NewSelect_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1882, PlSqlParserRULE_select_statement) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16270) + p.Select_only_statement() + } + p.SetState(16277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2187, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(16275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFOR: + { + p.SetState(16271) + p.For_update_clause() + } + + case PlSqlParserORDER: + { + p.SetState(16272) + p.Order_by_clause() + } + + case PlSqlParserOFFSET: + { + p.SetState(16273) + p.Offset_clause() + } + + case PlSqlParserFETCH: + { + p.SetState(16274) + p.Fetch_clause() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(16279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2187, 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 +} + +// ISubquery_factoring_clauseContext is an interface to support dynamic dispatch. +type ISubquery_factoring_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + AllFactoring_element() []IFactoring_elementContext + Factoring_element(i int) IFactoring_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSubquery_factoring_clauseContext differentiates from other interfaces. + IsSubquery_factoring_clauseContext() +} + +type Subquery_factoring_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_factoring_clauseContext() *Subquery_factoring_clauseContext { + var p = new(Subquery_factoring_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause + return p +} + +func InitEmptySubquery_factoring_clauseContext(p *Subquery_factoring_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause +} + +func (*Subquery_factoring_clauseContext) IsSubquery_factoring_clauseContext() {} + +func NewSubquery_factoring_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_factoring_clauseContext { + var p = new(Subquery_factoring_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_factoring_clause + + return p +} + +func (s *Subquery_factoring_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_factoring_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Subquery_factoring_clauseContext) AllFactoring_element() []IFactoring_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFactoring_elementContext); ok { + len++ + } + } + + tst := make([]IFactoring_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFactoring_elementContext); ok { + tst[i] = t.(IFactoring_elementContext) + i++ + } + } + + return tst +} + +func (s *Subquery_factoring_clauseContext) Factoring_element(i int) IFactoring_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFactoring_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFactoring_elementContext) +} + +func (s *Subquery_factoring_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Subquery_factoring_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Subquery_factoring_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_factoring_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_factoring_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_factoring_clause(s) + } +} + +func (s *Subquery_factoring_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_factoring_clause(s) + } +} + +func (s *Subquery_factoring_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubquery_factoring_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subquery_factoring_clause() (localctx ISubquery_factoring_clauseContext) { + localctx = NewSubquery_factoring_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1884, PlSqlParserRULE_subquery_factoring_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16280) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16281) + p.Factoring_element() + } + p.SetState(16286) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16282) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16283) + p.Factoring_element() + } + + p.SetState(16288) + 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 +} + +// IFactoring_elementContext is an interface to support dynamic dispatch. +type IFactoring_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_name() IQuery_nameContext + AS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + Order_by_clause() IOrder_by_clauseContext + Search_clause() ISearch_clauseContext + Cycle_clause() ICycle_clauseContext + + // IsFactoring_elementContext differentiates from other interfaces. + IsFactoring_elementContext() +} + +type Factoring_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFactoring_elementContext() *Factoring_elementContext { + var p = new(Factoring_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_factoring_element + return p +} + +func InitEmptyFactoring_elementContext(p *Factoring_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_factoring_element +} + +func (*Factoring_elementContext) IsFactoring_elementContext() {} + +func NewFactoring_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Factoring_elementContext { + var p = new(Factoring_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_factoring_element + + return p +} + +func (s *Factoring_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Factoring_elementContext) Query_name() IQuery_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_nameContext) +} + +func (s *Factoring_elementContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Factoring_elementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Factoring_elementContext) 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 *Factoring_elementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Factoring_elementContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Factoring_elementContext) 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 *Factoring_elementContext) Search_clause() ISearch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearch_clauseContext) +} + +func (s *Factoring_elementContext) Cycle_clause() ICycle_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICycle_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICycle_clauseContext) +} + +func (s *Factoring_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Factoring_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Factoring_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFactoring_element(s) + } +} + +func (s *Factoring_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFactoring_element(s) + } +} + +func (s *Factoring_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFactoring_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Factoring_element() (localctx IFactoring_elementContext) { + localctx = NewFactoring_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1886, PlSqlParserRULE_factoring_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16289) + p.Query_name() + } + p.SetState(16291) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(16290) + p.Paren_column_list() + } + + } + { + p.SetState(16293) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16294) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16295) + p.Subquery() + } + p.SetState(16297) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(16296) + p.Order_by_clause() + } + + } + { + p.SetState(16299) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16301) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSEARCH { + { + p.SetState(16300) + p.Search_clause() + } + + } + p.SetState(16304) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCYCLE { + { + p.SetState(16303) + p.Cycle_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 +} + +// ISearch_clauseContext is an interface to support dynamic dispatch. +type ISearch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEARCH() antlr.TerminalNode + AllFIRST() []antlr.TerminalNode + FIRST(i int) antlr.TerminalNode + BY() antlr.TerminalNode + AllColumn_name() []IColumn_nameContext + Column_name(i int) IColumn_nameContext + SET() antlr.TerminalNode + DEPTH() antlr.TerminalNode + BREADTH() antlr.TerminalNode + AllASC() []antlr.TerminalNode + ASC(i int) antlr.TerminalNode + AllDESC() []antlr.TerminalNode + DESC(i int) antlr.TerminalNode + AllNULLS() []antlr.TerminalNode + NULLS(i int) antlr.TerminalNode + AllLAST() []antlr.TerminalNode + LAST(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSearch_clauseContext differentiates from other interfaces. + IsSearch_clauseContext() +} + +type Search_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearch_clauseContext() *Search_clauseContext { + var p = new(Search_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_search_clause + return p +} + +func InitEmptySearch_clauseContext(p *Search_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_search_clause +} + +func (*Search_clauseContext) IsSearch_clauseContext() {} + +func NewSearch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Search_clauseContext { + var p = new(Search_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_search_clause + + return p +} + +func (s *Search_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Search_clauseContext) SEARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEARCH, 0) +} + +func (s *Search_clauseContext) AllFIRST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserFIRST) +} + +func (s *Search_clauseContext) FIRST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, i) +} + +func (s *Search_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Search_clauseContext) 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 *Search_clauseContext) 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 *Search_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Search_clauseContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Search_clauseContext) BREADTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBREADTH, 0) +} + +func (s *Search_clauseContext) AllASC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserASC) +} + +func (s *Search_clauseContext) ASC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, i) +} + +func (s *Search_clauseContext) AllDESC() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDESC) +} + +func (s *Search_clauseContext) DESC(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, i) +} + +func (s *Search_clauseContext) AllNULLS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULLS) +} + +func (s *Search_clauseContext) NULLS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, i) +} + +func (s *Search_clauseContext) AllLAST() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLAST) +} + +func (s *Search_clauseContext) LAST(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, i) +} + +func (s *Search_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Search_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Search_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Search_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Search_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearch_clause(s) + } +} + +func (s *Search_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearch_clause(s) + } +} + +func (s *Search_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSearch_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Search_clause() (localctx ISearch_clauseContext) { + localctx = NewSearch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1888, PlSqlParserRULE_search_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16306) + p.Match(PlSqlParserSEARCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16307) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBREADTH || _la == PlSqlParserDEPTH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16308) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16309) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16310) + p.Column_name() + } + p.SetState(16312) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC { + { + p.SetState(16311) + p.Match(PlSqlParserASC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16315) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESC { + { + p.SetState(16314) + p.Match(PlSqlParserDESC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16319) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2195, p.GetParserRuleContext()) == 1 { + { + p.SetState(16317) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16318) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16323) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLS { + { + p.SetState(16321) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16322) + p.Match(PlSqlParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16343) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16325) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16326) + p.Column_name() + } + p.SetState(16328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASC { + { + p.SetState(16327) + p.Match(PlSqlParserASC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDESC { + { + p.SetState(16330) + p.Match(PlSqlParserDESC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16335) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2199, p.GetParserRuleContext()) == 1 { + { + p.SetState(16333) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16334) + p.Match(PlSqlParserFIRST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16339) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULLS { + { + p.SetState(16337) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16338) + p.Match(PlSqlParserLAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + p.SetState(16345) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16346) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16347) + p.Column_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 +} + +// ICycle_clauseContext is an interface to support dynamic dispatch. +type ICycle_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CYCLE() antlr.TerminalNode + Column_list() IColumn_listContext + SET() antlr.TerminalNode + Column_name() IColumn_nameContext + TO() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + DEFAULT() antlr.TerminalNode + + // IsCycle_clauseContext differentiates from other interfaces. + IsCycle_clauseContext() +} + +type Cycle_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCycle_clauseContext() *Cycle_clauseContext { + var p = new(Cycle_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cycle_clause + return p +} + +func InitEmptyCycle_clauseContext(p *Cycle_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cycle_clause +} + +func (*Cycle_clauseContext) IsCycle_clauseContext() {} + +func NewCycle_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cycle_clauseContext { + var p = new(Cycle_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cycle_clause + + return p +} + +func (s *Cycle_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cycle_clauseContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Cycle_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 *Cycle_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Cycle_clauseContext) 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 *Cycle_clauseContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Cycle_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Cycle_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Cycle_clauseContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Cycle_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cycle_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cycle_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCycle_clause(s) + } +} + +func (s *Cycle_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCycle_clause(s) + } +} + +func (s *Cycle_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCycle_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cycle_clause() (localctx ICycle_clauseContext) { + localctx = NewCycle_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1890, PlSqlParserRULE_cycle_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16349) + p.Match(PlSqlParserCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16350) + p.Column_list() + } + { + p.SetState(16351) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16352) + p.Column_name() + } + { + p.SetState(16353) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16354) + p.Expression() + } + { + p.SetState(16355) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16356) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubqueryContext is an interface to support dynamic dispatch. +type ISubqueryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery_basic_elements() ISubquery_basic_elementsContext + AllSubquery_operation_part() []ISubquery_operation_partContext + Subquery_operation_part(i int) ISubquery_operation_partContext + + // 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 = PlSqlParserRULE_subquery + return p +} + +func InitEmptySubqueryContext(p *SubqueryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_subquery + + return p +} + +func (s *SubqueryContext) GetParser() antlr.Parser { return s.parser } + +func (s *SubqueryContext) Subquery_basic_elements() ISubquery_basic_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_basic_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_basic_elementsContext) +} + +func (s *SubqueryContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *SubqueryContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterSubquery(s) + } +} + +func (s *SubqueryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery(s) + } +} + +func (s *SubqueryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubquery(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subquery() (localctx ISubqueryContext) { + localctx = NewSubqueryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1892, PlSqlParserRULE_subquery) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16358) + p.Subquery_basic_elements() + } + p.SetState(16362) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2202, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16359) + p.Subquery_operation_part() + } + + } + p.SetState(16364) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2202, 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 +} + +// ISubquery_basic_elementsContext is an interface to support dynamic dispatch. +type ISubquery_basic_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Query_block() IQuery_blockContext + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + + // IsSubquery_basic_elementsContext differentiates from other interfaces. + IsSubquery_basic_elementsContext() +} + +type Subquery_basic_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_basic_elementsContext() *Subquery_basic_elementsContext { + var p = new(Subquery_basic_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements + return p +} + +func InitEmptySubquery_basic_elementsContext(p *Subquery_basic_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements +} + +func (*Subquery_basic_elementsContext) IsSubquery_basic_elementsContext() {} + +func NewSubquery_basic_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_basic_elementsContext { + var p = new(Subquery_basic_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_basic_elements + + return p +} + +func (s *Subquery_basic_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_basic_elementsContext) Query_block() IQuery_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_blockContext) +} + +func (s *Subquery_basic_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Subquery_basic_elementsContext) 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 *Subquery_basic_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Subquery_basic_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_basic_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_basic_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_basic_elements(s) + } +} + +func (s *Subquery_basic_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_basic_elements(s) + } +} + +func (s *Subquery_basic_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubquery_basic_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subquery_basic_elements() (localctx ISubquery_basic_elementsContext) { + localctx = NewSubquery_basic_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1894, PlSqlParserRULE_subquery_basic_elements) + p.SetState(16370) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSELECT, PlSqlParserWITH: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16365) + p.Query_block() + } + + case PlSqlParserLEFT_PAREN: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16366) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16367) + p.Subquery() + } + { + p.SetState(16368) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISubquery_operation_partContext is an interface to support dynamic dispatch. +type ISubquery_operation_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Subquery_basic_elements() ISubquery_basic_elementsContext + UNION() antlr.TerminalNode + INTERSECT() antlr.TerminalNode + MINUS() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsSubquery_operation_partContext differentiates from other interfaces. + IsSubquery_operation_partContext() +} + +type Subquery_operation_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_operation_partContext() *Subquery_operation_partContext { + var p = new(Subquery_operation_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_operation_part + return p +} + +func InitEmptySubquery_operation_partContext(p *Subquery_operation_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_operation_part +} + +func (*Subquery_operation_partContext) IsSubquery_operation_partContext() {} + +func NewSubquery_operation_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_operation_partContext { + var p = new(Subquery_operation_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_operation_part + + return p +} + +func (s *Subquery_operation_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_operation_partContext) Subquery_basic_elements() ISubquery_basic_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_basic_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_basic_elementsContext) +} + +func (s *Subquery_operation_partContext) UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNION, 0) +} + +func (s *Subquery_operation_partContext) INTERSECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERSECT, 0) +} + +func (s *Subquery_operation_partContext) MINUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS, 0) +} + +func (s *Subquery_operation_partContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Subquery_operation_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_operation_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_operation_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_operation_part(s) + } +} + +func (s *Subquery_operation_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_operation_part(s) + } +} + +func (s *Subquery_operation_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubquery_operation_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subquery_operation_part() (localctx ISubquery_operation_partContext) { + localctx = NewSubquery_operation_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1896, PlSqlParserRULE_subquery_operation_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16378) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNION: + { + p.SetState(16372) + p.Match(PlSqlParserUNION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(16373) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserINTERSECT: + { + p.SetState(16376) + p.Match(PlSqlParserINTERSECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUS: + { + p.SetState(16377) + p.Match(PlSqlParserMINUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16380) + p.Subquery_basic_elements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_blockContext is an interface to support dynamic dispatch. +type IQuery_blockContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SELECT() antlr.TerminalNode + Selected_list() ISelected_listContext + From_clause() IFrom_clauseContext + Subquery_factoring_clause() ISubquery_factoring_clauseContext + Into_clause() IInto_clauseContext + Where_clause() IWhere_clauseContext + Hierarchical_query_clause() IHierarchical_query_clauseContext + Group_by_clause() IGroup_by_clauseContext + Model_clause() IModel_clauseContext + Order_by_clause() IOrder_by_clauseContext + Fetch_clause() IFetch_clauseContext + DISTINCT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsQuery_blockContext differentiates from other interfaces. + IsQuery_blockContext() +} + +type Query_blockContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_blockContext() *Query_blockContext { + var p = new(Query_blockContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_block + return p +} + +func InitEmptyQuery_blockContext(p *Query_blockContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_block +} + +func (*Query_blockContext) IsQuery_blockContext() {} + +func NewQuery_blockContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_blockContext { + var p = new(Query_blockContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_block + + return p +} + +func (s *Query_blockContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_blockContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Query_blockContext) Selected_list() ISelected_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelected_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelected_listContext) +} + +func (s *Query_blockContext) 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 *Query_blockContext) Subquery_factoring_clause() ISubquery_factoring_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_factoring_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_factoring_clauseContext) +} + +func (s *Query_blockContext) 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 *Query_blockContext) 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 *Query_blockContext) Hierarchical_query_clause() IHierarchical_query_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IHierarchical_query_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IHierarchical_query_clauseContext) +} + +func (s *Query_blockContext) 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 *Query_blockContext) Model_clause() IModel_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_clauseContext) +} + +func (s *Query_blockContext) 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 *Query_blockContext) Fetch_clause() IFetch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFetch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFetch_clauseContext) +} + +func (s *Query_blockContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Query_blockContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Query_blockContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Query_blockContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_blockContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_blockContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_block(s) + } +} + +func (s *Query_blockContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_block(s) + } +} + +func (s *Query_blockContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuery_block(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Query_block() (localctx IQuery_blockContext) { + localctx = NewQuery_blockContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1898, PlSqlParserRULE_query_block) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16383) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(16382) + p.Subquery_factoring_clause() + } + + } + { + p.SetState(16385) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16387) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2207, p.GetParserRuleContext()) == 1 { + { + p.SetState(16386) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16389) + p.Selected_list() + } + p.SetState(16391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBULK || _la == PlSqlParserINTO { + { + p.SetState(16390) + p.Into_clause() + } + + } + { + p.SetState(16393) + p.From_clause() + } + p.SetState(16395) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2209, p.GetParserRuleContext()) == 1 { + { + p.SetState(16394) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16398) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2210, p.GetParserRuleContext()) == 1 { + { + p.SetState(16397) + p.Hierarchical_query_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16401) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2211, p.GetParserRuleContext()) == 1 { + { + p.SetState(16400) + p.Group_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16404) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2212, p.GetParserRuleContext()) == 1 { + { + p.SetState(16403) + p.Model_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16407) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2213, p.GetParserRuleContext()) == 1 { + { + p.SetState(16406) + p.Order_by_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16410) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2214, p.GetParserRuleContext()) == 1 { + { + p.SetState(16409) + p.Fetch_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 +} + +// ISelected_listContext is an interface to support dynamic dispatch. +type ISelected_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ASTERISK() antlr.TerminalNode + AllSelect_list_elements() []ISelect_list_elementsContext + Select_list_elements(i int) ISelect_list_elementsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsSelected_listContext differentiates from other interfaces. + IsSelected_listContext() +} + +type Selected_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelected_listContext() *Selected_listContext { + var p = new(Selected_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_list + return p +} + +func InitEmptySelected_listContext(p *Selected_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_list +} + +func (*Selected_listContext) IsSelected_listContext() {} + +func NewSelected_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selected_listContext { + var p = new(Selected_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selected_list + + return p +} + +func (s *Selected_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selected_listContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Selected_listContext) AllSelect_list_elements() []ISelect_list_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelect_list_elementsContext); ok { + len++ + } + } + + tst := make([]ISelect_list_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelect_list_elementsContext); ok { + tst[i] = t.(ISelect_list_elementsContext) + i++ + } + } + + return tst +} + +func (s *Selected_listContext) Select_list_elements(i int) ISelect_list_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_elementsContext) +} + +func (s *Selected_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Selected_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Selected_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selected_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selected_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelected_list(s) + } +} + +func (s *Selected_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelected_list(s) + } +} + +func (s *Selected_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSelected_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Selected_list() (localctx ISelected_listContext) { + localctx = NewSelected_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1900, PlSqlParserRULE_selected_list) + var _la int + + p.SetState(16421) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserASTERISK: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16412) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNOT, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16413) + p.Select_list_elements() + } + p.SetState(16418) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16414) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16415) + p.Select_list_elements() + } + + p.SetState(16420) + 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 +} + +// 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_ref_list() ITable_ref_listContext + + // IsFrom_clauseContext differentiates from other interfaces. + IsFrom_clauseContext() +} + +type From_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFrom_clauseContext() *From_clauseContext { + var p = new(From_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_from_clause + return p +} + +func InitEmptyFrom_clauseContext(p *From_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_from_clause + + return p +} + +func (s *From_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *From_clauseContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *From_clauseContext) Table_ref_list() ITable_ref_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_listContext) +} + +func (s *From_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *From_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *From_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFrom_clause(s) + } +} + +func (s *From_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFrom_clause(s) + } +} + +func (s *From_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFrom_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) From_clause() (localctx IFrom_clauseContext) { + localctx = NewFrom_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1902, PlSqlParserRULE_from_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16423) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16424) + p.Table_ref_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_elementsContext is an interface to support dynamic dispatch. +type ISelect_list_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_wild() ITable_wildContext + Expression() IExpressionContext + Column_alias() IColumn_aliasContext + + // IsSelect_list_elementsContext differentiates from other interfaces. + IsSelect_list_elementsContext() +} + +type Select_list_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelect_list_elementsContext() *Select_list_elementsContext { + var p = new(Select_list_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_list_elements + return p +} + +func InitEmptySelect_list_elementsContext(p *Select_list_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_select_list_elements +} + +func (*Select_list_elementsContext) IsSelect_list_elementsContext() {} + +func NewSelect_list_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Select_list_elementsContext { + var p = new(Select_list_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_select_list_elements + + return p +} + +func (s *Select_list_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Select_list_elementsContext) Table_wild() ITable_wildContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_wildContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_wildContext) +} + +func (s *Select_list_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Select_list_elementsContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Select_list_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Select_list_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Select_list_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelect_list_elements(s) + } +} + +func (s *Select_list_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelect_list_elements(s) + } +} + +func (s *Select_list_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSelect_list_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Select_list_elements() (localctx ISelect_list_elementsContext) { + localctx = NewSelect_list_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1904, PlSqlParserRULE_select_list_elements) + p.SetState(16431) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2218, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16426) + p.Table_wild() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16427) + p.Expression() + } + p.SetState(16429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2217, p.GetParserRuleContext()) == 1 { + { + p.SetState(16428) + p.Column_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 +} + +// ITable_wildContext is an interface to support dynamic dispatch. +type ITable_wildContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + PERIOD() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + + // IsTable_wildContext differentiates from other interfaces. + IsTable_wildContext() +} + +type Table_wildContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_wildContext() *Table_wildContext { + var p = new(Table_wildContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_wild + return p +} + +func InitEmptyTable_wildContext(p *Table_wildContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_wild +} + +func (*Table_wildContext) IsTable_wildContext() {} + +func NewTable_wildContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_wildContext { + var p = new(Table_wildContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_wild + + return p +} + +func (s *Table_wildContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_wildContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Table_wildContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Table_wildContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Table_wildContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_wildContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_wildContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_wild(s) + } +} + +func (s *Table_wildContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_wild(s) + } +} + +func (s *Table_wildContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_wild(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_wild() (localctx ITable_wildContext) { + localctx = NewTable_wildContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1906, PlSqlParserRULE_table_wild) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16433) + p.Tableview_name() + } + { + p.SetState(16434) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16435) + p.Match(PlSqlParserASTERISK) + 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 +} + +// ITable_ref_listContext is an interface to support dynamic dispatch. +type ITable_ref_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllTable_ref() []ITable_refContext + Table_ref(i int) ITable_refContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsTable_ref_listContext differentiates from other interfaces. + IsTable_ref_listContext() +} + +type Table_ref_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_listContext() *Table_ref_listContext { + var p = new(Table_ref_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_list + return p +} + +func InitEmptyTable_ref_listContext(p *Table_ref_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_list +} + +func (*Table_ref_listContext) IsTable_ref_listContext() {} + +func NewTable_ref_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_listContext { + var p = new(Table_ref_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_list + + return p +} + +func (s *Table_ref_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_listContext) AllTable_ref() []ITable_refContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ITable_refContext); ok { + len++ + } + } + + tst := make([]ITable_refContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ITable_refContext); ok { + tst[i] = t.(ITable_refContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_listContext) Table_ref(i int) ITable_refContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *Table_ref_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Table_ref_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Table_ref_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_ref_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_list(s) + } +} + +func (s *Table_ref_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_list(s) + } +} + +func (s *Table_ref_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_ref_list() (localctx ITable_ref_listContext) { + localctx = NewTable_ref_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1908, PlSqlParserRULE_table_ref_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16437) + p.Table_ref() + } + p.SetState(16442) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2219, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16438) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16439) + p.Table_ref() + } + + } + p.SetState(16444) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2219, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_refContext is an interface to support dynamic dispatch. +type ITable_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_ref_aux() ITable_ref_auxContext + AllJoin_clause() []IJoin_clauseContext + Join_clause(i int) IJoin_clauseContext + Pivot_clause() IPivot_clauseContext + Unpivot_clause() IUnpivot_clauseContext + + // IsTable_refContext differentiates from other interfaces. + IsTable_refContext() +} + +type Table_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_refContext() *Table_refContext { + var p = new(Table_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref + return p +} + +func InitEmptyTable_refContext(p *Table_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref +} + +func (*Table_refContext) IsTable_refContext() {} + +func NewTable_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_refContext { + var p = new(Table_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref + + return p +} + +func (s *Table_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_refContext) Table_ref_aux() ITable_ref_auxContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_auxContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_auxContext) +} + +func (s *Table_refContext) 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_refContext) 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_refContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_refContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref(s) + } +} + +func (s *Table_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref(s) + } +} + +func (s *Table_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_ref() (localctx ITable_refContext) { + localctx = NewTable_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1910, PlSqlParserRULE_table_ref) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16445) + p.Table_ref_aux() + } + p.SetState(16449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2220, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16446) + p.Join_clause() + } + + } + p.SetState(16451) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2220, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16454) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2221, p.GetParserRuleContext()) == 1 { + { + p.SetState(16452) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2221, p.GetParserRuleContext()) == 2 { + { + p.SetState(16453) + p.Unpivot_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 +} + +// ITable_ref_auxContext is an interface to support dynamic dispatch. +type ITable_ref_auxContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_ref_aux_internal() ITable_ref_aux_internalContext + AllFlashback_query_clause() []IFlashback_query_clauseContext + Flashback_query_clause(i int) IFlashback_query_clauseContext + Table_alias() ITable_aliasContext + + // IsTable_ref_auxContext differentiates from other interfaces. + IsTable_ref_auxContext() +} + +type Table_ref_auxContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_auxContext() *Table_ref_auxContext { + var p = new(Table_ref_auxContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux + return p +} + +func InitEmptyTable_ref_auxContext(p *Table_ref_auxContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux +} + +func (*Table_ref_auxContext) IsTable_ref_auxContext() {} + +func NewTable_ref_auxContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_auxContext { + var p = new(Table_ref_auxContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_aux + + return p +} + +func (s *Table_ref_auxContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_auxContext) Table_ref_aux_internal() ITable_ref_aux_internalContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_aux_internalContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_aux_internalContext) +} + +func (s *Table_ref_auxContext) AllFlashback_query_clause() []IFlashback_query_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IFlashback_query_clauseContext); ok { + len++ + } + } + + tst := make([]IFlashback_query_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IFlashback_query_clauseContext); ok { + tst[i] = t.(IFlashback_query_clauseContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_auxContext) Flashback_query_clause(i int) IFlashback_query_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFlashback_query_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IFlashback_query_clauseContext) +} + +func (s *Table_ref_auxContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Table_ref_auxContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_auxContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_ref_auxContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux(s) + } +} + +func (s *Table_ref_auxContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux(s) + } +} + +func (s *Table_ref_auxContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref_aux(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_ref_aux() (localctx ITable_ref_auxContext) { + localctx = NewTable_ref_auxContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1912, PlSqlParserRULE_table_ref_aux) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16456) + p.Table_ref_aux_internal() + } + p.SetState(16460) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2222, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16457) + p.Flashback_query_clause() + } + + } + p.SetState(16462) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2222, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16465) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2223, p.GetParserRuleContext()) == 1 { + p.SetState(16463) + + if !(p.IsTableAlias()) { + p.SetError(antlr.NewFailedPredicateException(p, "p.IsTableAlias()", "")) + goto errorExit + } + { + p.SetState(16464) + p.Table_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 +} + +// ITable_ref_aux_internalContext is an interface to support dynamic dispatch. +type ITable_ref_aux_internalContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + // IsTable_ref_aux_internalContext differentiates from other interfaces. + IsTable_ref_aux_internalContext() +} + +type Table_ref_aux_internalContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_ref_aux_internalContext() *Table_ref_aux_internalContext { + var p = new(Table_ref_aux_internalContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal + return p +} + +func InitEmptyTable_ref_aux_internalContext(p *Table_ref_aux_internalContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal +} + +func (*Table_ref_aux_internalContext) IsTable_ref_aux_internalContext() {} + +func NewTable_ref_aux_internalContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_ref_aux_internalContext { + var p = new(Table_ref_aux_internalContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_ref_aux_internal + + return p +} + +func (s *Table_ref_aux_internalContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_ref_aux_internalContext) CopyAll(ctx *Table_ref_aux_internalContext) { + s.CopyFrom(&ctx.BaseParserRuleContext) +} + +func (s *Table_ref_aux_internalContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internalContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +type Table_ref_aux_internal_threeContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_threeContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_threeContext { + var p = new(Table_ref_aux_internal_threeContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_threeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_threeContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Table_ref_aux_internal_threeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_threeContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *Table_ref_aux_internal_threeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_threeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_three(s) + } +} + +func (s *Table_ref_aux_internal_threeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_three(s) + } +} + +func (s *Table_ref_aux_internal_threeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref_aux_internal_three(s) + + default: + return t.VisitChildren(s) + } +} + +type Table_ref_aux_internal_oneContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_oneContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_oneContext { + var p = new(Table_ref_aux_internal_oneContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_oneContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_oneContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_ref_aux_internal_oneContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_one(s) + } +} + +func (s *Table_ref_aux_internal_oneContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_one(s) + } +} + +func (s *Table_ref_aux_internal_oneContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref_aux_internal_one(s) + + default: + return t.VisitChildren(s) + } +} + +type Table_ref_aux_internal_twoContext struct { + Table_ref_aux_internalContext +} + +func NewTable_ref_aux_internal_twoContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Table_ref_aux_internal_twoContext { + var p = new(Table_ref_aux_internal_twoContext) + + InitEmptyTable_ref_aux_internalContext(&p.Table_ref_aux_internalContext) + p.parser = parser + p.CopyAll(ctx.(*Table_ref_aux_internalContext)) + + return p +} + +func (s *Table_ref_aux_internal_twoContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_ref_aux_internal_twoContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_twoContext) Table_ref() ITable_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_refContext) +} + +func (s *Table_ref_aux_internal_twoContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_ref_aux_internal_twoContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *Table_ref_aux_internal_twoContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +func (s *Table_ref_aux_internal_twoContext) Pivot_clause() IPivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_clauseContext) +} + +func (s *Table_ref_aux_internal_twoContext) Unpivot_clause() IUnpivot_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_clauseContext) +} + +func (s *Table_ref_aux_internal_twoContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_ref_aux_internal_two(s) + } +} + +func (s *Table_ref_aux_internal_twoContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_ref_aux_internal_two(s) + } +} + +func (s *Table_ref_aux_internal_twoContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_ref_aux_internal_two(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_ref_aux_internal() (localctx ITable_ref_aux_internalContext) { + localctx = NewTable_ref_aux_internalContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1914, PlSqlParserRULE_table_ref_aux_internal) + var _la int + + p.SetState(16490) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2227, p.GetParserRuleContext()) { + case 1: + localctx = NewTable_ref_aux_internal_oneContext(p, localctx) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16467) + p.Dml_table_expression_clause() + } + p.SetState(16470) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2224, p.GetParserRuleContext()) == 1 { + { + p.SetState(16468) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2224, p.GetParserRuleContext()) == 2 { + { + p.SetState(16469) + p.Unpivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + localctx = NewTable_ref_aux_internal_twoContext(p, localctx) + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16472) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16473) + p.Table_ref() + } + p.SetState(16477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserINTERSECT || _la == PlSqlParserMINUS || _la == PlSqlParserUNION { + { + p.SetState(16474) + p.Subquery_operation_part() + } + + p.SetState(16479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16480) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16483) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2226, p.GetParserRuleContext()) == 1 { + { + p.SetState(16481) + p.Pivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2226, p.GetParserRuleContext()) == 2 { + { + p.SetState(16482) + p.Unpivot_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + localctx = NewTable_ref_aux_internal_threeContext(p, localctx) + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16485) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16486) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16487) + p.Dml_table_expression_clause() + } + { + p.SetState(16488) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Table_ref_aux() ITable_ref_auxContext + AllQuery_partition_clause() []IQuery_partition_clauseContext + Query_partition_clause(i int) IQuery_partition_clauseContext + INNER() antlr.TerminalNode + Outer_join_type() IOuter_join_typeContext + AllJoin_on_part() []IJoin_on_partContext + Join_on_part(i int) IJoin_on_partContext + AllJoin_using_part() []IJoin_using_partContext + Join_using_part(i int) IJoin_using_partContext + CROSS() antlr.TerminalNode + NATURAL() 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 = PlSqlParserRULE_join_clause + return p +} + +func InitEmptyJoin_clauseContext(p *Join_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_join_clause + + return p +} + +func (s *Join_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_clauseContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Join_clauseContext) Table_ref_aux() ITable_ref_auxContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_ref_auxContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_ref_auxContext) +} + +func (s *Join_clauseContext) AllQuery_partition_clause() []IQuery_partition_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + len++ + } + } + + tst := make([]IQuery_partition_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuery_partition_clauseContext); ok { + tst[i] = t.(IQuery_partition_clauseContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Query_partition_clause(i int) IQuery_partition_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuery_partition_clauseContext) +} + +func (s *Join_clauseContext) INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINNER, 0) +} + +func (s *Join_clauseContext) Outer_join_type() IOuter_join_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_typeContext) +} + +func (s *Join_clauseContext) AllJoin_on_part() []IJoin_on_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_on_partContext); ok { + len++ + } + } + + tst := make([]IJoin_on_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_on_partContext); ok { + tst[i] = t.(IJoin_on_partContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Join_on_part(i int) IJoin_on_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_on_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_on_partContext) +} + +func (s *Join_clauseContext) AllJoin_using_part() []IJoin_using_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJoin_using_partContext); ok { + len++ + } + } + + tst := make([]IJoin_using_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJoin_using_partContext); ok { + tst[i] = t.(IJoin_using_partContext) + i++ + } + } + + return tst +} + +func (s *Join_clauseContext) Join_using_part(i int) IJoin_using_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJoin_using_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJoin_using_partContext) +} + +func (s *Join_clauseContext) CROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSS, 0) +} + +func (s *Join_clauseContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 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.(PlSqlParserListener); ok { + listenerT.EnterJoin_clause(s) + } +} + +func (s *Join_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_clause(s) + } +} + +func (s *Join_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_clause() (localctx IJoin_clauseContext) { + localctx = NewJoin_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1916, PlSqlParserRULE_join_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16493) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(16492) + p.Query_partition_clause() + } + + } + p.SetState(16496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCROSS || _la == PlSqlParserNATURAL { + { + p.SetState(16495) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCROSS || _la == PlSqlParserNATURAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(16500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserINNER: + { + p.SetState(16498) + p.Match(PlSqlParserINNER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFULL, PlSqlParserLEFT, PlSqlParserRIGHT: + { + p.SetState(16499) + p.Outer_join_type() + } + + case PlSqlParserJOIN: + + default: + } + { + p.SetState(16502) + p.Match(PlSqlParserJOIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16503) + p.Table_ref_aux() + } + p.SetState(16505) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2231, p.GetParserRuleContext()) == 1 { + { + p.SetState(16504) + p.Query_partition_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16511) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2233, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + p.SetState(16509) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserON: + { + p.SetState(16507) + p.Join_on_part() + } + + case PlSqlParserUSING: + { + p.SetState(16508) + p.Join_using_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(16513) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2233, 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 +} + +// IJoin_on_partContext is an interface to support dynamic dispatch. +type IJoin_on_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + Condition() IConditionContext + + // IsJoin_on_partContext differentiates from other interfaces. + IsJoin_on_partContext() +} + +type Join_on_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_on_partContext() *Join_on_partContext { + var p = new(Join_on_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_on_part + return p +} + +func InitEmptyJoin_on_partContext(p *Join_on_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_on_part +} + +func (*Join_on_partContext) IsJoin_on_partContext() {} + +func NewJoin_on_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_on_partContext { + var p = new(Join_on_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_on_part + + return p +} + +func (s *Join_on_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_on_partContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Join_on_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Join_on_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_on_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_on_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_on_part(s) + } +} + +func (s *Join_on_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_on_part(s) + } +} + +func (s *Join_on_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_on_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_on_part() (localctx IJoin_on_partContext) { + localctx = NewJoin_on_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1918, PlSqlParserRULE_join_on_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16514) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16515) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_using_partContext is an interface to support dynamic dispatch. +type IJoin_using_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + + // IsJoin_using_partContext differentiates from other interfaces. + IsJoin_using_partContext() +} + +type Join_using_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJoin_using_partContext() *Join_using_partContext { + var p = new(Join_using_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_using_part + return p +} + +func InitEmptyJoin_using_partContext(p *Join_using_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_join_using_part +} + +func (*Join_using_partContext) IsJoin_using_partContext() {} + +func NewJoin_using_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Join_using_partContext { + var p = new(Join_using_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_join_using_part + + return p +} + +func (s *Join_using_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Join_using_partContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Join_using_partContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Join_using_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Join_using_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Join_using_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJoin_using_part(s) + } +} + +func (s *Join_using_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJoin_using_part(s) + } +} + +func (s *Join_using_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJoin_using_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Join_using_part() (localctx IJoin_using_partContext) { + localctx = NewJoin_using_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1920, PlSqlParserRULE_join_using_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16517) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16518) + p.Paren_column_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 +} + +// IOuter_join_typeContext is an interface to support dynamic dispatch. +type IOuter_join_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FULL() antlr.TerminalNode + LEFT() antlr.TerminalNode + RIGHT() antlr.TerminalNode + OUTER() antlr.TerminalNode + + // IsOuter_join_typeContext differentiates from other interfaces. + IsOuter_join_typeContext() +} + +type Outer_join_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOuter_join_typeContext() *Outer_join_typeContext { + var p = new(Outer_join_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_type + return p +} + +func InitEmptyOuter_join_typeContext(p *Outer_join_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_type +} + +func (*Outer_join_typeContext) IsOuter_join_typeContext() {} + +func NewOuter_join_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outer_join_typeContext { + var p = new(Outer_join_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outer_join_type + + return p +} + +func (s *Outer_join_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outer_join_typeContext) FULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL, 0) +} + +func (s *Outer_join_typeContext) LEFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT, 0) +} + +func (s *Outer_join_typeContext) RIGHT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT, 0) +} + +func (s *Outer_join_typeContext) OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER, 0) +} + +func (s *Outer_join_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outer_join_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outer_join_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOuter_join_type(s) + } +} + +func (s *Outer_join_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOuter_join_type(s) + } +} + +func (s *Outer_join_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOuter_join_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Outer_join_type() (localctx IOuter_join_typeContext) { + localctx = NewOuter_join_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1922, PlSqlParserRULE_outer_join_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16520) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFULL || _la == PlSqlParserLEFT || _la == PlSqlParserRIGHT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOUTER { + { + p.SetState(16521) + p.Match(PlSqlParserOUTER) + 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 +} + +// IQuery_partition_clauseContext is an interface to support dynamic dispatch. +type IQuery_partition_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Expressions() IExpressionsContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + + // IsQuery_partition_clauseContext differentiates from other interfaces. + IsQuery_partition_clauseContext() +} + +type Query_partition_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_partition_clauseContext() *Query_partition_clauseContext { + var p = new(Query_partition_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_partition_clause + return p +} + +func InitEmptyQuery_partition_clauseContext(p *Query_partition_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_partition_clause +} + +func (*Query_partition_clauseContext) IsQuery_partition_clauseContext() {} + +func NewQuery_partition_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_partition_clauseContext { + var p = new(Query_partition_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_partition_clause + + return p +} + +func (s *Query_partition_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_partition_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Query_partition_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Query_partition_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Query_partition_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Query_partition_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Query_partition_clauseContext) 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 *Query_partition_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_partition_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_partition_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_partition_clause(s) + } +} + +func (s *Query_partition_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_partition_clause(s) + } +} + +func (s *Query_partition_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuery_partition_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Query_partition_clause() (localctx IQuery_partition_clauseContext) { + localctx = NewQuery_partition_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1924, PlSqlParserRULE_query_partition_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16524) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16525) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16533) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2236, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16526) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16529) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2235, p.GetParserRuleContext()) == 1 { + { + p.SetState(16527) + p.Subquery() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2235, p.GetParserRuleContext()) == 2 { + { + p.SetState(16528) + p.Expressions() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16531) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(16532) + p.Expressions() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IFlashback_query_clauseContext is an interface to support dynamic dispatch. +type IFlashback_query_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSIONS() antlr.TerminalNode + BETWEEN() antlr.TerminalNode + Expression() IExpressionContext + SCN() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + AS() antlr.TerminalNode + OF() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + + // IsFlashback_query_clauseContext differentiates from other interfaces. + IsFlashback_query_clauseContext() +} + +type Flashback_query_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFlashback_query_clauseContext() *Flashback_query_clauseContext { + var p = new(Flashback_query_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_query_clause + return p +} + +func InitEmptyFlashback_query_clauseContext(p *Flashback_query_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_flashback_query_clause +} + +func (*Flashback_query_clauseContext) IsFlashback_query_clauseContext() {} + +func NewFlashback_query_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Flashback_query_clauseContext { + var p = new(Flashback_query_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_flashback_query_clause + + return p +} + +func (s *Flashback_query_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Flashback_query_clauseContext) VERSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS, 0) +} + +func (s *Flashback_query_clauseContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Flashback_query_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Flashback_query_clauseContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Flashback_query_clauseContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Flashback_query_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Flashback_query_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Flashback_query_clauseContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Flashback_query_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Flashback_query_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Flashback_query_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFlashback_query_clause(s) + } +} + +func (s *Flashback_query_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFlashback_query_clause(s) + } +} + +func (s *Flashback_query_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFlashback_query_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Flashback_query_clause() (localctx IFlashback_query_clauseContext) { + localctx = NewFlashback_query_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1926, PlSqlParserRULE_flashback_query_clause) + var _la int + + p.SetState(16543) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVERSIONS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16535) + p.Match(PlSqlParserVERSIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16536) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16537) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16538) + p.Expression() + } + + case PlSqlParserAS: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16539) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16540) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16541) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserSCN || _la == PlSqlParserSNAPSHOT || _la == PlSqlParserTIMESTAMP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16542) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_clauseContext is an interface to support dynamic dispatch. +type IPivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PIVOT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllPivot_element() []IPivot_elementContext + Pivot_element(i int) IPivot_elementContext + Pivot_for_clause() IPivot_for_clauseContext + Pivot_in_clause() IPivot_in_clauseContext + RIGHT_PAREN() antlr.TerminalNode + XML() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPivot_clauseContext differentiates from other interfaces. + IsPivot_clauseContext() +} + +type Pivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_clauseContext() *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_clause + return p +} + +func InitEmptyPivot_clauseContext(p *Pivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_clause +} + +func (*Pivot_clauseContext) IsPivot_clauseContext() {} + +func NewPivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_clauseContext { + var p = new(Pivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_clause + + return p +} + +func (s *Pivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_clauseContext) PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIVOT, 0) +} + +func (s *Pivot_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_clauseContext) AllPivot_element() []IPivot_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_elementContext); ok { + len++ + } + } + + tst := make([]IPivot_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_elementContext); ok { + tst[i] = t.(IPivot_elementContext) + i++ + } + } + + return tst +} + +func (s *Pivot_clauseContext) Pivot_element(i int) IPivot_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_elementContext) +} + +func (s *Pivot_clauseContext) Pivot_for_clause() IPivot_for_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_for_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_for_clauseContext) +} + +func (s *Pivot_clauseContext) Pivot_in_clause() IPivot_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clauseContext) +} + +func (s *Pivot_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_clauseContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Pivot_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pivot_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_clause(s) + } +} + +func (s *Pivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_clause() (localctx IPivot_clauseContext) { + localctx = NewPivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1928, PlSqlParserRULE_pivot_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16545) + p.Match(PlSqlParserPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserXML { + { + p.SetState(16546) + p.Match(PlSqlParserXML) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16549) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16550) + p.Pivot_element() + } + p.SetState(16555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16551) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16552) + p.Pivot_element() + } + + p.SetState(16557) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16558) + p.Pivot_for_clause() + } + { + p.SetState(16559) + p.Pivot_in_clause() + } + { + p.SetState(16560) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_elementContext is an interface to support dynamic dispatch. +type IPivot_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Aggregate_function_name() IAggregate_function_nameContext + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Column_alias() IColumn_aliasContext + + // IsPivot_elementContext differentiates from other interfaces. + IsPivot_elementContext() +} + +type Pivot_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_elementContext() *Pivot_elementContext { + var p = new(Pivot_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_element + return p +} + +func InitEmptyPivot_elementContext(p *Pivot_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_element +} + +func (*Pivot_elementContext) IsPivot_elementContext() {} + +func NewPivot_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_elementContext { + var p = new(Pivot_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_element + + return p +} + +func (s *Pivot_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_elementContext) Aggregate_function_name() IAggregate_function_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAggregate_function_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAggregate_function_nameContext) +} + +func (s *Pivot_elementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_elementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Pivot_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_element(s) + } +} + +func (s *Pivot_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_element(s) + } +} + +func (s *Pivot_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_element() (localctx IPivot_elementContext) { + localctx = NewPivot_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1930, PlSqlParserRULE_pivot_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16562) + p.Aggregate_function_name() + } + { + p.SetState(16563) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16564) + p.Expression() + } + { + p.SetState(16565) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16567) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(16566) + p.Column_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 +} + +// IPivot_for_clauseContext is an interface to support dynamic dispatch. +type IPivot_for_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + + // IsPivot_for_clauseContext differentiates from other interfaces. + IsPivot_for_clauseContext() +} + +type Pivot_for_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_for_clauseContext() *Pivot_for_clauseContext { + var p = new(Pivot_for_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_for_clause + return p +} + +func InitEmptyPivot_for_clauseContext(p *Pivot_for_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_for_clause +} + +func (*Pivot_for_clauseContext) IsPivot_for_clauseContext() {} + +func NewPivot_for_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_for_clauseContext { + var p = new(Pivot_for_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_for_clause + + return p +} + +func (s *Pivot_for_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_for_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Pivot_for_clauseContext) 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_for_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Pivot_for_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_for_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_for_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_for_clause(s) + } +} + +func (s *Pivot_for_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_for_clause(s) + } +} + +func (s *Pivot_for_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_for_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_for_clause() (localctx IPivot_for_clauseContext) { + localctx = NewPivot_for_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1932, PlSqlParserRULE_pivot_for_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16569) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16572) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16570) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(16571) + p.Paren_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 +} + +// IPivot_in_clauseContext is an interface to support dynamic dispatch. +type IPivot_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + AllPivot_in_clause_element() []IPivot_in_clause_elementContext + Pivot_in_clause_element(i int) IPivot_in_clause_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsPivot_in_clauseContext differentiates from other interfaces. + IsPivot_in_clauseContext() +} + +type Pivot_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clauseContext() *Pivot_in_clauseContext { + var p = new(Pivot_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause + return p +} + +func InitEmptyPivot_in_clauseContext(p *Pivot_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause +} + +func (*Pivot_in_clauseContext) IsPivot_in_clauseContext() {} + +func NewPivot_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clauseContext { + var p = new(Pivot_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause + + return p +} + +func (s *Pivot_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Pivot_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_in_clauseContext) 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 *Pivot_in_clauseContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserANY) +} + +func (s *Pivot_in_clauseContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, i) +} + +func (s *Pivot_in_clauseContext) AllPivot_in_clause_element() []IPivot_in_clause_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IPivot_in_clause_elementContext); ok { + len++ + } + } + + tst := make([]IPivot_in_clause_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IPivot_in_clause_elementContext); ok { + tst[i] = t.(IPivot_in_clause_elementContext) + i++ + } + } + + return tst +} + +func (s *Pivot_in_clauseContext) Pivot_in_clause_element(i int) IPivot_in_clause_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clause_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clause_elementContext) +} + +func (s *Pivot_in_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Pivot_in_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Pivot_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause(s) + } +} + +func (s *Pivot_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause(s) + } +} + +func (s *Pivot_in_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_in_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause() (localctx IPivot_in_clauseContext) { + localctx = NewPivot_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1934, PlSqlParserRULE_pivot_in_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16574) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16575) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16593) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2244, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16576) + p.Subquery() + } + + case 2: + { + p.SetState(16577) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16582) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16578) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16579) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + p.SetState(16584) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + { + p.SetState(16585) + p.Pivot_in_clause_element() + } + p.SetState(16590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16586) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16587) + p.Pivot_in_clause_element() + } + + p.SetState(16592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(16595) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPivot_in_clause_elementContext is an interface to support dynamic dispatch. +type IPivot_in_clause_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Pivot_in_clause_elements() IPivot_in_clause_elementsContext + Column_alias() IColumn_aliasContext + + // IsPivot_in_clause_elementContext differentiates from other interfaces. + IsPivot_in_clause_elementContext() +} + +type Pivot_in_clause_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clause_elementContext() *Pivot_in_clause_elementContext { + var p = new(Pivot_in_clause_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element + return p +} + +func InitEmptyPivot_in_clause_elementContext(p *Pivot_in_clause_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element +} + +func (*Pivot_in_clause_elementContext) IsPivot_in_clause_elementContext() {} + +func NewPivot_in_clause_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clause_elementContext { + var p = new(Pivot_in_clause_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_element + + return p +} + +func (s *Pivot_in_clause_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clause_elementContext) Pivot_in_clause_elements() IPivot_in_clause_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_in_clause_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_in_clause_elementsContext) +} + +func (s *Pivot_in_clause_elementContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Pivot_in_clause_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clause_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clause_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause_element(s) + } +} + +func (s *Pivot_in_clause_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause_element(s) + } +} + +func (s *Pivot_in_clause_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_in_clause_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause_element() (localctx IPivot_in_clause_elementContext) { + localctx = NewPivot_in_clause_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1936, PlSqlParserRULE_pivot_in_clause_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16597) + p.Pivot_in_clause_elements() + } + p.SetState(16599) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(16598) + p.Column_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 +} + +// IPivot_in_clause_elementsContext is an interface to support dynamic dispatch. +type IPivot_in_clause_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + + // IsPivot_in_clause_elementsContext differentiates from other interfaces. + IsPivot_in_clause_elementsContext() +} + +type Pivot_in_clause_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPivot_in_clause_elementsContext() *Pivot_in_clause_elementsContext { + var p = new(Pivot_in_clause_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements + return p +} + +func InitEmptyPivot_in_clause_elementsContext(p *Pivot_in_clause_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements +} + +func (*Pivot_in_clause_elementsContext) IsPivot_in_clause_elementsContext() {} + +func NewPivot_in_clause_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Pivot_in_clause_elementsContext { + var p = new(Pivot_in_clause_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_pivot_in_clause_elements + + return p +} + +func (s *Pivot_in_clause_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Pivot_in_clause_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Pivot_in_clause_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Pivot_in_clause_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Pivot_in_clause_elementsContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Pivot_in_clause_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Pivot_in_clause_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Pivot_in_clause_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPivot_in_clause_elements(s) + } +} + +func (s *Pivot_in_clause_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPivot_in_clause_elements(s) + } +} + +func (s *Pivot_in_clause_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPivot_in_clause_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Pivot_in_clause_elements() (localctx IPivot_in_clause_elementsContext) { + localctx = NewPivot_in_clause_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1938, PlSqlParserRULE_pivot_in_clause_elements) + var _la int + + p.SetState(16607) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2247, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16601) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16602) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(16603) + p.Expressions() + } + + } + { + p.SetState(16606) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNPIVOT() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Pivot_for_clause() IPivot_for_clauseContext + Unpivot_in_clause() IUnpivot_in_clauseContext + RIGHT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + NULLS() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + + // IsUnpivot_clauseContext differentiates from other interfaces. + IsUnpivot_clauseContext() +} + +type Unpivot_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_clauseContext() *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_clause + return p +} + +func InitEmptyUnpivot_clauseContext(p *Unpivot_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_clause +} + +func (*Unpivot_clauseContext) IsUnpivot_clauseContext() {} + +func NewUnpivot_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_clauseContext { + var p = new(Unpivot_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_clause + + return p +} + +func (s *Unpivot_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_clauseContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPIVOT, 0) +} + +func (s *Unpivot_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_clauseContext) Pivot_for_clause() IPivot_for_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPivot_for_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPivot_for_clauseContext) +} + +func (s *Unpivot_clauseContext) Unpivot_in_clause() IUnpivot_in_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_clauseContext) +} + +func (s *Unpivot_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_clauseContext) 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 *Unpivot_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Unpivot_clauseContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Unpivot_clauseContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE, 0) +} + +func (s *Unpivot_clauseContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDE, 0) +} + +func (s *Unpivot_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_clause(s) + } +} + +func (s *Unpivot_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnpivot_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unpivot_clause() (localctx IUnpivot_clauseContext) { + localctx = NewUnpivot_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1940, PlSqlParserRULE_unpivot_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16609) + p.Match(PlSqlParserUNPIVOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXCLUDE || _la == PlSqlParserINCLUDE { + { + p.SetState(16610) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEXCLUDE || _la == PlSqlParserINCLUDE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16611) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16614) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16617) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16615) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(16616) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(16619) + p.Pivot_for_clause() + } + { + p.SetState(16620) + p.Unpivot_in_clause() + } + { + p.SetState(16621) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_clauseContext is an interface to support dynamic dispatch. +type IUnpivot_in_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllUnpivot_in_elements() []IUnpivot_in_elementsContext + Unpivot_in_elements(i int) IUnpivot_in_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnpivot_in_clauseContext differentiates from other interfaces. + IsUnpivot_in_clauseContext() +} + +type Unpivot_in_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_clauseContext() *Unpivot_in_clauseContext { + var p = new(Unpivot_in_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause + return p +} + +func InitEmptyUnpivot_in_clauseContext(p *Unpivot_in_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause +} + +func (*Unpivot_in_clauseContext) IsUnpivot_in_clauseContext() {} + +func NewUnpivot_in_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_clauseContext { + var p = new(Unpivot_in_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_in_clause + + return p +} + +func (s *Unpivot_in_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_clauseContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Unpivot_in_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_in_clauseContext) AllUnpivot_in_elements() []IUnpivot_in_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUnpivot_in_elementsContext); ok { + len++ + } + } + + tst := make([]IUnpivot_in_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUnpivot_in_elementsContext); ok { + tst[i] = t.(IUnpivot_in_elementsContext) + i++ + } + } + + return tst +} + +func (s *Unpivot_in_clauseContext) Unpivot_in_elements(i int) IUnpivot_in_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnpivot_in_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUnpivot_in_elementsContext) +} + +func (s *Unpivot_in_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_in_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unpivot_in_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unpivot_in_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_in_clause(s) + } +} + +func (s *Unpivot_in_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_in_clause(s) + } +} + +func (s *Unpivot_in_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnpivot_in_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unpivot_in_clause() (localctx IUnpivot_in_clauseContext) { + localctx = NewUnpivot_in_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1942, PlSqlParserRULE_unpivot_in_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16623) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16624) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16625) + p.Unpivot_in_elements() + } + p.SetState(16630) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16626) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16627) + p.Unpivot_in_elements() + } + + p.SetState(16632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16633) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnpivot_in_elementsContext is an interface to support dynamic dispatch. +type IUnpivot_in_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + Paren_column_list() IParen_column_listContext + AS() antlr.TerminalNode + AllConstant() []IConstantContext + Constant(i int) IConstantContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUnpivot_in_elementsContext differentiates from other interfaces. + IsUnpivot_in_elementsContext() +} + +type Unpivot_in_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnpivot_in_elementsContext() *Unpivot_in_elementsContext { + var p = new(Unpivot_in_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements + return p +} + +func InitEmptyUnpivot_in_elementsContext(p *Unpivot_in_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements +} + +func (*Unpivot_in_elementsContext) IsUnpivot_in_elementsContext() {} + +func NewUnpivot_in_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unpivot_in_elementsContext { + var p = new(Unpivot_in_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unpivot_in_elements + + return p +} + +func (s *Unpivot_in_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unpivot_in_elementsContext) 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 *Unpivot_in_elementsContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Unpivot_in_elementsContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Unpivot_in_elementsContext) AllConstant() []IConstantContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConstantContext); ok { + len++ + } + } + + tst := make([]IConstantContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConstantContext); ok { + tst[i] = t.(IConstantContext) + i++ + } + } + + return tst +} + +func (s *Unpivot_in_elementsContext) Constant(i int) IConstantContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *Unpivot_in_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Unpivot_in_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Unpivot_in_elementsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Unpivot_in_elementsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Unpivot_in_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unpivot_in_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unpivot_in_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnpivot_in_elements(s) + } +} + +func (s *Unpivot_in_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnpivot_in_elements(s) + } +} + +func (s *Unpivot_in_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnpivot_in_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unpivot_in_elements() (localctx IUnpivot_in_elementsContext) { + localctx = NewUnpivot_in_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1944, PlSqlParserRULE_unpivot_in_elements) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16637) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16635) + p.Column_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(16636) + p.Paren_column_list() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16654) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(16639) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16652) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16640) + p.Constant() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(16641) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16642) + p.Constant() + } + p.SetState(16647) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16643) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16644) + p.Constant() + } + + p.SetState(16649) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16650) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IHierarchical_query_clauseContext is an interface to support dynamic dispatch. +type IHierarchical_query_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CONNECT() antlr.TerminalNode + BY() antlr.TerminalNode + Condition() IConditionContext + NOCYCLE() antlr.TerminalNode + Start_part() IStart_partContext + + // IsHierarchical_query_clauseContext differentiates from other interfaces. + IsHierarchical_query_clauseContext() +} + +type Hierarchical_query_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyHierarchical_query_clauseContext() *Hierarchical_query_clauseContext { + var p = new(Hierarchical_query_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause + return p +} + +func InitEmptyHierarchical_query_clauseContext(p *Hierarchical_query_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause +} + +func (*Hierarchical_query_clauseContext) IsHierarchical_query_clauseContext() {} + +func NewHierarchical_query_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Hierarchical_query_clauseContext { + var p = new(Hierarchical_query_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_hierarchical_query_clause + + return p +} + +func (s *Hierarchical_query_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Hierarchical_query_clauseContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Hierarchical_query_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Hierarchical_query_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Hierarchical_query_clauseContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Hierarchical_query_clauseContext) Start_part() IStart_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStart_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStart_partContext) +} + +func (s *Hierarchical_query_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Hierarchical_query_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Hierarchical_query_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterHierarchical_query_clause(s) + } +} + +func (s *Hierarchical_query_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHierarchical_query_clause(s) + } +} + +func (s *Hierarchical_query_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHierarchical_query_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Hierarchical_query_clause() (localctx IHierarchical_query_clauseContext) { + localctx = NewHierarchical_query_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1946, PlSqlParserRULE_hierarchical_query_clause) + p.SetState(16673) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCONNECT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16656) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16657) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16659) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2255, p.GetParserRuleContext()) == 1 { + { + p.SetState(16658) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16661) + p.Condition() + } + p.SetState(16663) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2256, p.GetParserRuleContext()) == 1 { + { + p.SetState(16662) + p.Start_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSTART: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16665) + p.Start_part() + } + { + p.SetState(16666) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16667) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16669) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2257, p.GetParserRuleContext()) == 1 { + { + p.SetState(16668) + p.Match(PlSqlParserNOCYCLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16671) + p.Condition() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_partContext is an interface to support dynamic dispatch. +type IStart_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + START() antlr.TerminalNode + WITH() antlr.TerminalNode + Condition() IConditionContext + + // IsStart_partContext differentiates from other interfaces. + IsStart_partContext() +} + +type Start_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStart_partContext() *Start_partContext { + var p = new(Start_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_part + return p +} + +func InitEmptyStart_partContext(p *Start_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_start_part +} + +func (*Start_partContext) IsStart_partContext() {} + +func NewStart_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Start_partContext { + var p = new(Start_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_start_part + + return p +} + +func (s *Start_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Start_partContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Start_partContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Start_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Start_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Start_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Start_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStart_part(s) + } +} + +func (s *Start_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStart_part(s) + } +} + +func (s *Start_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStart_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Start_part() (localctx IStart_partContext) { + localctx = NewStart_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1948, PlSqlParserRULE_start_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16675) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16676) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16677) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_by_elements() []IGroup_by_elementsContext + Group_by_elements(i int) IGroup_by_elementsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Having_clause() IHaving_clauseContext + + // 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 = PlSqlParserRULE_group_by_clause + return p +} + +func InitEmptyGroup_by_clauseContext(p *Group_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_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(PlSqlParserGROUP, 0) +} + +func (s *Group_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Group_by_clauseContext) AllGroup_by_elements() []IGroup_by_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGroup_by_elementsContext); ok { + len++ + } + } + + tst := make([]IGroup_by_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGroup_by_elementsContext); ok { + tst[i] = t.(IGroup_by_elementsContext) + i++ + } + } + + return tst +} + +func (s *Group_by_clauseContext) Group_by_elements(i int) IGroup_by_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGroup_by_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGroup_by_elementsContext) +} + +func (s *Group_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Group_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 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) 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.(PlSqlParserListener); ok { + listenerT.EnterGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_by_clause(s) + } +} + +func (s *Group_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGroup_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Group_by_clause() (localctx IGroup_by_clauseContext) { + localctx = NewGroup_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1950, PlSqlParserRULE_group_by_clause) + var _alt int + + p.SetState(16705) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserGROUP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16679) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16680) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16681) + p.Group_by_elements() + } + p.SetState(16686) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2259, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16682) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16683) + p.Group_by_elements() + } + + } + p.SetState(16688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2259, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(16690) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2260, p.GetParserRuleContext()) == 1 { + { + p.SetState(16689) + p.Having_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserHAVING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16692) + p.Having_clause() + } + p.SetState(16703) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2262, p.GetParserRuleContext()) == 1 { + { + p.SetState(16693) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16694) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16695) + p.Group_by_elements() + } + p.SetState(16700) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2261, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16696) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16697) + p.Group_by_elements() + } + + } + p.SetState(16702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2261, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IGroup_by_elementsContext is an interface to support dynamic dispatch. +type IGroup_by_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Grouping_sets_clause() IGrouping_sets_clauseContext + Rollup_cube_clause() IRollup_cube_clauseContext + Expression() IExpressionContext + + // IsGroup_by_elementsContext differentiates from other interfaces. + IsGroup_by_elementsContext() +} + +type Group_by_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGroup_by_elementsContext() *Group_by_elementsContext { + var p = new(Group_by_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_elements + return p +} + +func InitEmptyGroup_by_elementsContext(p *Group_by_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_group_by_elements +} + +func (*Group_by_elementsContext) IsGroup_by_elementsContext() {} + +func NewGroup_by_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Group_by_elementsContext { + var p = new(Group_by_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_group_by_elements + + return p +} + +func (s *Group_by_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Group_by_elementsContext) Grouping_sets_clause() IGrouping_sets_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_clauseContext) +} + +func (s *Group_by_elementsContext) Rollup_cube_clause() IRollup_cube_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_cube_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_cube_clauseContext) +} + +func (s *Group_by_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Group_by_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Group_by_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Group_by_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGroup_by_elements(s) + } +} + +func (s *Group_by_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGroup_by_elements(s) + } +} + +func (s *Group_by_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGroup_by_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Group_by_elements() (localctx IGroup_by_elementsContext) { + localctx = NewGroup_by_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1952, PlSqlParserRULE_group_by_elements) + p.SetState(16710) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2264, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16707) + p.Grouping_sets_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16708) + p.Rollup_cube_clause() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16709) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollup_cube_clauseContext is an interface to support dynamic dispatch. +type IRollup_cube_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllGrouping_sets_elements() []IGrouping_sets_elementsContext + Grouping_sets_elements(i int) IGrouping_sets_elementsContext + RIGHT_PAREN() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + CUBE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsRollup_cube_clauseContext differentiates from other interfaces. + IsRollup_cube_clauseContext() +} + +type Rollup_cube_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollup_cube_clauseContext() *Rollup_cube_clauseContext { + var p = new(Rollup_cube_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause + return p +} + +func InitEmptyRollup_cube_clauseContext(p *Rollup_cube_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause +} + +func (*Rollup_cube_clauseContext) IsRollup_cube_clauseContext() {} + +func NewRollup_cube_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollup_cube_clauseContext { + var p = new(Rollup_cube_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollup_cube_clause + + return p +} + +func (s *Rollup_cube_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollup_cube_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Rollup_cube_clauseContext) AllGrouping_sets_elements() []IGrouping_sets_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + len++ + } + } + + tst := make([]IGrouping_sets_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_sets_elementsContext); ok { + tst[i] = t.(IGrouping_sets_elementsContext) + i++ + } + } + + return tst +} + +func (s *Rollup_cube_clauseContext) Grouping_sets_elements(i int) IGrouping_sets_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_elementsContext) +} + +func (s *Rollup_cube_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Rollup_cube_clauseContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLUP, 0) +} + +func (s *Rollup_cube_clauseContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *Rollup_cube_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Rollup_cube_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Rollup_cube_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollup_cube_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollup_cube_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollup_cube_clause(s) + } +} + +func (s *Rollup_cube_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollup_cube_clause(s) + } +} + +func (s *Rollup_cube_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRollup_cube_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rollup_cube_clause() (localctx IRollup_cube_clauseContext) { + localctx = NewRollup_cube_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1954, PlSqlParserRULE_rollup_cube_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16712) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCUBE || _la == PlSqlParserROLLUP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16713) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16714) + p.Grouping_sets_elements() + } + p.SetState(16719) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16715) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16716) + p.Grouping_sets_elements() + } + + p.SetState(16721) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16722) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_clauseContext is an interface to support dynamic dispatch. +type IGrouping_sets_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + GROUPING() antlr.TerminalNode + SETS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllGrouping_sets_elements() []IGrouping_sets_elementsContext + Grouping_sets_elements(i int) IGrouping_sets_elementsContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsGrouping_sets_clauseContext differentiates from other interfaces. + IsGrouping_sets_clauseContext() +} + +type Grouping_sets_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_sets_clauseContext() *Grouping_sets_clauseContext { + var p = new(Grouping_sets_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause + return p +} + +func InitEmptyGrouping_sets_clauseContext(p *Grouping_sets_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause +} + +func (*Grouping_sets_clauseContext) IsGrouping_sets_clauseContext() {} + +func NewGrouping_sets_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_clauseContext { + var p = new(Grouping_sets_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grouping_sets_clause + + return p +} + +func (s *Grouping_sets_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_sets_clauseContext) GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING, 0) +} + +func (s *Grouping_sets_clauseContext) SETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETS, 0) +} + +func (s *Grouping_sets_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) AllGrouping_sets_elements() []IGrouping_sets_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + len++ + } + } + + tst := make([]IGrouping_sets_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGrouping_sets_elementsContext); ok { + tst[i] = t.(IGrouping_sets_elementsContext) + i++ + } + } + + return tst +} + +func (s *Grouping_sets_clauseContext) Grouping_sets_elements(i int) IGrouping_sets_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGrouping_sets_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGrouping_sets_elementsContext) +} + +func (s *Grouping_sets_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Grouping_sets_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grouping_sets_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grouping_sets_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrouping_sets_clause(s) + } +} + +func (s *Grouping_sets_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrouping_sets_clause(s) + } +} + +func (s *Grouping_sets_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGrouping_sets_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Grouping_sets_clause() (localctx IGrouping_sets_clauseContext) { + localctx = NewGrouping_sets_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1956, PlSqlParserRULE_grouping_sets_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16724) + p.Match(PlSqlParserGROUPING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16725) + p.Match(PlSqlParserSETS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16726) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16727) + p.Grouping_sets_elements() + } + p.SetState(16732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16728) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16729) + p.Grouping_sets_elements() + } + + p.SetState(16734) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16735) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrouping_sets_elementsContext is an interface to support dynamic dispatch. +type IGrouping_sets_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Rollup_cube_clause() IRollup_cube_clauseContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + Expression() IExpressionContext + + // IsGrouping_sets_elementsContext differentiates from other interfaces. + IsGrouping_sets_elementsContext() +} + +type Grouping_sets_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrouping_sets_elementsContext() *Grouping_sets_elementsContext { + var p = new(Grouping_sets_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements + return p +} + +func InitEmptyGrouping_sets_elementsContext(p *Grouping_sets_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements +} + +func (*Grouping_sets_elementsContext) IsGrouping_sets_elementsContext() {} + +func NewGrouping_sets_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grouping_sets_elementsContext { + var p = new(Grouping_sets_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grouping_sets_elements + + return p +} + +func (s *Grouping_sets_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grouping_sets_elementsContext) Rollup_cube_clause() IRollup_cube_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRollup_cube_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRollup_cube_clauseContext) +} + +func (s *Grouping_sets_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Grouping_sets_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Grouping_sets_elementsContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Grouping_sets_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Grouping_sets_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grouping_sets_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grouping_sets_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrouping_sets_elements(s) + } +} + +func (s *Grouping_sets_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrouping_sets_elements(s) + } +} + +func (s *Grouping_sets_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGrouping_sets_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Grouping_sets_elements() (localctx IGrouping_sets_elementsContext) { + localctx = NewGrouping_sets_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1958, PlSqlParserRULE_grouping_sets_elements) + var _la int + + p.SetState(16744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2268, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16737) + p.Rollup_cube_clause() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16738) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16740) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(16739) + p.Expressions() + } + + } + { + p.SetState(16742) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16743) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + Condition() IConditionContext + + // 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 = PlSqlParserRULE_having_clause + return p +} + +func InitEmptyHaving_clauseContext(p *Having_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_having_clause + + return p +} + +func (s *Having_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Having_clauseContext) HAVING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHAVING, 0) +} + +func (s *Having_clauseContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterHaving_clause(s) + } +} + +func (s *Having_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitHaving_clause(s) + } +} + +func (s *Having_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitHaving_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Having_clause() (localctx IHaving_clauseContext) { + localctx = NewHaving_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1960, PlSqlParserRULE_having_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16746) + p.Match(PlSqlParserHAVING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16747) + p.Condition() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_clauseContext is an interface to support dynamic dispatch. +type IModel_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MODEL() antlr.TerminalNode + Main_model() IMain_modelContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + Return_rows_clause() IReturn_rows_clauseContext + AllReference_model() []IReference_modelContext + Reference_model(i int) IReference_modelContext + + // IsModel_clauseContext differentiates from other interfaces. + IsModel_clauseContext() +} + +type Model_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_clauseContext() *Model_clauseContext { + var p = new(Model_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_clause + return p +} + +func InitEmptyModel_clauseContext(p *Model_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_clause +} + +func (*Model_clauseContext) IsModel_clauseContext() {} + +func NewModel_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_clauseContext { + var p = new(Model_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_clause + + return p +} + +func (s *Model_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Model_clauseContext) Main_model() IMain_modelContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMain_modelContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMain_modelContext) +} + +func (s *Model_clauseContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Model_clauseContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Model_clauseContext) Return_rows_clause() IReturn_rows_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReturn_rows_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReturn_rows_clauseContext) +} + +func (s *Model_clauseContext) AllReference_model() []IReference_modelContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IReference_modelContext); ok { + len++ + } + } + + tst := make([]IReference_modelContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IReference_modelContext); ok { + tst[i] = t.(IReference_modelContext) + i++ + } + } + + return tst +} + +func (s *Model_clauseContext) Reference_model(i int) IReference_modelContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_modelContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IReference_modelContext) +} + +func (s *Model_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_clause(s) + } +} + +func (s *Model_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_clause(s) + } +} + +func (s *Model_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_clause() (localctx IModel_clauseContext) { + localctx = NewModel_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1962, PlSqlParserRULE_model_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16749) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16753) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(16750) + p.Cell_reference_options() + } + + p.SetState(16755) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(16757) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURN { + { + p.SetState(16756) + p.Return_rows_clause() + } + + } + p.SetState(16762) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserREFERENCE { + { + p.SetState(16759) + p.Reference_model() + } + + p.SetState(16764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16765) + p.Main_model() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICell_reference_optionsContext is an interface to support dynamic dispatch. +type ICell_reference_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NAV() antlr.TerminalNode + IGNORE() antlr.TerminalNode + KEEP() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + SINGLE() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + + // IsCell_reference_optionsContext differentiates from other interfaces. + IsCell_reference_optionsContext() +} + +type Cell_reference_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCell_reference_optionsContext() *Cell_reference_optionsContext { + var p = new(Cell_reference_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_reference_options + return p +} + +func InitEmptyCell_reference_optionsContext(p *Cell_reference_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_reference_options +} + +func (*Cell_reference_optionsContext) IsCell_reference_optionsContext() {} + +func NewCell_reference_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cell_reference_optionsContext { + var p = new(Cell_reference_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cell_reference_options + + return p +} + +func (s *Cell_reference_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cell_reference_optionsContext) NAV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAV, 0) +} + +func (s *Cell_reference_optionsContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Cell_reference_optionsContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Cell_reference_optionsContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Cell_reference_optionsContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Cell_reference_optionsContext) SINGLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, 0) +} + +func (s *Cell_reference_optionsContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Cell_reference_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cell_reference_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cell_reference_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCell_reference_options(s) + } +} + +func (s *Cell_reference_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCell_reference_options(s) + } +} + +func (s *Cell_reference_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCell_reference_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cell_reference_options() (localctx ICell_reference_optionsContext) { + localctx = NewCell_reference_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1964, PlSqlParserRULE_cell_reference_options) + var _la int + + p.SetState(16775) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIGNORE, PlSqlParserKEEP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16767) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIGNORE || _la == PlSqlParserKEEP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16768) + p.Match(PlSqlParserNAV) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNIQUE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16769) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16773) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDIMENSION: + { + p.SetState(16770) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSINGLE: + { + p.SetState(16771) + p.Match(PlSqlParserSINGLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16772) + p.Match(PlSqlParserREFERENCE) + 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 +} + +// IReturn_rows_clauseContext is an interface to support dynamic dispatch. +type IReturn_rows_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURN() antlr.TerminalNode + ROWS() antlr.TerminalNode + UPDATED() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsReturn_rows_clauseContext differentiates from other interfaces. + IsReturn_rows_clauseContext() +} + +type Return_rows_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReturn_rows_clauseContext() *Return_rows_clauseContext { + var p = new(Return_rows_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_rows_clause + return p +} + +func InitEmptyReturn_rows_clauseContext(p *Return_rows_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_return_rows_clause +} + +func (*Return_rows_clauseContext) IsReturn_rows_clauseContext() {} + +func NewReturn_rows_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Return_rows_clauseContext { + var p = new(Return_rows_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_return_rows_clause + + return p +} + +func (s *Return_rows_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Return_rows_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Return_rows_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Return_rows_clauseContext) UPDATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATED, 0) +} + +func (s *Return_rows_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Return_rows_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Return_rows_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Return_rows_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReturn_rows_clause(s) + } +} + +func (s *Return_rows_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReturn_rows_clause(s) + } +} + +func (s *Return_rows_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReturn_rows_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Return_rows_clause() (localctx IReturn_rows_clauseContext) { + localctx = NewReturn_rows_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1966, PlSqlParserRULE_return_rows_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16777) + p.Match(PlSqlParserRETURN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16778) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserUPDATED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16779) + p.Match(PlSqlParserROWS) + 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 +} + +// IReference_modelContext is an interface to support dynamic dispatch. +type IReference_modelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REFERENCE() antlr.TerminalNode + Reference_model_name() IReference_model_nameContext + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Model_column_clauses() IModel_column_clausesContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + + // IsReference_modelContext differentiates from other interfaces. + IsReference_modelContext() +} + +type Reference_modelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_modelContext() *Reference_modelContext { + var p = new(Reference_modelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model + return p +} + +func InitEmptyReference_modelContext(p *Reference_modelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model +} + +func (*Reference_modelContext) IsReference_modelContext() {} + +func NewReference_modelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_modelContext { + var p = new(Reference_modelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_model + + return p +} + +func (s *Reference_modelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_modelContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Reference_modelContext) Reference_model_name() IReference_model_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IReference_model_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IReference_model_nameContext) +} + +func (s *Reference_modelContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Reference_modelContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Reference_modelContext) 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 *Reference_modelContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Reference_modelContext) Model_column_clauses() IModel_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_clausesContext) +} + +func (s *Reference_modelContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Reference_modelContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Reference_modelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_modelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_modelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_model(s) + } +} + +func (s *Reference_modelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_model(s) + } +} + +func (s *Reference_modelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReference_model(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Reference_model() (localctx IReference_modelContext) { + localctx = NewReference_modelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1968, PlSqlParserRULE_reference_model) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16781) + p.Match(PlSqlParserREFERENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16782) + p.Reference_model_name() + } + { + p.SetState(16783) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16784) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16785) + p.Subquery() + } + { + p.SetState(16786) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16787) + p.Model_column_clauses() + } + p.SetState(16791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(16788) + p.Cell_reference_options() + } + + p.SetState(16793) + 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 +} + +// IMain_modelContext is an interface to support dynamic dispatch. +type IMain_modelContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Model_column_clauses() IModel_column_clausesContext + Model_rules_clause() IModel_rules_clauseContext + MAIN() antlr.TerminalNode + Main_model_name() IMain_model_nameContext + AllCell_reference_options() []ICell_reference_optionsContext + Cell_reference_options(i int) ICell_reference_optionsContext + + // IsMain_modelContext differentiates from other interfaces. + IsMain_modelContext() +} + +type Main_modelContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMain_modelContext() *Main_modelContext { + var p = new(Main_modelContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model + return p +} + +func InitEmptyMain_modelContext(p *Main_modelContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model +} + +func (*Main_modelContext) IsMain_modelContext() {} + +func NewMain_modelContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Main_modelContext { + var p = new(Main_modelContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_main_model + + return p +} + +func (s *Main_modelContext) GetParser() antlr.Parser { return s.parser } + +func (s *Main_modelContext) Model_column_clauses() IModel_column_clausesContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_clausesContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_clausesContext) +} + +func (s *Main_modelContext) Model_rules_clause() IModel_rules_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_clauseContext) +} + +func (s *Main_modelContext) MAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAIN, 0) +} + +func (s *Main_modelContext) Main_model_name() IMain_model_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMain_model_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMain_model_nameContext) +} + +func (s *Main_modelContext) AllCell_reference_options() []ICell_reference_optionsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + len++ + } + } + + tst := make([]ICell_reference_optionsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICell_reference_optionsContext); ok { + tst[i] = t.(ICell_reference_optionsContext) + i++ + } + } + + return tst +} + +func (s *Main_modelContext) Cell_reference_options(i int) ICell_reference_optionsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_reference_optionsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICell_reference_optionsContext) +} + +func (s *Main_modelContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Main_modelContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Main_modelContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMain_model(s) + } +} + +func (s *Main_modelContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMain_model(s) + } +} + +func (s *Main_modelContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMain_model(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Main_model() (localctx IMain_modelContext) { + localctx = NewMain_modelContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1970, PlSqlParserRULE_main_model) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16796) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserMAIN { + { + p.SetState(16794) + p.Match(PlSqlParserMAIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16795) + p.Main_model_name() + } + + } + { + p.SetState(16798) + p.Model_column_clauses() + } + p.SetState(16802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserIGNORE || _la == PlSqlParserKEEP || _la == PlSqlParserUNIQUE { + { + p.SetState(16799) + p.Cell_reference_options() + } + + p.SetState(16804) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16805) + p.Model_rules_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 +} + +// IModel_column_clausesContext is an interface to support dynamic dispatch. +type IModel_column_clausesContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DIMENSION() antlr.TerminalNode + BY() antlr.TerminalNode + AllModel_column_list() []IModel_column_listContext + Model_column_list(i int) IModel_column_listContext + MEASURES() antlr.TerminalNode + Model_column_partition_part() IModel_column_partition_partContext + + // IsModel_column_clausesContext differentiates from other interfaces. + IsModel_column_clausesContext() +} + +type Model_column_clausesContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_clausesContext() *Model_column_clausesContext { + var p = new(Model_column_clausesContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_clauses + return p +} + +func InitEmptyModel_column_clausesContext(p *Model_column_clausesContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_clauses +} + +func (*Model_column_clausesContext) IsModel_column_clausesContext() {} + +func NewModel_column_clausesContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_clausesContext { + var p = new(Model_column_clausesContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_clauses + + return p +} + +func (s *Model_column_clausesContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_clausesContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Model_column_clausesContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Model_column_clausesContext) AllModel_column_list() []IModel_column_listContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_column_listContext); ok { + len++ + } + } + + tst := make([]IModel_column_listContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_column_listContext); ok { + tst[i] = t.(IModel_column_listContext) + i++ + } + } + + return tst +} + +func (s *Model_column_clausesContext) Model_column_list(i int) IModel_column_listContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_listContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_listContext) +} + +func (s *Model_column_clausesContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Model_column_clausesContext) Model_column_partition_part() IModel_column_partition_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_partition_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_partition_partContext) +} + +func (s *Model_column_clausesContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_clausesContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_clausesContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_clauses(s) + } +} + +func (s *Model_column_clausesContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_clauses(s) + } +} + +func (s *Model_column_clausesContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_column_clauses(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_column_clauses() (localctx IModel_column_clausesContext) { + localctx = NewModel_column_clausesContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1972, PlSqlParserRULE_model_column_clauses) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16808) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(16807) + p.Model_column_partition_part() + } + + } + { + p.SetState(16810) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16811) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16812) + p.Model_column_list() + } + { + p.SetState(16813) + p.Match(PlSqlParserMEASURES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16814) + p.Model_column_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 +} + +// IModel_column_partition_partContext is an interface to support dynamic dispatch. +type IModel_column_partition_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PARTITION() antlr.TerminalNode + BY() antlr.TerminalNode + Model_column_list() IModel_column_listContext + + // IsModel_column_partition_partContext differentiates from other interfaces. + IsModel_column_partition_partContext() +} + +type Model_column_partition_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_partition_partContext() *Model_column_partition_partContext { + var p = new(Model_column_partition_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_partition_part + return p +} + +func InitEmptyModel_column_partition_partContext(p *Model_column_partition_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_partition_part +} + +func (*Model_column_partition_partContext) IsModel_column_partition_partContext() {} + +func NewModel_column_partition_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_partition_partContext { + var p = new(Model_column_partition_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_partition_part + + return p +} + +func (s *Model_column_partition_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_partition_partContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Model_column_partition_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Model_column_partition_partContext) Model_column_list() IModel_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_column_listContext) +} + +func (s *Model_column_partition_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_partition_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_partition_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_partition_part(s) + } +} + +func (s *Model_column_partition_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_partition_part(s) + } +} + +func (s *Model_column_partition_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_column_partition_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_column_partition_part() (localctx IModel_column_partition_partContext) { + localctx = NewModel_column_partition_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1974, PlSqlParserRULE_model_column_partition_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16816) + p.Match(PlSqlParserPARTITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16817) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16818) + p.Model_column_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 +} + +// IModel_column_listContext is an interface to support dynamic dispatch. +type IModel_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + AllModel_column() []IModel_columnContext + Model_column(i int) IModel_columnContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModel_column_listContext differentiates from other interfaces. + IsModel_column_listContext() +} + +type Model_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_column_listContext() *Model_column_listContext { + var p = new(Model_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_list + return p +} + +func InitEmptyModel_column_listContext(p *Model_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column_list +} + +func (*Model_column_listContext) IsModel_column_listContext() {} + +func NewModel_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_column_listContext { + var p = new(Model_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column_list + + return p +} + +func (s *Model_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_column_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_column_listContext) AllModel_column() []IModel_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_columnContext); ok { + len++ + } + } + + tst := make([]IModel_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_columnContext); ok { + tst[i] = t.(IModel_columnContext) + i++ + } + } + + return tst +} + +func (s *Model_column_listContext) Model_column(i int) IModel_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_columnContext) +} + +func (s *Model_column_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_column_listContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column_list(s) + } +} + +func (s *Model_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column_list(s) + } +} + +func (s *Model_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_column_list() (localctx IModel_column_listContext) { + localctx = NewModel_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1976, PlSqlParserRULE_model_column_list) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16820) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16821) + p.Model_column() + } + p.SetState(16826) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16822) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16823) + p.Model_column() + } + + p.SetState(16828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(16829) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_columnContext is an interface to support dynamic dispatch. +type IModel_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Query_block() IQuery_blockContext + Column_alias() IColumn_aliasContext + + // IsModel_columnContext differentiates from other interfaces. + IsModel_columnContext() +} + +type Model_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_columnContext() *Model_columnContext { + var p = new(Model_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column + return p +} + +func InitEmptyModel_columnContext(p *Model_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_column +} + +func (*Model_columnContext) IsModel_columnContext() {} + +func NewModel_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_columnContext { + var p = new(Model_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_column + + return p +} + +func (s *Model_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_columnContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_columnContext) Query_block() IQuery_blockContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_blockContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_blockContext) +} + +func (s *Model_columnContext) Column_alias() IColumn_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Model_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_column(s) + } +} + +func (s *Model_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_column(s) + } +} + +func (s *Model_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_column() (localctx IModel_columnContext) { + localctx = NewModel_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1978, PlSqlParserRULE_model_column) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNOT, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(16831) + p.Expression() + } + + case PlSqlParserSELECT, PlSqlParserWITH: + { + p.SetState(16832) + p.Query_block() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(16836) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(16835) + p.Column_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 +} + +// IModel_rules_clauseContext is an interface to support dynamic dispatch. +type IModel_rules_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Model_rules_part() IModel_rules_partContext + AllModel_rules_element() []IModel_rules_elementContext + Model_rules_element(i int) IModel_rules_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsModel_rules_clauseContext differentiates from other interfaces. + IsModel_rules_clauseContext() +} + +type Model_rules_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_clauseContext() *Model_rules_clauseContext { + var p = new(Model_rules_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_clause + return p +} + +func InitEmptyModel_rules_clauseContext(p *Model_rules_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_clause +} + +func (*Model_rules_clauseContext) IsModel_rules_clauseContext() {} + +func NewModel_rules_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_clauseContext { + var p = new(Model_rules_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_clause + + return p +} + +func (s *Model_rules_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_rules_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_rules_clauseContext) Model_rules_part() IModel_rules_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_partContext) +} + +func (s *Model_rules_clauseContext) AllModel_rules_element() []IModel_rules_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IModel_rules_elementContext); ok { + len++ + } + } + + tst := make([]IModel_rules_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IModel_rules_elementContext); ok { + tst[i] = t.(IModel_rules_elementContext) + i++ + } + } + + return tst +} + +func (s *Model_rules_clauseContext) Model_rules_element(i int) IModel_rules_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_rules_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IModel_rules_elementContext) +} + +func (s *Model_rules_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_rules_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_rules_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_clause(s) + } +} + +func (s *Model_rules_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_clause(s) + } +} + +func (s *Model_rules_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_rules_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_rules_clause() (localctx IModel_rules_clauseContext) { + localctx = NewModel_rules_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1980, PlSqlParserRULE_model_rules_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16839) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRULES { + { + p.SetState(16838) + p.Model_rules_part() + } + + } + { + p.SetState(16841) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16850) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281483566645249) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-1572865) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(16842) + p.Model_rules_element() + } + p.SetState(16847) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(16843) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16844) + p.Model_rules_element() + } + + p.SetState(16849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(16852) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_rules_partContext is an interface to support dynamic dispatch. +type IModel_rules_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RULES() antlr.TerminalNode + UPDATE() antlr.TerminalNode + UPSERT() antlr.TerminalNode + ORDER() antlr.TerminalNode + Model_iterate_clause() IModel_iterate_clauseContext + AUTOMATIC() antlr.TerminalNode + SEQUENTIAL() antlr.TerminalNode + ALL() antlr.TerminalNode + + // IsModel_rules_partContext differentiates from other interfaces. + IsModel_rules_partContext() +} + +type Model_rules_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_partContext() *Model_rules_partContext { + var p = new(Model_rules_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_part + return p +} + +func InitEmptyModel_rules_partContext(p *Model_rules_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_part +} + +func (*Model_rules_partContext) IsModel_rules_partContext() {} + +func NewModel_rules_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_partContext { + var p = new(Model_rules_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_part + + return p +} + +func (s *Model_rules_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_partContext) RULES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULES, 0) +} + +func (s *Model_rules_partContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Model_rules_partContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Model_rules_partContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Model_rules_partContext) Model_iterate_clause() IModel_iterate_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_iterate_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_iterate_clauseContext) +} + +func (s *Model_rules_partContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *Model_rules_partContext) SEQUENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENTIAL, 0) +} + +func (s *Model_rules_partContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Model_rules_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_part(s) + } +} + +func (s *Model_rules_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_part(s) + } +} + +func (s *Model_rules_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_rules_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_rules_part() (localctx IModel_rules_partContext) { + localctx = NewModel_rules_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1982, PlSqlParserRULE_model_rules_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16854) + p.Match(PlSqlParserRULES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16860) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserUPDATE: + { + p.SetState(16855) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUPSERT: + { + p.SetState(16856) + p.Match(PlSqlParserUPSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16858) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL { + { + p.SetState(16857) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserAUTOMATIC, PlSqlParserITERATE, PlSqlParserSEQUENTIAL, PlSqlParserLEFT_PAREN: + + default: + } + p.SetState(16864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTOMATIC || _la == PlSqlParserSEQUENTIAL { + { + p.SetState(16862) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserAUTOMATIC || _la == PlSqlParserSEQUENTIAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(16863) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(16867) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserITERATE { + { + p.SetState(16866) + p.Model_iterate_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 +} + +// IModel_rules_elementContext is an interface to support dynamic dispatch. +type IModel_rules_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Cell_assignment() ICell_assignmentContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + UPDATE() antlr.TerminalNode + UPSERT() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + ALL() antlr.TerminalNode + + // IsModel_rules_elementContext differentiates from other interfaces. + IsModel_rules_elementContext() +} + +type Model_rules_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_rules_elementContext() *Model_rules_elementContext { + var p = new(Model_rules_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_element + return p +} + +func InitEmptyModel_rules_elementContext(p *Model_rules_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_rules_element +} + +func (*Model_rules_elementContext) IsModel_rules_elementContext() {} + +func NewModel_rules_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_rules_elementContext { + var p = new(Model_rules_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_rules_element + + return p +} + +func (s *Model_rules_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_rules_elementContext) Cell_assignment() ICell_assignmentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICell_assignmentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICell_assignmentContext) +} + +func (s *Model_rules_elementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Model_rules_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_rules_elementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Model_rules_elementContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Model_rules_elementContext) 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 *Model_rules_elementContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Model_rules_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_rules_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_rules_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_rules_element(s) + } +} + +func (s *Model_rules_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_rules_element(s) + } +} + +func (s *Model_rules_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_rules_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_rules_element() (localctx IModel_rules_elementContext) { + localctx = NewModel_rules_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1984, PlSqlParserRULE_model_rules_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(16874) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2289, p.GetParserRuleContext()) == 1 { + { + p.SetState(16869) + p.Match(PlSqlParserUPDATE) + 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(), 2289, p.GetParserRuleContext()) == 2 { + { + p.SetState(16870) + p.Match(PlSqlParserUPSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16872) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2288, p.GetParserRuleContext()) == 1 { + { + p.SetState(16871) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16876) + p.Cell_assignment() + } + p.SetState(16878) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(16877) + p.Order_by_clause() + } + + } + { + p.SetState(16880) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16881) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICell_assignmentContext is an interface to support dynamic dispatch. +type ICell_assignmentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Model_expression() IModel_expressionContext + + // IsCell_assignmentContext differentiates from other interfaces. + IsCell_assignmentContext() +} + +type Cell_assignmentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCell_assignmentContext() *Cell_assignmentContext { + var p = new(Cell_assignmentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_assignment + return p +} + +func InitEmptyCell_assignmentContext(p *Cell_assignmentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cell_assignment +} + +func (*Cell_assignmentContext) IsCell_assignmentContext() {} + +func NewCell_assignmentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cell_assignmentContext { + var p = new(Cell_assignmentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cell_assignment + + return p +} + +func (s *Cell_assignmentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cell_assignmentContext) Model_expression() IModel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expressionContext) +} + +func (s *Cell_assignmentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cell_assignmentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cell_assignmentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCell_assignment(s) + } +} + +func (s *Cell_assignmentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCell_assignment(s) + } +} + +func (s *Cell_assignmentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCell_assignment(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cell_assignment() (localctx ICell_assignmentContext) { + localctx = NewCell_assignmentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1986, PlSqlParserRULE_cell_assignment) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16883) + p.Model_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_iterate_clauseContext is an interface to support dynamic dispatch. +type IModel_iterate_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ITERATE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + Until_part() IUntil_partContext + + // IsModel_iterate_clauseContext differentiates from other interfaces. + IsModel_iterate_clauseContext() +} + +type Model_iterate_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_iterate_clauseContext() *Model_iterate_clauseContext { + var p = new(Model_iterate_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_iterate_clause + return p +} + +func InitEmptyModel_iterate_clauseContext(p *Model_iterate_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_iterate_clause +} + +func (*Model_iterate_clauseContext) IsModel_iterate_clauseContext() {} + +func NewModel_iterate_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_iterate_clauseContext { + var p = new(Model_iterate_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_iterate_clause + + return p +} + +func (s *Model_iterate_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_iterate_clauseContext) ITERATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATE, 0) +} + +func (s *Model_iterate_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Model_iterate_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_iterate_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Model_iterate_clauseContext) Until_part() IUntil_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUntil_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUntil_partContext) +} + +func (s *Model_iterate_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_iterate_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_iterate_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_iterate_clause(s) + } +} + +func (s *Model_iterate_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_iterate_clause(s) + } +} + +func (s *Model_iterate_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_iterate_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_iterate_clause() (localctx IModel_iterate_clauseContext) { + localctx = NewModel_iterate_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1988, PlSqlParserRULE_model_iterate_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16885) + p.Match(PlSqlParserITERATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16886) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16887) + p.Expression() + } + { + p.SetState(16888) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUNTIL { + { + p.SetState(16889) + p.Until_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUntil_partContext is an interface to support dynamic dispatch. +type IUntil_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNTIL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsUntil_partContext differentiates from other interfaces. + IsUntil_partContext() +} + +type Until_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUntil_partContext() *Until_partContext { + var p = new(Until_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_until_part + return p +} + +func InitEmptyUntil_partContext(p *Until_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_until_part +} + +func (*Until_partContext) IsUntil_partContext() {} + +func NewUntil_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Until_partContext { + var p = new(Until_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_until_part + + return p +} + +func (s *Until_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Until_partContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Until_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Until_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Until_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Until_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Until_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Until_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUntil_part(s) + } +} + +func (s *Until_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUntil_part(s) + } +} + +func (s *Until_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUntil_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Until_part() (localctx IUntil_partContext) { + localctx = NewUntil_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1990, PlSqlParserRULE_until_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16892) + p.Match(PlSqlParserUNTIL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16893) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16894) + p.Condition() + } + { + p.SetState(16895) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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_by_elements() []IOrder_by_elementsContext + Order_by_elements(i int) IOrder_by_elementsContext + SIBLINGS() antlr.TerminalNode + 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 = PlSqlParserRULE_order_by_clause + return p +} + +func InitEmptyOrder_by_clauseContext(p *Order_by_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_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(PlSqlParserORDER, 0) +} + +func (s *Order_by_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Order_by_clauseContext) AllOrder_by_elements() []IOrder_by_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IOrder_by_elementsContext); ok { + len++ + } + } + + tst := make([]IOrder_by_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IOrder_by_elementsContext); ok { + tst[i] = t.(IOrder_by_elementsContext) + i++ + } + } + + return tst +} + +func (s *Order_by_clauseContext) Order_by_elements(i int) IOrder_by_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOrder_by_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IOrder_by_elementsContext) +} + +func (s *Order_by_clauseContext) SIBLINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIBLINGS, 0) +} + +func (s *Order_by_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Order_by_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 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.(PlSqlParserListener); ok { + listenerT.EnterOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOrder_by_clause(s) + } +} + +func (s *Order_by_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOrder_by_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Order_by_clause() (localctx IOrder_by_clauseContext) { + localctx = NewOrder_by_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1992, PlSqlParserRULE_order_by_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16897) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIBLINGS { + { + p.SetState(16898) + p.Match(PlSqlParserSIBLINGS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(16901) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16902) + p.Order_by_elements() + } + p.SetState(16907) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2293, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16903) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16904) + p.Order_by_elements() + } + + } + p.SetState(16909) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2293, 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 +} + +// IOrder_by_elementsContext is an interface to support dynamic dispatch. +type IOrder_by_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + NULLS() antlr.TerminalNode + ASC() antlr.TerminalNode + DESC() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + + // IsOrder_by_elementsContext differentiates from other interfaces. + IsOrder_by_elementsContext() +} + +type Order_by_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOrder_by_elementsContext() *Order_by_elementsContext { + var p = new(Order_by_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_elements + return p +} + +func InitEmptyOrder_by_elementsContext(p *Order_by_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_order_by_elements +} + +func (*Order_by_elementsContext) IsOrder_by_elementsContext() {} + +func NewOrder_by_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Order_by_elementsContext { + var p = new(Order_by_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_order_by_elements + + return p +} + +func (s *Order_by_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Order_by_elementsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Order_by_elementsContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Order_by_elementsContext) ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASC, 0) +} + +func (s *Order_by_elementsContext) DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESC, 0) +} + +func (s *Order_by_elementsContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Order_by_elementsContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Order_by_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Order_by_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Order_by_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOrder_by_elements(s) + } +} + +func (s *Order_by_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOrder_by_elements(s) + } +} + +func (s *Order_by_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOrder_by_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Order_by_elements() (localctx IOrder_by_elementsContext) { + localctx = NewOrder_by_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1994, PlSqlParserRULE_order_by_elements) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16910) + p.Expression() + } + p.SetState(16912) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2294, p.GetParserRuleContext()) == 1 { + { + p.SetState(16911) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASC || _la == PlSqlParserDESC) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16916) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2295, p.GetParserRuleContext()) == 1 { + { + p.SetState(16914) + p.Match(PlSqlParserNULLS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16915) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + 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 +} + +// IOffset_clauseContext is an interface to support dynamic dispatch. +type IOffset_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OFFSET() antlr.TerminalNode + Expression() IExpressionContext + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + + // IsOffset_clauseContext differentiates from other interfaces. + IsOffset_clauseContext() +} + +type Offset_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOffset_clauseContext() *Offset_clauseContext { + var p = new(Offset_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_offset_clause + return p +} + +func InitEmptyOffset_clauseContext(p *Offset_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_offset_clause +} + +func (*Offset_clauseContext) IsOffset_clauseContext() {} + +func NewOffset_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Offset_clauseContext { + var p = new(Offset_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_offset_clause + + return p +} + +func (s *Offset_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Offset_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Offset_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Offset_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Offset_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Offset_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Offset_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Offset_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOffset_clause(s) + } +} + +func (s *Offset_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOffset_clause(s) + } +} + +func (s *Offset_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOffset_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Offset_clause() (localctx IOffset_clauseContext) { + localctx = NewOffset_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1996, PlSqlParserRULE_offset_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16918) + p.Match(PlSqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16919) + p.Expression() + } + { + p.SetState(16920) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserROW || _la == PlSqlParserROWS) { + 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 +} + +// IFetch_clauseContext is an interface to support dynamic dispatch. +type IFetch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FETCH() antlr.TerminalNode + FIRST() antlr.TerminalNode + NEXT() antlr.TerminalNode + ROW() antlr.TerminalNode + ROWS() antlr.TerminalNode + ONLY() antlr.TerminalNode + WITH() antlr.TerminalNode + TIES() antlr.TerminalNode + Expression() IExpressionContext + PERCENT_KEYWORD() antlr.TerminalNode + + // IsFetch_clauseContext differentiates from other interfaces. + IsFetch_clauseContext() +} + +type Fetch_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFetch_clauseContext() *Fetch_clauseContext { + var p = new(Fetch_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_clause + return p +} + +func InitEmptyFetch_clauseContext(p *Fetch_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_fetch_clause +} + +func (*Fetch_clauseContext) IsFetch_clauseContext() {} + +func NewFetch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Fetch_clauseContext { + var p = new(Fetch_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_fetch_clause + + return p +} + +func (s *Fetch_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Fetch_clauseContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Fetch_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Fetch_clauseContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Fetch_clauseContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Fetch_clauseContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Fetch_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Fetch_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Fetch_clauseContext) TIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIES, 0) +} + +func (s *Fetch_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Fetch_clauseContext) PERCENT_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_KEYWORD, 0) +} + +func (s *Fetch_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Fetch_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Fetch_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFetch_clause(s) + } +} + +func (s *Fetch_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFetch_clause(s) + } +} + +func (s *Fetch_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFetch_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Fetch_clause() (localctx IFetch_clauseContext) { + localctx = NewFetch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 1998, PlSqlParserRULE_fetch_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16922) + p.Match(PlSqlParserFETCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16923) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserNEXT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16928) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2297, p.GetParserRuleContext()) == 1 { + { + p.SetState(16924) + p.Expression() + } + p.SetState(16926) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERCENT_KEYWORD { + { + p.SetState(16925) + p.Match(PlSqlParserPERCENT_KEYWORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(16930) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserROW || _la == PlSqlParserROWS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(16934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserONLY: + { + p.SetState(16931) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWITH: + { + p.SetState(16932) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16933) + p.Match(PlSqlParserTIES) + 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 +} + +// IFor_update_clauseContext is an interface to support dynamic dispatch. +type IFor_update_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + UPDATE() antlr.TerminalNode + For_update_of_part() IFor_update_of_partContext + For_update_options() IFor_update_optionsContext + + // IsFor_update_clauseContext differentiates from other interfaces. + IsFor_update_clauseContext() +} + +type For_update_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_clauseContext() *For_update_clauseContext { + var p = new(For_update_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_clause + return p +} + +func InitEmptyFor_update_clauseContext(p *For_update_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_clause +} + +func (*For_update_clauseContext) IsFor_update_clauseContext() {} + +func NewFor_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_clauseContext { + var p = new(For_update_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_clause + + return p +} + +func (s *For_update_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *For_update_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *For_update_clauseContext) For_update_of_part() IFor_update_of_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_of_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_of_partContext) +} + +func (s *For_update_clauseContext) For_update_options() IFor_update_optionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFor_update_optionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFor_update_optionsContext) +} + +func (s *For_update_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_clause(s) + } +} + +func (s *For_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_clause(s) + } +} + +func (s *For_update_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFor_update_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) For_update_clause() (localctx IFor_update_clauseContext) { + localctx = NewFor_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2000, PlSqlParserRULE_for_update_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16936) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16937) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16939) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2299, p.GetParserRuleContext()) == 1 { + { + p.SetState(16938) + p.For_update_of_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16942) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2300, p.GetParserRuleContext()) == 1 { + { + p.SetState(16941) + p.For_update_options() + } + + } 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 +} + +// IFor_update_of_partContext is an interface to support dynamic dispatch. +type IFor_update_of_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + OF() antlr.TerminalNode + Column_list() IColumn_listContext + + // IsFor_update_of_partContext differentiates from other interfaces. + IsFor_update_of_partContext() +} + +type For_update_of_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_of_partContext() *For_update_of_partContext { + var p = new(For_update_of_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_of_part + return p +} + +func InitEmptyFor_update_of_partContext(p *For_update_of_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_of_part +} + +func (*For_update_of_partContext) IsFor_update_of_partContext() {} + +func NewFor_update_of_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_of_partContext { + var p = new(For_update_of_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_of_part + + return p +} + +func (s *For_update_of_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_of_partContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *For_update_of_partContext) 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 *For_update_of_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_of_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_of_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_of_part(s) + } +} + +func (s *For_update_of_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_of_part(s) + } +} + +func (s *For_update_of_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFor_update_of_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) For_update_of_part() (localctx IFor_update_of_partContext) { + localctx = NewFor_update_of_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2002, PlSqlParserRULE_for_update_of_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16944) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16945) + p.Column_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 +} + +// IFor_update_optionsContext is an interface to support dynamic dispatch. +type IFor_update_optionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SKIP_() antlr.TerminalNode + LOCKED() antlr.TerminalNode + NOWAIT() antlr.TerminalNode + WAIT() antlr.TerminalNode + Expression() IExpressionContext + + // IsFor_update_optionsContext differentiates from other interfaces. + IsFor_update_optionsContext() +} + +type For_update_optionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFor_update_optionsContext() *For_update_optionsContext { + var p = new(For_update_optionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_options + return p +} + +func InitEmptyFor_update_optionsContext(p *For_update_optionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_for_update_options +} + +func (*For_update_optionsContext) IsFor_update_optionsContext() {} + +func NewFor_update_optionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *For_update_optionsContext { + var p = new(For_update_optionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_for_update_options + + return p +} + +func (s *For_update_optionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *For_update_optionsContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *For_update_optionsContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *For_update_optionsContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *For_update_optionsContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *For_update_optionsContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *For_update_optionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *For_update_optionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *For_update_optionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFor_update_options(s) + } +} + +func (s *For_update_optionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFor_update_options(s) + } +} + +func (s *For_update_optionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFor_update_options(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) For_update_options() (localctx IFor_update_optionsContext) { + localctx = NewFor_update_optionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2004, PlSqlParserRULE_for_update_options) + p.SetState(16952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSKIP_: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16947) + p.Match(PlSqlParserSKIP_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16948) + p.Match(PlSqlParserLOCKED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNOWAIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16949) + p.Match(PlSqlParserNOWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWAIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16950) + p.Match(PlSqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16951) + p.Expression() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + General_table_ref() IGeneral_table_refContext + Update_set_clause() IUpdate_set_clauseContext + Where_clause() IWhere_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // 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 = PlSqlParserRULE_update_statement + return p +} + +func InitEmptyUpdate_statementContext(p *Update_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_update_statement + + return p +} + +func (s *Update_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_statementContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Update_statementContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Update_statementContext) Update_set_clause() IUpdate_set_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUpdate_set_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUpdate_set_clauseContext) +} + +func (s *Update_statementContext) 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 *Update_statementContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Update_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterUpdate_statement(s) + } +} + +func (s *Update_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_statement(s) + } +} + +func (s *Update_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_statement() (localctx IUpdate_statementContext) { + localctx = NewUpdate_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2006, PlSqlParserRULE_update_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16954) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16955) + p.General_table_ref() + } + { + p.SetState(16956) + p.Update_set_clause() + } + p.SetState(16958) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2302, p.GetParserRuleContext()) == 1 { + { + p.SetState(16957) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16961) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2303, p.GetParserRuleContext()) == 1 { + { + p.SetState(16960) + p.Static_returning_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(16964) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2304, p.GetParserRuleContext()) == 1 { + { + p.SetState(16963) + p.Error_logging_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 +} + +// IUpdate_set_clauseContext is an interface to support dynamic dispatch. +type IUpdate_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllColumn_based_update_set_clause() []IColumn_based_update_set_clauseContext + Column_based_update_set_clause(i int) IColumn_based_update_set_clauseContext + VALUE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Identifier() IIdentifierContext + RIGHT_PAREN() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUpdate_set_clauseContext differentiates from other interfaces. + IsUpdate_set_clauseContext() +} + +type Update_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUpdate_set_clauseContext() *Update_set_clauseContext { + var p = new(Update_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_set_clause + return p +} + +func InitEmptyUpdate_set_clauseContext(p *Update_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_update_set_clause +} + +func (*Update_set_clauseContext) IsUpdate_set_clauseContext() {} + +func NewUpdate_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Update_set_clauseContext { + var p = new(Update_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_update_set_clause + + return p +} + +func (s *Update_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Update_set_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Update_set_clauseContext) AllColumn_based_update_set_clause() []IColumn_based_update_set_clauseContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + len++ + } + } + + tst := make([]IColumn_based_update_set_clauseContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + tst[i] = t.(IColumn_based_update_set_clauseContext) + i++ + } + } + + return tst +} + +func (s *Update_set_clauseContext) Column_based_update_set_clause(i int) IColumn_based_update_set_clauseContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_based_update_set_clauseContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_based_update_set_clauseContext) +} + +func (s *Update_set_clauseContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Update_set_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Update_set_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Update_set_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Update_set_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Update_set_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Update_set_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Update_set_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Update_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Update_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Update_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUpdate_set_clause(s) + } +} + +func (s *Update_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUpdate_set_clause(s) + } +} + +func (s *Update_set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUpdate_set_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Update_set_clause() (localctx IUpdate_set_clauseContext) { + localctx = NewUpdate_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2008, PlSqlParserRULE_update_set_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16966) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(16982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2306, p.GetParserRuleContext()) { + case 1: + { + p.SetState(16967) + p.Column_based_update_set_clause() + } + p.SetState(16972) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2305, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(16968) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16969) + p.Column_based_update_set_clause() + } + + } + p.SetState(16974) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2305, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 2: + { + p.SetState(16975) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16976) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16977) + p.Identifier() + } + { + p.SetState(16978) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16979) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16980) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_based_update_set_clauseContext is an interface to support dynamic dispatch. +type IColumn_based_update_set_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + Paren_column_list() IParen_column_listContext + Subquery() ISubqueryContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsColumn_based_update_set_clauseContext differentiates from other interfaces. + IsColumn_based_update_set_clauseContext() +} + +type Column_based_update_set_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_based_update_set_clauseContext() *Column_based_update_set_clauseContext { + var p = new(Column_based_update_set_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause + return p +} + +func InitEmptyColumn_based_update_set_clauseContext(p *Column_based_update_set_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause +} + +func (*Column_based_update_set_clauseContext) IsColumn_based_update_set_clauseContext() {} + +func NewColumn_based_update_set_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_based_update_set_clauseContext { + var p = new(Column_based_update_set_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_based_update_set_clause + + return p +} + +func (s *Column_based_update_set_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_based_update_set_clauseContext) 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_based_update_set_clauseContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Column_based_update_set_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Column_based_update_set_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Column_based_update_set_clauseContext) 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 *Column_based_update_set_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Column_based_update_set_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Column_based_update_set_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_based_update_set_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_based_update_set_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_based_update_set_clause(s) + } +} + +func (s *Column_based_update_set_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_based_update_set_clause(s) + } +} + +func (s *Column_based_update_set_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_based_update_set_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_based_update_set_clause() (localctx IColumn_based_update_set_clauseContext) { + localctx = NewColumn_based_update_set_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2010, PlSqlParserRULE_column_based_update_set_clause) + p.SetState(16998) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2307, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(16984) + p.Column_name() + } + { + p.SetState(16985) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16986) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(16988) + p.Paren_column_list() + } + { + p.SetState(16989) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16990) + p.Subquery() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(16992) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16993) + p.Column_name() + } + { + p.SetState(16994) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16995) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(16996) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + General_table_ref() IGeneral_table_refContext + FROM() antlr.TerminalNode + Where_clause() IWhere_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // 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 = PlSqlParserRULE_delete_statement + return p +} + +func InitEmptyDelete_statementContext(p *Delete_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_delete_statement + + return p +} + +func (s *Delete_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Delete_statementContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Delete_statementContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Delete_statementContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Delete_statementContext) 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 *Delete_statementContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Delete_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterDelete_statement(s) + } +} + +func (s *Delete_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDelete_statement(s) + } +} + +func (s *Delete_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDelete_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Delete_statement() (localctx IDelete_statementContext) { + localctx = NewDelete_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2012, PlSqlParserRULE_delete_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17000) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFROM { + { + p.SetState(17001) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17004) + p.General_table_ref() + } + p.SetState(17006) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2309, p.GetParserRuleContext()) == 1 { + { + p.SetState(17005) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17009) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2310, p.GetParserRuleContext()) == 1 { + { + p.SetState(17008) + p.Static_returning_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17012) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2311, p.GetParserRuleContext()) == 1 { + { + p.SetState(17011) + p.Error_logging_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 +} + +// 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 + Single_table_insert() ISingle_table_insertContext + Multi_table_insert() IMulti_table_insertContext + + // 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 = PlSqlParserRULE_insert_statement + return p +} + +func InitEmptyInsert_statementContext(p *Insert_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_insert_statement + + return p +} + +func (s *Insert_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_statementContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Insert_statementContext) Single_table_insert() ISingle_table_insertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_table_insertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingle_table_insertContext) +} + +func (s *Insert_statementContext) Multi_table_insert() IMulti_table_insertContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_insertContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_insertContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterInsert_statement(s) + } +} + +func (s *Insert_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInsert_statement(s) + } +} + +func (s *Insert_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInsert_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Insert_statement() (localctx IInsert_statementContext) { + localctx = NewInsert_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2014, PlSqlParserRULE_insert_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17014) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserINTO: + { + p.SetState(17015) + p.Single_table_insert() + } + + case PlSqlParserALL, PlSqlParserFIRST, PlSqlParserWHEN: + { + p.SetState(17016) + p.Multi_table_insert() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_table_insertContext is an interface to support dynamic dispatch. +type ISingle_table_insertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_into_clause() IInsert_into_clauseContext + Values_clause() IValues_clauseContext + Select_statement() ISelect_statementContext + Error_logging_clause() IError_logging_clauseContext + Static_returning_clause() IStatic_returning_clauseContext + + // IsSingle_table_insertContext differentiates from other interfaces. + IsSingle_table_insertContext() +} + +type Single_table_insertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySingle_table_insertContext() *Single_table_insertContext { + var p = new(Single_table_insertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_table_insert + return p +} + +func InitEmptySingle_table_insertContext(p *Single_table_insertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_table_insert +} + +func (*Single_table_insertContext) IsSingle_table_insertContext() {} + +func NewSingle_table_insertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_table_insertContext { + var p = new(Single_table_insertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_single_table_insert + + return p +} + +func (s *Single_table_insertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_table_insertContext) Insert_into_clause() IInsert_into_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_into_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_into_clauseContext) +} + +func (s *Single_table_insertContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Single_table_insertContext) 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 *Single_table_insertContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Single_table_insertContext) Static_returning_clause() IStatic_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStatic_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStatic_returning_clauseContext) +} + +func (s *Single_table_insertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_table_insertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_table_insertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSingle_table_insert(s) + } +} + +func (s *Single_table_insertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSingle_table_insert(s) + } +} + +func (s *Single_table_insertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSingle_table_insert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Single_table_insert() (localctx ISingle_table_insertContext) { + localctx = NewSingle_table_insertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2016, PlSqlParserRULE_single_table_insert) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17019) + p.Insert_into_clause() + } + p.SetState(17025) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVALUES: + { + p.SetState(17020) + p.Values_clause() + } + p.SetState(17022) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2313, p.GetParserRuleContext()) == 1 { + { + p.SetState(17021) + p.Static_returning_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserSELECT, PlSqlParserWITH, PlSqlParserLEFT_PAREN: + { + p.SetState(17024) + p.Select_statement() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(17028) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2315, p.GetParserRuleContext()) == 1 { + { + p.SetState(17027) + p.Error_logging_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 +} + +// IMulti_table_insertContext is an interface to support dynamic dispatch. +type IMulti_table_insertContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_statement() ISelect_statementContext + ALL() antlr.TerminalNode + Conditional_insert_clause() IConditional_insert_clauseContext + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsMulti_table_insertContext differentiates from other interfaces. + IsMulti_table_insertContext() +} + +type Multi_table_insertContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_table_insertContext() *Multi_table_insertContext { + var p = new(Multi_table_insertContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_insert + return p +} + +func InitEmptyMulti_table_insertContext(p *Multi_table_insertContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_insert +} + +func (*Multi_table_insertContext) IsMulti_table_insertContext() {} + +func NewMulti_table_insertContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_table_insertContext { + var p = new(Multi_table_insertContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_table_insert + + return p +} + +func (s *Multi_table_insertContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_table_insertContext) 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 *Multi_table_insertContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Multi_table_insertContext) Conditional_insert_clause() IConditional_insert_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_clauseContext) +} + +func (s *Multi_table_insertContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Multi_table_insertContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Multi_table_insertContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_table_insertContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_table_insertContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_table_insert(s) + } +} + +func (s *Multi_table_insertContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_table_insert(s) + } +} + +func (s *Multi_table_insertContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMulti_table_insert(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Multi_table_insert() (localctx IMulti_table_insertContext) { + localctx = NewMulti_table_insertContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2018, PlSqlParserRULE_multi_table_insert) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2317, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17030) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17032) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17031) + p.Multi_table_element() + } + + p.SetState(17034) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + { + p.SetState(17036) + p.Conditional_insert_clause() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(17039) + 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 +} + +// IMulti_table_elementContext is an interface to support dynamic dispatch. +type IMulti_table_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Insert_into_clause() IInsert_into_clauseContext + Values_clause() IValues_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // IsMulti_table_elementContext differentiates from other interfaces. + IsMulti_table_elementContext() +} + +type Multi_table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_table_elementContext() *Multi_table_elementContext { + var p = new(Multi_table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_element + return p +} + +func InitEmptyMulti_table_elementContext(p *Multi_table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_table_element +} + +func (*Multi_table_elementContext) IsMulti_table_elementContext() {} + +func NewMulti_table_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_table_elementContext { + var p = new(Multi_table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_table_element + + return p +} + +func (s *Multi_table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_table_elementContext) Insert_into_clause() IInsert_into_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInsert_into_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInsert_into_clauseContext) +} + +func (s *Multi_table_elementContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Multi_table_elementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +func (s *Multi_table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_table_element(s) + } +} + +func (s *Multi_table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_table_element(s) + } +} + +func (s *Multi_table_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMulti_table_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Multi_table_element() (localctx IMulti_table_elementContext) { + localctx = NewMulti_table_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2020, PlSqlParserRULE_multi_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17041) + p.Insert_into_clause() + } + p.SetState(17043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUES { + { + p.SetState(17042) + p.Values_clause() + } + + } + p.SetState(17046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOG { + { + p.SetState(17045) + p.Error_logging_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 +} + +// IConditional_insert_clauseContext is an interface to support dynamic dispatch. +type IConditional_insert_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConditional_insert_when_part() []IConditional_insert_when_partContext + Conditional_insert_when_part(i int) IConditional_insert_when_partContext + Conditional_insert_else_part() IConditional_insert_else_partContext + ALL() antlr.TerminalNode + FIRST() antlr.TerminalNode + + // IsConditional_insert_clauseContext differentiates from other interfaces. + IsConditional_insert_clauseContext() +} + +type Conditional_insert_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_clauseContext() *Conditional_insert_clauseContext { + var p = new(Conditional_insert_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause + return p +} + +func InitEmptyConditional_insert_clauseContext(p *Conditional_insert_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause +} + +func (*Conditional_insert_clauseContext) IsConditional_insert_clauseContext() {} + +func NewConditional_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_clauseContext { + var p = new(Conditional_insert_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_clause + + return p +} + +func (s *Conditional_insert_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_clauseContext) AllConditional_insert_when_part() []IConditional_insert_when_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConditional_insert_when_partContext); ok { + len++ + } + } + + tst := make([]IConditional_insert_when_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConditional_insert_when_partContext); ok { + tst[i] = t.(IConditional_insert_when_partContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_clauseContext) Conditional_insert_when_part(i int) IConditional_insert_when_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_when_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_when_partContext) +} + +func (s *Conditional_insert_clauseContext) Conditional_insert_else_part() IConditional_insert_else_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditional_insert_else_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditional_insert_else_partContext) +} + +func (s *Conditional_insert_clauseContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Conditional_insert_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Conditional_insert_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_clause(s) + } +} + +func (s *Conditional_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_clause(s) + } +} + +func (s *Conditional_insert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConditional_insert_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Conditional_insert_clause() (localctx IConditional_insert_clauseContext) { + localctx = NewConditional_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2022, PlSqlParserRULE_conditional_insert_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17049) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserALL || _la == PlSqlParserFIRST { + { + p.SetState(17048) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserFIRST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(17052) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(17051) + p.Conditional_insert_when_part() + } + + p.SetState(17054) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17057) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(17056) + p.Conditional_insert_else_part() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditional_insert_when_partContext is an interface to support dynamic dispatch. +type IConditional_insert_when_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + Condition() IConditionContext + THEN() antlr.TerminalNode + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsConditional_insert_when_partContext differentiates from other interfaces. + IsConditional_insert_when_partContext() +} + +type Conditional_insert_when_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_when_partContext() *Conditional_insert_when_partContext { + var p = new(Conditional_insert_when_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part + return p +} + +func InitEmptyConditional_insert_when_partContext(p *Conditional_insert_when_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part +} + +func (*Conditional_insert_when_partContext) IsConditional_insert_when_partContext() {} + +func NewConditional_insert_when_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_when_partContext { + var p = new(Conditional_insert_when_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_when_part + + return p +} + +func (s *Conditional_insert_when_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_when_partContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Conditional_insert_when_partContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Conditional_insert_when_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Conditional_insert_when_partContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_when_partContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Conditional_insert_when_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_when_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_when_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_when_part(s) + } +} + +func (s *Conditional_insert_when_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_when_part(s) + } +} + +func (s *Conditional_insert_when_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConditional_insert_when_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Conditional_insert_when_part() (localctx IConditional_insert_when_partContext) { + localctx = NewConditional_insert_when_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2024, PlSqlParserRULE_conditional_insert_when_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17059) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17060) + p.Condition() + } + { + p.SetState(17061) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17062) + p.Multi_table_element() + } + + p.SetState(17065) + 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 +} + +// IConditional_insert_else_partContext is an interface to support dynamic dispatch. +type IConditional_insert_else_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + AllMulti_table_element() []IMulti_table_elementContext + Multi_table_element(i int) IMulti_table_elementContext + + // IsConditional_insert_else_partContext differentiates from other interfaces. + IsConditional_insert_else_partContext() +} + +type Conditional_insert_else_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditional_insert_else_partContext() *Conditional_insert_else_partContext { + var p = new(Conditional_insert_else_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part + return p +} + +func InitEmptyConditional_insert_else_partContext(p *Conditional_insert_else_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part +} + +func (*Conditional_insert_else_partContext) IsConditional_insert_else_partContext() {} + +func NewConditional_insert_else_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Conditional_insert_else_partContext { + var p = new(Conditional_insert_else_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_conditional_insert_else_part + + return p +} + +func (s *Conditional_insert_else_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Conditional_insert_else_partContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Conditional_insert_else_partContext) AllMulti_table_element() []IMulti_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMulti_table_elementContext); ok { + len++ + } + } + + tst := make([]IMulti_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMulti_table_elementContext); ok { + tst[i] = t.(IMulti_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Conditional_insert_else_partContext) Multi_table_element(i int) IMulti_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMulti_table_elementContext) +} + +func (s *Conditional_insert_else_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Conditional_insert_else_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Conditional_insert_else_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConditional_insert_else_part(s) + } +} + +func (s *Conditional_insert_else_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConditional_insert_else_part(s) + } +} + +func (s *Conditional_insert_else_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConditional_insert_else_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Conditional_insert_else_part() (localctx IConditional_insert_else_partContext) { + localctx = NewConditional_insert_else_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2026, PlSqlParserRULE_conditional_insert_else_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17067) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17069) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserINTO { + { + p.SetState(17068) + p.Multi_table_element() + } + + p.SetState(17071) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IInsert_into_clauseContext is an interface to support dynamic dispatch. +type IInsert_into_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + General_table_ref() IGeneral_table_refContext + Paren_column_list() IParen_column_listContext + + // IsInsert_into_clauseContext differentiates from other interfaces. + IsInsert_into_clauseContext() +} + +type Insert_into_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInsert_into_clauseContext() *Insert_into_clauseContext { + var p = new(Insert_into_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_into_clause + return p +} + +func InitEmptyInsert_into_clauseContext(p *Insert_into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_insert_into_clause +} + +func (*Insert_into_clauseContext) IsInsert_into_clauseContext() {} + +func NewInsert_into_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Insert_into_clauseContext { + var p = new(Insert_into_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_insert_into_clause + + return p +} + +func (s *Insert_into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Insert_into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Insert_into_clauseContext) General_table_ref() IGeneral_table_refContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_table_refContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_table_refContext) +} + +func (s *Insert_into_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Insert_into_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Insert_into_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Insert_into_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInsert_into_clause(s) + } +} + +func (s *Insert_into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInsert_into_clause(s) + } +} + +func (s *Insert_into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInsert_into_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Insert_into_clause() (localctx IInsert_into_clauseContext) { + localctx = NewInsert_into_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2028, PlSqlParserRULE_insert_into_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17073) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17074) + p.General_table_ref() + } + p.SetState(17076) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2325, p.GetParserRuleContext()) == 1 { + { + p.SetState(17075) + p.Paren_column_list() + } + + } 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 +} + +// IValues_clauseContext is an interface to support dynamic dispatch. +type IValues_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VALUES() antlr.TerminalNode + Expression() IExpressionContext + LEFT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + RIGHT_PAREN() antlr.TerminalNode + + // IsValues_clauseContext differentiates from other interfaces. + IsValues_clauseContext() +} + +type Values_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyValues_clauseContext() *Values_clauseContext { + var p = new(Values_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_values_clause + return p +} + +func InitEmptyValues_clauseContext(p *Values_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_values_clause +} + +func (*Values_clauseContext) IsValues_clauseContext() {} + +func NewValues_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Values_clauseContext { + var p = new(Values_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_values_clause + + return p +} + +func (s *Values_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Values_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Values_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Values_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Values_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Values_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Values_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Values_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Values_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterValues_clause(s) + } +} + +func (s *Values_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitValues_clause(s) + } +} + +func (s *Values_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitValues_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Values_clause() (localctx IValues_clauseContext) { + localctx = NewValues_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2030, PlSqlParserRULE_values_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17078) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17084) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2326, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17079) + p.Expression() + } + + case 2: + { + p.SetState(17080) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17081) + p.Expressions() + } + { + p.SetState(17082) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + AllSelected_tableview() []ISelected_tableviewContext + Selected_tableview(i int) ISelected_tableviewContext + USING() antlr.TerminalNode + ON() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Condition() IConditionContext + RIGHT_PAREN() antlr.TerminalNode + Merge_update_clause() IMerge_update_clauseContext + Merge_insert_clause() IMerge_insert_clauseContext + Error_logging_clause() IError_logging_clauseContext + + // 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 = PlSqlParserRULE_merge_statement + return p +} + +func InitEmptyMerge_statementContext(p *Merge_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_merge_statement + + return p +} + +func (s *Merge_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_statementContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Merge_statementContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Merge_statementContext) AllSelected_tableview() []ISelected_tableviewContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISelected_tableviewContext); ok { + len++ + } + } + + tst := make([]ISelected_tableviewContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISelected_tableviewContext); ok { + tst[i] = t.(ISelected_tableviewContext) + i++ + } + } + + return tst +} + +func (s *Merge_statementContext) Selected_tableview(i int) ISelected_tableviewContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelected_tableviewContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISelected_tableviewContext) +} + +func (s *Merge_statementContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Merge_statementContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Merge_statementContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Merge_statementContext) Condition() IConditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConditionContext) +} + +func (s *Merge_statementContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Merge_statementContext) Merge_update_clause() IMerge_update_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_update_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_update_clauseContext) +} + +func (s *Merge_statementContext) Merge_insert_clause() IMerge_insert_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_insert_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_insert_clauseContext) +} + +func (s *Merge_statementContext) Error_logging_clause() IError_logging_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterMerge_statement(s) + } +} + +func (s *Merge_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_statement(s) + } +} + +func (s *Merge_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_statement() (localctx IMerge_statementContext) { + localctx = NewMerge_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2032, PlSqlParserRULE_merge_statement) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17086) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17087) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17088) + p.Selected_tableview() + } + { + p.SetState(17089) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17090) + p.Selected_tableview() + } + { + p.SetState(17091) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17092) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17093) + p.Condition() + } + { + p.SetState(17094) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17103) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2329, p.GetParserRuleContext()) == 1 { + { + p.SetState(17095) + p.Merge_update_clause() + } + p.SetState(17097) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2327, p.GetParserRuleContext()) == 1 { + { + p.SetState(17096) + p.Merge_insert_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2329, p.GetParserRuleContext()) == 2 { + { + p.SetState(17099) + p.Merge_insert_clause() + } + p.SetState(17101) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2328, p.GetParserRuleContext()) == 1 { + { + p.SetState(17100) + p.Merge_update_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17106) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2330, p.GetParserRuleContext()) == 1 { + { + p.SetState(17105) + p.Error_logging_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 +} + +// IMerge_update_clauseContext is an interface to support dynamic dispatch. +type IMerge_update_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + UPDATE() antlr.TerminalNode + SET() antlr.TerminalNode + AllMerge_element() []IMerge_elementContext + Merge_element(i int) IMerge_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Where_clause() IWhere_clauseContext + Merge_update_delete_part() IMerge_update_delete_partContext + + // IsMerge_update_clauseContext differentiates from other interfaces. + IsMerge_update_clauseContext() +} + +type Merge_update_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_clauseContext() *Merge_update_clauseContext { + var p = new(Merge_update_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_clause + return p +} + +func InitEmptyMerge_update_clauseContext(p *Merge_update_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_clause +} + +func (*Merge_update_clauseContext) IsMerge_update_clauseContext() {} + +func NewMerge_update_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_clauseContext { + var p = new(Merge_update_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_update_clause + + return p +} + +func (s *Merge_update_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_update_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Merge_update_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Merge_update_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Merge_update_clauseContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Merge_update_clauseContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Merge_update_clauseContext) AllMerge_element() []IMerge_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IMerge_elementContext); ok { + len++ + } + } + + tst := make([]IMerge_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IMerge_elementContext); ok { + tst[i] = t.(IMerge_elementContext) + i++ + } + } + + return tst +} + +func (s *Merge_update_clauseContext) Merge_element(i int) IMerge_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IMerge_elementContext) +} + +func (s *Merge_update_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Merge_update_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Merge_update_clauseContext) 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 *Merge_update_clauseContext) Merge_update_delete_part() IMerge_update_delete_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMerge_update_delete_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMerge_update_delete_partContext) +} + +func (s *Merge_update_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_update_clause(s) + } +} + +func (s *Merge_update_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_update_clause(s) + } +} + +func (s *Merge_update_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_update_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_update_clause() (localctx IMerge_update_clauseContext) { + localctx = NewMerge_update_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2034, PlSqlParserRULE_merge_update_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17108) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17109) + p.Match(PlSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17110) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17111) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17112) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17113) + p.Merge_element() + } + p.SetState(17118) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2331, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17114) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17115) + p.Merge_element() + } + + } + p.SetState(17120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2331, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(17122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2332, p.GetParserRuleContext()) == 1 { + { + p.SetState(17121) + p.Where_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17125) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2333, p.GetParserRuleContext()) == 1 { + { + p.SetState(17124) + p.Merge_update_delete_part() + } + + } 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 +} + +// IMerge_elementContext is an interface to support dynamic dispatch. +type IMerge_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + EQUALS_OP() antlr.TerminalNode + Expression() IExpressionContext + + // IsMerge_elementContext differentiates from other interfaces. + IsMerge_elementContext() +} + +type Merge_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_elementContext() *Merge_elementContext { + var p = new(Merge_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_element + return p +} + +func InitEmptyMerge_elementContext(p *Merge_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_element +} + +func (*Merge_elementContext) IsMerge_elementContext() {} + +func NewMerge_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_elementContext { + var p = new(Merge_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_element + + return p +} + +func (s *Merge_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_elementContext) 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 *Merge_elementContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Merge_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Merge_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_element(s) + } +} + +func (s *Merge_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_element(s) + } +} + +func (s *Merge_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_element() (localctx IMerge_elementContext) { + localctx = NewMerge_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2036, PlSqlParserRULE_merge_element) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17127) + p.Column_name() + } + { + p.SetState(17128) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17129) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_update_delete_partContext is an interface to support dynamic dispatch. +type IMerge_update_delete_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DELETE() antlr.TerminalNode + Where_clause() IWhere_clauseContext + + // IsMerge_update_delete_partContext differentiates from other interfaces. + IsMerge_update_delete_partContext() +} + +type Merge_update_delete_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_update_delete_partContext() *Merge_update_delete_partContext { + var p = new(Merge_update_delete_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part + return p +} + +func InitEmptyMerge_update_delete_partContext(p *Merge_update_delete_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part +} + +func (*Merge_update_delete_partContext) IsMerge_update_delete_partContext() {} + +func NewMerge_update_delete_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_update_delete_partContext { + var p = new(Merge_update_delete_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_update_delete_part + + return p +} + +func (s *Merge_update_delete_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_update_delete_partContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Merge_update_delete_partContext) 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 *Merge_update_delete_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_update_delete_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_update_delete_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_update_delete_part(s) + } +} + +func (s *Merge_update_delete_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_update_delete_part(s) + } +} + +func (s *Merge_update_delete_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_update_delete_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_update_delete_part() (localctx IMerge_update_delete_partContext) { + localctx = NewMerge_update_delete_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2038, PlSqlParserRULE_merge_update_delete_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17131) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17132) + p.Where_clause() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMerge_insert_clauseContext is an interface to support dynamic dispatch. +type IMerge_insert_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + NOT() antlr.TerminalNode + MATCHED() antlr.TerminalNode + THEN() antlr.TerminalNode + INSERT() antlr.TerminalNode + Values_clause() IValues_clauseContext + Paren_column_list() IParen_column_listContext + Where_clause() IWhere_clauseContext + + // IsMerge_insert_clauseContext differentiates from other interfaces. + IsMerge_insert_clauseContext() +} + +type Merge_insert_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMerge_insert_clauseContext() *Merge_insert_clauseContext { + var p = new(Merge_insert_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_insert_clause + return p +} + +func InitEmptyMerge_insert_clauseContext(p *Merge_insert_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_merge_insert_clause +} + +func (*Merge_insert_clauseContext) IsMerge_insert_clauseContext() {} + +func NewMerge_insert_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Merge_insert_clauseContext { + var p = new(Merge_insert_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_merge_insert_clause + + return p +} + +func (s *Merge_insert_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Merge_insert_clauseContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Merge_insert_clauseContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Merge_insert_clauseContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Merge_insert_clauseContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Merge_insert_clauseContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Merge_insert_clauseContext) Values_clause() IValues_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IValues_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IValues_clauseContext) +} + +func (s *Merge_insert_clauseContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Merge_insert_clauseContext) 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 *Merge_insert_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Merge_insert_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Merge_insert_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMerge_insert_clause(s) + } +} + +func (s *Merge_insert_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMerge_insert_clause(s) + } +} + +func (s *Merge_insert_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMerge_insert_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Merge_insert_clause() (localctx IMerge_insert_clauseContext) { + localctx = NewMerge_insert_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2040, PlSqlParserRULE_merge_insert_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17134) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17135) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17136) + p.Match(PlSqlParserMATCHED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17137) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17138) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17139) + p.Paren_column_list() + } + + } + { + p.SetState(17142) + p.Values_clause() + } + p.SetState(17144) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2335, p.GetParserRuleContext()) == 1 { + { + p.SetState(17143) + p.Where_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 +} + +// ISelected_tableviewContext is an interface to support dynamic dispatch. +type ISelected_tableviewContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Table_alias() ITable_aliasContext + + // IsSelected_tableviewContext differentiates from other interfaces. + IsSelected_tableviewContext() +} + +type Selected_tableviewContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySelected_tableviewContext() *Selected_tableviewContext { + var p = new(Selected_tableviewContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_tableview + return p +} + +func InitEmptySelected_tableviewContext(p *Selected_tableviewContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_selected_tableview +} + +func (*Selected_tableviewContext) IsSelected_tableviewContext() {} + +func NewSelected_tableviewContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Selected_tableviewContext { + var p = new(Selected_tableviewContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_selected_tableview + + return p +} + +func (s *Selected_tableviewContext) GetParser() antlr.Parser { return s.parser } + +func (s *Selected_tableviewContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Selected_tableviewContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Selected_tableviewContext) 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 *Selected_tableviewContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Selected_tableviewContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *Selected_tableviewContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Selected_tableviewContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Selected_tableviewContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSelected_tableview(s) + } +} + +func (s *Selected_tableviewContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSelected_tableview(s) + } +} + +func (s *Selected_tableviewContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSelected_tableview(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Selected_tableview() (localctx ISelected_tableviewContext) { + localctx = NewSelected_tableviewContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2042, PlSqlParserRULE_selected_tableview) + p.EnterOuterAlt(localctx, 1) + p.SetState(17151) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(17146) + p.Tableview_name() + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(17147) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17148) + p.Select_statement() + } + { + p.SetState(17149) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(17154) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2337, p.GetParserRuleContext()) == 1 { + { + p.SetState(17153) + p.Table_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 +} + +// ILock_table_statementContext is an interface to support dynamic dispatch. +type ILock_table_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOCK() antlr.TerminalNode + TABLE() antlr.TerminalNode + AllLock_table_element() []ILock_table_elementContext + Lock_table_element(i int) ILock_table_elementContext + IN() antlr.TerminalNode + Lock_mode() ILock_modeContext + MODE() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Wait_nowait_part() IWait_nowait_partContext + + // IsLock_table_statementContext differentiates from other interfaces. + IsLock_table_statementContext() +} + +type Lock_table_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_table_statementContext() *Lock_table_statementContext { + var p = new(Lock_table_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_statement + return p +} + +func InitEmptyLock_table_statementContext(p *Lock_table_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_statement +} + +func (*Lock_table_statementContext) IsLock_table_statementContext() {} + +func NewLock_table_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_table_statementContext { + var p = new(Lock_table_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_table_statement + + return p +} + +func (s *Lock_table_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_table_statementContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *Lock_table_statementContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Lock_table_statementContext) AllLock_table_element() []ILock_table_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILock_table_elementContext); ok { + len++ + } + } + + tst := make([]ILock_table_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILock_table_elementContext); ok { + tst[i] = t.(ILock_table_elementContext) + i++ + } + } + + return tst +} + +func (s *Lock_table_statementContext) Lock_table_element(i int) ILock_table_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_table_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILock_table_elementContext) +} + +func (s *Lock_table_statementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Lock_table_statementContext) Lock_mode() ILock_modeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILock_modeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILock_modeContext) +} + +func (s *Lock_table_statementContext) MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODE, 0) +} + +func (s *Lock_table_statementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Lock_table_statementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Lock_table_statementContext) Wait_nowait_part() IWait_nowait_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWait_nowait_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWait_nowait_partContext) +} + +func (s *Lock_table_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_table_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_table_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_table_statement(s) + } +} + +func (s *Lock_table_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_table_statement(s) + } +} + +func (s *Lock_table_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLock_table_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lock_table_statement() (localctx ILock_table_statementContext) { + localctx = NewLock_table_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2044, PlSqlParserRULE_lock_table_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17156) + p.Match(PlSqlParserLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17157) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17158) + p.Lock_table_element() + } + p.SetState(17163) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17159) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17160) + p.Lock_table_element() + } + + p.SetState(17165) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17166) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17167) + p.Lock_mode() + } + { + p.SetState(17168) + p.Match(PlSqlParserMODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17170) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2339, p.GetParserRuleContext()) == 1 { + { + p.SetState(17169) + p.Wait_nowait_part() + } + + } 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 +} + +// IWait_nowait_partContext is an interface to support dynamic dispatch. +type IWait_nowait_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WAIT() antlr.TerminalNode + Expression() IExpressionContext + NOWAIT() antlr.TerminalNode + + // IsWait_nowait_partContext differentiates from other interfaces. + IsWait_nowait_partContext() +} + +type Wait_nowait_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWait_nowait_partContext() *Wait_nowait_partContext { + var p = new(Wait_nowait_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait_part + return p +} + +func InitEmptyWait_nowait_partContext(p *Wait_nowait_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_wait_nowait_part +} + +func (*Wait_nowait_partContext) IsWait_nowait_partContext() {} + +func NewWait_nowait_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Wait_nowait_partContext { + var p = new(Wait_nowait_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_wait_nowait_part + + return p +} + +func (s *Wait_nowait_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Wait_nowait_partContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Wait_nowait_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Wait_nowait_partContext) NOWAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOWAIT, 0) +} + +func (s *Wait_nowait_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Wait_nowait_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Wait_nowait_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWait_nowait_part(s) + } +} + +func (s *Wait_nowait_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWait_nowait_part(s) + } +} + +func (s *Wait_nowait_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWait_nowait_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Wait_nowait_part() (localctx IWait_nowait_partContext) { + localctx = NewWait_nowait_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2046, PlSqlParserRULE_wait_nowait_part) + p.SetState(17175) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWAIT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17172) + p.Match(PlSqlParserWAIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17173) + p.Expression() + } + + case PlSqlParserNOWAIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17174) + p.Match(PlSqlParserNOWAIT) + 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 +} + +// ILock_table_elementContext is an interface to support dynamic dispatch. +type ILock_table_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + Partition_extension_clause() IPartition_extension_clauseContext + + // IsLock_table_elementContext differentiates from other interfaces. + IsLock_table_elementContext() +} + +type Lock_table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_table_elementContext() *Lock_table_elementContext { + var p = new(Lock_table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_element + return p +} + +func InitEmptyLock_table_elementContext(p *Lock_table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_table_element +} + +func (*Lock_table_elementContext) IsLock_table_elementContext() {} + +func NewLock_table_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_table_elementContext { + var p = new(Lock_table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_table_element + + return p +} + +func (s *Lock_table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_table_elementContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Lock_table_elementContext) Partition_extension_clause() IPartition_extension_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extension_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extension_clauseContext) +} + +func (s *Lock_table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_table_element(s) + } +} + +func (s *Lock_table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_table_element(s) + } +} + +func (s *Lock_table_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLock_table_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lock_table_element() (localctx ILock_table_elementContext) { + localctx = NewLock_table_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2048, PlSqlParserRULE_lock_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17177) + p.Tableview_name() + } + p.SetState(17179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION { + { + p.SetState(17178) + p.Partition_extension_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 +} + +// ILock_modeContext is an interface to support dynamic dispatch. +type ILock_modeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROW() antlr.TerminalNode + SHARE() antlr.TerminalNode + EXCLUSIVE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + + // IsLock_modeContext differentiates from other interfaces. + IsLock_modeContext() +} + +type Lock_modeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLock_modeContext() *Lock_modeContext { + var p = new(Lock_modeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_mode + return p +} + +func InitEmptyLock_modeContext(p *Lock_modeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_lock_mode +} + +func (*Lock_modeContext) IsLock_modeContext() {} + +func NewLock_modeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Lock_modeContext { + var p = new(Lock_modeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_lock_mode + + return p +} + +func (s *Lock_modeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Lock_modeContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Lock_modeContext) SHARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARE, 0) +} + +func (s *Lock_modeContext) EXCLUSIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUSIVE, 0) +} + +func (s *Lock_modeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Lock_modeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Lock_modeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Lock_modeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLock_mode(s) + } +} + +func (s *Lock_modeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLock_mode(s) + } +} + +func (s *Lock_modeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLock_mode(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Lock_mode() (localctx ILock_modeContext) { + localctx = NewLock_modeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2050, PlSqlParserRULE_lock_mode) + var _la int + + p.SetState(17193) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2343, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17181) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17182) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17183) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17184) + p.Match(PlSqlParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17185) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17187) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUPDATE { + { + p.SetState(17186) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17189) + p.Match(PlSqlParserSHARE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17190) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17191) + p.Match(PlSqlParserEXCLUSIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17192) + p.Match(PlSqlParserEXCLUSIVE) + 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 +} + +// IGeneral_table_refContext is an interface to support dynamic dispatch. +type IGeneral_table_refContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Dml_table_expression_clause() IDml_table_expression_clauseContext + ONLY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Table_alias() ITable_aliasContext + + // IsGeneral_table_refContext differentiates from other interfaces. + IsGeneral_table_refContext() +} + +type General_table_refContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_table_refContext() *General_table_refContext { + var p = new(General_table_refContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_table_ref + return p +} + +func InitEmptyGeneral_table_refContext(p *General_table_refContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_table_ref +} + +func (*General_table_refContext) IsGeneral_table_refContext() {} + +func NewGeneral_table_refContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_table_refContext { + var p = new(General_table_refContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_table_ref + + return p +} + +func (s *General_table_refContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_table_refContext) Dml_table_expression_clause() IDml_table_expression_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDml_table_expression_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDml_table_expression_clauseContext) +} + +func (s *General_table_refContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *General_table_refContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *General_table_refContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *General_table_refContext) Table_alias() ITable_aliasContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_aliasContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_aliasContext) +} + +func (s *General_table_refContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_table_refContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_table_refContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_table_ref(s) + } +} + +func (s *General_table_refContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_table_ref(s) + } +} + +func (s *General_table_refContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGeneral_table_ref(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) General_table_ref() (localctx IGeneral_table_refContext) { + localctx = NewGeneral_table_refContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2052, PlSqlParserRULE_general_table_ref) + p.EnterOuterAlt(localctx, 1) + p.SetState(17201) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2344, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17195) + p.Dml_table_expression_clause() + } + + case 2: + { + p.SetState(17196) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17197) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17198) + p.Dml_table_expression_clause() + } + { + p.SetState(17199) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17204) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2345, p.GetParserRuleContext()) == 1 { + { + p.SetState(17203) + p.Table_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 +} + +// IStatic_returning_clauseContext is an interface to support dynamic dispatch. +type IStatic_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expressions() IExpressionsContext + Into_clause() IInto_clauseContext + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + + // IsStatic_returning_clauseContext differentiates from other interfaces. + IsStatic_returning_clauseContext() +} + +type Static_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStatic_returning_clauseContext() *Static_returning_clauseContext { + var p = new(Static_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_returning_clause + return p +} + +func InitEmptyStatic_returning_clauseContext(p *Static_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_static_returning_clause +} + +func (*Static_returning_clauseContext) IsStatic_returning_clauseContext() {} + +func NewStatic_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Static_returning_clauseContext { + var p = new(Static_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_static_returning_clause + + return p +} + +func (s *Static_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Static_returning_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Static_returning_clauseContext) 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 *Static_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Static_returning_clauseContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Static_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Static_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Static_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStatic_returning_clause(s) + } +} + +func (s *Static_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStatic_returning_clause(s) + } +} + +func (s *Static_returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStatic_returning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Static_returning_clause() (localctx IStatic_returning_clauseContext) { + localctx = NewStatic_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2054, PlSqlParserRULE_static_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17206) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRETURNING || _la == PlSqlParserRETURN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17207) + p.Expressions() + } + { + p.SetState(17208) + p.Into_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 +} + +// IError_logging_clauseContext is an interface to support dynamic dispatch. +type IError_logging_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LOG() antlr.TerminalNode + ERRORS() antlr.TerminalNode + Error_logging_into_part() IError_logging_into_partContext + Expression() IExpressionContext + Error_logging_reject_part() IError_logging_reject_partContext + + // IsError_logging_clauseContext differentiates from other interfaces. + IsError_logging_clauseContext() +} + +type Error_logging_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_clauseContext() *Error_logging_clauseContext { + var p = new(Error_logging_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_clause + return p +} + +func InitEmptyError_logging_clauseContext(p *Error_logging_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_clause +} + +func (*Error_logging_clauseContext) IsError_logging_clauseContext() {} + +func NewError_logging_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_clauseContext { + var p = new(Error_logging_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_clause + + return p +} + +func (s *Error_logging_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_clauseContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Error_logging_clauseContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Error_logging_clauseContext) Error_logging_into_part() IError_logging_into_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_into_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_into_partContext) +} + +func (s *Error_logging_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Error_logging_clauseContext) Error_logging_reject_part() IError_logging_reject_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IError_logging_reject_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IError_logging_reject_partContext) +} + +func (s *Error_logging_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_clause(s) + } +} + +func (s *Error_logging_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_clause(s) + } +} + +func (s *Error_logging_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitError_logging_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Error_logging_clause() (localctx IError_logging_clauseContext) { + localctx = NewError_logging_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2056, PlSqlParserRULE_error_logging_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17210) + p.Match(PlSqlParserLOG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17211) + p.Match(PlSqlParserERRORS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17213) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2346, p.GetParserRuleContext()) == 1 { + { + p.SetState(17212) + p.Error_logging_into_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17216) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2347, p.GetParserRuleContext()) == 1 { + { + p.SetState(17215) + p.Expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17219) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2348, p.GetParserRuleContext()) == 1 { + { + p.SetState(17218) + p.Error_logging_reject_part() + } + + } 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 +} + +// IError_logging_into_partContext is an interface to support dynamic dispatch. +type IError_logging_into_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + INTO() antlr.TerminalNode + Tableview_name() ITableview_nameContext + + // IsError_logging_into_partContext differentiates from other interfaces. + IsError_logging_into_partContext() +} + +type Error_logging_into_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_into_partContext() *Error_logging_into_partContext { + var p = new(Error_logging_into_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_into_part + return p +} + +func InitEmptyError_logging_into_partContext(p *Error_logging_into_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_into_part +} + +func (*Error_logging_into_partContext) IsError_logging_into_partContext() {} + +func NewError_logging_into_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_into_partContext { + var p = new(Error_logging_into_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_into_part + + return p +} + +func (s *Error_logging_into_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_into_partContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Error_logging_into_partContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Error_logging_into_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_into_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_into_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_into_part(s) + } +} + +func (s *Error_logging_into_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_into_part(s) + } +} + +func (s *Error_logging_into_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitError_logging_into_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Error_logging_into_part() (localctx IError_logging_into_partContext) { + localctx = NewError_logging_into_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2058, PlSqlParserRULE_error_logging_into_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17221) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17222) + p.Tableview_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 +} + +// IError_logging_reject_partContext is an interface to support dynamic dispatch. +type IError_logging_reject_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REJECT() antlr.TerminalNode + LIMIT() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + Expression() IExpressionContext + + // IsError_logging_reject_partContext differentiates from other interfaces. + IsError_logging_reject_partContext() +} + +type Error_logging_reject_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyError_logging_reject_partContext() *Error_logging_reject_partContext { + var p = new(Error_logging_reject_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part + return p +} + +func InitEmptyError_logging_reject_partContext(p *Error_logging_reject_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part +} + +func (*Error_logging_reject_partContext) IsError_logging_reject_partContext() {} + +func NewError_logging_reject_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Error_logging_reject_partContext { + var p = new(Error_logging_reject_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_error_logging_reject_part + + return p +} + +func (s *Error_logging_reject_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Error_logging_reject_partContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Error_logging_reject_partContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Error_logging_reject_partContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Error_logging_reject_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Error_logging_reject_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Error_logging_reject_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Error_logging_reject_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterError_logging_reject_part(s) + } +} + +func (s *Error_logging_reject_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitError_logging_reject_part(s) + } +} + +func (s *Error_logging_reject_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitError_logging_reject_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Error_logging_reject_part() (localctx IError_logging_reject_partContext) { + localctx = NewError_logging_reject_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2060, PlSqlParserRULE_error_logging_reject_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17224) + p.Match(PlSqlParserREJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17225) + p.Match(PlSqlParserLIMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17228) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2349, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17226) + p.Match(PlSqlParserUNLIMITED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17227) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDml_table_expression_clauseContext is an interface to support dynamic dispatch. +type IDml_table_expression_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_collection_expression() ITable_collection_expressionContext + LEFT_PAREN() antlr.TerminalNode + Select_statement() ISelect_statementContext + RIGHT_PAREN() antlr.TerminalNode + Subquery_restriction_clause() ISubquery_restriction_clauseContext + Tableview_name() ITableview_nameContext + Sample_clause() ISample_clauseContext + Json_table_clause() IJson_table_clauseContext + AS() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsDml_table_expression_clauseContext differentiates from other interfaces. + IsDml_table_expression_clauseContext() +} + +type Dml_table_expression_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDml_table_expression_clauseContext() *Dml_table_expression_clauseContext { + var p = new(Dml_table_expression_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause + return p +} + +func InitEmptyDml_table_expression_clauseContext(p *Dml_table_expression_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause +} + +func (*Dml_table_expression_clauseContext) IsDml_table_expression_clauseContext() {} + +func NewDml_table_expression_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dml_table_expression_clauseContext { + var p = new(Dml_table_expression_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dml_table_expression_clause + + return p +} + +func (s *Dml_table_expression_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dml_table_expression_clauseContext) Table_collection_expression() ITable_collection_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_collection_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_collection_expressionContext) +} + +func (s *Dml_table_expression_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Dml_table_expression_clauseContext) 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 *Dml_table_expression_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Dml_table_expression_clauseContext) Subquery_restriction_clause() ISubquery_restriction_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_restriction_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_restriction_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Dml_table_expression_clauseContext) Sample_clause() ISample_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISample_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISample_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) Json_table_clause() IJson_table_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_table_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_table_clauseContext) +} + +func (s *Dml_table_expression_clauseContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Dml_table_expression_clauseContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Dml_table_expression_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dml_table_expression_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dml_table_expression_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDml_table_expression_clause(s) + } +} + +func (s *Dml_table_expression_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDml_table_expression_clause(s) + } +} + +func (s *Dml_table_expression_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDml_table_expression_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dml_table_expression_clause() (localctx IDml_table_expression_clauseContext) { + localctx = NewDml_table_expression_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2062, PlSqlParserRULE_dml_table_expression_clause) + var _la int + + p.SetState(17247) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2353, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17230) + p.Table_collection_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17231) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17232) + p.Select_statement() + } + p.SetState(17234) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(17233) + p.Subquery_restriction_clause() + } + + } + { + p.SetState(17236) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17238) + p.Tableview_name() + } + p.SetState(17240) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2351, p.GetParserRuleContext()) == 1 { + { + p.SetState(17239) + p.Sample_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17242) + p.Json_table_clause() + } + p.SetState(17245) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2352, p.GetParserRuleContext()) == 1 { + { + p.SetState(17243) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17244) + p.Identifier() + } + + } 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 +} + +// ITable_collection_expressionContext is an interface to support dynamic dispatch. +type ITable_collection_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TABLE() antlr.TerminalNode + THE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + Outer_join_sign() IOuter_join_signContext + + // IsTable_collection_expressionContext differentiates from other interfaces. + IsTable_collection_expressionContext() +} + +type Table_collection_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_collection_expressionContext() *Table_collection_expressionContext { + var p = new(Table_collection_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_collection_expression + return p +} + +func InitEmptyTable_collection_expressionContext(p *Table_collection_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_collection_expression +} + +func (*Table_collection_expressionContext) IsTable_collection_expressionContext() {} + +func NewTable_collection_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_collection_expressionContext { + var p = new(Table_collection_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_collection_expression + + return p +} + +func (s *Table_collection_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_collection_expressionContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Table_collection_expressionContext) THE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHE, 0) +} + +func (s *Table_collection_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Table_collection_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 *Table_collection_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Table_collection_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Table_collection_expressionContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *Table_collection_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_collection_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_collection_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_collection_expression(s) + } +} + +func (s *Table_collection_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_collection_expression(s) + } +} + +func (s *Table_collection_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_collection_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_collection_expression() (localctx ITable_collection_expressionContext) { + localctx = NewTable_collection_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2064, PlSqlParserRULE_table_collection_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17249) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserTABLE || _la == PlSqlParserTHE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2355, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17250) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17251) + p.Subquery() + } + { + p.SetState(17252) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17254) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17255) + p.Expression() + } + { + p.SetState(17256) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17258) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2354, p.GetParserRuleContext()) == 1 { + { + p.SetState(17257) + p.Outer_join_sign() + } + + } 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 +} + +// ISubquery_restriction_clauseContext is an interface to support dynamic dispatch. +type ISubquery_restriction_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITH() antlr.TerminalNode + READ() antlr.TerminalNode + ONLY() antlr.TerminalNode + CHECK() antlr.TerminalNode + OPTION() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + Constraint_name() IConstraint_nameContext + + // IsSubquery_restriction_clauseContext differentiates from other interfaces. + IsSubquery_restriction_clauseContext() +} + +type Subquery_restriction_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySubquery_restriction_clauseContext() *Subquery_restriction_clauseContext { + var p = new(Subquery_restriction_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause + return p +} + +func InitEmptySubquery_restriction_clauseContext(p *Subquery_restriction_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause +} + +func (*Subquery_restriction_clauseContext) IsSubquery_restriction_clauseContext() {} + +func NewSubquery_restriction_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Subquery_restriction_clauseContext { + var p = new(Subquery_restriction_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_subquery_restriction_clause + + return p +} + +func (s *Subquery_restriction_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Subquery_restriction_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Subquery_restriction_clauseContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Subquery_restriction_clauseContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Subquery_restriction_clauseContext) CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK, 0) +} + +func (s *Subquery_restriction_clauseContext) OPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTION, 0) +} + +func (s *Subquery_restriction_clauseContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Subquery_restriction_clauseContext) Constraint_name() IConstraint_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstraint_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstraint_nameContext) +} + +func (s *Subquery_restriction_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Subquery_restriction_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Subquery_restriction_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSubquery_restriction_clause(s) + } +} + +func (s *Subquery_restriction_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSubquery_restriction_clause(s) + } +} + +func (s *Subquery_restriction_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSubquery_restriction_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Subquery_restriction_clause() (localctx ISubquery_restriction_clauseContext) { + localctx = NewSubquery_restriction_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2066, PlSqlParserRULE_subquery_restriction_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17262) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserREAD: + { + p.SetState(17263) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17264) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHECK: + { + p.SetState(17265) + p.Match(PlSqlParserCHECK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17266) + p.Match(PlSqlParserOPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17269) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2356, p.GetParserRuleContext()) == 1 { + { + p.SetState(17267) + p.Match(PlSqlParserCONSTRAINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17268) + p.Constraint_name() + } + + } 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 +} + +// ISample_clauseContext is an interface to support dynamic dispatch. +type ISample_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SAMPLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + BLOCK() antlr.TerminalNode + COMMA() antlr.TerminalNode + Seed_part() ISeed_partContext + + // IsSample_clauseContext differentiates from other interfaces. + IsSample_clauseContext() +} + +type Sample_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySample_clauseContext() *Sample_clauseContext { + var p = new(Sample_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sample_clause + return p +} + +func InitEmptySample_clauseContext(p *Sample_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sample_clause +} + +func (*Sample_clauseContext) IsSample_clauseContext() {} + +func NewSample_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sample_clauseContext { + var p = new(Sample_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sample_clause + + return p +} + +func (s *Sample_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sample_clauseContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAMPLE, 0) +} + +func (s *Sample_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Sample_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Sample_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Sample_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Sample_clauseContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Sample_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Sample_clauseContext) Seed_part() ISeed_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeed_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeed_partContext) +} + +func (s *Sample_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sample_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sample_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSample_clause(s) + } +} + +func (s *Sample_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSample_clause(s) + } +} + +func (s *Sample_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSample_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sample_clause() (localctx ISample_clauseContext) { + localctx = NewSample_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2068, PlSqlParserRULE_sample_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17273) + p.Match(PlSqlParserSAMPLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17275) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBLOCK { + { + p.SetState(17274) + p.Match(PlSqlParserBLOCK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17277) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17278) + p.Expression() + } + p.SetState(17281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(17279) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17280) + p.Expression() + } + + } + { + p.SetState(17283) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17285) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2360, p.GetParserRuleContext()) == 1 { + { + p.SetState(17284) + p.Seed_part() + } + + } 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 +} + +// ISeed_partContext is an interface to support dynamic dispatch. +type ISeed_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SEED() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + + // IsSeed_partContext differentiates from other interfaces. + IsSeed_partContext() +} + +type Seed_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySeed_partContext() *Seed_partContext { + var p = new(Seed_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seed_part + return p +} + +func InitEmptySeed_partContext(p *Seed_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_seed_part +} + +func (*Seed_partContext) IsSeed_partContext() {} + +func NewSeed_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Seed_partContext { + var p = new(Seed_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_seed_part + + return p +} + +func (s *Seed_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Seed_partContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Seed_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Seed_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Seed_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Seed_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Seed_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Seed_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSeed_part(s) + } +} + +func (s *Seed_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSeed_part(s) + } +} + +func (s *Seed_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSeed_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Seed_part() (localctx ISeed_partContext) { + localctx = NewSeed_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2070, PlSqlParserRULE_seed_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17287) + p.Match(PlSqlParserSEED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17288) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17289) + p.Expression() + } + { + p.SetState(17290) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IConditionContext is an interface to support dynamic dispatch. +type IConditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Json_condition() IJson_conditionContext + + // IsConditionContext differentiates from other interfaces. + IsConditionContext() +} + +type ConditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConditionContext() *ConditionContext { + var p = new(ConditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_condition + return p +} + +func InitEmptyConditionContext(p *ConditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_condition +} + +func (*ConditionContext) IsConditionContext() {} + +func NewConditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConditionContext { + var p = new(ConditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_condition + + return p +} + +func (s *ConditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConditionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ConditionContext) Json_condition() IJson_conditionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_conditionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_conditionContext) +} + +func (s *ConditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCondition(s) + } +} + +func (s *ConditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCondition(s) + } +} + +func (s *ConditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCondition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Condition() (localctx IConditionContext) { + localctx = NewConditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2072, PlSqlParserRULE_condition) + p.SetState(17294) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2361, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17292) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17293) + p.Json_condition() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_conditionContext is an interface to support dynamic dispatch. +type IJson_conditionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Column_name() IColumn_nameContext + IS() antlr.TerminalNode + AllJSON() []antlr.TerminalNode + JSON(i int) antlr.TerminalNode + NOT() antlr.TerminalNode + FORMAT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + STRICT() antlr.TerminalNode + LAX() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + JSON_EQUAL() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expressions() IExpressionsContext + RIGHT_PAREN() antlr.TerminalNode + + // IsJson_conditionContext differentiates from other interfaces. + IsJson_conditionContext() +} + +type Json_conditionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_conditionContext() *Json_conditionContext { + var p = new(Json_conditionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_condition + return p +} + +func InitEmptyJson_conditionContext(p *Json_conditionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_condition +} + +func (*Json_conditionContext) IsJson_conditionContext() {} + +func NewJson_conditionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_conditionContext { + var p = new(Json_conditionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_condition + + return p +} + +func (s *Json_conditionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_conditionContext) 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 *Json_conditionContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Json_conditionContext) AllJSON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserJSON) +} + +func (s *Json_conditionContext) JSON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, i) +} + +func (s *Json_conditionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Json_conditionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_conditionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Json_conditionContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Json_conditionContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Json_conditionContext) LAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAX, 0) +} + +func (s *Json_conditionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_conditionContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Json_conditionContext) JSON_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EQUAL, 0) +} + +func (s *Json_conditionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_conditionContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Json_conditionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_conditionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_conditionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_conditionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_condition(s) + } +} + +func (s *Json_conditionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_condition(s) + } +} + +func (s *Json_conditionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_condition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_condition() (localctx IJson_conditionContext) { + localctx = NewJson_conditionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2074, PlSqlParserRULE_json_condition) + var _la int + + p.SetState(17319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2366, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17296) + p.Column_name() + } + { + p.SetState(17297) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(17298) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17301) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17304) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2363, p.GetParserRuleContext()) == 1 { + { + p.SetState(17302) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17303) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17307) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2364, p.GetParserRuleContext()) == 1 { + { + p.SetState(17306) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserLAX || _la == PlSqlParserSTRICT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2365, p.GetParserRuleContext()) == 1 { + { + p.SetState(17309) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17310) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17311) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17314) + p.Match(PlSqlParserJSON_EQUAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17315) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17316) + p.Expressions() + } + { + p.SetState(17317) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IExpressionsContext is an interface to support dynamic dispatch. +type IExpressionsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsExpressionsContext differentiates from other interfaces. + IsExpressionsContext() +} + +type ExpressionsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionsContext() *ExpressionsContext { + var p = new(ExpressionsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expressions + return p +} + +func InitEmptyExpressionsContext(p *ExpressionsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expressions +} + +func (*ExpressionsContext) IsExpressionsContext() {} + +func NewExpressionsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionsContext { + var p = new(ExpressionsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_expressions + + return p +} + +func (s *ExpressionsContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionsContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *ExpressionsContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ExpressionsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *ExpressionsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *ExpressionsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExpressions(s) + } +} + +func (s *ExpressionsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExpressions(s) + } +} + +func (s *ExpressionsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExpressions(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Expressions() (localctx IExpressionsContext) { + localctx = NewExpressionsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2076, PlSqlParserRULE_expressions) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17321) + p.Expression() + } + p.SetState(17326) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2367, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17322) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17323) + p.Expression() + } + + } + p.SetState(17328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2367, 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 +} + +// IExpressionContext is an interface to support dynamic dispatch. +type IExpressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Cursor_expression() ICursor_expressionContext + Logical_expression() ILogical_expressionContext + + // IsExpressionContext differentiates from other interfaces. + IsExpressionContext() +} + +type ExpressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyExpressionContext() *ExpressionContext { + var p = new(ExpressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expression + return p +} + +func InitEmptyExpressionContext(p *ExpressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_expression +} + +func (*ExpressionContext) IsExpressionContext() {} + +func NewExpressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ExpressionContext { + var p = new(ExpressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_expression + + return p +} + +func (s *ExpressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *ExpressionContext) Cursor_expression() ICursor_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_expressionContext) +} + +func (s *ExpressionContext) Logical_expression() ILogical_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILogical_expressionContext) +} + +func (s *ExpressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ExpressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ExpressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterExpression(s) + } +} + +func (s *ExpressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitExpression(s) + } +} + +func (s *ExpressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitExpression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Expression() (localctx IExpressionContext) { + localctx = NewExpressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2078, PlSqlParserRULE_expression) + p.SetState(17331) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2368, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17329) + p.Cursor_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17330) + p.logical_expression(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 +} + +// ICursor_expressionContext is an interface to support dynamic dispatch. +type ICursor_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CURSOR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + + // IsCursor_expressionContext differentiates from other interfaces. + IsCursor_expressionContext() +} + +type Cursor_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_expressionContext() *Cursor_expressionContext { + var p = new(Cursor_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_expression + return p +} + +func InitEmptyCursor_expressionContext(p *Cursor_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_expression +} + +func (*Cursor_expressionContext) IsCursor_expressionContext() {} + +func NewCursor_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_expressionContext { + var p = new(Cursor_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_expression + + return p +} + +func (s *Cursor_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_expressionContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Cursor_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Cursor_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 *Cursor_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Cursor_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_expression(s) + } +} + +func (s *Cursor_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_expression(s) + } +} + +func (s *Cursor_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCursor_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cursor_expression() (localctx ICursor_expressionContext) { + localctx = NewCursor_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2080, PlSqlParserRULE_cursor_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17333) + p.Match(PlSqlParserCURSOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17334) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17335) + p.Subquery() + } + { + p.SetState(17336) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILogical_expressionContext is an interface to support dynamic dispatch. +type ILogical_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unary_logical_expression() IUnary_logical_expressionContext + AllLogical_expression() []ILogical_expressionContext + Logical_expression(i int) ILogical_expressionContext + AND() antlr.TerminalNode + OR() antlr.TerminalNode + + // IsLogical_expressionContext differentiates from other interfaces. + IsLogical_expressionContext() +} + +type Logical_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_expressionContext() *Logical_expressionContext { + var p = new(Logical_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_expression + return p +} + +func InitEmptyLogical_expressionContext(p *Logical_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_expression +} + +func (*Logical_expressionContext) IsLogical_expressionContext() {} + +func NewLogical_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_expressionContext { + var p = new(Logical_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_expression + + return p +} + +func (s *Logical_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_expressionContext) Unary_logical_expression() IUnary_logical_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_logical_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_logical_expressionContext) +} + +func (s *Logical_expressionContext) AllLogical_expression() []ILogical_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogical_expressionContext); ok { + len++ + } + } + + tst := make([]ILogical_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogical_expressionContext); ok { + tst[i] = t.(ILogical_expressionContext) + i++ + } + } + + return tst +} + +func (s *Logical_expressionContext) Logical_expression(i int) ILogical_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogical_expressionContext) +} + +func (s *Logical_expressionContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Logical_expressionContext) OR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR, 0) +} + +func (s *Logical_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_expression(s) + } +} + +func (s *Logical_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_expression(s) + } +} + +func (s *Logical_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogical_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logical_expression() (localctx ILogical_expressionContext) { + return p.logical_expression(0) +} + +func (p *PlSqlParser) logical_expression(_p int) (localctx ILogical_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewLogical_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx ILogical_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2082 + p.EnterRecursionRule(localctx, 2082, PlSqlParserRULE_logical_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17339) + p.Unary_logical_expression() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(17349) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2370, 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(17347) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2369, p.GetParserRuleContext()) { + case 1: + localctx = NewLogical_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_logical_expression) + p.SetState(17341) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(17342) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17343) + p.logical_expression(3) + } + + case 2: + localctx = NewLogical_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_logical_expression) + p.SetState(17344) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(17345) + p.Match(PlSqlParserOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17346) + p.logical_expression(2) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(17351) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2370, 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 +} + +// IUnary_logical_expressionContext is an interface to support dynamic dispatch. +type IUnary_logical_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Multiset_expression() IMultiset_expressionContext + AllNOT() []antlr.TerminalNode + NOT(i int) antlr.TerminalNode + AllIS() []antlr.TerminalNode + IS(i int) antlr.TerminalNode + AllLogical_operation() []ILogical_operationContext + Logical_operation(i int) ILogical_operationContext + + // IsUnary_logical_expressionContext differentiates from other interfaces. + IsUnary_logical_expressionContext() +} + +type Unary_logical_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_logical_expressionContext() *Unary_logical_expressionContext { + var p = new(Unary_logical_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_expression + return p +} + +func InitEmptyUnary_logical_expressionContext(p *Unary_logical_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_logical_expression +} + +func (*Unary_logical_expressionContext) IsUnary_logical_expressionContext() {} + +func NewUnary_logical_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_logical_expressionContext { + var p = new(Unary_logical_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_logical_expression + + return p +} + +func (s *Unary_logical_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_logical_expressionContext) Multiset_expression() IMultiset_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMultiset_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMultiset_expressionContext) +} + +func (s *Unary_logical_expressionContext) AllNOT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNOT) +} + +func (s *Unary_logical_expressionContext) NOT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, i) +} + +func (s *Unary_logical_expressionContext) AllIS() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIS) +} + +func (s *Unary_logical_expressionContext) IS(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, i) +} + +func (s *Unary_logical_expressionContext) AllLogical_operation() []ILogical_operationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILogical_operationContext); ok { + len++ + } + } + + tst := make([]ILogical_operationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILogical_operationContext); ok { + tst[i] = t.(ILogical_operationContext) + i++ + } + } + + return tst +} + +func (s *Unary_logical_expressionContext) Logical_operation(i int) ILogical_operationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILogical_operationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILogical_operationContext) +} + +func (s *Unary_logical_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_logical_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_logical_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_logical_expression(s) + } +} + +func (s *Unary_logical_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_logical_expression(s) + } +} + +func (s *Unary_logical_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnary_logical_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unary_logical_expression() (localctx IUnary_logical_expressionContext) { + localctx = NewUnary_logical_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2084, PlSqlParserRULE_unary_logical_expression) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(17352) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17355) + p.Multiset_expression() + } + p.SetState(17363) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2373, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17356) + p.Match(PlSqlParserIS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(17357) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17360) + p.Logical_operation() + } + + } + p.SetState(17365) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2373, 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 +} + +// ILogical_operationContext is an interface to support dynamic dispatch. +type ILogical_operationContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULL_() antlr.TerminalNode + NAN() antlr.TerminalNode + PRESENT() antlr.TerminalNode + INFINITE() antlr.TerminalNode + A_LETTER() antlr.TerminalNode + SET() antlr.TerminalNode + EMPTY() antlr.TerminalNode + OF() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllType_spec() []IType_specContext + Type_spec(i int) IType_specContext + RIGHT_PAREN() antlr.TerminalNode + TYPE() antlr.TerminalNode + ONLY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsLogical_operationContext differentiates from other interfaces. + IsLogical_operationContext() +} + +type Logical_operationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLogical_operationContext() *Logical_operationContext { + var p = new(Logical_operationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_operation + return p +} + +func InitEmptyLogical_operationContext(p *Logical_operationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_logical_operation +} + +func (*Logical_operationContext) IsLogical_operationContext() {} + +func NewLogical_operationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Logical_operationContext { + var p = new(Logical_operationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_logical_operation + + return p +} + +func (s *Logical_operationContext) GetParser() antlr.Parser { return s.parser } + +func (s *Logical_operationContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Logical_operationContext) NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAN, 0) +} + +func (s *Logical_operationContext) PRESENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENT, 0) +} + +func (s *Logical_operationContext) INFINITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFINITE, 0) +} + +func (s *Logical_operationContext) A_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserA_LETTER, 0) +} + +func (s *Logical_operationContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Logical_operationContext) EMPTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, 0) +} + +func (s *Logical_operationContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Logical_operationContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Logical_operationContext) AllType_spec() []IType_specContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IType_specContext); ok { + len++ + } + } + + tst := make([]IType_specContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IType_specContext); ok { + tst[i] = t.(IType_specContext) + i++ + } + } + + return tst +} + +func (s *Logical_operationContext) Type_spec(i int) IType_specContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Logical_operationContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Logical_operationContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Logical_operationContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Logical_operationContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Logical_operationContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Logical_operationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Logical_operationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Logical_operationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLogical_operation(s) + } +} + +func (s *Logical_operationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLogical_operation(s) + } +} + +func (s *Logical_operationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLogical_operation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Logical_operation() (localctx ILogical_operationContext) { + localctx = NewLogical_operationContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2086, PlSqlParserRULE_logical_operation) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17391) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(17366) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNAN: + { + p.SetState(17367) + p.Match(PlSqlParserNAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPRESENT: + { + p.SetState(17368) + p.Match(PlSqlParserPRESENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINFINITE: + { + p.SetState(17369) + p.Match(PlSqlParserINFINITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserA_LETTER: + { + p.SetState(17370) + p.Match(PlSqlParserA_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17371) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEMPTY: + { + p.SetState(17372) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOF: + { + p.SetState(17373) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17375) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTYPE { + { + p.SetState(17374) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17377) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17379) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2375, p.GetParserRuleContext()) == 1 { + { + p.SetState(17378) + p.Match(PlSqlParserONLY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17381) + p.Type_spec() + } + p.SetState(17386) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17382) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17383) + p.Type_spec() + } + + p.SetState(17388) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17389) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMultiset_expressionContext is an interface to support dynamic dispatch. +type IMultiset_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetMultiset_type returns the multiset_type token. + GetMultiset_type() antlr.Token + + // SetMultiset_type sets the multiset_type token. + SetMultiset_type(antlr.Token) + + // Getter signatures + Relational_expression() IRelational_expressionContext + Concatenation() IConcatenationContext + MEMBER() antlr.TerminalNode + SUBMULTISET() antlr.TerminalNode + OF() antlr.TerminalNode + + // IsMultiset_expressionContext differentiates from other interfaces. + IsMultiset_expressionContext() +} + +type Multiset_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + multiset_type antlr.Token +} + +func NewEmptyMultiset_expressionContext() *Multiset_expressionContext { + var p = new(Multiset_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multiset_expression + return p +} + +func InitEmptyMultiset_expressionContext(p *Multiset_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multiset_expression +} + +func (*Multiset_expressionContext) IsMultiset_expressionContext() {} + +func NewMultiset_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multiset_expressionContext { + var p = new(Multiset_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multiset_expression + + return p +} + +func (s *Multiset_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multiset_expressionContext) GetMultiset_type() antlr.Token { return s.multiset_type } + +func (s *Multiset_expressionContext) SetMultiset_type(v antlr.Token) { s.multiset_type = v } + +func (s *Multiset_expressionContext) Relational_expression() IRelational_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_expressionContext) +} + +func (s *Multiset_expressionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Multiset_expressionContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Multiset_expressionContext) SUBMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBMULTISET, 0) +} + +func (s *Multiset_expressionContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Multiset_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multiset_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multiset_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMultiset_expression(s) + } +} + +func (s *Multiset_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMultiset_expression(s) + } +} + +func (s *Multiset_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMultiset_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Multiset_expression() (localctx IMultiset_expressionContext) { + localctx = NewMultiset_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2088, PlSqlParserRULE_multiset_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17393) + p.relational_expression(0) + } + p.SetState(17399) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2379, p.GetParserRuleContext()) == 1 { + { + p.SetState(17394) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Multiset_expressionContext).multiset_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMEMBER || _la == PlSqlParserSUBMULTISET) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Multiset_expressionContext).multiset_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOF { + { + p.SetState(17395) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17398) + p.concatenation(0) + } + + } 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 +} + +// IRelational_expressionContext is an interface to support dynamic dispatch. +type IRelational_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Compound_expression() ICompound_expressionContext + AllRelational_expression() []IRelational_expressionContext + Relational_expression(i int) IRelational_expressionContext + Relational_operator() IRelational_operatorContext + + // IsRelational_expressionContext differentiates from other interfaces. + IsRelational_expressionContext() +} + +type Relational_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_expressionContext() *Relational_expressionContext { + var p = new(Relational_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_expression + return p +} + +func InitEmptyRelational_expressionContext(p *Relational_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_expression +} + +func (*Relational_expressionContext) IsRelational_expressionContext() {} + +func NewRelational_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_expressionContext { + var p = new(Relational_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_expression + + return p +} + +func (s *Relational_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_expressionContext) Compound_expression() ICompound_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICompound_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICompound_expressionContext) +} + +func (s *Relational_expressionContext) AllRelational_expression() []IRelational_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRelational_expressionContext); ok { + len++ + } + } + + tst := make([]IRelational_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRelational_expressionContext); ok { + tst[i] = t.(IRelational_expressionContext) + i++ + } + } + + return tst +} + +func (s *Relational_expressionContext) Relational_expression(i int) IRelational_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRelational_expressionContext) +} + +func (s *Relational_expressionContext) Relational_operator() IRelational_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_operatorContext) +} + +func (s *Relational_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_expression(s) + } +} + +func (s *Relational_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_expression(s) + } +} + +func (s *Relational_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRelational_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Relational_expression() (localctx IRelational_expressionContext) { + return p.relational_expression(0) +} + +func (p *PlSqlParser) relational_expression(_p int) (localctx IRelational_expressionContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewRelational_expressionContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IRelational_expressionContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2090 + p.EnterRecursionRule(localctx, 2090, PlSqlParserRULE_relational_expression, _p) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17402) + p.Compound_expression() + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(17410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2380, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + if p.GetParseListeners() != nil { + p.TriggerExitRuleEvent() + } + _prevctx = localctx + localctx = NewRelational_expressionContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_relational_expression) + p.SetState(17404) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(17405) + p.Relational_operator() + } + { + p.SetState(17406) + p.relational_expression(3) + } + + } + p.SetState(17412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2380, 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 +} + +// ICompound_expressionContext is an interface to support dynamic dispatch. +type ICompound_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetLike_type returns the like_type token. + GetLike_type() antlr.Token + + // SetLike_type sets the like_type token. + SetLike_type(antlr.Token) + + // Getter signatures + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + IN() antlr.TerminalNode + In_elements() IIn_elementsContext + BETWEEN() antlr.TerminalNode + Between_elements() IBetween_elementsContext + NOT() antlr.TerminalNode + LIKE() antlr.TerminalNode + LIKEC() antlr.TerminalNode + LIKE2() antlr.TerminalNode + LIKE4() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + + // IsCompound_expressionContext differentiates from other interfaces. + IsCompound_expressionContext() +} + +type Compound_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + like_type antlr.Token +} + +func NewEmptyCompound_expressionContext() *Compound_expressionContext { + var p = new(Compound_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_expression + return p +} + +func InitEmptyCompound_expressionContext(p *Compound_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_compound_expression +} + +func (*Compound_expressionContext) IsCompound_expressionContext() {} + +func NewCompound_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Compound_expressionContext { + var p = new(Compound_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_compound_expression + + return p +} + +func (s *Compound_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Compound_expressionContext) GetLike_type() antlr.Token { return s.like_type } + +func (s *Compound_expressionContext) SetLike_type(v antlr.Token) { s.like_type = v } + +func (s *Compound_expressionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Compound_expressionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Compound_expressionContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Compound_expressionContext) In_elements() IIn_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIn_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIn_elementsContext) +} + +func (s *Compound_expressionContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Compound_expressionContext) Between_elements() IBetween_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBetween_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBetween_elementsContext) +} + +func (s *Compound_expressionContext) NOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT, 0) +} + +func (s *Compound_expressionContext) LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE, 0) +} + +func (s *Compound_expressionContext) LIKEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKEC, 0) +} + +func (s *Compound_expressionContext) LIKE2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE2, 0) +} + +func (s *Compound_expressionContext) LIKE4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE4, 0) +} + +func (s *Compound_expressionContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESCAPE, 0) +} + +func (s *Compound_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Compound_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Compound_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCompound_expression(s) + } +} + +func (s *Compound_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCompound_expression(s) + } +} + +func (s *Compound_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCompound_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Compound_expression() (localctx ICompound_expressionContext) { + localctx = NewCompound_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2092, PlSqlParserRULE_compound_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17413) + p.concatenation(0) + } + p.SetState(17429) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2384, p.GetParserRuleContext()) == 1 { + p.SetState(17415) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNOT { + { + p.SetState(17414) + p.Match(PlSqlParserNOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIN: + { + p.SetState(17417) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17418) + p.In_elements() + } + + case PlSqlParserBETWEEN: + { + p.SetState(17419) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17420) + p.Between_elements() + } + + case PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE: + { + p.SetState(17421) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Compound_expressionContext).like_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-788)) & ^0x3f) == 0 && ((int64(1)<<(_la-788))&23) != 0) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Compound_expressionContext).like_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17422) + p.concatenation(0) + } + p.SetState(17425) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2382, p.GetParserRuleContext()) == 1 { + { + p.SetState(17423) + p.Match(PlSqlParserESCAPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17424) + p.concatenation(0) + } + + } else if p.HasError() { // JIM + goto errorExit + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRelational_operatorContext is an interface to support dynamic dispatch. +type IRelational_operatorContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + EQUALS_OP() antlr.TerminalNode + NOT_EQUAL_OP() antlr.TerminalNode + LESS_THAN_OP() antlr.TerminalNode + GREATER_THAN_OP() antlr.TerminalNode + EXCLAMATION_OPERATOR_PART() antlr.TerminalNode + CARRET_OPERATOR_PART() antlr.TerminalNode + + // IsRelational_operatorContext differentiates from other interfaces. + IsRelational_operatorContext() +} + +type Relational_operatorContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRelational_operatorContext() *Relational_operatorContext { + var p = new(Relational_operatorContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_operator + return p +} + +func InitEmptyRelational_operatorContext(p *Relational_operatorContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_relational_operator +} + +func (*Relational_operatorContext) IsRelational_operatorContext() {} + +func NewRelational_operatorContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Relational_operatorContext { + var p = new(Relational_operatorContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_relational_operator + + return p +} + +func (s *Relational_operatorContext) GetParser() antlr.Parser { return s.parser } + +func (s *Relational_operatorContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Relational_operatorContext) NOT_EQUAL_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOT_EQUAL_OP, 0) +} + +func (s *Relational_operatorContext) LESS_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS_THAN_OP, 0) +} + +func (s *Relational_operatorContext) GREATER_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, 0) +} + +func (s *Relational_operatorContext) EXCLAMATION_OPERATOR_PART() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLAMATION_OPERATOR_PART, 0) +} + +func (s *Relational_operatorContext) CARRET_OPERATOR_PART() antlr.TerminalNode { + return s.GetToken(PlSqlParserCARRET_OPERATOR_PART, 0) +} + +func (s *Relational_operatorContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Relational_operatorContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Relational_operatorContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRelational_operator(s) + } +} + +func (s *Relational_operatorContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRelational_operator(s) + } +} + +func (s *Relational_operatorContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRelational_operator(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Relational_operator() (localctx IRelational_operatorContext) { + localctx = NewRelational_operatorContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2094, PlSqlParserRULE_relational_operator) + var _la int + + p.SetState(17445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2387, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17431) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(17439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNOT_EQUAL_OP: + { + p.SetState(17432) + p.Match(PlSqlParserNOT_EQUAL_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLESS_THAN_OP: + { + p.SetState(17433) + p.Match(PlSqlParserLESS_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17434) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXCLAMATION_OPERATOR_PART: + { + p.SetState(17435) + p.Match(PlSqlParserEXCLAMATION_OPERATOR_PART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17436) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCARRET_OPERATOR_PART: + { + p.SetState(17437) + p.Match(PlSqlParserCARRET_OPERATOR_PART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17438) + p.Match(PlSqlParserEQUALS_OP) + 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(17441) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserGREATER_THAN_OP || _la == PlSqlParserLESS_THAN_OP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17443) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEQUALS_OP { + { + p.SetState(17442) + p.Match(PlSqlParserEQUALS_OP) + 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 +} + +// IIn_elementsContext is an interface to support dynamic dispatch. +type IIn_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Constant() IConstantContext + Bind_variable() IBind_variableContext + General_element() IGeneral_elementContext + + // IsIn_elementsContext differentiates from other interfaces. + IsIn_elementsContext() +} + +type In_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIn_elementsContext() *In_elementsContext { + var p = new(In_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_in_elements + return p +} + +func InitEmptyIn_elementsContext(p *In_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_in_elements +} + +func (*In_elementsContext) IsIn_elementsContext() {} + +func NewIn_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *In_elementsContext { + var p = new(In_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_in_elements + + return p +} + +func (s *In_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *In_elementsContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *In_elementsContext) 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 *In_elementsContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *In_elementsContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *In_elementsContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *In_elementsContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *In_elementsContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *In_elementsContext) Constant() IConstantContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstantContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstantContext) +} + +func (s *In_elementsContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *In_elementsContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *In_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *In_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *In_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIn_elements(s) + } +} + +func (s *In_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIn_elements(s) + } +} + +func (s *In_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIn_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) In_elements() (localctx IIn_elementsContext) { + localctx = NewIn_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2096, PlSqlParserRULE_in_elements) + var _la int + + p.SetState(17465) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2389, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17447) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17448) + p.Subquery() + } + { + p.SetState(17449) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17451) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17452) + p.concatenation(0) + } + p.SetState(17457) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17453) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17454) + p.concatenation(0) + } + + p.SetState(17459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17460) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17462) + p.Constant() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17463) + p.Bind_variable() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17464) + p.General_element() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IBetween_elementsContext is an interface to support dynamic dispatch. +type IBetween_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AND() antlr.TerminalNode + + // IsBetween_elementsContext differentiates from other interfaces. + IsBetween_elementsContext() +} + +type Between_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBetween_elementsContext() *Between_elementsContext { + var p = new(Between_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_elements + return p +} + +func InitEmptyBetween_elementsContext(p *Between_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_between_elements +} + +func (*Between_elementsContext) IsBetween_elementsContext() {} + +func NewBetween_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Between_elementsContext { + var p = new(Between_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_between_elements + + return p +} + +func (s *Between_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Between_elementsContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Between_elementsContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Between_elementsContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Between_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Between_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Between_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBetween_elements(s) + } +} + +func (s *Between_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBetween_elements(s) + } +} + +func (s *Between_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBetween_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Between_elements() (localctx IBetween_elementsContext) { + localctx = NewBetween_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2098, PlSqlParserRULE_between_elements) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17467) + p.concatenation(0) + } + { + p.SetState(17468) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17469) + p.concatenation(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 +} + +// IConcatenationContext is an interface to support dynamic dispatch. +type IConcatenationContext 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 + Model_expression() IModel_expressionContext + AT() antlr.TerminalNode + Interval_expression() IInterval_expressionContext + ON() antlr.TerminalNode + OVERFLOW() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + ERROR() antlr.TerminalNode + LOCAL() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + ASTERISK() antlr.TerminalNode + SOLIDUS() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + MINUS_SIGN() antlr.TerminalNode + AllBAR() []antlr.TerminalNode + BAR(i int) antlr.TerminalNode + + // IsConcatenationContext differentiates from other interfaces. + IsConcatenationContext() +} + +type ConcatenationContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + op antlr.Token +} + +func NewEmptyConcatenationContext() *ConcatenationContext { + var p = new(ConcatenationContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concatenation + return p +} + +func InitEmptyConcatenationContext(p *ConcatenationContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_concatenation +} + +func (*ConcatenationContext) IsConcatenationContext() {} + +func NewConcatenationContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConcatenationContext { + var p = new(ConcatenationContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_concatenation + + return p +} + +func (s *ConcatenationContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConcatenationContext) GetOp() antlr.Token { return s.op } + +func (s *ConcatenationContext) SetOp(v antlr.Token) { s.op = v } + +func (s *ConcatenationContext) Model_expression() IModel_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expressionContext) +} + +func (s *ConcatenationContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *ConcatenationContext) Interval_expression() IInterval_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IInterval_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IInterval_expressionContext) +} + +func (s *ConcatenationContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *ConcatenationContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *ConcatenationContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *ConcatenationContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *ConcatenationContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *ConcatenationContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *ConcatenationContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *ConcatenationContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *ConcatenationContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *ConcatenationContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *ConcatenationContext) SOLIDUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOLIDUS, 0) +} + +func (s *ConcatenationContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *ConcatenationContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *ConcatenationContext) AllBAR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBAR) +} + +func (s *ConcatenationContext) BAR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBAR, i) +} + +func (s *ConcatenationContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConcatenationContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConcatenationContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConcatenation(s) + } +} + +func (s *ConcatenationContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConcatenation(s) + } +} + +func (s *ConcatenationContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConcatenation(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Concatenation() (localctx IConcatenationContext) { + return p.concatenation(0) +} + +func (p *PlSqlParser) concatenation(_p int) (localctx IConcatenationContext) { + var _parentctx antlr.ParserRuleContext = p.GetParserRuleContext() + + _parentState := p.GetState() + localctx = NewConcatenationContext(p, p.GetParserRuleContext(), _parentState) + var _prevctx IConcatenationContext = localctx + var _ antlr.ParserRuleContext = _prevctx // TODO: To prevent unused variable warning. + _startState := 2100 + p.EnterRecursionRule(localctx, 2100, PlSqlParserRULE_concatenation, _p) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17472) + p.Model_expression() + } + p.SetState(17481) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2391, p.GetParserRuleContext()) == 1 { + { + p.SetState(17473) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17478) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserLOCAL: + { + p.SetState(17474) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIME: + { + p.SetState(17475) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17476) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17477) + p.concatenation(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2391, p.GetParserRuleContext()) == 2 { + { + p.SetState(17480) + p.Interval_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17486) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2392, p.GetParserRuleContext()) == 1 { + { + p.SetState(17483) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17484) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17485) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserTRUNCATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.GetParserRuleContext().SetStop(p.GetTokenStream().LT(-1)) + p.SetState(17500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2394, 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(17498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2393, p.GetParserRuleContext()) { + case 1: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(17488) + + if !(p.Precpred(p.GetParserRuleContext(), 3)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 3)", "")) + goto errorExit + } + { + p.SetState(17489) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConcatenationContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserASTERISK || _la == PlSqlParserSOLIDUS) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConcatenationContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17490) + p.concatenation(4) + } + + case 2: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(17491) + + if !(p.Precpred(p.GetParserRuleContext(), 2)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 2)", "")) + goto errorExit + } + { + p.SetState(17492) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*ConcatenationContext).op = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*ConcatenationContext).op = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17493) + p.concatenation(3) + } + + case 3: + localctx = NewConcatenationContext(p, _parentctx, _parentState) + p.PushNewRecursionContext(localctx, _startState, PlSqlParserRULE_concatenation) + p.SetState(17494) + + if !(p.Precpred(p.GetParserRuleContext(), 1)) { + p.SetError(antlr.NewFailedPredicateException(p, "p.Precpred(p.GetParserRuleContext(), 1)", "")) + goto errorExit + } + { + p.SetState(17495) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17496) + p.Match(PlSqlParserBAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17497) + p.concatenation(2) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + } + p.SetState(17502) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2394, 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 +} + +// IInterval_expressionContext is an interface to support dynamic dispatch. +type IInterval_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DAY() antlr.TerminalNode + TO() antlr.TerminalNode + SECOND() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + + // IsInterval_expressionContext differentiates from other interfaces. + IsInterval_expressionContext() +} + +type Interval_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyInterval_expressionContext() *Interval_expressionContext { + var p = new(Interval_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expression + return p +} + +func InitEmptyInterval_expressionContext(p *Interval_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_interval_expression +} + +func (*Interval_expressionContext) IsInterval_expressionContext() {} + +func NewInterval_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Interval_expressionContext { + var p = new(Interval_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_interval_expression + + return p +} + +func (s *Interval_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Interval_expressionContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Interval_expressionContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Interval_expressionContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Interval_expressionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Interval_expressionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Interval_expressionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Interval_expressionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Interval_expressionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Interval_expressionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Interval_expressionContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Interval_expressionContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Interval_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Interval_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Interval_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterInterval_expression(s) + } +} + +func (s *Interval_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInterval_expression(s) + } +} + +func (s *Interval_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInterval_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Interval_expression() (localctx IInterval_expressionContext) { + localctx = NewInterval_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2102, PlSqlParserRULE_interval_expression) + var _la int + + p.SetState(17530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2398, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17503) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17508) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17504) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17505) + p.concatenation(0) + } + { + p.SetState(17506) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17510) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17511) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17516) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2396, p.GetParserRuleContext()) == 1 { + { + p.SetState(17512) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17513) + p.concatenation(0) + } + { + p.SetState(17514) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17518) + p.Match(PlSqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17519) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17520) + p.concatenation(0) + } + { + p.SetState(17521) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17525) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17526) + p.Match(PlSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17527) + p.concatenation(0) + } + { + p.SetState(17528) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserMONTH || _la == PlSqlParserSECOND || _la == PlSqlParserYEAR) { + 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 +} + +// IModel_expressionContext is an interface to support dynamic dispatch. +type IModel_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unary_expression() IUnary_expressionContext + LEFT_BRACKET() antlr.TerminalNode + Model_expression_element() IModel_expression_elementContext + RIGHT_BRACKET() antlr.TerminalNode + + // IsModel_expressionContext differentiates from other interfaces. + IsModel_expressionContext() +} + +type Model_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_expressionContext() *Model_expressionContext { + var p = new(Model_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression + return p +} + +func InitEmptyModel_expressionContext(p *Model_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression +} + +func (*Model_expressionContext) IsModel_expressionContext() {} + +func NewModel_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_expressionContext { + var p = new(Model_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_expression + + return p +} + +func (s *Model_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_expressionContext) Unary_expression() IUnary_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_expressionContext) +} + +func (s *Model_expressionContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *Model_expressionContext) Model_expression_element() IModel_expression_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IModel_expression_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IModel_expression_elementContext) +} + +func (s *Model_expressionContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *Model_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_expression(s) + } +} + +func (s *Model_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_expression(s) + } +} + +func (s *Model_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_expression() (localctx IModel_expressionContext) { + localctx = NewModel_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2104, PlSqlParserRULE_model_expression) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17532) + p.Unary_expression() + } + p.SetState(17537) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2399, p.GetParserRuleContext()) == 1 { + { + p.SetState(17533) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17534) + p.Model_expression_element() + } + { + p.SetState(17535) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IModel_expression_elementContext is an interface to support dynamic dispatch. +type IModel_expression_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllANY() []antlr.TerminalNode + ANY(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllSingle_column_for_loop() []ISingle_column_for_loopContext + Single_column_for_loop(i int) ISingle_column_for_loopContext + Multi_column_for_loop() IMulti_column_for_loopContext + + // IsModel_expression_elementContext differentiates from other interfaces. + IsModel_expression_elementContext() +} + +type Model_expression_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyModel_expression_elementContext() *Model_expression_elementContext { + var p = new(Model_expression_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression_element + return p +} + +func InitEmptyModel_expression_elementContext(p *Model_expression_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_model_expression_element +} + +func (*Model_expression_elementContext) IsModel_expression_elementContext() {} + +func NewModel_expression_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Model_expression_elementContext { + var p = new(Model_expression_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_model_expression_element + + return p +} + +func (s *Model_expression_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Model_expression_elementContext) AllANY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserANY) +} + +func (s *Model_expression_elementContext) ANY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, i) +} + +func (s *Model_expression_elementContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Model_expression_elementContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Model_expression_elementContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Model_expression_elementContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Model_expression_elementContext) AllSingle_column_for_loop() []ISingle_column_for_loopContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + len++ + } + } + + tst := make([]ISingle_column_for_loopContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISingle_column_for_loopContext); ok { + tst[i] = t.(ISingle_column_for_loopContext) + i++ + } + } + + return tst +} + +func (s *Model_expression_elementContext) Single_column_for_loop(i int) ISingle_column_for_loopContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISingle_column_for_loopContext) +} + +func (s *Model_expression_elementContext) Multi_column_for_loop() IMulti_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_column_for_loopContext) +} + +func (s *Model_expression_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Model_expression_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Model_expression_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterModel_expression_element(s) + } +} + +func (s *Model_expression_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitModel_expression_element(s) + } +} + +func (s *Model_expression_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitModel_expression_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Model_expression_element() (localctx IModel_expression_elementContext) { + localctx = NewModel_expression_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2106, PlSqlParserRULE_model_expression_element) + var _la int + + p.SetState(17562) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2404, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(17541) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2400, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17539) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17540) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17550) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17543) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17546) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2401, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17544) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17545) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + p.SetState(17552) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17553) + p.Single_column_for_loop() + } + p.SetState(17558) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17554) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17555) + p.Single_column_for_loop() + } + + p.SetState(17560) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17561) + p.Multi_column_for_loop() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISingle_column_for_loopContext is an interface to support dynamic dispatch. +type ISingle_column_for_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetAction_type returns the action_type token. + GetAction_type() antlr.Token + + // SetAction_type sets the action_type token. + SetAction_type(antlr.Token) + + // GetFromExpr returns the fromExpr rule contexts. + GetFromExpr() IExpressionContext + + // GetToExpr returns the toExpr rule contexts. + GetToExpr() IExpressionContext + + // GetAction_expr returns the action_expr rule contexts. + GetAction_expr() IExpressionContext + + // SetFromExpr sets the fromExpr rule contexts. + SetFromExpr(IExpressionContext) + + // SetToExpr sets the toExpr rule contexts. + SetToExpr(IExpressionContext) + + // SetAction_expr sets the action_expr rule contexts. + SetAction_expr(IExpressionContext) + + // Getter signatures + FOR() antlr.TerminalNode + Column_name() IColumn_nameContext + IN() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + FROM() antlr.TerminalNode + TO() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + INCREMENT() antlr.TerminalNode + DECREMENT() antlr.TerminalNode + Expressions() IExpressionsContext + LIKE() antlr.TerminalNode + + // IsSingle_column_for_loopContext differentiates from other interfaces. + IsSingle_column_for_loopContext() +} + +type Single_column_for_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + fromExpr IExpressionContext + toExpr IExpressionContext + action_type antlr.Token + action_expr IExpressionContext +} + +func NewEmptySingle_column_for_loopContext() *Single_column_for_loopContext { + var p = new(Single_column_for_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_column_for_loop + return p +} + +func InitEmptySingle_column_for_loopContext(p *Single_column_for_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_single_column_for_loop +} + +func (*Single_column_for_loopContext) IsSingle_column_for_loopContext() {} + +func NewSingle_column_for_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Single_column_for_loopContext { + var p = new(Single_column_for_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_single_column_for_loop + + return p +} + +func (s *Single_column_for_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Single_column_for_loopContext) GetAction_type() antlr.Token { return s.action_type } + +func (s *Single_column_for_loopContext) SetAction_type(v antlr.Token) { s.action_type = v } + +func (s *Single_column_for_loopContext) GetFromExpr() IExpressionContext { return s.fromExpr } + +func (s *Single_column_for_loopContext) GetToExpr() IExpressionContext { return s.toExpr } + +func (s *Single_column_for_loopContext) GetAction_expr() IExpressionContext { return s.action_expr } + +func (s *Single_column_for_loopContext) SetFromExpr(v IExpressionContext) { s.fromExpr = v } + +func (s *Single_column_for_loopContext) SetToExpr(v IExpressionContext) { s.toExpr = v } + +func (s *Single_column_for_loopContext) SetAction_expr(v IExpressionContext) { s.action_expr = v } + +func (s *Single_column_for_loopContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Single_column_for_loopContext) 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 *Single_column_for_loopContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Single_column_for_loopContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Single_column_for_loopContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Single_column_for_loopContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Single_column_for_loopContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Single_column_for_loopContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Single_column_for_loopContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Single_column_for_loopContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Single_column_for_loopContext) DECREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECREMENT, 0) +} + +func (s *Single_column_for_loopContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Single_column_for_loopContext) LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE, 0) +} + +func (s *Single_column_for_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Single_column_for_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Single_column_for_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSingle_column_for_loop(s) + } +} + +func (s *Single_column_for_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSingle_column_for_loop(s) + } +} + +func (s *Single_column_for_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSingle_column_for_loop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Single_column_for_loop() (localctx ISingle_column_for_loopContext) { + localctx = NewSingle_column_for_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2108, PlSqlParserRULE_single_column_for_loop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17564) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17565) + p.Column_name() + } + p.SetState(17583) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserIN: + { + p.SetState(17566) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17567) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17569) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(17568) + p.Expressions() + } + + } + { + p.SetState(17571) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFROM, PlSqlParserLIKE: + p.SetState(17574) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLIKE { + { + p.SetState(17572) + p.Match(PlSqlParserLIKE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17573) + p.Expression() + } + + } + { + p.SetState(17576) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17577) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).fromExpr = _x + } + { + p.SetState(17578) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17579) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).toExpr = _x + } + { + p.SetState(17580) + + var _lt = p.GetTokenStream().LT(1) + + localctx.(*Single_column_for_loopContext).action_type = _lt + + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDECREMENT || _la == PlSqlParserINCREMENT) { + var _ri = p.GetErrorHandler().RecoverInline(p) + + localctx.(*Single_column_for_loopContext).action_type = _ri + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17581) + + var _x = p.Expression() + + localctx.(*Single_column_for_loopContext).action_expr = _x + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMulti_column_for_loopContext is an interface to support dynamic dispatch. +type IMulti_column_for_loopContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + FOR() antlr.TerminalNode + Paren_column_list() IParen_column_listContext + IN() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + Subquery() ISubqueryContext + Expressions() IExpressionsContext + + // IsMulti_column_for_loopContext differentiates from other interfaces. + IsMulti_column_for_loopContext() +} + +type Multi_column_for_loopContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMulti_column_for_loopContext() *Multi_column_for_loopContext { + var p = new(Multi_column_for_loopContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop + return p +} + +func InitEmptyMulti_column_for_loopContext(p *Multi_column_for_loopContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop +} + +func (*Multi_column_for_loopContext) IsMulti_column_for_loopContext() {} + +func NewMulti_column_for_loopContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Multi_column_for_loopContext { + var p = new(Multi_column_for_loopContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_multi_column_for_loop + + return p +} + +func (s *Multi_column_for_loopContext) GetParser() antlr.Parser { return s.parser } + +func (s *Multi_column_for_loopContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Multi_column_for_loopContext) Paren_column_list() IParen_column_listContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IParen_column_listContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IParen_column_listContext) +} + +func (s *Multi_column_for_loopContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Multi_column_for_loopContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Multi_column_for_loopContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Multi_column_for_loopContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Multi_column_for_loopContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Multi_column_for_loopContext) 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 *Multi_column_for_loopContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Multi_column_for_loopContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Multi_column_for_loopContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Multi_column_for_loopContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMulti_column_for_loop(s) + } +} + +func (s *Multi_column_for_loopContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMulti_column_for_loop(s) + } +} + +func (s *Multi_column_for_loopContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMulti_column_for_loop(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Multi_column_for_loop() (localctx IMulti_column_for_loopContext) { + localctx = NewMulti_column_for_loopContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2110, PlSqlParserRULE_multi_column_for_loop) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17585) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17586) + p.Paren_column_list() + } + { + p.SetState(17587) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17588) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2409, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17589) + p.Subquery() + } + + case 2: + { + p.SetState(17590) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(17591) + p.Expressions() + } + + } + { + p.SetState(17594) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(17597) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUnary_expressionContext is an interface to support dynamic dispatch. +type IUnary_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Unary_expression() IUnary_expressionContext + MINUS_SIGN() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + PRIOR() antlr.TerminalNode + CONNECT_BY_ROOT() antlr.TerminalNode + NEW() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + Case_statement() ICase_statementContext + Quantified_expression() IQuantified_expressionContext + Standard_function() IStandard_functionContext + Atom() IAtomContext + + // IsUnary_expressionContext differentiates from other interfaces. + IsUnary_expressionContext() +} + +type Unary_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUnary_expressionContext() *Unary_expressionContext { + var p = new(Unary_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression + return p +} + +func InitEmptyUnary_expressionContext(p *Unary_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_unary_expression +} + +func (*Unary_expressionContext) IsUnary_expressionContext() {} + +func NewUnary_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Unary_expressionContext { + var p = new(Unary_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_unary_expression + + return p +} + +func (s *Unary_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Unary_expressionContext) Unary_expression() IUnary_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUnary_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUnary_expressionContext) +} + +func (s *Unary_expressionContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *Unary_expressionContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *Unary_expressionContext) PRIOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIOR, 0) +} + +func (s *Unary_expressionContext) CONNECT_BY_ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ROOT, 0) +} + +func (s *Unary_expressionContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Unary_expressionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Unary_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Unary_expressionContext) Case_statement() ICase_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_statementContext) +} + +func (s *Unary_expressionContext) Quantified_expression() IQuantified_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuantified_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuantified_expressionContext) +} + +func (s *Unary_expressionContext) Standard_function() IStandard_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_functionContext) +} + +func (s *Unary_expressionContext) Atom() IAtomContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IAtomContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IAtomContext) +} + +func (s *Unary_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Unary_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Unary_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUnary_expression(s) + } +} + +func (s *Unary_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUnary_expression(s) + } +} + +func (s *Unary_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUnary_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Unary_expression() (localctx IUnary_expressionContext) { + localctx = NewUnary_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2112, PlSqlParserRULE_unary_expression) + var _la int + + p.SetState(17615) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2410, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17599) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPLUS_SIGN || _la == PlSqlParserMINUS_SIGN) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17600) + p.Unary_expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17601) + p.Match(PlSqlParserPRIOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17602) + p.Unary_expression() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17603) + p.Match(PlSqlParserCONNECT_BY_ROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17604) + p.Unary_expression() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17605) + p.Match(PlSqlParserNEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17606) + p.Unary_expression() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17607) + p.Match(PlSqlParserDISTINCT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17608) + p.Unary_expression() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(17609) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17610) + p.Unary_expression() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(17611) + p.Case_statement() + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(17612) + p.Quantified_expression() + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(17613) + p.Standard_function() + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(17614) + p.Atom() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_statementContext is an interface to support dynamic dispatch. +type ICase_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Searched_case_statement() ISearched_case_statementContext + Simple_case_statement() ISimple_case_statementContext + + // IsCase_statementContext differentiates from other interfaces. + IsCase_statementContext() +} + +type Case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_statementContext() *Case_statementContext { + var p = new(Case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_statement + return p +} + +func InitEmptyCase_statementContext(p *Case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_statement +} + +func (*Case_statementContext) IsCase_statementContext() {} + +func NewCase_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_statementContext { + var p = new(Case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_statement + + return p +} + +func (s *Case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_statementContext) Searched_case_statement() ISearched_case_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearched_case_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISearched_case_statementContext) +} + +func (s *Case_statementContext) Simple_case_statement() ISimple_case_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_case_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISimple_case_statementContext) +} + +func (s *Case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_statement(s) + } +} + +func (s *Case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_statement(s) + } +} + +func (s *Case_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCase_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Case_statement() (localctx ICase_statementContext) { + localctx = NewCase_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2114, PlSqlParserRULE_case_statement) + p.SetState(17619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2411, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17617) + p.Searched_case_statement() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17618) + p.Simple_case_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 +} + +// ISimple_case_statementContext is an interface to support dynamic dispatch. +type ISimple_case_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + Expression() IExpressionContext + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + AllLabel_name() []ILabel_nameContext + Label_name(i int) ILabel_nameContext + AllSimple_case_when_part() []ISimple_case_when_partContext + Simple_case_when_part(i int) ISimple_case_when_partContext + Case_else_part() ICase_else_partContext + + // IsSimple_case_statementContext differentiates from other interfaces. + IsSimple_case_statementContext() +} + +type Simple_case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySimple_case_statementContext() *Simple_case_statementContext { + var p = new(Simple_case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_statement + return p +} + +func InitEmptySimple_case_statementContext(p *Simple_case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_statement +} + +func (*Simple_case_statementContext) IsSimple_case_statementContext() {} + +func NewSimple_case_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_case_statementContext { + var p = new(Simple_case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_case_statement + + return p +} + +func (s *Simple_case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_case_statementContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Simple_case_statementContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Simple_case_statementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Simple_case_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Simple_case_statementContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Simple_case_statementContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Simple_case_statementContext) AllLabel_name() []ILabel_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_nameContext); ok { + len++ + } + } + + tst := make([]ILabel_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_nameContext); ok { + tst[i] = t.(ILabel_nameContext) + i++ + } + } + + return tst +} + +func (s *Simple_case_statementContext) Label_name(i int) ILabel_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Simple_case_statementContext) AllSimple_case_when_part() []ISimple_case_when_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISimple_case_when_partContext); ok { + len++ + } + } + + tst := make([]ISimple_case_when_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISimple_case_when_partContext); ok { + tst[i] = t.(ISimple_case_when_partContext) + i++ + } + } + + return tst +} + +func (s *Simple_case_statementContext) Simple_case_when_part(i int) ISimple_case_when_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISimple_case_when_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISimple_case_when_partContext) +} + +func (s *Simple_case_statementContext) Case_else_part() ICase_else_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_partContext) +} + +func (s *Simple_case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_case_statement(s) + } +} + +func (s *Simple_case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_case_statement(s) + } +} + +func (s *Simple_case_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSimple_case_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Simple_case_statement() (localctx ISimple_case_statementContext) { + localctx = NewSimple_case_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2116, PlSqlParserRULE_simple_case_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17622) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2412, p.GetParserRuleContext()) == 1 { + { + p.SetState(17621) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17624) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Simple_case_statementContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17625) + p.Expression() + } + p.SetState(17627) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(17626) + p.Simple_case_when_part() + } + + p.SetState(17629) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17632) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(17631) + p.Case_else_part() + } + + } + { + p.SetState(17634) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17636) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2415, p.GetParserRuleContext()) == 1 { + { + p.SetState(17635) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17639) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2416, p.GetParserRuleContext()) == 1 { + { + p.SetState(17638) + p.Label_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 +} + +// ISimple_case_when_partContext is an interface to support dynamic dispatch. +type ISimple_case_when_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsSimple_case_when_partContext differentiates from other interfaces. + IsSimple_case_when_partContext() +} + +type Simple_case_when_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySimple_case_when_partContext() *Simple_case_when_partContext { + var p = new(Simple_case_when_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_when_part + return p +} + +func InitEmptySimple_case_when_partContext(p *Simple_case_when_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_simple_case_when_part +} + +func (*Simple_case_when_partContext) IsSimple_case_when_partContext() {} + +func NewSimple_case_when_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Simple_case_when_partContext { + var p = new(Simple_case_when_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_simple_case_when_part + + return p +} + +func (s *Simple_case_when_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Simple_case_when_partContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Simple_case_when_partContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Simple_case_when_partContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Simple_case_when_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Simple_case_when_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Simple_case_when_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Simple_case_when_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Simple_case_when_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSimple_case_when_part(s) + } +} + +func (s *Simple_case_when_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSimple_case_when_part(s) + } +} + +func (s *Simple_case_when_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSimple_case_when_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Simple_case_when_part() (localctx ISimple_case_when_partContext) { + localctx = NewSimple_case_when_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2118, PlSqlParserRULE_simple_case_when_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17641) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17642) + p.Expression() + } + { + p.SetState(17643) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17646) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2417, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17644) + p.Seq_of_statements() + } + + case 2: + { + p.SetState(17645) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISearched_case_statementContext is an interface to support dynamic dispatch. +type ISearched_case_statementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetCk1 returns the ck1 token. + GetCk1() antlr.Token + + // SetCk1 sets the ck1 token. + SetCk1(antlr.Token) + + // Getter signatures + END() antlr.TerminalNode + AllCASE() []antlr.TerminalNode + CASE(i int) antlr.TerminalNode + AllLabel_name() []ILabel_nameContext + Label_name(i int) ILabel_nameContext + AllSearched_case_when_part() []ISearched_case_when_partContext + Searched_case_when_part(i int) ISearched_case_when_partContext + Case_else_part() ICase_else_partContext + + // IsSearched_case_statementContext differentiates from other interfaces. + IsSearched_case_statementContext() +} + +type Searched_case_statementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + ck1 antlr.Token +} + +func NewEmptySearched_case_statementContext() *Searched_case_statementContext { + var p = new(Searched_case_statementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_statement + return p +} + +func InitEmptySearched_case_statementContext(p *Searched_case_statementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_statement +} + +func (*Searched_case_statementContext) IsSearched_case_statementContext() {} + +func NewSearched_case_statementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Searched_case_statementContext { + var p = new(Searched_case_statementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_searched_case_statement + + return p +} + +func (s *Searched_case_statementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Searched_case_statementContext) GetCk1() antlr.Token { return s.ck1 } + +func (s *Searched_case_statementContext) SetCk1(v antlr.Token) { s.ck1 = v } + +func (s *Searched_case_statementContext) END() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND, 0) +} + +func (s *Searched_case_statementContext) AllCASE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCASE) +} + +func (s *Searched_case_statementContext) CASE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, i) +} + +func (s *Searched_case_statementContext) AllLabel_name() []ILabel_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILabel_nameContext); ok { + len++ + } + } + + tst := make([]ILabel_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILabel_nameContext); ok { + tst[i] = t.(ILabel_nameContext) + i++ + } + } + + return tst +} + +func (s *Searched_case_statementContext) Label_name(i int) ILabel_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILabel_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILabel_nameContext) +} + +func (s *Searched_case_statementContext) AllSearched_case_when_part() []ISearched_case_when_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISearched_case_when_partContext); ok { + len++ + } + } + + tst := make([]ISearched_case_when_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISearched_case_when_partContext); ok { + tst[i] = t.(ISearched_case_when_partContext) + i++ + } + } + + return tst +} + +func (s *Searched_case_statementContext) Searched_case_when_part(i int) ISearched_case_when_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISearched_case_when_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISearched_case_when_partContext) +} + +func (s *Searched_case_statementContext) Case_else_part() ICase_else_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICase_else_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICase_else_partContext) +} + +func (s *Searched_case_statementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Searched_case_statementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Searched_case_statementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearched_case_statement(s) + } +} + +func (s *Searched_case_statementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearched_case_statement(s) + } +} + +func (s *Searched_case_statementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSearched_case_statement(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Searched_case_statement() (localctx ISearched_case_statementContext) { + localctx = NewSearched_case_statementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2120, PlSqlParserRULE_searched_case_statement) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(17649) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2418, p.GetParserRuleContext()) == 1 { + { + p.SetState(17648) + p.Label_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17651) + + var _m = p.Match(PlSqlParserCASE) + + localctx.(*Searched_case_statementContext).ck1 = _m + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17653) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for ok := true; ok; ok = _la == PlSqlParserWHEN { + { + p.SetState(17652) + p.Searched_case_when_part() + } + + p.SetState(17655) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17658) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserELSE { + { + p.SetState(17657) + p.Case_else_part() + } + + } + { + p.SetState(17660) + p.Match(PlSqlParserEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17662) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2421, p.GetParserRuleContext()) == 1 { + { + p.SetState(17661) + p.Match(PlSqlParserCASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17665) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2422, p.GetParserRuleContext()) == 1 { + { + p.SetState(17664) + p.Label_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 +} + +// ISearched_case_when_partContext is an interface to support dynamic dispatch. +type ISearched_case_when_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHEN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + THEN() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + + // IsSearched_case_when_partContext differentiates from other interfaces. + IsSearched_case_when_partContext() +} + +type Searched_case_when_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySearched_case_when_partContext() *Searched_case_when_partContext { + var p = new(Searched_case_when_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_when_part + return p +} + +func InitEmptySearched_case_when_partContext(p *Searched_case_when_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_searched_case_when_part +} + +func (*Searched_case_when_partContext) IsSearched_case_when_partContext() {} + +func NewSearched_case_when_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Searched_case_when_partContext { + var p = new(Searched_case_when_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_searched_case_when_part + + return p +} + +func (s *Searched_case_when_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Searched_case_when_partContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Searched_case_when_partContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Searched_case_when_partContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Searched_case_when_partContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Searched_case_when_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Searched_case_when_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Searched_case_when_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Searched_case_when_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSearched_case_when_part(s) + } +} + +func (s *Searched_case_when_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSearched_case_when_part(s) + } +} + +func (s *Searched_case_when_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSearched_case_when_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Searched_case_when_part() (localctx ISearched_case_when_partContext) { + localctx = NewSearched_case_when_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2122, PlSqlParserRULE_searched_case_when_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17667) + p.Match(PlSqlParserWHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17668) + p.Expression() + } + { + p.SetState(17669) + p.Match(PlSqlParserTHEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2423, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17670) + p.Seq_of_statements() + } + + case 2: + { + p.SetState(17671) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICase_else_partContext is an interface to support dynamic dispatch. +type ICase_else_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ELSE() antlr.TerminalNode + Seq_of_statements() ISeq_of_statementsContext + Expression() IExpressionContext + + // IsCase_else_partContext differentiates from other interfaces. + IsCase_else_partContext() +} + +type Case_else_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCase_else_partContext() *Case_else_partContext { + var p = new(Case_else_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part + return p +} + +func InitEmptyCase_else_partContext(p *Case_else_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_case_else_part +} + +func (*Case_else_partContext) IsCase_else_partContext() {} + +func NewCase_else_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Case_else_partContext { + var p = new(Case_else_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_case_else_part + + return p +} + +func (s *Case_else_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Case_else_partContext) ELSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserELSE, 0) +} + +func (s *Case_else_partContext) Seq_of_statements() ISeq_of_statementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISeq_of_statementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISeq_of_statementsContext) +} + +func (s *Case_else_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Case_else_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Case_else_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Case_else_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCase_else_part(s) + } +} + +func (s *Case_else_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCase_else_part(s) + } +} + +func (s *Case_else_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCase_else_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Case_else_part() (localctx ICase_else_partContext) { + localctx = NewCase_else_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2124, PlSqlParserRULE_case_else_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17674) + p.Match(PlSqlParserELSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17677) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2424, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17675) + p.Seq_of_statements() + } + + case 2: + { + p.SetState(17676) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAtomContext is an interface to support dynamic dispatch. +type IAtomContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Table_element() ITable_elementContext + Outer_join_sign() IOuter_join_signContext + Bind_variable() IBind_variableContext + Constant_without_variable() IConstant_without_variableContext + General_element() IGeneral_elementContext + LEFT_PAREN() antlr.TerminalNode + Subquery() ISubqueryContext + RIGHT_PAREN() antlr.TerminalNode + AllSubquery_operation_part() []ISubquery_operation_partContext + Subquery_operation_part(i int) ISubquery_operation_partContext + Expressions() IExpressionsContext + + // IsAtomContext differentiates from other interfaces. + IsAtomContext() +} + +type AtomContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAtomContext() *AtomContext { + var p = new(AtomContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_atom + return p +} + +func InitEmptyAtomContext(p *AtomContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_atom +} + +func (*AtomContext) IsAtomContext() {} + +func NewAtomContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *AtomContext { + var p = new(AtomContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_atom + + return p +} + +func (s *AtomContext) GetParser() antlr.Parser { return s.parser } + +func (s *AtomContext) Table_element() ITable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *AtomContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *AtomContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *AtomContext) Constant_without_variable() IConstant_without_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConstant_without_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConstant_without_variableContext) +} + +func (s *AtomContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *AtomContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *AtomContext) 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 *AtomContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *AtomContext) AllSubquery_operation_part() []ISubquery_operation_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + len++ + } + } + + tst := make([]ISubquery_operation_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ISubquery_operation_partContext); ok { + tst[i] = t.(ISubquery_operation_partContext) + i++ + } + } + + return tst +} + +func (s *AtomContext) Subquery_operation_part(i int) ISubquery_operation_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISubquery_operation_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ISubquery_operation_partContext) +} + +func (s *AtomContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *AtomContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *AtomContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *AtomContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAtom(s) + } +} + +func (s *AtomContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAtom(s) + } +} + +func (s *AtomContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAtom(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Atom() (localctx IAtomContext) { + localctx = NewAtomContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2126, PlSqlParserRULE_atom) + var _alt int + + p.SetState(17698) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2426, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17679) + p.Table_element() + } + { + p.SetState(17680) + p.Outer_join_sign() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17682) + p.Bind_variable() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17683) + p.Constant_without_variable() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17684) + p.General_element() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17685) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17686) + p.Subquery() + } + { + p.SetState(17687) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17691) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2425, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(17688) + p.Subquery_operation_part() + } + + } + p.SetState(17693) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2425, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(17694) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17695) + p.Expressions() + } + { + p.SetState(17696) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuantified_expressionContext is an interface to support dynamic dispatch. +type IQuantified_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SOME() antlr.TerminalNode + EXISTS() antlr.TerminalNode + ALL() antlr.TerminalNode + ANY() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Select_only_statement() ISelect_only_statementContext + RIGHT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + + // IsQuantified_expressionContext differentiates from other interfaces. + IsQuantified_expressionContext() +} + +type Quantified_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuantified_expressionContext() *Quantified_expressionContext { + var p = new(Quantified_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantified_expression + return p +} + +func InitEmptyQuantified_expressionContext(p *Quantified_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantified_expression +} + +func (*Quantified_expressionContext) IsQuantified_expressionContext() {} + +func NewQuantified_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quantified_expressionContext { + var p = new(Quantified_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quantified_expression + + return p +} + +func (s *Quantified_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quantified_expressionContext) SOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOME, 0) +} + +func (s *Quantified_expressionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Quantified_expressionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Quantified_expressionContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *Quantified_expressionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Quantified_expressionContext) Select_only_statement() ISelect_only_statementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_only_statementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_only_statementContext) +} + +func (s *Quantified_expressionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Quantified_expressionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Quantified_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quantified_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quantified_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuantified_expression(s) + } +} + +func (s *Quantified_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuantified_expression(s) + } +} + +func (s *Quantified_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuantified_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quantified_expression() (localctx IQuantified_expressionContext) { + localctx = NewQuantified_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2128, PlSqlParserRULE_quantified_expression) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17700) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserANY || _la == PlSqlParserEXISTS || _la == PlSqlParserSOME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(17709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2427, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17701) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17702) + p.Select_only_statement() + } + { + p.SetState(17703) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(17705) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17706) + p.Expression() + } + { + p.SetState(17707) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IString_functionContext is an interface to support dynamic dispatch. +type IString_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUBSTR() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + Table_element() ITable_elementContext + Standard_function() IStandard_functionContext + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + DECODE() antlr.TerminalNode + Expressions() IExpressionsContext + CHR() antlr.TerminalNode + Concatenation() IConcatenationContext + USING() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + NVL() antlr.TerminalNode + TRIM() antlr.TerminalNode + FROM() antlr.TerminalNode + LEADING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + BOTH() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + ON() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + ERROR() antlr.TerminalNode + + // IsString_functionContext differentiates from other interfaces. + IsString_functionContext() +} + +type String_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_functionContext() *String_functionContext { + var p = new(String_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function + return p +} + +func InitEmptyString_functionContext(p *String_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function +} + +func (*String_functionContext) IsString_functionContext() {} + +func NewString_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_functionContext { + var p = new(String_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_string_function + + return p +} + +func (s *String_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_functionContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR, 0) +} + +func (s *String_functionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *String_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *String_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *String_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *String_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *String_functionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *String_functionContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CHAR, 0) +} + +func (s *String_functionContext) Table_element() ITable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *String_functionContext) Standard_function() IStandard_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_functionContext) +} + +func (s *String_functionContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *String_functionContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *String_functionContext) DECODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECODE, 0) +} + +func (s *String_functionContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *String_functionContext) CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHR, 0) +} + +func (s *String_functionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *String_functionContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *String_functionContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *String_functionContext) NVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL, 0) +} + +func (s *String_functionContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *String_functionContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *String_functionContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *String_functionContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *String_functionContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *String_functionContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DATE, 0) +} + +func (s *String_functionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *String_functionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *String_functionContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *String_functionContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *String_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterString_function(s) + } +} + +func (s *String_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_function(s) + } +} + +func (s *String_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitString_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) String_function() (localctx IString_functionContext) { + localctx = NewString_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2130, PlSqlParserRULE_string_function) + var _la int + + p.SetState(17797) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUBSTR: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17711) + p.Match(PlSqlParserSUBSTR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17712) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17713) + p.Expression() + } + { + p.SetState(17714) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17715) + p.Expression() + } + p.SetState(17718) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(17716) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17717) + p.Expression() + } + + } + { + p.SetState(17720) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTO_CHAR: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17722) + p.Match(PlSqlParserTO_CHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17723) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17727) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2429, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17724) + p.Table_element() + } + + case 2: + { + p.SetState(17725) + p.Standard_function() + } + + case 3: + { + p.SetState(17726) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17731) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2430, p.GetParserRuleContext()) == 1 { + { + p.SetState(17729) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17730) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17735) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(17733) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17734) + p.Quoted_string() + } + + } + { + p.SetState(17737) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECODE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17739) + p.Match(PlSqlParserDECODE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17740) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17741) + p.Expressions() + } + { + p.SetState(17742) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHR: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17744) + p.Match(PlSqlParserCHR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17745) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17746) + p.concatenation(0) + } + { + p.SetState(17747) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17748) + p.Match(PlSqlParserNCHAR_CS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17749) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNVL: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17751) + p.Match(PlSqlParserNVL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17752) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17753) + p.Expression() + } + { + p.SetState(17754) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17755) + p.Expression() + } + { + p.SetState(17756) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRIM: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(17758) + p.Match(PlSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17759) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17767) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2434, p.GetParserRuleContext()) == 1 { + p.SetState(17761) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2432, p.GetParserRuleContext()) == 1 { + { + p.SetState(17760) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBOTH || _la == PlSqlParserLEADING || _la == PlSqlParserTRAILING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(17763) + p.Quoted_string() + } + + } + { + p.SetState(17766) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17769) + p.concatenation(0) + } + { + p.SetState(17770) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTO_DATE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(17772) + p.Match(PlSqlParserTO_DATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17773) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17777) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2435, p.GetParserRuleContext()) { + case 1: + { + p.SetState(17774) + p.Table_element() + } + + case 2: + { + p.SetState(17775) + p.Standard_function() + } + + case 3: + { + p.SetState(17776) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(17785) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(17779) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17780) + p.concatenation(0) + } + { + p.SetState(17781) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17782) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17783) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17793) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(17787) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17788) + p.Quoted_string() + } + p.SetState(17791) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(17789) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17790) + p.Quoted_string() + } + + } + + } + { + p.SetState(17795) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IStandard_functionContext is an interface to support dynamic dispatch. +type IStandard_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + String_function() IString_functionContext + Numeric_function_wrapper() INumeric_function_wrapperContext + Json_function() IJson_functionContext + Other_function() IOther_functionContext + + // IsStandard_functionContext differentiates from other interfaces. + IsStandard_functionContext() +} + +type Standard_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_functionContext() *Standard_functionContext { + var p = new(Standard_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_function + return p +} + +func InitEmptyStandard_functionContext(p *Standard_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_function +} + +func (*Standard_functionContext) IsStandard_functionContext() {} + +func NewStandard_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_functionContext { + var p = new(Standard_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_function + + return p +} + +func (s *Standard_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_functionContext) String_function() IString_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_functionContext) +} + +func (s *Standard_functionContext) Numeric_function_wrapper() INumeric_function_wrapperContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_function_wrapperContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_function_wrapperContext) +} + +func (s *Standard_functionContext) Json_function() IJson_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_functionContext) +} + +func (s *Standard_functionContext) Other_function() IOther_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOther_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOther_functionContext) +} + +func (s *Standard_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_function(s) + } +} + +func (s *Standard_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_function(s) + } +} + +func (s *Standard_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStandard_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Standard_function() (localctx IStandard_functionContext) { + localctx = NewStandard_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2132, PlSqlParserRULE_standard_function) + p.SetState(17803) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2440, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17799) + p.String_function() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17800) + p.Numeric_function_wrapper() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17801) + p.Json_function() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17802) + p.Other_function() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_functionContext is an interface to support dynamic dispatch. +type IJson_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_ARRAY() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllJson_array_element() []IJson_array_elementContext + Json_array_element(i int) IJson_array_elementContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Json_on_null_clause() IJson_on_null_clauseContext + Json_return_clause() IJson_return_clauseContext + STRICT() antlr.TerminalNode + JSON_ARRAYAGG() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + JSON_OBJECT() antlr.TerminalNode + Json_object_content() IJson_object_contentContext + JSON_OBJECTAGG() antlr.TerminalNode + VALUE() antlr.TerminalNode + KEY() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + RETURNING() antlr.TerminalNode + WITH() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + ABSENT() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + JSON_QUERY() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + Json_query_returning_clause() IJson_query_returning_clauseContext + Json_query_wrapper_clause() IJson_query_wrapper_clauseContext + Json_query_on_error_clause() IJson_query_on_error_clauseContext + Json_query_on_empty_clause() IJson_query_on_empty_clauseContext + JSON_SERIALIZE() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + PRETTY() antlr.TerminalNode + ASCII() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + EMPTY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + JSON_TRANSFORM() antlr.TerminalNode + AllJson_transform_op() []IJson_transform_opContext + Json_transform_op(i int) IJson_transform_opContext + JSON_VALUE() antlr.TerminalNode + Json_value_return_clause() IJson_value_return_clauseContext + Json_value_on_mismatch_clause() IJson_value_on_mismatch_clauseContext + AllDEFAULT() []antlr.TerminalNode + DEFAULT(i int) antlr.TerminalNode + AllLiteral() []ILiteralContext + Literal(i int) ILiteralContext + + // IsJson_functionContext differentiates from other interfaces. + IsJson_functionContext() +} + +type Json_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_functionContext() *Json_functionContext { + var p = new(Json_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_function + return p +} + +func InitEmptyJson_functionContext(p *Json_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_function +} + +func (*Json_functionContext) IsJson_functionContext() {} + +func NewJson_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_functionContext { + var p = new(Json_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_function + + return p +} + +func (s *Json_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_functionContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAY, 0) +} + +func (s *Json_functionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Json_functionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Json_functionContext) AllJson_array_element() []IJson_array_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_array_elementContext); ok { + len++ + } + } + + tst := make([]IJson_array_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_array_elementContext); ok { + tst[i] = t.(IJson_array_elementContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Json_array_element(i int) IJson_array_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_array_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_array_elementContext) +} + +func (s *Json_functionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Json_functionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Json_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_functionContext) Json_on_null_clause() IJson_on_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_on_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_on_null_clauseContext) +} + +func (s *Json_functionContext) Json_return_clause() IJson_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_return_clauseContext) +} + +func (s *Json_functionContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Json_functionContext) JSON_ARRAYAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAYAGG, 0) +} + +func (s *Json_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_functionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_functionContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_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 *Json_functionContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECT, 0) +} + +func (s *Json_functionContext) Json_object_content() IJson_object_contentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_object_contentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_object_contentContext) +} + +func (s *Json_functionContext) JSON_OBJECTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECTAGG, 0) +} + +func (s *Json_functionContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Json_functionContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Json_functionContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_functionContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_functionContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_functionContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_functionContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_functionContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Json_functionContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Json_functionContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Json_functionContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_functionContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_functionContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_functionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_functionContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_functionContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_functionContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_QUERY, 0) +} + +func (s *Json_functionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_functionContext) Json_query_returning_clause() IJson_query_returning_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_returning_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_returning_clauseContext) +} + +func (s *Json_functionContext) Json_query_wrapper_clause() IJson_query_wrapper_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_wrapper_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_wrapper_clauseContext) +} + +func (s *Json_functionContext) Json_query_on_error_clause() IJson_query_on_error_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_error_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_error_clauseContext) +} + +func (s *Json_functionContext) Json_query_on_empty_clause() IJson_query_on_empty_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_empty_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_empty_clauseContext) +} + +func (s *Json_functionContext) JSON_SERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_SERIALIZE, 0) +} + +func (s *Json_functionContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_functionContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Json_functionContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_functionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_functionContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_functionContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_functionContext) EMPTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, 0) +} + +func (s *Json_functionContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_functionContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_functionContext) JSON_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TRANSFORM, 0) +} + +func (s *Json_functionContext) AllJson_transform_op() []IJson_transform_opContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_transform_opContext); ok { + len++ + } + } + + tst := make([]IJson_transform_opContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_transform_opContext); ok { + tst[i] = t.(IJson_transform_opContext) + i++ + } + } + + return tst +} + +func (s *Json_functionContext) Json_transform_op(i int) IJson_transform_opContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_transform_opContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_transform_opContext) +} + +func (s *Json_functionContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_VALUE, 0) +} + +func (s *Json_functionContext) Json_value_return_clause() IJson_value_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_clauseContext) +} + +func (s *Json_functionContext) Json_value_on_mismatch_clause() IJson_value_on_mismatch_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_on_mismatch_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_on_mismatch_clauseContext) +} + +func (s *Json_functionContext) AllDEFAULT() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDEFAULT) +} + +func (s *Json_functionContext) DEFAULT(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, i) +} + +func (s *Json_functionContext) 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 *Json_functionContext) 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 *Json_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_function(s) + } +} + +func (s *Json_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_function(s) + } +} + +func (s *Json_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_function() (localctx IJson_functionContext) { + localctx = NewJson_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2134, PlSqlParserRULE_json_function) + var _la int + + p.SetState(17995) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserJSON_ARRAY: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(17805) + p.Match(PlSqlParserJSON_ARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17806) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17807) + p.Json_array_element() + } + p.SetState(17812) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17808) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17809) + p.Json_array_element() + } + + p.SetState(17814) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(17816) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(17815) + p.Json_on_null_clause() + } + + } + p.SetState(17819) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(17818) + p.Json_return_clause() + } + + } + p.SetState(17822) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(17821) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17824) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_ARRAYAGG: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(17826) + p.Match(PlSqlParserJSON_ARRAYAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17827) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17828) + p.Expression() + } + p.SetState(17831) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(17829) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17830) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17834) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(17833) + p.Order_by_clause() + } + + } + p.SetState(17837) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(17836) + p.Json_on_null_clause() + } + + } + p.SetState(17840) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(17839) + p.Json_return_clause() + } + + } + p.SetState(17843) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(17842) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17845) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_OBJECT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(17847) + p.Match(PlSqlParserJSON_OBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17848) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17849) + p.Json_object_content() + } + { + p.SetState(17850) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_OBJECTAGG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(17852) + p.Match(PlSqlParserJSON_OBJECTAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17853) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17855) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2450, p.GetParserRuleContext()) == 1 { + { + p.SetState(17854) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(17857) + p.Expression() + } + { + p.SetState(17858) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17859) + p.Expression() + } + p.SetState(17863) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(17860) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABSENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(17861) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17862) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(17865) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17877) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + { + p.SetState(17866) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(17867) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17868) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17870) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(17869) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(17872) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + { + p.SetState(17875) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + { + p.SetState(17876) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(17882) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(17881) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17887) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(17884) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17885) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17886) + p.Match(PlSqlParserKEYS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17889) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_QUERY: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(17891) + p.Match(PlSqlParserJSON_QUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17892) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17893) + p.Expression() + } + p.SetState(17896) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(17894) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17895) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17898) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17899) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17901) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2459, p.GetParserRuleContext()) == 1 { + { + p.SetState(17900) + p.Json_query_returning_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17904) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(17903) + p.Json_query_wrapper_clause() + } + + } + p.SetState(17907) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2461, p.GetParserRuleContext()) == 1 { + { + p.SetState(17906) + p.Json_query_on_error_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17910) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + { + p.SetState(17909) + p.Json_query_on_empty_clause() + } + + } + { + p.SetState(17912) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_SERIALIZE: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(17914) + p.Match(PlSqlParserJSON_SERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17915) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17916) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17919) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(17917) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17918) + p.Json_query_return_type() + } + + } + p.SetState(17922) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRETTY { + { + p.SetState(17921) + p.Match(PlSqlParserPRETTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17925) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(17924) + p.Match(PlSqlParserASCII) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17928) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTRUNCATE { + { + p.SetState(17927) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17938) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ { + p.SetState(17934) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNULL_: + { + p.SetState(17930) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserERROR: + { + p.SetState(17931) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEMPTY: + { + p.SetState(17932) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17933) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserARRAY || _la == PlSqlParserOBJECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(17936) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17937) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(17940) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_TRANSFORM: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(17941) + p.Match(PlSqlParserJSON_TRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17942) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17943) + p.Expression() + } + { + p.SetState(17944) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17945) + p.Json_transform_op() + } + p.SetState(17950) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17946) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17947) + p.Json_transform_op() + } + + p.SetState(17952) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(17953) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserJSON_VALUE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(17955) + p.Match(PlSqlParserJSON_VALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17956) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17957) + p.Expression() + } + p.SetState(17960) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2470, p.GetParserRuleContext()) == 1 { + { + p.SetState(17958) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17959) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17993) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2478, p.GetParserRuleContext()) == 1 { + { + p.SetState(17962) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(17964) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(17963) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(17967) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(17966) + p.Json_value_return_clause() + } + + } + p.SetState(17977) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2474, p.GetParserRuleContext()) == 1 { + p.SetState(17973) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserERROR: + { + p.SetState(17969) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNULL_: + { + p.SetState(17970) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(17971) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17972) + p.Literal() + } + + case PlSqlParserON: + + default: + } + { + p.SetState(17975) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17976) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17987) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2476, p.GetParserRuleContext()) == 1 { + p.SetState(17983) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserERROR: + { + p.SetState(17979) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNULL_: + { + p.SetState(17980) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + { + p.SetState(17981) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17982) + p.Literal() + } + + case PlSqlParserON: + + default: + } + { + p.SetState(17985) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17986) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(17990) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(17989) + p.Json_value_on_mismatch_clause() + } + + } + { + p.SetState(17992) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// IJson_object_contentContext is an interface to support dynamic dispatch. +type IJson_object_contentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllJson_object_entry() []IJson_object_entryContext + Json_object_entry(i int) IJson_object_entryContext + ASTERISK() antlr.TerminalNode + Json_on_null_clause() IJson_on_null_clauseContext + Json_return_clause() IJson_return_clauseContext + STRICT() antlr.TerminalNode + WITH() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + KEYS() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_object_contentContext differentiates from other interfaces. + IsJson_object_contentContext() +} + +type Json_object_contentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_object_contentContext() *Json_object_contentContext { + var p = new(Json_object_contentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_content + return p +} + +func InitEmptyJson_object_contentContext(p *Json_object_contentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_content +} + +func (*Json_object_contentContext) IsJson_object_contentContext() {} + +func NewJson_object_contentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_object_contentContext { + var p = new(Json_object_contentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_object_content + + return p +} + +func (s *Json_object_contentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_object_contentContext) AllJson_object_entry() []IJson_object_entryContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_object_entryContext); ok { + len++ + } + } + + tst := make([]IJson_object_entryContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_object_entryContext); ok { + tst[i] = t.(IJson_object_entryContext) + i++ + } + } + + return tst +} + +func (s *Json_object_contentContext) Json_object_entry(i int) IJson_object_entryContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_object_entryContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_object_entryContext) +} + +func (s *Json_object_contentContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Json_object_contentContext) Json_on_null_clause() IJson_on_null_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_on_null_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_on_null_clauseContext) +} + +func (s *Json_object_contentContext) Json_return_clause() IJson_return_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_return_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_return_clauseContext) +} + +func (s *Json_object_contentContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Json_object_contentContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_object_contentContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Json_object_contentContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Json_object_contentContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_object_contentContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_object_contentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_object_contentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_object_contentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_object_content(s) + } +} + +func (s *Json_object_contentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_object_content(s) + } +} + +func (s *Json_object_contentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_object_content(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_object_content() (localctx IJson_object_contentContext) { + localctx = NewJson_object_contentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2136, PlSqlParserRULE_json_object_content) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNOT, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(17997) + p.Json_object_entry() + } + p.SetState(18002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(17998) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(17999) + p.Json_object_entry() + } + + p.SetState(18004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case PlSqlParserASTERISK: + { + p.SetState(18005) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(18009) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserABSENT || _la == PlSqlParserNULL_ { + { + p.SetState(18008) + p.Json_on_null_clause() + } + + } + p.SetState(18012) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18011) + p.Json_return_clause() + } + + } + p.SetState(18015) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSTRICT { + { + p.SetState(18014) + p.Match(PlSqlParserSTRICT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18020) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18017) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18018) + p.Match(PlSqlParserUNIQUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18019) + p.Match(PlSqlParserKEYS) + 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_object_entryContext is an interface to support dynamic dispatch. +type IJson_object_entryContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + KEY() antlr.TerminalNode + VALUE() antlr.TerminalNode + IS() antlr.TerminalNode + COLON() antlr.TerminalNode + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + Identifier() IIdentifierContext + + // IsJson_object_entryContext differentiates from other interfaces. + IsJson_object_entryContext() +} + +type Json_object_entryContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_object_entryContext() *Json_object_entryContext { + var p = new(Json_object_entryContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_entry + return p +} + +func InitEmptyJson_object_entryContext(p *Json_object_entryContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_object_entry +} + +func (*Json_object_entryContext) IsJson_object_entryContext() {} + +func NewJson_object_entryContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_object_entryContext { + var p = new(Json_object_entryContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_object_entry + + return p +} + +func (s *Json_object_entryContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_object_entryContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Json_object_entryContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_object_entryContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Json_object_entryContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Json_object_entryContext) IS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS, 0) +} + +func (s *Json_object_entryContext) COLON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, 0) +} + +func (s *Json_object_entryContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_object_entryContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_object_entryContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Json_object_entryContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_object_entryContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_object_entryContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_object_entry(s) + } +} + +func (s *Json_object_entryContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_object_entry(s) + } +} + +func (s *Json_object_entryContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_object_entry(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_object_entry() (localctx IJson_object_entryContext) { + localctx = NewJson_object_entryContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2138, PlSqlParserRULE_json_object_entry) + var _la int + + p.SetState(18039) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2489, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(18023) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2486, p.GetParserRuleContext()) == 1 { + { + p.SetState(18022) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18025) + p.Expression() + } + p.SetState(18027) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2487, p.GetParserRuleContext()) == 1 { + { + p.SetState(18026) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIS || _la == PlSqlParserVALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18029) + p.Expression() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18031) + p.Expression() + } + { + p.SetState(18032) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18033) + p.Expression() + } + p.SetState(18036) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18034) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18035) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18038) + p.Identifier() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_table_clauseContext is an interface to support dynamic dispatch. +type IJson_table_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + JSON_TABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + COMMA() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + AllEMPTY() []antlr.TerminalNode + EMPTY(i int) antlr.TerminalNode + Json_column_clause() IJson_column_clauseContext + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + + // IsJson_table_clauseContext differentiates from other interfaces. + IsJson_table_clauseContext() +} + +type Json_table_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_table_clauseContext() *Json_table_clauseContext { + var p = new(Json_table_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_table_clause + return p +} + +func InitEmptyJson_table_clauseContext(p *Json_table_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_table_clause +} + +func (*Json_table_clauseContext) IsJson_table_clauseContext() {} + +func NewJson_table_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_table_clauseContext { + var p = new(Json_table_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_table_clause + + return p +} + +func (s *Json_table_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_table_clauseContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TABLE, 0) +} + +func (s *Json_table_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_table_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_table_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_table_clauseContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_table_clauseContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_table_clauseContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Json_table_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_table_clauseContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_table_clauseContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_table_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_table_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_table_clauseContext) AllEMPTY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEMPTY) +} + +func (s *Json_table_clauseContext) EMPTY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, i) +} + +func (s *Json_table_clauseContext) Json_column_clause() IJson_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_clauseContext) +} + +func (s *Json_table_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_table_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_table_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_table_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_table_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_table_clause(s) + } +} + +func (s *Json_table_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_table_clause(s) + } +} + +func (s *Json_table_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_table_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_table_clause() (localctx IJson_table_clauseContext) { + localctx = NewJson_table_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2140, PlSqlParserRULE_json_table_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18041) + p.Match(PlSqlParserJSON_TABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18042) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18043) + p.Expression() + } + p.SetState(18046) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18044) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18045) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18048) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18049) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18055) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2492, p.GetParserRuleContext()) == 1 { + { + p.SetState(18052) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18053) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18054) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18060) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY || _la == PlSqlParserNULL_ { + { + p.SetState(18057) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEMPTY || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18058) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18059) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18063) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMNS { + { + p.SetState(18062) + p.Json_column_clause() + } + + } + { + p.SetState(18065) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_array_elementContext is an interface to support dynamic dispatch. +type IJson_array_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + CHAR_STRING() antlr.TerminalNode + NULL_() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + Json_function() IJson_functionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + + // IsJson_array_elementContext differentiates from other interfaces. + IsJson_array_elementContext() +} + +type Json_array_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_array_elementContext() *Json_array_elementContext { + var p = new(Json_array_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_array_element + return p +} + +func InitEmptyJson_array_elementContext(p *Json_array_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_array_element +} + +func (*Json_array_elementContext) IsJson_array_elementContext() {} + +func NewJson_array_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_array_elementContext { + var p = new(Json_array_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_array_element + + return p +} + +func (s *Json_array_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_array_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_array_elementContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_array_elementContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_array_elementContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_array_elementContext) Json_function() IJson_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_functionContext) +} + +func (s *Json_array_elementContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_array_elementContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_array_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_array_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_array_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_array_element(s) + } +} + +func (s *Json_array_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_array_element(s) + } +} + +func (s *Json_array_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_array_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_array_element() (localctx IJson_array_elementContext) { + localctx = NewJson_array_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2142, PlSqlParserRULE_json_array_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2495, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18067) + p.Expression() + } + + case 2: + { + p.SetState(18068) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(18069) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(18070) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + { + p.SetState(18071) + p.Json_function() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(18076) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18074) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18075) + p.Match(PlSqlParserJSON) + 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_on_null_clauseContext is an interface to support dynamic dispatch. +type IJson_on_null_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + ABSENT() antlr.TerminalNode + + // IsJson_on_null_clauseContext differentiates from other interfaces. + IsJson_on_null_clauseContext() +} + +type Json_on_null_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_on_null_clauseContext() *Json_on_null_clauseContext { + var p = new(Json_on_null_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_on_null_clause + return p +} + +func InitEmptyJson_on_null_clauseContext(p *Json_on_null_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_on_null_clause +} + +func (*Json_on_null_clauseContext) IsJson_on_null_clauseContext() {} + +func NewJson_on_null_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_on_null_clauseContext { + var p = new(Json_on_null_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_on_null_clause + + return p +} + +func (s *Json_on_null_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_on_null_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_on_null_clauseContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_on_null_clauseContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_on_null_clauseContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Json_on_null_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_on_null_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_on_null_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_on_null_clause(s) + } +} + +func (s *Json_on_null_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_on_null_clause(s) + } +} + +func (s *Json_on_null_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_on_null_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_on_null_clause() (localctx IJson_on_null_clauseContext) { + localctx = NewJson_on_null_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2144, PlSqlParserRULE_json_on_null_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18078) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserABSENT || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18079) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18080) + p.Match(PlSqlParserNULL_) + 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_return_clauseContext is an interface to support dynamic dispatch. +type IJson_return_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + + // IsJson_return_clauseContext differentiates from other interfaces. + IsJson_return_clauseContext() +} + +type Json_return_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_return_clauseContext() *Json_return_clauseContext { + var p = new(Json_return_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_return_clause + return p +} + +func InitEmptyJson_return_clauseContext(p *Json_return_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_return_clause +} + +func (*Json_return_clauseContext) IsJson_return_clauseContext() {} + +func NewJson_return_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_return_clauseContext { + var p = new(Json_return_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_return_clause + + return p +} + +func (s *Json_return_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_return_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_return_clauseContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_return_clauseContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_return_clauseContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_return_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_return_clauseContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_return_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_return_clauseContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_return_clauseContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_return_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_return_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_return_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_return_clause(s) + } +} + +func (s *Json_return_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_return_clause(s) + } +} + +func (s *Json_return_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_return_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_return_clause() (localctx IJson_return_clauseContext) { + localctx = NewJson_return_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2146, PlSqlParserRULE_json_return_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18082) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18094) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + { + p.SetState(18083) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18090) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18084) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18085) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18087) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(18086) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18089) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + { + p.SetState(18092) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + { + p.SetState(18093) + p.Match(PlSqlParserBLOB) + 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 +} + +// IJson_transform_opContext is an interface to support dynamic dispatch. +type IJson_transform_opContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + REMOVE() antlr.TerminalNode + AllCHAR_STRING() []antlr.TerminalNode + CHAR_STRING(i int) antlr.TerminalNode + AllON() []antlr.TerminalNode + ON(i int) antlr.TerminalNode + MISSING() antlr.TerminalNode + AllIGNORE() []antlr.TerminalNode + IGNORE(i int) antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + INSERT() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + EXISTING() antlr.TerminalNode + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + REPLACE() antlr.TerminalNode + CREATE() antlr.TerminalNode + Expression() IExpressionContext + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + APPEND() antlr.TerminalNode + SET() antlr.TerminalNode + + // IsJson_transform_opContext differentiates from other interfaces. + IsJson_transform_opContext() +} + +type Json_transform_opContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_transform_opContext() *Json_transform_opContext { + var p = new(Json_transform_opContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_transform_op + return p +} + +func InitEmptyJson_transform_opContext(p *Json_transform_opContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_transform_op +} + +func (*Json_transform_opContext) IsJson_transform_opContext() {} + +func NewJson_transform_opContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_transform_opContext { + var p = new(Json_transform_opContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_transform_op + + return p +} + +func (s *Json_transform_opContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_transform_opContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Json_transform_opContext) AllCHAR_STRING() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCHAR_STRING) +} + +func (s *Json_transform_opContext) CHAR_STRING(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, i) +} + +func (s *Json_transform_opContext) AllON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserON) +} + +func (s *Json_transform_opContext) ON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserON, i) +} + +func (s *Json_transform_opContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Json_transform_opContext) AllIGNORE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserIGNORE) +} + +func (s *Json_transform_opContext) IGNORE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, i) +} + +func (s *Json_transform_opContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_transform_opContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_transform_opContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Json_transform_opContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Json_transform_opContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Json_transform_opContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Json_transform_opContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Json_transform_opContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Json_transform_opContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *Json_transform_opContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_transform_opContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_transform_opContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_transform_opContext) APPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND, 0) +} + +func (s *Json_transform_opContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Json_transform_opContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_transform_opContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_transform_opContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_transform_op(s) + } +} + +func (s *Json_transform_opContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_transform_op(s) + } +} + +func (s *Json_transform_opContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_transform_op(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_transform_op() (localctx IJson_transform_opContext) { + localctx = NewJson_transform_opContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2148, PlSqlParserRULE_json_transform_op) + var _la int + + p.SetState(18183) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2517, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18096) + p.Match(PlSqlParserREMOVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18097) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18103) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserON { + p.SetState(18099) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE { + { + p.SetState(18098) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18101) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18102) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18105) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18106) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18107) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18108) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18112) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2502, p.GetParserRuleContext()) == 1 { + { + p.SetState(18109) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18110) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18111) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18119) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON || _la == PlSqlParserREMOVE { + p.SetState(18115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserREMOVE { + { + p.SetState(18114) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserREMOVE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18117) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18118) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18121) + p.Match(PlSqlParserREPLACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18122) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18123) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18124) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18128) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2505, p.GetParserRuleContext()) == 1 { + { + p.SetState(18125) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18126) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18127) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18135) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(18131) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(18130) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18133) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18134) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18137) + p.Expression() + } + p.SetState(18140) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18138) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18139) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18142) + p.Match(PlSqlParserAPPEND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18143) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18144) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18145) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18149) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2509, p.GetParserRuleContext()) == 1 { + { + p.SetState(18146) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18147) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18148) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18156) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(18152) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(18151) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18154) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18155) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18158) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18159) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18160) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18161) + p.Expression() + } + p.SetState(18164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFORMAT { + { + p.SetState(18162) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18163) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18169) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2513, p.GetParserRuleContext()) == 1 { + { + p.SetState(18166) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserREPLACE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18167) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18168) + p.Match(PlSqlParserEXISTING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18174) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2514, p.GetParserRuleContext()) == 1 { + { + p.SetState(18171) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserERROR || _la == PlSqlParserIGNORE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18172) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18173) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + p.SetState(18177) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_ { + { + p.SetState(18176) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18179) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18180) + p.Match(PlSqlParserNULL_) + 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 +} + +// IJson_column_clauseContext is an interface to support dynamic dispatch. +type IJson_column_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COLUMNS() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllJson_column_definition() []IJson_column_definitionContext + Json_column_definition(i int) IJson_column_definitionContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsJson_column_clauseContext differentiates from other interfaces. + IsJson_column_clauseContext() +} + +type Json_column_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_column_clauseContext() *Json_column_clauseContext { + var p = new(Json_column_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_clause + return p +} + +func InitEmptyJson_column_clauseContext(p *Json_column_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_clause +} + +func (*Json_column_clauseContext) IsJson_column_clauseContext() {} + +func NewJson_column_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_column_clauseContext { + var p = new(Json_column_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_column_clause + + return p +} + +func (s *Json_column_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_column_clauseContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Json_column_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_column_clauseContext) AllJson_column_definition() []IJson_column_definitionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IJson_column_definitionContext); ok { + len++ + } + } + + tst := make([]IJson_column_definitionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IJson_column_definitionContext); ok { + tst[i] = t.(IJson_column_definitionContext) + i++ + } + } + + return tst +} + +func (s *Json_column_clauseContext) Json_column_definition(i int) IJson_column_definitionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_definitionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_definitionContext) +} + +func (s *Json_column_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_column_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Json_column_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Json_column_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_column_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_column_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_column_clause(s) + } +} + +func (s *Json_column_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_column_clause(s) + } +} + +func (s *Json_column_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_column_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_column_clause() (localctx IJson_column_clauseContext) { + localctx = NewJson_column_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2150, PlSqlParserRULE_json_column_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18185) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18186) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18187) + p.Json_column_definition() + } + p.SetState(18192) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18188) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18189) + p.Json_column_definition() + } + + p.SetState(18194) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18195) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IJson_column_definitionContext is an interface to support dynamic dispatch. +type IJson_column_definitionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Json_value_return_type() IJson_value_return_typeContext + PATH() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + Json_query_on_error_clause() IJson_query_on_error_clauseContext + Json_query_on_empty_clause() IJson_query_on_empty_clauseContext + EXISTS() antlr.TerminalNode + FORMAT() antlr.TerminalNode + JSON() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + Json_query_wrapper_clause() IJson_query_wrapper_clauseContext + NESTED() antlr.TerminalNode + Json_column_clause() IJson_column_clauseContext + LEFT_BRACKET() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + RIGHT_BRACKET() antlr.TerminalNode + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + + // IsJson_column_definitionContext differentiates from other interfaces. + IsJson_column_definitionContext() +} + +type Json_column_definitionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_column_definitionContext() *Json_column_definitionContext { + var p = new(Json_column_definitionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_definition + return p +} + +func InitEmptyJson_column_definitionContext(p *Json_column_definitionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_column_definition +} + +func (*Json_column_definitionContext) IsJson_column_definitionContext() {} + +func NewJson_column_definitionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_column_definitionContext { + var p = new(Json_column_definitionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_column_definition + + return p +} + +func (s *Json_column_definitionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_column_definitionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_column_definitionContext) Json_value_return_type() IJson_value_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_typeContext) +} + +func (s *Json_column_definitionContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Json_column_definitionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Json_column_definitionContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_column_definitionContext) Json_query_on_error_clause() IJson_query_on_error_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_error_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_error_clauseContext) +} + +func (s *Json_column_definitionContext) Json_query_on_empty_clause() IJson_query_on_empty_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_on_empty_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_on_empty_clauseContext) +} + +func (s *Json_column_definitionContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Json_column_definitionContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Json_column_definitionContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Json_column_definitionContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_column_definitionContext) Json_query_wrapper_clause() IJson_query_wrapper_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_wrapper_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_wrapper_clauseContext) +} + +func (s *Json_column_definitionContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Json_column_definitionContext) Json_column_clause() IJson_column_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_column_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_column_clauseContext) +} + +func (s *Json_column_definitionContext) LEFT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_BRACKET, 0) +} + +func (s *Json_column_definitionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Json_column_definitionContext) RIGHT_BRACKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_BRACKET, 0) +} + +func (s *Json_column_definitionContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Json_column_definitionContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Json_column_definitionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_column_definitionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_column_definitionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_column_definition(s) + } +} + +func (s *Json_column_definitionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_column_definition(s) + } +} + +func (s *Json_column_definitionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_column_definition(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_column_definition() (localctx IJson_column_definitionContext) { + localctx = NewJson_column_definitionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2152, PlSqlParserRULE_json_column_definition) + var _la int + + p.SetState(18250) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2530, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18197) + p.Expression() + } + p.SetState(18199) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2519, p.GetParserRuleContext()) == 1 { + { + p.SetState(18198) + p.Json_value_return_type() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18211) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXISTS, PlSqlParserPATH: + p.SetState(18202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEXISTS { + { + p.SetState(18201) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18204) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18205) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUNCATE: + { + p.SetState(18206) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18209) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPATH { + { + p.SetState(18207) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18208) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserEMPTY, PlSqlParserERROR, PlSqlParserNULL_, PlSqlParserON, PlSqlParserRIGHT_PAREN, PlSqlParserCOMMA: + + default: + } + p.SetState(18214) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2523, p.GetParserRuleContext()) == 1 { + { + p.SetState(18213) + p.Json_query_on_error_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18217) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserEMPTY || _la == PlSqlParserERROR || _la == PlSqlParserNULL_ || _la == PlSqlParserON { + { + p.SetState(18216) + p.Json_query_on_empty_clause() + } + + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18219) + p.Expression() + } + p.SetState(18221) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBLOB || _la == PlSqlParserCLOB || _la == PlSqlParserVARCHAR2 { + { + p.SetState(18220) + p.Json_query_return_type() + } + + } + p.SetState(18224) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserTRUNCATE { + { + p.SetState(18223) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18226) + p.Match(PlSqlParserFORMAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18227) + p.Match(PlSqlParserJSON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18229) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(18228) + p.Json_query_wrapper_clause() + } + + } + { + p.SetState(18231) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18232) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18234) + p.Match(PlSqlParserNESTED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18236) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2528, p.GetParserRuleContext()) == 1 { + { + p.SetState(18235) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18238) + p.Expression() + } + p.SetState(18242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_BRACKET { + { + p.SetState(18239) + p.Match(PlSqlParserLEFT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18240) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18241) + p.Match(PlSqlParserRIGHT_BRACKET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18244) + p.Json_column_clause() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18246) + p.Expression() + } + { + p.SetState(18247) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18248) + p.Match(PlSqlParserORDINALITY) + 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 +} + +// IJson_query_returning_clauseContext is an interface to support dynamic dispatch. +type IJson_query_returning_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + Json_query_return_type() IJson_query_return_typeContext + PRETTY() antlr.TerminalNode + ASCII() antlr.TerminalNode + + // IsJson_query_returning_clauseContext differentiates from other interfaces. + IsJson_query_returning_clauseContext() +} + +type Json_query_returning_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_returning_clauseContext() *Json_query_returning_clauseContext { + var p = new(Json_query_returning_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause + return p +} + +func InitEmptyJson_query_returning_clauseContext(p *Json_query_returning_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause +} + +func (*Json_query_returning_clauseContext) IsJson_query_returning_clauseContext() {} + +func NewJson_query_returning_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_returning_clauseContext { + var p = new(Json_query_returning_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_returning_clause + + return p +} + +func (s *Json_query_returning_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_returning_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_query_returning_clauseContext) Json_query_return_type() IJson_query_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_query_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_query_return_typeContext) +} + +func (s *Json_query_returning_clauseContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Json_query_returning_clauseContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_query_returning_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_returning_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_returning_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_returning_clause(s) + } +} + +func (s *Json_query_returning_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_returning_clause(s) + } +} + +func (s *Json_query_returning_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_query_returning_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_query_returning_clause() (localctx IJson_query_returning_clauseContext) { + localctx = NewJson_query_returning_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2154, PlSqlParserRULE_json_query_returning_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(18254) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRETURNING { + { + p.SetState(18252) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18253) + p.Json_query_return_type() + } + + } + p.SetState(18257) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRETTY { + { + p.SetState(18256) + p.Match(PlSqlParserPRETTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18260) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(18259) + p.Match(PlSqlParserASCII) + 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_query_return_typeContext is an interface to support dynamic dispatch. +type IJson_query_return_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARCHAR2() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + BLOB() antlr.TerminalNode + + // IsJson_query_return_typeContext differentiates from other interfaces. + IsJson_query_return_typeContext() +} + +type Json_query_return_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_return_typeContext() *Json_query_return_typeContext { + var p = new(Json_query_return_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_return_type + return p +} + +func InitEmptyJson_query_return_typeContext(p *Json_query_return_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_return_type +} + +func (*Json_query_return_typeContext) IsJson_query_return_typeContext() {} + +func NewJson_query_return_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_return_typeContext { + var p = new(Json_query_return_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_return_type + + return p +} + +func (s *Json_query_return_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_return_typeContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_query_return_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_query_return_typeContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_query_return_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_query_return_typeContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_query_return_typeContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_query_return_typeContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_query_return_typeContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Json_query_return_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_return_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_return_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_return_type(s) + } +} + +func (s *Json_query_return_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_return_type(s) + } +} + +func (s *Json_query_return_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_query_return_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_query_return_type() (localctx IJson_query_return_typeContext) { + localctx = NewJson_query_return_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2156, PlSqlParserRULE_json_query_return_type) + var _la int + + p.SetState(18273) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserVARCHAR2: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18262) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18269) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18263) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18264) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18266) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(18265) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18268) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCLOB: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18271) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18272) + p.Match(PlSqlParserBLOB) + 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 +} + +// IJson_query_wrapper_clauseContext is an interface to support dynamic dispatch. +type IJson_query_wrapper_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITHOUT() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + ARRAY() antlr.TerminalNode + WITH() antlr.TerminalNode + UNCONDITIONAL() antlr.TerminalNode + CONDITIONAL() antlr.TerminalNode + + // IsJson_query_wrapper_clauseContext differentiates from other interfaces. + IsJson_query_wrapper_clauseContext() +} + +type Json_query_wrapper_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_wrapper_clauseContext() *Json_query_wrapper_clauseContext { + var p = new(Json_query_wrapper_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause + return p +} + +func InitEmptyJson_query_wrapper_clauseContext(p *Json_query_wrapper_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause +} + +func (*Json_query_wrapper_clauseContext) IsJson_query_wrapper_clauseContext() {} + +func NewJson_query_wrapper_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_wrapper_clauseContext { + var p = new(Json_query_wrapper_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_wrapper_clause + + return p +} + +func (s *Json_query_wrapper_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_wrapper_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Json_query_wrapper_clauseContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPER, 0) +} + +func (s *Json_query_wrapper_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_wrapper_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_query_wrapper_clauseContext) UNCONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNCONDITIONAL, 0) +} + +func (s *Json_query_wrapper_clauseContext) CONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITIONAL, 0) +} + +func (s *Json_query_wrapper_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_wrapper_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_wrapper_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_wrapper_clause(s) + } +} + +func (s *Json_query_wrapper_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_wrapper_clause(s) + } +} + +func (s *Json_query_wrapper_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_query_wrapper_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_query_wrapper_clause() (localctx IJson_query_wrapper_clauseContext) { + localctx = NewJson_query_wrapper_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2158, PlSqlParserRULE_json_query_wrapper_clause) + var _la int + + p.SetState(18288) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITHOUT: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18275) + p.Match(PlSqlParserWITHOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18277) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserARRAY { + { + p.SetState(18276) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18279) + p.Match(PlSqlParserWRAPPER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWITH: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18280) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18282) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCONDITIONAL || _la == PlSqlParserUNCONDITIONAL { + { + p.SetState(18281) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONDITIONAL || _la == PlSqlParserUNCONDITIONAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(18285) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserARRAY { + { + p.SetState(18284) + p.Match(PlSqlParserARRAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18287) + p.Match(PlSqlParserWRAPPER) + 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 +} + +// IJson_query_on_error_clauseContext is an interface to support dynamic dispatch. +type IJson_query_on_error_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + EMPTY() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsJson_query_on_error_clauseContext differentiates from other interfaces. + IsJson_query_on_error_clauseContext() +} + +type Json_query_on_error_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_on_error_clauseContext() *Json_query_on_error_clauseContext { + var p = new(Json_query_on_error_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause + return p +} + +func InitEmptyJson_query_on_error_clauseContext(p *Json_query_on_error_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause +} + +func (*Json_query_on_error_clauseContext) IsJson_query_on_error_clauseContext() {} + +func NewJson_query_on_error_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_on_error_clauseContext { + var p = new(Json_query_on_error_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_on_error_clause + + return p +} + +func (s *Json_query_on_error_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_on_error_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_query_on_error_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_query_on_error_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_query_on_error_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_query_on_error_clauseContext) EMPTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, 0) +} + +func (s *Json_query_on_error_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_on_error_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_query_on_error_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_on_error_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_on_error_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_on_error_clause(s) + } +} + +func (s *Json_query_on_error_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_on_error_clause(s) + } +} + +func (s *Json_query_on_error_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_query_on_error_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_query_on_error_clause() (localctx IJson_query_on_error_clauseContext) { + localctx = NewJson_query_on_error_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2160, PlSqlParserRULE_json_query_on_error_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(18297) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2541, p.GetParserRuleContext()) == 1 { + { + p.SetState(18290) + p.Match(PlSqlParserERROR) + 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(), 2541, p.GetParserRuleContext()) == 2 { + { + p.SetState(18291) + p.Match(PlSqlParserNULL_) + 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(), 2541, p.GetParserRuleContext()) == 3 { + { + p.SetState(18292) + p.Match(PlSqlParserEMPTY) + 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(), 2541, p.GetParserRuleContext()) == 4 { + { + p.SetState(18293) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18294) + p.Match(PlSqlParserARRAY) + 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(), 2541, p.GetParserRuleContext()) == 5 { + { + p.SetState(18295) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18296) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18299) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18300) + p.Match(PlSqlParserERROR) + 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_query_on_empty_clauseContext is an interface to support dynamic dispatch. +type IJson_query_on_empty_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + AllEMPTY() []antlr.TerminalNode + EMPTY(i int) antlr.TerminalNode + ERROR() antlr.TerminalNode + NULL_() antlr.TerminalNode + ARRAY() antlr.TerminalNode + OBJECT() antlr.TerminalNode + + // IsJson_query_on_empty_clauseContext differentiates from other interfaces. + IsJson_query_on_empty_clauseContext() +} + +type Json_query_on_empty_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_query_on_empty_clauseContext() *Json_query_on_empty_clauseContext { + var p = new(Json_query_on_empty_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause + return p +} + +func InitEmptyJson_query_on_empty_clauseContext(p *Json_query_on_empty_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause +} + +func (*Json_query_on_empty_clauseContext) IsJson_query_on_empty_clauseContext() {} + +func NewJson_query_on_empty_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_query_on_empty_clauseContext { + var p = new(Json_query_on_empty_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_query_on_empty_clause + + return p +} + +func (s *Json_query_on_empty_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_query_on_empty_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_query_on_empty_clauseContext) AllEMPTY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserEMPTY) +} + +func (s *Json_query_on_empty_clauseContext) EMPTY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, i) +} + +func (s *Json_query_on_empty_clauseContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Json_query_on_empty_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_query_on_empty_clauseContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Json_query_on_empty_clauseContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Json_query_on_empty_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_query_on_empty_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_query_on_empty_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_query_on_empty_clause(s) + } +} + +func (s *Json_query_on_empty_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_query_on_empty_clause(s) + } +} + +func (s *Json_query_on_empty_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_query_on_empty_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_query_on_empty_clause() (localctx IJson_query_on_empty_clauseContext) { + localctx = NewJson_query_on_empty_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2162, PlSqlParserRULE_json_query_on_empty_clause) + p.EnterOuterAlt(localctx, 1) + p.SetState(18309) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2542, p.GetParserRuleContext()) == 1 { + { + p.SetState(18302) + p.Match(PlSqlParserERROR) + 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(), 2542, p.GetParserRuleContext()) == 2 { + { + p.SetState(18303) + p.Match(PlSqlParserNULL_) + 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(), 2542, p.GetParserRuleContext()) == 3 { + { + p.SetState(18304) + p.Match(PlSqlParserEMPTY) + 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(), 2542, p.GetParserRuleContext()) == 4 { + { + p.SetState(18305) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18306) + p.Match(PlSqlParserARRAY) + 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(), 2542, p.GetParserRuleContext()) == 5 { + { + p.SetState(18307) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18308) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18311) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18312) + p.Match(PlSqlParserEMPTY) + 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_value_return_clauseContext is an interface to support dynamic dispatch. +type IJson_value_return_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + RETURNING() antlr.TerminalNode + Json_value_return_type() IJson_value_return_typeContext + ASCII() antlr.TerminalNode + + // IsJson_value_return_clauseContext differentiates from other interfaces. + IsJson_value_return_clauseContext() +} + +type Json_value_return_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_return_clauseContext() *Json_value_return_clauseContext { + var p = new(Json_value_return_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_clause + return p +} + +func InitEmptyJson_value_return_clauseContext(p *Json_value_return_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_clause +} + +func (*Json_value_return_clauseContext) IsJson_value_return_clauseContext() {} + +func NewJson_value_return_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_return_clauseContext { + var p = new(Json_value_return_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_return_clause + + return p +} + +func (s *Json_value_return_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_return_clauseContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Json_value_return_clauseContext) Json_value_return_type() IJson_value_return_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IJson_value_return_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IJson_value_return_typeContext) +} + +func (s *Json_value_return_clauseContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Json_value_return_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_return_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_return_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_return_clause(s) + } +} + +func (s *Json_value_return_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_return_clause(s) + } +} + +func (s *Json_value_return_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_value_return_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_value_return_clause() (localctx IJson_value_return_clauseContext) { + localctx = NewJson_value_return_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2164, PlSqlParserRULE_json_value_return_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18314) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18316) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2543, p.GetParserRuleContext()) == 1 { + { + p.SetState(18315) + p.Json_value_return_type() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18319) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserASCII { + { + p.SetState(18318) + p.Match(PlSqlParserASCII) + 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_value_return_typeContext is an interface to support dynamic dispatch. +type IJson_value_return_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VARCHAR2() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + BYTE() antlr.TerminalNode + CHAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + DATE() antlr.TerminalNode + NUMBER() antlr.TerminalNode + AllINTEGER() []antlr.TerminalNode + INTEGER(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + WITH() antlr.TerminalNode + TIMEZONE() antlr.TerminalNode + SDO_GEOMETRY() antlr.TerminalNode + Expression() IExpressionContext + USING() antlr.TerminalNode + CASESENSITIVE() antlr.TerminalNode + MAPPING() antlr.TerminalNode + + // IsJson_value_return_typeContext differentiates from other interfaces. + IsJson_value_return_typeContext() +} + +type Json_value_return_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_return_typeContext() *Json_value_return_typeContext { + var p = new(Json_value_return_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_type + return p +} + +func InitEmptyJson_value_return_typeContext(p *Json_value_return_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_return_type +} + +func (*Json_value_return_typeContext) IsJson_value_return_typeContext() {} + +func NewJson_value_return_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_return_typeContext { + var p = new(Json_value_return_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_return_type + + return p +} + +func (s *Json_value_return_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_return_typeContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Json_value_return_typeContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_value_return_typeContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Json_value_return_typeContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_value_return_typeContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Json_value_return_typeContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Json_value_return_typeContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Json_value_return_typeContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Json_value_return_typeContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Json_value_return_typeContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Json_value_return_typeContext) AllINTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserINTEGER) +} + +func (s *Json_value_return_typeContext) INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, i) +} + +func (s *Json_value_return_typeContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Json_value_return_typeContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Json_value_return_typeContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Json_value_return_typeContext) TIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE, 0) +} + +func (s *Json_value_return_typeContext) SDO_GEOMETRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOMETRY, 0) +} + +func (s *Json_value_return_typeContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Json_value_return_typeContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Json_value_return_typeContext) CASESENSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASESENSITIVE, 0) +} + +func (s *Json_value_return_typeContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Json_value_return_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_return_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_return_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_return_type(s) + } +} + +func (s *Json_value_return_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_return_type(s) + } +} + +func (s *Json_value_return_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_value_return_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_value_return_type() (localctx IJson_value_return_typeContext) { + localctx = NewJson_value_return_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2166, PlSqlParserRULE_json_value_return_type) + var _la int + + p.SetState(18355) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2551, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18321) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18328) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(18322) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18323) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(18324) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18327) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18331) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2547, p.GetParserRuleContext()) == 1 { + { + p.SetState(18330) + p.Match(PlSqlParserTRUNCATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18333) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18334) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18335) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18336) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18337) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18340) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18338) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18339) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18342) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18343) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18346) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITH { + { + p.SetState(18344) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18345) + p.Match(PlSqlParserTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18348) + p.Match(PlSqlParserSDO_GEOMETRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(18349) + p.Expression() + } + p.SetState(18353) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(18350) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18351) + p.Match(PlSqlParserCASESENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18352) + p.Match(PlSqlParserMAPPING) + 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 +} + +// IJson_value_on_mismatch_clauseContext is an interface to support dynamic dispatch. +type IJson_value_on_mismatch_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + MISMATCH() antlr.TerminalNode + IGNORE() antlr.TerminalNode + AllERROR() []antlr.TerminalNode + ERROR(i int) antlr.TerminalNode + NULL_() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + MISSING() antlr.TerminalNode + DATA() antlr.TerminalNode + EXTRA() antlr.TerminalNode + TYPE() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsJson_value_on_mismatch_clauseContext differentiates from other interfaces. + IsJson_value_on_mismatch_clauseContext() +} + +type Json_value_on_mismatch_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyJson_value_on_mismatch_clauseContext() *Json_value_on_mismatch_clauseContext { + var p = new(Json_value_on_mismatch_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause + return p +} + +func InitEmptyJson_value_on_mismatch_clauseContext(p *Json_value_on_mismatch_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause +} + +func (*Json_value_on_mismatch_clauseContext) IsJson_value_on_mismatch_clauseContext() {} + +func NewJson_value_on_mismatch_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Json_value_on_mismatch_clauseContext { + var p = new(Json_value_on_mismatch_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_json_value_on_mismatch_clause + + return p +} + +func (s *Json_value_on_mismatch_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Json_value_on_mismatch_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) MISMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISMATCH, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) AllERROR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserERROR) +} + +func (s *Json_value_on_mismatch_clauseContext) ERROR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, i) +} + +func (s *Json_value_on_mismatch_clauseContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) EXTRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRA, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Json_value_on_mismatch_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Json_value_on_mismatch_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Json_value_on_mismatch_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterJson_value_on_mismatch_clause(s) + } +} + +func (s *Json_value_on_mismatch_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitJson_value_on_mismatch_clause(s) + } +} + +func (s *Json_value_on_mismatch_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitJson_value_on_mismatch_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Json_value_on_mismatch_clause() (localctx IJson_value_on_mismatch_clauseContext) { + localctx = NewJson_value_on_mismatch_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2168, PlSqlParserRULE_json_value_on_mismatch_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18357) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserIGNORE || _la == PlSqlParserNULL_) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18358) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18359) + p.Match(PlSqlParserMISMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18368) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + switch p.GetTokenStream().LA(1) { + case PlSqlParserLEFT_PAREN: + { + p.SetState(18360) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18361) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18362) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXTRA: + { + p.SetState(18363) + p.Match(PlSqlParserEXTRA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18364) + p.Match(PlSqlParserDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTYPE: + { + p.SetState(18365) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18366) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18367) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRIGHT_PAREN: + + default: + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILiteralContext is an interface to support dynamic dispatch. +type ILiteralContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + String_function() IString_functionContext + Numeric() INumericContext + MAXVALUE() 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 = PlSqlParserRULE_literal + return p +} + +func InitEmptyLiteralContext(p *LiteralContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_literal + + return p +} + +func (s *LiteralContext) GetParser() antlr.Parser { return s.parser } + +func (s *LiteralContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *LiteralContext) String_function() IString_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IString_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IString_functionContext) +} + +func (s *LiteralContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *LiteralContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 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.(PlSqlParserListener); ok { + listenerT.EnterLiteral(s) + } +} + +func (s *LiteralContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLiteral(s) + } +} + +func (s *LiteralContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLiteral(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Literal() (localctx ILiteralContext) { + localctx = NewLiteralContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2170, PlSqlParserRULE_literal) + p.SetState(18374) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18370) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHR, PlSqlParserDECODE, PlSqlParserNVL, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserTO_DATE: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18371) + p.String_function() + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18372) + p.Numeric() + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18373) + p.Match(PlSqlParserMAXVALUE) + 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 +} + +// INumeric_function_wrapperContext is an interface to support dynamic dispatch. +type INumeric_function_wrapperContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Numeric_function() INumeric_functionContext + Single_column_for_loop() ISingle_column_for_loopContext + Multi_column_for_loop() IMulti_column_for_loopContext + + // IsNumeric_function_wrapperContext differentiates from other interfaces. + IsNumeric_function_wrapperContext() +} + +type Numeric_function_wrapperContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_function_wrapperContext() *Numeric_function_wrapperContext { + var p = new(Numeric_function_wrapperContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper + return p +} + +func InitEmptyNumeric_function_wrapperContext(p *Numeric_function_wrapperContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper +} + +func (*Numeric_function_wrapperContext) IsNumeric_function_wrapperContext() {} + +func NewNumeric_function_wrapperContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_function_wrapperContext { + var p = new(Numeric_function_wrapperContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_function_wrapper + + return p +} + +func (s *Numeric_function_wrapperContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_function_wrapperContext) Numeric_function() INumeric_functionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_functionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_functionContext) +} + +func (s *Numeric_function_wrapperContext) Single_column_for_loop() ISingle_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISingle_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISingle_column_for_loopContext) +} + +func (s *Numeric_function_wrapperContext) Multi_column_for_loop() IMulti_column_for_loopContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IMulti_column_for_loopContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IMulti_column_for_loopContext) +} + +func (s *Numeric_function_wrapperContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_function_wrapperContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_function_wrapperContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_function_wrapper(s) + } +} + +func (s *Numeric_function_wrapperContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_function_wrapper(s) + } +} + +func (s *Numeric_function_wrapperContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNumeric_function_wrapper(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Numeric_function_wrapper() (localctx INumeric_function_wrapperContext) { + localctx = NewNumeric_function_wrapperContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2172, PlSqlParserRULE_numeric_function_wrapper) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18376) + p.Numeric_function() + } + p.SetState(18379) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2554, p.GetParserRuleContext()) == 1 { + { + p.SetState(18377) + p.Single_column_for_loop() + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2554, p.GetParserRuleContext()) == 2 { + { + p.SetState(18378) + p.Multi_column_for_loop() + } + + } 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 +} + +// INumeric_functionContext is an interface to support dynamic dispatch. +type INumeric_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SUM() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Expression() IExpressionContext + RIGHT_PAREN() antlr.TerminalNode + DISTINCT() antlr.TerminalNode + ALL() antlr.TerminalNode + COUNT() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + Over_clause() IOver_clauseContext + Concatenation() IConcatenationContext + UNIQUE() antlr.TerminalNode + ROUND() antlr.TerminalNode + COMMA() antlr.TerminalNode + UNSIGNED_INTEGER() antlr.TerminalNode + AVG() antlr.TerminalNode + MAX() antlr.TerminalNode + LEAST() antlr.TerminalNode + Expressions() IExpressionsContext + GREATEST() antlr.TerminalNode + + // IsNumeric_functionContext differentiates from other interfaces. + IsNumeric_functionContext() +} + +type Numeric_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_functionContext() *Numeric_functionContext { + var p = new(Numeric_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function + return p +} + +func InitEmptyNumeric_functionContext(p *Numeric_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function +} + +func (*Numeric_functionContext) IsNumeric_functionContext() {} + +func NewNumeric_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_functionContext { + var p = new(Numeric_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_function + + return p +} + +func (s *Numeric_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_functionContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Numeric_functionContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Numeric_functionContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Numeric_functionContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Numeric_functionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Numeric_functionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Numeric_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Numeric_functionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Numeric_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 *Numeric_functionContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Numeric_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Numeric_functionContext) ROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserROUND, 0) +} + +func (s *Numeric_functionContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Numeric_functionContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *Numeric_functionContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Numeric_functionContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Numeric_functionContext) LEAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAST, 0) +} + +func (s *Numeric_functionContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Numeric_functionContext) GREATEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATEST, 0) +} + +func (s *Numeric_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_function(s) + } +} + +func (s *Numeric_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_function(s) + } +} + +func (s *Numeric_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNumeric_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Numeric_function() (localctx INumeric_functionContext) { + localctx = NewNumeric_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2174, PlSqlParserRULE_numeric_function) + var _la int + + p.SetState(18439) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSUM: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18381) + p.Match(PlSqlParserSUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18382) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18384) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2555, p.GetParserRuleContext()) == 1 { + { + p.SetState(18383) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18386) + p.Expression() + } + { + p.SetState(18387) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOUNT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18389) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18390) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18398) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserASTERISK: + { + p.SetState(18391) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNIQUE, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserRIGHT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(18396) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281483566645249) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796093546497) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + p.SetState(18393) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2556, p.GetParserRuleContext()) == 1 { + { + p.SetState(18392) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18395) + p.concatenation(0) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(18400) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18402) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2559, p.GetParserRuleContext()) == 1 { + { + p.SetState(18401) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserROUND: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18404) + p.Match(PlSqlParserROUND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18405) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18406) + p.Expression() + } + p.SetState(18409) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18407) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18408) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18411) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserAVG: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18413) + p.Match(PlSqlParserAVG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18414) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18416) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2561, p.GetParserRuleContext()) == 1 { + { + p.SetState(18415) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18418) + p.Expression() + } + { + p.SetState(18419) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAX: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18421) + p.Match(PlSqlParserMAX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18422) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18424) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2562, p.GetParserRuleContext()) == 1 { + { + p.SetState(18423) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18426) + p.Expression() + } + { + p.SetState(18427) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLEAST: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18429) + p.Match(PlSqlParserLEAST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18430) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18431) + p.Expressions() + } + { + p.SetState(18432) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserGREATEST: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(18434) + p.Match(PlSqlParserGREATEST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18435) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18436) + p.Expressions() + } + { + p.SetState(18437) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IListagg_overflow_clauseContext is an interface to support dynamic dispatch. +type IListagg_overflow_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ON() antlr.TerminalNode + OVERFLOW() antlr.TerminalNode + ERROR() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + CHAR_STRING() antlr.TerminalNode + COUNT() antlr.TerminalNode + WITH() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + + // IsListagg_overflow_clauseContext differentiates from other interfaces. + IsListagg_overflow_clauseContext() +} + +type Listagg_overflow_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyListagg_overflow_clauseContext() *Listagg_overflow_clauseContext { + var p = new(Listagg_overflow_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause + return p +} + +func InitEmptyListagg_overflow_clauseContext(p *Listagg_overflow_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause +} + +func (*Listagg_overflow_clauseContext) IsListagg_overflow_clauseContext() {} + +func NewListagg_overflow_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Listagg_overflow_clauseContext { + var p = new(Listagg_overflow_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_listagg_overflow_clause + + return p +} + +func (s *Listagg_overflow_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Listagg_overflow_clauseContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Listagg_overflow_clauseContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Listagg_overflow_clauseContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Listagg_overflow_clauseContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Listagg_overflow_clauseContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Listagg_overflow_clauseContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Listagg_overflow_clauseContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *Listagg_overflow_clauseContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Listagg_overflow_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Listagg_overflow_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Listagg_overflow_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterListagg_overflow_clause(s) + } +} + +func (s *Listagg_overflow_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitListagg_overflow_clause(s) + } +} + +func (s *Listagg_overflow_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitListagg_overflow_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Listagg_overflow_clause() (localctx IListagg_overflow_clauseContext) { + localctx = NewListagg_overflow_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2176, PlSqlParserRULE_listagg_overflow_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18441) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18442) + p.Match(PlSqlParserOVERFLOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18443) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERROR || _la == PlSqlParserTRUNCATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(18445) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCHAR_STRING { + { + p.SetState(18444) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18449) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWITHOUT || _la == PlSqlParserWITH { + { + p.SetState(18447) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserWITHOUT || _la == PlSqlParserWITH) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18448) + p.Match(PlSqlParserCOUNT) + 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_functionContext is an interface to support dynamic dispatch. +type IOther_functionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Over_clause_keyword() IOver_clause_keywordContext + Function_argument_analytic() IFunction_argument_analyticContext + Over_clause() IOver_clauseContext + Regular_id() IRegular_idContext + Function_argument_modeling() IFunction_argument_modelingContext + Using_clause() IUsing_clauseContext + COUNT() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + DISTINCT() antlr.TerminalNode + UNIQUE() antlr.TerminalNode + ALL() antlr.TerminalNode + AS() antlr.TerminalNode + Type_spec() IType_specContext + CAST() antlr.TerminalNode + XMLCAST() antlr.TerminalNode + MULTISET() antlr.TerminalNode + Subquery() ISubqueryContext + DEFAULT() antlr.TerminalNode + ON() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + ERROR() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + COALESCE() antlr.TerminalNode + Table_element() ITable_elementContext + Numeric() INumericContext + COLLECT() antlr.TerminalNode + Collect_order_by_part() ICollect_order_by_partContext + Within_or_over_clause_keyword() IWithin_or_over_clause_keywordContext + Function_argument() IFunction_argumentContext + AllWithin_or_over_part() []IWithin_or_over_partContext + Within_or_over_part(i int) IWithin_or_over_partContext + LISTAGG() antlr.TerminalNode + Argument() IArgumentContext + CHAR_STRING() antlr.TerminalNode + Listagg_overflow_clause() IListagg_overflow_clauseContext + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + Cursor_name() ICursor_nameContext + PERCENT_ISOPEN() antlr.TerminalNode + PERCENT_FOUND() antlr.TerminalNode + PERCENT_NOTFOUND() antlr.TerminalNode + PERCENT_ROWCOUNT() antlr.TerminalNode + DECOMPOSE() antlr.TerminalNode + CANONICAL() antlr.TerminalNode + COMPATIBILITY() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + FROM() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + Respect_or_ignore_nulls() IRespect_or_ignore_nullsContext + Standard_prediction_function_keyword() IStandard_prediction_function_keywordContext + Expressions() IExpressionsContext + Cost_matrix_clause() ICost_matrix_clauseContext + TO_BINARY_DOUBLE() antlr.TerminalNode + TO_BINARY_FLOAT() antlr.TerminalNode + TO_NUMBER() antlr.TerminalNode + TO_TIMESTAMP() antlr.TerminalNode + TO_TIMESTAMP_TZ() antlr.TerminalNode + TO_DSINTERVAL() antlr.TerminalNode + TO_YMINTERVAL() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + USING() antlr.TerminalNode + CHAR_CS() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + TREAT() antlr.TerminalNode + REF() antlr.TerminalNode + TRIM() antlr.TerminalNode + LEADING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + BOTH() antlr.TerminalNode + VALIDATE_CONVERSION() antlr.TerminalNode + XMLAGG() antlr.TerminalNode + PERIOD() antlr.TerminalNode + General_element() IGeneral_elementContext + AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext + Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext + XMLCOLATTVAL() antlr.TerminalNode + XMLFOREST() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + Xml_attributes_clause() IXml_attributes_clauseContext + ENTITYESCAPING() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + NAME() antlr.TerminalNode + EVALNAME() antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + XMLEXISTS() antlr.TerminalNode + Xml_passing_clause() IXml_passing_clauseContext + XMLPARSE() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + CONTENT() antlr.TerminalNode + WELLFORMED() antlr.TerminalNode + XMLPI() antlr.TerminalNode + Identifier() IIdentifierContext + XMLQUERY() antlr.TerminalNode + RETURNING() antlr.TerminalNode + NULL_() antlr.TerminalNode + EMPTY() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + Xmlroot_param_version_part() IXmlroot_param_version_partContext + Xmlroot_param_standalone_part() IXmlroot_param_standalone_partContext + XMLSERIALIZE() antlr.TerminalNode + Xmlserialize_param_enconding_part() IXmlserialize_param_enconding_partContext + Xmlserialize_param_version_part() IXmlserialize_param_version_partContext + Xmlserialize_param_ident_part() IXmlserialize_param_ident_partContext + DEFAULTS() antlr.TerminalNode + HIDE() antlr.TerminalNode + SHOW() antlr.TerminalNode + TIME() antlr.TerminalNode + Xmltable() IXmltableContext + + // IsOther_functionContext differentiates from other interfaces. + IsOther_functionContext() +} + +type Other_functionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOther_functionContext() *Other_functionContext { + var p = new(Other_functionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_other_function + return p +} + +func InitEmptyOther_functionContext(p *Other_functionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_other_function +} + +func (*Other_functionContext) IsOther_functionContext() {} + +func NewOther_functionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Other_functionContext { + var p = new(Other_functionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_other_function + + return p +} + +func (s *Other_functionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Other_functionContext) Over_clause_keyword() IOver_clause_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOver_clause_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOver_clause_keywordContext) +} + +func (s *Other_functionContext) Function_argument_analytic() IFunction_argument_analyticContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argument_analyticContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argument_analyticContext) +} + +func (s *Other_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 *Other_functionContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Other_functionContext) Function_argument_modeling() IFunction_argument_modelingContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argument_modelingContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argument_modelingContext) +} + +func (s *Other_functionContext) Using_clause() IUsing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IUsing_clauseContext) +} + +func (s *Other_functionContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Other_functionContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Other_functionContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Other_functionContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Other_functionContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Other_functionContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Other_functionContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Other_functionContext) DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINCT, 0) +} + +func (s *Other_functionContext) UNIQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIQUE, 0) +} + +func (s *Other_functionContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Other_functionContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Other_functionContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Other_functionContext) CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAST, 0) +} + +func (s *Other_functionContext) XMLCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCAST, 0) +} + +func (s *Other_functionContext) MULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTISET, 0) +} + +func (s *Other_functionContext) 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 *Other_functionContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Other_functionContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Other_functionContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *Other_functionContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Other_functionContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Other_functionContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Other_functionContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Other_functionContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Other_functionContext) Table_element() ITable_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITable_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITable_elementContext) +} + +func (s *Other_functionContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Other_functionContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Other_functionContext) Collect_order_by_part() ICollect_order_by_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICollect_order_by_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICollect_order_by_partContext) +} + +func (s *Other_functionContext) Within_or_over_clause_keyword() IWithin_or_over_clause_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithin_or_over_clause_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWithin_or_over_clause_keywordContext) +} + +func (s *Other_functionContext) Function_argument() IFunction_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *Other_functionContext) AllWithin_or_over_part() []IWithin_or_over_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWithin_or_over_partContext); ok { + len++ + } + } + + tst := make([]IWithin_or_over_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWithin_or_over_partContext); ok { + tst[i] = t.(IWithin_or_over_partContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Within_or_over_part(i int) IWithin_or_over_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWithin_or_over_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWithin_or_over_partContext) +} + +func (s *Other_functionContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLISTAGG, 0) +} + +func (s *Other_functionContext) Argument() IArgumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Other_functionContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Other_functionContext) Listagg_overflow_clause() IListagg_overflow_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IListagg_overflow_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IListagg_overflow_clauseContext) +} + +func (s *Other_functionContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Other_functionContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Other_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 *Other_functionContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Other_functionContext) PERCENT_ISOPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ISOPEN, 0) +} + +func (s *Other_functionContext) PERCENT_FOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_FOUND, 0) +} + +func (s *Other_functionContext) PERCENT_NOTFOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_NOTFOUND, 0) +} + +func (s *Other_functionContext) PERCENT_ROWCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ROWCOUNT, 0) +} + +func (s *Other_functionContext) DECOMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECOMPOSE, 0) +} + +func (s *Other_functionContext) CANONICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANONICAL, 0) +} + +func (s *Other_functionContext) COMPATIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPATIBILITY, 0) +} + +func (s *Other_functionContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACT, 0) +} + +func (s *Other_functionContext) FROM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM, 0) +} + +func (s *Other_functionContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_VALUE, 0) +} + +func (s *Other_functionContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_VALUE, 0) +} + +func (s *Other_functionContext) Respect_or_ignore_nulls() IRespect_or_ignore_nullsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRespect_or_ignore_nullsContext) +} + +func (s *Other_functionContext) Standard_prediction_function_keyword() IStandard_prediction_function_keywordContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IStandard_prediction_function_keywordContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IStandard_prediction_function_keywordContext) +} + +func (s *Other_functionContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Other_functionContext) Cost_matrix_clause() ICost_matrix_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICost_matrix_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICost_matrix_clauseContext) +} + +func (s *Other_functionContext) TO_BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_DOUBLE, 0) +} + +func (s *Other_functionContext) TO_BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_FLOAT, 0) +} + +func (s *Other_functionContext) TO_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NUMBER, 0) +} + +func (s *Other_functionContext) TO_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP, 0) +} + +func (s *Other_functionContext) TO_TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP_TZ, 0) +} + +func (s *Other_functionContext) TO_DSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DSINTERVAL, 0) +} + +func (s *Other_functionContext) TO_YMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_YMINTERVAL, 0) +} + +func (s *Other_functionContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Other_functionContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Other_functionContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Other_functionContext) CHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_CS, 0) +} + +func (s *Other_functionContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *Other_functionContext) TREAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTREAT, 0) +} + +func (s *Other_functionContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Other_functionContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *Other_functionContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *Other_functionContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *Other_functionContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *Other_functionContext) VALIDATE_CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE_CONVERSION, 0) +} + +func (s *Other_functionContext) XMLAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLAGG, 0) +} + +func (s *Other_functionContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Other_functionContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Other_functionContext) AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + len++ + } + } + + tst := make([]IXml_multiuse_expression_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + tst[i] = t.(IXml_multiuse_expression_elementContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_multiuse_expression_elementContext) +} + +func (s *Other_functionContext) XMLCOLATTVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOLATTVAL, 0) +} + +func (s *Other_functionContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLFOREST, 0) +} + +func (s *Other_functionContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLELEMENT, 0) +} + +func (s *Other_functionContext) Xml_attributes_clause() IXml_attributes_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_attributes_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_attributes_clauseContext) +} + +func (s *Other_functionContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Other_functionContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Other_functionContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Other_functionContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Other_functionContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Other_functionContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Other_functionContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS, 0) +} + +func (s *Other_functionContext) Xml_passing_clause() IXml_passing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_passing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_passing_clauseContext) +} + +func (s *Other_functionContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPARSE, 0) +} + +func (s *Other_functionContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCUMENT, 0) +} + +func (s *Other_functionContext) CONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENT, 0) +} + +func (s *Other_functionContext) WELLFORMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWELLFORMED, 0) +} + +func (s *Other_functionContext) XMLPI() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPI, 0) +} + +func (s *Other_functionContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Other_functionContext) XMLQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERY, 0) +} + +func (s *Other_functionContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Other_functionContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Other_functionContext) EMPTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, 0) +} + +func (s *Other_functionContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLROOT, 0) +} + +func (s *Other_functionContext) Xmlroot_param_version_part() IXmlroot_param_version_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlroot_param_version_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlroot_param_version_partContext) +} + +func (s *Other_functionContext) Xmlroot_param_standalone_part() IXmlroot_param_standalone_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlroot_param_standalone_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlroot_param_standalone_partContext) +} + +func (s *Other_functionContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSERIALIZE, 0) +} + +func (s *Other_functionContext) Xmlserialize_param_enconding_part() IXmlserialize_param_enconding_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_enconding_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_enconding_partContext) +} + +func (s *Other_functionContext) Xmlserialize_param_version_part() IXmlserialize_param_version_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_version_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_version_partContext) +} + +func (s *Other_functionContext) Xmlserialize_param_ident_part() IXmlserialize_param_ident_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmlserialize_param_ident_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmlserialize_param_ident_partContext) +} + +func (s *Other_functionContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTS, 0) +} + +func (s *Other_functionContext) HIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDE, 0) +} + +func (s *Other_functionContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Other_functionContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Other_functionContext) Xmltable() IXmltableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltableContext) +} + +func (s *Other_functionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Other_functionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Other_functionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOther_function(s) + } +} + +func (s *Other_functionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOther_function(s) + } +} + +func (s *Other_functionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOther_function(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Other_function() (localctx IOther_functionContext) { + localctx = NewOther_functionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2178, PlSqlParserRULE_other_function) + var _la int + + var _alt int + + p.SetState(18838) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2629, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18451) + p.Over_clause_keyword() + } + { + p.SetState(18452) + p.Function_argument_analytic() + } + p.SetState(18454) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2566, p.GetParserRuleContext()) == 1 { + { + p.SetState(18453) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18456) + p.Regular_id() + } + { + p.SetState(18457) + p.Function_argument_modeling() + } + p.SetState(18459) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2567, p.GetParserRuleContext()) == 1 { + { + p.SetState(18458) + p.Using_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18461) + p.Match(PlSqlParserCOUNT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18462) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserASTERISK: + { + p.SetState(18463) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNIQUE, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.SetState(18465) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2568, p.GetParserRuleContext()) == 1 { + { + p.SetState(18464) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18467) + p.concatenation(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(18470) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18472) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2570, p.GetParserRuleContext()) == 1 { + { + p.SetState(18471) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(18474) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCAST || _la == PlSqlParserXMLCAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18475) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18482) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2571, p.GetParserRuleContext()) { + case 1: + { + p.SetState(18476) + p.Match(PlSqlParserMULTISET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18477) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18478) + p.Subquery() + } + { + p.SetState(18479) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(18481) + p.concatenation(0) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(18484) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18485) + p.Type_spec() + } + p.SetState(18492) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(18486) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18487) + p.concatenation(0) + } + { + p.SetState(18488) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18489) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18490) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18494) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18495) + p.Quoted_string() + } + p.SetState(18498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18496) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18497) + p.Quoted_string() + } + + } + + } + { + p.SetState(18502) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(18504) + p.Match(PlSqlParserCOALESCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18505) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18506) + p.Table_element() + } + p.SetState(18512) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18507) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(18508) + p.Numeric() + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(18509) + p.Quoted_string() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(18514) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(18516) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18517) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18519) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2577, p.GetParserRuleContext()) == 1 { + { + p.SetState(18518) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18521) + p.concatenation(0) + } + p.SetState(18523) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(18522) + p.Collect_order_by_part() + } + + } + { + p.SetState(18525) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(18527) + p.Within_or_over_clause_keyword() + } + { + p.SetState(18528) + p.Function_argument() + } + p.SetState(18530) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = 1 + for ok := true; ok; ok = _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + switch _alt { + case 1: + { + p.SetState(18529) + p.Within_or_over_part() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + p.SetState(18532) + p.GetErrorHandler().Sync(p) + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2579, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(18534) + p.Match(PlSqlParserLISTAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18535) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18537) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2580, p.GetParserRuleContext()) == 1 { + { + p.SetState(18536) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserDISTINCT || _la == PlSqlParserUNIQUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18539) + p.Argument() + } + p.SetState(18542) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18540) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18541) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserON { + { + p.SetState(18544) + p.Listagg_overflow_clause() + } + + } + { + p.SetState(18547) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18554) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2583, p.GetParserRuleContext()) == 1 { + { + p.SetState(18548) + p.Match(PlSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18549) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18550) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18551) + p.Order_by_clause() + } + { + p.SetState(18552) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18557) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2584, p.GetParserRuleContext()) == 1 { + { + p.SetState(18556) + p.Over_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(18559) + p.Cursor_name() + } + { + p.SetState(18560) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-1283)) & ^0x3f) == 0 && ((int64(1)<<(_la-1283))&39) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(18562) + p.Match(PlSqlParserDECOMPOSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18563) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18564) + p.concatenation(0) + } + p.SetState(18566) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCANONICAL || _la == PlSqlParserCOMPATIBILITY { + { + p.SetState(18565) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCANONICAL || _la == PlSqlParserCOMPATIBILITY) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(18568) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(18570) + p.Match(PlSqlParserEXTRACT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18571) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18572) + p.Regular_id() + } + { + p.SetState(18573) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18574) + p.concatenation(0) + } + { + p.SetState(18575) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(18577) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST_VALUE || _la == PlSqlParserLAST_VALUE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18578) + p.Function_argument_analytic() + } + p.SetState(18580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(18579) + p.Respect_or_ignore_nulls() + } + + } + { + p.SetState(18582) + p.Over_clause() + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(18584) + p.Standard_prediction_function_keyword() + } + { + p.SetState(18585) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18586) + p.Expressions() + } + p.SetState(18588) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOST { + { + p.SetState(18587) + p.Cost_matrix_clause() + } + + } + p.SetState(18591) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(18590) + p.Using_clause() + } + + } + { + p.SetState(18593) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(18595) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2013)) & ^0x3f) == 0 && ((int64(1)<<(_la-2013))&12803) != 0) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18596) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18597) + p.concatenation(0) + } + p.SetState(18604) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(18598) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18599) + p.concatenation(0) + } + { + p.SetState(18600) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18601) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18602) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(18612) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18606) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18607) + p.Quoted_string() + } + p.SetState(18610) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18608) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18609) + p.Quoted_string() + } + + } + + } + { + p.SetState(18614) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(18616) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserTO_DSINTERVAL || _la == PlSqlParserTO_YMINTERVAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18617) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18618) + p.concatenation(0) + } + p.SetState(18625) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(18619) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18620) + p.concatenation(0) + } + { + p.SetState(18621) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18622) + p.Match(PlSqlParserCONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18623) + p.Match(PlSqlParserERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18627) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(18629) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18630) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18631) + p.Expression() + } + p.SetState(18634) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserUSING { + { + p.SetState(18632) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18633) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCHAR_CS || _la == PlSqlParserNCHAR_CS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + p.SetState(18640) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18636) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18637) + p.Expression() + } + + p.SetState(18642) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18643) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(18645) + p.Match(PlSqlParserTREAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18646) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18647) + p.Expression() + } + { + p.SetState(18648) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18650) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2595, p.GetParserRuleContext()) == 1 { + { + p.SetState(18649) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18652) + p.Type_spec() + } + { + p.SetState(18653) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(18655) + p.Match(PlSqlParserTRIM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18656) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18664) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2598, p.GetParserRuleContext()) == 1 { + p.SetState(18658) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2596, p.GetParserRuleContext()) == 1 { + { + p.SetState(18657) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBOTH || _la == PlSqlParserLEADING || _la == PlSqlParserTRAILING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18661) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(18660) + p.Quoted_string() + } + + } + { + p.SetState(18663) + p.Match(PlSqlParserFROM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18666) + p.concatenation(0) + } + { + p.SetState(18667) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(18669) + p.Match(PlSqlParserVALIDATE_CONVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18670) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18671) + p.concatenation(0) + } + { + p.SetState(18672) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18673) + p.Type_spec() + } + p.SetState(18680) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18674) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18675) + p.Quoted_string() + } + p.SetState(18678) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18676) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18677) + p.Quoted_string() + } + + } + + } + { + p.SetState(18682) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(18684) + p.Match(PlSqlParserXMLAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18685) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18686) + p.Expression() + } + p.SetState(18688) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(18687) + p.Order_by_clause() + } + + } + { + p.SetState(18690) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18693) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2602, p.GetParserRuleContext()) == 1 { + { + p.SetState(18691) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18692) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(18695) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserXMLCOLATTVAL || _la == PlSqlParserXMLFOREST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18696) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18697) + p.Xml_multiuse_expression_element() + } + p.SetState(18702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18698) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18699) + p.Xml_multiuse_expression_element() + } + + p.SetState(18704) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18705) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18708) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2604, p.GetParserRuleContext()) == 1 { + { + p.SetState(18706) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18707) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(18710) + p.Match(PlSqlParserXMLELEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18711) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18713) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2605, p.GetParserRuleContext()) == 1 { + { + p.SetState(18712) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENTITYESCAPING || _la == PlSqlParserNOENTITYESCAPING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18716) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2606, p.GetParserRuleContext()) == 1 { + { + p.SetState(18715) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserEVALNAME || _la == PlSqlParserNAME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18718) + p.Expression() + } + p.SetState(18721) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2607, p.GetParserRuleContext()) == 1 { + { + p.SetState(18719) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18720) + p.Xml_attributes_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18730) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18723) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18724) + p.Expression() + } + p.SetState(18726) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(18725) + p.Column_alias() + } + + } + + p.SetState(18732) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18733) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18736) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2610, p.GetParserRuleContext()) == 1 { + { + p.SetState(18734) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18735) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(18738) + p.Match(PlSqlParserXMLEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18739) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18740) + p.Expression() + } + p.SetState(18742) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(18741) + p.Xml_passing_clause() + } + + } + { + p.SetState(18744) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(18746) + p.Match(PlSqlParserXMLPARSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18747) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18748) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTENT || _la == PlSqlParserDOCUMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18749) + p.concatenation(0) + } + p.SetState(18751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserWELLFORMED { + { + p.SetState(18750) + p.Match(PlSqlParserWELLFORMED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18753) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18756) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2613, p.GetParserRuleContext()) == 1 { + { + p.SetState(18754) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18755) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(18758) + p.Match(PlSqlParserXMLPI) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18759) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18764) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNAME: + { + p.SetState(18760) + p.Match(PlSqlParserNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18761) + p.Identifier() + } + + case PlSqlParserEVALNAME: + { + p.SetState(18762) + p.Match(PlSqlParserEVALNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18763) + p.concatenation(0) + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(18768) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18766) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18767) + p.concatenation(0) + } + + } + { + p.SetState(18770) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18773) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2616, p.GetParserRuleContext()) == 1 { + { + p.SetState(18771) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18772) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(18775) + p.Match(PlSqlParserXMLQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18776) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18777) + p.concatenation(0) + } + p.SetState(18779) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(18778) + p.Xml_passing_clause() + } + + } + { + p.SetState(18781) + p.Match(PlSqlParserRETURNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18782) + p.Match(PlSqlParserCONTENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18786) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserNULL_ { + { + p.SetState(18783) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18784) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18785) + p.Match(PlSqlParserEMPTY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18788) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18791) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2619, p.GetParserRuleContext()) == 1 { + { + p.SetState(18789) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18790) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(18793) + p.Match(PlSqlParserXMLROOT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18794) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18795) + p.concatenation(0) + } + p.SetState(18798) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2620, p.GetParserRuleContext()) == 1 { + { + p.SetState(18796) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18797) + p.Xmlroot_param_version_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18802) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(18800) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18801) + p.Xmlroot_param_standalone_part() + } + + } + { + p.SetState(18804) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18807) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2622, p.GetParserRuleContext()) == 1 { + { + p.SetState(18805) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18806) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(18809) + p.Match(PlSqlParserXMLSERIALIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18810) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18811) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCONTENT || _la == PlSqlParserDOCUMENT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18812) + p.concatenation(0) + } + p.SetState(18815) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(18813) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18814) + p.Type_spec() + } + + } + p.SetState(18818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserENCODING { + { + p.SetState(18817) + p.Xmlserialize_param_enconding_part() + } + + } + p.SetState(18821) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVERSION { + { + p.SetState(18820) + p.Xmlserialize_param_version_part() + } + + } + p.SetState(18824) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDENT || _la == PlSqlParserNO { + { + p.SetState(18823) + p.Xmlserialize_param_ident_part() + } + + } + p.SetState(18828) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserHIDE || _la == PlSqlParserSHOW { + { + p.SetState(18826) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserHIDE || _la == PlSqlParserSHOW) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(18827) + p.Match(PlSqlParserDEFAULTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18830) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18833) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2628, p.GetParserRuleContext()) == 1 { + { + p.SetState(18831) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18832) + p.General_element() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(18835) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18836) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(18837) + p.Xmltable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_clause_keywordContext is an interface to support dynamic dispatch. +type IOver_clause_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AVG() antlr.TerminalNode + CORR() antlr.TerminalNode + LAG() antlr.TerminalNode + LAG_DIFF() antlr.TerminalNode + LAG_DIFF_PERCENT() antlr.TerminalNode + LEAD() antlr.TerminalNode + MAX() antlr.TerminalNode + MEDIAN() antlr.TerminalNode + MIN() antlr.TerminalNode + NTILE() antlr.TerminalNode + RATIO_TO_REPORT() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + SUM() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + REGR_() antlr.TerminalNode + STDDEV() antlr.TerminalNode + VAR_() antlr.TerminalNode + COVAR_() antlr.TerminalNode + + // IsOver_clause_keywordContext differentiates from other interfaces. + IsOver_clause_keywordContext() +} + +type Over_clause_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOver_clause_keywordContext() *Over_clause_keywordContext { + var p = new(Over_clause_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause_keyword + return p +} + +func InitEmptyOver_clause_keywordContext(p *Over_clause_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause_keyword +} + +func (*Over_clause_keywordContext) IsOver_clause_keywordContext() {} + +func NewOver_clause_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Over_clause_keywordContext { + var p = new(Over_clause_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_over_clause_keyword + + return p +} + +func (s *Over_clause_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clause_keywordContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Over_clause_keywordContext) CORR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR, 0) +} + +func (s *Over_clause_keywordContext) LAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG, 0) +} + +func (s *Over_clause_keywordContext) LAG_DIFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG_DIFF, 0) +} + +func (s *Over_clause_keywordContext) LAG_DIFF_PERCENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG_DIFF_PERCENT, 0) +} + +func (s *Over_clause_keywordContext) LEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD, 0) +} + +func (s *Over_clause_keywordContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Over_clause_keywordContext) MEDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIAN, 0) +} + +func (s *Over_clause_keywordContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Over_clause_keywordContext) NTILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTILE, 0) +} + +func (s *Over_clause_keywordContext) RATIO_TO_REPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRATIO_TO_REPORT, 0) +} + +func (s *Over_clause_keywordContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_NUMBER, 0) +} + +func (s *Over_clause_keywordContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Over_clause_keywordContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIANCE, 0) +} + +func (s *Over_clause_keywordContext) REGR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_, 0) +} + +func (s *Over_clause_keywordContext) STDDEV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV, 0) +} + +func (s *Over_clause_keywordContext) VAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_, 0) +} + +func (s *Over_clause_keywordContext) COVAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_, 0) +} + +func (s *Over_clause_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Over_clause_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Over_clause_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOver_clause_keyword(s) + } +} + +func (s *Over_clause_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOver_clause_keyword(s) + } +} + +func (s *Over_clause_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOver_clause_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Over_clause_keyword() (localctx IOver_clause_keywordContext) { + localctx = NewOver_clause_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2180, PlSqlParserRULE_over_clause_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18840) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2273)) & ^0x3f) == 0 && ((int64(1)<<(_la-2273))&31644663) != 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 +} + +// IWithin_or_over_clause_keywordContext is an interface to support dynamic dispatch. +type IWithin_or_over_clause_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CUME_DIST() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + RANK() antlr.TerminalNode + + // IsWithin_or_over_clause_keywordContext differentiates from other interfaces. + IsWithin_or_over_clause_keywordContext() +} + +type Within_or_over_clause_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithin_or_over_clause_keywordContext() *Within_or_over_clause_keywordContext { + var p = new(Within_or_over_clause_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword + return p +} + +func InitEmptyWithin_or_over_clause_keywordContext(p *Within_or_over_clause_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword +} + +func (*Within_or_over_clause_keywordContext) IsWithin_or_over_clause_keywordContext() {} + +func NewWithin_or_over_clause_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_or_over_clause_keywordContext { + var p = new(Within_or_over_clause_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_within_or_over_clause_keyword + + return p +} + +func (s *Within_or_over_clause_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Within_or_over_clause_keywordContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DIST, 0) +} + +func (s *Within_or_over_clause_keywordContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_CONT, 0) +} + +func (s *Within_or_over_clause_keywordContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_DISC, 0) +} + +func (s *Within_or_over_clause_keywordContext) RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANK, 0) +} + +func (s *Within_or_over_clause_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Within_or_over_clause_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Within_or_over_clause_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWithin_or_over_clause_keyword(s) + } +} + +func (s *Within_or_over_clause_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWithin_or_over_clause_keyword(s) + } +} + +func (s *Within_or_over_clause_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWithin_or_over_clause_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Within_or_over_clause_keyword() (localctx IWithin_or_over_clause_keywordContext) { + localctx = NewWithin_or_over_clause_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2182, PlSqlParserRULE_within_or_over_clause_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18842) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2266)) & ^0x3f) == 0 && ((int64(1)<<(_la-2266))&123) != 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 +} + +// IStandard_prediction_function_keywordContext is an interface to support dynamic dispatch. +type IStandard_prediction_function_keywordContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PREDICTION() antlr.TerminalNode + PREDICTION_BOUNDS() antlr.TerminalNode + PREDICTION_COST() antlr.TerminalNode + PREDICTION_DETAILS() antlr.TerminalNode + PREDICTION_PROBABILITY() antlr.TerminalNode + PREDICTION_SET() antlr.TerminalNode + + // IsStandard_prediction_function_keywordContext differentiates from other interfaces. + IsStandard_prediction_function_keywordContext() +} + +type Standard_prediction_function_keywordContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyStandard_prediction_function_keywordContext() *Standard_prediction_function_keywordContext { + var p = new(Standard_prediction_function_keywordContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword + return p +} + +func InitEmptyStandard_prediction_function_keywordContext(p *Standard_prediction_function_keywordContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword +} + +func (*Standard_prediction_function_keywordContext) IsStandard_prediction_function_keywordContext() {} + +func NewStandard_prediction_function_keywordContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Standard_prediction_function_keywordContext { + var p = new(Standard_prediction_function_keywordContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_standard_prediction_function_keyword + + return p +} + +func (s *Standard_prediction_function_keywordContext) GetParser() antlr.Parser { return s.parser } + +func (s *Standard_prediction_function_keywordContext) PREDICTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_BOUNDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_BOUNDS, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_COST, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_DETAILS, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_PROBABILITY, 0) +} + +func (s *Standard_prediction_function_keywordContext) PREDICTION_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_SET, 0) +} + +func (s *Standard_prediction_function_keywordContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Standard_prediction_function_keywordContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Standard_prediction_function_keywordContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterStandard_prediction_function_keyword(s) + } +} + +func (s *Standard_prediction_function_keywordContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitStandard_prediction_function_keyword(s) + } +} + +func (s *Standard_prediction_function_keywordContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitStandard_prediction_function_keyword(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Standard_prediction_function_keyword() (localctx IStandard_prediction_function_keywordContext) { + localctx = NewStandard_prediction_function_keywordContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2184, PlSqlParserRULE_standard_prediction_function_keyword) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18844) + _la = p.GetTokenStream().LA(1) + + if !((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&63) != 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 +} + +// IOver_clauseContext is an interface to support dynamic dispatch. +type IOver_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTh returns the th rule contexts. + GetTh() IId_expressionContext + + // SetTh sets the th rule contexts. + SetTh(IId_expressionContext) + + // Getter signatures + OVER() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + OFFSET() antlr.TerminalNode + Numeric() INumericContext + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + Query_partition_clause() IQuery_partition_clauseContext + Order_by_clause() IOrder_by_clauseContext + ACROSS() antlr.TerminalNode + ANCESTOR() antlr.TerminalNode + AT() antlr.TerminalNode + LEVEL() antlr.TerminalNode + Windowing_clause() IWindowing_clauseContext + + // IsOver_clauseContext differentiates from other interfaces. + IsOver_clauseContext() +} + +type Over_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + th IId_expressionContext +} + +func NewEmptyOver_clauseContext() *Over_clauseContext { + var p = new(Over_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_over_clause + return p +} + +func InitEmptyOver_clauseContext(p *Over_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_over_clause + + return p +} + +func (s *Over_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Over_clauseContext) GetTh() IId_expressionContext { return s.th } + +func (s *Over_clauseContext) SetTh(v IId_expressionContext) { s.th = v } + +func (s *Over_clauseContext) OVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVER, 0) +} + +func (s *Over_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Over_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Over_clauseContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Over_clauseContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Over_clauseContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Over_clauseContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Over_clauseContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Over_clauseContext) Query_partition_clause() IQuery_partition_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuery_partition_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuery_partition_clauseContext) +} + +func (s *Over_clauseContext) 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 *Over_clauseContext) ACROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACROSS, 0) +} + +func (s *Over_clauseContext) ANCESTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCESTOR, 0) +} + +func (s *Over_clauseContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Over_clauseContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Over_clauseContext) Windowing_clause() IWindowing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_clauseContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterOver_clause(s) + } +} + +func (s *Over_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOver_clause(s) + } +} + +func (s *Over_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOver_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Over_clause() (localctx IOver_clauseContext) { + localctx = NewOver_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2186, PlSqlParserRULE_over_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18846) + p.Match(PlSqlParserOVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18847) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18868) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserORDER, PlSqlParserPARTITION, PlSqlParserRIGHT_PAREN: + p.SetState(18849) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPARTITION { + { + p.SetState(18848) + p.Query_partition_clause() + } + + } + p.SetState(18855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserORDER { + { + p.SetState(18851) + p.Order_by_clause() + } + p.SetState(18853) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRANGE || _la == PlSqlParserROWS { + { + p.SetState(18852) + p.Windowing_clause() + } + + } + + } + + case PlSqlParserHIERARCHY: + { + p.SetState(18857) + p.Match(PlSqlParserHIERARCHY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18858) + + var _x = p.Id_expression() + + localctx.(*Over_clauseContext).th = _x + } + { + p.SetState(18859) + p.Match(PlSqlParserOFFSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18860) + p.Numeric() + } + p.SetState(18866) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserACROSS { + { + p.SetState(18861) + p.Match(PlSqlParserACROSS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18862) + p.Match(PlSqlParserANCESTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18863) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18864) + p.Match(PlSqlParserLEVEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18865) + p.Id_expression() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(18870) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowing_clauseContext is an interface to support dynamic dispatch. +type IWindowing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Windowing_type() IWindowing_typeContext + BETWEEN() antlr.TerminalNode + AllWindowing_elements() []IWindowing_elementsContext + Windowing_elements(i int) IWindowing_elementsContext + AND() antlr.TerminalNode + + // IsWindowing_clauseContext differentiates from other interfaces. + IsWindowing_clauseContext() +} + +type Windowing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_clauseContext() *Windowing_clauseContext { + var p = new(Windowing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_clause + return p +} + +func InitEmptyWindowing_clauseContext(p *Windowing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_clause +} + +func (*Windowing_clauseContext) IsWindowing_clauseContext() {} + +func NewWindowing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_clauseContext { + var p = new(Windowing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_clause + + return p +} + +func (s *Windowing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_clauseContext) Windowing_type() IWindowing_typeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_typeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_typeContext) +} + +func (s *Windowing_clauseContext) BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBETWEEN, 0) +} + +func (s *Windowing_clauseContext) AllWindowing_elements() []IWindowing_elementsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IWindowing_elementsContext); ok { + len++ + } + } + + tst := make([]IWindowing_elementsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IWindowing_elementsContext); ok { + tst[i] = t.(IWindowing_elementsContext) + i++ + } + } + + return tst +} + +func (s *Windowing_clauseContext) Windowing_elements(i int) IWindowing_elementsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWindowing_elementsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IWindowing_elementsContext) +} + +func (s *Windowing_clauseContext) AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND, 0) +} + +func (s *Windowing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_clause(s) + } +} + +func (s *Windowing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_clause(s) + } +} + +func (s *Windowing_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWindowing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Windowing_clause() (localctx IWindowing_clauseContext) { + localctx = NewWindowing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2188, PlSqlParserRULE_windowing_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18872) + p.Windowing_type() + } + p.SetState(18879) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBETWEEN: + { + p.SetState(18873) + p.Match(PlSqlParserBETWEEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18874) + p.Windowing_elements() + } + { + p.SetState(18875) + p.Match(PlSqlParserAND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18876) + p.Windowing_elements() + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(18878) + p.Windowing_elements() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IWindowing_typeContext is an interface to support dynamic dispatch. +type IWindowing_typeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ROWS() antlr.TerminalNode + RANGE() antlr.TerminalNode + + // IsWindowing_typeContext differentiates from other interfaces. + IsWindowing_typeContext() +} + +type Windowing_typeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_typeContext() *Windowing_typeContext { + var p = new(Windowing_typeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_type + return p +} + +func InitEmptyWindowing_typeContext(p *Windowing_typeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_type +} + +func (*Windowing_typeContext) IsWindowing_typeContext() {} + +func NewWindowing_typeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_typeContext { + var p = new(Windowing_typeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_type + + return p +} + +func (s *Windowing_typeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_typeContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Windowing_typeContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Windowing_typeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_typeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_typeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_type(s) + } +} + +func (s *Windowing_typeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_type(s) + } +} + +func (s *Windowing_typeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWindowing_type(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Windowing_type() (localctx IWindowing_typeContext) { + localctx = NewWindowing_typeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2190, PlSqlParserRULE_windowing_type) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18881) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRANGE || _la == PlSqlParserROWS) { + 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 +} + +// IWindowing_elementsContext is an interface to support dynamic dispatch. +type IWindowing_elementsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNBOUNDED() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + CURRENT() antlr.TerminalNode + ROW() antlr.TerminalNode + Concatenation() IConcatenationContext + FOLLOWING() antlr.TerminalNode + + // IsWindowing_elementsContext differentiates from other interfaces. + IsWindowing_elementsContext() +} + +type Windowing_elementsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWindowing_elementsContext() *Windowing_elementsContext { + var p = new(Windowing_elementsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_elements + return p +} + +func InitEmptyWindowing_elementsContext(p *Windowing_elementsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_windowing_elements +} + +func (*Windowing_elementsContext) IsWindowing_elementsContext() {} + +func NewWindowing_elementsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Windowing_elementsContext { + var p = new(Windowing_elementsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_windowing_elements + + return p +} + +func (s *Windowing_elementsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Windowing_elementsContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUNDED, 0) +} + +func (s *Windowing_elementsContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDING, 0) +} + +func (s *Windowing_elementsContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Windowing_elementsContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Windowing_elementsContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Windowing_elementsContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWING, 0) +} + +func (s *Windowing_elementsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Windowing_elementsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Windowing_elementsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWindowing_elements(s) + } +} + +func (s *Windowing_elementsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWindowing_elements(s) + } +} + +func (s *Windowing_elementsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWindowing_elements(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Windowing_elements() (localctx IWindowing_elementsContext) { + localctx = NewWindowing_elementsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2192, PlSqlParserRULE_windowing_elements) + var _la int + + p.SetState(18890) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2636, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18883) + p.Match(PlSqlParserUNBOUNDED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18884) + p.Match(PlSqlParserPRECEDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18885) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18886) + p.Match(PlSqlParserROW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(18887) + p.concatenation(0) + } + { + p.SetState(18888) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFOLLOWING || _la == PlSqlParserPRECEDING) { + 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 +} + +// IUsing_clauseContext is an interface to support dynamic dispatch. +type IUsing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + USING() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllUsing_element() []IUsing_elementContext + Using_element(i int) IUsing_elementContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsUsing_clauseContext differentiates from other interfaces. + IsUsing_clauseContext() +} + +type Using_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_clauseContext() *Using_clauseContext { + var p = new(Using_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_clause + return p +} + +func InitEmptyUsing_clauseContext(p *Using_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_clause +} + +func (*Using_clauseContext) IsUsing_clauseContext() {} + +func NewUsing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_clauseContext { + var p = new(Using_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_clause + + return p +} + +func (s *Using_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_clauseContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Using_clauseContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Using_clauseContext) AllUsing_element() []IUsing_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUsing_elementContext); ok { + len++ + } + } + + tst := make([]IUsing_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUsing_elementContext); ok { + tst[i] = t.(IUsing_elementContext) + i++ + } + } + + return tst +} + +func (s *Using_clauseContext) Using_element(i int) IUsing_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUsing_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUsing_elementContext) +} + +func (s *Using_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Using_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Using_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_clause(s) + } +} + +func (s *Using_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_clause(s) + } +} + +func (s *Using_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_clause() (localctx IUsing_clauseContext) { + localctx = NewUsing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2194, PlSqlParserRULE_using_clause) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18892) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18902) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserASTERISK: + { + p.SetState(18893) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALL, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANY, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULT, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINCT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserIN, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNOT, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULL_, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIOR, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserDECODE, PlSqlParserLAG, PlSqlParserLAG_DIFF, PlSqlParserLAG_DIFF_PERCENT, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserPERIOD, PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT, PlSqlParserCHAR_STRING, PlSqlParserDELIMITED_ID, PlSqlParserLEFT_PAREN, PlSqlParserPLUS_SIGN, PlSqlParserMINUS_SIGN, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(18894) + p.Using_element() + } + p.SetState(18899) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2637, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(18895) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18896) + p.Using_element() + } + + } + p.SetState(18901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2637, p.GetParserRuleContext()) + if p.HasError() { + 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 +} + +// IUsing_elementContext is an interface to support dynamic dispatch. +type IUsing_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Select_list_elements() ISelect_list_elementsContext + IN() antlr.TerminalNode + OUT() antlr.TerminalNode + + // IsUsing_elementContext differentiates from other interfaces. + IsUsing_elementContext() +} + +type Using_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUsing_elementContext() *Using_elementContext { + var p = new(Using_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_element + return p +} + +func InitEmptyUsing_elementContext(p *Using_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_using_element +} + +func (*Using_elementContext) IsUsing_elementContext() {} + +func NewUsing_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Using_elementContext { + var p = new(Using_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_using_element + + return p +} + +func (s *Using_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Using_elementContext) Select_list_elements() ISelect_list_elementsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISelect_list_elementsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISelect_list_elementsContext) +} + +func (s *Using_elementContext) IN() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN, 0) +} + +func (s *Using_elementContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Using_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Using_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Using_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUsing_element(s) + } +} + +func (s *Using_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUsing_element(s) + } +} + +func (s *Using_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUsing_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Using_element() (localctx IUsing_elementContext) { + localctx = NewUsing_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2196, PlSqlParserRULE_using_element) + p.EnterOuterAlt(localctx, 1) + p.SetState(18909) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2640, p.GetParserRuleContext()) == 1 { + { + p.SetState(18904) + p.Match(PlSqlParserIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18906) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2639, p.GetParserRuleContext()) == 1 { + { + p.SetState(18905) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2640, p.GetParserRuleContext()) == 2 { + { + p.SetState(18908) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18911) + p.Select_list_elements() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollect_order_by_partContext is an interface to support dynamic dispatch. +type ICollect_order_by_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ORDER() antlr.TerminalNode + BY() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsCollect_order_by_partContext differentiates from other interfaces. + IsCollect_order_by_partContext() +} + +type Collect_order_by_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollect_order_by_partContext() *Collect_order_by_partContext { + var p = new(Collect_order_by_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collect_order_by_part + return p +} + +func InitEmptyCollect_order_by_partContext(p *Collect_order_by_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collect_order_by_part +} + +func (*Collect_order_by_partContext) IsCollect_order_by_partContext() {} + +func NewCollect_order_by_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collect_order_by_partContext { + var p = new(Collect_order_by_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collect_order_by_part + + return p +} + +func (s *Collect_order_by_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collect_order_by_partContext) ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDER, 0) +} + +func (s *Collect_order_by_partContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Collect_order_by_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Collect_order_by_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collect_order_by_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collect_order_by_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollect_order_by_part(s) + } +} + +func (s *Collect_order_by_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollect_order_by_part(s) + } +} + +func (s *Collect_order_by_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCollect_order_by_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Collect_order_by_part() (localctx ICollect_order_by_partContext) { + localctx = NewCollect_order_by_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2198, PlSqlParserRULE_collect_order_by_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18913) + p.Match(PlSqlParserORDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18914) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18915) + p.concatenation(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 +} + +// IWithin_or_over_partContext is an interface to support dynamic dispatch. +type IWithin_or_over_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WITHIN() antlr.TerminalNode + GROUP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + RIGHT_PAREN() antlr.TerminalNode + Over_clause() IOver_clauseContext + + // IsWithin_or_over_partContext differentiates from other interfaces. + IsWithin_or_over_partContext() +} + +type Within_or_over_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWithin_or_over_partContext() *Within_or_over_partContext { + var p = new(Within_or_over_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_part + return p +} + +func InitEmptyWithin_or_over_partContext(p *Within_or_over_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_within_or_over_part +} + +func (*Within_or_over_partContext) IsWithin_or_over_partContext() {} + +func NewWithin_or_over_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Within_or_over_partContext { + var p = new(Within_or_over_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_within_or_over_part + + return p +} + +func (s *Within_or_over_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Within_or_over_partContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Within_or_over_partContext) GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP, 0) +} + +func (s *Within_or_over_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Within_or_over_partContext) 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 *Within_or_over_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Within_or_over_partContext) 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 *Within_or_over_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Within_or_over_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Within_or_over_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWithin_or_over_part(s) + } +} + +func (s *Within_or_over_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWithin_or_over_part(s) + } +} + +func (s *Within_or_over_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWithin_or_over_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Within_or_over_part() (localctx IWithin_or_over_partContext) { + localctx = NewWithin_or_over_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2200, PlSqlParserRULE_within_or_over_part) + p.SetState(18924) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserWITHIN: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18917) + p.Match(PlSqlParserWITHIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18918) + p.Match(PlSqlParserGROUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18919) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18920) + p.Order_by_clause() + } + { + p.SetState(18921) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserOVER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(18923) + 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 +} + +// ICost_matrix_clauseContext is an interface to support dynamic dispatch. +type ICost_matrix_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + COST() antlr.TerminalNode + MODEL() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllCost_class_name() []ICost_class_nameContext + Cost_class_name(i int) ICost_class_nameContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + VALUES() antlr.TerminalNode + AUTO() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Expressions() IExpressionsContext + + // IsCost_matrix_clauseContext differentiates from other interfaces. + IsCost_matrix_clauseContext() +} + +type Cost_matrix_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCost_matrix_clauseContext() *Cost_matrix_clauseContext { + var p = new(Cost_matrix_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause + return p +} + +func InitEmptyCost_matrix_clauseContext(p *Cost_matrix_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause +} + +func (*Cost_matrix_clauseContext) IsCost_matrix_clauseContext() {} + +func NewCost_matrix_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cost_matrix_clauseContext { + var p = new(Cost_matrix_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cost_matrix_clause + + return p +} + +func (s *Cost_matrix_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cost_matrix_clauseContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Cost_matrix_clauseContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Cost_matrix_clauseContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Cost_matrix_clauseContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Cost_matrix_clauseContext) AllCost_class_name() []ICost_class_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ICost_class_nameContext); ok { + len++ + } + } + + tst := make([]ICost_class_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ICost_class_nameContext); ok { + tst[i] = t.(ICost_class_nameContext) + i++ + } + } + + return tst +} + +func (s *Cost_matrix_clauseContext) Cost_class_name(i int) ICost_class_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICost_class_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ICost_class_nameContext) +} + +func (s *Cost_matrix_clauseContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Cost_matrix_clauseContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Cost_matrix_clauseContext) VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUES, 0) +} + +func (s *Cost_matrix_clauseContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Cost_matrix_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Cost_matrix_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Cost_matrix_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Cost_matrix_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cost_matrix_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cost_matrix_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCost_matrix_clause(s) + } +} + +func (s *Cost_matrix_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCost_matrix_clause(s) + } +} + +func (s *Cost_matrix_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCost_matrix_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cost_matrix_clause() (localctx ICost_matrix_clauseContext) { + localctx = NewCost_matrix_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2202, PlSqlParserRULE_cost_matrix_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18926) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18948) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserMODEL: + { + p.SetState(18927) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18929) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAUTO { + { + p.SetState(18928) + p.Match(PlSqlParserAUTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserLEFT_PAREN: + { + p.SetState(18931) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18932) + p.Cost_class_name() + } + p.SetState(18937) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18933) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18934) + p.Cost_class_name() + } + + p.SetState(18939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18940) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18941) + p.Match(PlSqlParserVALUES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18942) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18944) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(18943) + p.Expressions() + } + + } + { + p.SetState(18946) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_passing_clauseContext is an interface to support dynamic dispatch. +type IXml_passing_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + PASSING() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + BY() antlr.TerminalNode + VALUE() antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsXml_passing_clauseContext differentiates from other interfaces. + IsXml_passing_clauseContext() +} + +type Xml_passing_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_passing_clauseContext() *Xml_passing_clauseContext { + var p = new(Xml_passing_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_passing_clause + return p +} + +func InitEmptyXml_passing_clauseContext(p *Xml_passing_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_passing_clause +} + +func (*Xml_passing_clauseContext) IsXml_passing_clauseContext() {} + +func NewXml_passing_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_passing_clauseContext { + var p = new(Xml_passing_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_passing_clause + + return p +} + +func (s *Xml_passing_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_passing_clauseContext) PASSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSING, 0) +} + +func (s *Xml_passing_clauseContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Xml_passing_clauseContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xml_passing_clauseContext) BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBY, 0) +} + +func (s *Xml_passing_clauseContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xml_passing_clauseContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Xml_passing_clauseContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Xml_passing_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_passing_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_passing_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_passing_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_passing_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_passing_clause(s) + } +} + +func (s *Xml_passing_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_passing_clause(s) + } +} + +func (s *Xml_passing_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_passing_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_passing_clause() (localctx IXml_passing_clauseContext) { + localctx = NewXml_passing_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2204, PlSqlParserRULE_xml_passing_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18950) + p.Match(PlSqlParserPASSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18953) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBY { + { + p.SetState(18951) + p.Match(PlSqlParserBY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18952) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(18955) + p.Expression() + } + p.SetState(18957) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2647, p.GetParserRuleContext()) == 1 { + { + p.SetState(18956) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18966) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18959) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18960) + p.Expression() + } + p.SetState(18962) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2648, p.GetParserRuleContext()) == 1 { + { + p.SetState(18961) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + p.SetState(18968) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_attributes_clauseContext is an interface to support dynamic dispatch. +type IXml_attributes_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLATTRIBUTES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext + Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext + RIGHT_PAREN() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + ENTITYESCAPING() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + SCHEMACHECK() antlr.TerminalNode + NOSCHEMACHECK() antlr.TerminalNode + + // IsXml_attributes_clauseContext differentiates from other interfaces. + IsXml_attributes_clauseContext() +} + +type Xml_attributes_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_attributes_clauseContext() *Xml_attributes_clauseContext { + var p = new(Xml_attributes_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause + return p +} + +func InitEmptyXml_attributes_clauseContext(p *Xml_attributes_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause +} + +func (*Xml_attributes_clauseContext) IsXml_attributes_clauseContext() {} + +func NewXml_attributes_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_attributes_clauseContext { + var p = new(Xml_attributes_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_attributes_clause + + return p +} + +func (s *Xml_attributes_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_attributes_clauseContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLATTRIBUTES, 0) +} + +func (s *Xml_attributes_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xml_attributes_clauseContext) AllXml_multiuse_expression_element() []IXml_multiuse_expression_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + len++ + } + } + + tst := make([]IXml_multiuse_expression_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + tst[i] = t.(IXml_multiuse_expression_elementContext) + i++ + } + } + + return tst +} + +func (s *Xml_attributes_clauseContext) Xml_multiuse_expression_element(i int) IXml_multiuse_expression_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_multiuse_expression_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_multiuse_expression_elementContext) +} + +func (s *Xml_attributes_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xml_attributes_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_attributes_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_attributes_clauseContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Xml_attributes_clauseContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Xml_attributes_clauseContext) SCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMACHECK, 0) +} + +func (s *Xml_attributes_clauseContext) NOSCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCHEMACHECK, 0) +} + +func (s *Xml_attributes_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_attributes_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_attributes_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_attributes_clause(s) + } +} + +func (s *Xml_attributes_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_attributes_clause(s) + } +} + +func (s *Xml_attributes_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_attributes_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_attributes_clause() (localctx IXml_attributes_clauseContext) { + localctx = NewXml_attributes_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2206, PlSqlParserRULE_xml_attributes_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18969) + p.Match(PlSqlParserXMLATTRIBUTES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18970) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18972) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2650, p.GetParserRuleContext()) == 1 { + { + p.SetState(18971) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserENTITYESCAPING || _la == PlSqlParserNOENTITYESCAPING) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(18975) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2651, p.GetParserRuleContext()) == 1 { + { + p.SetState(18974) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNOSCHEMACHECK || _la == PlSqlParserSCHEMACHECK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(18977) + p.Xml_multiuse_expression_element() + } + p.SetState(18982) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18978) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18979) + p.Xml_multiuse_expression_element() + } + + p.SetState(18984) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(18985) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_namespaces_clauseContext is an interface to support dynamic dispatch. +type IXml_namespaces_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLNAMESPACES() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllConcatenation() []IConcatenationContext + Concatenation(i int) IConcatenationContext + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Xml_general_default_part() IXml_general_default_partContext + + // IsXml_namespaces_clauseContext differentiates from other interfaces. + IsXml_namespaces_clauseContext() +} + +type Xml_namespaces_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_namespaces_clauseContext() *Xml_namespaces_clauseContext { + var p = new(Xml_namespaces_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause + return p +} + +func InitEmptyXml_namespaces_clauseContext(p *Xml_namespaces_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause +} + +func (*Xml_namespaces_clauseContext) IsXml_namespaces_clauseContext() {} + +func NewXml_namespaces_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_namespaces_clauseContext { + var p = new(Xml_namespaces_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_namespaces_clause + + return p +} + +func (s *Xml_namespaces_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_namespaces_clauseContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLNAMESPACES, 0) +} + +func (s *Xml_namespaces_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Xml_namespaces_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Xml_namespaces_clauseContext) AllConcatenation() []IConcatenationContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IConcatenationContext); ok { + len++ + } + } + + tst := make([]IConcatenationContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IConcatenationContext); ok { + tst[i] = t.(IConcatenationContext) + i++ + } + } + + return tst +} + +func (s *Xml_namespaces_clauseContext) Concatenation(i int) IConcatenationContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_namespaces_clauseContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Xml_namespaces_clauseContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Xml_namespaces_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Xml_namespaces_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Xml_namespaces_clauseContext) Xml_general_default_part() IXml_general_default_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_general_default_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_general_default_partContext) +} + +func (s *Xml_namespaces_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_namespaces_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_namespaces_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_namespaces_clause(s) + } +} + +func (s *Xml_namespaces_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_namespaces_clause(s) + } +} + +func (s *Xml_namespaces_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_namespaces_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_namespaces_clause() (localctx IXml_namespaces_clauseContext) { + localctx = NewXml_namespaces_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2208, PlSqlParserRULE_xml_namespaces_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(18987) + p.Match(PlSqlParserXMLNAMESPACES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18988) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(18992) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2653, p.GetParserRuleContext()) == 1 { + { + p.SetState(18989) + p.concatenation(0) + } + { + p.SetState(18990) + p.Column_alias() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19000) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(18994) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(18995) + p.concatenation(0) + } + { + p.SetState(18996) + p.Column_alias() + } + + p.SetState(19002) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + p.SetState(19004) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(19003) + p.Xml_general_default_part() + } + + } + { + p.SetState(19006) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_table_columnContext is an interface to support dynamic dispatch. +type IXml_table_columnContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Xml_column_name() IXml_column_nameContext + FOR() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + Type_spec() IType_specContext + PATH() antlr.TerminalNode + Concatenation() IConcatenationContext + Xml_general_default_part() IXml_general_default_partContext + + // IsXml_table_columnContext differentiates from other interfaces. + IsXml_table_columnContext() +} + +type Xml_table_columnContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_table_columnContext() *Xml_table_columnContext { + var p = new(Xml_table_columnContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_table_column + return p +} + +func InitEmptyXml_table_columnContext(p *Xml_table_columnContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_table_column +} + +func (*Xml_table_columnContext) IsXml_table_columnContext() {} + +func NewXml_table_columnContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_table_columnContext { + var p = new(Xml_table_columnContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_table_column + + return p +} + +func (s *Xml_table_columnContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_table_columnContext) Xml_column_name() IXml_column_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_column_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_column_nameContext) +} + +func (s *Xml_table_columnContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Xml_table_columnContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Xml_table_columnContext) Type_spec() IType_specContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_specContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_specContext) +} + +func (s *Xml_table_columnContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Xml_table_columnContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_table_columnContext) Xml_general_default_part() IXml_general_default_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_general_default_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_general_default_partContext) +} + +func (s *Xml_table_columnContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_table_columnContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_table_columnContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_table_column(s) + } +} + +func (s *Xml_table_columnContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_table_column(s) + } +} + +func (s *Xml_table_columnContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_table_column(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_table_column() (localctx IXml_table_columnContext) { + localctx = NewXml_table_columnContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2210, PlSqlParserRULE_xml_table_column) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19008) + p.Xml_column_name() + } + p.SetState(19019) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserFOR: + { + p.SetState(19009) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19010) + p.Match(PlSqlParserORDINALITY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNATURALN, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + { + p.SetState(19011) + p.Type_spec() + } + p.SetState(19014) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPATH { + { + p.SetState(19012) + p.Match(PlSqlParserPATH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19013) + p.concatenation(0) + } + + } + p.SetState(19017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserDEFAULT { + { + p.SetState(19016) + p.Xml_general_default_part() + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXml_general_default_partContext is an interface to support dynamic dispatch. +type IXml_general_default_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + DEFAULT() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXml_general_default_partContext differentiates from other interfaces. + IsXml_general_default_partContext() +} + +type Xml_general_default_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_general_default_partContext() *Xml_general_default_partContext { + var p = new(Xml_general_default_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_general_default_part + return p +} + +func InitEmptyXml_general_default_partContext(p *Xml_general_default_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_general_default_part +} + +func (*Xml_general_default_partContext) IsXml_general_default_partContext() {} + +func NewXml_general_default_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_general_default_partContext { + var p = new(Xml_general_default_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_general_default_part + + return p +} + +func (s *Xml_general_default_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_general_default_partContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Xml_general_default_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_general_default_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_general_default_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_general_default_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_general_default_part(s) + } +} + +func (s *Xml_general_default_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_general_default_part(s) + } +} + +func (s *Xml_general_default_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_general_default_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_general_default_part() (localctx IXml_general_default_partContext) { + localctx = NewXml_general_default_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2212, PlSqlParserRULE_xml_general_default_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19021) + p.Match(PlSqlParserDEFAULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19022) + p.concatenation(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 +} + +// IXml_multiuse_expression_elementContext is an interface to support dynamic dispatch. +type IXml_multiuse_expression_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + AS() antlr.TerminalNode + Id_expression() IId_expressionContext + EVALNAME() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXml_multiuse_expression_elementContext differentiates from other interfaces. + IsXml_multiuse_expression_elementContext() +} + +type Xml_multiuse_expression_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_multiuse_expression_elementContext() *Xml_multiuse_expression_elementContext { + var p = new(Xml_multiuse_expression_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element + return p +} + +func InitEmptyXml_multiuse_expression_elementContext(p *Xml_multiuse_expression_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element +} + +func (*Xml_multiuse_expression_elementContext) IsXml_multiuse_expression_elementContext() {} + +func NewXml_multiuse_expression_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_multiuse_expression_elementContext { + var p = new(Xml_multiuse_expression_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_multiuse_expression_element + + return p +} + +func (s *Xml_multiuse_expression_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_multiuse_expression_elementContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xml_multiuse_expression_elementContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Xml_multiuse_expression_elementContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Xml_multiuse_expression_elementContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Xml_multiuse_expression_elementContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xml_multiuse_expression_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_multiuse_expression_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_multiuse_expression_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_multiuse_expression_element(s) + } +} + +func (s *Xml_multiuse_expression_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_multiuse_expression_element(s) + } +} + +func (s *Xml_multiuse_expression_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_multiuse_expression_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_multiuse_expression_element() (localctx IXml_multiuse_expression_elementContext) { + localctx = NewXml_multiuse_expression_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2214, PlSqlParserRULE_xml_multiuse_expression_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19024) + p.Expression() + } + p.SetState(19031) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(19025) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19029) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2659, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19026) + p.Id_expression() + } + + case 2: + { + p.SetState(19027) + p.Match(PlSqlParserEVALNAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19028) + p.concatenation(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 +} + +// IXmlroot_param_version_partContext is an interface to support dynamic dispatch. +type IXmlroot_param_version_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION() antlr.TerminalNode + NO() antlr.TerminalNode + VALUE() antlr.TerminalNode + Expression() IExpressionContext + + // IsXmlroot_param_version_partContext differentiates from other interfaces. + IsXmlroot_param_version_partContext() +} + +type Xmlroot_param_version_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlroot_param_version_partContext() *Xmlroot_param_version_partContext { + var p = new(Xmlroot_param_version_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part + return p +} + +func InitEmptyXmlroot_param_version_partContext(p *Xmlroot_param_version_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part +} + +func (*Xmlroot_param_version_partContext) IsXmlroot_param_version_partContext() {} + +func NewXmlroot_param_version_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlroot_param_version_partContext { + var p = new(Xmlroot_param_version_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlroot_param_version_part + + return p +} + +func (s *Xmlroot_param_version_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlroot_param_version_partContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Xmlroot_param_version_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlroot_param_version_partContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xmlroot_param_version_partContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Xmlroot_param_version_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlroot_param_version_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlroot_param_version_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlroot_param_version_part(s) + } +} + +func (s *Xmlroot_param_version_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlroot_param_version_part(s) + } +} + +func (s *Xmlroot_param_version_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlroot_param_version_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlroot_param_version_part() (localctx IXmlroot_param_version_partContext) { + localctx = NewXmlroot_param_version_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2216, PlSqlParserRULE_xmlroot_param_version_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19033) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19037) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2661, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19034) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19035) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19036) + p.Expression() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IXmlroot_param_standalone_partContext is an interface to support dynamic dispatch. +type IXmlroot_param_standalone_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + STANDALONE() antlr.TerminalNode + YES() antlr.TerminalNode + NO() antlr.TerminalNode + VALUE() antlr.TerminalNode + + // IsXmlroot_param_standalone_partContext differentiates from other interfaces. + IsXmlroot_param_standalone_partContext() +} + +type Xmlroot_param_standalone_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlroot_param_standalone_partContext() *Xmlroot_param_standalone_partContext { + var p = new(Xmlroot_param_standalone_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part + return p +} + +func InitEmptyXmlroot_param_standalone_partContext(p *Xmlroot_param_standalone_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part +} + +func (*Xmlroot_param_standalone_partContext) IsXmlroot_param_standalone_partContext() {} + +func NewXmlroot_param_standalone_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlroot_param_standalone_partContext { + var p = new(Xmlroot_param_standalone_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlroot_param_standalone_part + + return p +} + +func (s *Xmlroot_param_standalone_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlroot_param_standalone_partContext) STANDALONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDALONE, 0) +} + +func (s *Xmlroot_param_standalone_partContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Xmlroot_param_standalone_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlroot_param_standalone_partContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Xmlroot_param_standalone_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlroot_param_standalone_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlroot_param_standalone_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlroot_param_standalone_part(s) + } +} + +func (s *Xmlroot_param_standalone_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlroot_param_standalone_part(s) + } +} + +func (s *Xmlroot_param_standalone_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlroot_param_standalone_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlroot_param_standalone_part() (localctx IXmlroot_param_standalone_partContext) { + localctx = NewXmlroot_param_standalone_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2218, PlSqlParserRULE_xmlroot_param_standalone_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19039) + p.Match(PlSqlParserSTANDALONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19045) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserYES: + { + p.SetState(19040) + p.Match(PlSqlParserYES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNO: + { + p.SetState(19041) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19043) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserVALUE { + { + p.SetState(19042) + p.Match(PlSqlParserVALUE) + 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 +} + +// IXmlserialize_param_enconding_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_enconding_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ENCODING() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_enconding_partContext differentiates from other interfaces. + IsXmlserialize_param_enconding_partContext() +} + +type Xmlserialize_param_enconding_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_enconding_partContext() *Xmlserialize_param_enconding_partContext { + var p = new(Xmlserialize_param_enconding_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part + return p +} + +func InitEmptyXmlserialize_param_enconding_partContext(p *Xmlserialize_param_enconding_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part +} + +func (*Xmlserialize_param_enconding_partContext) IsXmlserialize_param_enconding_partContext() {} + +func NewXmlserialize_param_enconding_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_enconding_partContext { + var p = new(Xmlserialize_param_enconding_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_enconding_part + + return p +} + +func (s *Xmlserialize_param_enconding_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_enconding_partContext) ENCODING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCODING, 0) +} + +func (s *Xmlserialize_param_enconding_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_enconding_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_enconding_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_enconding_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_enconding_part(s) + } +} + +func (s *Xmlserialize_param_enconding_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_enconding_part(s) + } +} + +func (s *Xmlserialize_param_enconding_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlserialize_param_enconding_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_enconding_part() (localctx IXmlserialize_param_enconding_partContext) { + localctx = NewXmlserialize_param_enconding_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2220, PlSqlParserRULE_xmlserialize_param_enconding_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19047) + p.Match(PlSqlParserENCODING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19048) + p.concatenation(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 +} + +// IXmlserialize_param_version_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_version_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + VERSION() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_version_partContext differentiates from other interfaces. + IsXmlserialize_param_version_partContext() +} + +type Xmlserialize_param_version_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_version_partContext() *Xmlserialize_param_version_partContext { + var p = new(Xmlserialize_param_version_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part + return p +} + +func InitEmptyXmlserialize_param_version_partContext(p *Xmlserialize_param_version_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part +} + +func (*Xmlserialize_param_version_partContext) IsXmlserialize_param_version_partContext() {} + +func NewXmlserialize_param_version_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_version_partContext { + var p = new(Xmlserialize_param_version_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_version_part + + return p +} + +func (s *Xmlserialize_param_version_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_version_partContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Xmlserialize_param_version_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_version_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_version_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_version_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_version_part(s) + } +} + +func (s *Xmlserialize_param_version_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_version_part(s) + } +} + +func (s *Xmlserialize_param_version_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlserialize_param_version_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_version_part() (localctx IXmlserialize_param_version_partContext) { + localctx = NewXmlserialize_param_version_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2222, PlSqlParserRULE_xmlserialize_param_version_part) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19050) + p.Match(PlSqlParserVERSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19051) + p.concatenation(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 +} + +// IXmlserialize_param_ident_partContext is an interface to support dynamic dispatch. +type IXmlserialize_param_ident_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NO() antlr.TerminalNode + INDENT() antlr.TerminalNode + SIZE() antlr.TerminalNode + EQUALS_OP() antlr.TerminalNode + Concatenation() IConcatenationContext + + // IsXmlserialize_param_ident_partContext differentiates from other interfaces. + IsXmlserialize_param_ident_partContext() +} + +type Xmlserialize_param_ident_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmlserialize_param_ident_partContext() *Xmlserialize_param_ident_partContext { + var p = new(Xmlserialize_param_ident_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part + return p +} + +func InitEmptyXmlserialize_param_ident_partContext(p *Xmlserialize_param_ident_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part +} + +func (*Xmlserialize_param_ident_partContext) IsXmlserialize_param_ident_partContext() {} + +func NewXmlserialize_param_ident_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xmlserialize_param_ident_partContext { + var p = new(Xmlserialize_param_ident_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmlserialize_param_ident_part + + return p +} + +func (s *Xmlserialize_param_ident_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xmlserialize_param_ident_partContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Xmlserialize_param_ident_partContext) INDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDENT, 0) +} + +func (s *Xmlserialize_param_ident_partContext) SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZE, 0) +} + +func (s *Xmlserialize_param_ident_partContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *Xmlserialize_param_ident_partContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *Xmlserialize_param_ident_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xmlserialize_param_ident_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xmlserialize_param_ident_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmlserialize_param_ident_part(s) + } +} + +func (s *Xmlserialize_param_ident_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmlserialize_param_ident_part(s) + } +} + +func (s *Xmlserialize_param_ident_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmlserialize_param_ident_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmlserialize_param_ident_part() (localctx IXmlserialize_param_ident_partContext) { + localctx = NewXmlserialize_param_ident_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2224, PlSqlParserRULE_xmlserialize_param_ident_part) + var _la int + + p.SetState(19061) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserNO: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19053) + p.Match(PlSqlParserNO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19054) + p.Match(PlSqlParserINDENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDENT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19055) + p.Match(PlSqlParserINDENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19059) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserSIZE { + { + p.SetState(19056) + p.Match(PlSqlParserSIZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19057) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19058) + p.concatenation(0) + } + + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.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_plus_commandContext is an interface to support dynamic dispatch. +type ISql_plus_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SOLIDUS() antlr.TerminalNode + EXIT() antlr.TerminalNode + PROMPT_MESSAGE() antlr.TerminalNode + SHOW() antlr.TerminalNode + ERR() antlr.TerminalNode + ERRORS() antlr.TerminalNode + START_CMD() antlr.TerminalNode + Whenever_command() IWhenever_commandContext + Set_command() ISet_commandContext + Timing_command() ITiming_commandContext + + // IsSql_plus_commandContext differentiates from other interfaces. + IsSql_plus_commandContext() +} + +type Sql_plus_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySql_plus_commandContext() *Sql_plus_commandContext { + var p = new(Sql_plus_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_command + return p +} + +func InitEmptySql_plus_commandContext(p *Sql_plus_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sql_plus_command +} + +func (*Sql_plus_commandContext) IsSql_plus_commandContext() {} + +func NewSql_plus_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sql_plus_commandContext { + var p = new(Sql_plus_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sql_plus_command + + return p +} + +func (s *Sql_plus_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sql_plus_commandContext) SOLIDUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOLIDUS, 0) +} + +func (s *Sql_plus_commandContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Sql_plus_commandContext) PROMPT_MESSAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROMPT_MESSAGE, 0) +} + +func (s *Sql_plus_commandContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Sql_plus_commandContext) ERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERR, 0) +} + +func (s *Sql_plus_commandContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Sql_plus_commandContext) START_CMD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART_CMD, 0) +} + +func (s *Sql_plus_commandContext) Whenever_command() IWhenever_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IWhenever_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IWhenever_commandContext) +} + +func (s *Sql_plus_commandContext) Set_command() ISet_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISet_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISet_commandContext) +} + +func (s *Sql_plus_commandContext) Timing_command() ITiming_commandContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITiming_commandContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITiming_commandContext) +} + +func (s *Sql_plus_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sql_plus_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sql_plus_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSql_plus_command(s) + } +} + +func (s *Sql_plus_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSql_plus_command(s) + } +} + +func (s *Sql_plus_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSql_plus_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sql_plus_command() (localctx ISql_plus_commandContext) { + localctx = NewSql_plus_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2226, PlSqlParserRULE_sql_plus_command) + var _la int + + p.SetState(19072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserSOLIDUS: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19063) + p.Match(PlSqlParserSOLIDUS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXIT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19064) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPROMPT_MESSAGE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19065) + p.Match(PlSqlParserPROMPT_MESSAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSHOW: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19066) + p.Match(PlSqlParserSHOW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19067) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserERR || _la == PlSqlParserERRORS) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case PlSqlParserSTART_CMD: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19068) + p.Match(PlSqlParserSTART_CMD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWHENEVER: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19069) + p.Whenever_command() + } + + case PlSqlParserSET: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19070) + p.Set_command() + } + + case PlSqlParserTIMING: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19071) + p.Timing_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 +} + +// IWhenever_commandContext is an interface to support dynamic dispatch. +type IWhenever_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + WHENEVER() antlr.TerminalNode + SQLERROR() antlr.TerminalNode + OSERROR() antlr.TerminalNode + EXIT() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + SUCCESS() antlr.TerminalNode + FAILURE() antlr.TerminalNode + WARNING() antlr.TerminalNode + Variable_name() IVariable_nameContext + Numeric() INumericContext + COMMIT() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + NONE() antlr.TerminalNode + + // IsWhenever_commandContext differentiates from other interfaces. + IsWhenever_commandContext() +} + +type Whenever_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyWhenever_commandContext() *Whenever_commandContext { + var p = new(Whenever_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_whenever_command + return p +} + +func InitEmptyWhenever_commandContext(p *Whenever_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_whenever_command +} + +func (*Whenever_commandContext) IsWhenever_commandContext() {} + +func NewWhenever_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Whenever_commandContext { + var p = new(Whenever_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_whenever_command + + return p +} + +func (s *Whenever_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Whenever_commandContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Whenever_commandContext) SQLERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLERROR, 0) +} + +func (s *Whenever_commandContext) OSERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOSERROR, 0) +} + +func (s *Whenever_commandContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Whenever_commandContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Whenever_commandContext) SUCCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESS, 0) +} + +func (s *Whenever_commandContext) FAILURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILURE, 0) +} + +func (s *Whenever_commandContext) WARNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserWARNING, 0) +} + +func (s *Whenever_commandContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Whenever_commandContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Whenever_commandContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Whenever_commandContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Whenever_commandContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Whenever_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Whenever_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Whenever_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterWhenever_command(s) + } +} + +func (s *Whenever_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWhenever_command(s) + } +} + +func (s *Whenever_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWhenever_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Whenever_command() (localctx IWhenever_commandContext) { + localctx = NewWhenever_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2228, PlSqlParserRULE_whenever_command) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19074) + p.Match(PlSqlParserWHENEVER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19075) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserOSERROR || _la == PlSqlParserSQLERROR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19091) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserEXIT: + { + p.SetState(19076) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19082) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2667, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19077) + p.Match(PlSqlParserSUCCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19078) + p.Match(PlSqlParserFAILURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(19079) + p.Match(PlSqlParserWARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(19080) + p.Variable_name() + } + + case 5: + { + p.SetState(19081) + p.Numeric() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(19085) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2668, p.GetParserRuleContext()) == 1 { + { + p.SetState(19084) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserCONTINUE: + { + p.SetState(19087) + p.Match(PlSqlParserCONTINUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19089) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2669, p.GetParserRuleContext()) == 1 { + { + p.SetState(19088) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOMMIT || _la == PlSqlParserNONE || _la == PlSqlParserROLLBACK) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } 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 +} + +// ISet_commandContext is an interface to support dynamic dispatch. +type ISet_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + SET() antlr.TerminalNode + AllRegular_id() []IRegular_idContext + Regular_id(i int) IRegular_idContext + CHAR_STRING() antlr.TerminalNode + ON() antlr.TerminalNode + OFF() antlr.TerminalNode + Numeric() INumericContext + + // IsSet_commandContext differentiates from other interfaces. + IsSet_commandContext() +} + +type Set_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySet_commandContext() *Set_commandContext { + var p = new(Set_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_command + return p +} + +func InitEmptySet_commandContext(p *Set_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_set_command +} + +func (*Set_commandContext) IsSet_commandContext() {} + +func NewSet_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Set_commandContext { + var p = new(Set_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_set_command + + return p +} + +func (s *Set_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Set_commandContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Set_commandContext) AllRegular_id() []IRegular_idContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRegular_idContext); ok { + len++ + } + } + + tst := make([]IRegular_idContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRegular_idContext); ok { + tst[i] = t.(IRegular_idContext) + i++ + } + } + + return tst +} + +func (s *Set_commandContext) Regular_id(i int) IRegular_idContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Set_commandContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Set_commandContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Set_commandContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Set_commandContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Set_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Set_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Set_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSet_command(s) + } +} + +func (s *Set_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSet_command(s) + } +} + +func (s *Set_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSet_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Set_command() (localctx ISet_commandContext) { + localctx = NewSet_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2230, PlSqlParserRULE_set_command) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19093) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19094) + p.Regular_id() + } + p.SetState(19100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2671, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19095) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19096) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(19097) + p.Match(PlSqlParserOFF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + { + p.SetState(19098) + p.Numeric() + } + + case 5: + { + p.SetState(19099) + p.Regular_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 +} + +// ITiming_commandContext is an interface to support dynamic dispatch. +type ITiming_commandContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // GetTiming_text returns the timing_text rule contexts. + GetTiming_text() IId_expressionContext + + // SetTiming_text sets the timing_text rule contexts. + SetTiming_text(IId_expressionContext) + + // Getter signatures + TIMING() antlr.TerminalNode + START() antlr.TerminalNode + SHOW() antlr.TerminalNode + STOP() antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsTiming_commandContext differentiates from other interfaces. + IsTiming_commandContext() +} + +type Timing_commandContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser + timing_text IId_expressionContext +} + +func NewEmptyTiming_commandContext() *Timing_commandContext { + var p = new(Timing_commandContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_command + return p +} + +func InitEmptyTiming_commandContext(p *Timing_commandContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_timing_command +} + +func (*Timing_commandContext) IsTiming_commandContext() {} + +func NewTiming_commandContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Timing_commandContext { + var p = new(Timing_commandContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_timing_command + + return p +} + +func (s *Timing_commandContext) GetParser() antlr.Parser { return s.parser } + +func (s *Timing_commandContext) GetTiming_text() IId_expressionContext { return s.timing_text } + +func (s *Timing_commandContext) SetTiming_text(v IId_expressionContext) { s.timing_text = v } + +func (s *Timing_commandContext) TIMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMING, 0) +} + +func (s *Timing_commandContext) START() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTART, 0) +} + +func (s *Timing_commandContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Timing_commandContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Timing_commandContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Timing_commandContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Timing_commandContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Timing_commandContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Timing_commandContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTiming_command(s) + } +} + +func (s *Timing_commandContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTiming_command(s) + } +} + +func (s *Timing_commandContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTiming_command(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Timing_command() (localctx ITiming_commandContext) { + localctx = NewTiming_commandContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2232, PlSqlParserRULE_timing_command) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19102) + p.Match(PlSqlParserTIMING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19112) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2673, p.GetParserRuleContext()) == 1 { + { + p.SetState(19103) + p.Match(PlSqlParserSTART) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19107) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2672, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19104) + + var _x = p.Id_expression() + + localctx.(*Timing_commandContext).timing_text = _x + } + + } + p.SetState(19109) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2672, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2673, p.GetParserRuleContext()) == 2 { + { + p.SetState(19110) + p.Match(PlSqlParserSHOW) + 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(), 2673, p.GetParserRuleContext()) == 3 { + { + p.SetState(19111) + p.Match(PlSqlParserSTOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IPartition_extension_clauseContext is an interface to support dynamic dispatch. +type IPartition_extension_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + PARTITION() antlr.TerminalNode + FOR() antlr.TerminalNode + Expressions() IExpressionsContext + + // IsPartition_extension_clauseContext differentiates from other interfaces. + IsPartition_extension_clauseContext() +} + +type Partition_extension_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPartition_extension_clauseContext() *Partition_extension_clauseContext { + var p = new(Partition_extension_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extension_clause + return p +} + +func InitEmptyPartition_extension_clauseContext(p *Partition_extension_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_partition_extension_clause +} + +func (*Partition_extension_clauseContext) IsPartition_extension_clauseContext() {} + +func NewPartition_extension_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Partition_extension_clauseContext { + var p = new(Partition_extension_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_partition_extension_clause + + return p +} + +func (s *Partition_extension_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Partition_extension_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Partition_extension_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Partition_extension_clauseContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Partition_extension_clauseContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Partition_extension_clauseContext) FOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOR, 0) +} + +func (s *Partition_extension_clauseContext) Expressions() IExpressionsContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionsContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionsContext) +} + +func (s *Partition_extension_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Partition_extension_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Partition_extension_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPartition_extension_clause(s) + } +} + +func (s *Partition_extension_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPartition_extension_clause(s) + } +} + +func (s *Partition_extension_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPartition_extension_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Partition_extension_clause() (localctx IPartition_extension_clauseContext) { + localctx = NewPartition_extension_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2234, PlSqlParserRULE_partition_extension_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19114) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPARTITION || _la == PlSqlParserSUBPARTITION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19116) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserFOR { + { + p.SetState(19115) + p.Match(PlSqlParserFOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19118) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(19119) + p.Expressions() + } + + } + { + p.SetState(19122) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_aliasContext is an interface to support dynamic dispatch. +type IColumn_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + AS() antlr.TerminalNode + + // IsColumn_aliasContext differentiates from other interfaces. + IsColumn_aliasContext() +} + +type Column_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyColumn_aliasContext() *Column_aliasContext { + var p = new(Column_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_alias + return p +} + +func InitEmptyColumn_aliasContext(p *Column_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_column_alias +} + +func (*Column_aliasContext) IsColumn_aliasContext() {} + +func NewColumn_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Column_aliasContext { + var p = new(Column_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_column_alias + + return p +} + +func (s *Column_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Column_aliasContext) AS() antlr.TerminalNode { + return s.GetToken(PlSqlParserAS, 0) +} + +func (s *Column_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Column_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Column_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterColumn_alias(s) + } +} + +func (s *Column_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_alias(s) + } +} + +func (s *Column_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_alias() (localctx IColumn_aliasContext) { + localctx = NewColumn_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2236, PlSqlParserRULE_column_alias) + var _la int + + p.SetState(19132) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2678, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + p.SetState(19125) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserAS { + { + p.SetState(19124) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19129) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2677, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19127) + p.Identifier() + } + + case 2: + { + p.SetState(19128) + p.Quoted_string() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19131) + p.Match(PlSqlParserAS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_aliasContext is an interface to support dynamic dispatch. +type ITable_aliasContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + + // IsTable_aliasContext differentiates from other interfaces. + IsTable_aliasContext() +} + +type Table_aliasContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_aliasContext() *Table_aliasContext { + var p = new(Table_aliasContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_alias + return p +} + +func InitEmptyTable_aliasContext(p *Table_aliasContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_alias +} + +func (*Table_aliasContext) IsTable_aliasContext() {} + +func NewTable_aliasContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_aliasContext { + var p = new(Table_aliasContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_alias + + return p +} + +func (s *Table_aliasContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_aliasContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_aliasContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Table_aliasContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_aliasContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_aliasContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_alias(s) + } +} + +func (s *Table_aliasContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_alias(s) + } +} + +func (s *Table_aliasContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_alias(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_alias() (localctx ITable_aliasContext) { + localctx = NewTable_aliasContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2238, PlSqlParserRULE_table_alias) + p.SetState(19136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2679, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19134) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19135) + p.Quoted_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 +} + +// 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 + CURRENT() antlr.TerminalNode + OF() antlr.TerminalNode + Cursor_name() ICursor_nameContext + Expression() IExpressionContext + Quantitative_where_stmt() IQuantitative_where_stmtContext + + // 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 = PlSqlParserRULE_where_clause + return p +} + +func InitEmptyWhere_clauseContext(p *Where_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_where_clause + + return p +} + +func (s *Where_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Where_clauseContext) WHERE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHERE, 0) +} + +func (s *Where_clauseContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Where_clauseContext) OF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOF, 0) +} + +func (s *Where_clauseContext) Cursor_name() ICursor_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ICursor_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ICursor_nameContext) +} + +func (s *Where_clauseContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Where_clauseContext) Quantitative_where_stmt() IQuantitative_where_stmtContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuantitative_where_stmtContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuantitative_where_stmtContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterWhere_clause(s) + } +} + +func (s *Where_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitWhere_clause(s) + } +} + +func (s *Where_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitWhere_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Where_clause() (localctx IWhere_clauseContext) { + localctx = NewWhere_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2240, PlSqlParserRULE_where_clause) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19138) + p.Match(PlSqlParserWHERE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19144) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2680, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19139) + p.Match(PlSqlParserCURRENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19140) + p.Match(PlSqlParserOF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19141) + p.Cursor_name() + } + + case 2: + { + p.SetState(19142) + p.Expression() + } + + case 3: + { + p.SetState(19143) + p.Quantitative_where_stmt() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuantitative_where_stmtContext is an interface to support dynamic dispatch. +type IQuantitative_where_stmtContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + Relational_operator() IRelational_operatorContext + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + SOME() antlr.TerminalNode + ALL() antlr.TerminalNode + ANY() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsQuantitative_where_stmtContext differentiates from other interfaces. + IsQuantitative_where_stmtContext() +} + +type Quantitative_where_stmtContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuantitative_where_stmtContext() *Quantitative_where_stmtContext { + var p = new(Quantitative_where_stmtContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantitative_where_stmt + return p +} + +func InitEmptyQuantitative_where_stmtContext(p *Quantitative_where_stmtContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quantitative_where_stmt +} + +func (*Quantitative_where_stmtContext) IsQuantitative_where_stmtContext() {} + +func NewQuantitative_where_stmtContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quantitative_where_stmtContext { + var p = new(Quantitative_where_stmtContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quantitative_where_stmt + + return p +} + +func (s *Quantitative_where_stmtContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quantitative_where_stmtContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Quantitative_where_stmtContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Quantitative_where_stmtContext) Relational_operator() IRelational_operatorContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRelational_operatorContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRelational_operatorContext) +} + +func (s *Quantitative_where_stmtContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Quantitative_where_stmtContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Quantitative_where_stmtContext) SOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOME, 0) +} + +func (s *Quantitative_where_stmtContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Quantitative_where_stmtContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *Quantitative_where_stmtContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Quantitative_where_stmtContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Quantitative_where_stmtContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quantitative_where_stmtContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quantitative_where_stmtContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuantitative_where_stmt(s) + } +} + +func (s *Quantitative_where_stmtContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuantitative_where_stmt(s) + } +} + +func (s *Quantitative_where_stmtContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuantitative_where_stmt(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quantitative_where_stmt() (localctx IQuantitative_where_stmtContext) { + localctx = NewQuantitative_where_stmtContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2242, PlSqlParserRULE_quantitative_where_stmt) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19146) + p.Expression() + } + { + p.SetState(19147) + p.Relational_operator() + } + { + p.SetState(19148) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALL || _la == PlSqlParserANY || _la == PlSqlParserSOME) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19149) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19150) + p.Expression() + } + p.SetState(19155) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19151) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19152) + p.Expression() + } + + p.SetState(19157) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + { + p.SetState(19158) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// 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 + AllGeneral_element() []IGeneral_elementContext + General_element(i int) IGeneral_elementContext + AllBind_variable() []IBind_variableContext + Bind_variable(i int) IBind_variableContext + BULK() antlr.TerminalNode + COLLECT() antlr.TerminalNode + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // 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 = PlSqlParserRULE_into_clause + return p +} + +func InitEmptyInto_clauseContext(p *Into_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_into_clause + + return p +} + +func (s *Into_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Into_clauseContext) INTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTO, 0) +} + +func (s *Into_clauseContext) AllGeneral_element() []IGeneral_elementContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_elementContext); ok { + len++ + } + } + + tst := make([]IGeneral_elementContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_elementContext); ok { + tst[i] = t.(IGeneral_elementContext) + i++ + } + } + + return tst +} + +func (s *Into_clauseContext) General_element(i int) IGeneral_elementContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Into_clauseContext) AllBind_variable() []IBind_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBind_variableContext); ok { + len++ + } + } + + tst := make([]IBind_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBind_variableContext); ok { + tst[i] = t.(IBind_variableContext) + i++ + } + } + + return tst +} + +func (s *Into_clauseContext) Bind_variable(i int) IBind_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Into_clauseContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Into_clauseContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Into_clauseContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Into_clauseContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterInto_clause(s) + } +} + +func (s *Into_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitInto_clause(s) + } +} + +func (s *Into_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitInto_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Into_clause() (localctx IInto_clauseContext) { + localctx = NewInto_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2244, PlSqlParserRULE_into_clause) + var _la int + + var _alt int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19162) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBULK { + { + p.SetState(19160) + p.Match(PlSqlParserBULK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19161) + p.Match(PlSqlParserCOLLECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19164) + p.Match(PlSqlParserINTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19167) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(19165) + p.General_element() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(19166) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(19176) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2685, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19169) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19172) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + { + p.SetState(19170) + p.General_element() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(19171) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(19178) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2685, 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 +} + +// IXml_column_nameContext is an interface to support dynamic dispatch. +type IXml_column_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Quoted_string() IQuoted_stringContext + + // IsXml_column_nameContext differentiates from other interfaces. + IsXml_column_nameContext() +} + +type Xml_column_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXml_column_nameContext() *Xml_column_nameContext { + var p = new(Xml_column_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_column_name + return p +} + +func InitEmptyXml_column_nameContext(p *Xml_column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xml_column_name +} + +func (*Xml_column_nameContext) IsXml_column_nameContext() {} + +func NewXml_column_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Xml_column_nameContext { + var p = new(Xml_column_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xml_column_name + + return p +} + +func (s *Xml_column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Xml_column_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Xml_column_nameContext) Quoted_string() IQuoted_stringContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Xml_column_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Xml_column_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Xml_column_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXml_column_name(s) + } +} + +func (s *Xml_column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXml_column_name(s) + } +} + +func (s *Xml_column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXml_column_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xml_column_name() (localctx IXml_column_nameContext) { + localctx = NewXml_column_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2246, PlSqlParserRULE_xml_column_name) + p.SetState(19181) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2686, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19179) + p.Identifier() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19180) + p.Quoted_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 +} + +// ICost_class_nameContext is an interface to support dynamic dispatch. +type ICost_class_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsCost_class_nameContext differentiates from other interfaces. + IsCost_class_nameContext() +} + +type Cost_class_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCost_class_nameContext() *Cost_class_nameContext { + var p = new(Cost_class_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_class_name + return p +} + +func InitEmptyCost_class_nameContext(p *Cost_class_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cost_class_name +} + +func (*Cost_class_nameContext) IsCost_class_nameContext() {} + +func NewCost_class_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cost_class_nameContext { + var p = new(Cost_class_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cost_class_name + + return p +} + +func (s *Cost_class_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cost_class_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Cost_class_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cost_class_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cost_class_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCost_class_name(s) + } +} + +func (s *Cost_class_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCost_class_name(s) + } +} + +func (s *Cost_class_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCost_class_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cost_class_name() (localctx ICost_class_nameContext) { + localctx = NewCost_class_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2248, PlSqlParserRULE_cost_class_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19183) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAttribute_nameContext is an interface to support dynamic dispatch. +type IAttribute_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsAttribute_nameContext differentiates from other interfaces. + IsAttribute_nameContext() +} + +type Attribute_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAttribute_nameContext() *Attribute_nameContext { + var p = new(Attribute_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_name + return p +} + +func InitEmptyAttribute_nameContext(p *Attribute_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_attribute_name +} + +func (*Attribute_nameContext) IsAttribute_nameContext() {} + +func NewAttribute_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Attribute_nameContext { + var p = new(Attribute_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_attribute_name + + return p +} + +func (s *Attribute_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Attribute_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Attribute_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Attribute_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Attribute_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAttribute_name(s) + } +} + +func (s *Attribute_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAttribute_name(s) + } +} + +func (s *Attribute_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAttribute_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Attribute_name() (localctx IAttribute_nameContext) { + localctx = NewAttribute_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2250, PlSqlParserRULE_attribute_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19185) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISavepoint_nameContext is an interface to support dynamic dispatch. +type ISavepoint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsSavepoint_nameContext differentiates from other interfaces. + IsSavepoint_nameContext() +} + +type Savepoint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySavepoint_nameContext() *Savepoint_nameContext { + var p = new(Savepoint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_name + return p +} + +func InitEmptySavepoint_nameContext(p *Savepoint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_savepoint_name +} + +func (*Savepoint_nameContext) IsSavepoint_nameContext() {} + +func NewSavepoint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Savepoint_nameContext { + var p = new(Savepoint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_savepoint_name + + return p +} + +func (s *Savepoint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Savepoint_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Savepoint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Savepoint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Savepoint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSavepoint_name(s) + } +} + +func (s *Savepoint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSavepoint_name(s) + } +} + +func (s *Savepoint_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSavepoint_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Savepoint_name() (localctx ISavepoint_nameContext) { + localctx = NewSavepoint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2252, PlSqlParserRULE_savepoint_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19187) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRollback_segment_nameContext is an interface to support dynamic dispatch. +type IRollback_segment_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsRollback_segment_nameContext differentiates from other interfaces. + IsRollback_segment_nameContext() +} + +type Rollback_segment_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRollback_segment_nameContext() *Rollback_segment_nameContext { + var p = new(Rollback_segment_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment_name + return p +} + +func InitEmptyRollback_segment_nameContext(p *Rollback_segment_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_rollback_segment_name +} + +func (*Rollback_segment_nameContext) IsRollback_segment_nameContext() {} + +func NewRollback_segment_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Rollback_segment_nameContext { + var p = new(Rollback_segment_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_rollback_segment_name + + return p +} + +func (s *Rollback_segment_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Rollback_segment_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Rollback_segment_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Rollback_segment_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Rollback_segment_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRollback_segment_name(s) + } +} + +func (s *Rollback_segment_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRollback_segment_name(s) + } +} + +func (s *Rollback_segment_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRollback_segment_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Rollback_segment_name() (localctx IRollback_segment_nameContext) { + localctx = NewRollback_segment_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2254, PlSqlParserRULE_rollback_segment_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19189) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITable_var_nameContext is an interface to support dynamic dispatch. +type ITable_var_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsTable_var_nameContext differentiates from other interfaces. + IsTable_var_nameContext() +} + +type Table_var_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_var_nameContext() *Table_var_nameContext { + var p = new(Table_var_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_var_name + return p +} + +func InitEmptyTable_var_nameContext(p *Table_var_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_var_name +} + +func (*Table_var_nameContext) IsTable_var_nameContext() {} + +func NewTable_var_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_var_nameContext { + var p = new(Table_var_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_var_name + + return p +} + +func (s *Table_var_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_var_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Table_var_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_var_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_var_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_var_name(s) + } +} + +func (s *Table_var_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_var_name(s) + } +} + +func (s *Table_var_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_var_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_var_name() (localctx ITable_var_nameContext) { + localctx = NewTable_var_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2256, PlSqlParserRULE_table_var_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19191) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_nameContext is an interface to support dynamic dispatch. +type ISchema_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // 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 = PlSqlParserRULE_schema_name + return p +} + +func InitEmptySchema_nameContext(p *Schema_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_schema_name + + return p +} + +func (s *Schema_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *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.(PlSqlParserListener); ok { + listenerT.EnterSchema_name(s) + } +} + +func (s *Schema_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSchema_name(s) + } +} + +func (s *Schema_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSchema_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Schema_name() (localctx ISchema_nameContext) { + localctx = NewSchema_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2258, PlSqlParserRULE_schema_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19193) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRoutine_nameContext is an interface to support dynamic dispatch. +type IRoutine_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsRoutine_nameContext differentiates from other interfaces. + IsRoutine_nameContext() +} + +type Routine_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRoutine_nameContext() *Routine_nameContext { + var p = new(Routine_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_name + return p +} + +func InitEmptyRoutine_nameContext(p *Routine_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_routine_name +} + +func (*Routine_nameContext) IsRoutine_nameContext() {} + +func NewRoutine_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Routine_nameContext { + var p = new(Routine_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_routine_name + + return p +} + +func (s *Routine_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Routine_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Routine_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Routine_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Routine_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Routine_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Routine_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Routine_nameContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Routine_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Routine_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Routine_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRoutine_name(s) + } +} + +func (s *Routine_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRoutine_name(s) + } +} + +func (s *Routine_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRoutine_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Routine_name() (localctx IRoutine_nameContext) { + localctx = NewRoutine_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2260, PlSqlParserRULE_routine_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19195) + p.Identifier() + } + p.SetState(19200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2687, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19196) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19197) + p.Id_expression() + } + + } + p.SetState(19202) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2687, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(19205) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2688, p.GetParserRuleContext()) == 1 { + { + p.SetState(19203) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19204) + p.Link_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 +} + +// IPackage_nameContext is an interface to support dynamic dispatch. +type IPackage_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsPackage_nameContext differentiates from other interfaces. + IsPackage_nameContext() +} + +type Package_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPackage_nameContext() *Package_nameContext { + var p = new(Package_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_name + return p +} + +func InitEmptyPackage_nameContext(p *Package_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_package_name +} + +func (*Package_nameContext) IsPackage_nameContext() {} + +func NewPackage_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Package_nameContext { + var p = new(Package_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_package_name + + return p +} + +func (s *Package_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Package_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Package_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Package_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Package_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPackage_name(s) + } +} + +func (s *Package_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPackage_name(s) + } +} + +func (s *Package_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPackage_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Package_name() (localctx IPackage_nameContext) { + localctx = NewPackage_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2262, PlSqlParserRULE_package_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19207) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IImplementation_type_nameContext is an interface to support dynamic dispatch. +type IImplementation_type_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsImplementation_type_nameContext differentiates from other interfaces. + IsImplementation_type_nameContext() +} + +type Implementation_type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyImplementation_type_nameContext() *Implementation_type_nameContext { + var p = new(Implementation_type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_type_name + return p +} + +func InitEmptyImplementation_type_nameContext(p *Implementation_type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_implementation_type_name +} + +func (*Implementation_type_nameContext) IsImplementation_type_nameContext() {} + +func NewImplementation_type_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Implementation_type_nameContext { + var p = new(Implementation_type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_implementation_type_name + + return p +} + +func (s *Implementation_type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Implementation_type_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Implementation_type_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Implementation_type_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Implementation_type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Implementation_type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Implementation_type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterImplementation_type_name(s) + } +} + +func (s *Implementation_type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitImplementation_type_name(s) + } +} + +func (s *Implementation_type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitImplementation_type_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Implementation_type_name() (localctx IImplementation_type_nameContext) { + localctx = NewImplementation_type_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2264, PlSqlParserRULE_implementation_type_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19209) + p.Identifier() + } + p.SetState(19212) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(19210) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19211) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IParameter_nameContext is an interface to support dynamic dispatch. +type IParameter_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsParameter_nameContext differentiates from other interfaces. + IsParameter_nameContext() +} + +type Parameter_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParameter_nameContext() *Parameter_nameContext { + var p = new(Parameter_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_name + return p +} + +func InitEmptyParameter_nameContext(p *Parameter_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_parameter_name +} + +func (*Parameter_nameContext) IsParameter_nameContext() {} + +func NewParameter_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Parameter_nameContext { + var p = new(Parameter_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_parameter_name + + return p +} + +func (s *Parameter_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Parameter_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Parameter_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Parameter_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Parameter_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParameter_name(s) + } +} + +func (s *Parameter_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParameter_name(s) + } +} + +func (s *Parameter_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParameter_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Parameter_name() (localctx IParameter_nameContext) { + localctx = NewParameter_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2266, PlSqlParserRULE_parameter_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19214) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IReference_model_nameContext is an interface to support dynamic dispatch. +type IReference_model_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsReference_model_nameContext differentiates from other interfaces. + IsReference_model_nameContext() +} + +type Reference_model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyReference_model_nameContext() *Reference_model_nameContext { + var p = new(Reference_model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model_name + return p +} + +func InitEmptyReference_model_nameContext(p *Reference_model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_reference_model_name +} + +func (*Reference_model_nameContext) IsReference_model_nameContext() {} + +func NewReference_model_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Reference_model_nameContext { + var p = new(Reference_model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_reference_model_name + + return p +} + +func (s *Reference_model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Reference_model_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Reference_model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Reference_model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Reference_model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterReference_model_name(s) + } +} + +func (s *Reference_model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitReference_model_name(s) + } +} + +func (s *Reference_model_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitReference_model_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Reference_model_name() (localctx IReference_model_nameContext) { + localctx = NewReference_model_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2268, PlSqlParserRULE_reference_model_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19216) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IMain_model_nameContext is an interface to support dynamic dispatch. +type IMain_model_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsMain_model_nameContext differentiates from other interfaces. + IsMain_model_nameContext() +} + +type Main_model_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyMain_model_nameContext() *Main_model_nameContext { + var p = new(Main_model_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model_name + return p +} + +func InitEmptyMain_model_nameContext(p *Main_model_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_main_model_name +} + +func (*Main_model_nameContext) IsMain_model_nameContext() {} + +func NewMain_model_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Main_model_nameContext { + var p = new(Main_model_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_main_model_name + + return p +} + +func (s *Main_model_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Main_model_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Main_model_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Main_model_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Main_model_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterMain_model_name(s) + } +} + +func (s *Main_model_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitMain_model_name(s) + } +} + +func (s *Main_model_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitMain_model_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Main_model_name() (localctx IMain_model_nameContext) { + localctx = NewMain_model_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2270, PlSqlParserRULE_main_model_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19218) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IContainer_tableview_nameContext is an interface to support dynamic dispatch. +type IContainer_tableview_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsContainer_tableview_nameContext differentiates from other interfaces. + IsContainer_tableview_nameContext() +} + +type Container_tableview_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyContainer_tableview_nameContext() *Container_tableview_nameContext { + var p = new(Container_tableview_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_tableview_name + return p +} + +func InitEmptyContainer_tableview_nameContext(p *Container_tableview_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_container_tableview_name +} + +func (*Container_tableview_nameContext) IsContainer_tableview_nameContext() {} + +func NewContainer_tableview_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Container_tableview_nameContext { + var p = new(Container_tableview_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_container_tableview_name + + return p +} + +func (s *Container_tableview_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Container_tableview_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Container_tableview_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Container_tableview_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Container_tableview_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Container_tableview_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Container_tableview_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterContainer_tableview_name(s) + } +} + +func (s *Container_tableview_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitContainer_tableview_name(s) + } +} + +func (s *Container_tableview_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitContainer_tableview_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Container_tableview_name() (localctx IContainer_tableview_nameContext) { + localctx = NewContainer_tableview_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2272, PlSqlParserRULE_container_tableview_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19220) + p.Identifier() + } + p.SetState(19223) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(19221) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19222) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IAggregate_function_nameContext is an interface to support dynamic dispatch. +type IAggregate_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsAggregate_function_nameContext differentiates from other interfaces. + IsAggregate_function_nameContext() +} + +type Aggregate_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyAggregate_function_nameContext() *Aggregate_function_nameContext { + var p = new(Aggregate_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_function_name + return p +} + +func InitEmptyAggregate_function_nameContext(p *Aggregate_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_aggregate_function_name +} + +func (*Aggregate_function_nameContext) IsAggregate_function_nameContext() {} + +func NewAggregate_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Aggregate_function_nameContext { + var p = new(Aggregate_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_aggregate_function_name + + return p +} + +func (s *Aggregate_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Aggregate_function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Aggregate_function_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Aggregate_function_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Aggregate_function_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Aggregate_function_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Aggregate_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Aggregate_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Aggregate_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterAggregate_function_name(s) + } +} + +func (s *Aggregate_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitAggregate_function_name(s) + } +} + +func (s *Aggregate_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitAggregate_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Aggregate_function_name() (localctx IAggregate_function_nameContext) { + localctx = NewAggregate_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2274, PlSqlParserRULE_aggregate_function_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19225) + p.Identifier() + } + p.SetState(19230) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2691, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19226) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19227) + p.Id_expression() + } + + } + p.SetState(19232) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2691, 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 +} + +// IQuery_nameContext is an interface to support dynamic dispatch. +type IQuery_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsQuery_nameContext differentiates from other interfaces. + IsQuery_nameContext() +} + +type Query_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuery_nameContext() *Query_nameContext { + var p = new(Query_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_name + return p +} + +func InitEmptyQuery_nameContext(p *Query_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_query_name +} + +func (*Query_nameContext) IsQuery_nameContext() {} + +func NewQuery_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Query_nameContext { + var p = new(Query_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_query_name + + return p +} + +func (s *Query_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Query_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Query_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Query_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Query_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuery_name(s) + } +} + +func (s *Query_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuery_name(s) + } +} + +func (s *Query_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuery_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Query_name() (localctx IQuery_nameContext) { + localctx = NewQuery_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2276, PlSqlParserRULE_query_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19233) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrantee_nameContext is an interface to support dynamic dispatch. +type IGrantee_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + Identified_by() IIdentified_byContext + + // IsGrantee_nameContext differentiates from other interfaces. + IsGrantee_nameContext() +} + +type Grantee_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrantee_nameContext() *Grantee_nameContext { + var p = new(Grantee_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grantee_name + return p +} + +func InitEmptyGrantee_nameContext(p *Grantee_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grantee_name +} + +func (*Grantee_nameContext) IsGrantee_nameContext() {} + +func NewGrantee_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grantee_nameContext { + var p = new(Grantee_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grantee_name + + return p +} + +func (s *Grantee_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grantee_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Grantee_nameContext) Identified_by() IIdentified_byContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentified_byContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentified_byContext) +} + +func (s *Grantee_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grantee_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grantee_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrantee_name(s) + } +} + +func (s *Grantee_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrantee_name(s) + } +} + +func (s *Grantee_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGrantee_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Grantee_name() (localctx IGrantee_nameContext) { + localctx = NewGrantee_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2278, PlSqlParserRULE_grantee_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19235) + p.Id_expression() + } + p.SetState(19237) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIDENTIFIED { + { + p.SetState(19236) + p.Identified_by() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRole_nameContext is an interface to support dynamic dispatch. +type IRole_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + CONNECT() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + + // 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 = PlSqlParserRULE_role_name + return p +} + +func InitEmptyRole_nameContext(p *Role_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_role_name + + return p +} + +func (s *Role_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Role_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Role_nameContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *Role_nameContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterRole_name(s) + } +} + +func (s *Role_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRole_name(s) + } +} + +func (s *Role_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRole_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Role_name() (localctx IRole_nameContext) { + localctx = NewRole_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2280, PlSqlParserRULE_role_name) + p.SetState(19242) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19239) + p.Id_expression() + } + + case PlSqlParserCONNECT: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19240) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRESOURCE: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19241) + p.Match(PlSqlParserRESOURCE) + 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 +} + +// IConstraint_nameContext is an interface to support dynamic dispatch. +type IConstraint_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + + // IsConstraint_nameContext differentiates from other interfaces. + IsConstraint_nameContext() +} + +type Constraint_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstraint_nameContext() *Constraint_nameContext { + var p = new(Constraint_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_name + return p +} + +func InitEmptyConstraint_nameContext(p *Constraint_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constraint_name +} + +func (*Constraint_nameContext) IsConstraint_nameContext() {} + +func NewConstraint_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constraint_nameContext { + var p = new(Constraint_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constraint_name + + return p +} + +func (s *Constraint_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constraint_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Constraint_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Constraint_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Constraint_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Constraint_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Constraint_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Constraint_nameContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Constraint_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constraint_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constraint_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstraint_name(s) + } +} + +func (s *Constraint_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstraint_name(s) + } +} + +func (s *Constraint_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstraint_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constraint_name() (localctx IConstraint_nameContext) { + localctx = NewConstraint_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2282, PlSqlParserRULE_constraint_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19244) + p.Identifier() + } + p.SetState(19249) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2694, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19245) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19246) + p.Id_expression() + } + + } + p.SetState(19251) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2694, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + p.SetState(19254) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2695, p.GetParserRuleContext()) == 1 { + { + p.SetState(19252) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19253) + p.Link_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 +} + +// ILabel_nameContext is an interface to support dynamic dispatch. +type ILabel_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsLabel_nameContext differentiates from other interfaces. + IsLabel_nameContext() +} + +type Label_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLabel_nameContext() *Label_nameContext { + var p = new(Label_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_name + return p +} + +func InitEmptyLabel_nameContext(p *Label_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_label_name +} + +func (*Label_nameContext) IsLabel_nameContext() {} + +func NewLabel_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Label_nameContext { + var p = new(Label_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_label_name + + return p +} + +func (s *Label_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Label_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Label_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Label_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Label_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLabel_name(s) + } +} + +func (s *Label_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLabel_name(s) + } +} + +func (s *Label_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLabel_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Label_name() (localctx ILabel_nameContext) { + localctx = NewLabel_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2284, PlSqlParserRULE_label_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19256) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_nameContext is an interface to support dynamic dispatch. +type IType_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsType_nameContext differentiates from other interfaces. + IsType_nameContext() +} + +type Type_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_nameContext() *Type_nameContext { + var p = new(Type_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_name + return p +} + +func InitEmptyType_nameContext(p *Type_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_name +} + +func (*Type_nameContext) IsType_nameContext() {} + +func NewType_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_nameContext { + var p = new(Type_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_name + + return p +} + +func (s *Type_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Type_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Type_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Type_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Type_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_name(s) + } +} + +func (s *Type_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_name(s) + } +} + +func (s *Type_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_name() (localctx IType_nameContext) { + localctx = NewType_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2286, PlSqlParserRULE_type_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19258) + p.Id_expression() + } + p.SetState(19263) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(19259) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19260) + p.Id_expression() + } + + p.SetState(19265) + 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 +} + +// ISequence_nameContext is an interface to support dynamic dispatch. +type ISequence_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsSequence_nameContext differentiates from other interfaces. + IsSequence_nameContext() +} + +type Sequence_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySequence_nameContext() *Sequence_nameContext { + var p = new(Sequence_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_name + return p +} + +func InitEmptySequence_nameContext(p *Sequence_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_sequence_name +} + +func (*Sequence_nameContext) IsSequence_nameContext() {} + +func NewSequence_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Sequence_nameContext { + var p = new(Sequence_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_sequence_name + + return p +} + +func (s *Sequence_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Sequence_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Sequence_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Sequence_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Sequence_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Sequence_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Sequence_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Sequence_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSequence_name(s) + } +} + +func (s *Sequence_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSequence_name(s) + } +} + +func (s *Sequence_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSequence_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Sequence_name() (localctx ISequence_nameContext) { + localctx = NewSequence_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2288, PlSqlParserRULE_sequence_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19266) + p.Id_expression() + } + p.SetState(19271) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(19267) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19268) + p.Id_expression() + } + + p.SetState(19273) + 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 +} + +// IException_nameContext is an interface to support dynamic dispatch. +type IException_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // IsException_nameContext differentiates from other interfaces. + IsException_nameContext() +} + +type Exception_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyException_nameContext() *Exception_nameContext { + var p = new(Exception_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_name + return p +} + +func InitEmptyException_nameContext(p *Exception_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_exception_name +} + +func (*Exception_nameContext) IsException_nameContext() {} + +func NewException_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Exception_nameContext { + var p = new(Exception_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_exception_name + + return p +} + +func (s *Exception_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Exception_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Exception_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Exception_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Exception_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Exception_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Exception_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Exception_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Exception_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterException_name(s) + } +} + +func (s *Exception_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitException_name(s) + } +} + +func (s *Exception_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitException_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Exception_name() (localctx IException_nameContext) { + localctx = NewException_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2290, PlSqlParserRULE_exception_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19274) + p.Identifier() + } + p.SetState(19279) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2698, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19275) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19276) + p.Id_expression() + } + + } + p.SetState(19281) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2698, 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 +} + +// IFunction_nameContext is an interface to support dynamic dispatch. +type IFunction_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsFunction_nameContext differentiates from other interfaces. + IsFunction_nameContext() +} + +type Function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_nameContext() *Function_nameContext { + var p = new(Function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_name + return p +} + +func InitEmptyFunction_nameContext(p *Function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_name +} + +func (*Function_nameContext) IsFunction_nameContext() {} + +func NewFunction_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_nameContext { + var p = new(Function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_name + + return p +} + +func (s *Function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Function_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Function_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_name(s) + } +} + +func (s *Function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_name(s) + } +} + +func (s *Function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_name() (localctx IFunction_nameContext) { + localctx = NewFunction_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2292, PlSqlParserRULE_function_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19282) + p.Identifier() + } + p.SetState(19285) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2699, p.GetParserRuleContext()) == 1 { + { + p.SetState(19283) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19284) + p.Id_expression() + } + + } 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 +} + +// IProcedure_nameContext is an interface to support dynamic dispatch. +type IProcedure_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsProcedure_nameContext differentiates from other interfaces. + IsProcedure_nameContext() +} + +type Procedure_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyProcedure_nameContext() *Procedure_nameContext { + var p = new(Procedure_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_name + return p +} + +func InitEmptyProcedure_nameContext(p *Procedure_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_procedure_name +} + +func (*Procedure_nameContext) IsProcedure_nameContext() {} + +func NewProcedure_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Procedure_nameContext { + var p = new(Procedure_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_procedure_name + + return p +} + +func (s *Procedure_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Procedure_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Procedure_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Procedure_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Procedure_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Procedure_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Procedure_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterProcedure_name(s) + } +} + +func (s *Procedure_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitProcedure_name(s) + } +} + +func (s *Procedure_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitProcedure_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Procedure_name() (localctx IProcedure_nameContext) { + localctx = NewProcedure_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2294, PlSqlParserRULE_procedure_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19287) + p.Identifier() + } + p.SetState(19290) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(19288) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19289) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ITrigger_nameContext is an interface to support dynamic dispatch. +type ITrigger_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsTrigger_nameContext differentiates from other interfaces. + IsTrigger_nameContext() +} + +type Trigger_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTrigger_nameContext() *Trigger_nameContext { + var p = new(Trigger_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_name + return p +} + +func InitEmptyTrigger_nameContext(p *Trigger_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_trigger_name +} + +func (*Trigger_nameContext) IsTrigger_nameContext() {} + +func NewTrigger_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Trigger_nameContext { + var p = new(Trigger_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_trigger_name + + return p +} + +func (s *Trigger_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Trigger_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Trigger_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Trigger_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Trigger_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Trigger_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Trigger_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTrigger_name(s) + } +} + +func (s *Trigger_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTrigger_name(s) + } +} + +func (s *Trigger_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTrigger_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Trigger_name() (localctx ITrigger_nameContext) { + localctx = NewTrigger_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2296, PlSqlParserRULE_trigger_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19292) + p.Identifier() + } + p.SetState(19295) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(19293) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19294) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IVariable_nameContext is an interface to support dynamic dispatch. +type IVariable_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + PERIOD() antlr.TerminalNode + Bind_variable() IBind_variableContext + + // IsVariable_nameContext differentiates from other interfaces. + IsVariable_nameContext() +} + +type Variable_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyVariable_nameContext() *Variable_nameContext { + var p = new(Variable_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_name + return p +} + +func InitEmptyVariable_nameContext(p *Variable_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_variable_name +} + +func (*Variable_nameContext) IsVariable_nameContext() {} + +func NewVariable_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Variable_nameContext { + var p = new(Variable_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_variable_name + + return p +} + +func (s *Variable_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Variable_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Variable_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Variable_nameContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *Variable_nameContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Variable_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Variable_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Variable_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Variable_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Variable_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterVariable_name(s) + } +} + +func (s *Variable_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitVariable_name(s) + } +} + +func (s *Variable_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitVariable_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Variable_name() (localctx IVariable_nameContext) { + localctx = NewVariable_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2298, PlSqlParserRULE_variable_name) + var _la int + + p.SetState(19307) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + p.SetState(19299) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(19297) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19298) + p.Char_set_name() + } + + } + { + p.SetState(19301) + p.Id_expression() + } + p.SetState(19304) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2703, p.GetParserRuleContext()) == 1 { + { + p.SetState(19302) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19303) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19306) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IIndex_nameContext is an interface to support dynamic dispatch. +type IIndex_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsIndex_nameContext differentiates from other interfaces. + IsIndex_nameContext() +} + +type Index_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIndex_nameContext() *Index_nameContext { + var p = new(Index_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_name + return p +} + +func InitEmptyIndex_nameContext(p *Index_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_index_name +} + +func (*Index_nameContext) IsIndex_nameContext() {} + +func NewIndex_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Index_nameContext { + var p = new(Index_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_index_name + + return p +} + +func (s *Index_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Index_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Index_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Index_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Index_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Index_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Index_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIndex_name(s) + } +} + +func (s *Index_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIndex_name(s) + } +} + +func (s *Index_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIndex_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Index_name() (localctx IIndex_nameContext) { + localctx = NewIndex_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2300, PlSqlParserRULE_index_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19309) + p.Identifier() + } + p.SetState(19312) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2705, p.GetParserRuleContext()) == 1 { + { + p.SetState(19310) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19311) + p.Id_expression() + } + + } 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 +} + +// ICursor_nameContext is an interface to support dynamic dispatch. +type ICursor_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + General_element() IGeneral_elementContext + Bind_variable() IBind_variableContext + + // IsCursor_nameContext differentiates from other interfaces. + IsCursor_nameContext() +} + +type Cursor_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCursor_nameContext() *Cursor_nameContext { + var p = new(Cursor_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_name + return p +} + +func InitEmptyCursor_nameContext(p *Cursor_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_cursor_name +} + +func (*Cursor_nameContext) IsCursor_nameContext() {} + +func NewCursor_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Cursor_nameContext { + var p = new(Cursor_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_cursor_name + + return p +} + +func (s *Cursor_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Cursor_nameContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Cursor_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Cursor_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Cursor_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Cursor_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCursor_name(s) + } +} + +func (s *Cursor_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCursor_name(s) + } +} + +func (s *Cursor_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCursor_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Cursor_name() (localctx ICursor_nameContext) { + localctx = NewCursor_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2302, PlSqlParserRULE_cursor_name) + p.SetState(19316) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19314) + p.General_element() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19315) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRecord_nameContext is an interface to support dynamic dispatch. +type IRecord_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + Bind_variable() IBind_variableContext + + // IsRecord_nameContext differentiates from other interfaces. + IsRecord_nameContext() +} + +type Record_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRecord_nameContext() *Record_nameContext { + var p = new(Record_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_name + return p +} + +func InitEmptyRecord_nameContext(p *Record_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_record_name +} + +func (*Record_nameContext) IsRecord_nameContext() {} + +func NewRecord_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Record_nameContext { + var p = new(Record_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_record_name + + return p +} + +func (s *Record_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Record_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Record_nameContext) Bind_variable() IBind_variableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Record_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Record_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Record_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRecord_name(s) + } +} + +func (s *Record_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRecord_name(s) + } +} + +func (s *Record_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRecord_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Record_name() (localctx IRecord_nameContext) { + localctx = NewRecord_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2304, PlSqlParserRULE_record_name) + p.SetState(19320) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19318) + p.Identifier() + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19319) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ICollection_nameContext is an interface to support dynamic dispatch. +type ICollection_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + PERIOD() antlr.TerminalNode + Id_expression() IId_expressionContext + + // IsCollection_nameContext differentiates from other interfaces. + IsCollection_nameContext() +} + +type Collection_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyCollection_nameContext() *Collection_nameContext { + var p = new(Collection_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_name + return p +} + +func InitEmptyCollection_nameContext(p *Collection_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_collection_name +} + +func (*Collection_nameContext) IsCollection_nameContext() {} + +func NewCollection_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Collection_nameContext { + var p = new(Collection_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_collection_name + + return p +} + +func (s *Collection_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Collection_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Collection_nameContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Collection_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Collection_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Collection_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Collection_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterCollection_name(s) + } +} + +func (s *Collection_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitCollection_name(s) + } +} + +func (s *Collection_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitCollection_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Collection_name() (localctx ICollection_nameContext) { + localctx = NewCollection_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2306, PlSqlParserRULE_collection_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19322) + p.Identifier() + } + p.SetState(19325) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERIOD { + { + p.SetState(19323) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19324) + p.Id_expression() + } + + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ILink_nameContext is an interface to support dynamic dispatch. +type ILink_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsLink_nameContext differentiates from other interfaces. + IsLink_nameContext() +} + +type Link_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyLink_nameContext() *Link_nameContext { + var p = new(Link_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_name + return p +} + +func InitEmptyLink_nameContext(p *Link_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_link_name +} + +func (*Link_nameContext) IsLink_nameContext() {} + +func NewLink_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Link_nameContext { + var p = new(Link_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_link_name + + return p +} + +func (s *Link_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Link_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Link_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Link_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Link_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterLink_name(s) + } +} + +func (s *Link_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitLink_name(s) + } +} + +func (s *Link_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitLink_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Link_name() (localctx ILink_nameContext) { + localctx = NewLink_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2308, PlSqlParserRULE_link_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19327) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IColumn_nameContext is an interface to support dynamic dispatch. +type IColumn_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + + // 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 = PlSqlParserRULE_column_name + return p +} + +func InitEmptyColumn_nameContext(p *Column_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_column_name + + return p +} + +func (s *Column_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Column_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Column_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Column_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Column_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Column_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +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.(PlSqlParserListener); ok { + listenerT.EnterColumn_name(s) + } +} + +func (s *Column_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_name(s) + } +} + +func (s *Column_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_name() (localctx IColumn_nameContext) { + localctx = NewColumn_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2310, PlSqlParserRULE_column_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19329) + p.Identifier() + } + p.SetState(19334) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2709, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19330) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19331) + p.Id_expression() + } + + } + p.SetState(19336) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2709, 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 +} + +// ITableview_nameContext is an interface to support dynamic dispatch. +type ITableview_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + Id_expression() IId_expressionContext + AT_SIGN() antlr.TerminalNode + AllLink_name() []ILink_nameContext + Link_name(i int) ILink_nameContext + Partition_extension_clause() IPartition_extension_clauseContext + Xmltable() IXmltableContext + Outer_join_sign() IOuter_join_signContext + + // IsTableview_nameContext differentiates from other interfaces. + IsTableview_nameContext() +} + +type Tableview_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTableview_nameContext() *Tableview_nameContext { + var p = new(Tableview_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tableview_name + return p +} + +func InitEmptyTableview_nameContext(p *Tableview_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_tableview_name +} + +func (*Tableview_nameContext) IsTableview_nameContext() {} + +func NewTableview_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Tableview_nameContext { + var p = new(Tableview_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_tableview_name + + return p +} + +func (s *Tableview_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Tableview_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Tableview_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Tableview_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Tableview_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Tableview_nameContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *Tableview_nameContext) AllLink_name() []ILink_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(ILink_nameContext); ok { + len++ + } + } + + tst := make([]ILink_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(ILink_nameContext); ok { + tst[i] = t.(ILink_nameContext) + i++ + } + } + + return tst +} + +func (s *Tableview_nameContext) Link_name(i int) ILink_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *Tableview_nameContext) Partition_extension_clause() IPartition_extension_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPartition_extension_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPartition_extension_clauseContext) +} + +func (s *Tableview_nameContext) Xmltable() IXmltableContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXmltableContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXmltableContext) +} + +func (s *Tableview_nameContext) Outer_join_sign() IOuter_join_signContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IOuter_join_signContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IOuter_join_signContext) +} + +func (s *Tableview_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Tableview_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Tableview_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTableview_name(s) + } +} + +func (s *Tableview_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTableview_name(s) + } +} + +func (s *Tableview_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTableview_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Tableview_name() (localctx ITableview_nameContext) { + localctx = NewTableview_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2312, PlSqlParserRULE_tableview_name) + var _alt int + + p.SetState(19358) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2714, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19337) + p.Identifier() + } + p.SetState(19340) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2710, p.GetParserRuleContext()) == 1 { + { + p.SetState(19338) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19339) + p.Id_expression() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19352) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 1 { + { + p.SetState(19342) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19343) + p.Link_name() + } + p.SetState(19348) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19344) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19345) + p.Link_name() + } + + } + p.SetState(19350) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2711, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } else if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2712, p.GetParserRuleContext()) == 2 { + { + p.SetState(19351) + p.Partition_extension_clause() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19354) + p.Xmltable() + } + p.SetState(19356) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2713, p.GetParserRuleContext()) == 1 { + { + p.SetState(19355) + p.Outer_join_sign() + } + + } 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 +} + +// IXmltableContext is an interface to support dynamic dispatch. +type IXmltableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + XMLTABLE() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + Concatenation() IConcatenationContext + RIGHT_PAREN() antlr.TerminalNode + Xml_namespaces_clause() IXml_namespaces_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Xml_passing_clause() IXml_passing_clauseContext + COLUMNS() antlr.TerminalNode + AllXml_table_column() []IXml_table_columnContext + Xml_table_column(i int) IXml_table_columnContext + PERIOD() antlr.TerminalNode + General_element() IGeneral_elementContext + + // IsXmltableContext differentiates from other interfaces. + IsXmltableContext() +} + +type XmltableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyXmltableContext() *XmltableContext { + var p = new(XmltableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltable + return p +} + +func InitEmptyXmltableContext(p *XmltableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_xmltable +} + +func (*XmltableContext) IsXmltableContext() {} + +func NewXmltableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *XmltableContext { + var p = new(XmltableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_xmltable + + return p +} + +func (s *XmltableContext) GetParser() antlr.Parser { return s.parser } + +func (s *XmltableContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTABLE, 0) +} + +func (s *XmltableContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *XmltableContext) Concatenation() IConcatenationContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IConcatenationContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IConcatenationContext) +} + +func (s *XmltableContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *XmltableContext) Xml_namespaces_clause() IXml_namespaces_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_namespaces_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_namespaces_clauseContext) +} + +func (s *XmltableContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *XmltableContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *XmltableContext) Xml_passing_clause() IXml_passing_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_passing_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IXml_passing_clauseContext) +} + +func (s *XmltableContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *XmltableContext) AllXml_table_column() []IXml_table_columnContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IXml_table_columnContext); ok { + len++ + } + } + + tst := make([]IXml_table_columnContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IXml_table_columnContext); ok { + tst[i] = t.(IXml_table_columnContext) + i++ + } + } + + return tst +} + +func (s *XmltableContext) Xml_table_column(i int) IXml_table_columnContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IXml_table_columnContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IXml_table_columnContext) +} + +func (s *XmltableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *XmltableContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *XmltableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *XmltableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *XmltableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterXmltable(s) + } +} + +func (s *XmltableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitXmltable(s) + } +} + +func (s *XmltableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitXmltable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Xmltable() (localctx IXmltableContext) { + localctx = NewXmltableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2314, PlSqlParserRULE_xmltable) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19360) + p.Match(PlSqlParserXMLTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19361) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19365) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2715, p.GetParserRuleContext()) == 1 { + { + p.SetState(19362) + p.Xml_namespaces_clause() + } + { + p.SetState(19363) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19367) + p.concatenation(0) + } + p.SetState(19369) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPASSING { + { + p.SetState(19368) + p.Xml_passing_clause() + } + + } + p.SetState(19380) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOLUMNS { + { + p.SetState(19371) + p.Match(PlSqlParserCOLUMNS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19372) + p.Xml_table_column() + } + p.SetState(19377) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19373) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19374) + p.Xml_table_column() + } + + p.SetState(19379) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(19382) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19385) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2719, p.GetParserRuleContext()) == 1 { + { + p.SetState(19383) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19384) + p.General_element() + } + + } 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 +} + +// IChar_set_nameContext is an interface to support dynamic dispatch. +type IChar_set_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsChar_set_nameContext differentiates from other interfaces. + IsChar_set_nameContext() +} + +type Char_set_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChar_set_nameContext() *Char_set_nameContext { + var p = new(Char_set_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_set_name + return p +} + +func InitEmptyChar_set_nameContext(p *Char_set_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_set_name +} + +func (*Char_set_nameContext) IsChar_set_nameContext() {} + +func NewChar_set_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Char_set_nameContext { + var p = new(Char_set_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_char_set_name + + return p +} + +func (s *Char_set_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Char_set_nameContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Char_set_nameContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Char_set_nameContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Char_set_nameContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Char_set_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Char_set_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Char_set_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterChar_set_name(s) + } +} + +func (s *Char_set_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitChar_set_name(s) + } +} + +func (s *Char_set_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitChar_set_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Char_set_name() (localctx IChar_set_nameContext) { + localctx = NewChar_set_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2316, PlSqlParserRULE_char_set_name) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19387) + p.Id_expression() + } + p.SetState(19392) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2720, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19388) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19389) + p.Id_expression() + } + + } + p.SetState(19394) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2720, 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 +} + +// ISynonym_nameContext is an interface to support dynamic dispatch. +type ISynonym_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Identifier() IIdentifierContext + + // IsSynonym_nameContext differentiates from other interfaces. + IsSynonym_nameContext() +} + +type Synonym_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySynonym_nameContext() *Synonym_nameContext { + var p = new(Synonym_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synonym_name + return p +} + +func InitEmptySynonym_nameContext(p *Synonym_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_synonym_name +} + +func (*Synonym_nameContext) IsSynonym_nameContext() {} + +func NewSynonym_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Synonym_nameContext { + var p = new(Synonym_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_synonym_name + + return p +} + +func (s *Synonym_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Synonym_nameContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *Synonym_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Synonym_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Synonym_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSynonym_name(s) + } +} + +func (s *Synonym_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSynonym_name(s) + } +} + +func (s *Synonym_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSynonym_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Synonym_name() (localctx ISynonym_nameContext) { + localctx = NewSynonym_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2318, PlSqlParserRULE_synonym_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19395) + p.Identifier() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// ISchema_object_nameContext is an interface to support dynamic dispatch. +type ISchema_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsSchema_object_nameContext differentiates from other interfaces. + IsSchema_object_nameContext() +} + +type Schema_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySchema_object_nameContext() *Schema_object_nameContext { + var p = new(Schema_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_object_name + return p +} + +func InitEmptySchema_object_nameContext(p *Schema_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_schema_object_name +} + +func (*Schema_object_nameContext) IsSchema_object_nameContext() {} + +func NewSchema_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Schema_object_nameContext { + var p = new(Schema_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_schema_object_name + + return p +} + +func (s *Schema_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Schema_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Schema_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Schema_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Schema_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSchema_object_name(s) + } +} + +func (s *Schema_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSchema_object_name(s) + } +} + +func (s *Schema_object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSchema_object_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Schema_object_name() (localctx ISchema_object_nameContext) { + localctx = NewSchema_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2320, PlSqlParserRULE_schema_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19397) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IDir_object_nameContext is an interface to support dynamic dispatch. +type IDir_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsDir_object_nameContext differentiates from other interfaces. + IsDir_object_nameContext() +} + +type Dir_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDir_object_nameContext() *Dir_object_nameContext { + var p = new(Dir_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_object_name + return p +} + +func InitEmptyDir_object_nameContext(p *Dir_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_dir_object_name +} + +func (*Dir_object_nameContext) IsDir_object_nameContext() {} + +func NewDir_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Dir_object_nameContext { + var p = new(Dir_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_dir_object_name + + return p +} + +func (s *Dir_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Dir_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Dir_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Dir_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Dir_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDir_object_name(s) + } +} + +func (s *Dir_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDir_object_name(s) + } +} + +func (s *Dir_object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDir_object_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Dir_object_name() (localctx IDir_object_nameContext) { + localctx = NewDir_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2322, PlSqlParserRULE_dir_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19399) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IUser_object_nameContext is an interface to support dynamic dispatch. +type IUser_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + + // IsUser_object_nameContext differentiates from other interfaces. + IsUser_object_nameContext() +} + +type User_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyUser_object_nameContext() *User_object_nameContext { + var p = new(User_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_object_name + return p +} + +func InitEmptyUser_object_nameContext(p *User_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_user_object_name +} + +func (*User_object_nameContext) IsUser_object_nameContext() {} + +func NewUser_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *User_object_nameContext { + var p = new(User_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_user_object_name + + return p +} + +func (s *User_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *User_object_nameContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *User_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *User_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *User_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterUser_object_name(s) + } +} + +func (s *User_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitUser_object_name(s) + } +} + +func (s *User_object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitUser_object_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) User_object_name() (localctx IUser_object_nameContext) { + localctx = NewUser_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2324, PlSqlParserRULE_user_object_name) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19401) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IGrant_object_nameContext is an interface to support dynamic dispatch. +type IGrant_object_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Tableview_name() ITableview_nameContext + USER() antlr.TerminalNode + AllUser_object_name() []IUser_object_nameContext + User_object_name(i int) IUser_object_nameContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + Dir_object_name() IDir_object_nameContext + EDITION() antlr.TerminalNode + Schema_object_name() ISchema_object_nameContext + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + JAVA() antlr.TerminalNode + SOURCE() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + SQL() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + PROFILE() antlr.TerminalNode + + // IsGrant_object_nameContext differentiates from other interfaces. + IsGrant_object_nameContext() +} + +type Grant_object_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGrant_object_nameContext() *Grant_object_nameContext { + var p = new(Grant_object_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_object_name + return p +} + +func InitEmptyGrant_object_nameContext(p *Grant_object_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_grant_object_name +} + +func (*Grant_object_nameContext) IsGrant_object_nameContext() {} + +func NewGrant_object_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Grant_object_nameContext { + var p = new(Grant_object_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_grant_object_name + + return p +} + +func (s *Grant_object_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Grant_object_nameContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Grant_object_nameContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Grant_object_nameContext) AllUser_object_name() []IUser_object_nameContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IUser_object_nameContext); ok { + len++ + } + } + + tst := make([]IUser_object_nameContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IUser_object_nameContext); ok { + tst[i] = t.(IUser_object_nameContext) + i++ + } + } + + return tst +} + +func (s *Grant_object_nameContext) User_object_name(i int) IUser_object_nameContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IUser_object_nameContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IUser_object_nameContext) +} + +func (s *Grant_object_nameContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Grant_object_nameContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Grant_object_nameContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Grant_object_nameContext) Dir_object_name() IDir_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDir_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDir_object_nameContext) +} + +func (s *Grant_object_nameContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Grant_object_nameContext) Schema_object_name() ISchema_object_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ISchema_object_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ISchema_object_nameContext) +} + +func (s *Grant_object_nameContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Grant_object_nameContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Grant_object_nameContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Grant_object_nameContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Grant_object_nameContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *Grant_object_nameContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Grant_object_nameContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Grant_object_nameContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Grant_object_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Grant_object_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Grant_object_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGrant_object_name(s) + } +} + +func (s *Grant_object_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGrant_object_name(s) + } +} + +func (s *Grant_object_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGrant_object_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Grant_object_name() (localctx IGrant_object_nameContext) { + localctx = NewGrant_object_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2326, PlSqlParserRULE_grant_object_name) + var _la int + + p.SetState(19427) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2722, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19403) + p.Tableview_name() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19404) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19405) + p.User_object_name() + } + p.SetState(19410) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19406) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19407) + p.User_object_name() + } + + p.SetState(19412) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19413) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19414) + p.Dir_object_name() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19415) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19416) + p.Schema_object_name() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19417) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19418) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19419) + p.Schema_object_name() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19420) + p.Match(PlSqlParserJAVA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19421) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserRESOURCE || _la == PlSqlParserSOURCE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19422) + p.Schema_object_name() + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19423) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19424) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19425) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19426) + p.Schema_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 +} + +// 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 = PlSqlParserRULE_column_list + return p +} + +func InitEmptyColumn_listContext(p *Column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_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(PlSqlParserCOMMA) +} + +func (s *Column_listContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 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.(PlSqlParserListener); ok { + listenerT.EnterColumn_list(s) + } +} + +func (s *Column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitColumn_list(s) + } +} + +func (s *Column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitColumn_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Column_list() (localctx IColumn_listContext) { + localctx = NewColumn_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2328, PlSqlParserRULE_column_list) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19429) + p.Column_name() + } + p.SetState(19434) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2723, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19430) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19431) + p.Column_name() + } + + } + p.SetState(19436) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2723, 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 +} + +// IParen_column_listContext is an interface to support dynamic dispatch. +type IParen_column_listContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_list() IColumn_listContext + RIGHT_PAREN() antlr.TerminalNode + + // IsParen_column_listContext differentiates from other interfaces. + IsParen_column_listContext() +} + +type Paren_column_listContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyParen_column_listContext() *Paren_column_listContext { + var p = new(Paren_column_listContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_paren_column_list + return p +} + +func InitEmptyParen_column_listContext(p *Paren_column_listContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_paren_column_list +} + +func (*Paren_column_listContext) IsParen_column_listContext() {} + +func NewParen_column_listContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Paren_column_listContext { + var p = new(Paren_column_listContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_paren_column_list + + return p +} + +func (s *Paren_column_listContext) GetParser() antlr.Parser { return s.parser } + +func (s *Paren_column_listContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Paren_column_listContext) 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 *Paren_column_listContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Paren_column_listContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Paren_column_listContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Paren_column_listContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterParen_column_list(s) + } +} + +func (s *Paren_column_listContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitParen_column_list(s) + } +} + +func (s *Paren_column_listContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitParen_column_list(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Paren_column_list() (localctx IParen_column_listContext) { + localctx = NewParen_column_listContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2330, PlSqlParserRULE_paren_column_list) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19437) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19438) + p.Column_list() + } + { + p.SetState(19439) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IKeep_clauseContext is an interface to support dynamic dispatch. +type IKeep_clauseContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + KEEP() antlr.TerminalNode + LEFT_PAREN() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + Order_by_clause() IOrder_by_clauseContext + RIGHT_PAREN() antlr.TerminalNode + FIRST() antlr.TerminalNode + LAST() antlr.TerminalNode + Over_clause() IOver_clauseContext + + // IsKeep_clauseContext differentiates from other interfaces. + IsKeep_clauseContext() +} + +type Keep_clauseContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyKeep_clauseContext() *Keep_clauseContext { + var p = new(Keep_clauseContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keep_clause + return p +} + +func InitEmptyKeep_clauseContext(p *Keep_clauseContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_keep_clause +} + +func (*Keep_clauseContext) IsKeep_clauseContext() {} + +func NewKeep_clauseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Keep_clauseContext { + var p = new(Keep_clauseContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_keep_clause + + return p +} + +func (s *Keep_clauseContext) GetParser() antlr.Parser { return s.parser } + +func (s *Keep_clauseContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Keep_clauseContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Keep_clauseContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Keep_clauseContext) 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 *Keep_clauseContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Keep_clauseContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Keep_clauseContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Keep_clauseContext) 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 *Keep_clauseContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Keep_clauseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Keep_clauseContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterKeep_clause(s) + } +} + +func (s *Keep_clauseContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitKeep_clause(s) + } +} + +func (s *Keep_clauseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitKeep_clause(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Keep_clause() (localctx IKeep_clauseContext) { + localctx = NewKeep_clauseContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2332, PlSqlParserRULE_keep_clause) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19441) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19442) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19443) + p.Match(PlSqlParserDENSE_RANK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19444) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserFIRST || _la == PlSqlParserLAST) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19445) + p.Order_by_clause() + } + { + p.SetState(19446) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19448) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2724, p.GetParserRuleContext()) == 1 { + { + p.SetState(19447) + p.Over_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 +} + +// IFunction_argumentContext is an interface to support dynamic dispatch. +type IFunction_argumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllArgument() []IArgumentContext + Argument(i int) IArgumentContext + Keep_clause() IKeep_clauseContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_argumentContext differentiates from other interfaces. + IsFunction_argumentContext() +} + +type Function_argumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argumentContext() *Function_argumentContext { + var p = new(Function_argumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument + return p +} + +func InitEmptyFunction_argumentContext(p *Function_argumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument +} + +func (*Function_argumentContext) IsFunction_argumentContext() {} + +func NewFunction_argumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argumentContext { + var p = new(Function_argumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument + + return p +} + +func (s *Function_argumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argumentContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argumentContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argumentContext) AllArgument() []IArgumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArgumentContext); ok { + len++ + } + } + + tst := make([]IArgumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArgumentContext); ok { + tst[i] = t.(IArgumentContext) + i++ + } + } + + return tst +} + +func (s *Function_argumentContext) Argument(i int) IArgumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Function_argumentContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argumentContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argumentContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument(s) + } +} + +func (s *Function_argumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument(s) + } +} + +func (s *Function_argumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_argument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_argument() (localctx IFunction_argumentContext) { + localctx = NewFunction_argumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2334, PlSqlParserRULE_function_argument) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19450) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19459) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(19451) + p.Argument() + } + p.SetState(19456) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19452) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19453) + p.Argument() + } + + p.SetState(19458) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(19461) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19463) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2727, p.GetParserRuleContext()) == 1 { + { + p.SetState(19462) + p.Keep_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 +} + +// IFunction_argument_analyticContext is an interface to support dynamic dispatch. +type IFunction_argument_analyticContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllArgument() []IArgumentContext + Argument(i int) IArgumentContext + Keep_clause() IKeep_clauseContext + AllRespect_or_ignore_nulls() []IRespect_or_ignore_nullsContext + Respect_or_ignore_nulls(i int) IRespect_or_ignore_nullsContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + + // IsFunction_argument_analyticContext differentiates from other interfaces. + IsFunction_argument_analyticContext() +} + +type Function_argument_analyticContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argument_analyticContext() *Function_argument_analyticContext { + var p = new(Function_argument_analyticContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_analytic + return p +} + +func InitEmptyFunction_argument_analyticContext(p *Function_argument_analyticContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_analytic +} + +func (*Function_argument_analyticContext) IsFunction_argument_analyticContext() {} + +func NewFunction_argument_analyticContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argument_analyticContext { + var p = new(Function_argument_analyticContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument_analytic + + return p +} + +func (s *Function_argument_analyticContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argument_analyticContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argument_analyticContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argument_analyticContext) AllArgument() []IArgumentContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IArgumentContext); ok { + len++ + } + } + + tst := make([]IArgumentContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IArgumentContext); ok { + tst[i] = t.(IArgumentContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_analyticContext) Argument(i int) IArgumentContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IArgumentContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IArgumentContext) +} + +func (s *Function_argument_analyticContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argument_analyticContext) AllRespect_or_ignore_nulls() []IRespect_or_ignore_nullsContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + len++ + } + } + + tst := make([]IRespect_or_ignore_nullsContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + tst[i] = t.(IRespect_or_ignore_nullsContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_analyticContext) Respect_or_ignore_nulls(i int) IRespect_or_ignore_nullsContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRespect_or_ignore_nullsContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IRespect_or_ignore_nullsContext) +} + +func (s *Function_argument_analyticContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argument_analyticContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argument_analyticContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argument_analyticContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argument_analyticContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument_analytic(s) + } +} + +func (s *Function_argument_analyticContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument_analytic(s) + } +} + +func (s *Function_argument_analyticContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_argument_analytic(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_argument_analytic() (localctx IFunction_argument_analyticContext) { + localctx = NewFunction_argument_analyticContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2336, PlSqlParserRULE_function_argument_analytic) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19465) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19480) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-283673999966210) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972813) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-68719476737) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819404132349) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-281474976710657) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-1) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-2621441) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240513695) != 0) { + { + p.SetState(19466) + p.Argument() + } + p.SetState(19468) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(19467) + p.Respect_or_ignore_nulls() + } + + } + p.SetState(19477) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19470) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19471) + p.Argument() + } + p.SetState(19473) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT { + { + p.SetState(19472) + p.Respect_or_ignore_nulls() + } + + } + + p.SetState(19479) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + } + { + p.SetState(19482) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19484) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2732, p.GetParserRuleContext()) == 1 { + { + p.SetState(19483) + p.Keep_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 +} + +// IFunction_argument_modelingContext is an interface to support dynamic dispatch. +type IFunction_argument_modelingContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + Column_name() IColumn_nameContext + USING() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + Tableview_name() ITableview_nameContext + PERIOD() antlr.TerminalNode + ASTERISK() antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllCOMMA() []antlr.TerminalNode + COMMA(i int) antlr.TerminalNode + Keep_clause() IKeep_clauseContext + AllNumeric() []INumericContext + Numeric(i int) INumericContext + AllNULL_() []antlr.TerminalNode + NULL_(i int) antlr.TerminalNode + AllColumn_alias() []IColumn_aliasContext + Column_alias(i int) IColumn_aliasContext + + // IsFunction_argument_modelingContext differentiates from other interfaces. + IsFunction_argument_modelingContext() +} + +type Function_argument_modelingContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyFunction_argument_modelingContext() *Function_argument_modelingContext { + var p = new(Function_argument_modelingContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_modeling + return p +} + +func InitEmptyFunction_argument_modelingContext(p *Function_argument_modelingContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_function_argument_modeling +} + +func (*Function_argument_modelingContext) IsFunction_argument_modelingContext() {} + +func NewFunction_argument_modelingContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Function_argument_modelingContext { + var p = new(Function_argument_modelingContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_function_argument_modeling + + return p +} + +func (s *Function_argument_modelingContext) GetParser() antlr.Parser { return s.parser } + +func (s *Function_argument_modelingContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Function_argument_modelingContext) 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 *Function_argument_modelingContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Function_argument_modelingContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Function_argument_modelingContext) Tableview_name() ITableview_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ITableview_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ITableview_nameContext) +} + +func (s *Function_argument_modelingContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Function_argument_modelingContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Function_argument_modelingContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *Function_argument_modelingContext) AllCOMMA() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOMMA) +} + +func (s *Function_argument_modelingContext) COMMA(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, i) +} + +func (s *Function_argument_modelingContext) Keep_clause() IKeep_clauseContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IKeep_clauseContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IKeep_clauseContext) +} + +func (s *Function_argument_modelingContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Function_argument_modelingContext) AllNULL_() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserNULL_) +} + +func (s *Function_argument_modelingContext) NULL_(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, i) +} + +func (s *Function_argument_modelingContext) AllColumn_alias() []IColumn_aliasContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IColumn_aliasContext); ok { + len++ + } + } + + tst := make([]IColumn_aliasContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IColumn_aliasContext); ok { + tst[i] = t.(IColumn_aliasContext) + i++ + } + } + + return tst +} + +func (s *Function_argument_modelingContext) Column_alias(i int) IColumn_aliasContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IColumn_aliasContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IColumn_aliasContext) +} + +func (s *Function_argument_modelingContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Function_argument_modelingContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Function_argument_modelingContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterFunction_argument_modeling(s) + } +} + +func (s *Function_argument_modelingContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitFunction_argument_modeling(s) + } +} + +func (s *Function_argument_modelingContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitFunction_argument_modeling(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Function_argument_modeling() (localctx IFunction_argument_modelingContext) { + localctx = NewFunction_argument_modelingContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2338, PlSqlParserRULE_function_argument_modeling) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19486) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19487) + p.Column_name() + } + p.SetState(19500) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19488) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19491) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(19489) + p.Numeric() + } + + case PlSqlParserNULL_: + { + p.SetState(19490) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(19498) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19493) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19496) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(19494) + p.Numeric() + } + + case PlSqlParserNULL_: + { + p.SetState(19495) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + + } + { + p.SetState(19502) + p.Match(PlSqlParserUSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19522) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2740, p.GetParserRuleContext()) { + case 1: + { + p.SetState(19503) + p.Tableview_name() + } + { + p.SetState(19504) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19505) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + { + p.SetState(19507) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + { + p.SetState(19508) + p.Expression() + } + p.SetState(19510) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(19509) + p.Column_alias() + } + + } + p.SetState(19519) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserCOMMA { + { + p.SetState(19512) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19513) + p.Expression() + } + p.SetState(19515) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if ((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-9291010693660674) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-281474976972809) != 0) || ((int64((_la-128)) & ^0x3f) == 0 && ((int64(1)<<(_la-128))&-288230444879577089) != 0) || ((int64((_la-192)) & ^0x3f) == 0 && ((int64(1)<<(_la-192))&-1125899906842625) != 0) || ((int64((_la-256)) & ^0x3f) == 0 && ((int64(1)<<(_la-256))&-35184372088865) != 0) || ((int64((_la-320)) & ^0x3f) == 0 && ((int64(1)<<(_la-320))&-8864813023233) != 0) || ((int64((_la-384)) & ^0x3f) == 0 && ((int64(1)<<(_la-384))&4611683819337023485) != 0) || ((int64((_la-448)) & ^0x3f) == 0 && ((int64(1)<<(_la-448))&-1099511629825) != 0) || ((int64((_la-512)) & ^0x3f) == 0 && ((int64(1)<<(_la-512))&-1157425104234217473) != 0) || ((int64((_la-576)) & ^0x3f) == 0 && ((int64(1)<<(_la-576))&-4504700212920321) != 0) || ((int64((_la-640)) & ^0x3f) == 0 && ((int64(1)<<(_la-640))&-144116287588007937) != 0) || ((int64((_la-704)) & ^0x3f) == 0 && ((int64(1)<<(_la-704))&-561153) != 0) || ((int64((_la-768)) & ^0x3f) == 0 && ((int64(1)<<(_la-768))&-17592202821633) != 0) || ((int64((_la-832)) & ^0x3f) == 0 && ((int64(1)<<(_la-832))&-9007199254740993) != 0) || ((int64((_la-896)) & ^0x3f) == 0 && ((int64(1)<<(_la-896))&-274877907969) != 0) || ((int64((_la-960)) & ^0x3f) == 0 && ((int64(1)<<(_la-960))&-1099511627777) != 0) || ((int64((_la-1024)) & ^0x3f) == 0 && ((int64(1)<<(_la-1024))&-1) != 0) || ((int64((_la-1088)) & ^0x3f) == 0 && ((int64(1)<<(_la-1088))&-144396671642501121) != 0) || ((int64((_la-1152)) & ^0x3f) == 0 && ((int64(1)<<(_la-1152))&9223371968126908415) != 0) || ((int64((_la-1216)) & ^0x3f) == 0 && ((int64(1)<<(_la-1216))&-2305843009213693961) != 0) || ((int64((_la-1280)) & ^0x3f) == 0 && ((int64(1)<<(_la-1280))&-2099001) != 0) || ((int64((_la-1344)) & ^0x3f) == 0 && ((int64(1)<<(_la-1344))&-16385) != 0) || ((int64((_la-1408)) & ^0x3f) == 0 && ((int64(1)<<(_la-1408))&9223336852482686975) != 0) || ((int64((_la-1472)) & ^0x3f) == 0 && ((int64(1)<<(_la-1472))&-262145) != 0) || ((int64((_la-1536)) & ^0x3f) == 0 && ((int64(1)<<(_la-1536))&-576461851815055361) != 0) || ((int64((_la-1600)) & ^0x3f) == 0 && ((int64(1)<<(_la-1600))&-2147483649) != 0) || ((int64((_la-1664)) & ^0x3f) == 0 && ((int64(1)<<(_la-1664))&-33554433) != 0) || ((int64((_la-1728)) & ^0x3f) == 0 && ((int64(1)<<(_la-1728))&-1) != 0) || ((int64((_la-1792)) & ^0x3f) == 0 && ((int64(1)<<(_la-1792))&-1) != 0) || ((int64((_la-1856)) & ^0x3f) == 0 && ((int64(1)<<(_la-1856))&-1) != 0) || ((int64((_la-1920)) & ^0x3f) == 0 && ((int64(1)<<(_la-1920))&-1) != 0) || ((int64((_la-1984)) & ^0x3f) == 0 && ((int64(1)<<(_la-1984))&-35184372350977) != 0) || ((int64((_la-2048)) & ^0x3f) == 0 && ((int64(1)<<(_la-2048))&-8796094595073) != 0) || ((int64((_la-2112)) & ^0x3f) == 0 && ((int64(1)<<(_la-2112))&-18014398777917441) != 0) || ((int64((_la-2176)) & ^0x3f) == 0 && ((int64(1)<<(_la-2176))&-34360004641) != 0) || ((int64((_la-2240)) & ^0x3f) == 0 && ((int64(1)<<(_la-2240))&-893355819009) != 0) || ((int64((_la-2304)) & ^0x3f) == 0 && ((int64(1)<<(_la-2304))&4611686018427387903) != 0) || ((int64((_la-2369)) & ^0x3f) == 0 && ((int64(1)<<(_la-2369))&279240507417) != 0) { + { + p.SetState(19514) + p.Column_alias() + } + + } + + p.SetState(19521) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(19524) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19526) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2741, p.GetParserRuleContext()) == 1 { + { + p.SetState(19525) + p.Keep_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 +} + +// IRespect_or_ignore_nullsContext is an interface to support dynamic dispatch. +type IRespect_or_ignore_nullsContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + NULLS() antlr.TerminalNode + RESPECT() antlr.TerminalNode + IGNORE() antlr.TerminalNode + + // IsRespect_or_ignore_nullsContext differentiates from other interfaces. + IsRespect_or_ignore_nullsContext() +} + +type Respect_or_ignore_nullsContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRespect_or_ignore_nullsContext() *Respect_or_ignore_nullsContext { + var p = new(Respect_or_ignore_nullsContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls + return p +} + +func InitEmptyRespect_or_ignore_nullsContext(p *Respect_or_ignore_nullsContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls +} + +func (*Respect_or_ignore_nullsContext) IsRespect_or_ignore_nullsContext() {} + +func NewRespect_or_ignore_nullsContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Respect_or_ignore_nullsContext { + var p = new(Respect_or_ignore_nullsContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_respect_or_ignore_nulls + + return p +} + +func (s *Respect_or_ignore_nullsContext) GetParser() antlr.Parser { return s.parser } + +func (s *Respect_or_ignore_nullsContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Respect_or_ignore_nullsContext) RESPECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESPECT, 0) +} + +func (s *Respect_or_ignore_nullsContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Respect_or_ignore_nullsContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Respect_or_ignore_nullsContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Respect_or_ignore_nullsContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRespect_or_ignore_nulls(s) + } +} + +func (s *Respect_or_ignore_nullsContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRespect_or_ignore_nulls(s) + } +} + +func (s *Respect_or_ignore_nullsContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRespect_or_ignore_nulls(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Respect_or_ignore_nulls() (localctx IRespect_or_ignore_nullsContext) { + localctx = NewRespect_or_ignore_nullsContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2340, PlSqlParserRULE_respect_or_ignore_nulls) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19528) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserIGNORE || _la == PlSqlParserRESPECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19529) + p.Match(PlSqlParserNULLS) + 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 +} + +// IArgumentContext is an interface to support dynamic dispatch. +type IArgumentContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Expression() IExpressionContext + Identifier() IIdentifierContext + EQUALS_OP() antlr.TerminalNode + GREATER_THAN_OP() antlr.TerminalNode + + // IsArgumentContext differentiates from other interfaces. + IsArgumentContext() +} + +type ArgumentContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyArgumentContext() *ArgumentContext { + var p = new(ArgumentContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_argument + return p +} + +func InitEmptyArgumentContext(p *ArgumentContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_argument +} + +func (*ArgumentContext) IsArgumentContext() {} + +func NewArgumentContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ArgumentContext { + var p = new(ArgumentContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_argument + + return p +} + +func (s *ArgumentContext) GetParser() antlr.Parser { return s.parser } + +func (s *ArgumentContext) Expression() IExpressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *ArgumentContext) Identifier() IIdentifierContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IIdentifierContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IIdentifierContext) +} + +func (s *ArgumentContext) EQUALS_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUALS_OP, 0) +} + +func (s *ArgumentContext) GREATER_THAN_OP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATER_THAN_OP, 0) +} + +func (s *ArgumentContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ArgumentContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ArgumentContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterArgument(s) + } +} + +func (s *ArgumentContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitArgument(s) + } +} + +func (s *ArgumentContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitArgument(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Argument() (localctx IArgumentContext) { + localctx = NewArgumentContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2342, PlSqlParserRULE_argument) + p.EnterOuterAlt(localctx, 1) + p.SetState(19535) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2742, p.GetParserRuleContext()) == 1 { + { + p.SetState(19531) + p.Identifier() + } + { + p.SetState(19532) + p.Match(PlSqlParserEQUALS_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19533) + p.Match(PlSqlParserGREATER_THAN_OP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19537) + p.Expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IType_specContext is an interface to support dynamic dispatch. +type IType_specContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Datatype() IDatatypeContext + Type_name() IType_nameContext + REF() antlr.TerminalNode + PERCENT_ROWTYPE() antlr.TerminalNode + PERCENT_TYPE() antlr.TerminalNode + + // IsType_specContext differentiates from other interfaces. + IsType_specContext() +} + +type Type_specContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyType_specContext() *Type_specContext { + var p = new(Type_specContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_spec + return p +} + +func InitEmptyType_specContext(p *Type_specContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_type_spec +} + +func (*Type_specContext) IsType_specContext() {} + +func NewType_specContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Type_specContext { + var p = new(Type_specContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_type_spec + + return p +} + +func (s *Type_specContext) GetParser() antlr.Parser { return s.parser } + +func (s *Type_specContext) Datatype() IDatatypeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IDatatypeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IDatatypeContext) +} + +func (s *Type_specContext) Type_name() IType_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IType_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IType_nameContext) +} + +func (s *Type_specContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Type_specContext) PERCENT_ROWTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_ROWTYPE, 0) +} + +func (s *Type_specContext) PERCENT_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_TYPE, 0) +} + +func (s *Type_specContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Type_specContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Type_specContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterType_spec(s) + } +} + +func (s *Type_specContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitType_spec(s) + } +} + +func (s *Type_specContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitType_spec(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Type_spec() (localctx IType_specContext) { + localctx = NewType_specContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2344, PlSqlParserRULE_type_spec) + var _la int + + p.SetState(19547) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2745, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19539) + p.Datatype() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + p.SetState(19541) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2743, p.GetParserRuleContext()) == 1 { + { + p.SetState(19540) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + { + p.SetState(19543) + p.Type_name() + } + p.SetState(19545) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPERCENT_ROWTYPE || _la == PlSqlParserPERCENT_TYPE { + { + p.SetState(19544) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserPERCENT_ROWTYPE || _la == PlSqlParserPERCENT_TYPE) { + 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 +} + +// IDatatypeContext is an interface to support dynamic dispatch. +type IDatatypeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Native_datatype_element() INative_datatype_elementContext + Precision_part() IPrecision_partContext + WITH() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + SET() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + LOCAL() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + TO() antlr.TerminalNode + YEAR() antlr.TerminalNode + DAY() antlr.TerminalNode + MONTH() antlr.TerminalNode + SECOND() antlr.TerminalNode + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllExpression() []IExpressionContext + Expression(i int) IExpressionContext + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + + // IsDatatypeContext differentiates from other interfaces. + IsDatatypeContext() +} + +type DatatypeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyDatatypeContext() *DatatypeContext { + var p = new(DatatypeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype + return p +} + +func InitEmptyDatatypeContext(p *DatatypeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_datatype +} + +func (*DatatypeContext) IsDatatypeContext() {} + +func NewDatatypeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *DatatypeContext { + var p = new(DatatypeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_datatype + + return p +} + +func (s *DatatypeContext) GetParser() antlr.Parser { return s.parser } + +func (s *DatatypeContext) Native_datatype_element() INative_datatype_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INative_datatype_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INative_datatype_elementContext) +} + +func (s *DatatypeContext) Precision_part() IPrecision_partContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IPrecision_partContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IPrecision_partContext) +} + +func (s *DatatypeContext) WITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH, 0) +} + +func (s *DatatypeContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *DatatypeContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *DatatypeContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *DatatypeContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *DatatypeContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *DatatypeContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *DatatypeContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *DatatypeContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *DatatypeContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *DatatypeContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *DatatypeContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *DatatypeContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *DatatypeContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *DatatypeContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *DatatypeContext) AllExpression() []IExpressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IExpressionContext); ok { + len++ + } + } + + tst := make([]IExpressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IExpressionContext); ok { + tst[i] = t.(IExpressionContext) + i++ + } + } + + return tst +} + +func (s *DatatypeContext) Expression(i int) IExpressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IExpressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IExpressionContext) +} + +func (s *DatatypeContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *DatatypeContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *DatatypeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *DatatypeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *DatatypeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterDatatype(s) + } +} + +func (s *DatatypeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitDatatype(s) + } +} + +func (s *DatatypeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitDatatype(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Datatype() (localctx IDatatypeContext) { + localctx = NewDatatypeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2346, PlSqlParserRULE_datatype) + var _la int + + p.SetState(19580) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBFILE, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_INTEGER, PlSqlParserBLOB, PlSqlParserBOOLEAN, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCLOB, PlSqlParserDATE, PlSqlParserDAY, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDOUBLE, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserFLOAT, PlSqlParserHOUR, PlSqlParserINTEGER, PlSqlParserINT, PlSqlParserLONG, PlSqlParserMINUTE, PlSqlParserMLSLABEL, PlSqlParserMONTH, PlSqlParserNATURAL, PlSqlParserNATURALN, PlSqlParserNCHAR, PlSqlParserNCLOB, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNVARCHAR2, PlSqlParserPLS_INTEGER, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserRAW, PlSqlParserREAL, PlSqlParserROWID, PlSqlParserSECOND, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSMALLINT, PlSqlParserSTRING, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_REGION, PlSqlParserUROWID, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserYEAR, PlSqlParserYMINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19549) + p.Native_datatype_element() + } + p.SetState(19551) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2746, p.GetParserRuleContext()) == 1 { + { + p.SetState(19550) + p.Precision_part() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19562) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2748, p.GetParserRuleContext()) == 1 { + { + p.SetState(19553) + p.Match(PlSqlParserWITH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19555) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLOCAL { + { + p.SetState(19554) + p.Match(PlSqlParserLOCAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19557) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19558) + p.Match(PlSqlParserZONE) + 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(), 2748, p.GetParserRuleContext()) == 2 { + { + p.SetState(19559) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19560) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19561) + p.Char_set_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserINTERVAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19564) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19565) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19570) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserLEFT_PAREN { + { + p.SetState(19566) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19567) + p.Expression() + } + { + p.SetState(19568) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19572) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19573) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserMONTH || _la == PlSqlParserSECOND) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19578) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2750, p.GetParserRuleContext()) == 1 { + { + p.SetState(19574) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19575) + p.Expression() + } + { + p.SetState(19576) + p.Match(PlSqlParserRIGHT_PAREN) + 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 +} + +// IPrecision_partContext is an interface to support dynamic dispatch. +type IPrecision_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + AllNumeric() []INumericContext + Numeric(i int) INumericContext + ASTERISK() antlr.TerminalNode + COMMA() antlr.TerminalNode + CHAR() antlr.TerminalNode + BYTE() antlr.TerminalNode + Numeric_negative() INumeric_negativeContext + + // IsPrecision_partContext differentiates from other interfaces. + IsPrecision_partContext() +} + +type Precision_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyPrecision_partContext() *Precision_partContext { + var p = new(Precision_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_precision_part + return p +} + +func InitEmptyPrecision_partContext(p *Precision_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_precision_part +} + +func (*Precision_partContext) IsPrecision_partContext() {} + +func NewPrecision_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Precision_partContext { + var p = new(Precision_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_precision_part + + return p +} + +func (s *Precision_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *Precision_partContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Precision_partContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Precision_partContext) AllNumeric() []INumericContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(INumericContext); ok { + len++ + } + } + + tst := make([]INumericContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(INumericContext); ok { + tst[i] = t.(INumericContext) + i++ + } + } + + return tst +} + +func (s *Precision_partContext) Numeric(i int) INumericContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Precision_partContext) ASTERISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserASTERISK, 0) +} + +func (s *Precision_partContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Precision_partContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Precision_partContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Precision_partContext) Numeric_negative() INumeric_negativeContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumeric_negativeContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumeric_negativeContext) +} + +func (s *Precision_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Precision_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Precision_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterPrecision_part(s) + } +} + +func (s *Precision_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitPrecision_part(s) + } +} + +func (s *Precision_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitPrecision_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Precision_part() (localctx IPrecision_partContext) { + localctx = NewPrecision_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2348, PlSqlParserRULE_precision_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19582) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19585) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(19583) + p.Numeric() + } + + case PlSqlParserASTERISK: + { + p.SetState(19584) + p.Match(PlSqlParserASTERISK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(19592) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(19587) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19590) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + { + p.SetState(19588) + p.Numeric() + } + + case PlSqlParserMINUS_SIGN: + { + p.SetState(19589) + p.Numeric_negative() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + p.SetState(19595) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserBYTE || _la == PlSqlParserCHAR { + { + p.SetState(19594) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserBYTE || _la == PlSqlParserCHAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19597) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// INative_datatype_elementContext is an interface to support dynamic dispatch. +type INative_datatype_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + BINARY_INTEGER() antlr.TerminalNode + PLS_INTEGER() antlr.TerminalNode + NATURAL() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + NATURALN() antlr.TerminalNode + POSITIVE() antlr.TerminalNode + POSITIVEN() antlr.TerminalNode + SIGNTYPE() antlr.TerminalNode + SIMPLE_INTEGER() antlr.TerminalNode + NVARCHAR2() antlr.TerminalNode + DEC() antlr.TerminalNode + INTEGER() antlr.TerminalNode + INT() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + NUMBER() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + PRECISION() antlr.TerminalNode + FLOAT() antlr.TerminalNode + REAL() antlr.TerminalNode + NCHAR() antlr.TerminalNode + LONG() antlr.TerminalNode + RAW() antlr.TerminalNode + CHAR() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + STRING() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + DATE() antlr.TerminalNode + ROWID() antlr.TerminalNode + UROWID() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + DAY() antlr.TerminalNode + HOUR() antlr.TerminalNode + MINUTE() antlr.TerminalNode + SECOND() antlr.TerminalNode + TIMEZONE_HOUR() antlr.TerminalNode + TIMEZONE_MINUTE() antlr.TerminalNode + TIMEZONE_REGION() antlr.TerminalNode + TIMEZONE_ABBR() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode + YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode + DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode + BFILE() antlr.TerminalNode + BLOB() antlr.TerminalNode + CLOB() antlr.TerminalNode + NCLOB() antlr.TerminalNode + MLSLABEL() antlr.TerminalNode + + // IsNative_datatype_elementContext differentiates from other interfaces. + IsNative_datatype_elementContext() +} + +type Native_datatype_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNative_datatype_elementContext() *Native_datatype_elementContext { + var p = new(Native_datatype_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_native_datatype_element + return p +} + +func InitEmptyNative_datatype_elementContext(p *Native_datatype_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_native_datatype_element +} + +func (*Native_datatype_elementContext) IsNative_datatype_elementContext() {} + +func NewNative_datatype_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Native_datatype_elementContext { + var p = new(Native_datatype_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_native_datatype_element + + return p +} + +func (s *Native_datatype_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Native_datatype_elementContext) BINARY_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) PLS_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLS_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 0) +} + +func (s *Native_datatype_elementContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *Native_datatype_elementContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *Native_datatype_elementContext) NATURALN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURALN, 0) +} + +func (s *Native_datatype_elementContext) POSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVE, 0) +} + +func (s *Native_datatype_elementContext) POSITIVEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVEN, 0) +} + +func (s *Native_datatype_elementContext) SIGNTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNTYPE, 0) +} + +func (s *Native_datatype_elementContext) SIMPLE_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE_INTEGER, 0) +} + +func (s *Native_datatype_elementContext) NVARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVARCHAR2, 0) +} + +func (s *Native_datatype_elementContext) DEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEC, 0) +} + +func (s *Native_datatype_elementContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *Native_datatype_elementContext) INT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINT, 0) +} + +func (s *Native_datatype_elementContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMERIC, 0) +} + +func (s *Native_datatype_elementContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLINT, 0) +} + +func (s *Native_datatype_elementContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Native_datatype_elementContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *Native_datatype_elementContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Native_datatype_elementContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Native_datatype_elementContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *Native_datatype_elementContext) REAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAL, 0) +} + +func (s *Native_datatype_elementContext) NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR, 0) +} + +func (s *Native_datatype_elementContext) LONG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLONG, 0) +} + +func (s *Native_datatype_elementContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *Native_datatype_elementContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Native_datatype_elementContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Native_datatype_elementContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Native_datatype_elementContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *Native_datatype_elementContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *Native_datatype_elementContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOOLEAN, 0) +} + +func (s *Native_datatype_elementContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Native_datatype_elementContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Native_datatype_elementContext) UROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUROWID, 0) +} + +func (s *Native_datatype_elementContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Native_datatype_elementContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Native_datatype_elementContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Native_datatype_elementContext) HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, 0) +} + +func (s *Native_datatype_elementContext) MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, 0) +} + +func (s *Native_datatype_elementContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_HOUR, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_MINUTE, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_REGION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_REGION, 0) +} + +func (s *Native_datatype_elementContext) TIMEZONE_ABBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_ABBR, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserYMINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDSINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Native_datatype_elementContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Native_datatype_elementContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Native_datatype_elementContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Native_datatype_elementContext) NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCLOB, 0) +} + +func (s *Native_datatype_elementContext) MLSLABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMLSLABEL, 0) +} + +func (s *Native_datatype_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Native_datatype_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Native_datatype_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNative_datatype_element(s) + } +} + +func (s *Native_datatype_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNative_datatype_element(s) + } +} + +func (s *Native_datatype_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNative_datatype_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Native_datatype_element() (localctx INative_datatype_elementContext) { + localctx = NewNative_datatype_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2350, PlSqlParserRULE_native_datatype_element) + var _la int + + p.SetState(19659) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINARY_INTEGER: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19599) + p.Match(PlSqlParserBINARY_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPLS_INTEGER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19600) + p.Match(PlSqlParserPLS_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATURAL: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19601) + p.Match(PlSqlParserNATURAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_FLOAT: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19602) + p.Match(PlSqlParserBINARY_FLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINARY_DOUBLE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19603) + p.Match(PlSqlParserBINARY_DOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATURALN: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19604) + p.Match(PlSqlParserNATURALN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPOSITIVE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19605) + p.Match(PlSqlParserPOSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserPOSITIVEN: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19606) + p.Match(PlSqlParserPOSITIVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSIGNTYPE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(19607) + p.Match(PlSqlParserSIGNTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSIMPLE_INTEGER: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(19608) + p.Match(PlSqlParserSIMPLE_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNVARCHAR2: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(19609) + p.Match(PlSqlParserNVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEC: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(19610) + p.Match(PlSqlParserDEC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINTEGER: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(19611) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINT: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(19612) + p.Match(PlSqlParserINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNUMERIC: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(19613) + p.Match(PlSqlParserNUMERIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSMALLINT: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(19614) + p.Match(PlSqlParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNUMBER: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(19615) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDECIMAL: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(19616) + p.Match(PlSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDOUBLE: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(19617) + p.Match(PlSqlParserDOUBLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19619) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPRECISION { + { + p.SetState(19618) + p.Match(PlSqlParserPRECISION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserFLOAT: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(19621) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAL: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(19622) + p.Match(PlSqlParserREAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNCHAR: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(19623) + p.Match(PlSqlParserNCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserLONG: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(19624) + p.Match(PlSqlParserLONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19626) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserRAW { + { + p.SetState(19625) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + + case PlSqlParserCHAR: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(19628) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCHARACTER: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(19629) + p.Match(PlSqlParserCHARACTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARCHAR2: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(19630) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserVARCHAR: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(19631) + p.Match(PlSqlParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSTRING: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(19632) + p.Match(PlSqlParserSTRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserRAW: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(19633) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBOOLEAN: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(19634) + p.Match(PlSqlParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDATE: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(19635) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserROWID: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(19636) + p.Match(PlSqlParserROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUROWID: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(19637) + p.Match(PlSqlParserUROWID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserYEAR: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(19638) + p.Match(PlSqlParserYEAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMONTH: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(19639) + p.Match(PlSqlParserMONTH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDAY: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(19640) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHOUR: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(19641) + p.Match(PlSqlParserHOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUTE: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(19642) + p.Match(PlSqlParserMINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSECOND: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(19643) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_HOUR: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(19644) + p.Match(PlSqlParserTIMEZONE_HOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_MINUTE: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(19645) + p.Match(PlSqlParserTIMEZONE_MINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_REGION: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(19646) + p.Match(PlSqlParserTIMEZONE_REGION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMEZONE_ABBR: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(19647) + p.Match(PlSqlParserTIMEZONE_ABBR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(19648) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(19649) + p.Match(PlSqlParserTIMESTAMP_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(19650) + p.Match(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(19651) + p.Match(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserYMINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(19652) + p.Match(PlSqlParserYMINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDSINTERVAL_UNCONSTRAINED: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(19653) + p.Match(PlSqlParserDSINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBFILE: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(19654) + p.Match(PlSqlParserBFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBLOB: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(19655) + p.Match(PlSqlParserBLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCLOB: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(19656) + p.Match(PlSqlParserCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNCLOB: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(19657) + p.Match(PlSqlParserNCLOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMLSLABEL: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(19658) + p.Match(PlSqlParserMLSLABEL) + 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 +} + +// IBind_variableContext is an interface to support dynamic dispatch. +type IBind_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllBINDVAR() []antlr.TerminalNode + BINDVAR(i int) antlr.TerminalNode + AllCOLON() []antlr.TerminalNode + COLON(i int) antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + PERIOD() antlr.TerminalNode + General_element() IGeneral_elementContext + INDICATOR() antlr.TerminalNode + + // IsBind_variableContext differentiates from other interfaces. + IsBind_variableContext() +} + +type Bind_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyBind_variableContext() *Bind_variableContext { + var p = new(Bind_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bind_variable + return p +} + +func InitEmptyBind_variableContext(p *Bind_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_bind_variable +} + +func (*Bind_variableContext) IsBind_variableContext() {} + +func NewBind_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Bind_variableContext { + var p = new(Bind_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_bind_variable + + return p +} + +func (s *Bind_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Bind_variableContext) AllBINDVAR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserBINDVAR) +} + +func (s *Bind_variableContext) BINDVAR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDVAR, i) +} + +func (s *Bind_variableContext) AllCOLON() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserCOLON) +} + +func (s *Bind_variableContext) COLON(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLON, i) +} + +func (s *Bind_variableContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Bind_variableContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Bind_variableContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Bind_variableContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Bind_variableContext) INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICATOR, 0) +} + +func (s *Bind_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Bind_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Bind_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterBind_variable(s) + } +} + +func (s *Bind_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitBind_variable(s) + } +} + +func (s *Bind_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitBind_variable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Bind_variable() (localctx IBind_variableContext) { + localctx = NewBind_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2352, PlSqlParserRULE_bind_variable) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19664) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINDVAR: + { + p.SetState(19661) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLON: + { + p.SetState(19662) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19663) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(19674) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2762, p.GetParserRuleContext()) == 1 { + p.SetState(19667) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINDICATOR { + { + p.SetState(19666) + p.Match(PlSqlParserINDICATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + p.SetState(19672) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserBINDVAR: + { + p.SetState(19669) + p.Match(PlSqlParserBINDVAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserCOLON: + { + p.SetState(19670) + p.Match(PlSqlParserCOLON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19671) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19678) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2763, p.GetParserRuleContext()) == 1 { + { + p.SetState(19676) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19677) + p.General_element() + } + + } 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 +} + +// IGeneral_elementContext is an interface to support dynamic dispatch. +type IGeneral_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllGeneral_element_part() []IGeneral_element_partContext + General_element_part(i int) IGeneral_element_partContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsGeneral_elementContext differentiates from other interfaces. + IsGeneral_elementContext() +} + +type General_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_elementContext() *General_elementContext { + var p = new(General_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element + return p +} + +func InitEmptyGeneral_elementContext(p *General_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element +} + +func (*General_elementContext) IsGeneral_elementContext() {} + +func NewGeneral_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_elementContext { + var p = new(General_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_element + + return p +} + +func (s *General_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_elementContext) AllGeneral_element_part() []IGeneral_element_partContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IGeneral_element_partContext); ok { + len++ + } + } + + tst := make([]IGeneral_element_partContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IGeneral_element_partContext); ok { + tst[i] = t.(IGeneral_element_partContext) + i++ + } + } + + return tst +} + +func (s *General_elementContext) General_element_part(i int) IGeneral_element_partContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_element_partContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_element_partContext) +} + +func (s *General_elementContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *General_elementContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *General_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_element(s) + } +} + +func (s *General_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_element(s) + } +} + +func (s *General_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGeneral_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) General_element() (localctx IGeneral_elementContext) { + localctx = NewGeneral_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2354, PlSqlParserRULE_general_element) + var _alt int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19680) + p.General_element_part() + } + p.SetState(19685) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2764, p.GetParserRuleContext()) + if p.HasError() { + goto errorExit + } + for _alt != 2 && _alt != antlr.ATNInvalidAltNumber { + if _alt == 1 { + { + p.SetState(19681) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19682) + p.General_element_part() + } + + } + p.SetState(19687) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _alt = p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2764, 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 +} + +// IGeneral_element_partContext is an interface to support dynamic dispatch. +type IGeneral_element_partContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + AT_SIGN() antlr.TerminalNode + Link_name() ILink_nameContext + Function_argument() IFunction_argumentContext + + // IsGeneral_element_partContext differentiates from other interfaces. + IsGeneral_element_partContext() +} + +type General_element_partContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyGeneral_element_partContext() *General_element_partContext { + var p = new(General_element_partContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element_part + return p +} + +func InitEmptyGeneral_element_partContext(p *General_element_partContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_general_element_part +} + +func (*General_element_partContext) IsGeneral_element_partContext() {} + +func NewGeneral_element_partContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *General_element_partContext { + var p = new(General_element_partContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_general_element_part + + return p +} + +func (s *General_element_partContext) GetParser() antlr.Parser { return s.parser } + +func (s *General_element_partContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *General_element_partContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *General_element_partContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *General_element_partContext) AT_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT_SIGN, 0) +} + +func (s *General_element_partContext) Link_name() ILink_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(ILink_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(ILink_nameContext) +} + +func (s *General_element_partContext) Function_argument() IFunction_argumentContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IFunction_argumentContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IFunction_argumentContext) +} + +func (s *General_element_partContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *General_element_partContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *General_element_partContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterGeneral_element_part(s) + } +} + +func (s *General_element_partContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitGeneral_element_part(s) + } +} + +func (s *General_element_partContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitGeneral_element_part(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) General_element_part() (localctx IGeneral_element_partContext) { + localctx = NewGeneral_element_partContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2356, PlSqlParserRULE_general_element_part) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19690) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(19688) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19689) + p.Char_set_name() + } + + } + { + p.SetState(19692) + p.Id_expression() + } + p.SetState(19695) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2766, p.GetParserRuleContext()) == 1 { + { + p.SetState(19693) + p.Match(PlSqlParserAT_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19694) + p.Link_name() + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(19698) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2767, p.GetParserRuleContext()) == 1 { + { + p.SetState(19697) + p.Function_argument() + } + + } 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 +} + +// ITable_elementContext is an interface to support dynamic dispatch. +type ITable_elementContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AllId_expression() []IId_expressionContext + Id_expression(i int) IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + AllPERIOD() []antlr.TerminalNode + PERIOD(i int) antlr.TerminalNode + + // IsTable_elementContext differentiates from other interfaces. + IsTable_elementContext() +} + +type Table_elementContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyTable_elementContext() *Table_elementContext { + var p = new(Table_elementContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_element + return p +} + +func InitEmptyTable_elementContext(p *Table_elementContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_table_element +} + +func (*Table_elementContext) IsTable_elementContext() {} + +func NewTable_elementContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Table_elementContext { + var p = new(Table_elementContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_table_element + + return p +} + +func (s *Table_elementContext) GetParser() antlr.Parser { return s.parser } + +func (s *Table_elementContext) AllId_expression() []IId_expressionContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IId_expressionContext); ok { + len++ + } + } + + tst := make([]IId_expressionContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IId_expressionContext); ok { + tst[i] = t.(IId_expressionContext) + i++ + } + } + + return tst +} + +func (s *Table_elementContext) Id_expression(i int) IId_expressionContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *Table_elementContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *Table_elementContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *Table_elementContext) AllPERIOD() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserPERIOD) +} + +func (s *Table_elementContext) PERIOD(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, i) +} + +func (s *Table_elementContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Table_elementContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Table_elementContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterTable_element(s) + } +} + +func (s *Table_elementContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitTable_element(s) + } +} + +func (s *Table_elementContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitTable_element(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Table_element() (localctx ITable_elementContext) { + localctx = NewTable_elementContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2358, PlSqlParserRULE_table_element) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(19702) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(19700) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19701) + p.Char_set_name() + } + + } + { + p.SetState(19704) + p.Id_expression() + } + p.SetState(19709) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + for _la == PlSqlParserPERIOD { + { + p.SetState(19705) + p.Match(PlSqlParserPERIOD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19706) + p.Id_expression() + } + + p.SetState(19711) + 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_privilegeContext is an interface to support dynamic dispatch. +type IObject_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ALTER() antlr.TerminalNode + DEBUG() antlr.TerminalNode + DELETE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INHERIT() antlr.TerminalNode + INSERT() antlr.TerminalNode + KEEP() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + MERGE() antlr.TerminalNode + VIEW() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + READ() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + SELECT() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + SQL() antlr.TerminalNode + UNDER() antlr.TerminalNode + UPDATE() antlr.TerminalNode + USE() antlr.TerminalNode + WRITE() 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 = PlSqlParserRULE_object_privilege + return p +} + +func InitEmptyObject_privilegeContext(p *Object_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_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 = PlSqlParserRULE_object_privilege + + return p +} + +func (s *Object_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Object_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *Object_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Object_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *Object_privilegeContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Object_privilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Object_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Object_privilegeContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Object_privilegeContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Object_privilegeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *Object_privilegeContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *Object_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *Object_privilegeContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Object_privilegeContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Object_privilegeContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Object_privilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *Object_privilegeContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *Object_privilegeContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Object_privilegeContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Object_privilegeContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Object_privilegeContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Object_privilegeContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Object_privilegeContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Object_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *Object_privilegeContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Object_privilegeContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Object_privilegeContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Object_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *Object_privilegeContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Object_privilegeContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 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.(PlSqlParserListener); ok { + listenerT.EnterObject_privilege(s) + } +} + +func (s *Object_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitObject_privilege(s) + } +} + +func (s *Object_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitObject_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Object_privilege() (localctx IObject_privilegeContext) { + localctx = NewObject_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2360, PlSqlParserRULE_object_privilege) + p.SetState(19744) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserALL: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19712) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19714) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2770, p.GetParserRuleContext()) == 1 { + { + p.SetState(19713) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserALTER: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19716) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEBUG: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19717) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDELETE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19718) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserEXECUTE: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19719) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFLASHBACK: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19720) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19721) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINDEX: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19722) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINHERIT: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19723) + p.Match(PlSqlParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19724) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserINSERT: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(19725) + p.Match(PlSqlParserINSERT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserKEEP: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(19726) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19727) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMERGE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(19728) + p.Match(PlSqlParserMERGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19729) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserON: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(19730) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19731) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19732) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserQUERY: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(19733) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19734) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREAD: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(19735) + p.Match(PlSqlParserREAD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserREFERENCES: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(19736) + p.Match(PlSqlParserREFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSELECT: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(19737) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRANSLATE: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(19738) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19739) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUNDER: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(19740) + p.Match(PlSqlParserUNDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUPDATE: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(19741) + p.Match(PlSqlParserUPDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserUSE: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(19742) + p.Match(PlSqlParserUSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserWRITE: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(19743) + p.Match(PlSqlParserWRITE) + 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 +} + +// ISystem_privilegeContext is an interface to support dynamic dispatch. +type ISystem_privilegeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ALL() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + ADVISOR() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + SQL() antlr.TerminalNode + TUNING() antlr.TerminalNode + SET() antlr.TerminalNode + ANY() antlr.TerminalNode + PROFILE() antlr.TerminalNode + ALTER() antlr.TerminalNode + CREATE() antlr.TerminalNode + DROP() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + OBJECT() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + EXEMPT() antlr.TerminalNode + REDACTION() antlr.TerminalNode + POLICY() antlr.TerminalNode + DATABASE() antlr.TerminalNode + LINK() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + DEBUG() antlr.TerminalNode + CONNECT() antlr.TerminalNode + SESSION() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + EDITION() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + TABLE() antlr.TerminalNode + INDEX() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + JOB() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + CLASS() antlr.TerminalNode + PROGRAM() antlr.TerminalNode + MANAGE() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + KEY() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + LOGMINING() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + VIEW() antlr.TerminalNode + QUERY() antlr.TerminalNode + REWRITE() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + ON() antlr.TerminalNode + COMMIT() antlr.TerminalNode + REFRESH() antlr.TerminalNode + MINING() antlr.TerminalNode + MODEL() antlr.TerminalNode + SELECT() antlr.TerminalNode + COMMENT() antlr.TerminalNode + CUBE() antlr.TerminalNode + UPDATE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + FOLDER() antlr.TerminalNode + DELETE() antlr.TerminalNode + INSERT() antlr.TerminalNode + BUILD() antlr.TerminalNode + PROCESS() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + CONTAINER() antlr.TerminalNode + ROLE() antlr.TerminalNode + GRANT() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + RESOURCE() antlr.TerminalNode + COST() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + USE() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + SYNONYM() antlr.TerminalNode + BACKUP() antlr.TerminalNode + LOCK() antlr.TerminalNode + READ() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + TYPE() antlr.TerminalNode + UNDER() antlr.TerminalNode + USER() antlr.TerminalNode + MERGE() antlr.TerminalNode + AUDIT() antlr.TerminalNode + BECOME() antlr.TerminalNode + CHANGE() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + ACCESS() antlr.TerminalNode + FORCE() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + PRIVILEGE() antlr.TerminalNode + INHERIT() antlr.TerminalNode + KEEP() antlr.TerminalNode + DATE() antlr.TerminalNode + TIME() antlr.TerminalNode + SYSGUID() antlr.TerminalNode + PURGE() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + SYSBACKUP() antlr.TerminalNode + SYSDBA() antlr.TerminalNode + SYSDG() antlr.TerminalNode + SYSKM() antlr.TerminalNode + SYSOPER() antlr.TerminalNode + + // IsSystem_privilegeContext differentiates from other interfaces. + IsSystem_privilegeContext() +} + +type System_privilegeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptySystem_privilegeContext() *System_privilegeContext { + var p = new(System_privilegeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_privilege + return p +} + +func InitEmptySystem_privilegeContext(p *System_privilegeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_system_privilege +} + +func (*System_privilegeContext) IsSystem_privilegeContext() {} + +func NewSystem_privilegeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *System_privilegeContext { + var p = new(System_privilegeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_system_privilege + + return p +} + +func (s *System_privilegeContext) GetParser() antlr.Parser { return s.parser } + +func (s *System_privilegeContext) ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL, 0) +} + +func (s *System_privilegeContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *System_privilegeContext) ADVISOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISOR, 0) +} + +func (s *System_privilegeContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *System_privilegeContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *System_privilegeContext) TUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTUNING, 0) +} + +func (s *System_privilegeContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *System_privilegeContext) ANY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANY, 0) +} + +func (s *System_privilegeContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *System_privilegeContext) ALTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTER, 0) +} + +func (s *System_privilegeContext) CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE, 0) +} + +func (s *System_privilegeContext) DROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP, 0) +} + +func (s *System_privilegeContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *System_privilegeContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *System_privilegeContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *System_privilegeContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *System_privilegeContext) EXEMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXEMPT, 0) +} + +func (s *System_privilegeContext) REDACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDACTION, 0) +} + +func (s *System_privilegeContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *System_privilegeContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *System_privilegeContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *System_privilegeContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *System_privilegeContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *System_privilegeContext) CONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT, 0) +} + +func (s *System_privilegeContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *System_privilegeContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *System_privilegeContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *System_privilegeContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDICTIONARY, 0) +} + +func (s *System_privilegeContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *System_privilegeContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *System_privilegeContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *System_privilegeContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *System_privilegeContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *System_privilegeContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *System_privilegeContext) INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX, 0) +} + +func (s *System_privilegeContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *System_privilegeContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *System_privilegeContext) JOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOB, 0) +} + +func (s *System_privilegeContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *System_privilegeContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *System_privilegeContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROGRAM, 0) +} + +func (s *System_privilegeContext) MANAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGE, 0) +} + +func (s *System_privilegeContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEDULER, 0) +} + +func (s *System_privilegeContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *System_privilegeContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *System_privilegeContext) LOGMINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGMINING, 0) +} + +func (s *System_privilegeContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *System_privilegeContext) VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIEW, 0) +} + +func (s *System_privilegeContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *System_privilegeContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *System_privilegeContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *System_privilegeContext) ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserON, 0) +} + +func (s *System_privilegeContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *System_privilegeContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *System_privilegeContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *System_privilegeContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *System_privilegeContext) SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECT, 0) +} + +func (s *System_privilegeContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *System_privilegeContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *System_privilegeContext) UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATE, 0) +} + +func (s *System_privilegeContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *System_privilegeContext) FOLDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLDER, 0) +} + +func (s *System_privilegeContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *System_privilegeContext) INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERT, 0) +} + +func (s *System_privilegeContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *System_privilegeContext) PROCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCESS, 0) +} + +func (s *System_privilegeContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *System_privilegeContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *System_privilegeContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *System_privilegeContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *System_privilegeContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *System_privilegeContext) GRANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserGRANT, 0) +} + +func (s *System_privilegeContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *System_privilegeContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *System_privilegeContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *System_privilegeContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *System_privilegeContext) RESOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOURCE, 0) +} + +func (s *System_privilegeContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *System_privilegeContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *System_privilegeContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *System_privilegeContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *System_privilegeContext) SYNONYM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNONYM, 0) +} + +func (s *System_privilegeContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *System_privilegeContext) LOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCK, 0) +} + +func (s *System_privilegeContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *System_privilegeContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *System_privilegeContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *System_privilegeContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *System_privilegeContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *System_privilegeContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *System_privilegeContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *System_privilegeContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *System_privilegeContext) AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUDIT, 0) +} + +func (s *System_privilegeContext) BECOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBECOME, 0) +} + +func (s *System_privilegeContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *System_privilegeContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTIFICATION, 0) +} + +func (s *System_privilegeContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *System_privilegeContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *System_privilegeContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *System_privilegeContext) PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGE, 0) +} + +func (s *System_privilegeContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *System_privilegeContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *System_privilegeContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *System_privilegeContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *System_privilegeContext) SYSGUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSGUID, 0) +} + +func (s *System_privilegeContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *System_privilegeContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *System_privilegeContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUMABLE, 0) +} + +func (s *System_privilegeContext) SYSBACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSBACKUP, 0) +} + +func (s *System_privilegeContext) SYSDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDBA, 0) +} + +func (s *System_privilegeContext) SYSDG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDG, 0) +} + +func (s *System_privilegeContext) SYSKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSKM, 0) +} + +func (s *System_privilegeContext) SYSOPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOPER, 0) +} + +func (s *System_privilegeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *System_privilegeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *System_privilegeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterSystem_privilege(s) + } +} + +func (s *System_privilegeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitSystem_privilege(s) + } +} + +func (s *System_privilegeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitSystem_privilege(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) System_privilege() (localctx ISystem_privilegeContext) { + localctx = NewSystem_privilegeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2362, PlSqlParserRULE_system_privilege) + var _la int + + p.SetState(20072) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2798, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(19746) + p.Match(PlSqlParserALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19747) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(19748) + p.Match(PlSqlParserADVISOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(19749) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19751) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19750) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19753) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19754) + p.Match(PlSqlParserTUNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19755) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(19756) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19757) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19758) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19759) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(19760) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19761) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19762) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19763) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(19764) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19766) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19765) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19768) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(19769) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19770) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19771) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(19772) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19773) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19774) + p.Match(PlSqlParserCONTEXT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(19775) + p.Match(PlSqlParserEXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19776) + p.Match(PlSqlParserREDACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19777) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(19778) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19779) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(19780) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(19782) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserPUBLIC { + { + p.SetState(19781) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19784) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19785) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(19786) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19787) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19788) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19789) + p.Match(PlSqlParserLINK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(19790) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19791) + p.Match(PlSqlParserCONNECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19792) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(19793) + p.Match(PlSqlParserDEBUG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19794) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19795) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(19796) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19797) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19798) + p.Match(PlSqlParserDICTIONARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(19799) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19801) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19800) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19803) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(19804) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19805) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19806) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(19807) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19808) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19809) + p.Match(PlSqlParserDIRECTORY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(19810) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19811) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19812) + p.Match(PlSqlParserEDITION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(19813) + p.Match(PlSqlParserFLASHBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19818) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserARCHIVE: + { + p.SetState(19814) + p.Match(PlSqlParserARCHIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19815) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserANY: + { + p.SetState(19816) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19817) + p.Match(PlSqlParserTABLE) + 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(19820) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19821) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19822) + p.Match(PlSqlParserINDEX) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(19823) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19825) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19824) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19827) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(19828) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19829) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19830) + p.Match(PlSqlParserINDEXTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(19831) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19833) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY || _la == PlSqlParserEXTERNAL { + { + p.SetState(19832) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserANY || _la == PlSqlParserEXTERNAL) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + } + { + p.SetState(19835) + p.Match(PlSqlParserJOB) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(19836) + p.Match(PlSqlParserEXECUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19837) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19838) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCLASS || _la == PlSqlParserPROGRAM) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(19839) + p.Match(PlSqlParserMANAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19840) + p.Match(PlSqlParserSCHEDULER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(19841) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19842) + p.Match(PlSqlParserKEY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19843) + p.Match(PlSqlParserMANAGEMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(19844) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19846) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19845) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19848) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(19849) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19850) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19851) + p.Match(PlSqlParserLIBRARY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(19852) + p.Match(PlSqlParserLOGMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(19853) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19855) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19854) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19857) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19858) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(19859) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19860) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19861) + p.Match(PlSqlParserMATERIALIZED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19862) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + p.SetState(19864) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserGLOBAL { + { + p.SetState(19863) + p.Match(PlSqlParserGLOBAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19866) + p.Match(PlSqlParserQUERY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19867) + p.Match(PlSqlParserREWRITE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(19868) + p.Match(PlSqlParserON) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19869) + p.Match(PlSqlParserCOMMIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19870) + p.Match(PlSqlParserREFRESH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(19871) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19873) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19872) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19875) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19876) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(19877) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCOMMENT || _la == PlSqlParserDROP || _la == PlSqlParserSELECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19878) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19879) + p.Match(PlSqlParserMINING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19880) + p.Match(PlSqlParserMODEL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(19881) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19883) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19882) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19885) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(19886) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19887) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19888) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(19889) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19891) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19890) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19893) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19894) + p.Match(PlSqlParserFOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(19895) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19896) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19897) + p.Match(PlSqlParserMEASURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19898) + p.Match(PlSqlParserFOLDER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(19899) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19901) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19900) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19903) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19904) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(19905) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19906) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19907) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19908) + p.Match(PlSqlParserDIMENSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(19909) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19911) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19910) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19913) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19914) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19915) + p.Match(PlSqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(19916) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19917) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19918) + p.Match(PlSqlParserCUBE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19919) + p.Match(PlSqlParserBUILD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19920) + p.Match(PlSqlParserPROCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(19921) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19923) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19922) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19925) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(19926) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19927) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19928) + p.Match(PlSqlParserOPERATOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(19929) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19930) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19931) + p.Match(PlSqlParserOUTLINE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(19932) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19933) + p.Match(PlSqlParserPLUGGABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19934) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(19935) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19936) + p.Match(PlSqlParserCONTAINER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(19937) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19939) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19938) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19941) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(19942) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19943) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19944) + p.Match(PlSqlParserPROCEDURE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(19945) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19946) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(19947) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19948) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(19949) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserGRANT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19950) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19951) + p.Match(PlSqlParserROLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(19952) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19953) + p.Match(PlSqlParserROLLBACK) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19954) + p.Match(PlSqlParserSEGMENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(19955) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19957) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19956) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19959) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(19960) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserSELECT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19961) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19962) + p.Match(PlSqlParserSEQUENCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(19963) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserRESTRICTED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19964) + p.Match(PlSqlParserSESSION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(19965) + p.Match(PlSqlParserALTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19966) + p.Match(PlSqlParserRESOURCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19967) + p.Match(PlSqlParserCOST) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(19968) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19970) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19969) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19972) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19973) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19974) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(19975) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserUSE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19976) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19977) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19978) + p.Match(PlSqlParserTRANSLATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19979) + p.Match(PlSqlParserPROFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(19980) + p.Match(PlSqlParserTRANSLATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19981) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19982) + p.Match(PlSqlParserSQL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(19983) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19985) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19984) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19987) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(19988) + p.Match(PlSqlParserDROP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19989) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19990) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(19991) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(19992) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(19993) + p.Match(PlSqlParserSYNONYM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(19994) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(19996) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(19995) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(19998) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(19999) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserBACKUP || _la == PlSqlParserCOMMENT || _la == PlSqlParserDELETE || _la == PlSqlParserDROP || _la == PlSqlParserINSERT || _la == PlSqlParserLOCK || _la == PlSqlParserREAD || _la == PlSqlParserSELECT || _la == PlSqlParserUPDATE) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20000) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20001) + p.Match(PlSqlParserTABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(20002) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP || _la == PlSqlParserMANAGE || _la == PlSqlParserUNLIMITED) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20003) + p.Match(PlSqlParserTABLESPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(20004) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20006) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20005) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20008) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(20009) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20010) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20011) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(20012) + p.Match(PlSqlParserADMINISTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20013) + p.Match(PlSqlParserDATABASE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20014) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(20015) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20017) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20016) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20019) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(20020) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserDROP || _la == PlSqlParserEXECUTE || _la == PlSqlParserUNDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20021) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20022) + p.Match(PlSqlParserTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(20023) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserALTER || _la == PlSqlParserCREATE || _la == PlSqlParserDROP) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20024) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(20025) + p.Match(PlSqlParserCREATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20027) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20026) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20029) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(20030) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDROP || _la == PlSqlParserMERGE || _la == PlSqlParserUNDER) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20031) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20032) + p.Match(PlSqlParserVIEW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(20033) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserANALYZE || _la == PlSqlParserAUDIT) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + { + p.SetState(20034) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(20035) + p.Match(PlSqlParserBECOME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20036) + p.Match(PlSqlParserUSER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(20037) + p.Match(PlSqlParserCHANGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20038) + p.Match(PlSqlParserNOTIFICATION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(20039) + p.Match(PlSqlParserEXEMPT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20040) + p.Match(PlSqlParserACCESS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20041) + p.Match(PlSqlParserPOLICY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(20042) + p.Match(PlSqlParserFORCE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20044) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserANY { + { + p.SetState(20043) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20046) + p.Match(PlSqlParserTRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(20047) + p.Match(PlSqlParserGRANT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20048) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20050) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserOBJECT { + { + p.SetState(20049) + p.Match(PlSqlParserOBJECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } + { + p.SetState(20052) + p.Match(PlSqlParserPRIVILEGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(20053) + p.Match(PlSqlParserINHERIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20054) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20055) + p.Match(PlSqlParserPRIVILEGES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(20056) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20057) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20058) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(20059) + p.Match(PlSqlParserKEEP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20060) + p.Match(PlSqlParserSYSGUID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(20061) + p.Match(PlSqlParserPURGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20062) + p.Match(PlSqlParserDBA_RECYCLEBIN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(20063) + p.Match(PlSqlParserRESUMABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(20064) + p.Match(PlSqlParserSELECT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20065) + p.Match(PlSqlParserANY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20066) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDICTIONARY || _la == PlSqlParserTRANSACTION) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(20067) + p.Match(PlSqlParserSYSBACKUP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(20068) + p.Match(PlSqlParserSYSDBA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(20069) + p.Match(PlSqlParserSYSDG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(20070) + p.Match(PlSqlParserSYSKM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(20071) + p.Match(PlSqlParserSYSOPER) + 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 +} + +// IConstantContext is an interface to support dynamic dispatch. +type IConstantContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIMESTAMP() antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + AllBind_variable() []IBind_variableContext + Bind_variable(i int) IBind_variableContext + AT() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + AllDAY() []antlr.TerminalNode + DAY(i int) antlr.TerminalNode + AllHOUR() []antlr.TerminalNode + HOUR(i int) antlr.TerminalNode + AllMINUTE() []antlr.TerminalNode + MINUTE(i int) antlr.TerminalNode + AllSECOND() []antlr.TerminalNode + SECOND(i int) antlr.TerminalNode + General_element() IGeneral_elementContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + Numeric() INumericContext + DATE() antlr.TerminalNode + NULL_() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + DBTIMEZONE() antlr.TerminalNode + SESSIONTIMEZONE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsConstantContext differentiates from other interfaces. + IsConstantContext() +} + +type ConstantContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstantContext() *ConstantContext { + var p = new(ConstantContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant + return p +} + +func InitEmptyConstantContext(p *ConstantContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant +} + +func (*ConstantContext) IsConstantContext() {} + +func NewConstantContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ConstantContext { + var p = new(ConstantContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constant + + return p +} + +func (s *ConstantContext) GetParser() antlr.Parser { return s.parser } + +func (s *ConstantContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *ConstantContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *ConstantContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *ConstantContext) AllBind_variable() []IBind_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBind_variableContext); ok { + len++ + } + } + + tst := make([]IBind_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBind_variableContext); ok { + tst[i] = t.(IBind_variableContext) + i++ + } + } + + return tst +} + +func (s *ConstantContext) Bind_variable(i int) IBind_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *ConstantContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *ConstantContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *ConstantContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *ConstantContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *ConstantContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *ConstantContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *ConstantContext) AllDAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDAY) +} + +func (s *ConstantContext) DAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, i) +} + +func (s *ConstantContext) AllHOUR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHOUR) +} + +func (s *ConstantContext) HOUR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, i) +} + +func (s *ConstantContext) AllMINUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUTE) +} + +func (s *ConstantContext) MINUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, i) +} + +func (s *ConstantContext) AllSECOND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECOND) +} + +func (s *ConstantContext) SECOND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, i) +} + +func (s *ConstantContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *ConstantContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *ConstantContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *ConstantContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *ConstantContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *ConstantContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *ConstantContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *ConstantContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *ConstantContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *ConstantContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *ConstantContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *ConstantContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *ConstantContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *ConstantContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *ConstantContext) DBTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBTIMEZONE, 0) +} + +func (s *ConstantContext) SESSIONTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTIMEZONE, 0) +} + +func (s *ConstantContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *ConstantContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *ConstantContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *ConstantContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *ConstantContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *ConstantContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstant(s) + } +} + +func (s *ConstantContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstant(s) + } +} + +func (s *ConstantContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstant(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constant() (localctx IConstantContext) { + localctx = NewConstantContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2364, PlSqlParserRULE_constant) + var _la int + + p.SetState(20136) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2810, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20074) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20077) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2799, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20075) + p.Quoted_string() + } + + case 2: + { + p.SetState(20076) + p.Bind_variable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(20083) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2800, p.GetParserRuleContext()) == 1 { + { + p.SetState(20079) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20080) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20081) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20082) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20085) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20089) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2801, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20086) + p.Quoted_string() + } + + case 2: + { + p.SetState(20087) + p.Bind_variable() + } + + case 3: + { + p.SetState(20088) + p.General_element() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(20091) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserHOUR || _la == PlSqlParserMINUTE || _la == PlSqlParserMONTH || _la == PlSqlParserSECOND || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20105) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2805, p.GetParserRuleContext()) == 1 { + { + p.SetState(20092) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20095) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20093) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20094) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20102) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(20097) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20100) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20098) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20099) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(20104) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20122) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2809, p.GetParserRuleContext()) == 1 { + { + p.SetState(20107) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20120) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDAY: + { + p.SetState(20108) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHOUR: + { + p.SetState(20109) + p.Match(PlSqlParserHOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUTE: + { + p.SetState(20110) + p.Match(PlSqlParserMINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSECOND: + { + p.SetState(20111) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20118) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2807, p.GetParserRuleContext()) == 1 { + { + p.SetState(20112) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20115) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20113) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20114) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(20117) + p.Match(PlSqlParserRIGHT_PAREN) + 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 + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20124) + p.Numeric() + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20125) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20126) + p.Quoted_string() + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20127) + p.Quoted_string() + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20128) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20129) + p.Match(PlSqlParserTRUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20130) + p.Match(PlSqlParserFALSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20131) + p.Match(PlSqlParserDBTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20132) + p.Match(PlSqlParserSESSIONTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20133) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20134) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20135) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// IConstant_without_variableContext is an interface to support dynamic dispatch. +type IConstant_without_variableContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + TIMESTAMP() antlr.TerminalNode + AllQuoted_string() []IQuoted_stringContext + Quoted_string(i int) IQuoted_stringContext + AllBind_variable() []IBind_variableContext + Bind_variable(i int) IBind_variableContext + AT() antlr.TerminalNode + TIME() antlr.TerminalNode + ZONE() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + YEAR() antlr.TerminalNode + MONTH() antlr.TerminalNode + AllDAY() []antlr.TerminalNode + DAY(i int) antlr.TerminalNode + AllHOUR() []antlr.TerminalNode + HOUR(i int) antlr.TerminalNode + AllMINUTE() []antlr.TerminalNode + MINUTE(i int) antlr.TerminalNode + AllSECOND() []antlr.TerminalNode + SECOND(i int) antlr.TerminalNode + General_element() IGeneral_elementContext + AllLEFT_PAREN() []antlr.TerminalNode + LEFT_PAREN(i int) antlr.TerminalNode + AllRIGHT_PAREN() []antlr.TerminalNode + RIGHT_PAREN(i int) antlr.TerminalNode + TO() antlr.TerminalNode + AllUNSIGNED_INTEGER() []antlr.TerminalNode + UNSIGNED_INTEGER(i int) antlr.TerminalNode + COMMA() antlr.TerminalNode + Numeric() INumericContext + DATE() antlr.TerminalNode + Char_str() IChar_strContext + NULL_() antlr.TerminalNode + TRUE() antlr.TerminalNode + FALSE() antlr.TerminalNode + DBTIMEZONE() antlr.TerminalNode + SESSIONTIMEZONE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + DEFAULT() antlr.TerminalNode + + // IsConstant_without_variableContext differentiates from other interfaces. + IsConstant_without_variableContext() +} + +type Constant_without_variableContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyConstant_without_variableContext() *Constant_without_variableContext { + var p = new(Constant_without_variableContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant_without_variable + return p +} + +func InitEmptyConstant_without_variableContext(p *Constant_without_variableContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_constant_without_variable +} + +func (*Constant_without_variableContext) IsConstant_without_variableContext() {} + +func NewConstant_without_variableContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Constant_without_variableContext { + var p = new(Constant_without_variableContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_constant_without_variable + + return p +} + +func (s *Constant_without_variableContext) GetParser() antlr.Parser { return s.parser } + +func (s *Constant_without_variableContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Constant_without_variableContext) AllQuoted_string() []IQuoted_stringContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IQuoted_stringContext); ok { + len++ + } + } + + tst := make([]IQuoted_stringContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IQuoted_stringContext); ok { + tst[i] = t.(IQuoted_stringContext) + i++ + } + } + + return tst +} + +func (s *Constant_without_variableContext) Quoted_string(i int) IQuoted_stringContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IQuoted_stringContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IQuoted_stringContext) +} + +func (s *Constant_without_variableContext) AllBind_variable() []IBind_variableContext { + children := s.GetChildren() + len := 0 + for _, ctx := range children { + if _, ok := ctx.(IBind_variableContext); ok { + len++ + } + } + + tst := make([]IBind_variableContext, len) + i := 0 + for _, ctx := range children { + if t, ok := ctx.(IBind_variableContext); ok { + tst[i] = t.(IBind_variableContext) + i++ + } + } + + return tst +} + +func (s *Constant_without_variableContext) Bind_variable(i int) IBind_variableContext { + var t antlr.RuleContext + j := 0 + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IBind_variableContext); ok { + if j == i { + t = ctx.(antlr.RuleContext) + break + } + j++ + } + } + + if t == nil { + return nil + } + + return t.(IBind_variableContext) +} + +func (s *Constant_without_variableContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Constant_without_variableContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Constant_without_variableContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *Constant_without_variableContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Constant_without_variableContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Constant_without_variableContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Constant_without_variableContext) AllDAY() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserDAY) +} + +func (s *Constant_without_variableContext) DAY(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, i) +} + +func (s *Constant_without_variableContext) AllHOUR() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserHOUR) +} + +func (s *Constant_without_variableContext) HOUR(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, i) +} + +func (s *Constant_without_variableContext) AllMINUTE() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserMINUTE) +} + +func (s *Constant_without_variableContext) MINUTE(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, i) +} + +func (s *Constant_without_variableContext) AllSECOND() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserSECOND) +} + +func (s *Constant_without_variableContext) SECOND(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, i) +} + +func (s *Constant_without_variableContext) General_element() IGeneral_elementContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IGeneral_elementContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IGeneral_elementContext) +} + +func (s *Constant_without_variableContext) AllLEFT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserLEFT_PAREN) +} + +func (s *Constant_without_variableContext) LEFT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, i) +} + +func (s *Constant_without_variableContext) AllRIGHT_PAREN() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserRIGHT_PAREN) +} + +func (s *Constant_without_variableContext) RIGHT_PAREN(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, i) +} + +func (s *Constant_without_variableContext) TO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO, 0) +} + +func (s *Constant_without_variableContext) AllUNSIGNED_INTEGER() []antlr.TerminalNode { + return s.GetTokens(PlSqlParserUNSIGNED_INTEGER) +} + +func (s *Constant_without_variableContext) UNSIGNED_INTEGER(i int) antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, i) +} + +func (s *Constant_without_variableContext) COMMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMA, 0) +} + +func (s *Constant_without_variableContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Constant_without_variableContext) DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE, 0) +} + +func (s *Constant_without_variableContext) Char_str() IChar_strContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_strContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_strContext) +} + +func (s *Constant_without_variableContext) NULL_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULL_, 0) +} + +func (s *Constant_without_variableContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *Constant_without_variableContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *Constant_without_variableContext) DBTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBTIMEZONE, 0) +} + +func (s *Constant_without_variableContext) SESSIONTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTIMEZONE, 0) +} + +func (s *Constant_without_variableContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Constant_without_variableContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Constant_without_variableContext) DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT, 0) +} + +func (s *Constant_without_variableContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Constant_without_variableContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Constant_without_variableContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterConstant_without_variable(s) + } +} + +func (s *Constant_without_variableContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitConstant_without_variable(s) + } +} + +func (s *Constant_without_variableContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitConstant_without_variable(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Constant_without_variable() (localctx IConstant_without_variableContext) { + localctx = NewConstant_without_variableContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2366, PlSqlParserRULE_constant_without_variable) + var _la int + + p.SetState(20200) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserTIMESTAMP: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20138) + p.Match(PlSqlParserTIMESTAMP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20141) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2811, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20139) + p.Quoted_string() + } + + case 2: + { + p.SetState(20140) + p.Bind_variable() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + p.SetState(20147) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2812, p.GetParserRuleContext()) == 1 { + { + p.SetState(20143) + p.Match(PlSqlParserAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20144) + p.Match(PlSqlParserTIME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20145) + p.Match(PlSqlParserZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20146) + p.Quoted_string() + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserINTERVAL: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20149) + p.Match(PlSqlParserINTERVAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20153) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2813, p.GetParserRuleContext()) { + case 1: + { + p.SetState(20150) + p.Quoted_string() + } + + case 2: + { + p.SetState(20151) + p.Bind_variable() + } + + case 3: + { + p.SetState(20152) + p.General_element() + } + + case antlr.ATNInvalidAltNumber: + goto errorExit + } + { + p.SetState(20155) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserDAY || _la == PlSqlParserHOUR || _la == PlSqlParserMINUTE || _la == PlSqlParserMONTH || _la == PlSqlParserSECOND || _la == PlSqlParserYEAR) { + p.GetErrorHandler().RecoverInline(p) + } else { + p.GetErrorHandler().ReportMatch(p) + p.Consume() + } + } + p.SetState(20169) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2817, p.GetParserRuleContext()) == 1 { + { + p.SetState(20156) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20159) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20157) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20158) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + p.SetState(20166) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserCOMMA { + { + p.SetState(20161) + p.Match(PlSqlParserCOMMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20164) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20162) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20163) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + + } + { + p.SetState(20168) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + } else if p.HasError() { // JIM + goto errorExit + } + p.SetState(20186) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2821, p.GetParserRuleContext()) == 1 { + { + p.SetState(20171) + p.Match(PlSqlParserTO) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20184) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserDAY: + { + p.SetState(20172) + p.Match(PlSqlParserDAY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserHOUR: + { + p.SetState(20173) + p.Match(PlSqlParserHOUR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINUTE: + { + p.SetState(20174) + p.Match(PlSqlParserMINUTE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSECOND: + { + p.SetState(20175) + p.Match(PlSqlParserSECOND) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20182) + p.GetErrorHandler().Sync(p) + + if p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2819, p.GetParserRuleContext()) == 1 { + { + p.SetState(20176) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + p.SetState(20179) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserUNSIGNED_INTEGER: + { + p.SetState(20177) + p.Match(PlSqlParserUNSIGNED_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserBINDVAR, PlSqlParserCOLON: + { + p.SetState(20178) + p.Bind_variable() + } + + default: + p.SetError(antlr.NewNoViableAltException(p, nil, nil, nil, nil, nil)) + goto errorExit + } + { + p.SetState(20181) + p.Match(PlSqlParserRIGHT_PAREN) + 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 + } + + } else if p.HasError() { // JIM + goto errorExit + } + + case PlSqlParserUNSIGNED_INTEGER, PlSqlParserAPPROXIMATE_NUM_LIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20188) + p.Numeric() + } + + case PlSqlParserDATE: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20189) + p.Match(PlSqlParserDATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20190) + p.Quoted_string() + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT, PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20191) + p.Char_str() + } + + case PlSqlParserNULL_: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20192) + p.Match(PlSqlParserNULL_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserTRUE: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20193) + p.Match(PlSqlParserTRUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserFALSE: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20194) + p.Match(PlSqlParserFALSE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDBTIMEZONE: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20195) + p.Match(PlSqlParserDBTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserSESSIONTIMEZONE: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20196) + p.Match(PlSqlParserSESSIONTIMEZONE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMINVALUE: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20197) + p.Match(PlSqlParserMINVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserMAXVALUE: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20198) + p.Match(PlSqlParserMAXVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserDEFAULT: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20199) + p.Match(PlSqlParserDEFAULT) + 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 +} + +// INumericContext is an interface to support dynamic dispatch. +type INumericContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + UNSIGNED_INTEGER() antlr.TerminalNode + APPROXIMATE_NUM_LIT() antlr.TerminalNode + + // IsNumericContext differentiates from other interfaces. + IsNumericContext() +} + +type NumericContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumericContext() *NumericContext { + var p = new(NumericContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric + return p +} + +func InitEmptyNumericContext(p *NumericContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric +} + +func (*NumericContext) IsNumericContext() {} + +func NewNumericContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *NumericContext { + var p = new(NumericContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric + + return p +} + +func (s *NumericContext) GetParser() antlr.Parser { return s.parser } + +func (s *NumericContext) UNSIGNED_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED_INTEGER, 0) +} + +func (s *NumericContext) APPROXIMATE_NUM_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPROXIMATE_NUM_LIT, 0) +} + +func (s *NumericContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *NumericContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *NumericContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric(s) + } +} + +func (s *NumericContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric(s) + } +} + +func (s *NumericContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNumeric(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Numeric() (localctx INumericContext) { + localctx = NewNumericContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2368, PlSqlParserRULE_numeric) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20202) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserUNSIGNED_INTEGER || _la == PlSqlParserAPPROXIMATE_NUM_LIT) { + 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 +} + +// INumeric_negativeContext is an interface to support dynamic dispatch. +type INumeric_negativeContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + MINUS_SIGN() antlr.TerminalNode + Numeric() INumericContext + + // IsNumeric_negativeContext differentiates from other interfaces. + IsNumeric_negativeContext() +} + +type Numeric_negativeContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_negativeContext() *Numeric_negativeContext { + var p = new(Numeric_negativeContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_negative + return p +} + +func InitEmptyNumeric_negativeContext(p *Numeric_negativeContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_negative +} + +func (*Numeric_negativeContext) IsNumeric_negativeContext() {} + +func NewNumeric_negativeContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_negativeContext { + var p = new(Numeric_negativeContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_negative + + return p +} + +func (s *Numeric_negativeContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_negativeContext) MINUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_SIGN, 0) +} + +func (s *Numeric_negativeContext) Numeric() INumericContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INumericContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INumericContext) +} + +func (s *Numeric_negativeContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_negativeContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_negativeContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_negative(s) + } +} + +func (s *Numeric_negativeContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_negative(s) + } +} + +func (s *Numeric_negativeContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNumeric_negative(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Numeric_negative() (localctx INumeric_negativeContext) { + localctx = NewNumeric_negativeContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2370, PlSqlParserRULE_numeric_negative) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20204) + p.Match(PlSqlParserMINUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20205) + p.Numeric() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IQuoted_stringContext is an interface to support dynamic dispatch. +type IQuoted_stringContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Variable_name() IVariable_nameContext + CHAR_STRING() antlr.TerminalNode + NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode + + // IsQuoted_stringContext differentiates from other interfaces. + IsQuoted_stringContext() +} + +type Quoted_stringContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyQuoted_stringContext() *Quoted_stringContext { + var p = new(Quoted_stringContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quoted_string + return p +} + +func InitEmptyQuoted_stringContext(p *Quoted_stringContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_quoted_string +} + +func (*Quoted_stringContext) IsQuoted_stringContext() {} + +func NewQuoted_stringContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Quoted_stringContext { + var p = new(Quoted_stringContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_quoted_string + + return p +} + +func (s *Quoted_stringContext) GetParser() antlr.Parser { return s.parser } + +func (s *Quoted_stringContext) Variable_name() IVariable_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IVariable_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IVariable_nameContext) +} + +func (s *Quoted_stringContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Quoted_stringContext) NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL_CHAR_STRING_LIT, 0) +} + +func (s *Quoted_stringContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Quoted_stringContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Quoted_stringContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterQuoted_string(s) + } +} + +func (s *Quoted_stringContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitQuoted_string(s) + } +} + +func (s *Quoted_stringContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitQuoted_string(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Quoted_string() (localctx IQuoted_stringContext) { + localctx = NewQuoted_stringContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2372, PlSqlParserRULE_quoted_string) + p.SetState(20210) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserDELIMITED_ID, PlSqlParserBINDVAR, PlSqlParserCOLON, PlSqlParserINTRODUCER, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20207) + p.Variable_name() + } + + case PlSqlParserCHAR_STRING: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20208) + p.Match(PlSqlParserCHAR_STRING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case PlSqlParserNATIONAL_CHAR_STRING_LIT: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20209) + p.Match(PlSqlParserNATIONAL_CHAR_STRING_LIT) + 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 +} + +// IChar_strContext is an interface to support dynamic dispatch. +type IChar_strContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHAR_STRING() antlr.TerminalNode + NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode + + // IsChar_strContext differentiates from other interfaces. + IsChar_strContext() +} + +type Char_strContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyChar_strContext() *Char_strContext { + var p = new(Char_strContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_str + return p +} + +func InitEmptyChar_strContext(p *Char_strContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_char_str +} + +func (*Char_strContext) IsChar_strContext() {} + +func NewChar_strContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Char_strContext { + var p = new(Char_strContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_char_str + + return p +} + +func (s *Char_strContext) GetParser() antlr.Parser { return s.parser } + +func (s *Char_strContext) CHAR_STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_STRING, 0) +} + +func (s *Char_strContext) NATIONAL_CHAR_STRING_LIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL_CHAR_STRING_LIT, 0) +} + +func (s *Char_strContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Char_strContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Char_strContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterChar_str(s) + } +} + +func (s *Char_strContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitChar_str(s) + } +} + +func (s *Char_strContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitChar_str(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Char_str() (localctx IChar_strContext) { + localctx = NewChar_strContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2374, PlSqlParserRULE_char_str) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20212) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserNATIONAL_CHAR_STRING_LIT || _la == PlSqlParserCHAR_STRING) { + 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 +} + +// IIdentifierContext is an interface to support dynamic dispatch. +type IIdentifierContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Id_expression() IId_expressionContext + INTRODUCER() antlr.TerminalNode + Char_set_name() IChar_set_nameContext + + // IsIdentifierContext differentiates from other interfaces. + IsIdentifierContext() +} + +type IdentifierContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyIdentifierContext() *IdentifierContext { + var p = new(IdentifierContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identifier + return p +} + +func InitEmptyIdentifierContext(p *IdentifierContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_identifier +} + +func (*IdentifierContext) IsIdentifierContext() {} + +func NewIdentifierContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *IdentifierContext { + var p = new(IdentifierContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_identifier + + return p +} + +func (s *IdentifierContext) GetParser() antlr.Parser { return s.parser } + +func (s *IdentifierContext) Id_expression() IId_expressionContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IId_expressionContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IId_expressionContext) +} + +func (s *IdentifierContext) INTRODUCER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTRODUCER, 0) +} + +func (s *IdentifierContext) Char_set_name() IChar_set_nameContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IChar_set_nameContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IChar_set_nameContext) +} + +func (s *IdentifierContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *IdentifierContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *IdentifierContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterIdentifier(s) + } +} + +func (s *IdentifierContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitIdentifier(s) + } +} + +func (s *IdentifierContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitIdentifier(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Identifier() (localctx IIdentifierContext) { + localctx = NewIdentifierContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2376, PlSqlParserRULE_identifier) + var _la int + + p.EnterOuterAlt(localctx, 1) + p.SetState(20216) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + _la = p.GetTokenStream().LA(1) + + if _la == PlSqlParserINTRODUCER { + { + p.SetState(20214) + p.Match(PlSqlParserINTRODUCER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20215) + p.Char_set_name() + } + + } + { + p.SetState(20218) + p.Id_expression() + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IId_expressionContext is an interface to support dynamic dispatch. +type IId_expressionContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Regular_id() IRegular_idContext + DELIMITED_ID() antlr.TerminalNode + + // IsId_expressionContext differentiates from other interfaces. + IsId_expressionContext() +} + +type Id_expressionContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyId_expressionContext() *Id_expressionContext { + var p = new(Id_expressionContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_id_expression + return p +} + +func InitEmptyId_expressionContext(p *Id_expressionContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_id_expression +} + +func (*Id_expressionContext) IsId_expressionContext() {} + +func NewId_expressionContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Id_expressionContext { + var p = new(Id_expressionContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_id_expression + + return p +} + +func (s *Id_expressionContext) GetParser() antlr.Parser { return s.parser } + +func (s *Id_expressionContext) Regular_id() IRegular_idContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(IRegular_idContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(IRegular_idContext) +} + +func (s *Id_expressionContext) DELIMITED_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED_ID, 0) +} + +func (s *Id_expressionContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Id_expressionContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Id_expressionContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterId_expression(s) + } +} + +func (s *Id_expressionContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitId_expression(s) + } +} + +func (s *Id_expressionContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitId_expression(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Id_expression() (localctx IId_expressionContext) { + localctx = NewId_expressionContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2378, PlSqlParserRULE_id_expression) + p.SetState(20222) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetTokenStream().LA(1) { + case PlSqlParserABORT, PlSqlParserABS, PlSqlParserABSENT, PlSqlParserACCESS, PlSqlParserACCESSED, PlSqlParserACCOUNT, PlSqlParserACL, PlSqlParserACOS, PlSqlParserACROSS, PlSqlParserACTION, PlSqlParserACTIONS, PlSqlParserACTIVATE, PlSqlParserACTIVE, PlSqlParserACTIVE_COMPONENT, PlSqlParserACTIVE_DATA, PlSqlParserACTIVE_FUNCTION, PlSqlParserACTIVE_TAG, PlSqlParserACTIVITY, PlSqlParserADAPTIVE_PLAN, PlSqlParserADD, PlSqlParserADD_COLUMN, PlSqlParserADD_GROUP, PlSqlParserADD_MONTHS, PlSqlParserADJ_DATE, PlSqlParserADMIN, PlSqlParserADMINISTER, PlSqlParserADMINISTRATOR, PlSqlParserADVANCED, PlSqlParserADVISE, PlSqlParserADVISOR, PlSqlParserAFD_DISKSTRING, PlSqlParserAFTER, PlSqlParserAGENT, PlSqlParserAGGREGATE, PlSqlParserA_LETTER, PlSqlParserALIAS, PlSqlParserALLOCATE, PlSqlParserALLOW, PlSqlParserALL_ROWS, PlSqlParserALTERNATE, PlSqlParserALWAYS, PlSqlParserANALYTIC, PlSqlParserANALYZE, PlSqlParserANCESTOR, PlSqlParserANCILLARY, PlSqlParserAND_EQUAL, PlSqlParserANOMALY, PlSqlParserANSI_REARCH, PlSqlParserANTIJOIN, PlSqlParserANYSCHEMA, PlSqlParserAPPEND, PlSqlParserAPPENDCHILDXML, PlSqlParserAPPEND_VALUES, PlSqlParserAPPLICATION, PlSqlParserAPPLY, PlSqlParserAPPROX_COUNT_DISTINCT, PlSqlParserARCHIVAL, PlSqlParserARCHIVE, PlSqlParserARCHIVED, PlSqlParserARCHIVELOG, PlSqlParserARRAY, PlSqlParserASCII, PlSqlParserASCIISTR, PlSqlParserASIN, PlSqlParserASIS, PlSqlParserASSEMBLY, PlSqlParserASSIGN, PlSqlParserASSOCIATE, PlSqlParserASYNC, PlSqlParserASYNCHRONOUS, PlSqlParserATAN2, PlSqlParserATAN, PlSqlParserAT, PlSqlParserATTRIBUTE, PlSqlParserATTRIBUTES, PlSqlParserAUTHENTICATED, PlSqlParserAUTHENTICATION, PlSqlParserAUTHID, PlSqlParserAUTHORIZATION, PlSqlParserAUTOALLOCATE, PlSqlParserAUTO, PlSqlParserAUTOEXTEND, PlSqlParserAUTO_LOGIN, PlSqlParserAUTOMATIC, PlSqlParserAUTONOMOUS_TRANSACTION, PlSqlParserAUTO_REOPTIMIZE, PlSqlParserAVAILABILITY, PlSqlParserAVRO, PlSqlParserBACKGROUND, PlSqlParserBACKINGFILE, PlSqlParserBACKUP, PlSqlParserBACKUPS, PlSqlParserBASIC, PlSqlParserBASICFILE, PlSqlParserBATCH, PlSqlParserBATCHSIZE, PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserBECOME, PlSqlParserBEFORE, PlSqlParserBEGIN, PlSqlParserBEGINNING, PlSqlParserBEGIN_OUTLINE_DATA, PlSqlParserBEHALF, PlSqlParserBEQUEATH, PlSqlParserBFILE, PlSqlParserBFILENAME, PlSqlParserBIGFILE, PlSqlParserBINARY, PlSqlParserBINARY_DOUBLE, PlSqlParserBINARY_DOUBLE_INFINITY, PlSqlParserBINARY_DOUBLE_NAN, PlSqlParserBINARY_FLOAT, PlSqlParserBINARY_FLOAT_INFINITY, PlSqlParserBINARY_FLOAT_NAN, PlSqlParserBINARY_INTEGER, PlSqlParserBIND_AWARE, PlSqlParserBINDING, PlSqlParserBIN_TO_NUM, PlSqlParserBITAND, PlSqlParserBITMAP_AND, PlSqlParserBITMAP, PlSqlParserBITMAPS, PlSqlParserBITMAP_TREE, PlSqlParserBITS, PlSqlParserBLOB, PlSqlParserBLOCK, PlSqlParserBLOCK_RANGE, PlSqlParserBLOCKS, PlSqlParserBLOCKSIZE, PlSqlParserBODY, PlSqlParserBOOLEAN, PlSqlParserBOTH, PlSqlParserBOUND, PlSqlParserBRANCH, PlSqlParserBREADTH, PlSqlParserBROADCAST, PlSqlParserBSON, PlSqlParserBUFFER, PlSqlParserBUFFER_CACHE, PlSqlParserBUFFER_POOL, PlSqlParserBUILD, PlSqlParserBULK, PlSqlParserBYPASS_RECURSIVE_CHECK, PlSqlParserBYPASS_UJVC, PlSqlParserBYTE, PlSqlParserCACHE, PlSqlParserCACHE_CB, PlSqlParserCACHE_INSTANCES, PlSqlParserCACHE_TEMP_TABLE, PlSqlParserCACHING, PlSqlParserCALCULATED, PlSqlParserCALLBACK, PlSqlParserCALL, PlSqlParserCANCEL, PlSqlParserCAPACITY, PlSqlParserCAPTION, PlSqlParserCARDINALITY, PlSqlParserCASCADE, PlSqlParserCASE, PlSqlParserCAST, PlSqlParserCASESENSITIVE, PlSqlParserCATEGORY, PlSqlParserCDBDEFAULT, PlSqlParserCEIL, PlSqlParserCELL_FLASH_CACHE, PlSqlParserCERTIFICATE, PlSqlParserCFILE, PlSqlParserCHAINED, PlSqlParserCHANGE, PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, PlSqlParserCHARACTER, PlSqlParserCHAR, PlSqlParserCHAR_CS, PlSqlParserCHARTOROWID, PlSqlParserCHECK_ACL_REWRITE, PlSqlParserCHECKPOINT, PlSqlParserCHILD, PlSqlParserCHOOSE, PlSqlParserCHR, PlSqlParserCHUNK, PlSqlParserCLASS, PlSqlParserCLASSIFICATION, PlSqlParserCLASSIFIER, PlSqlParserCLAUSE, PlSqlParserCLEAN, PlSqlParserCLEANUP, PlSqlParserCLEAR, PlSqlParserC_LETTER, PlSqlParserCLIENT, PlSqlParserCLOB, PlSqlParserCLONE, PlSqlParserCLOSE_CACHED_OPEN_CURSORS, PlSqlParserCLOSE, PlSqlParserCLUSTER_BY_ROWID, PlSqlParserCLUSTER, PlSqlParserCLUSTER_DETAILS, PlSqlParserCLUSTER_DISTANCE, PlSqlParserCLUSTER_ID, PlSqlParserCLUSTERING, PlSqlParserCLUSTERING_FACTOR, PlSqlParserCLUSTER_PROBABILITY, PlSqlParserCLUSTER_SET, PlSqlParserCOALESCE, PlSqlParserCOALESCE_SQ, PlSqlParserCOARSE, PlSqlParserCO_AUTH_IND, PlSqlParserCOLD, PlSqlParserCOLLECT, PlSqlParserCOLUMNAR, PlSqlParserCOLUMN_AUTH_INDICATOR, PlSqlParserCOLUMN, PlSqlParserCOLUMNS, PlSqlParserCOLUMN_STATS, PlSqlParserCOLUMN_VALUE, PlSqlParserCOMMENT, PlSqlParserCOMMIT, PlSqlParserCOMMITTED, PlSqlParserCOMMON, PlSqlParserCOMMON_DATA, PlSqlParserCOMPACT, PlSqlParserCOMPATIBILITY, PlSqlParserCOMPILE, PlSqlParserCOMPLETE, PlSqlParserCOMPLIANCE, PlSqlParserCOMPONENT, PlSqlParserCOMPONENTS, PlSqlParserCOMPOSE, PlSqlParserCOMPOSITE, PlSqlParserCOMPOSITE_LIMIT, PlSqlParserCOMPOUND, PlSqlParserCOMPUTE, PlSqlParserCONCAT, PlSqlParserCON_DBID_TO_ID, PlSqlParserCONDITIONAL, PlSqlParserCONDITION, PlSqlParserCONFIRM, PlSqlParserCONFORMING, PlSqlParserCON_GUID_TO_ID, PlSqlParserCON_ID, PlSqlParserCON_NAME_TO_ID, PlSqlParserCONNECT_BY_CB_WHR_ONLY, PlSqlParserCONNECT_BY_COMBINE_SW, PlSqlParserCONNECT_BY_COST_BASED, PlSqlParserCONNECT_BY_ELIM_DUPS, PlSqlParserCONNECT_BY_FILTERING, PlSqlParserCONNECT_BY_ISCYCLE, PlSqlParserCONNECT_BY_ISLEAF, PlSqlParserCONNECT_BY_ROOT, PlSqlParserCONNECT_TIME, PlSqlParserCONSIDER, PlSqlParserCONSISTENT, PlSqlParserCONSTANT, PlSqlParserCONST, PlSqlParserCONSTRAINT, PlSqlParserCONSTRAINTS, PlSqlParserCONSTRUCTOR, PlSqlParserCONTAINER, PlSqlParserCONTAINERS, PlSqlParserCONTAINERS_DEFAULT, PlSqlParserCONTAINER_DATA, PlSqlParserCONTAINER_MAP, PlSqlParserCONTENT, PlSqlParserCONTENTS, PlSqlParserCONTEXT, PlSqlParserCONTINUE, PlSqlParserCONTROLFILE, PlSqlParserCON_UID_TO_ID, PlSqlParserCONVERT, PlSqlParserCONVERSION, PlSqlParserCOOKIE, PlSqlParserCOPY, PlSqlParserCORR_K, PlSqlParserCORR_S, PlSqlParserCORRUPTION, PlSqlParserCORRUPT_XID_ALL, PlSqlParserCORRUPT_XID, PlSqlParserCOS, PlSqlParserCOSH, PlSqlParserCOST, PlSqlParserCOST_XML_QUERY_REWRITE, PlSqlParserCOUNT, PlSqlParserCOVAR_POP, PlSqlParserCOVAR_SAMP, PlSqlParserCPU_COSTING, PlSqlParserCPU_PER_CALL, PlSqlParserCPU_PER_SESSION, PlSqlParserCRASH, PlSqlParserCREATE_FILE_DEST, PlSqlParserCREATE_STORED_OUTLINES, PlSqlParserCREATION, PlSqlParserCREDENTIAL, PlSqlParserCRITICAL, PlSqlParserCROSS, PlSqlParserCROSSEDITION, PlSqlParserCSCONVERT, PlSqlParserCUBE_AJ, PlSqlParserCUBE, PlSqlParserCUBE_GB, PlSqlParserCUBE_SJ, PlSqlParserCUME_DISTM, PlSqlParserCURRENT, PlSqlParserCURRENT_DATE, PlSqlParserCURRENT_SCHEMA, PlSqlParserCURRENT_TIME, PlSqlParserCURRENT_TIMESTAMP, PlSqlParserCURRENT_USER, PlSqlParserCURRENTV, PlSqlParserCURSOR, PlSqlParserCURSOR_SHARING_EXACT, PlSqlParserCURSOR_SPECIFIC_SEGMENT, PlSqlParserCUSTOMDATUM, PlSqlParserCV, PlSqlParserCYCLE, PlSqlParserDANGLING, PlSqlParserDATABASE, PlSqlParserDATA, PlSqlParserDATAFILE, PlSqlParserDATAFILES, PlSqlParserDATAMOVEMENT, PlSqlParserDATAOBJNO, PlSqlParserDATAOBJ_TO_MAT_PARTITION, PlSqlParserDATAOBJ_TO_PARTITION, PlSqlParserDATAPUMP, PlSqlParserDATA_SECURITY_REWRITE_LIMIT, PlSqlParserDATE_MODE, PlSqlParserDAY, PlSqlParserDAYS, PlSqlParserDBA, PlSqlParserDBA_RECYCLEBIN, PlSqlParserDBMS_STATS, PlSqlParserDB_ROLE_CHANGE, PlSqlParserDBTIMEZONE, PlSqlParserDB_UNIQUE_NAME, PlSqlParserDB_VERSION, PlSqlParserDDL, PlSqlParserDEALLOCATE, PlSqlParserDEBUG, PlSqlParserDEBUGGER, PlSqlParserDEC, PlSqlParserDECIMAL, PlSqlParserDECOMPOSE, PlSqlParserDECORRELATE, PlSqlParserDECR, PlSqlParserDECREMENT, PlSqlParserDECRYPT, PlSqlParserDEDUPLICATE, PlSqlParserDEFAULTS, PlSqlParserDEFAULT_COLLATION, PlSqlParserDEFAULT_CREDENTIAL, PlSqlParserDEFERRABLE, PlSqlParserDEFERRED, PlSqlParserDEFINED, PlSqlParserDEFINE, PlSqlParserDEFINER, PlSqlParserDEGREE, PlSqlParserDELAY, PlSqlParserDELEGATE, PlSqlParserDELETE_ALL, PlSqlParserDELETE, PlSqlParserDELETEXML, PlSqlParserDEMAND, PlSqlParserDENSE_RANKM, PlSqlParserDEPENDENT, PlSqlParserDEPTH, PlSqlParserDEQUEUE, PlSqlParserDEREF, PlSqlParserDEREF_NO_REWRITE, PlSqlParserDESCRIPTION, PlSqlParserDESTROY, PlSqlParserDETACHED, PlSqlParserDETERMINES, PlSqlParserDETERMINISTIC, PlSqlParserDICTIONARY, PlSqlParserDIMENSION, PlSqlParserDIMENSIONS, PlSqlParserDIRECT_LOAD, PlSqlParserDIRECTORY, PlSqlParserDIRECT_PATH, PlSqlParserDISABLE_ALL, PlSqlParserDISABLE, PlSqlParserDISABLE_PARALLEL_DML, PlSqlParserDISABLE_PRESET, PlSqlParserDISABLE_RPKE, PlSqlParserDISALLOW, PlSqlParserDISASSOCIATE, PlSqlParserDISCARD, PlSqlParserDISCONNECT, PlSqlParserDISK, PlSqlParserDISKGROUP, PlSqlParserDISKS, PlSqlParserDISMOUNT, PlSqlParserDISTINGUISHED, PlSqlParserDISTRIBUTED, PlSqlParserDISTRIBUTE, PlSqlParserDML, PlSqlParserDML_UPDATE, PlSqlParserDOCFIDELITY, PlSqlParserDOCUMENT, PlSqlParserDOMAIN_INDEX_FILTER, PlSqlParserDOMAIN_INDEX_NO_SORT, PlSqlParserDOMAIN_INDEX_SORT, PlSqlParserDOUBLE, PlSqlParserDOWNGRADE, PlSqlParserDRIVING_SITE, PlSqlParserDROP_COLUMN, PlSqlParserDROP_GROUP, PlSqlParserDSINTERVAL_UNCONSTRAINED, PlSqlParserDST_UPGRADE_INSERT_CONV, PlSqlParserDUMP, PlSqlParserDUPLICATE, PlSqlParserDV, PlSqlParserDYNAMIC, PlSqlParserDYNAMIC_SAMPLING, PlSqlParserDYNAMIC_SAMPLING_EST_CDN, PlSqlParserE_LETTER, PlSqlParserEACH, PlSqlParserEDITIONABLE, PlSqlParserEDITION, PlSqlParserEDITIONING, PlSqlParserEDITIONS, PlSqlParserELEMENT, PlSqlParserELIM_GROUPBY, PlSqlParserELIMINATE_JOIN, PlSqlParserELIMINATE_OBY, PlSqlParserELIMINATE_OUTER_JOIN, PlSqlParserEM, PlSqlParserEMPTY_BLOB, PlSqlParserEMPTY_CLOB, PlSqlParserEMPTY, PlSqlParserENABLE_ALL, PlSqlParserENABLE, PlSqlParserENABLE_PARALLEL_DML, PlSqlParserENABLE_PRESET, PlSqlParserENCODING, PlSqlParserENCRYPT, PlSqlParserENCRYPTION, PlSqlParserEND_OUTLINE_DATA, PlSqlParserENFORCED, PlSqlParserENFORCE, PlSqlParserENQUEUE, PlSqlParserENTERPRISE, PlSqlParserENTITYESCAPING, PlSqlParserENTRY, PlSqlParserEQUIPART, PlSqlParserERR, PlSqlParserERROR_ARGUMENT, PlSqlParserERROR, PlSqlParserERROR_ON_OVERLAP_TIME, PlSqlParserERRORS, PlSqlParserESCAPE, PlSqlParserESTIMATE, PlSqlParserEVAL, PlSqlParserEVALNAME, PlSqlParserEVALUATE, PlSqlParserEVALUATION, PlSqlParserEVENTS, PlSqlParserEVERY, PlSqlParserEXCEPT, PlSqlParserEXCEPTION, PlSqlParserEXCEPTION_INIT, PlSqlParserEXCEPTIONS, PlSqlParserEXCHANGE, PlSqlParserEXCLUDE, PlSqlParserEXCLUDING, PlSqlParserEXECUTE, PlSqlParserEXEMPT, PlSqlParserEXISTING, PlSqlParserEXISTS, PlSqlParserEXISTSNODE, PlSqlParserEXIT, PlSqlParserEXPAND_GSET_TO_UNION, PlSqlParserEXPAND_TABLE, PlSqlParserEXP, PlSqlParserEXPIRE, PlSqlParserEXPLAIN, PlSqlParserEXPLOSION, PlSqlParserEXPORT, PlSqlParserEXPR_CORR_CHECK, PlSqlParserEXPRESS, PlSqlParserEXTENDS, PlSqlParserEXTENT, PlSqlParserEXTENTS, PlSqlParserEXTERNAL, PlSqlParserEXTERNALLY, PlSqlParserEXTRACTCLOBXML, PlSqlParserEXTRACT, PlSqlParserEXTRACTVALUE, PlSqlParserEXTRA, PlSqlParserFACILITY, PlSqlParserFACT, PlSqlParserFACTOR, PlSqlParserFACTORIZE_JOIN, PlSqlParserFAILED, PlSqlParserFAILED_LOGIN_ATTEMPTS, PlSqlParserFAILGROUP, PlSqlParserFAILOVER, PlSqlParserFAILURE, PlSqlParserFALSE, PlSqlParserFAMILY, PlSqlParserFAR, PlSqlParserFAST, PlSqlParserFASTSTART, PlSqlParserFBTSCAN, PlSqlParserFEATURE, PlSqlParserFEATURE_DETAILS, PlSqlParserFEATURE_ID, PlSqlParserFEATURE_SET, PlSqlParserFEATURE_VALUE, PlSqlParserFETCH, PlSqlParserFILE, PlSqlParserFILE_NAME_CONVERT, PlSqlParserFILEGROUP, PlSqlParserFILESTORE, PlSqlParserFILESYSTEM_LIKE_LOGGING, PlSqlParserFILTER, PlSqlParserFINAL, PlSqlParserFINE, PlSqlParserFINISH, PlSqlParserFIRST, PlSqlParserFIRSTM, PlSqlParserFIRST_ROWS, PlSqlParserFIRST_VALUE, PlSqlParserFIXED_VIEW_DATA, PlSqlParserFLAGGER, PlSqlParserFLASHBACK, PlSqlParserFLASH_CACHE, PlSqlParserFLOAT, PlSqlParserFLOB, PlSqlParserFLEX, PlSqlParserFLOOR, PlSqlParserFLUSH, PlSqlParserFOLDER, PlSqlParserFOLLOWING, PlSqlParserFOLLOWS, PlSqlParserFORALL, PlSqlParserFORCE, PlSqlParserFORCE_XML_QUERY_REWRITE, PlSqlParserFOREIGN, PlSqlParserFOREVER, PlSqlParserFORMAT, PlSqlParserFORWARD, PlSqlParserFRAGMENT_NUMBER, PlSqlParserFREELIST, PlSqlParserFREELISTS, PlSqlParserFREEPOOLS, PlSqlParserFRESH, PlSqlParserFROM_TZ, PlSqlParserFULL, PlSqlParserFULL_OUTER_JOIN_TO_OUTER, PlSqlParserFUNCTION, PlSqlParserFUNCTIONS, PlSqlParserFTP, PlSqlParserG_LETTER, PlSqlParserGATHER_OPTIMIZER_STATISTICS, PlSqlParserGATHER_PLAN_STATISTICS, PlSqlParserGBY_CONC_ROLLUP, PlSqlParserGBY_PUSHDOWN, PlSqlParserGENERATED, PlSqlParserGET, PlSqlParserGLOBAL, PlSqlParserGLOBALLY, PlSqlParserGLOBAL_NAME, PlSqlParserGLOBAL_TOPIC_ENABLED, PlSqlParserGROUP_BY, PlSqlParserGROUP_ID, PlSqlParserGROUPING, PlSqlParserGROUPING_ID, PlSqlParserGROUPS, PlSqlParserGUARANTEED, PlSqlParserGUARANTEE, PlSqlParserGUARD, PlSqlParserHALF_YEARS, PlSqlParserHASH_AJ, PlSqlParserHASH, PlSqlParserHASHKEYS, PlSqlParserHASH_SJ, PlSqlParserHEADER, PlSqlParserHEAP, PlSqlParserHELP, PlSqlParserHEXTORAW, PlSqlParserHEXTOREF, PlSqlParserHIDDEN_KEYWORD, PlSqlParserHIDE, PlSqlParserHIER_ORDER, PlSqlParserHIERARCHICAL, PlSqlParserHIERARCHY, PlSqlParserHIGH, PlSqlParserHINTSET_BEGIN, PlSqlParserHINTSET_END, PlSqlParserHOT, PlSqlParserHOUR, PlSqlParserHOURS, PlSqlParserHTTP, PlSqlParserHWM_BROKERED, PlSqlParserHYBRID, PlSqlParserH_LETTER, PlSqlParserIDENTIFIER, PlSqlParserIDENTITY, PlSqlParserIDGENERATORS, PlSqlParserID, PlSqlParserIDLE_TIME, PlSqlParserIF, PlSqlParserIGNORE, PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, PlSqlParserIGNORE_WHERE_CLAUSE, PlSqlParserILM, PlSqlParserIMMEDIATE, PlSqlParserIMPACT, PlSqlParserIMPORT, PlSqlParserINACTIVE, PlSqlParserINACTIVE_ACCOUNT_TIME, PlSqlParserINCLUDE, PlSqlParserINCLUDE_VERSION, PlSqlParserINCLUDING, PlSqlParserINCREMENTAL, PlSqlParserINCREMENT, PlSqlParserINCR, PlSqlParserINDENT, PlSqlParserINDEX_ASC, PlSqlParserINDEX_COMBINE, PlSqlParserINDEX_DESC, PlSqlParserINDEXED, PlSqlParserINDEXES, PlSqlParserINDEX_FFS, PlSqlParserINDEX_FILTER, PlSqlParserINDEXING, PlSqlParserINDEX_JOIN, PlSqlParserINDEX_ROWS, PlSqlParserINDEX_RRS, PlSqlParserINDEX_RS_ASC, PlSqlParserINDEX_RS_DESC, PlSqlParserINDEX_RS, PlSqlParserINDEX_SCAN, PlSqlParserINDEX_SKIP_SCAN, PlSqlParserINDEX_SS_ASC, PlSqlParserINDEX_SS_DESC, PlSqlParserINDEX_SS, PlSqlParserINDEX_STATS, PlSqlParserINDEXTYPE, PlSqlParserINDEXTYPES, PlSqlParserINDICATOR, PlSqlParserINDICES, PlSqlParserINFINITE, PlSqlParserINFORMATIONAL, PlSqlParserINHERIT, PlSqlParserINITCAP, PlSqlParserINITIAL, PlSqlParserINITIALIZED, PlSqlParserINITIALLY, PlSqlParserINITRANS, PlSqlParserINLINE, PlSqlParserINLINE_XMLTYPE_NT, PlSqlParserINMEMORY, PlSqlParserIN_MEMORY_METADATA, PlSqlParserINMEMORY_PRUNING, PlSqlParserINNER, PlSqlParserINOUT, PlSqlParserINPLACE, PlSqlParserINSERTCHILDXMLAFTER, PlSqlParserINSERTCHILDXMLBEFORE, PlSqlParserINSERTCHILDXML, PlSqlParserINSERTXMLAFTER, PlSqlParserINSERTXMLBEFORE, PlSqlParserINSTANCE, PlSqlParserINSTANCES, PlSqlParserINSTANTIABLE, PlSqlParserINSTANTLY, PlSqlParserINSTEAD, PlSqlParserINSTR2, PlSqlParserINSTR4, PlSqlParserINSTRB, PlSqlParserINSTRC, PlSqlParserINSTR, PlSqlParserINTEGER, PlSqlParserINTERLEAVED, PlSqlParserINTERMEDIATE, PlSqlParserINTERNAL_CONVERT, PlSqlParserINTERNAL_USE, PlSqlParserINTERPRETED, PlSqlParserINTERVAL, PlSqlParserINT, PlSqlParserINVALIDATE, PlSqlParserINVISIBLE, PlSqlParserIN_XQUERY, PlSqlParserIS_LEAF, PlSqlParserISOLATION, PlSqlParserISOLATION_LEVEL, PlSqlParserITERATE, PlSqlParserITERATION_NUMBER, PlSqlParserJAVA, PlSqlParserJOB, PlSqlParserJOIN, PlSqlParserJSON_ARRAYAGG, PlSqlParserJSON_ARRAY, PlSqlParserJSON_EQUAL, PlSqlParserJSON_EXISTS2, PlSqlParserJSON_EXISTS, PlSqlParserJSONGET, PlSqlParserJSON, PlSqlParserJSON_OBJECTAGG, PlSqlParserJSON_OBJECT, PlSqlParserJSONPARSE, PlSqlParserJSON_QUERY, PlSqlParserJSON_SERIALIZE, PlSqlParserJSON_TABLE, PlSqlParserJSON_TEXTCONTAINS2, PlSqlParserJSON_TEXTCONTAINS, PlSqlParserJSON_TRANSFORM, PlSqlParserJSON_VALUE, PlSqlParserK_LETTER, PlSqlParserKEEP_DUPLICATES, PlSqlParserKEEP, PlSqlParserKERBEROS, PlSqlParserKEY, PlSqlParserKEY_LENGTH, PlSqlParserKEYSIZE, PlSqlParserKEYS, PlSqlParserKEYSTORE, PlSqlParserKILL, PlSqlParserLABEL, PlSqlParserLANGUAGE, PlSqlParserLAST_DAY, PlSqlParserLAST, PlSqlParserLAST_VALUE, PlSqlParserLATERAL, PlSqlParserLAX, PlSqlParserLAYER, PlSqlParserLDAP_REGISTRATION_ENABLED, PlSqlParserLDAP_REGISTRATION, PlSqlParserLDAP_REG_SYNC_INTERVAL, PlSqlParserLEAF, PlSqlParserLEAD_CDB, PlSqlParserLEAD_CDB_URI, PlSqlParserLEADING, PlSqlParserLEFT, PlSqlParserLENGTH2, PlSqlParserLENGTH4, PlSqlParserLENGTHB, PlSqlParserLENGTHC, PlSqlParserLENGTH, PlSqlParserLESS, PlSqlParserLEVEL, PlSqlParserLEVEL_NAME, PlSqlParserLEVELS, PlSqlParserLIBRARY, PlSqlParserLIFECYCLE, PlSqlParserLIFE, PlSqlParserLIFETIME, PlSqlParserLIKE2, PlSqlParserLIKE4, PlSqlParserLIKEC, PlSqlParserLIKE_EXPAND, PlSqlParserLIMIT, PlSqlParserLINEAR, PlSqlParserLINK, PlSqlParserLIST, PlSqlParserLN, PlSqlParserLNNVL, PlSqlParserLOAD, PlSqlParserLOB, PlSqlParserLOBNVL, PlSqlParserLOBS, PlSqlParserLOCAL_INDEXES, PlSqlParserLOCAL, PlSqlParserLOCALTIME, PlSqlParserLOCALTIMESTAMP, PlSqlParserLOCATION, PlSqlParserLOCATOR, PlSqlParserLOCKDOWN, PlSqlParserLOCKED, PlSqlParserLOCKING, PlSqlParserLOGFILE, PlSqlParserLOGFILES, PlSqlParserLOGGING, PlSqlParserLOGICAL, PlSqlParserLOGICAL_READS_PER_CALL, PlSqlParserLOGICAL_READS_PER_SESSION, PlSqlParserLOG, PlSqlParserLOGMINING, PlSqlParserLOGOFF, PlSqlParserLOGON, PlSqlParserLOG_READ_ONLY_VIOLATIONS, PlSqlParserLONG, PlSqlParserLOOP, PlSqlParserLOST, PlSqlParserLOWER, PlSqlParserLOW, PlSqlParserLPAD, PlSqlParserLTRIM, PlSqlParserM_LETTER, PlSqlParserMAIN, PlSqlParserMAKE_REF, PlSqlParserMANAGED, PlSqlParserMANAGE, PlSqlParserMANAGEMENT, PlSqlParserMANAGER, PlSqlParserMANDATORY, PlSqlParserMANUAL, PlSqlParserMAP, PlSqlParserMAPPING, PlSqlParserMASTER, PlSqlParserMATCHED, PlSqlParserMATCHES, PlSqlParserMATCH, PlSqlParserMATCH_NUMBER, PlSqlParserMATCH_RECOGNIZE, PlSqlParserMATERIALIZED, PlSqlParserMATERIALIZE, PlSqlParserMAXARCHLOGS, PlSqlParserMAXDATAFILES, PlSqlParserMAXEXTENTS, PlSqlParserMAXIMIZE, PlSqlParserMAXINSTANCES, PlSqlParserMAXLOGFILES, PlSqlParserMAXLOGHISTORY, PlSqlParserMAXLOGMEMBERS, PlSqlParserMAX_SHARED_TEMP_SIZE, PlSqlParserMAXSIZE, PlSqlParserMAXTRANS, PlSqlParserMAXVALUE, PlSqlParserMEASURE, PlSqlParserMEASURES, PlSqlParserMEDIUM, PlSqlParserMEMBER, PlSqlParserMEMBER_CAPTION, PlSqlParserMEMBER_DESCRIPTION, PlSqlParserMEMBER_NAME, PlSqlParserMEMBER_UNIQUE_NAME, PlSqlParserMEMCOMPRESS, PlSqlParserMEMORY, PlSqlParserMERGEACTIONS, PlSqlParserMERGE_AJ, PlSqlParserMERGE_CONST_ON, PlSqlParserMERGE, PlSqlParserMERGE_SJ, PlSqlParserMETADATA, PlSqlParserMETHOD, PlSqlParserMIGRATE, PlSqlParserMIGRATION, PlSqlParserMINEXTENTS, PlSqlParserMINIMIZE, PlSqlParserMINIMUM, PlSqlParserMINING, PlSqlParserMINUS_NULL, PlSqlParserMINUTE, PlSqlParserMINUTES, PlSqlParserMINVALUE, PlSqlParserMIRRORCOLD, PlSqlParserMIRRORHOT, PlSqlParserMIRROR, PlSqlParserMISSING, PlSqlParserMISMATCH, PlSqlParserMLSLABEL, PlSqlParserMODEL_COMPILE_SUBQUERY, PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, PlSqlParserMODEL_DYNAMIC_SUBQUERY, PlSqlParserMODEL_MIN_ANALYSIS, PlSqlParserMODEL, PlSqlParserMODEL_NB, PlSqlParserMODEL_NO_ANALYSIS, PlSqlParserMODEL_PBY, PlSqlParserMODEL_PUSH_REF, PlSqlParserMODEL_SV, PlSqlParserMODIFICATION, PlSqlParserMODIFY_COLUMN_TYPE, PlSqlParserMODIFY, PlSqlParserMOD, PlSqlParserMODULE, PlSqlParserMONITORING, PlSqlParserMONITOR, PlSqlParserMONTH, PlSqlParserMONTHS_BETWEEN, PlSqlParserMONTHS, PlSqlParserMOUNT, PlSqlParserMOUNTPATH, PlSqlParserMOUNTPOINT, PlSqlParserMOVEMENT, PlSqlParserMOVE, PlSqlParserMULTIDIMENSIONAL, PlSqlParserMULTISET, PlSqlParserMV_MERGE, PlSqlParserNAMED, PlSqlParserNAME, PlSqlParserNAMESPACE, PlSqlParserNAN, PlSqlParserNANVL, PlSqlParserNATIONAL, PlSqlParserNATIVE_FULL_OUTER_JOIN, PlSqlParserNATIVE, PlSqlParserNATURAL, PlSqlParserNAV, PlSqlParserNCHAR_CS, PlSqlParserNCHAR, PlSqlParserNCHR, PlSqlParserNCLOB, PlSqlParserNEEDED, PlSqlParserNEG, PlSqlParserNESTED, PlSqlParserNESTED_TABLE_FAST_INSERT, PlSqlParserNESTED_TABLE_GET_REFS, PlSqlParserNESTED_TABLE_ID, PlSqlParserNESTED_TABLE_SET_REFS, PlSqlParserNESTED_TABLE_SET_SETID, PlSqlParserNETWORK, PlSqlParserNEVER, PlSqlParserNEW, PlSqlParserNEW_TIME, PlSqlParserNEXT_DAY, PlSqlParserNEXT, PlSqlParserNL_AJ, PlSqlParserNLJ_BATCHING, PlSqlParserNLJ_INDEX_FILTER, PlSqlParserNLJ_INDEX_SCAN, PlSqlParserNLJ_PREFETCH, PlSqlParserNLS_CALENDAR, PlSqlParserNLS_CHARACTERSET, PlSqlParserNLS_CHARSET_DECL_LEN, PlSqlParserNLS_CHARSET_ID, PlSqlParserNLS_CHARSET_NAME, PlSqlParserNLS_COMP, PlSqlParserNLS_CURRENCY, PlSqlParserNLS_DATE_FORMAT, PlSqlParserNLS_DATE_LANGUAGE, PlSqlParserNLS_INITCAP, PlSqlParserNLS_ISO_CURRENCY, PlSqlParserNL_SJ, PlSqlParserNLS_LANG, PlSqlParserNLS_LANGUAGE, PlSqlParserNLS_LENGTH_SEMANTICS, PlSqlParserNLS_LOWER, PlSqlParserNLS_NCHAR_CONV_EXCP, PlSqlParserNLS_NUMERIC_CHARACTERS, PlSqlParserNLS_SORT, PlSqlParserNLSSORT, PlSqlParserNLS_SPECIAL_CHARS, PlSqlParserNLS_TERRITORY, PlSqlParserNLS_UPPER, PlSqlParserNO_ACCESS, PlSqlParserNO_ADAPTIVE_PLAN, PlSqlParserNO_ANSI_REARCH, PlSqlParserNOAPPEND, PlSqlParserNOARCHIVELOG, PlSqlParserNOAUDIT, PlSqlParserNO_AUTO_REOPTIMIZE, PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, PlSqlParserNO_BIND_AWARE, PlSqlParserNO_BUFFER, PlSqlParserNOCACHE, PlSqlParserNO_CARTESIAN, PlSqlParserNO_CHECK_ACL_REWRITE, PlSqlParserNO_CLUSTER_BY_ROWID, PlSqlParserNO_CLUSTERING, PlSqlParserNO_COALESCE_SQ, PlSqlParserNO_COMMON_DATA, PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, PlSqlParserNO_CONNECT_BY_COMBINE_SW, PlSqlParserNO_CONNECT_BY_COST_BASED, PlSqlParserNO_CONNECT_BY_ELIM_DUPS, PlSqlParserNO_CONNECT_BY_FILTERING, PlSqlParserNOCOPY, PlSqlParserNO_COST_XML_QUERY_REWRITE, PlSqlParserNO_CPU_COSTING, PlSqlParserNOCPU_COSTING, PlSqlParserNOCYCLE, PlSqlParserNO_DATA_SECURITY_REWRITE, PlSqlParserNO_DECORRELATE, PlSqlParserNODELAY, PlSqlParserNO_DOMAIN_INDEX_FILTER, PlSqlParserNO_DST_UPGRADE_INSERT_CONV, PlSqlParserNO_ELIM_GROUPBY, PlSqlParserNO_ELIMINATE_JOIN, PlSqlParserNO_ELIMINATE_OBY, PlSqlParserNO_ELIMINATE_OUTER_JOIN, PlSqlParserNOENTITYESCAPING, PlSqlParserNO_EXPAND_GSET_TO_UNION, PlSqlParserNO_EXPAND, PlSqlParserNO_EXPAND_TABLE, PlSqlParserNO_FACT, PlSqlParserNO_FACTORIZE_JOIN, PlSqlParserNO_FILTERING, PlSqlParserNOFORCE, PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, PlSqlParserNO_GBY_PUSHDOWN, PlSqlParserNOGUARANTEE, PlSqlParserNO_INDEX_FFS, PlSqlParserNO_INDEX, PlSqlParserNO_INDEX_SS, PlSqlParserNO_INMEMORY, PlSqlParserNO_INMEMORY_PRUNING, PlSqlParserNOKEEP, PlSqlParserNO_LOAD, PlSqlParserNOLOCAL, PlSqlParserNOLOGGING, PlSqlParserNOMAPPING, PlSqlParserNOMAXVALUE, PlSqlParserNO_MERGE, PlSqlParserNOMINIMIZE, PlSqlParserNOMINVALUE, PlSqlParserNO_MODEL_PUSH_REF, PlSqlParserNO_MONITORING, PlSqlParserNOMONITORING, PlSqlParserNO_MONITOR, PlSqlParserNO_MULTIMV_REWRITE, PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, PlSqlParserNONBLOCKING, PlSqlParserNONEDITIONABLE, PlSqlParserNONE, PlSqlParserNO_NLJ_BATCHING, PlSqlParserNO_NLJ_PREFETCH, PlSqlParserNO, PlSqlParserNONSCHEMA, PlSqlParserNO_OBJECT_LINK, PlSqlParserNOORDER, PlSqlParserNO_ORDER_ROLLUPS, PlSqlParserNO_OUTER_JOIN_TO_ANTI, PlSqlParserNO_OUTER_JOIN_TO_INNER, PlSqlParserNOOVERRIDE, PlSqlParserNO_PARALLEL_INDEX, PlSqlParserNOPARALLEL_INDEX, PlSqlParserNO_PARALLEL, PlSqlParserNOPARALLEL, PlSqlParserNO_PARTIAL_COMMIT, PlSqlParserNO_PARTIAL_JOIN, PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, PlSqlParserNOPARTITION, PlSqlParserNO_PLACE_DISTINCT, PlSqlParserNO_PLACE_GROUP_BY, PlSqlParserNO_PQ_CONCURRENT_UNION, PlSqlParserNO_PQ_MAP, PlSqlParserNOPROMPT, PlSqlParserNO_PQ_REPLICATE, PlSqlParserNO_PQ_SKEW, PlSqlParserNO_PRUNE_GSETS, PlSqlParserNO_PULL_PRED, PlSqlParserNO_PUSH_PRED, PlSqlParserNO_PUSH_SUBQ, PlSqlParserNO_PX_FAULT_TOLERANCE, PlSqlParserNO_PX_JOIN_FILTER, PlSqlParserNO_QKN_BUFF, PlSqlParserNO_QUERY_TRANSFORMATION, PlSqlParserNO_REF_CASCADE, PlSqlParserNORELOCATE, PlSqlParserNORELY, PlSqlParserNOREPAIR, PlSqlParserNOREPLAY, PlSqlParserNORESETLOGS, PlSqlParserNO_RESULT_CACHE, PlSqlParserNOREVERSE, PlSqlParserNO_REWRITE, PlSqlParserNOREWRITE, PlSqlParserNORMAL, PlSqlParserNO_ROOT_SW_FOR_LOCAL, PlSqlParserNOROWDEPENDENCIES, PlSqlParserNOSCHEMACHECK, PlSqlParserNOSEGMENT, PlSqlParserNO_SEMIJOIN, PlSqlParserNO_SEMI_TO_INNER, PlSqlParserNO_SET_TO_JOIN, PlSqlParserNOSORT, PlSqlParserNO_SQL_TRANSLATION, PlSqlParserNO_SQL_TUNE, PlSqlParserNO_STAR_TRANSFORMATION, PlSqlParserNO_STATEMENT_QUEUING, PlSqlParserNO_STATS_GSETS, PlSqlParserNOSTRICT, PlSqlParserNO_SUBQUERY_PRUNING, PlSqlParserNO_SUBSTRB_PAD, PlSqlParserNO_SWAP_JOIN_INPUTS, PlSqlParserNOSWITCH, PlSqlParserNO_TABLE_LOOKUP_BY_NL, PlSqlParserNO_TEMP_TABLE, PlSqlParserNOTHING, PlSqlParserNOTIFICATION, PlSqlParserNO_TRANSFORM_DISTINCT_AGG, PlSqlParserNO_UNNEST, PlSqlParserNO_USE_CUBE, PlSqlParserNO_USE_HASH_AGGREGATION, PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserNO_USE_HASH, PlSqlParserNO_USE_INVISIBLE_INDEXES, PlSqlParserNO_USE_MERGE, PlSqlParserNO_USE_NL, PlSqlParserNO_USE_VECTOR_AGGREGATION, PlSqlParserNOVALIDATE, PlSqlParserNO_VECTOR_TRANSFORM_DIMS, PlSqlParserNO_VECTOR_TRANSFORM_FACT, PlSqlParserNO_VECTOR_TRANSFORM, PlSqlParserNO_XDB_FASTPATH_INSERT, PlSqlParserNO_XML_DML_REWRITE, PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, PlSqlParserNO_XMLINDEX_REWRITE, PlSqlParserNO_XML_QUERY_REWRITE, PlSqlParserNO_ZONEMAP, PlSqlParserNTH_VALUE, PlSqlParserNULLIF, PlSqlParserNULLS, PlSqlParserNUMBER, PlSqlParserNUMERIC, PlSqlParserNUM_INDEX_KEYS, PlSqlParserNUMTODSINTERVAL, PlSqlParserNUMTOYMINTERVAL, PlSqlParserNVARCHAR2, PlSqlParserNVL2, PlSqlParserOBJECT2XML, PlSqlParserOBJECT, PlSqlParserOBJ_ID, PlSqlParserOBJNO, PlSqlParserOBJNO_REUSE, PlSqlParserOCCURENCES, PlSqlParserOFFLINE, PlSqlParserOFF, PlSqlParserOFFSET, PlSqlParserOIDINDEX, PlSqlParserOID, PlSqlParserOLAP, PlSqlParserOLD, PlSqlParserOLD_PUSH_PRED, PlSqlParserOLS, PlSqlParserOLTP, PlSqlParserOMIT, PlSqlParserONE, PlSqlParserONLINE, PlSqlParserONLY, PlSqlParserOPAQUE, PlSqlParserOPAQUE_TRANSFORM, PlSqlParserOPAQUE_XCANONICAL, PlSqlParserOPCODE, PlSqlParserOPEN, PlSqlParserOPERATIONS, PlSqlParserOPERATOR, PlSqlParserOPT_ESTIMATE, PlSqlParserOPTIMAL, PlSqlParserOPTIMIZE, PlSqlParserOPTIMIZER_FEATURES_ENABLE, PlSqlParserOPTIMIZER_GOAL, PlSqlParserOPT_PARAM, PlSqlParserORA_BRANCH, PlSqlParserORA_CHECK_ACL, PlSqlParserORA_CHECK_PRIVILEGE, PlSqlParserORA_CLUSTERING, PlSqlParserORADATA, PlSqlParserORADEBUG, PlSqlParserORA_DST_AFFECTED, PlSqlParserORA_DST_CONVERT, PlSqlParserORA_DST_ERROR, PlSqlParserORA_GET_ACLIDS, PlSqlParserORA_GET_PRIVILEGES, PlSqlParserORA_HASH, PlSqlParserORA_INVOKING_USERID, PlSqlParserORA_INVOKING_USER, PlSqlParserORA_INVOKING_XS_USER_GUID, PlSqlParserORA_INVOKING_XS_USER, PlSqlParserORA_RAWCOMPARE, PlSqlParserORA_RAWCONCAT, PlSqlParserORA_ROWSCN, PlSqlParserORA_ROWSCN_RAW, PlSqlParserORA_ROWVERSION, PlSqlParserORA_TABVERSION, PlSqlParserORA_WRITE_TIME, PlSqlParserORDERED, PlSqlParserORDERED_PREDICATES, PlSqlParserORDINALITY, PlSqlParserOR_EXPAND, PlSqlParserORGANIZATION, PlSqlParserOR_PREDICATES, PlSqlParserOSERROR, PlSqlParserOTHER, PlSqlParserOUTER_JOIN_TO_ANTI, PlSqlParserOUTER_JOIN_TO_INNER, PlSqlParserOUTER, PlSqlParserOUTLINE_LEAF, PlSqlParserOUTLINE, PlSqlParserOUT_OF_LINE, PlSqlParserOUT, PlSqlParserOVERFLOW_NOMOVE, PlSqlParserOVERFLOW, PlSqlParserOVERLAPS, PlSqlParserOVER, PlSqlParserOVERRIDING, PlSqlParserOWNER, PlSqlParserOWNERSHIP, PlSqlParserOWN, PlSqlParserP_LETTER, PlSqlParserPACKAGE, PlSqlParserPACKAGES, PlSqlParserPARALLEL_ENABLE, PlSqlParserPARALLEL_INDEX, PlSqlParserPARALLEL, PlSqlParserPARAMETERS, PlSqlParserPARAM, PlSqlParserPARENT, PlSqlParserPARENT_LEVEL_NAME, PlSqlParserPARENT_UNIQUE_NAME, PlSqlParserPARITY, PlSqlParserPARTIAL_JOIN, PlSqlParserPARTIALLY, PlSqlParserPARTIAL, PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, PlSqlParserPARTITION_HASH, PlSqlParserPARTITION_LIST, PlSqlParserPARTITION, PlSqlParserPARTITION_RANGE, PlSqlParserPARTITIONS, PlSqlParserPARTNUMINST, PlSqlParserPASSING, PlSqlParserPASSWORD_GRACE_TIME, PlSqlParserPASSWORD_LIFE_TIME, PlSqlParserPASSWORD_LOCK_TIME, PlSqlParserPASSWORD, PlSqlParserPASSWORD_REUSE_MAX, PlSqlParserPASSWORD_REUSE_TIME, PlSqlParserPASSWORD_ROLLOVER_TIME, PlSqlParserPASSWORD_VERIFY_FUNCTION, PlSqlParserPAST, PlSqlParserPATCH, PlSqlParserPATH, PlSqlParserPATH_PREFIX, PlSqlParserPATHS, PlSqlParserPATTERN, PlSqlParserPBL_HS_BEGIN, PlSqlParserPBL_HS_END, PlSqlParserPCTINCREASE, PlSqlParserPCTTHRESHOLD, PlSqlParserPCTUSED, PlSqlParserPCTVERSION, PlSqlParserPENDING, PlSqlParserPERCENT_KEYWORD, PlSqlParserPERCENT_RANKM, PlSqlParserPERFORMANCE, PlSqlParserPERIOD_KEYWORD, PlSqlParserPERMANENT, PlSqlParserPERMISSION, PlSqlParserPERMUTE, PlSqlParserPER, PlSqlParserPFILE, PlSqlParserPHYSICAL, PlSqlParserPIKEY, PlSqlParserPIPELINED, PlSqlParserPIV_GB, PlSqlParserPIVOT, PlSqlParserPIV_SSF, PlSqlParserPLACE_DISTINCT, PlSqlParserPLACE_GROUP_BY, PlSqlParserPLAN, PlSqlParserPLSCOPE_SETTINGS, PlSqlParserPLS_INTEGER, PlSqlParserPLSQL_CCFLAGS, PlSqlParserPLSQL_CODE_TYPE, PlSqlParserPLSQL_DEBUG, PlSqlParserPLSQL_OPTIMIZE_LEVEL, PlSqlParserPLSQL_WARNINGS, PlSqlParserPLUGGABLE, PlSqlParserPMEM, PlSqlParserPOINT, PlSqlParserPOLICY, PlSqlParserPOOL_16K, PlSqlParserPOOL_2K, PlSqlParserPOOL_32K, PlSqlParserPOOL_4K, PlSqlParserPOOL_8K, PlSqlParserPOSITIVEN, PlSqlParserPOSITIVE, PlSqlParserPOST_TRANSACTION, PlSqlParserPOWERMULTISET_BY_CARDINALITY, PlSqlParserPOWERMULTISET, PlSqlParserPOWER, PlSqlParserPQ_CONCURRENT_UNION, PlSqlParserPQ_DISTRIBUTE, PlSqlParserPQ_DISTRIBUTE_WINDOW, PlSqlParserPQ_FILTER, PlSqlParserPQ_MAP, PlSqlParserPQ_NOMAP, PlSqlParserPQ_REPLICATE, PlSqlParserPQ_SKEW, PlSqlParserPRAGMA, PlSqlParserPREBUILT, PlSqlParserPRECEDES, PlSqlParserPRECEDING, PlSqlParserPRECISION, PlSqlParserPRECOMPUTE_SUBQUERY, PlSqlParserPREDICATE_REORDERS, PlSqlParserPRELOAD, PlSqlParserPREPARE, PlSqlParserPRESENTNNV, PlSqlParserPRESENT, PlSqlParserPRESENTV, PlSqlParserPRESERVE_OID, PlSqlParserPRESERVE, PlSqlParserPRETTY, PlSqlParserPREVIOUS, PlSqlParserPREV, PlSqlParserPRIMARY, PlSqlParserPRINTBLOBTOCLOB, PlSqlParserPRIORITY, PlSqlParserPRIVATE, PlSqlParserPRIVATE_SGA, PlSqlParserPRIVILEGED, PlSqlParserPRIVILEGE, PlSqlParserPRIVILEGES, PlSqlParserPROCEDURAL, PlSqlParserPROCEDURE, PlSqlParserPROCESS, PlSqlParserPROFILE, PlSqlParserPROGRAM, PlSqlParserPROJECT, PlSqlParserPROPAGATE, PlSqlParserPROPERTY, PlSqlParserPROTECTED, PlSqlParserPROTECTION, PlSqlParserPROTOCOL, PlSqlParserPROXY, PlSqlParserPRUNING, PlSqlParserPUBLIC, PlSqlParserPULL_PRED, PlSqlParserPURGE, PlSqlParserPUSH_PRED, PlSqlParserPUSH_SUBQ, PlSqlParserPX_FAULT_TOLERANCE, PlSqlParserPX_GRANULE, PlSqlParserPX_JOIN_FILTER, PlSqlParserQB_NAME, PlSqlParserQUARTERS, PlSqlParserQUERY_BLOCK, PlSqlParserQUERY, PlSqlParserQUEUE_CURR, PlSqlParserQUEUE, PlSqlParserQUEUE_ROWP, PlSqlParserQUIESCE, PlSqlParserQUORUM, PlSqlParserQUOTA, PlSqlParserQUOTAGROUP, PlSqlParserRAISE, PlSqlParserRANDOM_LOCAL, PlSqlParserRANDOM, PlSqlParserRANGE, PlSqlParserRANKM, PlSqlParserRAPIDLY, PlSqlParserRAW, PlSqlParserRAWTOHEX, PlSqlParserRAWTONHEX, PlSqlParserRBA, PlSqlParserRBO_OUTLINE, PlSqlParserRDBA, PlSqlParserREAD, PlSqlParserREADS, PlSqlParserREALM, PlSqlParserREAL, PlSqlParserREBALANCE, PlSqlParserREBUILD, PlSqlParserRECORD, PlSqlParserRECORDS_PER_BLOCK, PlSqlParserRECOVERABLE, PlSqlParserRECOVER, PlSqlParserRECOVERY, PlSqlParserRECYCLEBIN, PlSqlParserRECYCLE, PlSqlParserREDACTION, PlSqlParserREDEFINE, PlSqlParserREDO, PlSqlParserREDUCED, PlSqlParserREDUNDANCY, PlSqlParserREF_CASCADE_CURSOR, PlSqlParserREFERENCED, PlSqlParserREFERENCE, PlSqlParserREFERENCES, PlSqlParserREFERENCING, PlSqlParserREF, PlSqlParserREFRESH, PlSqlParserREFTOHEX, PlSqlParserREGEXP_COUNT, PlSqlParserREGEXP_INSTR, PlSqlParserREGEXP_LIKE, PlSqlParserREGEXP_REPLACE, PlSqlParserREGEXP_SUBSTR, PlSqlParserREGISTER, PlSqlParserREGR_AVGX, PlSqlParserREGR_AVGY, PlSqlParserREGR_COUNT, PlSqlParserREGR_INTERCEPT, PlSqlParserREGR_R2, PlSqlParserREGR_SLOPE, PlSqlParserREGR_SXX, PlSqlParserREGR_SXY, PlSqlParserREGR_SYY, PlSqlParserREGULAR, PlSqlParserREJECT, PlSqlParserREKEY, PlSqlParserRELATIONAL, PlSqlParserRELOCATE, PlSqlParserRELY, PlSqlParserREMAINDER, PlSqlParserREMOTE, PlSqlParserREMOTE_MAPPED, PlSqlParserREMOVE, PlSqlParserRENAME, PlSqlParserREPAIR, PlSqlParserREPEAT, PlSqlParserREPLACE, PlSqlParserREPLICATION, PlSqlParserREQUIRED, PlSqlParserRESETLOGS, PlSqlParserRESET, PlSqlParserRESIZE, PlSqlParserRESOLVE, PlSqlParserRESOLVER, PlSqlParserRESPECT, PlSqlParserRESTART, PlSqlParserRESTORE_AS_INTERVALS, PlSqlParserRESTORE, PlSqlParserRESTRICT_ALL_REF_CONS, PlSqlParserRESTRICTED, PlSqlParserRESTRICT_REFERENCES, PlSqlParserRESTRICT, PlSqlParserRESULT_CACHE, PlSqlParserRESULT, PlSqlParserRESUMABLE, PlSqlParserRESUME, PlSqlParserRETENTION, PlSqlParserRETRY_ON_ROW_CHANGE, PlSqlParserRETURNING, PlSqlParserRETURN, PlSqlParserREUSE, PlSqlParserREVERSE, PlSqlParserREWRITE_OR_ERROR, PlSqlParserREWRITE, PlSqlParserRIGHT, PlSqlParserROLE, PlSqlParserROLESET, PlSqlParserROLES, PlSqlParserROLLBACK, PlSqlParserROLLING, PlSqlParserROLLUP, PlSqlParserROWDEPENDENCIES, PlSqlParserROWID_MAPPING_TABLE, PlSqlParserROWID, PlSqlParserROWIDTOCHAR, PlSqlParserROWIDTONCHAR, PlSqlParserROW_LENGTH, PlSqlParserROWNUM, PlSqlParserROW, PlSqlParserROWS, PlSqlParserRPAD, PlSqlParserRTRIM, PlSqlParserRULE, PlSqlParserRULES, PlSqlParserRUNNING, PlSqlParserSALT, PlSqlParserSAMPLE, PlSqlParserSAVE_AS_INTERVALS, PlSqlParserSAVEPOINT, PlSqlParserSAVE, PlSqlParserSB4, PlSqlParserSCALE_ROWS, PlSqlParserSCALE, PlSqlParserSCAN_INSTANCES, PlSqlParserSCAN, PlSqlParserSCHEDULER, PlSqlParserSCHEMACHECK, PlSqlParserSCHEMA, PlSqlParserSCN_ASCENDING, PlSqlParserSCN, PlSqlParserSCOPE, PlSqlParserSCRUB, PlSqlParserSD_ALL, PlSqlParserSD_INHIBIT, PlSqlParserSDO_GEOM_MBR, PlSqlParserSDO_GEOMETRY, PlSqlParserSD_SHOW, PlSqlParserSEARCH, PlSqlParserSECOND, PlSqlParserSECONDS, PlSqlParserSECRET, PlSqlParserSECUREFILE_DBA, PlSqlParserSECUREFILE, PlSqlParserSECURITY, PlSqlParserSEED, PlSqlParserSEG_BLOCK, PlSqlParserSEG_FILE, PlSqlParserSEGMENT, PlSqlParserSELECTIVITY, PlSqlParserSELF, PlSqlParserSEMIJOIN_DRIVER, PlSqlParserSEMIJOIN, PlSqlParserSEMI_TO_INNER, PlSqlParserSEQUENCED, PlSqlParserSEQUENCE, PlSqlParserSEQUENTIAL, PlSqlParserSERIALIZABLE, PlSqlParserSERIALLY_REUSABLE, PlSqlParserSERIAL, PlSqlParserSERVERERROR, PlSqlParserSERVICE_NAME_CONVERT, PlSqlParserSERVICE, PlSqlParserSERVICES, PlSqlParserSESSION_CACHED_CURSORS, PlSqlParserSESSION, PlSqlParserSESSIONS_PER_USER, PlSqlParserSESSIONTIMEZONE, PlSqlParserSESSIONTZNAME, PlSqlParserSET, PlSqlParserSETS, PlSqlParserSETTINGS, PlSqlParserSET_TO_JOIN, PlSqlParserSEVERE, PlSqlParserSHARDSPACE, PlSqlParserSHARED_POOL, PlSqlParserSHARED, PlSqlParserSHARING, PlSqlParserSHELFLIFE, PlSqlParserSHOW, PlSqlParserSHRINK, PlSqlParserSHUTDOWN, PlSqlParserSIBLINGS, PlSqlParserSID, PlSqlParserSITE, PlSqlParserSIGNAL_COMPONENT, PlSqlParserSIGNAL_FUNCTION, PlSqlParserSIGN, PlSqlParserSIGNTYPE, PlSqlParserSIMPLE_INTEGER, PlSqlParserSIMPLE, PlSqlParserSINGLE, PlSqlParserSINGLETASK, PlSqlParserSINH, PlSqlParserSIN, PlSqlParserSKIP_EXT_OPTIMIZER, PlSqlParserSKIP_, PlSqlParserSKIP_UNQ_UNUSABLE_IDX, PlSqlParserSKIP_UNUSABLE_INDEXES, PlSqlParserSMALLFILE, PlSqlParserSMALLINT, PlSqlParserSNAPSHOT, PlSqlParserSOME, PlSqlParserSORT, PlSqlParserSOUNDEX, PlSqlParserSOURCE_FILE_DIRECTORY, PlSqlParserSOURCE_FILE_NAME_CONVERT, PlSqlParserSOURCE, PlSqlParserSPACE_KEYWORD, PlSqlParserSPECIFICATION, PlSqlParserSPFILE, PlSqlParserSPLIT, PlSqlParserSPREADSHEET, PlSqlParserSQLDATA, PlSqlParserSQLERROR, PlSqlParserSQLLDR, PlSqlParserSQL, PlSqlParserSQL_MACRO, PlSqlParserSQL_TRACE, PlSqlParserSQL_TRANSLATION_PROFILE, PlSqlParserSQRT, PlSqlParserSTALE, PlSqlParserSTANDALONE, PlSqlParserSTANDARD, PlSqlParserSTANDARD_HASH, PlSqlParserSTANDBY_MAX_DATA_DELAY, PlSqlParserSTANDBYS, PlSqlParserSTANDBY, PlSqlParserSTAR, PlSqlParserSTAR_TRANSFORMATION, PlSqlParserSTARTUP, PlSqlParserSTATEMENT_ID, PlSqlParserSTATEMENT_QUEUING, PlSqlParserSTATEMENTS, PlSqlParserSTATEMENT, PlSqlParserSTATE, PlSqlParserSTATIC, PlSqlParserSTATISTICS, PlSqlParserSTATS_BINOMIAL_TEST, PlSqlParserSTATS_CROSSTAB, PlSqlParserSTATS_F_TEST, PlSqlParserSTATS_KS_TEST, PlSqlParserSTATS_MODE, PlSqlParserSTATS_MW_TEST, PlSqlParserSTATS_ONE_WAY_ANOVA, PlSqlParserSTATS_T_TEST_INDEP, PlSqlParserSTATS_T_TEST_INDEPU, PlSqlParserSTATS_T_TEST_ONE, PlSqlParserSTATS_T_TEST_PAIRED, PlSqlParserSTATS_WSR_TEST, PlSqlParserSTDDEV_POP, PlSqlParserSTDDEV_SAMP, PlSqlParserSTOP, PlSqlParserSTORAGE, PlSqlParserSTORE, PlSqlParserSTREAMS, PlSqlParserSTREAM, PlSqlParserSTRICT, PlSqlParserSTRING, PlSqlParserSTRIPE_COLUMNS, PlSqlParserSTRIPE_WIDTH, PlSqlParserSTRIP, PlSqlParserSTRUCTURE, PlSqlParserSUBMULTISET, PlSqlParserSUBPARTITION_REL, PlSqlParserSUBPARTITIONS, PlSqlParserSUBPARTITION, PlSqlParserSUBQUERIES, PlSqlParserSUBQUERY_PRUNING, PlSqlParserSUBSCRIBE, PlSqlParserSUBSET, PlSqlParserSUBSTITUTABLE, PlSqlParserSUBSTR2, PlSqlParserSUBSTR4, PlSqlParserSUBSTRB, PlSqlParserSUBSTRC, PlSqlParserSUBTYPE, PlSqlParserSUCCESSFUL, PlSqlParserSUCCESS, PlSqlParserSUMMARY, PlSqlParserSUPPLEMENTAL, PlSqlParserSUSPEND, PlSqlParserSWAP_JOIN_INPUTS, PlSqlParserSWITCHOVER, PlSqlParserSWITCH, PlSqlParserSYNCHRONOUS, PlSqlParserSYNC, PlSqlParserSYS, PlSqlParserSYSASM, PlSqlParserSYS_AUDIT, PlSqlParserSYSAUX, PlSqlParserSYSBACKUP, PlSqlParserSYS_CHECKACL, PlSqlParserSYS_CHECK_PRIVILEGE, PlSqlParserSYS_CONNECT_BY_PATH, PlSqlParserSYS_CONTEXT, PlSqlParserSYSDATE, PlSqlParserSYSDBA, PlSqlParserSYS_DBURIGEN, PlSqlParserSYSDG, PlSqlParserSYS_DL_CURSOR, PlSqlParserSYS_DM_RXFORM_CHR, PlSqlParserSYS_DM_RXFORM_NUM, PlSqlParserSYS_DOM_COMPARE, PlSqlParserSYS_DST_PRIM2SEC, PlSqlParserSYS_DST_SEC2PRIM, PlSqlParserSYS_ET_BFILE_TO_RAW, PlSqlParserSYS_ET_BLOB_TO_IMAGE, PlSqlParserSYS_ET_IMAGE_TO_BLOB, PlSqlParserSYS_ET_RAW_TO_BFILE, PlSqlParserSYS_EXTPDTXT, PlSqlParserSYS_EXTRACT_UTC, PlSqlParserSYS_FBT_INSDEL, PlSqlParserSYS_FILTER_ACLS, PlSqlParserSYS_FNMATCHES, PlSqlParserSYS_FNREPLACE, PlSqlParserSYS_GET_ACLIDS, PlSqlParserSYS_GET_COL_ACLIDS, PlSqlParserSYS_GET_PRIVILEGES, PlSqlParserSYS_GETTOKENID, PlSqlParserSYS_GETXTIVAL, PlSqlParserSYS_GUID, PlSqlParserSYSGUID, PlSqlParserSYSKM, PlSqlParserSYS_MAKE_XMLNODEID, PlSqlParserSYS_MAKEXML, PlSqlParserSYS_MKXMLATTR, PlSqlParserSYS_MKXTI, PlSqlParserSYSOBJ, PlSqlParserSYS_OP_ADT2BIN, PlSqlParserSYS_OP_ADTCONS, PlSqlParserSYS_OP_ALSCRVAL, PlSqlParserSYS_OP_ATG, PlSqlParserSYS_OP_BIN2ADT, PlSqlParserSYS_OP_BITVEC, PlSqlParserSYS_OP_BL2R, PlSqlParserSYS_OP_BLOOM_FILTER_LIST, PlSqlParserSYS_OP_BLOOM_FILTER, PlSqlParserSYS_OP_C2C, PlSqlParserSYS_OP_CAST, PlSqlParserSYS_OP_CEG, PlSqlParserSYS_OP_CL2C, PlSqlParserSYS_OP_COMBINED_HASH, PlSqlParserSYS_OP_COMP, PlSqlParserSYS_OP_CONVERT, PlSqlParserSYS_OP_COUNTCHG, PlSqlParserSYS_OP_CSCONV, PlSqlParserSYS_OP_CSCONVTEST, PlSqlParserSYS_OP_CSR, PlSqlParserSYS_OP_CSX_PATCH, PlSqlParserSYS_OP_CYCLED_SEQ, PlSqlParserSYS_OP_DECOMP, PlSqlParserSYS_OP_DESCEND, PlSqlParserSYS_OP_DISTINCT, PlSqlParserSYS_OP_DRA, PlSqlParserSYS_OP_DUMP, PlSqlParserSYS_OP_DV_CHECK, PlSqlParserSYS_OP_ENFORCE_NOT_NULL, PlSqlParserSYSOPER, PlSqlParserSYS_OP_EXTRACT, PlSqlParserSYS_OP_GROUPING, PlSqlParserSYS_OP_GUID, PlSqlParserSYS_OP_HASH, PlSqlParserSYS_OP_IIX, PlSqlParserSYS_OP_ITR, PlSqlParserSYS_OP_KEY_VECTOR_CREATE, PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, PlSqlParserSYS_OP_KEY_VECTOR_FILTER, PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, PlSqlParserSYS_OP_KEY_VECTOR_USE, PlSqlParserSYS_OP_LBID, PlSqlParserSYS_OP_LOBLOC2BLOB, PlSqlParserSYS_OP_LOBLOC2CLOB, PlSqlParserSYS_OP_LOBLOC2ID, PlSqlParserSYS_OP_LOBLOC2NCLOB, PlSqlParserSYS_OP_LOBLOC2TYP, PlSqlParserSYS_OP_LSVI, PlSqlParserSYS_OP_LVL, PlSqlParserSYS_OP_MAKEOID, PlSqlParserSYS_OP_MAP_NONNULL, PlSqlParserSYS_OP_MSR, PlSqlParserSYS_OP_NICOMBINE, PlSqlParserSYS_OP_NIEXTRACT, PlSqlParserSYS_OP_NII, PlSqlParserSYS_OP_NIX, PlSqlParserSYS_OP_NOEXPAND, PlSqlParserSYS_OP_NTCIMG, PlSqlParserSYS_OP_NUMTORAW, PlSqlParserSYS_OP_OIDVALUE, PlSqlParserSYS_OP_OPNSIZE, PlSqlParserSYS_OP_PAR_1, PlSqlParserSYS_OP_PARGID_1, PlSqlParserSYS_OP_PARGID, PlSqlParserSYS_OP_PAR, PlSqlParserSYS_OP_PART_ID, PlSqlParserSYS_OP_PIVOT, PlSqlParserSYS_OP_R2O, PlSqlParserSYS_OP_RAWTONUM, PlSqlParserSYS_OP_RDTM, PlSqlParserSYS_OP_REF, PlSqlParserSYS_OP_RMTD, PlSqlParserSYS_OP_ROWIDTOOBJ, PlSqlParserSYS_OP_RPB, PlSqlParserSYS_OPTLOBPRBSC, PlSqlParserSYS_OP_TOSETID, PlSqlParserSYS_OP_TPR, PlSqlParserSYS_OP_TRTB, PlSqlParserSYS_OPTXICMP, PlSqlParserSYS_OPTXQCASTASNQ, PlSqlParserSYS_OP_UNDESCEND, PlSqlParserSYS_OP_VECAND, PlSqlParserSYS_OP_VECBIT, PlSqlParserSYS_OP_VECOR, PlSqlParserSYS_OP_VECXOR, PlSqlParserSYS_OP_VERSION, PlSqlParserSYS_OP_VREF, PlSqlParserSYS_OP_VVD, PlSqlParserSYS_OP_XMLCONS_FOR_CSX, PlSqlParserSYS_OP_XPTHATG, PlSqlParserSYS_OP_XPTHIDX, PlSqlParserSYS_OP_XPTHOP, PlSqlParserSYS_OP_XTXT2SQLT, PlSqlParserSYS_OP_ZONE_ID, PlSqlParserSYS_ORDERKEY_DEPTH, PlSqlParserSYS_ORDERKEY_MAXCHILD, PlSqlParserSYS_ORDERKEY_PARENT, PlSqlParserSYS_PARALLEL_TXN, PlSqlParserSYS_PATHID_IS_ATTR, PlSqlParserSYS_PATHID_IS_NMSPC, PlSqlParserSYS_PATHID_LASTNAME, PlSqlParserSYS_PATHID_LASTNMSPC, PlSqlParserSYS_PATH_REVERSE, PlSqlParserSYS_PXQEXTRACT, PlSqlParserSYS_RAW_TO_XSID, PlSqlParserSYS_RID_ORDER, PlSqlParserSYS_ROW_DELTA, PlSqlParserSYS_SC_2_XMLT, PlSqlParserSYS_SYNRCIREDO, PlSqlParserSYSTEM_DEFINED, PlSqlParserSYSTEM, PlSqlParserSYSTIMESTAMP, PlSqlParserSYS_TYPEID, PlSqlParserSYS_UMAKEXML, PlSqlParserSYS_XMLANALYZE, PlSqlParserSYS_XMLCONTAINS, PlSqlParserSYS_XMLCONV, PlSqlParserSYS_XMLEXNSURI, PlSqlParserSYS_XMLGEN, PlSqlParserSYS_XMLI_LOC_ISNODE, PlSqlParserSYS_XMLI_LOC_ISTEXT, PlSqlParserSYS_XMLINSTR, PlSqlParserSYS_XMLLOCATOR_GETSVAL, PlSqlParserSYS_XMLNODEID_GETCID, PlSqlParserSYS_XMLNODEID_GETLOCATOR, PlSqlParserSYS_XMLNODEID_GETOKEY, PlSqlParserSYS_XMLNODEID_GETPATHID, PlSqlParserSYS_XMLNODEID_GETPTRID, PlSqlParserSYS_XMLNODEID_GETRID, PlSqlParserSYS_XMLNODEID_GETSVAL, PlSqlParserSYS_XMLNODEID_GETTID, PlSqlParserSYS_XMLNODEID, PlSqlParserSYS_XMLT_2_SC, PlSqlParserSYS_XMLTRANSLATE, PlSqlParserSYS_XMLTYPE2SQL, PlSqlParserSYS_XQ_ASQLCNV, PlSqlParserSYS_XQ_ATOMCNVCHK, PlSqlParserSYS_XQBASEURI, PlSqlParserSYS_XQCASTABLEERRH, PlSqlParserSYS_XQCODEP2STR, PlSqlParserSYS_XQCODEPEQ, PlSqlParserSYS_XQCON2SEQ, PlSqlParserSYS_XQCONCAT, PlSqlParserSYS_XQDELETE, PlSqlParserSYS_XQDFLTCOLATION, PlSqlParserSYS_XQDOC, PlSqlParserSYS_XQDOCURI, PlSqlParserSYS_XQDURDIV, PlSqlParserSYS_XQED4URI, PlSqlParserSYS_XQENDSWITH, PlSqlParserSYS_XQERRH, PlSqlParserSYS_XQERR, PlSqlParserSYS_XQESHTMLURI, PlSqlParserSYS_XQEXLOBVAL, PlSqlParserSYS_XQEXSTWRP, PlSqlParserSYS_XQEXTRACT, PlSqlParserSYS_XQEXTRREF, PlSqlParserSYS_XQEXVAL, PlSqlParserSYS_XQFB2STR, PlSqlParserSYS_XQFNBOOL, PlSqlParserSYS_XQFNCMP, PlSqlParserSYS_XQFNDATIM, PlSqlParserSYS_XQFNLNAME, PlSqlParserSYS_XQFNNM, PlSqlParserSYS_XQFNNSURI, PlSqlParserSYS_XQFNPREDTRUTH, PlSqlParserSYS_XQFNQNM, PlSqlParserSYS_XQFNROOT, PlSqlParserSYS_XQFORMATNUM, PlSqlParserSYS_XQFTCONTAIN, PlSqlParserSYS_XQFUNCR, PlSqlParserSYS_XQGETCONTENT, PlSqlParserSYS_XQINDXOF, PlSqlParserSYS_XQINSERT, PlSqlParserSYS_XQINSPFX, PlSqlParserSYS_XQIRI2URI, PlSqlParserSYS_XQLANG, PlSqlParserSYS_XQLLNMFRMQNM, PlSqlParserSYS_XQMKNODEREF, PlSqlParserSYS_XQNILLED, PlSqlParserSYS_XQNODENAME, PlSqlParserSYS_XQNORMSPACE, PlSqlParserSYS_XQNORMUCODE, PlSqlParserSYS_XQ_NRNG, PlSqlParserSYS_XQNSP4PFX, PlSqlParserSYS_XQNSPFRMQNM, PlSqlParserSYS_XQPFXFRMQNM, PlSqlParserSYS_XQ_PKSQL2XML, PlSqlParserSYS_XQPOLYABS, PlSqlParserSYS_XQPOLYADD, PlSqlParserSYS_XQPOLYCEL, PlSqlParserSYS_XQPOLYCSTBL, PlSqlParserSYS_XQPOLYCST, PlSqlParserSYS_XQPOLYDIV, PlSqlParserSYS_XQPOLYFLR, PlSqlParserSYS_XQPOLYMOD, PlSqlParserSYS_XQPOLYMUL, PlSqlParserSYS_XQPOLYRND, PlSqlParserSYS_XQPOLYSQRT, PlSqlParserSYS_XQPOLYSUB, PlSqlParserSYS_XQPOLYUMUS, PlSqlParserSYS_XQPOLYUPLS, PlSqlParserSYS_XQPOLYVEQ, PlSqlParserSYS_XQPOLYVGE, PlSqlParserSYS_XQPOLYVGT, PlSqlParserSYS_XQPOLYVLE, PlSqlParserSYS_XQPOLYVLT, PlSqlParserSYS_XQPOLYVNE, PlSqlParserSYS_XQREF2VAL, PlSqlParserSYS_XQRENAME, PlSqlParserSYS_XQREPLACE, PlSqlParserSYS_XQRESVURI, PlSqlParserSYS_XQRNDHALF2EVN, PlSqlParserSYS_XQRSLVQNM, PlSqlParserSYS_XQRYENVPGET, PlSqlParserSYS_XQRYVARGET, PlSqlParserSYS_XQRYWRP, PlSqlParserSYS_XQSEQ2CON4XC, PlSqlParserSYS_XQSEQ2CON, PlSqlParserSYS_XQSEQDEEPEQ, PlSqlParserSYS_XQSEQINSB, PlSqlParserSYS_XQSEQRM, PlSqlParserSYS_XQSEQRVS, PlSqlParserSYS_XQSEQSUB, PlSqlParserSYS_XQSEQTYPMATCH, PlSqlParserSYS_XQSTARTSWITH, PlSqlParserSYS_XQSTATBURI, PlSqlParserSYS_XQSTR2CODEP, PlSqlParserSYS_XQSTRJOIN, PlSqlParserSYS_XQSUBSTRAFT, PlSqlParserSYS_XQSUBSTRBEF, PlSqlParserSYS_XQTOKENIZE, PlSqlParserSYS_XQTREATAS, PlSqlParserSYS_XQ_UPKXML2SQL, PlSqlParserSYS_XQXFORM, PlSqlParserSYS_XSID_TO_RAW, PlSqlParserSYS_ZMAP_FILTER, PlSqlParserSYS_ZMAP_REFRESH, PlSqlParserT_LETTER, PlSqlParserTABLE_LOOKUP_BY_NL, PlSqlParserTABLESPACE_NO, PlSqlParserTABLESPACE, PlSqlParserTABLES, PlSqlParserTABLE_STATS, PlSqlParserTABLE, PlSqlParserTABNO, PlSqlParserTAG, PlSqlParserTANH, PlSqlParserTAN, PlSqlParserTBLORIDXPARTNUM, PlSqlParserTEMPFILE, PlSqlParserTEMPLATE, PlSqlParserTEMPORARY, PlSqlParserTEMP_TABLE, PlSqlParserTEST, PlSqlParserTEXT, PlSqlParserTHAN, PlSqlParserTHEN, PlSqlParserTHE, PlSqlParserTHREAD, PlSqlParserTHROUGH, PlSqlParserTIER, PlSqlParserTIES, PlSqlParserTIMEOUT, PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, PlSqlParserTIMESTAMP, PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, PlSqlParserTIMESTAMP_UNCONSTRAINED, PlSqlParserTIMES, PlSqlParserTIME, PlSqlParserTIMEZONE_ABBR, PlSqlParserTIMEZONE_HOUR, PlSqlParserTIMEZONE_MINUTE, PlSqlParserTIMEZONE_OFFSET, PlSqlParserTIMEZONE_REGION, PlSqlParserTIME_ZONE, PlSqlParserTIMING, PlSqlParserTIV_GB, PlSqlParserTIV_SSF, PlSqlParserTO_ACLID, PlSqlParserTO_BINARY_DOUBLE, PlSqlParserTO_BINARY_FLOAT, PlSqlParserTO_BLOB, PlSqlParserTO_CLOB, PlSqlParserTO_DSINTERVAL, PlSqlParserTO_LOB, PlSqlParserTO_MULTI_BYTE, PlSqlParserTO_NCHAR, PlSqlParserTO_NCLOB, PlSqlParserTO_NUMBER, PlSqlParserTOPLEVEL, PlSqlParserTO_SINGLE_BYTE, PlSqlParserTO_TIMESTAMP, PlSqlParserTO_TIMESTAMP_TZ, PlSqlParserTO_TIME, PlSqlParserTO_TIME_TZ, PlSqlParserTO_YMINTERVAL, PlSqlParserTRACE, PlSqlParserTRACING, PlSqlParserTRACKING, PlSqlParserTRAILING, PlSqlParserTRANSACTION, PlSqlParserTRANSFORM, PlSqlParserTRANSFORM_DISTINCT_AGG, PlSqlParserTRANSITIONAL, PlSqlParserTRANSITION, PlSqlParserTRANSLATE, PlSqlParserTRANSLATION, PlSqlParserTREAT, PlSqlParserTRIGGERS, PlSqlParserTRIGGER, PlSqlParserTRUE, PlSqlParserTRUNCATE, PlSqlParserTRUNC, PlSqlParserTRUSTED, PlSqlParserTRUST, PlSqlParserTUNING, PlSqlParserTX, PlSqlParserTYPES, PlSqlParserTYPE, PlSqlParserTZ_OFFSET, PlSqlParserUB2, PlSqlParserUBA, PlSqlParserUCS2, PlSqlParserUID, PlSqlParserUNARCHIVED, PlSqlParserUNBOUNDED, PlSqlParserUNBOUND, PlSqlParserUNCONDITIONAL, PlSqlParserUNDER, PlSqlParserUNDO, PlSqlParserUNDROP, PlSqlParserUNIFORM, PlSqlParserUNISTR, PlSqlParserUNLIMITED, PlSqlParserUNLOAD, PlSqlParserUNLOCK, PlSqlParserUNMATCHED, PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, PlSqlParserUNNEST_SEMIJ_VIEW, PlSqlParserUNNEST, PlSqlParserUNPACKED, PlSqlParserUNPIVOT, PlSqlParserUNPLUG, PlSqlParserUNPROTECTED, PlSqlParserUNQUIESCE, PlSqlParserUNRECOVERABLE, PlSqlParserUNRESTRICTED, PlSqlParserUNSUBSCRIBE, PlSqlParserUNTIL, PlSqlParserUNUSABLE, PlSqlParserUNUSED, PlSqlParserUPDATABLE, PlSqlParserUPDATED, PlSqlParserUPDATEXML, PlSqlParserUPD_INDEXES, PlSqlParserUPD_JOININDEX, PlSqlParserUPGRADE, PlSqlParserUPPER, PlSqlParserUPSERT, PlSqlParserUROWID, PlSqlParserUSABLE, PlSqlParserUSAGE, PlSqlParserUSE_ANTI, PlSqlParserUSE_CONCAT, PlSqlParserUSE_CUBE, PlSqlParserUSE_HASH_AGGREGATION, PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, PlSqlParserUSE_HASH, PlSqlParserUSE_HIDDEN_PARTITIONS, PlSqlParserUSE_INVISIBLE_INDEXES, PlSqlParserUSE_MERGE_CARTESIAN, PlSqlParserUSE_MERGE, PlSqlParserUSE_NL, PlSqlParserUSE_NL_WITH_INDEX, PlSqlParserUSE_PRIVATE_OUTLINES, PlSqlParserUSER_DATA, PlSqlParserUSER_DEFINED, PlSqlParserUSERENV, PlSqlParserUSERGROUP, PlSqlParserUSER_RECYCLEBIN, PlSqlParserUSERS, PlSqlParserUSER_TABLESPACES, PlSqlParserUSER, PlSqlParserUSE_SEMI, PlSqlParserUSE_STORED_OUTLINES, PlSqlParserUSE_TTT_FOR_GSETS, PlSqlParserUSE, PlSqlParserUSE_VECTOR_AGGREGATION, PlSqlParserUSE_WEAK_NAME_RESL, PlSqlParserUSING_NO_EXPAND, PlSqlParserUSING, PlSqlParserUTF16BE, PlSqlParserUTF16LE, PlSqlParserUTF32, PlSqlParserUTF8, PlSqlParserV1, PlSqlParserV2, PlSqlParserVALIDATE, PlSqlParserVALIDATE_CONVERSION, PlSqlParserVALIDATION, PlSqlParserVALID_TIME_END, PlSqlParserVALUE, PlSqlParserVARCHAR2, PlSqlParserVARCHAR, PlSqlParserVARIABLE, PlSqlParserVAR_POP, PlSqlParserVARRAYS, PlSqlParserVARRAY, PlSqlParserVAR_SAMP, PlSqlParserVARYING, PlSqlParserVECTOR_READ_TRACE, PlSqlParserVECTOR_READ, PlSqlParserVECTOR_TRANSFORM_DIMS, PlSqlParserVECTOR_TRANSFORM_FACT, PlSqlParserVECTOR_TRANSFORM, PlSqlParserVERIFIER, PlSqlParserVERIFY, PlSqlParserVERSIONING, PlSqlParserVERSIONS_ENDSCN, PlSqlParserVERSIONS_ENDTIME, PlSqlParserVERSIONS_OPERATION, PlSqlParserVERSIONS_STARTSCN, PlSqlParserVERSIONS_STARTTIME, PlSqlParserVERSIONS, PlSqlParserVERSIONS_XID, PlSqlParserVERSION, PlSqlParserVIOLATION, PlSqlParserVIRTUAL, PlSqlParserVISIBILITY, PlSqlParserVISIBLE, PlSqlParserVOLUME, PlSqlParserVSIZE, PlSqlParserWAIT, PlSqlParserWALLET, PlSqlParserWARNING, PlSqlParserWEEKS, PlSqlParserWEEK, PlSqlParserWELLFORMED, PlSqlParserWHENEVER, PlSqlParserWHEN, PlSqlParserWHILE, PlSqlParserWHITESPACE, PlSqlParserWIDTH_BUCKET, PlSqlParserWITHIN, PlSqlParserWITHOUT, PlSqlParserWITH_PLSQL, PlSqlParserWORK, PlSqlParserWRAPPED, PlSqlParserWRAPPER, PlSqlParserWRITE, PlSqlParserXDB_FASTPATH_INSERT, PlSqlParserX_DYN_PRUNE, PlSqlParserXID, PlSqlParserXML2OBJECT, PlSqlParserXMLAGG, PlSqlParserXMLATTRIBUTES, PlSqlParserXMLCAST, PlSqlParserXMLCDATA, PlSqlParserXMLCOLATTVAL, PlSqlParserXMLCOMMENT, PlSqlParserXMLCONCAT, PlSqlParserXMLDIFF, PlSqlParserXML_DML_RWT_STMT, PlSqlParserXMLELEMENT, PlSqlParserXMLEXISTS2, PlSqlParserXMLEXISTS, PlSqlParserXMLFOREST, PlSqlParserXMLINDEX_REWRITE_IN_SELECT, PlSqlParserXMLINDEX_REWRITE, PlSqlParserXMLINDEX_SEL_IDX_TBL, PlSqlParserXMLISNODE, PlSqlParserXMLISVALID, PlSqlParserXMLNAMESPACES, PlSqlParserXMLPARSE, PlSqlParserXMLPATCH, PlSqlParserXMLPI, PlSqlParserXMLQUERYVAL, PlSqlParserXMLQUERY, PlSqlParserXMLROOT, PlSqlParserXMLSCHEMA, PlSqlParserXMLSERIALIZE, PlSqlParserXMLTABLE, PlSqlParserXMLTRANSFORMBLOB, PlSqlParserXMLTRANSFORM, PlSqlParserXMLTYPE, PlSqlParserXML, PlSqlParserXPATHTABLE, PlSqlParserXS_SYS_CONTEXT, PlSqlParserXS, PlSqlParserYEARS, PlSqlParserYEAR, PlSqlParserYES, PlSqlParserYMINTERVAL_UNCONSTRAINED, PlSqlParserZONEMAP, PlSqlParserZONE, PlSqlParserPREDICTION, PlSqlParserPREDICTION_BOUNDS, PlSqlParserPREDICTION_COST, PlSqlParserPREDICTION_DETAILS, PlSqlParserPREDICTION_PROBABILITY, PlSqlParserPREDICTION_SET, PlSqlParserBLOCKCHAIN, PlSqlParserCOLLATE, PlSqlParserCOLLATION, PlSqlParserDEFINITION, PlSqlParserDUPLICATED, PlSqlParserEXTENDED, PlSqlParserHASHING, PlSqlParserIDLE, PlSqlParserIMMUTABLE, PlSqlParserORACLE_DATAPUMP, PlSqlParserORACLE_HDFS, PlSqlParserORACLE_HIVE, PlSqlParserORACLE_LOADER, PlSqlParserSHARDED, PlSqlParserISOLATE, PlSqlParserROOT, PlSqlParserUNITE, PlSqlParserALGORITHM, PlSqlParserCUME_DIST, PlSqlParserDENSE_RANK, PlSqlParserLISTAGG, PlSqlParserPERCENT_RANK, PlSqlParserPERCENTILE_CONT, PlSqlParserPERCENTILE_DISC, PlSqlParserRANK, PlSqlParserAVG, PlSqlParserCORR, PlSqlParserCOVAR_, PlSqlParserLAG, PlSqlParserLEAD, PlSqlParserMAX, PlSqlParserMEDIAN, PlSqlParserMEMOPTIMIZE, PlSqlParserMIN, PlSqlParserNTILE, PlSqlParserNVL, PlSqlParserRATIO_TO_REPORT, PlSqlParserREGR_, PlSqlParserROUND, PlSqlParserROW_NUMBER, PlSqlParserSUBSTR, PlSqlParserTO_CHAR, PlSqlParserTRIM, PlSqlParserSUM, PlSqlParserSTDDEV, PlSqlParserVAR_, PlSqlParserVARIANCE, PlSqlParserLEAST, PlSqlParserGREATEST, PlSqlParserTO_DATE, PlSqlParserDEFAULTIF, PlSqlParserLLS, PlSqlParserENCLOSED, PlSqlParserTERMINATED, PlSqlParserOPTIONALLY, PlSqlParserLRTRIM, PlSqlParserNOTRIM, PlSqlParserLDRTRIM, PlSqlParserDATE_FORMAT, PlSqlParserMASK, PlSqlParserTRANSFORMS, PlSqlParserLOBFILE, PlSqlParserSTARTOF, PlSqlParserCHARACTERSET, PlSqlParserRECORDS, PlSqlParserFIXED, PlSqlParserDELIMITED, PlSqlParserXMLTAG, PlSqlParserPREPROCESSOR, PlSqlParserTERRITORY, PlSqlParserLITTLE, PlSqlParserBIG, PlSqlParserENDIAN, PlSqlParserBYTEORDERMARK, PlSqlParserNOCHECK, PlSqlParserSIZES, PlSqlParserARE, PlSqlParserBYTES, PlSqlParserCHARACTERS, PlSqlParserREADSIZE, PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, PlSqlParserDATE_CACHE, PlSqlParserFIELD_NAMES, PlSqlParserFILES, PlSqlParserIO_OPTIONS, PlSqlParserDIRECTIO, PlSqlParserNODIRECTIO, PlSqlParserDNFS_ENABLE, PlSqlParserDNFS_DISABLE, PlSqlParserDNFS_READBUFFERS, PlSqlParserNOBADFILE, PlSqlParserBADFILE, PlSqlParserNODISCARDFILE, PlSqlParserDISCARDFILE, PlSqlParserNOLOGFILE, PlSqlParserFIELDS, PlSqlParserIGNORE_CHARS_AFTER_EOR, PlSqlParserCSV, PlSqlParserEMBEDDED, PlSqlParserOVERRIDE, PlSqlParserTHESE, PlSqlParserFIELD, PlSqlParserNONULLIF, PlSqlParserPOSITION, PlSqlParserNEWLINE_, PlSqlParserDETECTED, PlSqlParserUNSIGNED, PlSqlParserZONED, PlSqlParserORACLE_DATE, PlSqlParserORACLE_NUMBER, PlSqlParserCOUNTED, PlSqlParserVARRAW, PlSqlParserVARCHARC, PlSqlParserVARRAWC, PlSqlParserPERIOD, PlSqlParserREGULAR_ID: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20220) + p.Regular_id() + } + + case PlSqlParserDELIMITED_ID: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20221) + p.Match(PlSqlParserDELIMITED_ID) + 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 +} + +// IOuter_join_signContext is an interface to support dynamic dispatch. +type IOuter_join_signContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + LEFT_PAREN() antlr.TerminalNode + PLUS_SIGN() antlr.TerminalNode + RIGHT_PAREN() antlr.TerminalNode + + // IsOuter_join_signContext differentiates from other interfaces. + IsOuter_join_signContext() +} + +type Outer_join_signContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyOuter_join_signContext() *Outer_join_signContext { + var p = new(Outer_join_signContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_sign + return p +} + +func InitEmptyOuter_join_signContext(p *Outer_join_signContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_outer_join_sign +} + +func (*Outer_join_signContext) IsOuter_join_signContext() {} + +func NewOuter_join_signContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Outer_join_signContext { + var p = new(Outer_join_signContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_outer_join_sign + + return p +} + +func (s *Outer_join_signContext) GetParser() antlr.Parser { return s.parser } + +func (s *Outer_join_signContext) LEFT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT_PAREN, 0) +} + +func (s *Outer_join_signContext) PLUS_SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUS_SIGN, 0) +} + +func (s *Outer_join_signContext) RIGHT_PAREN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT_PAREN, 0) +} + +func (s *Outer_join_signContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Outer_join_signContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Outer_join_signContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterOuter_join_sign(s) + } +} + +func (s *Outer_join_signContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitOuter_join_sign(s) + } +} + +func (s *Outer_join_signContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitOuter_join_sign(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Outer_join_sign() (localctx IOuter_join_signContext) { + localctx = NewOuter_join_signContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2380, PlSqlParserRULE_outer_join_sign) + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20224) + p.Match(PlSqlParserLEFT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20225) + p.Match(PlSqlParserPLUS_SIGN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + { + p.SetState(20226) + p.Match(PlSqlParserRIGHT_PAREN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + +errorExit: + if p.HasError() { + v := p.GetError() + localctx.SetException(v) + p.GetErrorHandler().ReportError(p, v) + p.GetErrorHandler().Recover(p, v) + p.SetError(nil) + } + p.ExitRule() + return localctx + goto errorExit // Trick to prevent compiler error if the label is not used +} + +// IRegular_idContext is an interface to support dynamic dispatch. +type IRegular_idContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + Non_reserved_keywords_pre12c() INon_reserved_keywords_pre12cContext + Non_reserved_keywords_in_12c() INon_reserved_keywords_in_12cContext + REGULAR_ID() antlr.TerminalNode + ABSENT() antlr.TerminalNode + A_LETTER() antlr.TerminalNode + AGENT() antlr.TerminalNode + AGGREGATE() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + AUTONOMOUS_TRANSACTION() antlr.TerminalNode + BACKINGFILE() antlr.TerminalNode + BATCH() antlr.TerminalNode + BINARY_INTEGER() antlr.TerminalNode + BOOLEAN() antlr.TerminalNode + C_LETTER() antlr.TerminalNode + CHAR() antlr.TerminalNode + CLUSTER() antlr.TerminalNode + CONSTRUCTOR() antlr.TerminalNode + CUSTOMDATUM() antlr.TerminalNode + CASESENSITIVE() antlr.TerminalNode + DECIMAL() antlr.TerminalNode + DELETE() antlr.TerminalNode + DETERMINISTIC() antlr.TerminalNode + DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode + E_LETTER() antlr.TerminalNode + ERR() antlr.TerminalNode + EXCEPTION() antlr.TerminalNode + EXCEPTION_INIT() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + EXISTS() antlr.TerminalNode + EXIT() antlr.TerminalNode + FILESTORE() antlr.TerminalNode + FLOAT() antlr.TerminalNode + FORALL() antlr.TerminalNode + G_LETTER() antlr.TerminalNode + INDICES() antlr.TerminalNode + INOUT() antlr.TerminalNode + INTEGER() antlr.TerminalNode + JSON_TRANSFORM() antlr.TerminalNode + K_LETTER() antlr.TerminalNode + LANGUAGE() antlr.TerminalNode + LONG() antlr.TerminalNode + LOOP() antlr.TerminalNode + MOUNTPOINT() antlr.TerminalNode + M_LETTER() antlr.TerminalNode + MISSING() antlr.TerminalNode + MISMATCH() antlr.TerminalNode + NUMBER() antlr.TerminalNode + ORADATA() antlr.TerminalNode + OSERROR() antlr.TerminalNode + OUT() antlr.TerminalNode + OVERRIDING() antlr.TerminalNode + P_LETTER() antlr.TerminalNode + PARALLEL_ENABLE() antlr.TerminalNode + PIPELINED() antlr.TerminalNode + PLS_INTEGER() antlr.TerminalNode + PMEM() antlr.TerminalNode + POSITIVE() antlr.TerminalNode + POSITIVEN() antlr.TerminalNode + PRAGMA() antlr.TerminalNode + PUBLIC() antlr.TerminalNode + RAISE() antlr.TerminalNode + RAW() antlr.TerminalNode + RECORD() antlr.TerminalNode + REF() antlr.TerminalNode + RENAME() antlr.TerminalNode + RESTRICT_REFERENCES() antlr.TerminalNode + RESULT() antlr.TerminalNode + SDO_GEOMETRY() antlr.TerminalNode + SELF() antlr.TerminalNode + SERIALLY_REUSABLE() antlr.TerminalNode + SET() antlr.TerminalNode + SHARDSPACE() antlr.TerminalNode + SIGNTYPE() antlr.TerminalNode + SIMPLE_INTEGER() antlr.TerminalNode + SMALLINT() antlr.TerminalNode + SQLDATA() antlr.TerminalNode + SQLERROR() antlr.TerminalNode + SUBTYPE() antlr.TerminalNode + T_LETTER() antlr.TerminalNode + TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode + TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode + TRIGGER() antlr.TerminalNode + VARCHAR() antlr.TerminalNode + VARCHAR2() antlr.TerminalNode + VARIABLE() antlr.TerminalNode + WARNING() antlr.TerminalNode + WHILE() antlr.TerminalNode + XMLAGG() antlr.TerminalNode + YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode + REGR_() antlr.TerminalNode + VAR_() antlr.TerminalNode + VALUE() antlr.TerminalNode + COVAR_() antlr.TerminalNode + + // IsRegular_idContext differentiates from other interfaces. + IsRegular_idContext() +} + +type Regular_idContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyRegular_idContext() *Regular_idContext { + var p = new(Regular_idContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_regular_id + return p +} + +func InitEmptyRegular_idContext(p *Regular_idContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_regular_id +} + +func (*Regular_idContext) IsRegular_idContext() {} + +func NewRegular_idContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Regular_idContext { + var p = new(Regular_idContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_regular_id + + return p +} + +func (s *Regular_idContext) GetParser() antlr.Parser { return s.parser } + +func (s *Regular_idContext) Non_reserved_keywords_pre12c() INon_reserved_keywords_pre12cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_keywords_pre12cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_keywords_pre12cContext) +} + +func (s *Regular_idContext) Non_reserved_keywords_in_12c() INon_reserved_keywords_in_12cContext { + var t antlr.RuleContext + for _, ctx := range s.GetChildren() { + if _, ok := ctx.(INon_reserved_keywords_in_12cContext); ok { + t = ctx.(antlr.RuleContext) + break + } + } + + if t == nil { + return nil + } + + return t.(INon_reserved_keywords_in_12cContext) +} + +func (s *Regular_idContext) REGULAR_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR_ID, 0) +} + +func (s *Regular_idContext) ABSENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABSENT, 0) +} + +func (s *Regular_idContext) A_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserA_LETTER, 0) +} + +func (s *Regular_idContext) AGENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGENT, 0) +} + +func (s *Regular_idContext) AGGREGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAGGREGATE, 0) +} + +func (s *Regular_idContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Regular_idContext) AUTONOMOUS_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTONOMOUS_TRANSACTION, 0) +} + +func (s *Regular_idContext) BACKINGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKINGFILE, 0) +} + +func (s *Regular_idContext) BATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, 0) +} + +func (s *Regular_idContext) BINARY_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_INTEGER, 0) +} + +func (s *Regular_idContext) BOOLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOOLEAN, 0) +} + +func (s *Regular_idContext) C_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserC_LETTER, 0) +} + +func (s *Regular_idContext) CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR, 0) +} + +func (s *Regular_idContext) CLUSTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER, 0) +} + +func (s *Regular_idContext) CONSTRUCTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRUCTOR, 0) +} + +func (s *Regular_idContext) CUSTOMDATUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUSTOMDATUM, 0) +} + +func (s *Regular_idContext) CASESENSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASESENSITIVE, 0) +} + +func (s *Regular_idContext) DECIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECIMAL, 0) +} + +func (s *Regular_idContext) DELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE, 0) +} + +func (s *Regular_idContext) DETERMINISTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINISTIC, 0) +} + +func (s *Regular_idContext) DSINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDSINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) E_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserE_LETTER, 0) +} + +func (s *Regular_idContext) ERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERR, 0) +} + +func (s *Regular_idContext) EXCEPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION, 0) +} + +func (s *Regular_idContext) EXCEPTION_INIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTION_INIT, 0) +} + +func (s *Regular_idContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Regular_idContext) EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTS, 0) +} + +func (s *Regular_idContext) EXIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXIT, 0) +} + +func (s *Regular_idContext) FILESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESTORE, 0) +} + +func (s *Regular_idContext) FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOAT, 0) +} + +func (s *Regular_idContext) FORALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORALL, 0) +} + +func (s *Regular_idContext) G_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserG_LETTER, 0) +} + +func (s *Regular_idContext) INDICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICES, 0) +} + +func (s *Regular_idContext) INOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINOUT, 0) +} + +func (s *Regular_idContext) INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTEGER, 0) +} + +func (s *Regular_idContext) JSON_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TRANSFORM, 0) +} + +func (s *Regular_idContext) K_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserK_LETTER, 0) +} + +func (s *Regular_idContext) LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLANGUAGE, 0) +} + +func (s *Regular_idContext) LONG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLONG, 0) +} + +func (s *Regular_idContext) LOOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOOP, 0) +} + +func (s *Regular_idContext) MOUNTPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPOINT, 0) +} + +func (s *Regular_idContext) M_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserM_LETTER, 0) +} + +func (s *Regular_idContext) MISSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISSING, 0) +} + +func (s *Regular_idContext) MISMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMISMATCH, 0) +} + +func (s *Regular_idContext) NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMBER, 0) +} + +func (s *Regular_idContext) ORADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADATA, 0) +} + +func (s *Regular_idContext) OSERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOSERROR, 0) +} + +func (s *Regular_idContext) OUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT, 0) +} + +func (s *Regular_idContext) OVERRIDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDING, 0) +} + +func (s *Regular_idContext) P_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserP_LETTER, 0) +} + +func (s *Regular_idContext) PARALLEL_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_ENABLE, 0) +} + +func (s *Regular_idContext) PIPELINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIPELINED, 0) +} + +func (s *Regular_idContext) PLS_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLS_INTEGER, 0) +} + +func (s *Regular_idContext) PMEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPMEM, 0) +} + +func (s *Regular_idContext) POSITIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVE, 0) +} + +func (s *Regular_idContext) POSITIVEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITIVEN, 0) +} + +func (s *Regular_idContext) PRAGMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRAGMA, 0) +} + +func (s *Regular_idContext) PUBLIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUBLIC, 0) +} + +func (s *Regular_idContext) RAISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAISE, 0) +} + +func (s *Regular_idContext) RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAW, 0) +} + +func (s *Regular_idContext) RECORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORD, 0) +} + +func (s *Regular_idContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Regular_idContext) RENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRENAME, 0) +} + +func (s *Regular_idContext) RESTRICT_REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_REFERENCES, 0) +} + +func (s *Regular_idContext) RESULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT, 0) +} + +func (s *Regular_idContext) SDO_GEOMETRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOMETRY, 0) +} + +func (s *Regular_idContext) SELF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELF, 0) +} + +func (s *Regular_idContext) SERIALLY_REUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALLY_REUSABLE, 0) +} + +func (s *Regular_idContext) SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET, 0) +} + +func (s *Regular_idContext) SHARDSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDSPACE, 0) +} + +func (s *Regular_idContext) SIGNTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNTYPE, 0) +} + +func (s *Regular_idContext) SIMPLE_INTEGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE_INTEGER, 0) +} + +func (s *Regular_idContext) SMALLINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLINT, 0) +} + +func (s *Regular_idContext) SQLDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLDATA, 0) +} + +func (s *Regular_idContext) SQLERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLERROR, 0) +} + +func (s *Regular_idContext) SUBTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBTYPE, 0) +} + +func (s *Regular_idContext) T_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserT_LETTER, 0) +} + +func (s *Regular_idContext) TIMESTAMP_LTZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TIMESTAMP_TZ_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TIMESTAMP_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) TRIGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGER, 0) +} + +func (s *Regular_idContext) VARCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR, 0) +} + +func (s *Regular_idContext) VARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHAR2, 0) +} + +func (s *Regular_idContext) VARIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIABLE, 0) +} + +func (s *Regular_idContext) WARNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserWARNING, 0) +} + +func (s *Regular_idContext) WHILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHILE, 0) +} + +func (s *Regular_idContext) XMLAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLAGG, 0) +} + +func (s *Regular_idContext) YMINTERVAL_UNCONSTRAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserYMINTERVAL_UNCONSTRAINED, 0) +} + +func (s *Regular_idContext) REGR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_, 0) +} + +func (s *Regular_idContext) VAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_, 0) +} + +func (s *Regular_idContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Regular_idContext) COVAR_() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_, 0) +} + +func (s *Regular_idContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Regular_idContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Regular_idContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterRegular_id(s) + } +} + +func (s *Regular_idContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitRegular_id(s) + } +} + +func (s *Regular_idContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitRegular_id(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Regular_id() (localctx IRegular_idContext) { + localctx = NewRegular_idContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2382, PlSqlParserRULE_regular_id) + p.SetState(20322) + p.GetErrorHandler().Sync(p) + if p.HasError() { + goto errorExit + } + + switch p.GetInterpreter().AdaptivePredict(p.BaseParser, p.GetTokenStream(), 2826, p.GetParserRuleContext()) { + case 1: + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20228) + p.Non_reserved_keywords_pre12c() + } + + case 2: + p.EnterOuterAlt(localctx, 2) + { + p.SetState(20229) + p.Non_reserved_keywords_in_12c() + } + + case 3: + p.EnterOuterAlt(localctx, 3) + { + p.SetState(20230) + p.Match(PlSqlParserREGULAR_ID) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 4: + p.EnterOuterAlt(localctx, 4) + { + p.SetState(20231) + p.Match(PlSqlParserABSENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 5: + p.EnterOuterAlt(localctx, 5) + { + p.SetState(20232) + p.Match(PlSqlParserA_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 6: + p.EnterOuterAlt(localctx, 6) + { + p.SetState(20233) + p.Match(PlSqlParserAGENT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 7: + p.EnterOuterAlt(localctx, 7) + { + p.SetState(20234) + p.Match(PlSqlParserAGGREGATE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 8: + p.EnterOuterAlt(localctx, 8) + { + p.SetState(20235) + p.Match(PlSqlParserANALYZE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 9: + p.EnterOuterAlt(localctx, 9) + { + p.SetState(20236) + p.Match(PlSqlParserAUTONOMOUS_TRANSACTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 10: + p.EnterOuterAlt(localctx, 10) + { + p.SetState(20237) + p.Match(PlSqlParserBACKINGFILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 11: + p.EnterOuterAlt(localctx, 11) + { + p.SetState(20238) + p.Match(PlSqlParserBATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 12: + p.EnterOuterAlt(localctx, 12) + { + p.SetState(20239) + p.Match(PlSqlParserBINARY_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 13: + p.EnterOuterAlt(localctx, 13) + { + p.SetState(20240) + p.Match(PlSqlParserBOOLEAN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 14: + p.EnterOuterAlt(localctx, 14) + { + p.SetState(20241) + p.Match(PlSqlParserC_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 15: + p.EnterOuterAlt(localctx, 15) + { + p.SetState(20242) + p.Match(PlSqlParserCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 16: + p.EnterOuterAlt(localctx, 16) + { + p.SetState(20243) + p.Match(PlSqlParserCLUSTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 17: + p.EnterOuterAlt(localctx, 17) + { + p.SetState(20244) + p.Match(PlSqlParserCONSTRUCTOR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 18: + p.EnterOuterAlt(localctx, 18) + { + p.SetState(20245) + p.Match(PlSqlParserCUSTOMDATUM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 19: + p.EnterOuterAlt(localctx, 19) + { + p.SetState(20246) + p.Match(PlSqlParserCASESENSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 20: + p.EnterOuterAlt(localctx, 20) + { + p.SetState(20247) + p.Match(PlSqlParserDECIMAL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 21: + p.EnterOuterAlt(localctx, 21) + { + p.SetState(20248) + p.Match(PlSqlParserDELETE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 22: + p.EnterOuterAlt(localctx, 22) + { + p.SetState(20249) + p.Match(PlSqlParserDETERMINISTIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 23: + p.EnterOuterAlt(localctx, 23) + { + p.SetState(20250) + p.Match(PlSqlParserDSINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 24: + p.EnterOuterAlt(localctx, 24) + { + p.SetState(20251) + p.Match(PlSqlParserE_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 25: + p.EnterOuterAlt(localctx, 25) + { + p.SetState(20252) + p.Match(PlSqlParserERR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 26: + p.EnterOuterAlt(localctx, 26) + { + p.SetState(20253) + p.Match(PlSqlParserEXCEPTION) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 27: + p.EnterOuterAlt(localctx, 27) + { + p.SetState(20254) + p.Match(PlSqlParserEXCEPTION_INIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 28: + p.EnterOuterAlt(localctx, 28) + { + p.SetState(20255) + p.Match(PlSqlParserEXCEPTIONS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 29: + p.EnterOuterAlt(localctx, 29) + { + p.SetState(20256) + p.Match(PlSqlParserEXISTS) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 30: + p.EnterOuterAlt(localctx, 30) + { + p.SetState(20257) + p.Match(PlSqlParserEXIT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 31: + p.EnterOuterAlt(localctx, 31) + { + p.SetState(20258) + p.Match(PlSqlParserFILESTORE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 32: + p.EnterOuterAlt(localctx, 32) + { + p.SetState(20259) + p.Match(PlSqlParserFLOAT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 33: + p.EnterOuterAlt(localctx, 33) + { + p.SetState(20260) + p.Match(PlSqlParserFORALL) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 34: + p.EnterOuterAlt(localctx, 34) + { + p.SetState(20261) + p.Match(PlSqlParserG_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 35: + p.EnterOuterAlt(localctx, 35) + { + p.SetState(20262) + p.Match(PlSqlParserINDICES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 36: + p.EnterOuterAlt(localctx, 36) + { + p.SetState(20263) + p.Match(PlSqlParserINOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 37: + p.EnterOuterAlt(localctx, 37) + { + p.SetState(20264) + p.Match(PlSqlParserINTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 38: + p.EnterOuterAlt(localctx, 38) + { + p.SetState(20265) + p.Match(PlSqlParserJSON_TRANSFORM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 39: + p.EnterOuterAlt(localctx, 39) + { + p.SetState(20266) + p.Match(PlSqlParserK_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 40: + p.EnterOuterAlt(localctx, 40) + { + p.SetState(20267) + p.Match(PlSqlParserLANGUAGE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 41: + p.EnterOuterAlt(localctx, 41) + { + p.SetState(20268) + p.Match(PlSqlParserLONG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 42: + p.EnterOuterAlt(localctx, 42) + { + p.SetState(20269) + p.Match(PlSqlParserLOOP) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 43: + p.EnterOuterAlt(localctx, 43) + { + p.SetState(20270) + p.Match(PlSqlParserMOUNTPOINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 44: + p.EnterOuterAlt(localctx, 44) + { + p.SetState(20271) + p.Match(PlSqlParserM_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 45: + p.EnterOuterAlt(localctx, 45) + { + p.SetState(20272) + p.Match(PlSqlParserMISSING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 46: + p.EnterOuterAlt(localctx, 46) + { + p.SetState(20273) + p.Match(PlSqlParserMISMATCH) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 47: + p.EnterOuterAlt(localctx, 47) + { + p.SetState(20274) + p.Match(PlSqlParserNUMBER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 48: + p.EnterOuterAlt(localctx, 48) + { + p.SetState(20275) + p.Match(PlSqlParserORADATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 49: + p.EnterOuterAlt(localctx, 49) + { + p.SetState(20276) + p.Match(PlSqlParserOSERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 50: + p.EnterOuterAlt(localctx, 50) + { + p.SetState(20277) + p.Match(PlSqlParserOUT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 51: + p.EnterOuterAlt(localctx, 51) + { + p.SetState(20278) + p.Match(PlSqlParserOVERRIDING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 52: + p.EnterOuterAlt(localctx, 52) + { + p.SetState(20279) + p.Match(PlSqlParserP_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 53: + p.EnterOuterAlt(localctx, 53) + { + p.SetState(20280) + p.Match(PlSqlParserPARALLEL_ENABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 54: + p.EnterOuterAlt(localctx, 54) + { + p.SetState(20281) + p.Match(PlSqlParserPIPELINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 55: + p.EnterOuterAlt(localctx, 55) + { + p.SetState(20282) + p.Match(PlSqlParserPLS_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 56: + p.EnterOuterAlt(localctx, 56) + { + p.SetState(20283) + p.Match(PlSqlParserPMEM) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 57: + p.EnterOuterAlt(localctx, 57) + { + p.SetState(20284) + p.Match(PlSqlParserPOSITIVE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 58: + p.EnterOuterAlt(localctx, 58) + { + p.SetState(20285) + p.Match(PlSqlParserPOSITIVEN) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 59: + p.EnterOuterAlt(localctx, 59) + { + p.SetState(20286) + p.Match(PlSqlParserPRAGMA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 60: + p.EnterOuterAlt(localctx, 60) + { + p.SetState(20287) + p.Match(PlSqlParserPUBLIC) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 61: + p.EnterOuterAlt(localctx, 61) + { + p.SetState(20288) + p.Match(PlSqlParserRAISE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 62: + p.EnterOuterAlt(localctx, 62) + { + p.SetState(20289) + p.Match(PlSqlParserRAW) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 63: + p.EnterOuterAlt(localctx, 63) + { + p.SetState(20290) + p.Match(PlSqlParserRECORD) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 64: + p.EnterOuterAlt(localctx, 64) + { + p.SetState(20291) + p.Match(PlSqlParserREF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 65: + p.EnterOuterAlt(localctx, 65) + { + p.SetState(20292) + p.Match(PlSqlParserRENAME) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 66: + p.EnterOuterAlt(localctx, 66) + { + p.SetState(20293) + p.Match(PlSqlParserRESTRICT_REFERENCES) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 67: + p.EnterOuterAlt(localctx, 67) + { + p.SetState(20294) + p.Match(PlSqlParserRESULT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 68: + p.EnterOuterAlt(localctx, 68) + { + p.SetState(20295) + p.Match(PlSqlParserSDO_GEOMETRY) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 69: + p.EnterOuterAlt(localctx, 69) + { + p.SetState(20296) + p.Match(PlSqlParserSELF) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 70: + p.EnterOuterAlt(localctx, 70) + { + p.SetState(20297) + p.Match(PlSqlParserSERIALLY_REUSABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 71: + p.EnterOuterAlt(localctx, 71) + { + p.SetState(20298) + p.Match(PlSqlParserSET) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 72: + p.EnterOuterAlt(localctx, 72) + { + p.SetState(20299) + p.Match(PlSqlParserSHARDSPACE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 73: + p.EnterOuterAlt(localctx, 73) + { + p.SetState(20300) + p.Match(PlSqlParserSIGNTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 74: + p.EnterOuterAlt(localctx, 74) + { + p.SetState(20301) + p.Match(PlSqlParserSIMPLE_INTEGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 75: + p.EnterOuterAlt(localctx, 75) + { + p.SetState(20302) + p.Match(PlSqlParserSMALLINT) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 76: + p.EnterOuterAlt(localctx, 76) + { + p.SetState(20303) + p.Match(PlSqlParserSQLDATA) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 77: + p.EnterOuterAlt(localctx, 77) + { + p.SetState(20304) + p.Match(PlSqlParserSQLERROR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 78: + p.EnterOuterAlt(localctx, 78) + { + p.SetState(20305) + p.Match(PlSqlParserSUBTYPE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 79: + p.EnterOuterAlt(localctx, 79) + { + p.SetState(20306) + p.Match(PlSqlParserT_LETTER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 80: + p.EnterOuterAlt(localctx, 80) + { + p.SetState(20307) + p.Match(PlSqlParserTIMESTAMP_LTZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 81: + p.EnterOuterAlt(localctx, 81) + { + p.SetState(20308) + p.Match(PlSqlParserTIMESTAMP_TZ_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 82: + p.EnterOuterAlt(localctx, 82) + { + p.SetState(20309) + p.Match(PlSqlParserTIMESTAMP_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 83: + p.EnterOuterAlt(localctx, 83) + { + p.SetState(20310) + p.Match(PlSqlParserTRIGGER) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 84: + p.EnterOuterAlt(localctx, 84) + { + p.SetState(20311) + p.Match(PlSqlParserVARCHAR) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 85: + p.EnterOuterAlt(localctx, 85) + { + p.SetState(20312) + p.Match(PlSqlParserVARCHAR2) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 86: + p.EnterOuterAlt(localctx, 86) + { + p.SetState(20313) + p.Match(PlSqlParserVARIABLE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 87: + p.EnterOuterAlt(localctx, 87) + { + p.SetState(20314) + p.Match(PlSqlParserWARNING) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 88: + p.EnterOuterAlt(localctx, 88) + { + p.SetState(20315) + p.Match(PlSqlParserWHILE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 89: + p.EnterOuterAlt(localctx, 89) + { + p.SetState(20316) + p.Match(PlSqlParserXMLAGG) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 90: + p.EnterOuterAlt(localctx, 90) + { + p.SetState(20317) + p.Match(PlSqlParserYMINTERVAL_UNCONSTRAINED) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 91: + p.EnterOuterAlt(localctx, 91) + { + p.SetState(20318) + p.Match(PlSqlParserREGR_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 92: + p.EnterOuterAlt(localctx, 92) + { + p.SetState(20319) + p.Match(PlSqlParserVAR_) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 93: + p.EnterOuterAlt(localctx, 93) + { + p.SetState(20320) + p.Match(PlSqlParserVALUE) + if p.HasError() { + // Recognition error - abort rule + goto errorExit + } + } + + case 94: + p.EnterOuterAlt(localctx, 94) + { + p.SetState(20321) + p.Match(PlSqlParserCOVAR_) + 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 +} + +// INon_reserved_keywords_in_12cContext is an interface to support dynamic dispatch. +type INon_reserved_keywords_in_12cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ACL() antlr.TerminalNode + ACROSS() antlr.TerminalNode + ACTION() antlr.TerminalNode + ACTIONS() antlr.TerminalNode + ACTIVE() antlr.TerminalNode + ACTIVE_DATA() antlr.TerminalNode + ACTIVITY() antlr.TerminalNode + ADAPTIVE_PLAN() antlr.TerminalNode + ADVANCED() antlr.TerminalNode + AFD_DISKSTRING() antlr.TerminalNode + ALTERNATE() antlr.TerminalNode + ALGORITHM() antlr.TerminalNode + ANALYTIC() antlr.TerminalNode + ANCESTOR() antlr.TerminalNode + ANOMALY() antlr.TerminalNode + ANSI_REARCH() antlr.TerminalNode + APPLICATION() antlr.TerminalNode + APPROX_COUNT_DISTINCT() antlr.TerminalNode + ARCHIVAL() antlr.TerminalNode + ARCHIVED() antlr.TerminalNode + ASIS() antlr.TerminalNode + ASSIGN() antlr.TerminalNode + AUTO_LOGIN() antlr.TerminalNode + AUTO_REOPTIMIZE() antlr.TerminalNode + AVRO() antlr.TerminalNode + BACKGROUND() antlr.TerminalNode + BACKUPS() antlr.TerminalNode + BATCHSIZE() antlr.TerminalNode + BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode + BEGINNING() antlr.TerminalNode + BEQUEATH() antlr.TerminalNode + BITMAP_AND() antlr.TerminalNode + BLOCKCHAIN() antlr.TerminalNode + BSON() antlr.TerminalNode + CACHING() antlr.TerminalNode + CALCULATED() antlr.TerminalNode + CALLBACK() antlr.TerminalNode + CAPACITY() antlr.TerminalNode + CAPTION() antlr.TerminalNode + CDBDEFAULT() antlr.TerminalNode + CLASSIFICATION() antlr.TerminalNode + CLASSIFIER() antlr.TerminalNode + CLAUSE() antlr.TerminalNode + CLEAN() antlr.TerminalNode + CLEANUP() antlr.TerminalNode + CLIENT() antlr.TerminalNode + CLUSTERING() antlr.TerminalNode + CLUSTER_DETAILS() antlr.TerminalNode + CLUSTER_DISTANCE() antlr.TerminalNode + COLLATE() antlr.TerminalNode + COLLATION() antlr.TerminalNode + COMMON() antlr.TerminalNode + COMMON_DATA() antlr.TerminalNode + COMPONENT() antlr.TerminalNode + COMPONENTS() antlr.TerminalNode + CONDITION() antlr.TerminalNode + CONDITIONAL() antlr.TerminalNode + CONTAINERS() antlr.TerminalNode + CONTAINERS_DEFAULT() antlr.TerminalNode + CONTAINER_DATA() antlr.TerminalNode + CONTAINER_MAP() antlr.TerminalNode + CONVERSION() antlr.TerminalNode + CON_DBID_TO_ID() antlr.TerminalNode + CON_GUID_TO_ID() antlr.TerminalNode + CON_ID() antlr.TerminalNode + CON_NAME_TO_ID() antlr.TerminalNode + CON_UID_TO_ID() antlr.TerminalNode + COOKIE() antlr.TerminalNode + COPY() antlr.TerminalNode + CREATE_FILE_DEST() antlr.TerminalNode + CREDENTIAL() antlr.TerminalNode + CRITICAL() antlr.TerminalNode + CUBE_AJ() antlr.TerminalNode + CUBE_SJ() antlr.TerminalNode + DATAMOVEMENT() antlr.TerminalNode + DATAOBJ_TO_MAT_PARTITION() antlr.TerminalNode + DATAPUMP() antlr.TerminalNode + DATA_SECURITY_REWRITE_LIMIT() antlr.TerminalNode + DAYS() antlr.TerminalNode + DB_UNIQUE_NAME() antlr.TerminalNode + DECORRELATE() antlr.TerminalNode + DEFAULT_CREDENTIAL() antlr.TerminalNode + DEFAULT_COLLATION() antlr.TerminalNode + DEFINE() antlr.TerminalNode + DEFINITION() antlr.TerminalNode + DELEGATE() antlr.TerminalNode + DELETE_ALL() antlr.TerminalNode + DESCRIPTION() antlr.TerminalNode + DESTROY() antlr.TerminalNode + DIMENSIONS() antlr.TerminalNode + DISABLE_ALL() antlr.TerminalNode + DISABLE_PARALLEL_DML() antlr.TerminalNode + DISCARD() antlr.TerminalNode + DISTRIBUTE() antlr.TerminalNode + DUPLICATE() antlr.TerminalNode + DUPLICATED() antlr.TerminalNode + DV() antlr.TerminalNode + EDITIONABLE() antlr.TerminalNode + ELIM_GROUPBY() antlr.TerminalNode + EM() antlr.TerminalNode + ENABLE_ALL() antlr.TerminalNode + ENABLE_PARALLEL_DML() antlr.TerminalNode + EQUIPART() antlr.TerminalNode + EVAL() antlr.TerminalNode + EVALUATE() antlr.TerminalNode + EXISTING() antlr.TerminalNode + EXPRESS() antlr.TerminalNode + EXTENDED() antlr.TerminalNode + EXTRACTCLOBXML() antlr.TerminalNode + FACTOR() antlr.TerminalNode + FAILOVER() antlr.TerminalNode + FAILURE() antlr.TerminalNode + FAMILY() antlr.TerminalNode + FAR() antlr.TerminalNode + FASTSTART() antlr.TerminalNode + FEATURE() antlr.TerminalNode + FEATURE_DETAILS() antlr.TerminalNode + FETCH() antlr.TerminalNode + FILE_NAME_CONVERT() antlr.TerminalNode + FILEGROUP() antlr.TerminalNode + FIXED_VIEW_DATA() antlr.TerminalNode + FLEX() antlr.TerminalNode + FORMAT() antlr.TerminalNode + FTP() antlr.TerminalNode + GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode + GET() antlr.TerminalNode + HALF_YEARS() antlr.TerminalNode + HASHING() antlr.TerminalNode + HIER_ORDER() antlr.TerminalNode + HIERARCHICAL() antlr.TerminalNode + HOURS() antlr.TerminalNode + HTTP() antlr.TerminalNode + H_LETTER() antlr.TerminalNode + IDLE() antlr.TerminalNode + ILM() antlr.TerminalNode + IMMUTABLE() antlr.TerminalNode + INACTIVE() antlr.TerminalNode + INACTIVE_ACCOUNT_TIME() antlr.TerminalNode + INDEXING() antlr.TerminalNode + INHERIT() antlr.TerminalNode + INMEMORY() antlr.TerminalNode + INMEMORY_PRUNING() antlr.TerminalNode + INPLACE() antlr.TerminalNode + INTERLEAVED() antlr.TerminalNode + ISOLATE() antlr.TerminalNode + IS_LEAF() antlr.TerminalNode + JSON() antlr.TerminalNode + JSONGET() antlr.TerminalNode + JSONPARSE() antlr.TerminalNode + JSON_ARRAY() antlr.TerminalNode + JSON_ARRAYAGG() antlr.TerminalNode + JSON_EQUAL() antlr.TerminalNode + JSON_EXISTS() antlr.TerminalNode + JSON_EXISTS2() antlr.TerminalNode + JSON_OBJECT() antlr.TerminalNode + JSON_OBJECTAGG() antlr.TerminalNode + JSON_QUERY() antlr.TerminalNode + JSON_SERIALIZE() antlr.TerminalNode + JSON_TABLE() antlr.TerminalNode + JSON_TEXTCONTAINS() antlr.TerminalNode + JSON_TEXTCONTAINS2() antlr.TerminalNode + JSON_VALUE() antlr.TerminalNode + KEYSTORE() antlr.TerminalNode + LABEL() antlr.TerminalNode + LAX() antlr.TerminalNode + LEAD_CDB() antlr.TerminalNode + LEAD_CDB_URI() antlr.TerminalNode + LEVEL_NAME() antlr.TerminalNode + LIFECYCLE() antlr.TerminalNode + LINEAR() antlr.TerminalNode + LOCKDOWN() antlr.TerminalNode + LOCKING() antlr.TerminalNode + LOGMINING() antlr.TerminalNode + LOST() antlr.TerminalNode + MANDATORY() antlr.TerminalNode + MAP() antlr.TerminalNode + MATCH() antlr.TerminalNode + MATCHES() antlr.TerminalNode + MATCH_NUMBER() antlr.TerminalNode + MATCH_RECOGNIZE() antlr.TerminalNode + MAX_SHARED_TEMP_SIZE() antlr.TerminalNode + MEMCOMPRESS() antlr.TerminalNode + METADATA() antlr.TerminalNode + MEMBER_CAPTION() antlr.TerminalNode + MEMBER_DESCRIPTION() antlr.TerminalNode + MEMBER_NAME() antlr.TerminalNode + MEMBER_UNIQUE_NAME() antlr.TerminalNode + MEMOPTIMIZE() antlr.TerminalNode + MINUTES() antlr.TerminalNode + MODEL_NB() antlr.TerminalNode + MODEL_SV() antlr.TerminalNode + MODIFICATION() antlr.TerminalNode + MODULE() antlr.TerminalNode + MONTHS() antlr.TerminalNode + MULTIDIMENSIONAL() antlr.TerminalNode + NEG() antlr.TerminalNode + NOCOPY() antlr.TerminalNode + NOKEEP() antlr.TerminalNode + NONEDITIONABLE() antlr.TerminalNode + NOPARTITION() antlr.TerminalNode + NORELOCATE() antlr.TerminalNode + NOREPLAY() antlr.TerminalNode + NO_ADAPTIVE_PLAN() antlr.TerminalNode + NO_ANSI_REARCH() antlr.TerminalNode + NO_AUTO_REOPTIMIZE() antlr.TerminalNode + NO_BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode + NO_CLUSTERING() antlr.TerminalNode + NO_COMMON_DATA() antlr.TerminalNode + NO_DATA_SECURITY_REWRITE() antlr.TerminalNode + NO_DECORRELATE() antlr.TerminalNode + NO_ELIM_GROUPBY() antlr.TerminalNode + NO_GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode + NO_INMEMORY() antlr.TerminalNode + NO_INMEMORY_PRUNING() antlr.TerminalNode + NO_OBJECT_LINK() antlr.TerminalNode + NO_PARTIAL_JOIN() antlr.TerminalNode + NO_PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode + NO_PQ_CONCURRENT_UNION() antlr.TerminalNode + NO_PQ_REPLICATE() antlr.TerminalNode + NO_PQ_SKEW() antlr.TerminalNode + NOPROMPT() antlr.TerminalNode + NO_PX_FAULT_TOLERANCE() antlr.TerminalNode + NO_ROOT_SW_FOR_LOCAL() antlr.TerminalNode + NO_SQL_TRANSLATION() antlr.TerminalNode + NO_USE_CUBE() antlr.TerminalNode + NO_USE_VECTOR_AGGREGATION() antlr.TerminalNode + NO_VECTOR_TRANSFORM() antlr.TerminalNode + NO_VECTOR_TRANSFORM_DIMS() antlr.TerminalNode + NO_VECTOR_TRANSFORM_FACT() antlr.TerminalNode + NO_ZONEMAP() antlr.TerminalNode + OBJ_ID() antlr.TerminalNode + OFFSET() antlr.TerminalNode + OLS() antlr.TerminalNode + OMIT() antlr.TerminalNode + ONE() antlr.TerminalNode + ORACLE_DATAPUMP() antlr.TerminalNode + ORACLE_HDFS() antlr.TerminalNode + ORACLE_HIVE() antlr.TerminalNode + ORACLE_LOADER() antlr.TerminalNode + ORA_CHECK_ACL() antlr.TerminalNode + ORA_CHECK_PRIVILEGE() antlr.TerminalNode + ORA_CLUSTERING() antlr.TerminalNode + ORA_INVOKING_USER() antlr.TerminalNode + ORA_INVOKING_USERID() antlr.TerminalNode + ORA_INVOKING_XS_USER() antlr.TerminalNode + ORA_INVOKING_XS_USER_GUID() antlr.TerminalNode + ORA_RAWCOMPARE() antlr.TerminalNode + ORA_RAWCONCAT() antlr.TerminalNode + ORA_WRITE_TIME() antlr.TerminalNode + PARENT_LEVEL_NAME() antlr.TerminalNode + PARENT_UNIQUE_NAME() antlr.TerminalNode + PASSWORD_ROLLOVER_TIME() antlr.TerminalNode + PARTIAL() antlr.TerminalNode + PARTIAL_JOIN() antlr.TerminalNode + PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode + PAST() antlr.TerminalNode + PATCH() antlr.TerminalNode + PATH_PREFIX() antlr.TerminalNode + PATTERN() antlr.TerminalNode + PER() antlr.TerminalNode + PERIOD() antlr.TerminalNode + PERIOD_KEYWORD() antlr.TerminalNode + PERMUTE() antlr.TerminalNode + PLUGGABLE() antlr.TerminalNode + POOL_16K() antlr.TerminalNode + POOL_2K() antlr.TerminalNode + POOL_32K() antlr.TerminalNode + POOL_4K() antlr.TerminalNode + POOL_8K() antlr.TerminalNode + PQ_CONCURRENT_UNION() antlr.TerminalNode + PQ_DISTRIBUTE_WINDOW() antlr.TerminalNode + PQ_FILTER() antlr.TerminalNode + PQ_REPLICATE() antlr.TerminalNode + PQ_SKEW() antlr.TerminalNode + PRELOAD() antlr.TerminalNode + PRETTY() antlr.TerminalNode + PREV() antlr.TerminalNode + PRINTBLOBTOCLOB() antlr.TerminalNode + PRIORITY() antlr.TerminalNode + PRIVILEGED() antlr.TerminalNode + PROPERTY() antlr.TerminalNode + PROTOCOL() antlr.TerminalNode + PROXY() antlr.TerminalNode + PRUNING() antlr.TerminalNode + PX_FAULT_TOLERANCE() antlr.TerminalNode + QUARTERS() antlr.TerminalNode + QUOTAGROUP() antlr.TerminalNode + REALM() antlr.TerminalNode + REDEFINE() antlr.TerminalNode + RELOCATE() antlr.TerminalNode + REMOTE() antlr.TerminalNode + RESTART() antlr.TerminalNode + ROLESET() antlr.TerminalNode + ROWID_MAPPING_TABLE() antlr.TerminalNode + RUNNING() antlr.TerminalNode + SAVE() antlr.TerminalNode + SCRUB() antlr.TerminalNode + SDO_GEOM_MBR() antlr.TerminalNode + SECONDS() antlr.TerminalNode + SECRET() antlr.TerminalNode + SERIAL() antlr.TerminalNode + SERVICES() antlr.TerminalNode + SERVICE_NAME_CONVERT() antlr.TerminalNode + SHARDED() antlr.TerminalNode + SHARING() antlr.TerminalNode + SHELFLIFE() antlr.TerminalNode + SITE() antlr.TerminalNode + SOURCE_FILE_DIRECTORY() antlr.TerminalNode + SOURCE_FILE_NAME_CONVERT() antlr.TerminalNode + SQL_TRANSLATION_PROFILE() antlr.TerminalNode + STANDARD() antlr.TerminalNode + STANDARD_HASH() antlr.TerminalNode + STANDBYS() antlr.TerminalNode + STATE() antlr.TerminalNode + STATEMENT() antlr.TerminalNode + STREAM() antlr.TerminalNode + SUBSCRIBE() antlr.TerminalNode + SUBSET() antlr.TerminalNode + SUCCESS() antlr.TerminalNode + SYS() antlr.TerminalNode + SYSBACKUP() antlr.TerminalNode + SYSDG() antlr.TerminalNode + SYSGUID() antlr.TerminalNode + SYSKM() antlr.TerminalNode + SYSOBJ() antlr.TerminalNode + SYS_CHECK_PRIVILEGE() antlr.TerminalNode + SYS_GET_COL_ACLIDS() antlr.TerminalNode + SYS_MKXTI() antlr.TerminalNode + SYS_OP_CYCLED_SEQ() antlr.TerminalNode + SYS_OP_HASH() antlr.TerminalNode + SYS_OP_KEY_VECTOR_CREATE() antlr.TerminalNode + SYS_OP_KEY_VECTOR_FILTER() antlr.TerminalNode + SYS_OP_KEY_VECTOR_FILTER_LIST() antlr.TerminalNode + SYS_OP_KEY_VECTOR_SUCCEEDED() antlr.TerminalNode + SYS_OP_KEY_VECTOR_USE() antlr.TerminalNode + SYS_OP_PART_ID() antlr.TerminalNode + SYS_OP_ZONE_ID() antlr.TerminalNode + SYS_RAW_TO_XSID() antlr.TerminalNode + SYS_XSID_TO_RAW() antlr.TerminalNode + SYS_ZMAP_FILTER() antlr.TerminalNode + SYS_ZMAP_REFRESH() antlr.TerminalNode + TAG() antlr.TerminalNode + TEXT() antlr.TerminalNode + TIER() antlr.TerminalNode + TIES() antlr.TerminalNode + TO_ACLID() antlr.TerminalNode + TRANSFORM() antlr.TerminalNode + TRANSLATION() antlr.TerminalNode + TRUST() antlr.TerminalNode + UCS2() antlr.TerminalNode + UNCONDITIONAL() antlr.TerminalNode + UNITE() antlr.TerminalNode + UNMATCHED() antlr.TerminalNode + UNPLUG() antlr.TerminalNode + UNSUBSCRIBE() antlr.TerminalNode + USABLE() antlr.TerminalNode + USER_DATA() antlr.TerminalNode + USER_TABLESPACES() antlr.TerminalNode + USE_CUBE() antlr.TerminalNode + USE_HIDDEN_PARTITIONS() antlr.TerminalNode + USE_VECTOR_AGGREGATION() antlr.TerminalNode + USING_NO_EXPAND() antlr.TerminalNode + UTF16BE() antlr.TerminalNode + UTF16LE() antlr.TerminalNode + UTF32() antlr.TerminalNode + UTF8() antlr.TerminalNode + V1() antlr.TerminalNode + V2() antlr.TerminalNode + VALIDATE_CONVERSION() antlr.TerminalNode + VALID_TIME_END() antlr.TerminalNode + VECTOR_TRANSFORM() antlr.TerminalNode + VECTOR_TRANSFORM_DIMS() antlr.TerminalNode + VECTOR_TRANSFORM_FACT() antlr.TerminalNode + VERIFIER() antlr.TerminalNode + VIOLATION() antlr.TerminalNode + VISIBILITY() antlr.TerminalNode + WEEK() antlr.TerminalNode + WEEKS() antlr.TerminalNode + WITH_PLSQL() antlr.TerminalNode + WRAPPER() antlr.TerminalNode + XS() antlr.TerminalNode + YEARS() antlr.TerminalNode + ZONEMAP() antlr.TerminalNode + DEFAULTIF() antlr.TerminalNode + LLS() antlr.TerminalNode + ENCLOSED() antlr.TerminalNode + TERMINATED() antlr.TerminalNode + OPTIONALLY() antlr.TerminalNode + LRTRIM() antlr.TerminalNode + NOTRIM() antlr.TerminalNode + LDRTRIM() antlr.TerminalNode + DATE_FORMAT() antlr.TerminalNode + MASK() antlr.TerminalNode + TRANSFORMS() antlr.TerminalNode + LOBFILE() antlr.TerminalNode + STARTOF() antlr.TerminalNode + CHARACTERSET() antlr.TerminalNode + RECORDS() antlr.TerminalNode + FIXED() antlr.TerminalNode + DELIMITED() antlr.TerminalNode + XMLTAG() antlr.TerminalNode + PREPROCESSOR() antlr.TerminalNode + TERRITORY() antlr.TerminalNode + LITTLE() antlr.TerminalNode + BIG() antlr.TerminalNode + ENDIAN() antlr.TerminalNode + BYTEORDERMARK() antlr.TerminalNode + NOCHECK() antlr.TerminalNode + SIZES() antlr.TerminalNode + ARE() antlr.TerminalNode + BYTES() antlr.TerminalNode + CHARACTERS() antlr.TerminalNode + READSIZE() antlr.TerminalNode + DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode + DATE_CACHE() antlr.TerminalNode + FIELD_NAMES() antlr.TerminalNode + FILES() antlr.TerminalNode + IO_OPTIONS() antlr.TerminalNode + DIRECTIO() antlr.TerminalNode + NODIRECTIO() antlr.TerminalNode + DNFS_ENABLE() antlr.TerminalNode + DNFS_DISABLE() antlr.TerminalNode + DNFS_READBUFFERS() antlr.TerminalNode + NOBADFILE() antlr.TerminalNode + BADFILE() antlr.TerminalNode + NODISCARDFILE() antlr.TerminalNode + DISCARDFILE() antlr.TerminalNode + NOLOGFILE() antlr.TerminalNode + FIELDS() antlr.TerminalNode + IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode + CSV() antlr.TerminalNode + EMBEDDED() antlr.TerminalNode + OVERRIDE() antlr.TerminalNode + THESE() antlr.TerminalNode + FIELD() antlr.TerminalNode + NONULLIF() antlr.TerminalNode + POSITION() antlr.TerminalNode + NEWLINE_() antlr.TerminalNode + DETECTED() antlr.TerminalNode + UNSIGNED() antlr.TerminalNode + ZONED() antlr.TerminalNode + ORACLE_DATE() antlr.TerminalNode + ORACLE_NUMBER() antlr.TerminalNode + COUNTED() antlr.TerminalNode + VARRAW() antlr.TerminalNode + VARCHARC() antlr.TerminalNode + VARRAWC() antlr.TerminalNode + + // IsNon_reserved_keywords_in_12cContext differentiates from other interfaces. + IsNon_reserved_keywords_in_12cContext() +} + +type Non_reserved_keywords_in_12cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_keywords_in_12cContext() *Non_reserved_keywords_in_12cContext { + var p = new(Non_reserved_keywords_in_12cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c + return p +} + +func InitEmptyNon_reserved_keywords_in_12cContext(p *Non_reserved_keywords_in_12cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c +} + +func (*Non_reserved_keywords_in_12cContext) IsNon_reserved_keywords_in_12cContext() {} + +func NewNon_reserved_keywords_in_12cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_keywords_in_12cContext { + var p = new(Non_reserved_keywords_in_12cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_in_12c + + return p +} + +func (s *Non_reserved_keywords_in_12cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_keywords_in_12cContext) ACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserACL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACROSS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ACTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ADAPTIVE_PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADAPTIVE_PLAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ADVANCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVANCED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AFD_DISKSTRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFD_DISKSTRING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ALTERNATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALTERNATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ALGORITHM() antlr.TerminalNode { + return s.GetToken(PlSqlParserALGORITHM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANALYTIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYTIC, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANCESTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCESTOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANOMALY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANOMALY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ANSI_REARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserANSI_REARCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) APPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) APPROX_COUNT_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPROX_COUNT_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ARCHIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ASIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASIS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ASSIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSIGN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AUTO_LOGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_LOGIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AUTO_REOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO_REOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) AVRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVRO, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BACKGROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKGROUND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BACKUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUPS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BATCHSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCHSIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH_TABLE_ACCESS_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BEGINNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGINNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BEQUEATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEQUEATH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BITMAP_AND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP_AND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BLOCKCHAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKCHAIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserBSON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CACHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CALCULATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALCULATED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CALLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALLBACK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CAPACITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPACITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CDBDEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCDBDEFAULT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLASSIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLASSIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASSIFIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLAUSE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLEAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLEANUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEANUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLIENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLIENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTER_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_DETAILS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CLUSTER_DISTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_DISTANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COLLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMMON() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMMON_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMON_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COMPONENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPONENTS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONDITIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINERS_DEFAULT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINERS_DEFAULT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONTAINER_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER_MAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERSION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_DBID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_DBID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_GUID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_GUID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_NAME_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_NAME_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CON_UID_TO_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCON_UID_TO_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COOKIE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOOKIE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOPY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CREATE_FILE_DEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE_FILE_DEST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREDENTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CRITICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRITICAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CUBE_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_AJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CUBE_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_SJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAMOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAMOVEMENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAOBJ_TO_MAT_PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJ_TO_MAT_PARTITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAPUMP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATA_SECURITY_REWRITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA_SECURITY_REWRITE_LIMIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DB_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DECORRELATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECORRELATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFAULT_CREDENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_CREDENTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFAULT_COLLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULT_COLLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFINITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DELEGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELEGATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DELETE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESCRIPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DESTROY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDESTROY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DIMENSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISABLE_PARALLEL_DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_PARALLEL_DML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISCARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCARD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DUPLICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUPLICATED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ELIM_GROUPBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIM_GROUPBY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EM() antlr.TerminalNode { + return s.GetToken(PlSqlParserEM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENABLE_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_ALL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENABLE_PARALLEL_DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_PARALLEL_DML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EQUIPART() antlr.TerminalNode { + return s.GetToken(PlSqlParserEQUIPART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EVALUATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXISTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPRESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXTENDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EXTRACTCLOBXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACTCLOBXML, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FACTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACTOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAILOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILOVER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAILURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILURE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAMILY() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAMILY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FASTSTART() antlr.TerminalNode { + return s.GetToken(PlSqlParserFASTSTART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FEATURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FEATURE_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_DETAILS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFETCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FILEGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILEGROUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIXED_VIEW_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIXED_VIEW_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FLEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLEX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORMAT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFTP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGATHER_OPTIMIZER_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GET() antlr.TerminalNode { + return s.GetToken(PlSqlParserGET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HALF_YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHALF_YEARS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HASHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HIER_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIER_ORDER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HIERARCHICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHICAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HOURS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOURS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) HTTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHTTP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) H_LETTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserH_LETTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IDLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ILM() antlr.TerminalNode { + return s.GetToken(PlSqlParserILM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IMMUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMUTABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INACTIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INACTIVE_ACCOUNT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserINACTIVE_ACCOUNT_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INDEXING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INHERIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINHERIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INMEMORY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINMEMORY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINPLACE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) INTERLEAVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERLEAVED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ISOLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IS_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIS_LEAF, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSONGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSONGET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSONPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSONPARSE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_ARRAYAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_ARRAYAGG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EQUAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EXISTS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_EXISTS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_EXISTS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_OBJECTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_OBJECTAGG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_QUERY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_SERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_SERIALIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TEXTCONTAINS() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TEXTCONTAINS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_TEXTCONTAINS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_TEXTCONTAINS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) JSON_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserJSON_VALUE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) KEYSTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSTORE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLABEL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEAD_CDB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEAD_CDB_URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD_CDB_URI, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LIFECYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFECYCLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LINEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINEAR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOCKDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOCKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOGMINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGMINING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MANDATORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANDATORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCHES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH_NUMBER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MATCH_RECOGNIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCH_RECOGNIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MAX_SHARED_TEMP_SIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX_SHARED_TEMP_SIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMCOMPRESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMCOMPRESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETADATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_CAPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_CAPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_DESCRIPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_DESCRIPTION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMBER_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MINUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODEL_NB() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_NB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODEL_SV() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_SV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFICATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MODULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODULE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MULTIDIMENSIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTIDIMENSIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NEG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOCOPY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCOPY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOKEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOKEEP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NONEDITIONABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONEDITIONABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARTITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NORELOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELOCATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOREPLAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPLAY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ADAPTIVE_PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ADAPTIVE_PLAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ANSI_REARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ANSI_REARCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_AUTO_REOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_AUTO_REOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_BATCH_TABLE_ACCESS_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BATCH_TABLE_ACCESS_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_COMMON_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COMMON_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_DATA_SECURITY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DATA_SECURITY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_DECORRELATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DECORRELATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ELIM_GROUPBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIM_GROUPBY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_GATHER_OPTIMIZER_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_GATHER_OPTIMIZER_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_INMEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INMEMORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_INMEMORY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INMEMORY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_OBJECT_LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OBJECT_LINK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PARTIAL_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_JOIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_ROLLUP_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_CONCURRENT_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_CONCURRENT_UNION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_REPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_REPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PQ_SKEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_SKEW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOPROMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPROMPT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_PX_FAULT_TOLERANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PX_FAULT_TOLERANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ROOT_SW_FOR_LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ROOT_SW_FOR_LOCAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_SQL_TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SQL_TRANSLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_USE_CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_CUBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_USE_VECTOR_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_VECTOR_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM_DIMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM_DIMS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_VECTOR_TRANSFORM_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_VECTOR_TRANSFORM_FACT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NO_ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ZONEMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OBJ_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJ_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFSET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOMIT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_DATAPUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATAPUMP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_HDFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HDFS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_HIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_HIVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_LOADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_LOADER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CHECK_ACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CHECK_ACL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CHECK_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CHECK_PRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_CLUSTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_CLUSTERING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_USER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_USERID() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_USERID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_XS_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_XS_USER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_INVOKING_XS_USER_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_INVOKING_XS_USER_GUID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_RAWCOMPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_RAWCOMPARE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_RAWCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_RAWCONCAT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORA_WRITE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_WRITE_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARENT_LEVEL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_LEVEL_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARENT_UNIQUE_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT_UNIQUE_NAME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PASSWORD_ROLLOVER_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_ROLLOVER_TIME, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL_JOIN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PARTIAL_ROLLUP_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIAL_ROLLUP_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPAST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATCH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATH_PREFIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH_PREFIX, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PATTERN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATTERN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERIOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERIOD_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERIOD_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PERMUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMUTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PLUGGABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLUGGABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_16K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_16K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_2K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_2K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_32K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_32K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_4K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_4K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POOL_8K() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOOL_8K, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_CONCURRENT_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_CONCURRENT_UNION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_DISTRIBUTE_WINDOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_DISTRIBUTE_WINDOW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_REPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_REPLICATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PQ_SKEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_SKEW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRELOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRELOAD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRETTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRETTY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PREV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRINTBLOBTOCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRINTBLOBTOCLOB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRIORITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIORITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRIVILEGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROPERTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPERTY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROTOCOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTOCOL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PROXY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROXY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRUNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PX_FAULT_TOLERANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_FAULT_TOLERANCE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) QUARTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUARTERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) QUOTAGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTAGROUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REALM() antlr.TerminalNode { + return s.GetToken(PlSqlParserREALM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REDEFINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDEFINE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RELOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELOCATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) REMOTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RESTART() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTART, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ROLESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLESET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ROWID_MAPPING_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID_MAPPING_TABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RUNNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRUNNING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SAVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SCRUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCRUB, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SDO_GEOM_MBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSDO_GEOM_MBR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SECONDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECONDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SECRET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECRET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERVICES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SERVICE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHARDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHARING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARING, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SHELFLIFE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHELFLIFE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SOURCE_FILE_DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE_FILE_DIRECTORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SOURCE_FILE_NAME_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE_FILE_NAME_CONVERT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SQL_TRANSLATION_PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_TRANSLATION_PROFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDARD_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDARD_HASH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STANDBYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STATEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STREAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTREAM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUBSCRIBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSCRIBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUBSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SUCCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSBACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSBACKUP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSDG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSGUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSGUID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSKM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYSOBJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOBJ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_CHECK_PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CHECK_PRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_GET_COL_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_COL_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_MKXTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MKXTI, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_CYCLED_SEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CYCLED_SEQ, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_HASH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_CREATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_CREATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_FILTER_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_FILTER_LIST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_SUCCEEDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_SUCCEEDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_KEY_VECTOR_USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_KEY_VECTOR_USE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_PART_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PART_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_OP_ZONE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ZONE_ID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_RAW_TO_XSID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_RAW_TO_XSID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_XSID_TO_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XSID_TO_RAW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_ZMAP_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ZMAP_FILTER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SYS_ZMAP_REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ZMAP_REFRESH, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEXT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TO_ACLID() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_ACLID, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRANSLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRUST() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUST, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UCS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserUCS2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNCONDITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNCONDITIONAL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNITE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNMATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNMATCHED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNPLUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPLUG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNSUBSCRIBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSUBSCRIBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USER_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DATA, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USER_TABLESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_TABLESPACES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_CUBE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_HIDDEN_PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HIDDEN_PARTITIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USE_VECTOR_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_VECTOR_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) USING_NO_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING_NO_EXPAND, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF16BE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF16BE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF16LE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF16LE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF32() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF32, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UTF8() antlr.TerminalNode { + return s.GetToken(PlSqlParserUTF8, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) V1() antlr.TerminalNode { + return s.GetToken(PlSqlParserV1, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) V2() antlr.TerminalNode { + return s.GetToken(PlSqlParserV2, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VALIDATE_CONVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE_CONVERSION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VALID_TIME_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALID_TIME_END, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM_DIMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM_DIMS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VECTOR_TRANSFORM_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_TRANSFORM_FACT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VERIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERIFIER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VIOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIOLATION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VISIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBILITY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WEEK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WEEKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserWEEKS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WITH_PLSQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITH_PLSQL, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) WRAPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) XS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) YEARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEARS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ZONEMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONEMAP, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DEFAULTIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTIF, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLLS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENCLOSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCLOSED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TERMINATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERMINATED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OPTIONALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIONALLY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLRTRIM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTRIM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LDRTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDRTRIM, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_FORMAT, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) MASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TRANSFORMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORMS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LOBFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) STARTOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTOF, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERSET, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) RECORDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIXED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DELIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELIMITED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) XMLTAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTAG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) PREPROCESSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPROCESSOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) TERRITORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTERRITORY, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) LITTLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLITTLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BIG() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIG, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ENDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserENDIAN, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BYTEORDERMARK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTEORDERMARK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOCHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCHECK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) SIZES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIZES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BYTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CHARACTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) READSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREADSIZE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISABLE_DIRECTORY_LINK_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_DIRECTORY_LINK_CHECK, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DATE_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_CACHE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIELD_NAMES() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD_NAMES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILES, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IO_OPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIO_OPTIONS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTIO, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NODIRECTIO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODIRECTIO, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DNFS_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_ENABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DNFS_DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_DISABLE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DNFS_READBUFFERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDNFS_READBUFFERS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOBADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOBADFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) BADFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBADFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NODISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODISCARDFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DISCARDFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCARDFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NOLOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGFILE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIELDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELDS, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) IGNORE_CHARS_AFTER_EOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_CHARS_AFTER_EOR, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) CSV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCSV, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) EMBEDDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMBEDDED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) OVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERRIDE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) THESE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHESE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) FIELD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIELD, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NONULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONULLIF, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) POSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOSITION, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) NEWLINE_() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEWLINE_, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) DETECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETECTED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) UNSIGNED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNSIGNED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ZONED() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_DATE, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) ORACLE_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserORACLE_NUMBER, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) COUNTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNTED, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VARRAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAW, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VARCHARC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARCHARC, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) VARRAWC() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAWC, 0) +} + +func (s *Non_reserved_keywords_in_12cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_keywords_in_12cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_keywords_in_12cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_reserved_keywords_in_12c(s) + } +} + +func (s *Non_reserved_keywords_in_12cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_reserved_keywords_in_12c(s) + } +} + +func (s *Non_reserved_keywords_in_12cContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNon_reserved_keywords_in_12c(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Non_reserved_keywords_in_12c() (localctx INon_reserved_keywords_in_12cContext) { + localctx = NewNon_reserved_keywords_in_12cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2384, PlSqlParserRULE_non_reserved_keywords_in_12c) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20324) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&-5472907085768511872) != 0) || ((int64((_la-71)) & ^0x3f) == 0 && ((int64(1)<<(_la-71))&144116438234824709) != 0) || ((int64((_la-145)) & ^0x3f) == 0 && ((int64(1)<<(_la-145))&-4566931496858697727) != 0) || ((int64((_la-210)) & ^0x3f) == 0 && ((int64(1)<<(_la-210))&-2305835071911231487) != 0) || ((int64((_la-274)) & ^0x3f) == 0 && ((int64(1)<<(_la-274))&-6341067650151479487) != 0) || ((int64((_la-338)) & ^0x3f) == 0 && ((int64(1)<<(_la-338))&2919177194323313681) != 0) || ((int64((_la-404)) & ^0x3f) == 0 && ((int64(1)<<(_la-404))&-9221946786116009471) != 0) || ((int64((_la-475)) & ^0x3f) == 0 && ((int64(1)<<(_la-475))&3777219382556557317) != 0) || ((int64((_la-547)) & ^0x3f) == 0 && ((int64(1)<<(_la-547))&18014684125069377) != 0) || ((int64((_la-614)) & ^0x3f) == 0 && ((int64(1)<<(_la-614))&70370388354563) != 0) || ((int64((_la-679)) & ^0x3f) == 0 && ((int64(1)<<(_la-679))&-8972010587665919) != 0) || ((int64((_la-743)) & ^0x3f) == 0 && ((int64(1)<<(_la-743))&2256748425592879) != 0) || ((int64((_la-809)) & ^0x3f) == 0 && ((int64(1)<<(_la-809))&4468134298385516549) != 0) || ((int64((_la-877)) & ^0x3f) == 0 && ((int64(1)<<(_la-877))&35752666728449) != 0) || ((int64((_la-941)) & ^0x3f) == 0 && ((int64(1)<<(_la-941))&361004851770949633) != 0) || ((int64((_la-1006)) & ^0x3f) == 0 && ((int64(1)<<(_la-1006))&9147940509582433) != 0) || ((int64((_la-1070)) & ^0x3f) == 0 && ((int64(1)<<(_la-1070))&-6899514491151039577) != 0) || ((int64((_la-1134)) & ^0x3f) == 0 && ((int64(1)<<(_la-1134))&1008806763480219907) != 0) || ((int64((_la-1202)) & ^0x3f) == 0 && ((int64(1)<<(_la-1202))&3764727813506111) != 0) || ((int64((_la-1267)) & ^0x3f) == 0 && ((int64(1)<<(_la-1267))&-9083478972590718803) != 0) || ((int64((_la-1332)) & ^0x3f) == 0 && ((int64(1)<<(_la-1332))&-9204200401764605901) != 0) || ((int64((_la-1410)) & ^0x3f) == 0 && ((int64(1)<<(_la-1410))&-9223213707180371967) != 0) || ((int64((_la-1495)) & ^0x3f) == 0 && ((int64(1)<<(_la-1495))&-9223345339329413055) != 0) || ((int64((_la-1560)) & ^0x3f) == 0 && ((int64(1)<<(_la-1560))&1153132610856550405) != 0) || ((int64((_la-1624)) & ^0x3f) == 0 && ((int64(1)<<(_la-1624))&72479823682875403) != 0) || ((int64((_la-1690)) & ^0x3f) == 0 && ((int64(1)<<(_la-1690))&-9223368634166931375) != 0) || ((int64((_la-1765)) & ^0x3f) == 0 && ((int64(1)<<(_la-1765))&1152921508901814521) != 0) || _la == PlSqlParserSYS_RAW_TO_XSID || ((int64((_la-1967)) & ^0x3f) == 0 && ((int64(1)<<(_la-1967))&35184574466055) != 0) || ((int64((_la-2036)) & ^0x3f) == 0 && ((int64(1)<<(_la-2036))&-9222791357207142367) != 0) || ((int64((_la-2103)) & ^0x3f) == 0 && ((int64(1)<<(_la-2103))&8444343698458641) != 0) || ((int64((_la-2167)) & ^0x3f) == 0 && ((int64(1)<<(_la-2167))&17827333) != 0) || ((int64((_la-2233)) & ^0x3f) == 0 && ((int64(1)<<(_la-2233))&1125907087482915) != 0) || ((int64((_la-2301)) & ^0x3f) == 0 && ((int64(1)<<(_la-2301))&-1) != 0) || _la == PlSqlParserPERIOD) { + 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_keywords_pre12cContext is an interface to support dynamic dispatch. +type INon_reserved_keywords_pre12cContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + ABORT() antlr.TerminalNode + ABS() antlr.TerminalNode + ACCESSED() antlr.TerminalNode + ACCESS() antlr.TerminalNode + ACCOUNT() antlr.TerminalNode + ACOS() antlr.TerminalNode + ACTIVATE() antlr.TerminalNode + ACTIVE_COMPONENT() antlr.TerminalNode + ACTIVE_FUNCTION() antlr.TerminalNode + ACTIVE_TAG() antlr.TerminalNode + ADD_COLUMN() antlr.TerminalNode + ADD_GROUP() antlr.TerminalNode + ADD_MONTHS() antlr.TerminalNode + ADD() antlr.TerminalNode + ADJ_DATE() antlr.TerminalNode + ADMINISTER() antlr.TerminalNode + ADMINISTRATOR() antlr.TerminalNode + ADMIN() antlr.TerminalNode + ADVISE() antlr.TerminalNode + ADVISOR() antlr.TerminalNode + AFTER() antlr.TerminalNode + ALIAS() antlr.TerminalNode + ALLOCATE() antlr.TerminalNode + ALLOW() antlr.TerminalNode + ALL_ROWS() antlr.TerminalNode + ALWAYS() antlr.TerminalNode + ANALYZE() antlr.TerminalNode + ANCILLARY() antlr.TerminalNode + AND_EQUAL() antlr.TerminalNode + ANTIJOIN() antlr.TerminalNode + ANYSCHEMA() antlr.TerminalNode + APPENDCHILDXML() antlr.TerminalNode + APPEND() antlr.TerminalNode + APPEND_VALUES() antlr.TerminalNode + APPLY() antlr.TerminalNode + ARCHIVELOG() antlr.TerminalNode + ARCHIVE() antlr.TerminalNode + ARRAY() antlr.TerminalNode + ASCII() antlr.TerminalNode + ASCIISTR() antlr.TerminalNode + ASIN() antlr.TerminalNode + ASSEMBLY() antlr.TerminalNode + ASSOCIATE() antlr.TerminalNode + ASYNCHRONOUS() antlr.TerminalNode + ASYNC() antlr.TerminalNode + ATAN2() antlr.TerminalNode + ATAN() antlr.TerminalNode + AT() antlr.TerminalNode + ATTRIBUTE() antlr.TerminalNode + ATTRIBUTES() antlr.TerminalNode + AUTHENTICATED() antlr.TerminalNode + AUTHENTICATION() antlr.TerminalNode + AUTHID() antlr.TerminalNode + AUTHORIZATION() antlr.TerminalNode + AUTOALLOCATE() antlr.TerminalNode + AUTOEXTEND() antlr.TerminalNode + AUTOMATIC() antlr.TerminalNode + AUTO() antlr.TerminalNode + AVAILABILITY() antlr.TerminalNode + AVG() antlr.TerminalNode + BACKUP() antlr.TerminalNode + BASICFILE() antlr.TerminalNode + BASIC() antlr.TerminalNode + BATCH() antlr.TerminalNode + BECOME() antlr.TerminalNode + BEFORE() antlr.TerminalNode + BEGIN() antlr.TerminalNode + BEGIN_OUTLINE_DATA() antlr.TerminalNode + BEHALF() antlr.TerminalNode + BFILE() antlr.TerminalNode + BFILENAME() antlr.TerminalNode + BIGFILE() antlr.TerminalNode + BINARY_DOUBLE_INFINITY() antlr.TerminalNode + BINARY_DOUBLE() antlr.TerminalNode + BINARY_DOUBLE_NAN() antlr.TerminalNode + BINARY_FLOAT_INFINITY() antlr.TerminalNode + BINARY_FLOAT() antlr.TerminalNode + BINARY_FLOAT_NAN() antlr.TerminalNode + BINARY() antlr.TerminalNode + BIND_AWARE() antlr.TerminalNode + BINDING() antlr.TerminalNode + BIN_TO_NUM() antlr.TerminalNode + BITAND() antlr.TerminalNode + BITMAP() antlr.TerminalNode + BITMAPS() antlr.TerminalNode + BITMAP_TREE() antlr.TerminalNode + BITS() antlr.TerminalNode + BLOB() antlr.TerminalNode + BLOCK() antlr.TerminalNode + BLOCK_RANGE() antlr.TerminalNode + BLOCKSIZE() antlr.TerminalNode + BLOCKS() antlr.TerminalNode + BODY() antlr.TerminalNode + BOTH() antlr.TerminalNode + BOUND() antlr.TerminalNode + BRANCH() antlr.TerminalNode + BREADTH() antlr.TerminalNode + BROADCAST() antlr.TerminalNode + BUFFER_CACHE() antlr.TerminalNode + BUFFER() antlr.TerminalNode + BUFFER_POOL() antlr.TerminalNode + BUILD() antlr.TerminalNode + BULK() antlr.TerminalNode + BYPASS_RECURSIVE_CHECK() antlr.TerminalNode + BYPASS_UJVC() antlr.TerminalNode + BYTE() antlr.TerminalNode + CACHE_CB() antlr.TerminalNode + CACHE_INSTANCES() antlr.TerminalNode + CACHE() antlr.TerminalNode + CACHE_TEMP_TABLE() antlr.TerminalNode + CALL() antlr.TerminalNode + CANCEL() antlr.TerminalNode + CARDINALITY() antlr.TerminalNode + CASCADE() antlr.TerminalNode + CASE() antlr.TerminalNode + CAST() antlr.TerminalNode + CATEGORY() antlr.TerminalNode + CEIL() antlr.TerminalNode + CELL_FLASH_CACHE() antlr.TerminalNode + CERTIFICATE() antlr.TerminalNode + CFILE() antlr.TerminalNode + CHAINED() antlr.TerminalNode + CHANGE_DUPKEY_ERROR_INDEX() antlr.TerminalNode + CHANGE() antlr.TerminalNode + CHARACTER() antlr.TerminalNode + CHAR_CS() antlr.TerminalNode + CHARTOROWID() antlr.TerminalNode + CHECK_ACL_REWRITE() antlr.TerminalNode + CHECKPOINT() antlr.TerminalNode + CHILD() antlr.TerminalNode + CHOOSE() antlr.TerminalNode + CHR() antlr.TerminalNode + CHUNK() antlr.TerminalNode + CLASS() antlr.TerminalNode + CLEAR() antlr.TerminalNode + CLOB() antlr.TerminalNode + CLONE() antlr.TerminalNode + CLOSE_CACHED_OPEN_CURSORS() antlr.TerminalNode + CLOSE() antlr.TerminalNode + CLUSTER_BY_ROWID() antlr.TerminalNode + CLUSTER_ID() antlr.TerminalNode + CLUSTERING_FACTOR() antlr.TerminalNode + CLUSTER_PROBABILITY() antlr.TerminalNode + CLUSTER_SET() antlr.TerminalNode + COALESCE() antlr.TerminalNode + COALESCE_SQ() antlr.TerminalNode + COARSE() antlr.TerminalNode + CO_AUTH_IND() antlr.TerminalNode + COLD() antlr.TerminalNode + COLLECT() antlr.TerminalNode + COLUMNAR() antlr.TerminalNode + COLUMN_AUTH_INDICATOR() antlr.TerminalNode + COLUMN() antlr.TerminalNode + COLUMNS() antlr.TerminalNode + COLUMN_STATS() antlr.TerminalNode + COLUMN_VALUE() antlr.TerminalNode + COMMENT() antlr.TerminalNode + COMMIT() antlr.TerminalNode + COMMITTED() antlr.TerminalNode + COMPACT() antlr.TerminalNode + COMPATIBILITY() antlr.TerminalNode + COMPILE() antlr.TerminalNode + COMPLETE() antlr.TerminalNode + COMPLIANCE() antlr.TerminalNode + COMPOSE() antlr.TerminalNode + COMPOSITE_LIMIT() antlr.TerminalNode + COMPOSITE() antlr.TerminalNode + COMPOUND() antlr.TerminalNode + COMPUTE() antlr.TerminalNode + CONCAT() antlr.TerminalNode + CONFIRM() antlr.TerminalNode + CONFORMING() antlr.TerminalNode + CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode + CONNECT_BY_COMBINE_SW() antlr.TerminalNode + CONNECT_BY_COST_BASED() antlr.TerminalNode + CONNECT_BY_ELIM_DUPS() antlr.TerminalNode + CONNECT_BY_FILTERING() antlr.TerminalNode + CONNECT_BY_ISCYCLE() antlr.TerminalNode + CONNECT_BY_ISLEAF() antlr.TerminalNode + CONNECT_BY_ROOT() antlr.TerminalNode + CONNECT_TIME() antlr.TerminalNode + CONSIDER() antlr.TerminalNode + CONSISTENT() antlr.TerminalNode + CONSTANT() antlr.TerminalNode + CONST() antlr.TerminalNode + CONSTRAINT() antlr.TerminalNode + CONSTRAINTS() antlr.TerminalNode + CONTAINER() antlr.TerminalNode + CONTENT() antlr.TerminalNode + CONTENTS() antlr.TerminalNode + CONTEXT() antlr.TerminalNode + CONTINUE() antlr.TerminalNode + CONTROLFILE() antlr.TerminalNode + CONVERT() antlr.TerminalNode + CORR_K() antlr.TerminalNode + CORR() antlr.TerminalNode + CORR_S() antlr.TerminalNode + CORRUPTION() antlr.TerminalNode + CORRUPT_XID_ALL() antlr.TerminalNode + CORRUPT_XID() antlr.TerminalNode + COSH() antlr.TerminalNode + COS() antlr.TerminalNode + COST() antlr.TerminalNode + COST_XML_QUERY_REWRITE() antlr.TerminalNode + COUNT() antlr.TerminalNode + COVAR_POP() antlr.TerminalNode + COVAR_SAMP() antlr.TerminalNode + CPU_COSTING() antlr.TerminalNode + CPU_PER_CALL() antlr.TerminalNode + CPU_PER_SESSION() antlr.TerminalNode + CRASH() antlr.TerminalNode + CREATE_STORED_OUTLINES() antlr.TerminalNode + CREATION() antlr.TerminalNode + CROSSEDITION() antlr.TerminalNode + CROSS() antlr.TerminalNode + CSCONVERT() antlr.TerminalNode + CUBE_GB() antlr.TerminalNode + CUBE() antlr.TerminalNode + CUME_DISTM() antlr.TerminalNode + CUME_DIST() antlr.TerminalNode + CURRENT_DATE() antlr.TerminalNode + CURRENT() antlr.TerminalNode + CURRENT_SCHEMA() antlr.TerminalNode + CURRENT_TIME() antlr.TerminalNode + CURRENT_TIMESTAMP() antlr.TerminalNode + CURRENT_USER() antlr.TerminalNode + CURRENTV() antlr.TerminalNode + CURSOR() antlr.TerminalNode + CURSOR_SHARING_EXACT() antlr.TerminalNode + CURSOR_SPECIFIC_SEGMENT() antlr.TerminalNode + CV() antlr.TerminalNode + CYCLE() antlr.TerminalNode + DANGLING() antlr.TerminalNode + DATABASE() antlr.TerminalNode + DATAFILE() antlr.TerminalNode + DATAFILES() antlr.TerminalNode + DATA() antlr.TerminalNode + DATAOBJNO() antlr.TerminalNode + DATAOBJ_TO_PARTITION() antlr.TerminalNode + DATE_MODE() antlr.TerminalNode + DAY() antlr.TerminalNode + DBA() antlr.TerminalNode + DBA_RECYCLEBIN() antlr.TerminalNode + DBMS_STATS() antlr.TerminalNode + DB_ROLE_CHANGE() antlr.TerminalNode + DBTIMEZONE() antlr.TerminalNode + DB_VERSION() antlr.TerminalNode + DDL() antlr.TerminalNode + DEALLOCATE() antlr.TerminalNode + DEBUGGER() antlr.TerminalNode + DEBUG() antlr.TerminalNode + DEC() antlr.TerminalNode + DECOMPOSE() antlr.TerminalNode + DECREMENT() antlr.TerminalNode + DECR() antlr.TerminalNode + DECRYPT() antlr.TerminalNode + DEDUPLICATE() antlr.TerminalNode + DEFAULTS() antlr.TerminalNode + DEFERRABLE() antlr.TerminalNode + DEFERRED() antlr.TerminalNode + DEFINED() antlr.TerminalNode + DEFINER() antlr.TerminalNode + DEGREE() antlr.TerminalNode + DELAY() antlr.TerminalNode + DELETEXML() antlr.TerminalNode + DEMAND() antlr.TerminalNode + DENSE_RANKM() antlr.TerminalNode + DENSE_RANK() antlr.TerminalNode + DEPENDENT() antlr.TerminalNode + DEPTH() antlr.TerminalNode + DEQUEUE() antlr.TerminalNode + DEREF() antlr.TerminalNode + DEREF_NO_REWRITE() antlr.TerminalNode + DETACHED() antlr.TerminalNode + DETERMINES() antlr.TerminalNode + DICTIONARY() antlr.TerminalNode + DIMENSION() antlr.TerminalNode + DIRECT_LOAD() antlr.TerminalNode + DIRECTORY() antlr.TerminalNode + DIRECT_PATH() antlr.TerminalNode + DISABLE() antlr.TerminalNode + DISABLE_PRESET() antlr.TerminalNode + DISABLE_RPKE() antlr.TerminalNode + DISALLOW() antlr.TerminalNode + DISASSOCIATE() antlr.TerminalNode + DISCONNECT() antlr.TerminalNode + DISKGROUP() antlr.TerminalNode + DISK() antlr.TerminalNode + DISKS() antlr.TerminalNode + DISMOUNT() antlr.TerminalNode + DISTINGUISHED() antlr.TerminalNode + DISTRIBUTED() antlr.TerminalNode + DML() antlr.TerminalNode + DML_UPDATE() antlr.TerminalNode + DOCFIDELITY() antlr.TerminalNode + DOCUMENT() antlr.TerminalNode + DOMAIN_INDEX_FILTER() antlr.TerminalNode + DOMAIN_INDEX_NO_SORT() antlr.TerminalNode + DOMAIN_INDEX_SORT() antlr.TerminalNode + DOUBLE() antlr.TerminalNode + DOWNGRADE() antlr.TerminalNode + DRIVING_SITE() antlr.TerminalNode + DROP_COLUMN() antlr.TerminalNode + DROP_GROUP() antlr.TerminalNode + DST_UPGRADE_INSERT_CONV() antlr.TerminalNode + DUMP() antlr.TerminalNode + DYNAMIC() antlr.TerminalNode + DYNAMIC_SAMPLING_EST_CDN() antlr.TerminalNode + DYNAMIC_SAMPLING() antlr.TerminalNode + EACH() antlr.TerminalNode + EDITIONING() antlr.TerminalNode + EDITION() antlr.TerminalNode + EDITIONS() antlr.TerminalNode + ELEMENT() antlr.TerminalNode + ELIMINATE_JOIN() antlr.TerminalNode + ELIMINATE_OBY() antlr.TerminalNode + ELIMINATE_OUTER_JOIN() antlr.TerminalNode + EMPTY_BLOB() antlr.TerminalNode + EMPTY_CLOB() antlr.TerminalNode + EMPTY() antlr.TerminalNode + ENABLE() antlr.TerminalNode + ENABLE_PRESET() antlr.TerminalNode + ENCODING() antlr.TerminalNode + ENCRYPTION() antlr.TerminalNode + ENCRYPT() antlr.TerminalNode + END_OUTLINE_DATA() antlr.TerminalNode + ENFORCED() antlr.TerminalNode + ENFORCE() antlr.TerminalNode + ENQUEUE() antlr.TerminalNode + ENTERPRISE() antlr.TerminalNode + ENTITYESCAPING() antlr.TerminalNode + ENTRY() antlr.TerminalNode + ERROR_ARGUMENT() antlr.TerminalNode + ERROR() antlr.TerminalNode + ERROR_ON_OVERLAP_TIME() antlr.TerminalNode + ERRORS() antlr.TerminalNode + ESCAPE() antlr.TerminalNode + ESTIMATE() antlr.TerminalNode + EVALNAME() antlr.TerminalNode + EVALUATION() antlr.TerminalNode + EVENTS() antlr.TerminalNode + EVERY() antlr.TerminalNode + EXCEPTIONS() antlr.TerminalNode + EXCEPT() antlr.TerminalNode + EXCHANGE() antlr.TerminalNode + EXCLUDE() antlr.TerminalNode + EXCLUDING() antlr.TerminalNode + EXECUTE() antlr.TerminalNode + EXEMPT() antlr.TerminalNode + EXISTSNODE() antlr.TerminalNode + EXPAND_GSET_TO_UNION() antlr.TerminalNode + EXPAND_TABLE() antlr.TerminalNode + EXPIRE() antlr.TerminalNode + EXPLAIN() antlr.TerminalNode + EXPLOSION() antlr.TerminalNode + EXP() antlr.TerminalNode + EXPORT() antlr.TerminalNode + EXPR_CORR_CHECK() antlr.TerminalNode + EXTENDS() antlr.TerminalNode + EXTENT() antlr.TerminalNode + EXTENTS() antlr.TerminalNode + EXTERNALLY() antlr.TerminalNode + EXTERNAL() antlr.TerminalNode + EXTRACT() antlr.TerminalNode + EXTRACTVALUE() antlr.TerminalNode + EXTRA() antlr.TerminalNode + FACILITY() antlr.TerminalNode + FACT() antlr.TerminalNode + FACTORIZE_JOIN() antlr.TerminalNode + FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode + FAILED() antlr.TerminalNode + FAILGROUP() antlr.TerminalNode + FALSE() antlr.TerminalNode + FAST() antlr.TerminalNode + FBTSCAN() antlr.TerminalNode + FEATURE_ID() antlr.TerminalNode + FEATURE_SET() antlr.TerminalNode + FEATURE_VALUE() antlr.TerminalNode + FILE() antlr.TerminalNode + FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode + FILTER() antlr.TerminalNode + FINAL() antlr.TerminalNode + FINE() antlr.TerminalNode + FINISH() antlr.TerminalNode + FIRSTM() antlr.TerminalNode + FIRST() antlr.TerminalNode + FIRST_ROWS() antlr.TerminalNode + FIRST_VALUE() antlr.TerminalNode + FLAGGER() antlr.TerminalNode + FLASHBACK() antlr.TerminalNode + FLASH_CACHE() antlr.TerminalNode + FLOB() antlr.TerminalNode + FLOOR() antlr.TerminalNode + FLUSH() antlr.TerminalNode + FOLDER() antlr.TerminalNode + FOLLOWING() antlr.TerminalNode + FOLLOWS() antlr.TerminalNode + FORCE() antlr.TerminalNode + FORCE_XML_QUERY_REWRITE() antlr.TerminalNode + FOREIGN() antlr.TerminalNode + FOREVER() antlr.TerminalNode + FORWARD() antlr.TerminalNode + FRAGMENT_NUMBER() antlr.TerminalNode + FREELIST() antlr.TerminalNode + FREELISTS() antlr.TerminalNode + FREEPOOLS() antlr.TerminalNode + FRESH() antlr.TerminalNode + FROM_TZ() antlr.TerminalNode + FULL() antlr.TerminalNode + FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode + FUNCTION() antlr.TerminalNode + FUNCTIONS() antlr.TerminalNode + GATHER_PLAN_STATISTICS() antlr.TerminalNode + GBY_CONC_ROLLUP() antlr.TerminalNode + GBY_PUSHDOWN() antlr.TerminalNode + GENERATED() antlr.TerminalNode + GLOBALLY() antlr.TerminalNode + GLOBAL() antlr.TerminalNode + GLOBAL_NAME() antlr.TerminalNode + GLOBAL_TOPIC_ENABLED() antlr.TerminalNode + GREATEST() antlr.TerminalNode + GROUP_BY() antlr.TerminalNode + GROUP_ID() antlr.TerminalNode + GROUPING_ID() antlr.TerminalNode + GROUPING() antlr.TerminalNode + GROUPS() antlr.TerminalNode + GUARANTEED() antlr.TerminalNode + GUARANTEE() antlr.TerminalNode + GUARD() antlr.TerminalNode + HASH_AJ() antlr.TerminalNode + HASHKEYS() antlr.TerminalNode + HASH() antlr.TerminalNode + HASH_SJ() antlr.TerminalNode + HEADER() antlr.TerminalNode + HEAP() antlr.TerminalNode + HELP() antlr.TerminalNode + HEXTORAW() antlr.TerminalNode + HEXTOREF() antlr.TerminalNode + HIDDEN_KEYWORD() antlr.TerminalNode + HIDE() antlr.TerminalNode + HIERARCHY() antlr.TerminalNode + HIGH() antlr.TerminalNode + HINTSET_BEGIN() antlr.TerminalNode + HINTSET_END() antlr.TerminalNode + HOT() antlr.TerminalNode + HOUR() antlr.TerminalNode + HWM_BROKERED() antlr.TerminalNode + HYBRID() antlr.TerminalNode + IDENTIFIER() antlr.TerminalNode + IDENTITY() antlr.TerminalNode + IDGENERATORS() antlr.TerminalNode + IDLE_TIME() antlr.TerminalNode + ID() antlr.TerminalNode + IF() antlr.TerminalNode + IGNORE() antlr.TerminalNode + IGNORE_OPTIM_EMBEDDED_HINTS() antlr.TerminalNode + IGNORE_ROW_ON_DUPKEY_INDEX() antlr.TerminalNode + IGNORE_WHERE_CLAUSE() antlr.TerminalNode + IMMEDIATE() antlr.TerminalNode + IMPACT() antlr.TerminalNode + IMPORT() antlr.TerminalNode + INCLUDE() antlr.TerminalNode + INCLUDE_VERSION() antlr.TerminalNode + INCLUDING() antlr.TerminalNode + INCREMENTAL() antlr.TerminalNode + INCREMENT() antlr.TerminalNode + INCR() antlr.TerminalNode + INDENT() antlr.TerminalNode + INDEX_ASC() antlr.TerminalNode + INDEX_COMBINE() antlr.TerminalNode + INDEX_DESC() antlr.TerminalNode + INDEXED() antlr.TerminalNode + INDEXES() antlr.TerminalNode + INDEX_FFS() antlr.TerminalNode + INDEX_FILTER() antlr.TerminalNode + INDEX_JOIN() antlr.TerminalNode + INDEX_ROWS() antlr.TerminalNode + INDEX_RRS() antlr.TerminalNode + INDEX_RS_ASC() antlr.TerminalNode + INDEX_RS_DESC() antlr.TerminalNode + INDEX_RS() antlr.TerminalNode + INDEX_SCAN() antlr.TerminalNode + INDEX_SKIP_SCAN() antlr.TerminalNode + INDEX_SS_ASC() antlr.TerminalNode + INDEX_SS_DESC() antlr.TerminalNode + INDEX_SS() antlr.TerminalNode + INDEX_STATS() antlr.TerminalNode + INDEXTYPE() antlr.TerminalNode + INDEXTYPES() antlr.TerminalNode + INDICATOR() antlr.TerminalNode + INFINITE() antlr.TerminalNode + INFORMATIONAL() antlr.TerminalNode + INITCAP() antlr.TerminalNode + INITIALIZED() antlr.TerminalNode + INITIALLY() antlr.TerminalNode + INITIAL() antlr.TerminalNode + INITRANS() antlr.TerminalNode + INLINE() antlr.TerminalNode + INLINE_XMLTYPE_NT() antlr.TerminalNode + IN_MEMORY_METADATA() antlr.TerminalNode + INNER() antlr.TerminalNode + INSERTCHILDXMLAFTER() antlr.TerminalNode + INSERTCHILDXMLBEFORE() antlr.TerminalNode + INSERTCHILDXML() antlr.TerminalNode + INSERTXMLAFTER() antlr.TerminalNode + INSERTXMLBEFORE() antlr.TerminalNode + INSTANCE() antlr.TerminalNode + INSTANCES() antlr.TerminalNode + INSTANTIABLE() antlr.TerminalNode + INSTANTLY() antlr.TerminalNode + INSTEAD() antlr.TerminalNode + INSTR2() antlr.TerminalNode + INSTR4() antlr.TerminalNode + INSTRB() antlr.TerminalNode + INSTRC() antlr.TerminalNode + INSTR() antlr.TerminalNode + INTERMEDIATE() antlr.TerminalNode + INTERNAL_CONVERT() antlr.TerminalNode + INTERNAL_USE() antlr.TerminalNode + INTERPRETED() antlr.TerminalNode + INTERVAL() antlr.TerminalNode + INT() antlr.TerminalNode + INVALIDATE() antlr.TerminalNode + INVISIBLE() antlr.TerminalNode + IN_XQUERY() antlr.TerminalNode + ISOLATION_LEVEL() antlr.TerminalNode + ISOLATION() antlr.TerminalNode + ITERATE() antlr.TerminalNode + ITERATION_NUMBER() antlr.TerminalNode + JAVA() antlr.TerminalNode + JOB() antlr.TerminalNode + JOIN() antlr.TerminalNode + KEEP_DUPLICATES() antlr.TerminalNode + KEEP() antlr.TerminalNode + KERBEROS() antlr.TerminalNode + KEY_LENGTH() antlr.TerminalNode + KEY() antlr.TerminalNode + KEYSIZE() antlr.TerminalNode + KEYS() antlr.TerminalNode + KILL() antlr.TerminalNode + LAG() antlr.TerminalNode + LAST_DAY() antlr.TerminalNode + LAST() antlr.TerminalNode + LAST_VALUE() antlr.TerminalNode + LATERAL() antlr.TerminalNode + LAYER() antlr.TerminalNode + LDAP_REGISTRATION_ENABLED() antlr.TerminalNode + LDAP_REGISTRATION() antlr.TerminalNode + LDAP_REG_SYNC_INTERVAL() antlr.TerminalNode + LEADING() antlr.TerminalNode + LEAD() antlr.TerminalNode + LEAF() antlr.TerminalNode + LEAST() antlr.TerminalNode + LEFT() antlr.TerminalNode + LENGTH2() antlr.TerminalNode + LENGTH4() antlr.TerminalNode + LENGTHB() antlr.TerminalNode + LENGTHC() antlr.TerminalNode + LENGTH() antlr.TerminalNode + LESS() antlr.TerminalNode + LEVEL() antlr.TerminalNode + LEVELS() antlr.TerminalNode + LIBRARY() antlr.TerminalNode + LIFE() antlr.TerminalNode + LIFETIME() antlr.TerminalNode + LIKE2() antlr.TerminalNode + LIKE4() antlr.TerminalNode + LIKEC() antlr.TerminalNode + LIKE_EXPAND() antlr.TerminalNode + LIMIT() antlr.TerminalNode + LINK() antlr.TerminalNode + LISTAGG() antlr.TerminalNode + LIST() antlr.TerminalNode + LN() antlr.TerminalNode + LNNVL() antlr.TerminalNode + LOAD() antlr.TerminalNode + LOB() antlr.TerminalNode + LOBNVL() antlr.TerminalNode + LOBS() antlr.TerminalNode + LOCAL_INDEXES() antlr.TerminalNode + LOCAL() antlr.TerminalNode + LOCALTIME() antlr.TerminalNode + LOCALTIMESTAMP() antlr.TerminalNode + LOCATION() antlr.TerminalNode + LOCATOR() antlr.TerminalNode + LOCKED() antlr.TerminalNode + LOGFILE() antlr.TerminalNode + LOGFILES() antlr.TerminalNode + LOGGING() antlr.TerminalNode + LOGICAL() antlr.TerminalNode + LOGICAL_READS_PER_CALL() antlr.TerminalNode + LOGICAL_READS_PER_SESSION() antlr.TerminalNode + LOG() antlr.TerminalNode + LOGOFF() antlr.TerminalNode + LOGON() antlr.TerminalNode + LOG_READ_ONLY_VIOLATIONS() antlr.TerminalNode + LOWER() antlr.TerminalNode + LOW() antlr.TerminalNode + LPAD() antlr.TerminalNode + LTRIM() antlr.TerminalNode + MAIN() antlr.TerminalNode + MAKE_REF() antlr.TerminalNode + MANAGED() antlr.TerminalNode + MANAGEMENT() antlr.TerminalNode + MANAGE() antlr.TerminalNode + MANAGER() antlr.TerminalNode + MANUAL() antlr.TerminalNode + MAPPING() antlr.TerminalNode + MASTER() antlr.TerminalNode + MATCHED() antlr.TerminalNode + MATERIALIZED() antlr.TerminalNode + MATERIALIZE() antlr.TerminalNode + MAXARCHLOGS() antlr.TerminalNode + MAXDATAFILES() antlr.TerminalNode + MAXEXTENTS() antlr.TerminalNode + MAXIMIZE() antlr.TerminalNode + MAXINSTANCES() antlr.TerminalNode + MAXLOGFILES() antlr.TerminalNode + MAXLOGHISTORY() antlr.TerminalNode + MAXLOGMEMBERS() antlr.TerminalNode + MAX() antlr.TerminalNode + MAXSIZE() antlr.TerminalNode + MAXTRANS() antlr.TerminalNode + MAXVALUE() antlr.TerminalNode + MEASURE() antlr.TerminalNode + MEASURES() antlr.TerminalNode + MEDIAN() antlr.TerminalNode + MEDIUM() antlr.TerminalNode + MEMBER() antlr.TerminalNode + MEMOPTIMIZE() antlr.TerminalNode + MEMORY() antlr.TerminalNode + MERGEACTIONS() antlr.TerminalNode + MERGE_AJ() antlr.TerminalNode + MERGE_CONST_ON() antlr.TerminalNode + MERGE() antlr.TerminalNode + MERGE_SJ() antlr.TerminalNode + METHOD() antlr.TerminalNode + MIGRATE() antlr.TerminalNode + MIGRATION() antlr.TerminalNode + MINEXTENTS() antlr.TerminalNode + MINIMIZE() antlr.TerminalNode + MINIMUM() antlr.TerminalNode + MINING() antlr.TerminalNode + MIN() antlr.TerminalNode + MINUS_NULL() antlr.TerminalNode + MINUTE() antlr.TerminalNode + MINVALUE() antlr.TerminalNode + MIRRORCOLD() antlr.TerminalNode + MIRRORHOT() antlr.TerminalNode + MIRROR() antlr.TerminalNode + MLSLABEL() antlr.TerminalNode + MODEL_COMPILE_SUBQUERY() antlr.TerminalNode + MODEL_DONTVERIFY_UNIQUENESS() antlr.TerminalNode + MODEL_DYNAMIC_SUBQUERY() antlr.TerminalNode + MODEL_MIN_ANALYSIS() antlr.TerminalNode + MODEL() antlr.TerminalNode + MODEL_NO_ANALYSIS() antlr.TerminalNode + MODEL_PBY() antlr.TerminalNode + MODEL_PUSH_REF() antlr.TerminalNode + MODIFY_COLUMN_TYPE() antlr.TerminalNode + MODIFY() antlr.TerminalNode + MOD() antlr.TerminalNode + MONITORING() antlr.TerminalNode + MONITOR() antlr.TerminalNode + MONTH() antlr.TerminalNode + MONTHS_BETWEEN() antlr.TerminalNode + MOUNT() antlr.TerminalNode + MOUNTPATH() antlr.TerminalNode + MOVEMENT() antlr.TerminalNode + MOVE() antlr.TerminalNode + MULTISET() antlr.TerminalNode + MV_MERGE() antlr.TerminalNode + NAMED() antlr.TerminalNode + NAME() antlr.TerminalNode + NAMESPACE() antlr.TerminalNode + NAN() antlr.TerminalNode + NANVL() antlr.TerminalNode + NATIONAL() antlr.TerminalNode + NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode + NATIVE() antlr.TerminalNode + NATURAL() antlr.TerminalNode + NAV() antlr.TerminalNode + NCHAR_CS() antlr.TerminalNode + NCHAR() antlr.TerminalNode + NCHR() antlr.TerminalNode + NCLOB() antlr.TerminalNode + NEEDED() antlr.TerminalNode + NESTED() antlr.TerminalNode + NESTED_TABLE_FAST_INSERT() antlr.TerminalNode + NESTED_TABLE_GET_REFS() antlr.TerminalNode + NESTED_TABLE_ID() antlr.TerminalNode + NESTED_TABLE_SET_REFS() antlr.TerminalNode + NESTED_TABLE_SET_SETID() antlr.TerminalNode + NETWORK() antlr.TerminalNode + NEVER() antlr.TerminalNode + NEW() antlr.TerminalNode + NEW_TIME() antlr.TerminalNode + NEXT_DAY() antlr.TerminalNode + NEXT() antlr.TerminalNode + NL_AJ() antlr.TerminalNode + NLJ_BATCHING() antlr.TerminalNode + NLJ_INDEX_FILTER() antlr.TerminalNode + NLJ_INDEX_SCAN() antlr.TerminalNode + NLJ_PREFETCH() antlr.TerminalNode + NLS_CALENDAR() antlr.TerminalNode + NLS_CHARACTERSET() antlr.TerminalNode + NLS_CHARSET_DECL_LEN() antlr.TerminalNode + NLS_CHARSET_ID() antlr.TerminalNode + NLS_CHARSET_NAME() antlr.TerminalNode + NLS_COMP() antlr.TerminalNode + NLS_CURRENCY() antlr.TerminalNode + NLS_DATE_FORMAT() antlr.TerminalNode + NLS_DATE_LANGUAGE() antlr.TerminalNode + NLS_INITCAP() antlr.TerminalNode + NLS_ISO_CURRENCY() antlr.TerminalNode + NL_SJ() antlr.TerminalNode + NLS_LANG() antlr.TerminalNode + NLS_LANGUAGE() antlr.TerminalNode + NLS_LENGTH_SEMANTICS() antlr.TerminalNode + NLS_LOWER() antlr.TerminalNode + NLS_NCHAR_CONV_EXCP() antlr.TerminalNode + NLS_NUMERIC_CHARACTERS() antlr.TerminalNode + NLS_SORT() antlr.TerminalNode + NLSSORT() antlr.TerminalNode + NLS_SPECIAL_CHARS() antlr.TerminalNode + NLS_TERRITORY() antlr.TerminalNode + NLS_UPPER() antlr.TerminalNode + NO_ACCESS() antlr.TerminalNode + NOAPPEND() antlr.TerminalNode + NOARCHIVELOG() antlr.TerminalNode + NOAUDIT() antlr.TerminalNode + NO_BASETABLE_MULTIMV_REWRITE() antlr.TerminalNode + NO_BIND_AWARE() antlr.TerminalNode + NO_BUFFER() antlr.TerminalNode + NOCACHE() antlr.TerminalNode + NO_CARTESIAN() antlr.TerminalNode + NO_CHECK_ACL_REWRITE() antlr.TerminalNode + NO_CLUSTER_BY_ROWID() antlr.TerminalNode + NO_COALESCE_SQ() antlr.TerminalNode + NO_CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode + NO_CONNECT_BY_COMBINE_SW() antlr.TerminalNode + NO_CONNECT_BY_COST_BASED() antlr.TerminalNode + NO_CONNECT_BY_ELIM_DUPS() antlr.TerminalNode + NO_CONNECT_BY_FILTERING() antlr.TerminalNode + NO_COST_XML_QUERY_REWRITE() antlr.TerminalNode + NO_CPU_COSTING() antlr.TerminalNode + NOCPU_COSTING() antlr.TerminalNode + NOCYCLE() antlr.TerminalNode + NODELAY() antlr.TerminalNode + NO_DOMAIN_INDEX_FILTER() antlr.TerminalNode + NO_DST_UPGRADE_INSERT_CONV() antlr.TerminalNode + NO_ELIMINATE_JOIN() antlr.TerminalNode + NO_ELIMINATE_OBY() antlr.TerminalNode + NO_ELIMINATE_OUTER_JOIN() antlr.TerminalNode + NOENTITYESCAPING() antlr.TerminalNode + NO_EXPAND_GSET_TO_UNION() antlr.TerminalNode + NO_EXPAND() antlr.TerminalNode + NO_EXPAND_TABLE() antlr.TerminalNode + NO_FACT() antlr.TerminalNode + NO_FACTORIZE_JOIN() antlr.TerminalNode + NO_FILTERING() antlr.TerminalNode + NOFORCE() antlr.TerminalNode + NO_FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode + NO_GBY_PUSHDOWN() antlr.TerminalNode + NOGUARANTEE() antlr.TerminalNode + NO_INDEX_FFS() antlr.TerminalNode + NO_INDEX() antlr.TerminalNode + NO_INDEX_SS() antlr.TerminalNode + NO_LOAD() antlr.TerminalNode + NOLOCAL() antlr.TerminalNode + NOLOGGING() antlr.TerminalNode + NOMAPPING() antlr.TerminalNode + NOMAXVALUE() antlr.TerminalNode + NO_MERGE() antlr.TerminalNode + NOMINIMIZE() antlr.TerminalNode + NOMINVALUE() antlr.TerminalNode + NO_MODEL_PUSH_REF() antlr.TerminalNode + NO_MONITORING() antlr.TerminalNode + NOMONITORING() antlr.TerminalNode + NO_MONITOR() antlr.TerminalNode + NO_MULTIMV_REWRITE() antlr.TerminalNode + NO() antlr.TerminalNode + NO_NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode + NONBLOCKING() antlr.TerminalNode + NONE() antlr.TerminalNode + NO_NLJ_BATCHING() antlr.TerminalNode + NO_NLJ_PREFETCH() antlr.TerminalNode + NONSCHEMA() antlr.TerminalNode + NOORDER() antlr.TerminalNode + NO_ORDER_ROLLUPS() antlr.TerminalNode + NO_OUTER_JOIN_TO_ANTI() antlr.TerminalNode + NO_OUTER_JOIN_TO_INNER() antlr.TerminalNode + NOOVERRIDE() antlr.TerminalNode + NO_PARALLEL_INDEX() antlr.TerminalNode + NOPARALLEL_INDEX() antlr.TerminalNode + NO_PARALLEL() antlr.TerminalNode + NOPARALLEL() antlr.TerminalNode + NO_PARTIAL_COMMIT() antlr.TerminalNode + NO_PLACE_DISTINCT() antlr.TerminalNode + NO_PLACE_GROUP_BY() antlr.TerminalNode + NO_PQ_MAP() antlr.TerminalNode + NO_PRUNE_GSETS() antlr.TerminalNode + NO_PULL_PRED() antlr.TerminalNode + NO_PUSH_PRED() antlr.TerminalNode + NO_PUSH_SUBQ() antlr.TerminalNode + NO_PX_JOIN_FILTER() antlr.TerminalNode + NO_QKN_BUFF() antlr.TerminalNode + NO_QUERY_TRANSFORMATION() antlr.TerminalNode + NO_REF_CASCADE() antlr.TerminalNode + NORELY() antlr.TerminalNode + NOREPAIR() antlr.TerminalNode + NORESETLOGS() antlr.TerminalNode + NO_RESULT_CACHE() antlr.TerminalNode + NOREVERSE() antlr.TerminalNode + NO_REWRITE() antlr.TerminalNode + NOREWRITE() antlr.TerminalNode + NORMAL() antlr.TerminalNode + NOROWDEPENDENCIES() antlr.TerminalNode + NOSCHEMACHECK() antlr.TerminalNode + NOSEGMENT() antlr.TerminalNode + NO_SEMIJOIN() antlr.TerminalNode + NO_SEMI_TO_INNER() antlr.TerminalNode + NO_SET_TO_JOIN() antlr.TerminalNode + NOSORT() antlr.TerminalNode + NO_SQL_TUNE() antlr.TerminalNode + NO_STAR_TRANSFORMATION() antlr.TerminalNode + NO_STATEMENT_QUEUING() antlr.TerminalNode + NO_STATS_GSETS() antlr.TerminalNode + NOSTRICT() antlr.TerminalNode + NO_SUBQUERY_PRUNING() antlr.TerminalNode + NO_SUBSTRB_PAD() antlr.TerminalNode + NO_SWAP_JOIN_INPUTS() antlr.TerminalNode + NOSWITCH() antlr.TerminalNode + NO_TABLE_LOOKUP_BY_NL() antlr.TerminalNode + NO_TEMP_TABLE() antlr.TerminalNode + NOTHING() antlr.TerminalNode + NOTIFICATION() antlr.TerminalNode + NO_TRANSFORM_DISTINCT_AGG() antlr.TerminalNode + NO_UNNEST() antlr.TerminalNode + NO_USE_HASH_AGGREGATION() antlr.TerminalNode + NO_USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode + NO_USE_HASH() antlr.TerminalNode + NO_USE_INVISIBLE_INDEXES() antlr.TerminalNode + NO_USE_MERGE() antlr.TerminalNode + NO_USE_NL() antlr.TerminalNode + NOVALIDATE() antlr.TerminalNode + NO_XDB_FASTPATH_INSERT() antlr.TerminalNode + NO_XML_DML_REWRITE() antlr.TerminalNode + NO_XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode + NO_XMLINDEX_REWRITE() antlr.TerminalNode + NO_XML_QUERY_REWRITE() antlr.TerminalNode + NTH_VALUE() antlr.TerminalNode + NTILE() antlr.TerminalNode + NULLIF() antlr.TerminalNode + NULLS() antlr.TerminalNode + NUMERIC() antlr.TerminalNode + NUM_INDEX_KEYS() antlr.TerminalNode + NUMTODSINTERVAL() antlr.TerminalNode + NUMTOYMINTERVAL() antlr.TerminalNode + NVARCHAR2() antlr.TerminalNode + NVL2() antlr.TerminalNode + NVL() antlr.TerminalNode + OBJECT2XML() antlr.TerminalNode + OBJECT() antlr.TerminalNode + OBJNO() antlr.TerminalNode + OBJNO_REUSE() antlr.TerminalNode + OCCURENCES() antlr.TerminalNode + OFFLINE() antlr.TerminalNode + OFF() antlr.TerminalNode + OIDINDEX() antlr.TerminalNode + OID() antlr.TerminalNode + OLAP() antlr.TerminalNode + OLD() antlr.TerminalNode + OLD_PUSH_PRED() antlr.TerminalNode + OLTP() antlr.TerminalNode + ONLINE() antlr.TerminalNode + ONLY() antlr.TerminalNode + OPAQUE() antlr.TerminalNode + OPAQUE_TRANSFORM() antlr.TerminalNode + OPAQUE_XCANONICAL() antlr.TerminalNode + OPCODE() antlr.TerminalNode + OPEN() antlr.TerminalNode + OPERATIONS() antlr.TerminalNode + OPERATOR() antlr.TerminalNode + OPT_ESTIMATE() antlr.TerminalNode + OPTIMAL() antlr.TerminalNode + OPTIMIZE() antlr.TerminalNode + OPTIMIZER_FEATURES_ENABLE() antlr.TerminalNode + OPTIMIZER_GOAL() antlr.TerminalNode + OPT_PARAM() antlr.TerminalNode + ORA_BRANCH() antlr.TerminalNode + ORADEBUG() antlr.TerminalNode + ORA_DST_AFFECTED() antlr.TerminalNode + ORA_DST_CONVERT() antlr.TerminalNode + ORA_DST_ERROR() antlr.TerminalNode + ORA_GET_ACLIDS() antlr.TerminalNode + ORA_GET_PRIVILEGES() antlr.TerminalNode + ORA_HASH() antlr.TerminalNode + ORA_ROWSCN() antlr.TerminalNode + ORA_ROWSCN_RAW() antlr.TerminalNode + ORA_ROWVERSION() antlr.TerminalNode + ORA_TABVERSION() antlr.TerminalNode + ORDERED() antlr.TerminalNode + ORDERED_PREDICATES() antlr.TerminalNode + ORDINALITY() antlr.TerminalNode + OR_EXPAND() antlr.TerminalNode + ORGANIZATION() antlr.TerminalNode + OR_PREDICATES() antlr.TerminalNode + OTHER() antlr.TerminalNode + OUTER_JOIN_TO_ANTI() antlr.TerminalNode + OUTER_JOIN_TO_INNER() antlr.TerminalNode + OUTER() antlr.TerminalNode + OUTLINE_LEAF() antlr.TerminalNode + OUTLINE() antlr.TerminalNode + OUT_OF_LINE() antlr.TerminalNode + OVERFLOW() antlr.TerminalNode + OVERFLOW_NOMOVE() antlr.TerminalNode + OVERLAPS() antlr.TerminalNode + OVER() antlr.TerminalNode + OWNER() antlr.TerminalNode + OWNERSHIP() antlr.TerminalNode + OWN() antlr.TerminalNode + PACKAGE() antlr.TerminalNode + PACKAGES() antlr.TerminalNode + PARALLEL_INDEX() antlr.TerminalNode + PARALLEL() antlr.TerminalNode + PARAMETERS() antlr.TerminalNode + PARAM() antlr.TerminalNode + PARENT() antlr.TerminalNode + PARITY() antlr.TerminalNode + PARTIALLY() antlr.TerminalNode + PARTITION_HASH() antlr.TerminalNode + PARTITION_LIST() antlr.TerminalNode + PARTITION() antlr.TerminalNode + PARTITION_RANGE() antlr.TerminalNode + PARTITIONS() antlr.TerminalNode + PARTNUMINST() antlr.TerminalNode + PASSING() antlr.TerminalNode + PASSWORD_GRACE_TIME() antlr.TerminalNode + PASSWORD_LIFE_TIME() antlr.TerminalNode + PASSWORD_LOCK_TIME() antlr.TerminalNode + PASSWORD() antlr.TerminalNode + PASSWORD_REUSE_MAX() antlr.TerminalNode + PASSWORD_REUSE_TIME() antlr.TerminalNode + PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode + PATH() antlr.TerminalNode + PATHS() antlr.TerminalNode + PBL_HS_BEGIN() antlr.TerminalNode + PBL_HS_END() antlr.TerminalNode + PCTINCREASE() antlr.TerminalNode + PCTTHRESHOLD() antlr.TerminalNode + PCTUSED() antlr.TerminalNode + PCTVERSION() antlr.TerminalNode + PENDING() antlr.TerminalNode + PERCENTILE_CONT() antlr.TerminalNode + PERCENTILE_DISC() antlr.TerminalNode + PERCENT_KEYWORD() antlr.TerminalNode + PERCENT_RANKM() antlr.TerminalNode + PERCENT_RANK() antlr.TerminalNode + PERFORMANCE() antlr.TerminalNode + PERMANENT() antlr.TerminalNode + PERMISSION() antlr.TerminalNode + PFILE() antlr.TerminalNode + PHYSICAL() antlr.TerminalNode + PIKEY() antlr.TerminalNode + PIV_GB() antlr.TerminalNode + PIVOT() antlr.TerminalNode + PIV_SSF() antlr.TerminalNode + PLACE_DISTINCT() antlr.TerminalNode + PLACE_GROUP_BY() antlr.TerminalNode + PLAN() antlr.TerminalNode + PLSCOPE_SETTINGS() antlr.TerminalNode + PLSQL_CCFLAGS() antlr.TerminalNode + PLSQL_CODE_TYPE() antlr.TerminalNode + PLSQL_DEBUG() antlr.TerminalNode + PLSQL_OPTIMIZE_LEVEL() antlr.TerminalNode + PLSQL_WARNINGS() antlr.TerminalNode + POINT() antlr.TerminalNode + POLICY() antlr.TerminalNode + POST_TRANSACTION() antlr.TerminalNode + POWERMULTISET_BY_CARDINALITY() antlr.TerminalNode + POWERMULTISET() antlr.TerminalNode + POWER() antlr.TerminalNode + PQ_DISTRIBUTE() antlr.TerminalNode + PQ_MAP() antlr.TerminalNode + PQ_NOMAP() antlr.TerminalNode + PREBUILT() antlr.TerminalNode + PRECEDES() antlr.TerminalNode + PRECEDING() antlr.TerminalNode + PRECISION() antlr.TerminalNode + PRECOMPUTE_SUBQUERY() antlr.TerminalNode + PREDICATE_REORDERS() antlr.TerminalNode + PREDICTION_BOUNDS() antlr.TerminalNode + PREDICTION_COST() antlr.TerminalNode + PREDICTION_DETAILS() antlr.TerminalNode + PREDICTION() antlr.TerminalNode + PREDICTION_PROBABILITY() antlr.TerminalNode + PREDICTION_SET() antlr.TerminalNode + PREPARE() antlr.TerminalNode + PRESENT() antlr.TerminalNode + PRESENTNNV() antlr.TerminalNode + PRESENTV() antlr.TerminalNode + PRESERVE() antlr.TerminalNode + PRESERVE_OID() antlr.TerminalNode + PREVIOUS() antlr.TerminalNode + PRIMARY() antlr.TerminalNode + PRIVATE() antlr.TerminalNode + PRIVATE_SGA() antlr.TerminalNode + PRIVILEGE() antlr.TerminalNode + PRIVILEGES() antlr.TerminalNode + PROCEDURAL() antlr.TerminalNode + PROCEDURE() antlr.TerminalNode + PROCESS() antlr.TerminalNode + PROFILE() antlr.TerminalNode + PROGRAM() antlr.TerminalNode + PROJECT() antlr.TerminalNode + PROPAGATE() antlr.TerminalNode + PROTECTED() antlr.TerminalNode + PROTECTION() antlr.TerminalNode + PULL_PRED() antlr.TerminalNode + PURGE() antlr.TerminalNode + PUSH_PRED() antlr.TerminalNode + PUSH_SUBQ() antlr.TerminalNode + PX_GRANULE() antlr.TerminalNode + PX_JOIN_FILTER() antlr.TerminalNode + QB_NAME() antlr.TerminalNode + QUERY_BLOCK() antlr.TerminalNode + QUERY() antlr.TerminalNode + QUEUE_CURR() antlr.TerminalNode + QUEUE() antlr.TerminalNode + QUEUE_ROWP() antlr.TerminalNode + QUIESCE() antlr.TerminalNode + QUORUM() antlr.TerminalNode + QUOTA() antlr.TerminalNode + RANDOM_LOCAL() antlr.TerminalNode + RANDOM() antlr.TerminalNode + RANGE() antlr.TerminalNode + RANKM() antlr.TerminalNode + RANK() antlr.TerminalNode + RAPIDLY() antlr.TerminalNode + RATIO_TO_REPORT() antlr.TerminalNode + RAWTOHEX() antlr.TerminalNode + RAWTONHEX() antlr.TerminalNode + RBA() antlr.TerminalNode + RBO_OUTLINE() antlr.TerminalNode + RDBA() antlr.TerminalNode + READ() antlr.TerminalNode + READS() antlr.TerminalNode + REAL() antlr.TerminalNode + REBALANCE() antlr.TerminalNode + REBUILD() antlr.TerminalNode + RECORDS_PER_BLOCK() antlr.TerminalNode + RECOVERABLE() antlr.TerminalNode + RECOVER() antlr.TerminalNode + RECOVERY() antlr.TerminalNode + RECYCLEBIN() antlr.TerminalNode + RECYCLE() antlr.TerminalNode + REDACTION() antlr.TerminalNode + REDO() antlr.TerminalNode + REDUCED() antlr.TerminalNode + REDUNDANCY() antlr.TerminalNode + REF_CASCADE_CURSOR() antlr.TerminalNode + REFERENCED() antlr.TerminalNode + REFERENCE() antlr.TerminalNode + REFERENCES() antlr.TerminalNode + REFERENCING() antlr.TerminalNode + REF() antlr.TerminalNode + REFRESH() antlr.TerminalNode + REFTOHEX() antlr.TerminalNode + REGEXP_COUNT() antlr.TerminalNode + REGEXP_INSTR() antlr.TerminalNode + REGEXP_LIKE() antlr.TerminalNode + REGEXP_REPLACE() antlr.TerminalNode + REGEXP_SUBSTR() antlr.TerminalNode + REGISTER() antlr.TerminalNode + REGR_AVGX() antlr.TerminalNode + REGR_AVGY() antlr.TerminalNode + REGR_COUNT() antlr.TerminalNode + REGR_INTERCEPT() antlr.TerminalNode + REGR_R2() antlr.TerminalNode + REGR_SLOPE() antlr.TerminalNode + REGR_SXX() antlr.TerminalNode + REGR_SXY() antlr.TerminalNode + REGR_SYY() antlr.TerminalNode + REGULAR() antlr.TerminalNode + REJECT() antlr.TerminalNode + REKEY() antlr.TerminalNode + RELATIONAL() antlr.TerminalNode + RELY() antlr.TerminalNode + REMAINDER() antlr.TerminalNode + REMOTE_MAPPED() antlr.TerminalNode + REMOVE() antlr.TerminalNode + REPAIR() antlr.TerminalNode + REPEAT() antlr.TerminalNode + REPLACE() antlr.TerminalNode + REPLICATION() antlr.TerminalNode + REQUIRED() antlr.TerminalNode + RESETLOGS() antlr.TerminalNode + RESET() antlr.TerminalNode + RESIZE() antlr.TerminalNode + RESOLVE() antlr.TerminalNode + RESOLVER() antlr.TerminalNode + RESPECT() antlr.TerminalNode + RESTORE_AS_INTERVALS() antlr.TerminalNode + RESTORE() antlr.TerminalNode + RESTRICT_ALL_REF_CONS() antlr.TerminalNode + RESTRICTED() antlr.TerminalNode + RESTRICT() antlr.TerminalNode + RESULT_CACHE() antlr.TerminalNode + RESUMABLE() antlr.TerminalNode + RESUME() antlr.TerminalNode + RETENTION() antlr.TerminalNode + RETRY_ON_ROW_CHANGE() antlr.TerminalNode + RETURNING() antlr.TerminalNode + RETURN() antlr.TerminalNode + REUSE() antlr.TerminalNode + REVERSE() antlr.TerminalNode + REWRITE() antlr.TerminalNode + REWRITE_OR_ERROR() antlr.TerminalNode + RIGHT() antlr.TerminalNode + ROLE() antlr.TerminalNode + ROLES() antlr.TerminalNode + ROLLBACK() antlr.TerminalNode + ROLLING() antlr.TerminalNode + ROLLUP() antlr.TerminalNode + ROOT() antlr.TerminalNode + ROUND() antlr.TerminalNode + ROWDEPENDENCIES() antlr.TerminalNode + ROWID() antlr.TerminalNode + ROWIDTOCHAR() antlr.TerminalNode + ROWIDTONCHAR() antlr.TerminalNode + ROW_LENGTH() antlr.TerminalNode + ROW() antlr.TerminalNode + ROW_NUMBER() antlr.TerminalNode + ROWNUM() antlr.TerminalNode + ROWS() antlr.TerminalNode + RPAD() antlr.TerminalNode + RTRIM() antlr.TerminalNode + RULE() antlr.TerminalNode + RULES() antlr.TerminalNode + SALT() antlr.TerminalNode + SAMPLE() antlr.TerminalNode + SAVE_AS_INTERVALS() antlr.TerminalNode + SAVEPOINT() antlr.TerminalNode + SB4() antlr.TerminalNode + SCALE() antlr.TerminalNode + SCALE_ROWS() antlr.TerminalNode + SCAN_INSTANCES() antlr.TerminalNode + SCAN() antlr.TerminalNode + SCHEDULER() antlr.TerminalNode + SCHEMACHECK() antlr.TerminalNode + SCHEMA() antlr.TerminalNode + SCN_ASCENDING() antlr.TerminalNode + SCN() antlr.TerminalNode + SCOPE() antlr.TerminalNode + SD_ALL() antlr.TerminalNode + SD_INHIBIT() antlr.TerminalNode + SD_SHOW() antlr.TerminalNode + SEARCH() antlr.TerminalNode + SECOND() antlr.TerminalNode + SECUREFILE_DBA() antlr.TerminalNode + SECUREFILE() antlr.TerminalNode + SECURITY() antlr.TerminalNode + SEED() antlr.TerminalNode + SEG_BLOCK() antlr.TerminalNode + SEG_FILE() antlr.TerminalNode + SEGMENT() antlr.TerminalNode + SELECTIVITY() antlr.TerminalNode + SEMIJOIN_DRIVER() antlr.TerminalNode + SEMIJOIN() antlr.TerminalNode + SEMI_TO_INNER() antlr.TerminalNode + SEQUENCED() antlr.TerminalNode + SEQUENCE() antlr.TerminalNode + SEQUENTIAL() antlr.TerminalNode + SERIALIZABLE() antlr.TerminalNode + SERVERERROR() antlr.TerminalNode + SERVICE() antlr.TerminalNode + SESSION_CACHED_CURSORS() antlr.TerminalNode + SESSION() antlr.TerminalNode + SESSIONS_PER_USER() antlr.TerminalNode + SESSIONTIMEZONE() antlr.TerminalNode + SESSIONTZNAME() antlr.TerminalNode + SETS() antlr.TerminalNode + SETTINGS() antlr.TerminalNode + SET_TO_JOIN() antlr.TerminalNode + SEVERE() antlr.TerminalNode + SHARED() antlr.TerminalNode + SHARED_POOL() antlr.TerminalNode + SHOW() antlr.TerminalNode + SHRINK() antlr.TerminalNode + SHUTDOWN() antlr.TerminalNode + SIBLINGS() antlr.TerminalNode + SID() antlr.TerminalNode + SIGNAL_COMPONENT() antlr.TerminalNode + SIGNAL_FUNCTION() antlr.TerminalNode + SIGN() antlr.TerminalNode + SIMPLE() antlr.TerminalNode + SINGLE() antlr.TerminalNode + SINGLETASK() antlr.TerminalNode + SINH() antlr.TerminalNode + SIN() antlr.TerminalNode + SKIP_EXT_OPTIMIZER() antlr.TerminalNode + SKIP_() antlr.TerminalNode + SKIP_UNQ_UNUSABLE_IDX() antlr.TerminalNode + SKIP_UNUSABLE_INDEXES() antlr.TerminalNode + SMALLFILE() antlr.TerminalNode + SNAPSHOT() antlr.TerminalNode + SOME() antlr.TerminalNode + SORT() antlr.TerminalNode + SOUNDEX() antlr.TerminalNode + SOURCE() antlr.TerminalNode + SPACE_KEYWORD() antlr.TerminalNode + SPECIFICATION() antlr.TerminalNode + SPFILE() antlr.TerminalNode + SPLIT() antlr.TerminalNode + SPREADSHEET() antlr.TerminalNode + SQLLDR() antlr.TerminalNode + SQL() antlr.TerminalNode + SQL_TRACE() antlr.TerminalNode + SQL_MACRO() antlr.TerminalNode + SQRT() antlr.TerminalNode + STALE() antlr.TerminalNode + STANDALONE() antlr.TerminalNode + STANDBY_MAX_DATA_DELAY() antlr.TerminalNode + STANDBY() antlr.TerminalNode + STAR() antlr.TerminalNode + STAR_TRANSFORMATION() antlr.TerminalNode + STARTUP() antlr.TerminalNode + STATEMENT_ID() antlr.TerminalNode + STATEMENT_QUEUING() antlr.TerminalNode + STATEMENTS() antlr.TerminalNode + STATIC() antlr.TerminalNode + STATISTICS() antlr.TerminalNode + STATS_BINOMIAL_TEST() antlr.TerminalNode + STATS_CROSSTAB() antlr.TerminalNode + STATS_F_TEST() antlr.TerminalNode + STATS_KS_TEST() antlr.TerminalNode + STATS_MODE() antlr.TerminalNode + STATS_MW_TEST() antlr.TerminalNode + STATS_ONE_WAY_ANOVA() antlr.TerminalNode + STATS_T_TEST_INDEP() antlr.TerminalNode + STATS_T_TEST_INDEPU() antlr.TerminalNode + STATS_T_TEST_ONE() antlr.TerminalNode + STATS_T_TEST_PAIRED() antlr.TerminalNode + STATS_WSR_TEST() antlr.TerminalNode + STDDEV() antlr.TerminalNode + STDDEV_POP() antlr.TerminalNode + STDDEV_SAMP() antlr.TerminalNode + STOP() antlr.TerminalNode + STORAGE() antlr.TerminalNode + STORE() antlr.TerminalNode + STREAMS() antlr.TerminalNode + STRICT() antlr.TerminalNode + STRING() antlr.TerminalNode + STRIPE_COLUMNS() antlr.TerminalNode + STRIPE_WIDTH() antlr.TerminalNode + STRIP() antlr.TerminalNode + STRUCTURE() antlr.TerminalNode + SUBMULTISET() antlr.TerminalNode + SUBPARTITION() antlr.TerminalNode + SUBPARTITION_REL() antlr.TerminalNode + SUBPARTITIONS() antlr.TerminalNode + SUBQUERIES() antlr.TerminalNode + SUBQUERY_PRUNING() antlr.TerminalNode + SUBSTITUTABLE() antlr.TerminalNode + SUBSTR2() antlr.TerminalNode + SUBSTR4() antlr.TerminalNode + SUBSTRB() antlr.TerminalNode + SUBSTRC() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + SUCCESSFUL() antlr.TerminalNode + SUMMARY() antlr.TerminalNode + SUM() antlr.TerminalNode + SUPPLEMENTAL() antlr.TerminalNode + SUSPEND() antlr.TerminalNode + SWAP_JOIN_INPUTS() antlr.TerminalNode + SWITCH() antlr.TerminalNode + SWITCHOVER() antlr.TerminalNode + SYNCHRONOUS() antlr.TerminalNode + SYNC() antlr.TerminalNode + SYS() antlr.TerminalNode + SYSASM() antlr.TerminalNode + SYS_AUDIT() antlr.TerminalNode + SYSAUX() antlr.TerminalNode + SYS_CHECKACL() antlr.TerminalNode + SYS_CONNECT_BY_PATH() antlr.TerminalNode + SYS_CONTEXT() antlr.TerminalNode + SYSDATE() antlr.TerminalNode + SYSDBA() antlr.TerminalNode + SYS_DBURIGEN() antlr.TerminalNode + SYS_DL_CURSOR() antlr.TerminalNode + SYS_DM_RXFORM_CHR() antlr.TerminalNode + SYS_DM_RXFORM_NUM() antlr.TerminalNode + SYS_DOM_COMPARE() antlr.TerminalNode + SYS_DST_PRIM2SEC() antlr.TerminalNode + SYS_DST_SEC2PRIM() antlr.TerminalNode + SYS_ET_BFILE_TO_RAW() antlr.TerminalNode + SYS_ET_BLOB_TO_IMAGE() antlr.TerminalNode + SYS_ET_IMAGE_TO_BLOB() antlr.TerminalNode + SYS_ET_RAW_TO_BFILE() antlr.TerminalNode + SYS_EXTPDTXT() antlr.TerminalNode + SYS_EXTRACT_UTC() antlr.TerminalNode + SYS_FBT_INSDEL() antlr.TerminalNode + SYS_FILTER_ACLS() antlr.TerminalNode + SYS_FNMATCHES() antlr.TerminalNode + SYS_FNREPLACE() antlr.TerminalNode + SYS_GET_ACLIDS() antlr.TerminalNode + SYS_GET_PRIVILEGES() antlr.TerminalNode + SYS_GETTOKENID() antlr.TerminalNode + SYS_GETXTIVAL() antlr.TerminalNode + SYS_GUID() antlr.TerminalNode + SYS_MAKEXML() antlr.TerminalNode + SYS_MAKE_XMLNODEID() antlr.TerminalNode + SYS_MKXMLATTR() antlr.TerminalNode + SYS_OP_ADT2BIN() antlr.TerminalNode + SYS_OP_ADTCONS() antlr.TerminalNode + SYS_OP_ALSCRVAL() antlr.TerminalNode + SYS_OP_ATG() antlr.TerminalNode + SYS_OP_BIN2ADT() antlr.TerminalNode + SYS_OP_BITVEC() antlr.TerminalNode + SYS_OP_BL2R() antlr.TerminalNode + SYS_OP_BLOOM_FILTER_LIST() antlr.TerminalNode + SYS_OP_BLOOM_FILTER() antlr.TerminalNode + SYS_OP_C2C() antlr.TerminalNode + SYS_OP_CAST() antlr.TerminalNode + SYS_OP_CEG() antlr.TerminalNode + SYS_OP_CL2C() antlr.TerminalNode + SYS_OP_COMBINED_HASH() antlr.TerminalNode + SYS_OP_COMP() antlr.TerminalNode + SYS_OP_CONVERT() antlr.TerminalNode + SYS_OP_COUNTCHG() antlr.TerminalNode + SYS_OP_CSCONV() antlr.TerminalNode + SYS_OP_CSCONVTEST() antlr.TerminalNode + SYS_OP_CSR() antlr.TerminalNode + SYS_OP_CSX_PATCH() antlr.TerminalNode + SYS_OP_DECOMP() antlr.TerminalNode + SYS_OP_DESCEND() antlr.TerminalNode + SYS_OP_DISTINCT() antlr.TerminalNode + SYS_OP_DRA() antlr.TerminalNode + SYS_OP_DUMP() antlr.TerminalNode + SYS_OP_DV_CHECK() antlr.TerminalNode + SYS_OP_ENFORCE_NOT_NULL() antlr.TerminalNode + SYSOPER() antlr.TerminalNode + SYS_OP_EXTRACT() antlr.TerminalNode + SYS_OP_GROUPING() antlr.TerminalNode + SYS_OP_GUID() antlr.TerminalNode + SYS_OP_IIX() antlr.TerminalNode + SYS_OP_ITR() antlr.TerminalNode + SYS_OP_LBID() antlr.TerminalNode + SYS_OP_LOBLOC2BLOB() antlr.TerminalNode + SYS_OP_LOBLOC2CLOB() antlr.TerminalNode + SYS_OP_LOBLOC2ID() antlr.TerminalNode + SYS_OP_LOBLOC2NCLOB() antlr.TerminalNode + SYS_OP_LOBLOC2TYP() antlr.TerminalNode + SYS_OP_LSVI() antlr.TerminalNode + SYS_OP_LVL() antlr.TerminalNode + SYS_OP_MAKEOID() antlr.TerminalNode + SYS_OP_MAP_NONNULL() antlr.TerminalNode + SYS_OP_MSR() antlr.TerminalNode + SYS_OP_NICOMBINE() antlr.TerminalNode + SYS_OP_NIEXTRACT() antlr.TerminalNode + SYS_OP_NII() antlr.TerminalNode + SYS_OP_NIX() antlr.TerminalNode + SYS_OP_NOEXPAND() antlr.TerminalNode + SYS_OP_NTCIMG() antlr.TerminalNode + SYS_OP_NUMTORAW() antlr.TerminalNode + SYS_OP_OIDVALUE() antlr.TerminalNode + SYS_OP_OPNSIZE() antlr.TerminalNode + SYS_OP_PAR_1() antlr.TerminalNode + SYS_OP_PARGID_1() antlr.TerminalNode + SYS_OP_PARGID() antlr.TerminalNode + SYS_OP_PAR() antlr.TerminalNode + SYS_OP_PIVOT() antlr.TerminalNode + SYS_OP_R2O() antlr.TerminalNode + SYS_OP_RAWTONUM() antlr.TerminalNode + SYS_OP_RDTM() antlr.TerminalNode + SYS_OP_REF() antlr.TerminalNode + SYS_OP_RMTD() antlr.TerminalNode + SYS_OP_ROWIDTOOBJ() antlr.TerminalNode + SYS_OP_RPB() antlr.TerminalNode + SYS_OPTLOBPRBSC() antlr.TerminalNode + SYS_OP_TOSETID() antlr.TerminalNode + SYS_OP_TPR() antlr.TerminalNode + SYS_OP_TRTB() antlr.TerminalNode + SYS_OPTXICMP() antlr.TerminalNode + SYS_OPTXQCASTASNQ() antlr.TerminalNode + SYS_OP_UNDESCEND() antlr.TerminalNode + SYS_OP_VECAND() antlr.TerminalNode + SYS_OP_VECBIT() antlr.TerminalNode + SYS_OP_VECOR() antlr.TerminalNode + SYS_OP_VECXOR() antlr.TerminalNode + SYS_OP_VERSION() antlr.TerminalNode + SYS_OP_VREF() antlr.TerminalNode + SYS_OP_VVD() antlr.TerminalNode + SYS_OP_XMLCONS_FOR_CSX() antlr.TerminalNode + SYS_OP_XPTHATG() antlr.TerminalNode + SYS_OP_XPTHIDX() antlr.TerminalNode + SYS_OP_XPTHOP() antlr.TerminalNode + SYS_OP_XTXT2SQLT() antlr.TerminalNode + SYS_ORDERKEY_DEPTH() antlr.TerminalNode + SYS_ORDERKEY_MAXCHILD() antlr.TerminalNode + SYS_ORDERKEY_PARENT() antlr.TerminalNode + SYS_PARALLEL_TXN() antlr.TerminalNode + SYS_PATHID_IS_ATTR() antlr.TerminalNode + SYS_PATHID_IS_NMSPC() antlr.TerminalNode + SYS_PATHID_LASTNAME() antlr.TerminalNode + SYS_PATHID_LASTNMSPC() antlr.TerminalNode + SYS_PATH_REVERSE() antlr.TerminalNode + SYS_PXQEXTRACT() antlr.TerminalNode + SYS_RID_ORDER() antlr.TerminalNode + SYS_ROW_DELTA() antlr.TerminalNode + SYS_SC_2_XMLT() antlr.TerminalNode + SYS_SYNRCIREDO() antlr.TerminalNode + SYSTEM_DEFINED() antlr.TerminalNode + SYSTEM() antlr.TerminalNode + SYSTIMESTAMP() antlr.TerminalNode + SYS_TYPEID() antlr.TerminalNode + SYS_UMAKEXML() antlr.TerminalNode + SYS_XMLANALYZE() antlr.TerminalNode + SYS_XMLCONTAINS() antlr.TerminalNode + SYS_XMLCONV() antlr.TerminalNode + SYS_XMLEXNSURI() antlr.TerminalNode + SYS_XMLGEN() antlr.TerminalNode + SYS_XMLI_LOC_ISNODE() antlr.TerminalNode + SYS_XMLI_LOC_ISTEXT() antlr.TerminalNode + SYS_XMLINSTR() antlr.TerminalNode + SYS_XMLLOCATOR_GETSVAL() antlr.TerminalNode + SYS_XMLNODEID_GETCID() antlr.TerminalNode + SYS_XMLNODEID_GETLOCATOR() antlr.TerminalNode + SYS_XMLNODEID_GETOKEY() antlr.TerminalNode + SYS_XMLNODEID_GETPATHID() antlr.TerminalNode + SYS_XMLNODEID_GETPTRID() antlr.TerminalNode + SYS_XMLNODEID_GETRID() antlr.TerminalNode + SYS_XMLNODEID_GETSVAL() antlr.TerminalNode + SYS_XMLNODEID_GETTID() antlr.TerminalNode + SYS_XMLNODEID() antlr.TerminalNode + SYS_XMLT_2_SC() antlr.TerminalNode + SYS_XMLTRANSLATE() antlr.TerminalNode + SYS_XMLTYPE2SQL() antlr.TerminalNode + SYS_XQ_ASQLCNV() antlr.TerminalNode + SYS_XQ_ATOMCNVCHK() antlr.TerminalNode + SYS_XQBASEURI() antlr.TerminalNode + SYS_XQCASTABLEERRH() antlr.TerminalNode + SYS_XQCODEP2STR() antlr.TerminalNode + SYS_XQCODEPEQ() antlr.TerminalNode + SYS_XQCON2SEQ() antlr.TerminalNode + SYS_XQCONCAT() antlr.TerminalNode + SYS_XQDELETE() antlr.TerminalNode + SYS_XQDFLTCOLATION() antlr.TerminalNode + SYS_XQDOC() antlr.TerminalNode + SYS_XQDOCURI() antlr.TerminalNode + SYS_XQDURDIV() antlr.TerminalNode + SYS_XQED4URI() antlr.TerminalNode + SYS_XQENDSWITH() antlr.TerminalNode + SYS_XQERRH() antlr.TerminalNode + SYS_XQERR() antlr.TerminalNode + SYS_XQESHTMLURI() antlr.TerminalNode + SYS_XQEXLOBVAL() antlr.TerminalNode + SYS_XQEXSTWRP() antlr.TerminalNode + SYS_XQEXTRACT() antlr.TerminalNode + SYS_XQEXTRREF() antlr.TerminalNode + SYS_XQEXVAL() antlr.TerminalNode + SYS_XQFB2STR() antlr.TerminalNode + SYS_XQFNBOOL() antlr.TerminalNode + SYS_XQFNCMP() antlr.TerminalNode + SYS_XQFNDATIM() antlr.TerminalNode + SYS_XQFNLNAME() antlr.TerminalNode + SYS_XQFNNM() antlr.TerminalNode + SYS_XQFNNSURI() antlr.TerminalNode + SYS_XQFNPREDTRUTH() antlr.TerminalNode + SYS_XQFNQNM() antlr.TerminalNode + SYS_XQFNROOT() antlr.TerminalNode + SYS_XQFORMATNUM() antlr.TerminalNode + SYS_XQFTCONTAIN() antlr.TerminalNode + SYS_XQFUNCR() antlr.TerminalNode + SYS_XQGETCONTENT() antlr.TerminalNode + SYS_XQINDXOF() antlr.TerminalNode + SYS_XQINSERT() antlr.TerminalNode + SYS_XQINSPFX() antlr.TerminalNode + SYS_XQIRI2URI() antlr.TerminalNode + SYS_XQLANG() antlr.TerminalNode + SYS_XQLLNMFRMQNM() antlr.TerminalNode + SYS_XQMKNODEREF() antlr.TerminalNode + SYS_XQNILLED() antlr.TerminalNode + SYS_XQNODENAME() antlr.TerminalNode + SYS_XQNORMSPACE() antlr.TerminalNode + SYS_XQNORMUCODE() antlr.TerminalNode + SYS_XQ_NRNG() antlr.TerminalNode + SYS_XQNSP4PFX() antlr.TerminalNode + SYS_XQNSPFRMQNM() antlr.TerminalNode + SYS_XQPFXFRMQNM() antlr.TerminalNode + SYS_XQ_PKSQL2XML() antlr.TerminalNode + SYS_XQPOLYABS() antlr.TerminalNode + SYS_XQPOLYADD() antlr.TerminalNode + SYS_XQPOLYCEL() antlr.TerminalNode + SYS_XQPOLYCSTBL() antlr.TerminalNode + SYS_XQPOLYCST() antlr.TerminalNode + SYS_XQPOLYDIV() antlr.TerminalNode + SYS_XQPOLYFLR() antlr.TerminalNode + SYS_XQPOLYMOD() antlr.TerminalNode + SYS_XQPOLYMUL() antlr.TerminalNode + SYS_XQPOLYRND() antlr.TerminalNode + SYS_XQPOLYSQRT() antlr.TerminalNode + SYS_XQPOLYSUB() antlr.TerminalNode + SYS_XQPOLYUMUS() antlr.TerminalNode + SYS_XQPOLYUPLS() antlr.TerminalNode + SYS_XQPOLYVEQ() antlr.TerminalNode + SYS_XQPOLYVGE() antlr.TerminalNode + SYS_XQPOLYVGT() antlr.TerminalNode + SYS_XQPOLYVLE() antlr.TerminalNode + SYS_XQPOLYVLT() antlr.TerminalNode + SYS_XQPOLYVNE() antlr.TerminalNode + SYS_XQREF2VAL() antlr.TerminalNode + SYS_XQRENAME() antlr.TerminalNode + SYS_XQREPLACE() antlr.TerminalNode + SYS_XQRESVURI() antlr.TerminalNode + SYS_XQRNDHALF2EVN() antlr.TerminalNode + SYS_XQRSLVQNM() antlr.TerminalNode + SYS_XQRYENVPGET() antlr.TerminalNode + SYS_XQRYVARGET() antlr.TerminalNode + SYS_XQRYWRP() antlr.TerminalNode + SYS_XQSEQ2CON4XC() antlr.TerminalNode + SYS_XQSEQ2CON() antlr.TerminalNode + SYS_XQSEQDEEPEQ() antlr.TerminalNode + SYS_XQSEQINSB() antlr.TerminalNode + SYS_XQSEQRM() antlr.TerminalNode + SYS_XQSEQRVS() antlr.TerminalNode + SYS_XQSEQSUB() antlr.TerminalNode + SYS_XQSEQTYPMATCH() antlr.TerminalNode + SYS_XQSTARTSWITH() antlr.TerminalNode + SYS_XQSTATBURI() antlr.TerminalNode + SYS_XQSTR2CODEP() antlr.TerminalNode + SYS_XQSTRJOIN() antlr.TerminalNode + SYS_XQSUBSTRAFT() antlr.TerminalNode + SYS_XQSUBSTRBEF() antlr.TerminalNode + SYS_XQTOKENIZE() antlr.TerminalNode + SYS_XQTREATAS() antlr.TerminalNode + SYS_XQ_UPKXML2SQL() antlr.TerminalNode + SYS_XQXFORM() antlr.TerminalNode + TABLE() antlr.TerminalNode + TABLE_LOOKUP_BY_NL() antlr.TerminalNode + TABLES() antlr.TerminalNode + TABLESPACE() antlr.TerminalNode + TABLESPACE_NO() antlr.TerminalNode + TABLE_STATS() antlr.TerminalNode + TABNO() antlr.TerminalNode + TANH() antlr.TerminalNode + TAN() antlr.TerminalNode + TBLORIDXPARTNUM() antlr.TerminalNode + TEMPFILE() antlr.TerminalNode + TEMPLATE() antlr.TerminalNode + TEMPORARY() antlr.TerminalNode + TEMP_TABLE() antlr.TerminalNode + TEST() antlr.TerminalNode + THAN() antlr.TerminalNode + THE() antlr.TerminalNode + THEN() antlr.TerminalNode + THREAD() antlr.TerminalNode + THROUGH() antlr.TerminalNode + TIME() antlr.TerminalNode + TIMING() antlr.TerminalNode + TIMEOUT() antlr.TerminalNode + TIMES() antlr.TerminalNode + TIMESTAMP() antlr.TerminalNode + TIMEZONE_ABBR() antlr.TerminalNode + TIMEZONE_HOUR() antlr.TerminalNode + TIMEZONE_MINUTE() antlr.TerminalNode + TIME_ZONE() antlr.TerminalNode + TIMEZONE_OFFSET() antlr.TerminalNode + TIMEZONE_REGION() antlr.TerminalNode + TIV_GB() antlr.TerminalNode + TIV_SSF() antlr.TerminalNode + TO_BINARY_DOUBLE() antlr.TerminalNode + TO_BINARY_FLOAT() antlr.TerminalNode + TO_BLOB() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + TO_CLOB() antlr.TerminalNode + TO_DATE() antlr.TerminalNode + TO_DSINTERVAL() antlr.TerminalNode + TO_LOB() antlr.TerminalNode + TO_MULTI_BYTE() antlr.TerminalNode + TO_NCHAR() antlr.TerminalNode + TO_NCLOB() antlr.TerminalNode + TO_NUMBER() antlr.TerminalNode + TOPLEVEL() antlr.TerminalNode + TO_SINGLE_BYTE() antlr.TerminalNode + TO_TIME() antlr.TerminalNode + TO_TIMESTAMP() antlr.TerminalNode + TO_TIMESTAMP_TZ() antlr.TerminalNode + TO_TIME_TZ() antlr.TerminalNode + TO_YMINTERVAL() antlr.TerminalNode + TRACE() antlr.TerminalNode + TRACING() antlr.TerminalNode + TRACKING() antlr.TerminalNode + TRAILING() antlr.TerminalNode + TRANSACTION() antlr.TerminalNode + TRANSFORM_DISTINCT_AGG() antlr.TerminalNode + TRANSITIONAL() antlr.TerminalNode + TRANSITION() antlr.TerminalNode + TRANSLATE() antlr.TerminalNode + TREAT() antlr.TerminalNode + TRIGGERS() antlr.TerminalNode + TRIM() antlr.TerminalNode + TRUE() antlr.TerminalNode + TRUNCATE() antlr.TerminalNode + TRUNC() antlr.TerminalNode + TRUSTED() antlr.TerminalNode + TUNING() antlr.TerminalNode + TX() antlr.TerminalNode + TYPE() antlr.TerminalNode + TYPES() antlr.TerminalNode + TZ_OFFSET() antlr.TerminalNode + UB2() antlr.TerminalNode + UBA() antlr.TerminalNode + UID() antlr.TerminalNode + UNARCHIVED() antlr.TerminalNode + UNBOUNDED() antlr.TerminalNode + UNBOUND() antlr.TerminalNode + UNDER() antlr.TerminalNode + UNDO() antlr.TerminalNode + UNDROP() antlr.TerminalNode + UNIFORM() antlr.TerminalNode + UNISTR() antlr.TerminalNode + UNLIMITED() antlr.TerminalNode + UNLOAD() antlr.TerminalNode + UNLOCK() antlr.TerminalNode + UNNEST_INNERJ_DISTINCT_VIEW() antlr.TerminalNode + UNNEST() antlr.TerminalNode + UNNEST_NOSEMIJ_NODISTINCTVIEW() antlr.TerminalNode + UNNEST_SEMIJ_VIEW() antlr.TerminalNode + UNPACKED() antlr.TerminalNode + UNPIVOT() antlr.TerminalNode + UNPROTECTED() antlr.TerminalNode + UNQUIESCE() antlr.TerminalNode + UNRECOVERABLE() antlr.TerminalNode + UNRESTRICTED() antlr.TerminalNode + UNTIL() antlr.TerminalNode + UNUSABLE() antlr.TerminalNode + UNUSED() antlr.TerminalNode + UPDATABLE() antlr.TerminalNode + UPDATED() antlr.TerminalNode + UPDATEXML() antlr.TerminalNode + UPD_INDEXES() antlr.TerminalNode + UPD_JOININDEX() antlr.TerminalNode + UPGRADE() antlr.TerminalNode + UPPER() antlr.TerminalNode + UPSERT() antlr.TerminalNode + UROWID() antlr.TerminalNode + USAGE() antlr.TerminalNode + USE_ANTI() antlr.TerminalNode + USE_CONCAT() antlr.TerminalNode + USE_HASH_AGGREGATION() antlr.TerminalNode + USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode + USE_HASH() antlr.TerminalNode + USE_INVISIBLE_INDEXES() antlr.TerminalNode + USE_MERGE_CARTESIAN() antlr.TerminalNode + USE_MERGE() antlr.TerminalNode + USE() antlr.TerminalNode + USE_NL() antlr.TerminalNode + USE_NL_WITH_INDEX() antlr.TerminalNode + USE_PRIVATE_OUTLINES() antlr.TerminalNode + USER_DEFINED() antlr.TerminalNode + USERENV() antlr.TerminalNode + USERGROUP() antlr.TerminalNode + USER() antlr.TerminalNode + USER_RECYCLEBIN() antlr.TerminalNode + USERS() antlr.TerminalNode + USE_SEMI() antlr.TerminalNode + USE_STORED_OUTLINES() antlr.TerminalNode + USE_TTT_FOR_GSETS() antlr.TerminalNode + USE_WEAK_NAME_RESL() antlr.TerminalNode + USING() antlr.TerminalNode + VALIDATE() antlr.TerminalNode + VALIDATION() antlr.TerminalNode + VALUE() antlr.TerminalNode + VARIANCE() antlr.TerminalNode + VAR_POP() antlr.TerminalNode + VARRAY() antlr.TerminalNode + VARRAYS() antlr.TerminalNode + VAR_SAMP() antlr.TerminalNode + VARYING() antlr.TerminalNode + VECTOR_READ() antlr.TerminalNode + VECTOR_READ_TRACE() antlr.TerminalNode + VERIFY() antlr.TerminalNode + VERSIONING() antlr.TerminalNode + VERSION() antlr.TerminalNode + VERSIONS_ENDSCN() antlr.TerminalNode + VERSIONS_ENDTIME() antlr.TerminalNode + VERSIONS() antlr.TerminalNode + VERSIONS_OPERATION() antlr.TerminalNode + VERSIONS_STARTSCN() antlr.TerminalNode + VERSIONS_STARTTIME() antlr.TerminalNode + VERSIONS_XID() antlr.TerminalNode + VIRTUAL() antlr.TerminalNode + VISIBLE() antlr.TerminalNode + VOLUME() antlr.TerminalNode + VSIZE() antlr.TerminalNode + WAIT() antlr.TerminalNode + WALLET() antlr.TerminalNode + WELLFORMED() antlr.TerminalNode + WHENEVER() antlr.TerminalNode + WHEN() antlr.TerminalNode + WHITESPACE() antlr.TerminalNode + WIDTH_BUCKET() antlr.TerminalNode + WITHIN() antlr.TerminalNode + WITHOUT() antlr.TerminalNode + WORK() antlr.TerminalNode + WRAPPED() antlr.TerminalNode + WRITE() antlr.TerminalNode + XDB_FASTPATH_INSERT() antlr.TerminalNode + X_DYN_PRUNE() antlr.TerminalNode + XID() antlr.TerminalNode + XML2OBJECT() antlr.TerminalNode + XMLATTRIBUTES() antlr.TerminalNode + XMLCAST() antlr.TerminalNode + XMLCDATA() antlr.TerminalNode + XMLCOLATTVAL() antlr.TerminalNode + XMLCOMMENT() antlr.TerminalNode + XMLCONCAT() antlr.TerminalNode + XMLDIFF() antlr.TerminalNode + XML_DML_RWT_STMT() antlr.TerminalNode + XMLELEMENT() antlr.TerminalNode + XMLEXISTS2() antlr.TerminalNode + XMLEXISTS() antlr.TerminalNode + XMLFOREST() antlr.TerminalNode + XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode + XMLINDEX_REWRITE() antlr.TerminalNode + XMLINDEX_SEL_IDX_TBL() antlr.TerminalNode + XMLISNODE() antlr.TerminalNode + XMLISVALID() antlr.TerminalNode + XML() antlr.TerminalNode + XMLNAMESPACES() antlr.TerminalNode + XMLPARSE() antlr.TerminalNode + XMLPATCH() antlr.TerminalNode + XMLPI() antlr.TerminalNode + XMLQUERY() antlr.TerminalNode + XMLQUERYVAL() antlr.TerminalNode + XMLROOT() antlr.TerminalNode + XMLSCHEMA() antlr.TerminalNode + XMLSERIALIZE() antlr.TerminalNode + XMLTABLE() antlr.TerminalNode + XMLTRANSFORMBLOB() antlr.TerminalNode + XMLTRANSFORM() antlr.TerminalNode + XMLTYPE() antlr.TerminalNode + XPATHTABLE() antlr.TerminalNode + XS_SYS_CONTEXT() antlr.TerminalNode + YEAR() antlr.TerminalNode + YES() antlr.TerminalNode + ZONE() antlr.TerminalNode + + // IsNon_reserved_keywords_pre12cContext differentiates from other interfaces. + IsNon_reserved_keywords_pre12cContext() +} + +type Non_reserved_keywords_pre12cContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNon_reserved_keywords_pre12cContext() *Non_reserved_keywords_pre12cContext { + var p = new(Non_reserved_keywords_pre12cContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c + return p +} + +func InitEmptyNon_reserved_keywords_pre12cContext(p *Non_reserved_keywords_pre12cContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c +} + +func (*Non_reserved_keywords_pre12cContext) IsNon_reserved_keywords_pre12cContext() {} + +func NewNon_reserved_keywords_pre12cContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Non_reserved_keywords_pre12cContext { + var p = new(Non_reserved_keywords_pre12cContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_non_reserved_keywords_pre12c + + return p +} + +func (s *Non_reserved_keywords_pre12cContext) GetParser() antlr.Parser { return s.parser } + +func (s *Non_reserved_keywords_pre12cContext) ABORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserABORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ABS() antlr.TerminalNode { + return s.GetToken(PlSqlParserABS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCESSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACCOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACCOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACOS() antlr.TerminalNode { + return s.GetToken(PlSqlParserACOS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_COMPONENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ACTIVE_TAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserACTIVE_TAG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_COLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_GROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD_MONTHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD_MONTHS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserADD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADJ_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADJ_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMINISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMINISTRATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMINISTRATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADMIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserADMIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADVISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ADVISOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserADVISOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALIAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALIAS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserALLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALL_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALL_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ALWAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserALWAYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserANALYZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANCILLARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserANCILLARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AND_EQUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserAND_EQUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANTIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserANTIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ANYSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserANYSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPENDCHILDXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPENDCHILDXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPEND_VALUES() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPEND_VALUES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) APPLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAPPLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVELOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARCHIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserARCHIVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserARRAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASCII() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCII, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASCIISTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserASCIISTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserASIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASSEMBLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSEMBLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserASSOCIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNCHRONOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ASYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserASYNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATAN2() antlr.TerminalNode { + return s.GetToken(PlSqlParserATAN2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserATAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AT() antlr.TerminalNode { + return s.GetToken(PlSqlParserAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserATTRIBUTES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHENTICATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHENTICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHENTICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTHORIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTHORIZATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOEXTEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOEXTEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTOMATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTOMATIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AUTO() antlr.TerminalNode { + return s.GetToken(PlSqlParserAUTO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AVAILABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVAILABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BACKUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBACKUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BASICFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASICFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BASIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBASIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BECOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBECOME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEGIN_OUTLINE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEGIN_OUTLINE_DATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BEHALF() antlr.TerminalNode { + return s.GetToken(PlSqlParserBEHALF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BFILENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserBFILENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIGFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE_INFINITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE_INFINITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_DOUBLE_NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_DOUBLE_NAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT_INFINITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT_INFINITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY_FLOAT_NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY_FLOAT_NAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIND_AWARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIND_AWARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BINDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserBINDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BIN_TO_NUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserBIN_TO_NUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITMAP_TREE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITMAP_TREE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BITS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBITS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCK_RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCK_RANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCKSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BLOCKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserBLOCKS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BODY() antlr.TerminalNode { + return s.GetToken(PlSqlParserBODY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BOTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserBOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BRANCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBRANCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BREADTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserBREADTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BROADCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserBROADCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUFFER_POOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUFFER_POOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserBUILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BULK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBULK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYPASS_RECURSIVE_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYPASS_RECURSIVE_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYPASS_UJVC() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYPASS_UJVC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserBYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_CB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_CB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_INSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CACHE_TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCACHE_TEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CANCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCANCEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CARDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCARDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASCADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CATEGORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCATEGORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CEIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCEIL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CELL_FLASH_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCELL_FLASH_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CERTIFICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCERTIFICATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHAINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHANGE_DUPKEY_ERROR_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE_DUPKEY_ERROR_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHARACTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARACTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHAR_CS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHARTOROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHARTOROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHECK_ACL_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECK_ACL_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHECKPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHECKPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHOOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHOOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CHUNK() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHUNK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLASS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLASS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLEAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOSE_CACHED_OPEN_CURSORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE_CACHED_OPEN_CURSORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTERING_FACTOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTERING_FACTOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_PROBABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CLUSTER_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserCLUSTER_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COALESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COALESCE_SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOALESCE_SQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOARSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CO_AUTH_IND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCO_AUTH_IND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLLECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLLECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMNAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_AUTH_INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_AUTH_INDICATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMNS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COLUMN_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOLUMN_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMMITTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMMITTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPATIBILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPATIBILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPLETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLETE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPLIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPLIANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSITE_LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE_LIMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOSITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOSITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COMPUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOMPUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONFIRM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONFIRM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONFORMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONFORMING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_CB_WHR_ONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_COMBINE_SW() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_COMBINE_SW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_COST_BASED() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_COST_BASED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ELIM_DUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ELIM_DUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ISCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ISCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ISLEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ISLEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_BY_ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_BY_ROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONNECT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONNECT_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSIDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSIDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSISTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSISTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTANT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTANT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTRAINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONSTRAINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONSTRAINTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTAINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTAINER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTINUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTINUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONTROLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONTROLFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR_K() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR_K, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORR_S() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORR_S, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPT_XID_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID_ALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CORRUPT_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserCORRUPT_XID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COSH() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOSH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COST_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOST_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COVAR_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) COVAR_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOVAR_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_CALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CPU_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCPU_PER_SESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CRASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserCRASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CREATE_STORED_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATE_STORED_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CREATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCREATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CROSSEDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSSEDITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CROSS() antlr.TerminalNode { + return s.GetToken(PlSqlParserCROSS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CSCONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCSCONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUBE_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUBE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUBE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUME_DISTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DISTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CUME_DIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserCUME_DIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_SCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_TIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENT_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENT_USER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURRENTV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURRENTV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR_SHARING_EXACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR_SHARING_EXACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CURSOR_SPECIFIC_SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCURSOR_SPECIFIC_SEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CV() antlr.TerminalNode { + return s.GetToken(PlSqlParserCV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) CYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DANGLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDANGLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATABASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATABASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAOBJNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATAOBJ_TO_PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATAOBJ_TO_PARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DATE_MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDATE_MODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBA_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBA_RECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBMS_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBMS_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DB_ROLE_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_ROLE_CHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DBTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDBTIMEZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DB_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDB_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DDL() antlr.TerminalNode { + return s.GetToken(PlSqlParserDDL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEALLOCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEALLOCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEBUGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUGGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECOMPOSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECOMPOSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECREMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECR() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DECRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECRYPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEDUPLICATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEDUPLICATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFAULTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFAULTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFERRABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFERRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFERRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEFINER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEFINER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEGREE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEGREE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DELETEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDELETEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEMAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEMAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DENSE_RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DENSE_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDENSE_RANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEPENDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPENDENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEPTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEQUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DEREF_NO_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDEREF_NO_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DETACHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETACHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DETERMINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserDETERMINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DICTIONARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDICTIONARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIMENSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIMENSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECT_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_LOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECTORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DIRECT_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserDIRECT_PATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE_PRESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_PRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISABLE_RPKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISABLE_RPKE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISALLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISALLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISASSOCIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISASSOCIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISCONNECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISCONNECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISKGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISK() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISKS() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISKS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISMOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISMOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISTINGUISHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTINGUISHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DISTRIBUTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserDISTRIBUTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DML() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DML_UPDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDML_UPDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOCFIDELITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCFIDELITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOCUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOCUMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_NO_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_NO_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOMAIN_INDEX_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOMAIN_INDEX_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DOWNGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDOWNGRADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DRIVING_SITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDRIVING_SITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DROP_COLUMN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP_COLUMN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DROP_GROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDROP_GROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DST_UPGRADE_INSERT_CONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserDST_UPGRADE_INSERT_CONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserDUMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC_SAMPLING_EST_CDN() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC_SAMPLING_EST_CDN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) DYNAMIC_SAMPLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserDYNAMIC_SAMPLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EACH() antlr.TerminalNode { + return s.GetToken(PlSqlParserEACH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EDITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEDITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserELEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_OBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_OBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ELIMINATE_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserELIMINATE_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY_CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY_CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EMPTY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEMPTY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENABLE_PRESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserENABLE_PRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCODING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCODING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCRYPTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENCRYPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserENCRYPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) END_OUTLINE_DATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEND_OUTLINE_DATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENFORCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENQUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTERPRISE() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTERPRISE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTITYESCAPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ENTRY() antlr.TerminalNode { + return s.GetToken(PlSqlParserENTRY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR_ARGUMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_ARGUMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERROR_ON_OVERLAP_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserERROR_ON_OVERLAP_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ERRORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserERRORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ESCAPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESCAPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ESTIMATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserESTIMATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVALNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVALUATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVALUATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EVERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEVERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCEPTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCEPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXCLUDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXECUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXECUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXEMPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXEMPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXISTSNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXISTSNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPAND_GSET_TO_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPAND_GSET_TO_UNION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPAND_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPAND_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPIRE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPIRE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPLAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPLOSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPLOSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXP() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXPR_CORR_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXPR_CORR_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTERNALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTERNAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTERNAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRACTVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRACTVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) EXTRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserEXTRA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FACTORIZE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFACTORIZE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILED_LOGIN_ATTEMPTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED_LOGIN_ATTEMPTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILED() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAILGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAILGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FALSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFALSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FBTSCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFBTSCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FEATURE_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFEATURE_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILESYSTEM_LIKE_LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILESYSTEM_LIKE_LOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FINISH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFINISH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRSTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRSTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FIRST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFIRST_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLAGGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLAGGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLASHBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASHBACK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLASH_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLASH_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLOOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLOOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FLUSH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFLUSH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLLOWING() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOLLOWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOLLOWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORCE_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORCE_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOREIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREIGN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FOREVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFOREVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FORWARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserFORWARD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FRAGMENT_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRAGMENT_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREELIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREELISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREELISTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FREEPOOLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFREEPOOLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserFRESH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FROM_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserFROM_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserFULL_OUTER_JOIN_TO_OUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) FUNCTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserFUNCTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GATHER_PLAN_STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGATHER_PLAN_STATISTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GBY_CONC_ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserGBY_CONC_ROLLUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GBY_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserGBY_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GENERATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGENERATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GLOBAL_TOPIC_ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGLOBAL_TOPIC_ENABLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GREATEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserGREATEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUP_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUP_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPING_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GROUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserGROUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARANTEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARANTEE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GUARD() antlr.TerminalNode { + return s.GetToken(PlSqlParserGUARD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASHKEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASHKEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HASH_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserHASH_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEADER() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEADER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HELP() antlr.TerminalNode { + return s.GetToken(PlSqlParserHELP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEXTORAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEXTORAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HEXTOREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserHEXTOREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIDDEN_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDDEN_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIERARCHY() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIERARCHY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HIGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserHIGH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HINTSET_BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserHINTSET_BEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HINTSET_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserHINTSET_END, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserHOUR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HWM_BROKERED() antlr.TerminalNode { + return s.GetToken(PlSqlParserHWM_BROKERED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) HYBRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserHYBRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDENTIFIER() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTIFIER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDENTITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDENTITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDGENERATORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDGENERATORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IDLE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserIDLE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IF() antlr.TerminalNode { + return s.GetToken(PlSqlParserIF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_OPTIM_EMBEDDED_HINTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_OPTIM_EMBEDDED_HINTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_ROW_ON_DUPKEY_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_ROW_ON_DUPKEY_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IGNORE_WHERE_CLAUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIGNORE_WHERE_CLAUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMMEDIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMPACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IMPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserIMPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDE_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDE_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCLUDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCLUDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCREMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENTAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCREMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCREMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INCR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINCR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_COMBINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_COMBINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_FFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_FFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RRS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RRS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_RS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_RS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SKIP_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SKIP_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS_ASC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS_ASC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS_DESC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS_DESC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_SS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_SS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEX_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEX_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDEXTYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDEXTYPES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INDICATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINDICATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INFINITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFINITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INFORMATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINFORMATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITCAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITCAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALIZED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITIAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INITRANS() antlr.TerminalNode { + return s.GetToken(PlSqlParserINITRANS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INLINE_XMLTYPE_NT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINLINE_XMLTYPE_NT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IN_MEMORY_METADATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN_MEMORY_METADATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXMLAFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXMLAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXMLBEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXMLBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTCHILDXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTCHILDXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTXMLAFTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTXMLAFTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSERTXMLBEFORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSERTXMLBEFORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANTIABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTIABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTANTLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTANTLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTEAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR4() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTRB() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTRB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTRC() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTRC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserINSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERMEDIATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERMEDIATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERNAL_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERNAL_USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERNAL_USE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERPRETED() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERPRETED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INT() antlr.TerminalNode { + return s.GetToken(PlSqlParserINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) INVISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserINVISIBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) IN_XQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserIN_XQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ISOLATION_LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION_LEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ISOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserISOLATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ITERATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ITERATION_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserITERATION_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JAVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserJAVA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEEP_DUPLICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP_DUPLICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KERBEROS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKERBEROS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEY_LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY_LENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEYSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserKEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) KILL() antlr.TerminalNode { + return s.GetToken(PlSqlParserKILL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST_DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_DAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAST_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAST_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LATERAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLATERAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LAYER() antlr.TerminalNode { + return s.GetToken(PlSqlParserLAYER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REGISTRATION_ENABLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REGISTRATION_ENABLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REGISTRATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REGISTRATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LDAP_REG_SYNC_INTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLDAP_REG_SYNC_INTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEADING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEADING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEFT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTHB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTHB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTHC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTHC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserLENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LEVELS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLEVELS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIBRARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIBRARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIFE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIFETIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIFETIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE2() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE4() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIKE_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIKE_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserLINK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LISTAGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLISTAGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserLIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LN() antlr.TerminalNode { + return s.GetToken(PlSqlParserLN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LNNVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLNNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOBNVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOBS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOBS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCAL_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCALTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCALTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCALTIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCALTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOCKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOCKED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL_READS_PER_CALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_CALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGICAL_READS_PER_SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGICAL_READS_PER_SESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGOFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGOFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOGON() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOGON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOG_READ_ONLY_VIOLATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOG_READ_ONLY_VIOLATIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LPAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserLPAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) LTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserLTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAKE_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAKE_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANAGER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANAGER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MANUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMANUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAPPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MASTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMASTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATCHED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATCHED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATERIALIZED() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MATERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMATERIALIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXARCHLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXARCHLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXDATAFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXDATAFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXEXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXINSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXINSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGFILES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGFILES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGHISTORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGHISTORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXLOGMEMBERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXLOGMEMBERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXTRANS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXTRANS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMAXVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEASURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEASURES() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEASURES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEDIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEDIUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEDIUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMOPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MEMORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMEMORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGEACTIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGEACTIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_CONST_ON() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_CONST_ON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MERGE_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserMERGE_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) METHOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMETHOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIGRATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIGRATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIGRATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINEXTENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINEXTENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINIMUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINIMUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINUS_NULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUS_NULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMINVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRRORCOLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRRORCOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRRORHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRRORHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MIRROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMIRROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MLSLABEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMLSLABEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_COMPILE_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_COMPILE_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_DONTVERIFY_UNIQUENESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_DONTVERIFY_UNIQUENESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_DYNAMIC_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_DYNAMIC_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_MIN_ANALYSIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_MIN_ANALYSIS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_NO_ANALYSIS() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_NO_ANALYSIS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_PBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_PBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODEL_PUSH_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODEL_PUSH_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODIFY_COLUMN_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY_COLUMN_TYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MODIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserMODIFY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONITOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONITOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MONTHS_BETWEEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserMONTHS_BETWEEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOUNTPATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOUNTPATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOVEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) MV_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserMV_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAMESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAMESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NANVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNANVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIVE_FULL_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATIVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATIVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NATURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNATURAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NAV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNAV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHAR_CS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR_CS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserNCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEEDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEEDED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_FAST_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_FAST_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_GET_REFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_GET_REFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_SET_REFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_SET_REFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NESTED_TABLE_SET_SETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNESTED_TABLE_SET_SETID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NETWORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNETWORK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEW_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEW_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEXT_DAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT_DAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NL_AJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNL_AJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_BATCHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_BATCHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_INDEX_SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_INDEX_SCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLJ_PREFETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLJ_PREFETCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CALENDAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CALENDAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARACTERSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARACTERSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_DECL_LEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_DECL_LEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CHARSET_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CHARSET_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_COMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_CURRENCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_CURRENCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_DATE_FORMAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_DATE_FORMAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_DATE_LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_DATE_LANGUAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_INITCAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_INITCAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_ISO_CURRENCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_ISO_CURRENCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NL_SJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNL_SJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LANG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LANG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LANGUAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LANGUAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LENGTH_SEMANTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LENGTH_SEMANTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_LOWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_LOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_NCHAR_CONV_EXCP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_NCHAR_CONV_EXCP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_NUMERIC_CHARACTERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_NUMERIC_CHARACTERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_SORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLSSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLSSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_SPECIAL_CHARS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_SPECIAL_CHARS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_TERRITORY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_TERRITORY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NLS_UPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNLS_UPPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ACCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ACCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOAPPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAPPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOARCHIVELOG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOARCHIVELOG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOAUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOAUDIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BASETABLE_MULTIMV_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BASETABLE_MULTIMV_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BIND_AWARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BIND_AWARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_BUFFER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_BUFFER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CARTESIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CARTESIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CHECK_ACL_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CHECK_ACL_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CLUSTER_BY_ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CLUSTER_BY_ROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_COALESCE_SQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COALESCE_SQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_CB_WHR_ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_CB_WHR_ONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_COMBINE_SW() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_COMBINE_SW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_COST_BASED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_COST_BASED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_ELIM_DUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_ELIM_DUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CONNECT_BY_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CONNECT_BY_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_COST_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_COST_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_CPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_CPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCPU_COSTING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCPU_COSTING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOCYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOCYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NODELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNODELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_DOMAIN_INDEX_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DOMAIN_INDEX_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_DST_UPGRADE_INSERT_CONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_DST_UPGRADE_INSERT_CONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_OBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_OBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ELIMINATE_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ELIMINATE_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOENTITYESCAPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOENTITYESCAPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND_GSET_TO_UNION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND_GSET_TO_UNION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_EXPAND_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_EXPAND_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FACTORIZE_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FACTORIZE_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FILTERING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FILTERING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOFORCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOFORCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_FULL_OUTER_JOIN_TO_OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_FULL_OUTER_JOIN_TO_OUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_GBY_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_GBY_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOGUARANTEE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOGUARANTEE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX_FFS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX_FFS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_INDEX_SS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_INDEX_SS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_LOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_LOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOLOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOLOGGING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOLOGGING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMAPPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAPPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMAXVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMAXVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMINIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMINVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMINVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MODEL_PUSH_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MODEL_PUSH_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOMONITORING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOMONITORING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MONITOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MONITOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_MULTIMV_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_MULTIMV_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NATIVE_FULL_OUTER_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NATIVE_FULL_OUTER_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONBLOCKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONBLOCKING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NLJ_BATCHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NLJ_BATCHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_NLJ_PREFETCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_NLJ_PREFETCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NONSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserNONSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOORDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_ORDER_ROLLUPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_ORDER_ROLLUPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_OUTER_JOIN_TO_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OUTER_JOIN_TO_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_OUTER_JOIN_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_OUTER_JOIN_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOOVERRIDE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOOVERRIDE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOPARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOPARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOPARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PARTIAL_COMMIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PARTIAL_COMMIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PLACE_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PLACE_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PLACE_GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PLACE_GROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PQ_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PQ_MAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PRUNE_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PRUNE_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PULL_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PULL_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PUSH_SUBQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PUSH_SUBQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_PX_JOIN_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_PX_JOIN_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_QKN_BUFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_QKN_BUFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_QUERY_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_QUERY_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_REF_CASCADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_REF_CASCADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORELY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREPAIR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORESETLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_RESULT_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOREWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOREWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NORMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNORMAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOROWDEPENDENCIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSCHEMACHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SEMIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SEMIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SEMI_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SEMI_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SET_TO_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SET_TO_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SQL_TUNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SQL_TUNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STAR_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STAR_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STATEMENT_QUEUING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STATEMENT_QUEUING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_STATS_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_STATS_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSTRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SUBQUERY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SUBQUERY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SUBSTRB_PAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SUBSTRB_PAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_SWAP_JOIN_INPUTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_SWAP_JOIN_INPUTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOSWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOSWITCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TABLE_LOOKUP_BY_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TABLE_LOOKUP_BY_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOTHING() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTHING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOTIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOTIFICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_TRANSFORM_DISTINCT_AGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_TRANSFORM_DISTINCT_AGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_UNNEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_UNNEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH_GBY_FOR_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_INVISIBLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_INVISIBLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_USE_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_USE_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NOVALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNOVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XDB_FASTPATH_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XDB_FASTPATH_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XML_DML_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XML_DML_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XMLINDEX_REWRITE_IN_SELECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XMLINDEX_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XMLINDEX_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NO_XML_QUERY_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNO_XML_QUERY_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NTH_VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTH_VALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NTILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserNTILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NULLIF() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLIF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NULLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNULLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMERIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMERIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUM_INDEX_KEYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUM_INDEX_KEYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMTODSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMTODSINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NUMTOYMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNUMTOYMINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVARCHAR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVARCHAR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVL2() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) NVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJECT2XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT2XML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OBJNO_REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOBJNO_REUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OCCURENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserOCCURENCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OFFLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFFLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OIDINDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserOIDINDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserOID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLD_PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLD_PUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OLTP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOLTP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ONLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ONLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserONLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE_TRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE_TRANSFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPAQUE_XCANONICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPAQUE_XCANONICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPCODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPCODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPERATIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPERATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPERATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPT_ESTIMATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPT_ESTIMATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZER_FEATURES_ENABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZER_FEATURES_ENABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPTIMIZER_GOAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPTIMIZER_GOAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OPT_PARAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserOPT_PARAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_BRANCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_BRANCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORADEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserORADEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_AFFECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_AFFECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_DST_ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_DST_ERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_GET_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_GET_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_GET_PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_GET_PRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWSCN_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWSCN_RAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_ROWVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_ROWVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORA_TABVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORA_TABVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDERED() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDERED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDERED_PREDICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDERED_PREDICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserORDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OR_EXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR_EXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ORGANIZATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserORGANIZATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OR_PREDICATES() antlr.TerminalNode { + return s.GetToken(PlSqlParserOR_PREDICATES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OTHER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOTHER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER_JOIN_TO_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER_JOIN_TO_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER_JOIN_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER_JOIN_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTLINE_LEAF() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE_LEAF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUTLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OUT_OF_LINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOUT_OF_LINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERFLOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERFLOW_NOMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERFLOW_NOMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVERLAPS() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVERLAPS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWNERSHIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWNERSHIP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) OWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PACKAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PACKAGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPACKAGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARALLEL_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARALLEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARALLEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARAMETERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAMETERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTIALLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTIALLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_LIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITION_RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITION_RANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PARTNUMINST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPARTNUMINST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_GRACE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_GRACE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_LIFE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LIFE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_LOCK_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_LOCK_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_REUSE_MAX() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_MAX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_REUSE_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_REUSE_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PASSWORD_VERIFY_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPASSWORD_VERIFY_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PATHS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPATHS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PBL_HS_BEGIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPBL_HS_BEGIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PBL_HS_END() antlr.TerminalNode { + return s.GetToken(PlSqlParserPBL_HS_END, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTINCREASE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTINCREASE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTTHRESHOLD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTTHRESHOLD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTUSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PCTVERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPCTVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PENDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPENDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENTILE_CONT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_CONT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENTILE_DISC() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENTILE_DISC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERCENT_RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERCENT_RANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERFORMANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERFORMANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERMANENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMANENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PERMISSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPERMISSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PHYSICAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPHYSICAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIV_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIV_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PIV_SSF() antlr.TerminalNode { + return s.GetToken(PlSqlParserPIV_SSF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLACE_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLACE_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLACE_GROUP_BY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLACE_GROUP_BY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSCOPE_SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSCOPE_SETTINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_CCFLAGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_CCFLAGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_CODE_TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_CODE_TYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_DEBUG() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_DEBUG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_OPTIMIZE_LEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_OPTIMIZE_LEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PLSQL_WARNINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPLSQL_WARNINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POLICY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOLICY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POST_TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOST_TRANSACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWERMULTISET_BY_CARDINALITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWERMULTISET_BY_CARDINALITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWERMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWERMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) POWER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPOWER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_DISTRIBUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_DISTRIBUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_MAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_MAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PQ_NOMAP() antlr.TerminalNode { + return s.GetToken(PlSqlParserPQ_NOMAP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREBUILT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREBUILT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECEDES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECEDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECEDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECISION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECISION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRECOMPUTE_SUBQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRECOMPUTE_SUBQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICATE_REORDERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICATE_REORDERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_BOUNDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_BOUNDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_COST() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_COST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_DETAILS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_DETAILS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_PROBABILITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_PROBABILITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREDICTION_SET() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREDICTION_SET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREPARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENTNNV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENTNNV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESENTV() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESENTV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESERVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRESERVE_OID() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRESERVE_OID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PREVIOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPREVIOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIMARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVATE_SGA() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVATE_SGA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVILEGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserPRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCEDURAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCEDURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCEDURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROCESS() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROCESS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROGRAM() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROGRAM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROPAGATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROPAGATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PROTECTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserPROTECTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PULL_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPULL_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PURGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPURGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PUSH_PRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUSH_PRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PUSH_SUBQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserPUSH_SUBQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PX_GRANULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_GRANULE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) PX_JOIN_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserPX_JOIN_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QB_NAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserQB_NAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUERY_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE_CURR() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE_CURR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUEUE_ROWP() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUEUE_ROWP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUIESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUIESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUORUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUORUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) QUOTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserQUOTA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANDOM_LOCAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANDOM_LOCAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANDOM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANDOM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANKM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANKM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RANK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRANK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAPIDLY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAPIDLY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RATIO_TO_REPORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRATIO_TO_REPORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAWTOHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAWTOHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RAWTONHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserRAWTONHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserRBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RBO_OUTLINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRBO_OUTLINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserRDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) READS() antlr.TerminalNode { + return s.GetToken(PlSqlParserREADS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserREAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REBALANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBALANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REBUILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserREBUILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECORDS_PER_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECORDS_PER_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVERABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECOVERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECOVERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RECYCLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRECYCLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDUCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REDUNDANCY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREDUNDANCY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REF_CASCADE_CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF_CASCADE_CURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFERENCING() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFERENCING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFRESH() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFRESH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REFTOHEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREFTOHEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_COUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_INSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_INSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_LIKE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_LIKE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_REPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGEXP_SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGEXP_SUBSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGISTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGISTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_AVGX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_AVGX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_AVGY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_AVGY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_COUNT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_INTERCEPT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_INTERCEPT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_R2() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_R2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SLOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SLOPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SXX() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SXX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SXY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SXY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGR_SYY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGR_SYY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REGULAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREGULAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserREKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RELATIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELATIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RELY() antlr.TerminalNode { + return s.GetToken(PlSqlParserRELY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMAINDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMAINDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMOTE_MAPPED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOTE_MAPPED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REMOVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREMOVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPAIR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPAIR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPEAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPEAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REPLICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserREPLICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REQUIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserREQUIRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESETLOGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESETLOGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESET() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESOLVE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESOLVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESOLVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESPECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESPECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTORE_AS_INTERVALS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE_AS_INTERVALS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICT_ALL_REF_CONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT_ALL_REF_CONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESTRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESULT_CACHE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESULT_CACHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESUMABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUMABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RESUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserRESUME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETENTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETENTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETRY_ON_ROW_CHANGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETRY_ON_ROW_CHANGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETURNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RETURN() antlr.TerminalNode { + return s.GetToken(PlSqlParserRETURN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REUSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) REWRITE_OR_ERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserREWRITE_OR_ERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RIGHT() antlr.TerminalNode { + return s.GetToken(PlSqlParserRIGHT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLBACK() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLBACK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLING() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROLLUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserROLLUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserROUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWDEPENDENCIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWDEPENDENCIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWIDTOCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWIDTOCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWIDTONCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWIDTONCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW_LENGTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_LENGTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROW_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserROW_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RPAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserRPAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RTRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserRTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RULE() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) RULES() antlr.TerminalNode { + return s.GetToken(PlSqlParserRULES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SALT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSALT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAMPLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAVE_AS_INTERVALS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVE_AS_INTERVALS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SAVEPOINT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSAVEPOINT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SB4() antlr.TerminalNode { + return s.GetToken(PlSqlParserSB4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCALE_ROWS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCALE_ROWS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCAN_INSTANCES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN_INSTANCES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEDULER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEDULER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEMACHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMACHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCN_ASCENDING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN_ASCENDING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SCOPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSCOPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_ALL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_ALL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_INHIBIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_INHIBIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SD_SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSD_SHOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEARCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEARCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECOND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECOND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECUREFILE_DBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE_DBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECUREFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECUREFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SECURITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSECURITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEG_BLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEG_BLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEG_FILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEG_FILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEGMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEGMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SELECTIVITY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSELECTIVITY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMIJOIN_DRIVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMIJOIN_DRIVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMIJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMIJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEMI_TO_INNER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEMI_TO_INNER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENCED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEQUENTIAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEQUENTIAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERIALIZABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERIALIZABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERVERERROR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVERERROR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SERVICE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSERVICE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSION_CACHED_CURSORS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION_CACHED_CURSORS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONS_PER_USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONS_PER_USER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONTIMEZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTIMEZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SESSIONTZNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSESSIONTZNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SETTINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSETTINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SET_TO_JOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSET_TO_JOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SEVERE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSEVERE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHARED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHARED_POOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHARED_POOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHOW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHOW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHRINK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHRINK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SHUTDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSHUTDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIBLINGS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIBLINGS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGNAL_COMPONENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNAL_COMPONENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGNAL_FUNCTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGNAL_FUNCTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIGN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIGN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIMPLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIMPLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINGLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINGLETASK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINGLETASK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SINH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSINH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_EXT_OPTIMIZER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_EXT_OPTIMIZER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_UNQ_UNUSABLE_IDX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_UNQ_UNUSABLE_IDX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SKIP_UNUSABLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSKIP_UNUSABLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SMALLFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSMALLFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SNAPSHOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSNAPSHOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SORT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSORT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOUNDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOUNDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SOURCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSOURCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPACE_KEYWORD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPACE_KEYWORD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPECIFICATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPECIFICATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPLIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPLIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SPREADSHEET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSPREADSHEET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQLLDR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQLLDR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL_TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_TRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQL_MACRO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQL_MACRO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SQRT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSQRT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STALE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTALE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDALONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDALONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDBY_MAX_DATA_DELAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY_MAX_DATA_DELAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STANDBY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTANDBY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STAR_TRANSFORMATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTAR_TRANSFORMATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STARTUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTARTUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENT_ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENT_QUEUING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENT_QUEUING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATEMENTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATEMENTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATIC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATIC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATISTICS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATISTICS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_BINOMIAL_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_BINOMIAL_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_CROSSTAB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_CROSSTAB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_F_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_F_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_KS_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_KS_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_MODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_MODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_MW_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_MW_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_ONE_WAY_ANOVA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_ONE_WAY_ANOVA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_INDEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_INDEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_INDEPU() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_INDEPU, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_ONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_ONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_T_TEST_PAIRED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_T_TEST_PAIRED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STATS_WSR_TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTATS_WSR_TEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STDDEV_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTDDEV_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTOP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STORAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STORE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTORE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STREAMS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTREAMS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRICT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRICT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIPE_COLUMNS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_COLUMNS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIPE_WIDTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIPE_WIDTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRIP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRIP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) STRUCTURE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSTRUCTURE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBMULTISET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBMULTISET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITION_REL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITION_REL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBPARTITIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBPARTITIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBQUERIES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBQUERIES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBQUERY_PRUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBQUERY_PRUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTITUTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTITUTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR2() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR4() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR4, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTRB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTRB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTRC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTRC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUCCESSFUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUCCESSFUL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUMMARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUMMARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUPPLEMENTAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUPPLEMENTAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SUSPEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUSPEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWAP_JOIN_INPUTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWAP_JOIN_INPUTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWITCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SWITCHOVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSWITCHOVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYNCHRONOUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNCHRONOUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSASM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSASM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_AUDIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_AUDIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSAUX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSAUX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CHECKACL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CHECKACL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CONNECT_BY_PATH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CONNECT_BY_PATH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_CONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSDBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSDBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DBURIGEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DBURIGEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DL_CURSOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DL_CURSOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DM_RXFORM_CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DM_RXFORM_CHR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DM_RXFORM_NUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DM_RXFORM_NUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DOM_COMPARE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DOM_COMPARE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DST_PRIM2SEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DST_PRIM2SEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_DST_SEC2PRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_DST_SEC2PRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_BFILE_TO_RAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_BFILE_TO_RAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_BLOB_TO_IMAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_BLOB_TO_IMAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_IMAGE_TO_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_IMAGE_TO_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ET_RAW_TO_BFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ET_RAW_TO_BFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_EXTPDTXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_EXTPDTXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_EXTRACT_UTC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_EXTRACT_UTC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FBT_INSDEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FBT_INSDEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FILTER_ACLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FILTER_ACLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FNMATCHES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FNMATCHES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_FNREPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_FNREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GET_ACLIDS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_ACLIDS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GET_PRIVILEGES() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GET_PRIVILEGES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GETTOKENID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GETTOKENID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GETXTIVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GETXTIVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_GUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MAKEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MAKEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MAKE_XMLNODEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MAKE_XMLNODEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_MKXMLATTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_MKXMLATTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ADT2BIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ADT2BIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ADTCONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ADTCONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ALSCRVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ALSCRVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ATG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ATG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BIN2ADT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BIN2ADT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BITVEC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BITVEC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BL2R() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BL2R, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BLOOM_FILTER_LIST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BLOOM_FILTER_LIST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_BLOOM_FILTER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_BLOOM_FILTER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_C2C() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_C2C, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CEG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CEG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CL2C() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CL2C, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COMBINED_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COMBINED_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CONVERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CONVERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_COUNTCHG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_COUNTCHG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSCONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSCONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSCONVTEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSCONVTEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_CSX_PATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_CSX_PATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DECOMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DECOMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DESCEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DESCEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DISTINCT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DISTINCT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DRA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DRA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DUMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DUMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_DV_CHECK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_DV_CHECK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ENFORCE_NOT_NULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ENFORCE_NOT_NULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSOPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSOPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_EXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_EXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_GROUPING() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_GROUPING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_GUID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_GUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_IIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_IIX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ITR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ITR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LBID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LBID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2ID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2ID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2NCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LOBLOC2TYP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LOBLOC2TYP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LSVI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LSVI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_LVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_LVL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MAKEOID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MAKEOID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MAP_NONNULL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MAP_NONNULL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_MSR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_MSR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NICOMBINE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NICOMBINE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NIEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NIEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NII() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NII, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NIX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NIX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NOEXPAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NOEXPAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NTCIMG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NTCIMG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_NUMTORAW() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_NUMTORAW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_OIDVALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_OIDVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_OPNSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_OPNSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PAR_1() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PAR_1, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PARGID_1() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PARGID_1, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PARGID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PARGID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_PIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_PIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_R2O() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_R2O, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RAWTONUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RAWTONUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RDTM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RDTM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_REF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_REF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RMTD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RMTD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_ROWIDTOOBJ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_ROWIDTOOBJ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_RPB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_RPB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTLOBPRBSC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTLOBPRBSC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TOSETID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TOSETID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TPR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TPR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_TRTB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_TRTB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTXICMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTXICMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OPTXQCASTASNQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OPTXQCASTASNQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_UNDESCEND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_UNDESCEND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECAND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECAND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECBIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECBIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VECXOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VECXOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_VVD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_VVD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XMLCONS_FOR_CSX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XMLCONS_FOR_CSX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHATG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHATG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHIDX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHIDX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XPTHOP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XPTHOP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_OP_XTXT2SQLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_OP_XTXT2SQLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_DEPTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_DEPTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_MAXCHILD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_MAXCHILD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ORDERKEY_PARENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ORDERKEY_PARENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PARALLEL_TXN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PARALLEL_TXN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_IS_ATTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_IS_ATTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_IS_NMSPC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_IS_NMSPC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_LASTNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_LASTNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATHID_LASTNMSPC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATHID_LASTNMSPC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PATH_REVERSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PATH_REVERSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_PXQEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_PXQEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_RID_ORDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_RID_ORDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_ROW_DELTA() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_ROW_DELTA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_SC_2_XMLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_SC_2_XMLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_SYNRCIREDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_SYNRCIREDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTEM_DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM_DEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTEM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTEM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYSTIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYSTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_TYPEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_TYPEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_UMAKEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_UMAKEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLANALYZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLANALYZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLCONTAINS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLCONTAINS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLCONV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLCONV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLEXNSURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLEXNSURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLGEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLGEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLI_LOC_ISNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLI_LOC_ISNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLI_LOC_ISTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLI_LOC_ISTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLINSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLINSTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLLOCATOR_GETSVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLLOCATOR_GETSVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETCID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETCID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETLOCATOR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETLOCATOR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETOKEY() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETOKEY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETPATHID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETPATHID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETPTRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETPTRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETRID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETRID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETSVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETSVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID_GETTID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID_GETTID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLNODEID() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLNODEID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLT_2_SC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLT_2_SC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLTRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLTRANSLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XMLTYPE2SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XMLTYPE2SQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_ASQLCNV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_ASQLCNV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_ATOMCNVCHK() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_ATOMCNVCHK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQBASEURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQBASEURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCASTABLEERRH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCASTABLEERRH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCODEP2STR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCODEP2STR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCODEPEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCODEPEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCON2SEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCON2SEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDELETE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDELETE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDFLTCOLATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDFLTCOLATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDOC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDOC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDOCURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDOCURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQDURDIV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQDURDIV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQED4URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQED4URI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQENDSWITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQENDSWITH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQERRH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQERRH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQERR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQERR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQESHTMLURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQESHTMLURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXLOBVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXLOBVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXSTWRP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXSTWRP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXTRACT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXTRACT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXTRREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXTRREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQEXVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQEXVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFB2STR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFB2STR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNBOOL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNBOOL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNCMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNCMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNDATIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNDATIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNLNAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNLNAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNNSURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNNSURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNPREDTRUTH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNPREDTRUTH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFNROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFNROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFORMATNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFORMATNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFTCONTAIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFTCONTAIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQFUNCR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQFUNCR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQGETCONTENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQGETCONTENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINDXOF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINDXOF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQINSPFX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQINSPFX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQIRI2URI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQIRI2URI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQLANG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQLANG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQLLNMFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQLLNMFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQMKNODEREF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQMKNODEREF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNILLED() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNILLED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNODENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNODENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNORMSPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNORMSPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNORMUCODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNORMUCODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_NRNG() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_NRNG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNSP4PFX() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNSP4PFX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQNSPFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQNSPFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPFXFRMQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPFXFRMQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_PKSQL2XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_PKSQL2XML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYABS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYABS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYADD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYADD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCSTBL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCSTBL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYCST() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYCST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYDIV() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYDIV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYFLR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYFLR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYMOD() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYMOD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYMUL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYMUL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYRND() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYRND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYSQRT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYSQRT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYSUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYSUB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYUMUS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYUMUS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYUPLS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYUPLS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVGT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVGT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVLT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVLT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQPOLYVNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQPOLYVNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQREF2VAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQREF2VAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRENAME() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRENAME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQREPLACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQREPLACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRESVURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRESVURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRNDHALF2EVN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRNDHALF2EVN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRSLVQNM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRSLVQNM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYENVPGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYENVPGET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYVARGET() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYVARGET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQRYWRP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQRYWRP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQ2CON4XC() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQ2CON4XC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQ2CON() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQ2CON, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQDEEPEQ() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQDEEPEQ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQINSB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQINSB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQRM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQRM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQRVS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQRVS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQSUB() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQSUB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSEQTYPMATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSEQTYPMATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTARTSWITH() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTARTSWITH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTATBURI() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTATBURI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTR2CODEP() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTR2CODEP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSTRJOIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSTRJOIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSUBSTRAFT() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSUBSTRAFT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQSUBSTRBEF() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQSUBSTRBEF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQTOKENIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQTOKENIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQTREATAS() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQTREATAS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQ_UPKXML2SQL() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQ_UPKXML2SQL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) SYS_XQXFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSYS_XQXFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE_LOOKUP_BY_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE_LOOKUP_BY_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLESPACE_NO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLESPACE_NO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABLE_STATS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABLE_STATS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TABNO() antlr.TerminalNode { + return s.GetToken(PlSqlParserTABNO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TANH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTANH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TBLORIDXPARTNUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTBLORIDXPARTNUM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPFILE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPFILE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMPORARY() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMPORARY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEMP_TABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEMP_TABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserTEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THREAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHREAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) THROUGH() antlr.TerminalNode { + return s.GetToken(PlSqlParserTHROUGH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEOUT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_ABBR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_ABBR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_HOUR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_HOUR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_MINUTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_MINUTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIME_ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIME_ZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_OFFSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIMEZONE_REGION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIMEZONE_REGION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIV_GB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIV_GB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TIV_SSF() antlr.TerminalNode { + return s.GetToken(PlSqlParserTIV_SSF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BINARY_DOUBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_DOUBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BINARY_FLOAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BINARY_FLOAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_BLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_BLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_CLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_DATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_DSINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_DSINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_LOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_LOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_MULTI_BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_MULTI_BYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NCHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NCHAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NCLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NCLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_NUMBER() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_NUMBER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TOPLEVEL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTOPLEVEL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_SINGLE_BYTE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_SINGLE_BYTE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIMESTAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIMESTAMP_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIMESTAMP_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_TIME_TZ() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_TIME_TZ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TO_YMINTERVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_YMINTERVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRACKING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRACKING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRAILING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRAILING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSACTION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSACTION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSFORM_DISTINCT_AGG() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSFORM_DISTINCT_AGG, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSITIONAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSITIONAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSITION() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSITION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRANSLATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRANSLATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TREAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserTREAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRIGGERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIGGERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUNCATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNCATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUNC() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUNC, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TRUSTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRUSTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TUNING() antlr.TerminalNode { + return s.GetToken(PlSqlParserTUNING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TX() antlr.TerminalNode { + return s.GetToken(PlSqlParserTX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TYPES() antlr.TerminalNode { + return s.GetToken(PlSqlParserTYPES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) TZ_OFFSET() antlr.TerminalNode { + return s.GetToken(PlSqlParserTZ_OFFSET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UB2() antlr.TerminalNode { + return s.GetToken(PlSqlParserUB2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UBA() antlr.TerminalNode { + return s.GetToken(PlSqlParserUBA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNARCHIVED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNARCHIVED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNBOUNDED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUNDED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNBOUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNBOUND, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDO() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDO, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNDROP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNDROP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNIFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNIFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNISTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNISTR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLIMITED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLIMITED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLOAD() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOAD, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNLOCK() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNLOCK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_INNERJ_DISTINCT_VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_INNERJ_DISTINCT_VIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_NOSEMIJ_NODISTINCTVIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_NOSEMIJ_NODISTINCTVIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNNEST_SEMIJ_VIEW() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNNEST_SEMIJ_VIEW, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPACKED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPACKED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPIVOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPIVOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNPROTECTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNPROTECTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNQUIESCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNQUIESCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNRECOVERABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRECOVERABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNRESTRICTED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNRESTRICTED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNTIL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNTIL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNUSABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UNUSED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUNUSED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPDATEXML() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPDATEXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPD_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPD_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPD_JOININDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPD_JOININDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPGRADE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPGRADE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPPER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPPER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UPSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUPSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) UROWID() antlr.TerminalNode { + return s.GetToken(PlSqlParserUROWID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USAGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSAGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_ANTI() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_ANTI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_CONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_CONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH_AGGREGATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH_AGGREGATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH_GBY_FOR_PUSHDOWN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH_GBY_FOR_PUSHDOWN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_HASH() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_HASH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_INVISIBLE_INDEXES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_INVISIBLE_INDEXES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_MERGE_CARTESIAN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_MERGE_CARTESIAN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_MERGE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_MERGE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_NL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_NL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_NL_WITH_INDEX() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_NL_WITH_INDEX, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_PRIVATE_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_PRIVATE_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER_DEFINED() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_DEFINED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERENV() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERENV, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERGROUP() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERGROUP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USER_RECYCLEBIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSER_RECYCLEBIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USERS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSERS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_SEMI() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_SEMI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_STORED_OUTLINES() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_STORED_OUTLINES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_TTT_FOR_GSETS() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_TTT_FOR_GSETS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USE_WEAK_NAME_RESL() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSE_WEAK_NAME_RESL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) USING() antlr.TerminalNode { + return s.GetToken(PlSqlParserUSING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALIDATE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALIDATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALIDATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VALUE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVALUE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARIANCE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARIANCE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VAR_POP() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_POP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARRAY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARRAYS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARRAYS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VAR_SAMP() antlr.TerminalNode { + return s.GetToken(PlSqlParserVAR_SAMP, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VARYING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVARYING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VECTOR_READ() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_READ, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VECTOR_READ_TRACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVECTOR_READ_TRACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERIFY() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERIFY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONING() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONING, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_ENDSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_ENDSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_ENDTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_ENDTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_OPERATION() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_OPERATION, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_STARTSCN() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_STARTSCN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_STARTTIME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_STARTTIME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VERSIONS_XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserVERSIONS_XID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VIRTUAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserVIRTUAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VISIBLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVISIBLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VOLUME() antlr.TerminalNode { + return s.GetToken(PlSqlParserVOLUME, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) VSIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserVSIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WAIT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWAIT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WALLET() antlr.TerminalNode { + return s.GetToken(PlSqlParserWALLET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WELLFORMED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWELLFORMED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHENEVER() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHENEVER, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHEN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHEN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WHITESPACE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWHITESPACE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WIDTH_BUCKET() antlr.TerminalNode { + return s.GetToken(PlSqlParserWIDTH_BUCKET, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WITHIN() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHIN, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WITHOUT() antlr.TerminalNode { + return s.GetToken(PlSqlParserWITHOUT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WORK() antlr.TerminalNode { + return s.GetToken(PlSqlParserWORK, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WRAPPED() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRAPPED, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) WRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XDB_FASTPATH_INSERT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXDB_FASTPATH_INSERT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) X_DYN_PRUNE() antlr.TerminalNode { + return s.GetToken(PlSqlParserX_DYN_PRUNE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XID() antlr.TerminalNode { + return s.GetToken(PlSqlParserXID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML2OBJECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML2OBJECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLATTRIBUTES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLATTRIBUTES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCAST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCAST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCDATA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCDATA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCOLATTVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOLATTVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCOMMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCOMMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLCONCAT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLCONCAT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLDIFF() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLDIFF, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML_DML_RWT_STMT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML_DML_RWT_STMT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLELEMENT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLELEMENT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLEXISTS2() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS2, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLEXISTS() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLEXISTS, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLFOREST() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLFOREST, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_REWRITE_IN_SELECT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_REWRITE_IN_SELECT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_REWRITE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_REWRITE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLINDEX_SEL_IDX_TBL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLINDEX_SEL_IDX_TBL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLISNODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLISNODE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLISVALID() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLISVALID, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XML() antlr.TerminalNode { + return s.GetToken(PlSqlParserXML, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLNAMESPACES() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLNAMESPACES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPARSE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPARSE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPATCH() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPATCH, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLPI() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLPI, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLQUERY() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERY, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLQUERYVAL() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLQUERYVAL, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLROOT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLROOT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLSCHEMA() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSCHEMA, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLSERIALIZE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLSERIALIZE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTRANSFORMBLOB() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTRANSFORMBLOB, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTRANSFORM() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTRANSFORM, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XMLTYPE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXMLTYPE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XPATHTABLE() antlr.TerminalNode { + return s.GetToken(PlSqlParserXPATHTABLE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) XS_SYS_CONTEXT() antlr.TerminalNode { + return s.GetToken(PlSqlParserXS_SYS_CONTEXT, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) YEAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserYEAR, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) YES() antlr.TerminalNode { + return s.GetToken(PlSqlParserYES, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) ZONE() antlr.TerminalNode { + return s.GetToken(PlSqlParserZONE, 0) +} + +func (s *Non_reserved_keywords_pre12cContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Non_reserved_keywords_pre12cContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Non_reserved_keywords_pre12cContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNon_reserved_keywords_pre12c(s) + } +} + +func (s *Non_reserved_keywords_pre12cContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNon_reserved_keywords_pre12c(s) + } +} + +func (s *Non_reserved_keywords_pre12cContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNon_reserved_keywords_pre12c(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Non_reserved_keywords_pre12c() (localctx INon_reserved_keywords_pre12cContext) { + localctx = NewNon_reserved_keywords_pre12cContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2386, PlSqlParserRULE_non_reserved_keywords_pre12c) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20326) + _la = p.GetTokenStream().LA(1) + + if !(((int64(_la) & ^0x3f) == 0 && ((int64(1)<<_la)&5463616014945309046) != 0) || ((int64((_la-64)) & ^0x3f) == 0 && ((int64(1)<<(_la-64))&-576902256486777485) != 0) || ((int64((_la-129)) & ^0x3f) == 0 && ((int64(1)<<(_la-129))&-153144625601774593) != 0) || ((int64((_la-198)) & ^0x3f) == 0 && ((int64(1)<<(_la-198))&9190843253782472953) != 0) || ((int64((_la-262)) & ^0x3f) == 0 && ((int64(1)<<(_la-262))&9220810724510261631) != 0) || ((int64((_la-326)) & ^0x3f) == 0 && ((int64(1)<<(_la-326))&-4037214975763233409) != 0) || ((int64((_la-391)) & ^0x3f) == 0 && ((int64(1)<<(_la-391))&6662985952592912059) != 0) || ((int64((_la-455)) & ^0x3f) == 0 && ((int64(1)<<(_la-455))&-1171218143005126673) != 0) || ((int64((_la-519)) & ^0x3f) == 0 && ((int64(1)<<(_la-519))&-4044339139750348471) != 0) || ((int64((_la-583)) & ^0x3f) == 0 && ((int64(1)<<(_la-583))&-3530878197992523141) != 0) || ((int64((_la-647)) & ^0x3f) == 0 && ((int64(1)<<(_la-647))&9222129575293603839) != 0) || ((int64((_la-712)) & ^0x3f) == 0 && ((int64(1)<<(_la-712))&-1738847127879030929) != 0) || ((int64((_la-776)) & ^0x3f) == 0 && ((int64(1)<<(_la-776))&-4649702844138848833) != 0) || ((int64((_la-841)) & ^0x3f) == 0 && ((int64(1)<<(_la-841))&-1166590702923153529) != 0) || ((int64((_la-908)) & ^0x3f) == 0 && ((int64(1)<<(_la-908))&-8657062153) != 0) || ((int64((_la-972)) & ^0x3f) == 0 && ((int64(1)<<(_la-972))&9079237589709023231) != 0) || ((int64((_la-1038)) & ^0x3f) == 0 && ((int64(1)<<(_la-1038))&-2326183592077590529) != 0) || ((int64((_la-1102)) & ^0x3f) == 0 && ((int64(1)<<(_la-1102))&-3476824025060605985) != 0) || ((int64((_la-1166)) & ^0x3f) == 0 && ((int64(1)<<(_la-1166))&9177698392048926103) != 0) || ((int64((_la-1230)) & ^0x3f) == 0 && ((int64(1)<<(_la-1230))&-6692513560713890065) != 0) || ((int64((_la-1294)) & ^0x3f) == 0 && ((int64(1)<<(_la-1294))&3168250653908631353) != 0) || ((int64((_la-1359)) & ^0x3f) == 0 && ((int64(1)<<(_la-1359))&9185082437627572219) != 0) || ((int64((_la-1423)) & ^0x3f) == 0 && ((int64(1)<<(_la-1423))&-325666705894277121) != 0) || ((int64((_la-1487)) & ^0x3f) == 0 && ((int64(1)<<(_la-1487))&-6924504331622301961) != 0) || ((int64((_la-1551)) & ^0x3f) == 0 && ((int64(1)<<(_la-1551))&9114141732558992703) != 0) || ((int64((_la-1616)) & ^0x3f) == 0 && ((int64(1)<<(_la-1616))&-4719776807533972241) != 0) || ((int64((_la-1681)) & ^0x3f) == 0 && ((int64(1)<<(_la-1681))&-1742176176349441) != 0) || ((int64((_la-1745)) & ^0x3f) == 0 && ((int64(1)<<(_la-1745))&-4503599888466177) != 0) || ((int64((_la-1809)) & ^0x3f) == 0 && ((int64(1)<<(_la-1809))&-134283265) != 0) || ((int64((_la-1873)) & ^0x3f) == 0 && ((int64(1)<<(_la-1873))&-1) != 0) || ((int64((_la-1937)) & ^0x3f) == 0 && ((int64(1)<<(_la-1937))&-7711290677094514689) != 0) || ((int64((_la-2001)) & ^0x3f) == 0 && ((int64(1)<<(_la-2001))&-2378192008461158403) != 0) || ((int64((_la-2065)) & ^0x3f) == 0 && ((int64(1)<<(_la-2065))&6880932590496218867) != 0) || ((int64((_la-2129)) & ^0x3f) == 0 && ((int64(1)<<(_la-2129))&-5490382038928256383) != 0) || ((int64((_la-2193)) & ^0x3f) == 0 && ((int64(1)<<(_la-2193))&8951124161462237) != 0) || ((int64((_la-2263)) & ^0x3f) == 0 && ((int64(1)<<(_la-2263))&266254307321) != 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 +} + +// IString_function_nameContext is an interface to support dynamic dispatch. +type IString_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + CHR() antlr.TerminalNode + DECODE() antlr.TerminalNode + SUBSTR() antlr.TerminalNode + TO_CHAR() antlr.TerminalNode + TRIM() antlr.TerminalNode + + // IsString_function_nameContext differentiates from other interfaces. + IsString_function_nameContext() +} + +type String_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyString_function_nameContext() *String_function_nameContext { + var p = new(String_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function_name + return p +} + +func InitEmptyString_function_nameContext(p *String_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_string_function_name +} + +func (*String_function_nameContext) IsString_function_nameContext() {} + +func NewString_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *String_function_nameContext { + var p = new(String_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_string_function_name + + return p +} + +func (s *String_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *String_function_nameContext) CHR() antlr.TerminalNode { + return s.GetToken(PlSqlParserCHR, 0) +} + +func (s *String_function_nameContext) DECODE() antlr.TerminalNode { + return s.GetToken(PlSqlParserDECODE, 0) +} + +func (s *String_function_nameContext) SUBSTR() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUBSTR, 0) +} + +func (s *String_function_nameContext) TO_CHAR() antlr.TerminalNode { + return s.GetToken(PlSqlParserTO_CHAR, 0) +} + +func (s *String_function_nameContext) TRIM() antlr.TerminalNode { + return s.GetToken(PlSqlParserTRIM, 0) +} + +func (s *String_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *String_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *String_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterString_function_name(s) + } +} + +func (s *String_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitString_function_name(s) + } +} + +func (s *String_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitString_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) String_function_name() (localctx IString_function_nameContext) { + localctx = NewString_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2388, PlSqlParserRULE_string_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20328) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCHR || ((int64((_la-2276)) & ^0x3f) == 0 && ((int64(1)<<(_la-2276))&229377) != 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 +} + +// INumeric_function_nameContext is an interface to support dynamic dispatch. +type INumeric_function_nameContext interface { + antlr.ParserRuleContext + + // GetParser returns the parser. + GetParser() antlr.Parser + + // Getter signatures + AVG() antlr.TerminalNode + COUNT() antlr.TerminalNode + NVL() antlr.TerminalNode + ROUND() antlr.TerminalNode + SUM() antlr.TerminalNode + + // IsNumeric_function_nameContext differentiates from other interfaces. + IsNumeric_function_nameContext() +} + +type Numeric_function_nameContext struct { + antlr.BaseParserRuleContext + parser antlr.Parser +} + +func NewEmptyNumeric_function_nameContext() *Numeric_function_nameContext { + var p = new(Numeric_function_nameContext) + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_name + return p +} + +func InitEmptyNumeric_function_nameContext(p *Numeric_function_nameContext) { + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, nil, -1) + p.RuleIndex = PlSqlParserRULE_numeric_function_name +} + +func (*Numeric_function_nameContext) IsNumeric_function_nameContext() {} + +func NewNumeric_function_nameContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *Numeric_function_nameContext { + var p = new(Numeric_function_nameContext) + + antlr.InitBaseParserRuleContext(&p.BaseParserRuleContext, parent, invokingState) + + p.parser = parser + p.RuleIndex = PlSqlParserRULE_numeric_function_name + + return p +} + +func (s *Numeric_function_nameContext) GetParser() antlr.Parser { return s.parser } + +func (s *Numeric_function_nameContext) AVG() antlr.TerminalNode { + return s.GetToken(PlSqlParserAVG, 0) +} + +func (s *Numeric_function_nameContext) COUNT() antlr.TerminalNode { + return s.GetToken(PlSqlParserCOUNT, 0) +} + +func (s *Numeric_function_nameContext) NVL() antlr.TerminalNode { + return s.GetToken(PlSqlParserNVL, 0) +} + +func (s *Numeric_function_nameContext) ROUND() antlr.TerminalNode { + return s.GetToken(PlSqlParserROUND, 0) +} + +func (s *Numeric_function_nameContext) SUM() antlr.TerminalNode { + return s.GetToken(PlSqlParserSUM, 0) +} + +func (s *Numeric_function_nameContext) GetRuleContext() antlr.RuleContext { + return s +} + +func (s *Numeric_function_nameContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string { + return antlr.TreesStringTree(s, ruleNames, recog) +} + +func (s *Numeric_function_nameContext) EnterRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.EnterNumeric_function_name(s) + } +} + +func (s *Numeric_function_nameContext) ExitRule(listener antlr.ParseTreeListener) { + if listenerT, ok := listener.(PlSqlParserListener); ok { + listenerT.ExitNumeric_function_name(s) + } +} + +func (s *Numeric_function_nameContext) Accept(visitor antlr.ParseTreeVisitor) interface{} { + switch t := visitor.(type) { + case PlSqlParserVisitor: + return t.VisitNumeric_function_name(s) + + default: + return t.VisitChildren(s) + } +} + +func (p *PlSqlParser) Numeric_function_name() (localctx INumeric_function_nameContext) { + localctx = NewNumeric_function_nameContext(p, p.GetParserRuleContext(), p.GetState()) + p.EnterRule(localctx, 2390, PlSqlParserRULE_numeric_function_name) + var _la int + + p.EnterOuterAlt(localctx, 1) + { + p.SetState(20330) + _la = p.GetTokenStream().LA(1) + + if !(_la == PlSqlParserCOUNT || ((int64((_la-2273)) & ^0x3f) == 0 && ((int64(1)<<(_la-2273))&2170881) != 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 *PlSqlParser) Sempred(localctx antlr.RuleContext, ruleIndex, predIndex int) bool { + switch ruleIndex { + case 356: + var t *Unified_auditingContext = nil + if localctx != nil { + t = localctx.(*Unified_auditingContext) + } + return p.Unified_auditing_Sempred(t, predIndex) + + case 359: + var t *Audit_direct_pathContext = nil + if localctx != nil { + t = localctx.(*Audit_direct_pathContext) + } + return p.Audit_direct_path_Sempred(t, predIndex) + + case 360: + var t *Audit_container_clauseContext = nil + if localctx != nil { + t = localctx.(*Audit_container_clauseContext) + } + return p.Audit_container_clause_Sempred(t, predIndex) + + case 366: + var t *Auditing_on_clauseContext = nil + if localctx != nil { + t = localctx.(*Auditing_on_clauseContext) + } + return p.Auditing_on_clause_Sempred(t, predIndex) + + case 370: + var t *Sql_statement_shortcutContext = nil + if localctx != nil { + t = localctx.(*Sql_statement_shortcutContext) + } + return p.Sql_statement_shortcut_Sempred(t, predIndex) + + case 402: + var t *Library_editionableContext = nil + if localctx != nil { + t = localctx.(*Library_editionableContext) + } + return p.Library_editionable_Sempred(t, predIndex) + + case 403: + var t *Library_debugContext = nil + if localctx != nil { + t = localctx.(*Library_debugContext) + } + return p.Library_debug_Sempred(t, predIndex) + + case 415: + var t *Alter_view_editionableContext = nil + if localctx != nil { + t = localctx.(*Alter_view_editionableContext) + } + return p.Alter_view_editionable_Sempred(t, predIndex) + + case 701: + var t *Partial_database_recovery_10gContext = nil + if localctx != nil { + t = localctx.(*Partial_database_recovery_10gContext) + } + return p.Partial_database_recovery_10g_Sempred(t, predIndex) + + case 837: + var t *Period_definitionContext = nil + if localctx != nil { + t = localctx.(*Period_definitionContext) + } + return p.Period_definition_Sempred(t, predIndex) + + case 956: + var t *Table_ref_auxContext = nil + if localctx != nil { + t = localctx.(*Table_ref_auxContext) + } + return p.Table_ref_aux_Sempred(t, predIndex) + + case 1041: + var t *Logical_expressionContext = nil + if localctx != nil { + t = localctx.(*Logical_expressionContext) + } + return p.Logical_expression_Sempred(t, predIndex) + + case 1045: + var t *Relational_expressionContext = nil + if localctx != nil { + t = localctx.(*Relational_expressionContext) + } + return p.Relational_expression_Sempred(t, predIndex) + + case 1050: + var t *ConcatenationContext = nil + if localctx != nil { + t = localctx.(*ConcatenationContext) + } + return p.Concatenation_Sempred(t, predIndex) + + default: + panic("No predicate with index: " + fmt.Sprint(ruleIndex)) + } +} + +func (p *PlSqlParser) Unified_auditing_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 0: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Audit_direct_path_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 1: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Audit_container_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 2: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Auditing_on_clause_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 3: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Sql_statement_shortcut_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 4: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Library_editionable_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 5: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Library_debug_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 6: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Alter_view_editionable_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 7: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Partial_database_recovery_10g_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 8: + return p.isVersion10() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Period_definition_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 9: + return p.isVersion12() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Table_ref_aux_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 10: + return p.IsTableAlias() + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Logical_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 11: + return p.Precpred(p.GetParserRuleContext(), 2) + + case 12: + return p.Precpred(p.GetParserRuleContext(), 1) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Relational_expression_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 13: + return p.Precpred(p.GetParserRuleContext(), 2) + + default: + panic("No predicate with index: " + fmt.Sprint(predIndex)) + } +} + +func (p *PlSqlParser) Concatenation_Sempred(localctx antlr.RuleContext, predIndex int) bool { + switch predIndex { + case 14: + return p.Precpred(p.GetParserRuleContext(), 3) + + 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/plsql/plsql_parser_base.go b/plsql/plsql_parser_base.go new file mode 100644 index 0000000..0600fe9 --- /dev/null +++ b/plsql/plsql_parser_base.go @@ -0,0 +1,32 @@ +package plsql + +import ( + "github.com/antlr4-go/antlr/v4" +) + +// PlSqlParserBase implementation. +type PlSqlParserBase struct { + *antlr.BaseParser + _isVersion12 bool + _isVersion10 bool +} + +func (p *PlSqlParserBase) IsTableAlias() bool { + return p.GetCurrentToken().GetTokenType() != PlSqlLexerJOIN +} + +func (p *PlSqlParserBase) isVersion12() bool { + return p._isVersion12 +} + +func (p *PlSqlParserBase) SetVersion12(value bool) { + p._isVersion12 = value +} + +func (p *PlSqlParserBase) isVersion10() bool { + return p._isVersion10 +} + +func (p *PlSqlParserBase) SetVersion10(value bool) { + p._isVersion10 = value +} diff --git a/plsql/plsqlparser_base_listener.go b/plsql/plsqlparser_base_listener.go new file mode 100644 index 0000000..f896bb1 --- /dev/null +++ b/plsql/plsqlparser_base_listener.go @@ -0,0 +1,7629 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +// BasePlSqlParserListener is a complete listener for a parse tree produced by PlSqlParser. +type BasePlSqlParserListener struct{} + +var _ PlSqlParserListener = &BasePlSqlParserListener{} + +// VisitTerminal is called when a terminal node is visited. +func (s *BasePlSqlParserListener) VisitTerminal(node antlr.TerminalNode) {} + +// VisitErrorNode is called when an error node is visited. +func (s *BasePlSqlParserListener) VisitErrorNode(node antlr.ErrorNode) {} + +// EnterEveryRule is called when any rule is entered. +func (s *BasePlSqlParserListener) EnterEveryRule(ctx antlr.ParserRuleContext) {} + +// ExitEveryRule is called when any rule is exited. +func (s *BasePlSqlParserListener) ExitEveryRule(ctx antlr.ParserRuleContext) {} + +// EnterSql_script is called when production sql_script is entered. +func (s *BasePlSqlParserListener) EnterSql_script(ctx *Sql_scriptContext) {} + +// ExitSql_script is called when production sql_script is exited. +func (s *BasePlSqlParserListener) ExitSql_script(ctx *Sql_scriptContext) {} + +// EnterUnit_statement is called when production unit_statement is entered. +func (s *BasePlSqlParserListener) EnterUnit_statement(ctx *Unit_statementContext) {} + +// ExitUnit_statement is called when production unit_statement is exited. +func (s *BasePlSqlParserListener) ExitUnit_statement(ctx *Unit_statementContext) {} + +// EnterAlter_diskgroup is called when production alter_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterAlter_diskgroup(ctx *Alter_diskgroupContext) {} + +// ExitAlter_diskgroup is called when production alter_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitAlter_diskgroup(ctx *Alter_diskgroupContext) {} + +// EnterAdd_disk_clause is called when production add_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_disk_clause(ctx *Add_disk_clauseContext) {} + +// ExitAdd_disk_clause is called when production add_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_disk_clause(ctx *Add_disk_clauseContext) {} + +// EnterDrop_disk_clause is called when production drop_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_disk_clause(ctx *Drop_disk_clauseContext) {} + +// ExitDrop_disk_clause is called when production drop_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_disk_clause(ctx *Drop_disk_clauseContext) {} + +// EnterResize_disk_clause is called when production resize_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterResize_disk_clause(ctx *Resize_disk_clauseContext) {} + +// ExitResize_disk_clause is called when production resize_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitResize_disk_clause(ctx *Resize_disk_clauseContext) {} + +// EnterReplace_disk_clause is called when production replace_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterReplace_disk_clause(ctx *Replace_disk_clauseContext) {} + +// ExitReplace_disk_clause is called when production replace_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitReplace_disk_clause(ctx *Replace_disk_clauseContext) {} + +// EnterWait_nowait is called when production wait_nowait is entered. +func (s *BasePlSqlParserListener) EnterWait_nowait(ctx *Wait_nowaitContext) {} + +// ExitWait_nowait is called when production wait_nowait is exited. +func (s *BasePlSqlParserListener) ExitWait_nowait(ctx *Wait_nowaitContext) {} + +// EnterRename_disk_clause is called when production rename_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterRename_disk_clause(ctx *Rename_disk_clauseContext) {} + +// ExitRename_disk_clause is called when production rename_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitRename_disk_clause(ctx *Rename_disk_clauseContext) {} + +// EnterDisk_online_clause is called when production disk_online_clause is entered. +func (s *BasePlSqlParserListener) EnterDisk_online_clause(ctx *Disk_online_clauseContext) {} + +// ExitDisk_online_clause is called when production disk_online_clause is exited. +func (s *BasePlSqlParserListener) ExitDisk_online_clause(ctx *Disk_online_clauseContext) {} + +// EnterDisk_offline_clause is called when production disk_offline_clause is entered. +func (s *BasePlSqlParserListener) EnterDisk_offline_clause(ctx *Disk_offline_clauseContext) {} + +// ExitDisk_offline_clause is called when production disk_offline_clause is exited. +func (s *BasePlSqlParserListener) ExitDisk_offline_clause(ctx *Disk_offline_clauseContext) {} + +// EnterTimeout_clause is called when production timeout_clause is entered. +func (s *BasePlSqlParserListener) EnterTimeout_clause(ctx *Timeout_clauseContext) {} + +// ExitTimeout_clause is called when production timeout_clause is exited. +func (s *BasePlSqlParserListener) ExitTimeout_clause(ctx *Timeout_clauseContext) {} + +// EnterRebalance_diskgroup_clause is called when production rebalance_diskgroup_clause is entered. +func (s *BasePlSqlParserListener) EnterRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) { +} + +// ExitRebalance_diskgroup_clause is called when production rebalance_diskgroup_clause is exited. +func (s *BasePlSqlParserListener) ExitRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) { +} + +// EnterPhase is called when production phase is entered. +func (s *BasePlSqlParserListener) EnterPhase(ctx *PhaseContext) {} + +// ExitPhase is called when production phase is exited. +func (s *BasePlSqlParserListener) ExitPhase(ctx *PhaseContext) {} + +// EnterCheck_diskgroup_clause is called when production check_diskgroup_clause is entered. +func (s *BasePlSqlParserListener) EnterCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) {} + +// ExitCheck_diskgroup_clause is called when production check_diskgroup_clause is exited. +func (s *BasePlSqlParserListener) ExitCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) {} + +// EnterDiskgroup_template_clauses is called when production diskgroup_template_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) { +} + +// ExitDiskgroup_template_clauses is called when production diskgroup_template_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) { +} + +// EnterQualified_template_clause is called when production qualified_template_clause is entered. +func (s *BasePlSqlParserListener) EnterQualified_template_clause(ctx *Qualified_template_clauseContext) { +} + +// ExitQualified_template_clause is called when production qualified_template_clause is exited. +func (s *BasePlSqlParserListener) ExitQualified_template_clause(ctx *Qualified_template_clauseContext) { +} + +// EnterRedundancy_clause is called when production redundancy_clause is entered. +func (s *BasePlSqlParserListener) EnterRedundancy_clause(ctx *Redundancy_clauseContext) {} + +// ExitRedundancy_clause is called when production redundancy_clause is exited. +func (s *BasePlSqlParserListener) ExitRedundancy_clause(ctx *Redundancy_clauseContext) {} + +// EnterStriping_clause is called when production striping_clause is entered. +func (s *BasePlSqlParserListener) EnterStriping_clause(ctx *Striping_clauseContext) {} + +// ExitStriping_clause is called when production striping_clause is exited. +func (s *BasePlSqlParserListener) ExitStriping_clause(ctx *Striping_clauseContext) {} + +// EnterForce_noforce is called when production force_noforce is entered. +func (s *BasePlSqlParserListener) EnterForce_noforce(ctx *Force_noforceContext) {} + +// ExitForce_noforce is called when production force_noforce is exited. +func (s *BasePlSqlParserListener) ExitForce_noforce(ctx *Force_noforceContext) {} + +// EnterDiskgroup_directory_clauses is called when production diskgroup_directory_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) { +} + +// ExitDiskgroup_directory_clauses is called when production diskgroup_directory_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) { +} + +// EnterDir_name is called when production dir_name is entered. +func (s *BasePlSqlParserListener) EnterDir_name(ctx *Dir_nameContext) {} + +// ExitDir_name is called when production dir_name is exited. +func (s *BasePlSqlParserListener) ExitDir_name(ctx *Dir_nameContext) {} + +// EnterDiskgroup_alias_clauses is called when production diskgroup_alias_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) {} + +// ExitDiskgroup_alias_clauses is called when production diskgroup_alias_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) {} + +// EnterDiskgroup_volume_clauses is called when production diskgroup_volume_clauses is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) { +} + +// ExitDiskgroup_volume_clauses is called when production diskgroup_volume_clauses is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) { +} + +// EnterAdd_volume_clause is called when production add_volume_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_volume_clause(ctx *Add_volume_clauseContext) {} + +// ExitAdd_volume_clause is called when production add_volume_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_volume_clause(ctx *Add_volume_clauseContext) {} + +// EnterModify_volume_clause is called when production modify_volume_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_volume_clause(ctx *Modify_volume_clauseContext) {} + +// ExitModify_volume_clause is called when production modify_volume_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_volume_clause(ctx *Modify_volume_clauseContext) {} + +// EnterDiskgroup_attributes is called when production diskgroup_attributes is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_attributes(ctx *Diskgroup_attributesContext) {} + +// ExitDiskgroup_attributes is called when production diskgroup_attributes is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_attributes(ctx *Diskgroup_attributesContext) {} + +// EnterModify_diskgroup_file is called when production modify_diskgroup_file is entered. +func (s *BasePlSqlParserListener) EnterModify_diskgroup_file(ctx *Modify_diskgroup_fileContext) {} + +// ExitModify_diskgroup_file is called when production modify_diskgroup_file is exited. +func (s *BasePlSqlParserListener) ExitModify_diskgroup_file(ctx *Modify_diskgroup_fileContext) {} + +// EnterDisk_region_clause is called when production disk_region_clause is entered. +func (s *BasePlSqlParserListener) EnterDisk_region_clause(ctx *Disk_region_clauseContext) {} + +// ExitDisk_region_clause is called when production disk_region_clause is exited. +func (s *BasePlSqlParserListener) ExitDisk_region_clause(ctx *Disk_region_clauseContext) {} + +// EnterDrop_diskgroup_file_clause is called when production drop_diskgroup_file_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) { +} + +// ExitDrop_diskgroup_file_clause is called when production drop_diskgroup_file_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) { +} + +// EnterConvert_redundancy_clause is called when production convert_redundancy_clause is entered. +func (s *BasePlSqlParserListener) EnterConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) { +} + +// ExitConvert_redundancy_clause is called when production convert_redundancy_clause is exited. +func (s *BasePlSqlParserListener) ExitConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) { +} + +// EnterUsergroup_clauses is called when production usergroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterUsergroup_clauses(ctx *Usergroup_clausesContext) {} + +// ExitUsergroup_clauses is called when production usergroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitUsergroup_clauses(ctx *Usergroup_clausesContext) {} + +// EnterUser_clauses is called when production user_clauses is entered. +func (s *BasePlSqlParserListener) EnterUser_clauses(ctx *User_clausesContext) {} + +// ExitUser_clauses is called when production user_clauses is exited. +func (s *BasePlSqlParserListener) ExitUser_clauses(ctx *User_clausesContext) {} + +// EnterFile_permissions_clause is called when production file_permissions_clause is entered. +func (s *BasePlSqlParserListener) EnterFile_permissions_clause(ctx *File_permissions_clauseContext) {} + +// ExitFile_permissions_clause is called when production file_permissions_clause is exited. +func (s *BasePlSqlParserListener) ExitFile_permissions_clause(ctx *File_permissions_clauseContext) {} + +// EnterFile_owner_clause is called when production file_owner_clause is entered. +func (s *BasePlSqlParserListener) EnterFile_owner_clause(ctx *File_owner_clauseContext) {} + +// ExitFile_owner_clause is called when production file_owner_clause is exited. +func (s *BasePlSqlParserListener) ExitFile_owner_clause(ctx *File_owner_clauseContext) {} + +// EnterScrub_clause is called when production scrub_clause is entered. +func (s *BasePlSqlParserListener) EnterScrub_clause(ctx *Scrub_clauseContext) {} + +// ExitScrub_clause is called when production scrub_clause is exited. +func (s *BasePlSqlParserListener) ExitScrub_clause(ctx *Scrub_clauseContext) {} + +// EnterQuotagroup_clauses is called when production quotagroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterQuotagroup_clauses(ctx *Quotagroup_clausesContext) {} + +// ExitQuotagroup_clauses is called when production quotagroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitQuotagroup_clauses(ctx *Quotagroup_clausesContext) {} + +// EnterProperty_name is called when production property_name is entered. +func (s *BasePlSqlParserListener) EnterProperty_name(ctx *Property_nameContext) {} + +// ExitProperty_name is called when production property_name is exited. +func (s *BasePlSqlParserListener) ExitProperty_name(ctx *Property_nameContext) {} + +// EnterProperty_value is called when production property_value is entered. +func (s *BasePlSqlParserListener) EnterProperty_value(ctx *Property_valueContext) {} + +// ExitProperty_value is called when production property_value is exited. +func (s *BasePlSqlParserListener) ExitProperty_value(ctx *Property_valueContext) {} + +// EnterFilegroup_clauses is called when production filegroup_clauses is entered. +func (s *BasePlSqlParserListener) EnterFilegroup_clauses(ctx *Filegroup_clausesContext) {} + +// ExitFilegroup_clauses is called when production filegroup_clauses is exited. +func (s *BasePlSqlParserListener) ExitFilegroup_clauses(ctx *Filegroup_clausesContext) {} + +// EnterAdd_filegroup_clause is called when production add_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) {} + +// ExitAdd_filegroup_clause is called when production add_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) {} + +// EnterModify_filegroup_clause is called when production modify_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) {} + +// ExitModify_filegroup_clause is called when production modify_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) {} + +// EnterMove_to_filegroup_clause is called when production move_to_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) { +} + +// ExitMove_to_filegroup_clause is called when production move_to_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) { +} + +// EnterDrop_filegroup_clause is called when production drop_filegroup_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) {} + +// ExitDrop_filegroup_clause is called when production drop_filegroup_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) {} + +// EnterQuorum_regular is called when production quorum_regular is entered. +func (s *BasePlSqlParserListener) EnterQuorum_regular(ctx *Quorum_regularContext) {} + +// ExitQuorum_regular is called when production quorum_regular is exited. +func (s *BasePlSqlParserListener) ExitQuorum_regular(ctx *Quorum_regularContext) {} + +// EnterUndrop_disk_clause is called when production undrop_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterUndrop_disk_clause(ctx *Undrop_disk_clauseContext) {} + +// ExitUndrop_disk_clause is called when production undrop_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitUndrop_disk_clause(ctx *Undrop_disk_clauseContext) {} + +// EnterDiskgroup_availability is called when production diskgroup_availability is entered. +func (s *BasePlSqlParserListener) EnterDiskgroup_availability(ctx *Diskgroup_availabilityContext) {} + +// ExitDiskgroup_availability is called when production diskgroup_availability is exited. +func (s *BasePlSqlParserListener) ExitDiskgroup_availability(ctx *Diskgroup_availabilityContext) {} + +// EnterEnable_disable_volume is called when production enable_disable_volume is entered. +func (s *BasePlSqlParserListener) EnterEnable_disable_volume(ctx *Enable_disable_volumeContext) {} + +// ExitEnable_disable_volume is called when production enable_disable_volume is exited. +func (s *BasePlSqlParserListener) ExitEnable_disable_volume(ctx *Enable_disable_volumeContext) {} + +// EnterDrop_function is called when production drop_function is entered. +func (s *BasePlSqlParserListener) EnterDrop_function(ctx *Drop_functionContext) {} + +// ExitDrop_function is called when production drop_function is exited. +func (s *BasePlSqlParserListener) ExitDrop_function(ctx *Drop_functionContext) {} + +// EnterAlter_flashback_archive is called when production alter_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterAlter_flashback_archive(ctx *Alter_flashback_archiveContext) {} + +// ExitAlter_flashback_archive is called when production alter_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitAlter_flashback_archive(ctx *Alter_flashback_archiveContext) {} + +// EnterAlter_hierarchy is called when production alter_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterAlter_hierarchy(ctx *Alter_hierarchyContext) {} + +// ExitAlter_hierarchy is called when production alter_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitAlter_hierarchy(ctx *Alter_hierarchyContext) {} + +// EnterAlter_function is called when production alter_function is entered. +func (s *BasePlSqlParserListener) EnterAlter_function(ctx *Alter_functionContext) {} + +// ExitAlter_function is called when production alter_function is exited. +func (s *BasePlSqlParserListener) ExitAlter_function(ctx *Alter_functionContext) {} + +// EnterAlter_java is called when production alter_java is entered. +func (s *BasePlSqlParserListener) EnterAlter_java(ctx *Alter_javaContext) {} + +// ExitAlter_java is called when production alter_java is exited. +func (s *BasePlSqlParserListener) ExitAlter_java(ctx *Alter_javaContext) {} + +// EnterMatch_string is called when production match_string is entered. +func (s *BasePlSqlParserListener) EnterMatch_string(ctx *Match_stringContext) {} + +// ExitMatch_string is called when production match_string is exited. +func (s *BasePlSqlParserListener) ExitMatch_string(ctx *Match_stringContext) {} + +// EnterCreate_function_body is called when production create_function_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_function_body(ctx *Create_function_bodyContext) {} + +// ExitCreate_function_body is called when production create_function_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_function_body(ctx *Create_function_bodyContext) {} + +// EnterSql_macro_body is called when production sql_macro_body is entered. +func (s *BasePlSqlParserListener) EnterSql_macro_body(ctx *Sql_macro_bodyContext) {} + +// ExitSql_macro_body is called when production sql_macro_body is exited. +func (s *BasePlSqlParserListener) ExitSql_macro_body(ctx *Sql_macro_bodyContext) {} + +// EnterParallel_enable_clause is called when production parallel_enable_clause is entered. +func (s *BasePlSqlParserListener) EnterParallel_enable_clause(ctx *Parallel_enable_clauseContext) {} + +// ExitParallel_enable_clause is called when production parallel_enable_clause is exited. +func (s *BasePlSqlParserListener) ExitParallel_enable_clause(ctx *Parallel_enable_clauseContext) {} + +// EnterPartition_by_clause is called when production partition_by_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// ExitPartition_by_clause is called when production partition_by_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_by_clause(ctx *Partition_by_clauseContext) {} + +// EnterResult_cache_clause is called when production result_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterResult_cache_clause(ctx *Result_cache_clauseContext) {} + +// ExitResult_cache_clause is called when production result_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitResult_cache_clause(ctx *Result_cache_clauseContext) {} + +// EnterRelies_on_part is called when production relies_on_part is entered. +func (s *BasePlSqlParserListener) EnterRelies_on_part(ctx *Relies_on_partContext) {} + +// ExitRelies_on_part is called when production relies_on_part is exited. +func (s *BasePlSqlParserListener) ExitRelies_on_part(ctx *Relies_on_partContext) {} + +// EnterStreaming_clause is called when production streaming_clause is entered. +func (s *BasePlSqlParserListener) EnterStreaming_clause(ctx *Streaming_clauseContext) {} + +// ExitStreaming_clause is called when production streaming_clause is exited. +func (s *BasePlSqlParserListener) ExitStreaming_clause(ctx *Streaming_clauseContext) {} + +// EnterAlter_outline is called when production alter_outline is entered. +func (s *BasePlSqlParserListener) EnterAlter_outline(ctx *Alter_outlineContext) {} + +// ExitAlter_outline is called when production alter_outline is exited. +func (s *BasePlSqlParserListener) ExitAlter_outline(ctx *Alter_outlineContext) {} + +// EnterOutline_options is called when production outline_options is entered. +func (s *BasePlSqlParserListener) EnterOutline_options(ctx *Outline_optionsContext) {} + +// ExitOutline_options is called when production outline_options is exited. +func (s *BasePlSqlParserListener) ExitOutline_options(ctx *Outline_optionsContext) {} + +// EnterAlter_lockdown_profile is called when production alter_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) {} + +// ExitAlter_lockdown_profile is called when production alter_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) {} + +// EnterLockdown_feature is called when production lockdown_feature is entered. +func (s *BasePlSqlParserListener) EnterLockdown_feature(ctx *Lockdown_featureContext) {} + +// ExitLockdown_feature is called when production lockdown_feature is exited. +func (s *BasePlSqlParserListener) ExitLockdown_feature(ctx *Lockdown_featureContext) {} + +// EnterLockdown_options is called when production lockdown_options is entered. +func (s *BasePlSqlParserListener) EnterLockdown_options(ctx *Lockdown_optionsContext) {} + +// ExitLockdown_options is called when production lockdown_options is exited. +func (s *BasePlSqlParserListener) ExitLockdown_options(ctx *Lockdown_optionsContext) {} + +// EnterLockdown_statements is called when production lockdown_statements is entered. +func (s *BasePlSqlParserListener) EnterLockdown_statements(ctx *Lockdown_statementsContext) {} + +// ExitLockdown_statements is called when production lockdown_statements is exited. +func (s *BasePlSqlParserListener) ExitLockdown_statements(ctx *Lockdown_statementsContext) {} + +// EnterStatement_clauses is called when production statement_clauses is entered. +func (s *BasePlSqlParserListener) EnterStatement_clauses(ctx *Statement_clausesContext) {} + +// ExitStatement_clauses is called when production statement_clauses is exited. +func (s *BasePlSqlParserListener) ExitStatement_clauses(ctx *Statement_clausesContext) {} + +// EnterClause_options is called when production clause_options is entered. +func (s *BasePlSqlParserListener) EnterClause_options(ctx *Clause_optionsContext) {} + +// ExitClause_options is called when production clause_options is exited. +func (s *BasePlSqlParserListener) ExitClause_options(ctx *Clause_optionsContext) {} + +// EnterOption_values is called when production option_values is entered. +func (s *BasePlSqlParserListener) EnterOption_values(ctx *Option_valuesContext) {} + +// ExitOption_values is called when production option_values is exited. +func (s *BasePlSqlParserListener) ExitOption_values(ctx *Option_valuesContext) {} + +// EnterString_list is called when production string_list is entered. +func (s *BasePlSqlParserListener) EnterString_list(ctx *String_listContext) {} + +// ExitString_list is called when production string_list is exited. +func (s *BasePlSqlParserListener) ExitString_list(ctx *String_listContext) {} + +// EnterDisable_enable is called when production disable_enable is entered. +func (s *BasePlSqlParserListener) EnterDisable_enable(ctx *Disable_enableContext) {} + +// ExitDisable_enable is called when production disable_enable is exited. +func (s *BasePlSqlParserListener) ExitDisable_enable(ctx *Disable_enableContext) {} + +// EnterDrop_lockdown_profile is called when production drop_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) {} + +// ExitDrop_lockdown_profile is called when production drop_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) {} + +// EnterDrop_package is called when production drop_package is entered. +func (s *BasePlSqlParserListener) EnterDrop_package(ctx *Drop_packageContext) {} + +// ExitDrop_package is called when production drop_package is exited. +func (s *BasePlSqlParserListener) ExitDrop_package(ctx *Drop_packageContext) {} + +// EnterAlter_package is called when production alter_package is entered. +func (s *BasePlSqlParserListener) EnterAlter_package(ctx *Alter_packageContext) {} + +// ExitAlter_package is called when production alter_package is exited. +func (s *BasePlSqlParserListener) ExitAlter_package(ctx *Alter_packageContext) {} + +// EnterCreate_package is called when production create_package is entered. +func (s *BasePlSqlParserListener) EnterCreate_package(ctx *Create_packageContext) {} + +// ExitCreate_package is called when production create_package is exited. +func (s *BasePlSqlParserListener) ExitCreate_package(ctx *Create_packageContext) {} + +// EnterCreate_package_body is called when production create_package_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_package_body(ctx *Create_package_bodyContext) {} + +// ExitCreate_package_body is called when production create_package_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_package_body(ctx *Create_package_bodyContext) {} + +// EnterPackage_obj_spec is called when production package_obj_spec is entered. +func (s *BasePlSqlParserListener) EnterPackage_obj_spec(ctx *Package_obj_specContext) {} + +// ExitPackage_obj_spec is called when production package_obj_spec is exited. +func (s *BasePlSqlParserListener) ExitPackage_obj_spec(ctx *Package_obj_specContext) {} + +// EnterProcedure_spec is called when production procedure_spec is entered. +func (s *BasePlSqlParserListener) EnterProcedure_spec(ctx *Procedure_specContext) {} + +// ExitProcedure_spec is called when production procedure_spec is exited. +func (s *BasePlSqlParserListener) ExitProcedure_spec(ctx *Procedure_specContext) {} + +// EnterFunction_spec is called when production function_spec is entered. +func (s *BasePlSqlParserListener) EnterFunction_spec(ctx *Function_specContext) {} + +// ExitFunction_spec is called when production function_spec is exited. +func (s *BasePlSqlParserListener) ExitFunction_spec(ctx *Function_specContext) {} + +// EnterPackage_obj_body is called when production package_obj_body is entered. +func (s *BasePlSqlParserListener) EnterPackage_obj_body(ctx *Package_obj_bodyContext) {} + +// ExitPackage_obj_body is called when production package_obj_body is exited. +func (s *BasePlSqlParserListener) ExitPackage_obj_body(ctx *Package_obj_bodyContext) {} + +// EnterAlter_pmem_filestore is called when production alter_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) {} + +// ExitAlter_pmem_filestore is called when production alter_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) {} + +// EnterDrop_pmem_filestore is called when production drop_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) {} + +// ExitDrop_pmem_filestore is called when production drop_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) {} + +// EnterDrop_procedure is called when production drop_procedure is entered. +func (s *BasePlSqlParserListener) EnterDrop_procedure(ctx *Drop_procedureContext) {} + +// ExitDrop_procedure is called when production drop_procedure is exited. +func (s *BasePlSqlParserListener) ExitDrop_procedure(ctx *Drop_procedureContext) {} + +// EnterAlter_procedure is called when production alter_procedure is entered. +func (s *BasePlSqlParserListener) EnterAlter_procedure(ctx *Alter_procedureContext) {} + +// ExitAlter_procedure is called when production alter_procedure is exited. +func (s *BasePlSqlParserListener) ExitAlter_procedure(ctx *Alter_procedureContext) {} + +// EnterFunction_body is called when production function_body is entered. +func (s *BasePlSqlParserListener) EnterFunction_body(ctx *Function_bodyContext) {} + +// ExitFunction_body is called when production function_body is exited. +func (s *BasePlSqlParserListener) ExitFunction_body(ctx *Function_bodyContext) {} + +// EnterProcedure_body is called when production procedure_body is entered. +func (s *BasePlSqlParserListener) EnterProcedure_body(ctx *Procedure_bodyContext) {} + +// ExitProcedure_body is called when production procedure_body is exited. +func (s *BasePlSqlParserListener) ExitProcedure_body(ctx *Procedure_bodyContext) {} + +// EnterCreate_procedure_body is called when production create_procedure_body is entered. +func (s *BasePlSqlParserListener) EnterCreate_procedure_body(ctx *Create_procedure_bodyContext) {} + +// ExitCreate_procedure_body is called when production create_procedure_body is exited. +func (s *BasePlSqlParserListener) ExitCreate_procedure_body(ctx *Create_procedure_bodyContext) {} + +// EnterAlter_resource_cost is called when production alter_resource_cost is entered. +func (s *BasePlSqlParserListener) EnterAlter_resource_cost(ctx *Alter_resource_costContext) {} + +// ExitAlter_resource_cost is called when production alter_resource_cost is exited. +func (s *BasePlSqlParserListener) ExitAlter_resource_cost(ctx *Alter_resource_costContext) {} + +// EnterDrop_outline is called when production drop_outline is entered. +func (s *BasePlSqlParserListener) EnterDrop_outline(ctx *Drop_outlineContext) {} + +// ExitDrop_outline is called when production drop_outline is exited. +func (s *BasePlSqlParserListener) ExitDrop_outline(ctx *Drop_outlineContext) {} + +// EnterAlter_rollback_segment is called when production alter_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterAlter_rollback_segment(ctx *Alter_rollback_segmentContext) {} + +// ExitAlter_rollback_segment is called when production alter_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitAlter_rollback_segment(ctx *Alter_rollback_segmentContext) {} + +// EnterDrop_restore_point is called when production drop_restore_point is entered. +func (s *BasePlSqlParserListener) EnterDrop_restore_point(ctx *Drop_restore_pointContext) {} + +// ExitDrop_restore_point is called when production drop_restore_point is exited. +func (s *BasePlSqlParserListener) ExitDrop_restore_point(ctx *Drop_restore_pointContext) {} + +// EnterDrop_rollback_segment is called when production drop_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterDrop_rollback_segment(ctx *Drop_rollback_segmentContext) {} + +// ExitDrop_rollback_segment is called when production drop_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitDrop_rollback_segment(ctx *Drop_rollback_segmentContext) {} + +// EnterDrop_role is called when production drop_role is entered. +func (s *BasePlSqlParserListener) EnterDrop_role(ctx *Drop_roleContext) {} + +// ExitDrop_role is called when production drop_role is exited. +func (s *BasePlSqlParserListener) ExitDrop_role(ctx *Drop_roleContext) {} + +// EnterCreate_pmem_filestore is called when production create_pmem_filestore is entered. +func (s *BasePlSqlParserListener) EnterCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) {} + +// ExitCreate_pmem_filestore is called when production create_pmem_filestore is exited. +func (s *BasePlSqlParserListener) ExitCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) {} + +// EnterPmem_filestore_options is called when production pmem_filestore_options is entered. +func (s *BasePlSqlParserListener) EnterPmem_filestore_options(ctx *Pmem_filestore_optionsContext) {} + +// ExitPmem_filestore_options is called when production pmem_filestore_options is exited. +func (s *BasePlSqlParserListener) ExitPmem_filestore_options(ctx *Pmem_filestore_optionsContext) {} + +// EnterFile_path is called when production file_path is entered. +func (s *BasePlSqlParserListener) EnterFile_path(ctx *File_pathContext) {} + +// ExitFile_path is called when production file_path is exited. +func (s *BasePlSqlParserListener) ExitFile_path(ctx *File_pathContext) {} + +// EnterCreate_rollback_segment is called when production create_rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterCreate_rollback_segment(ctx *Create_rollback_segmentContext) {} + +// ExitCreate_rollback_segment is called when production create_rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitCreate_rollback_segment(ctx *Create_rollback_segmentContext) {} + +// EnterDrop_trigger is called when production drop_trigger is entered. +func (s *BasePlSqlParserListener) EnterDrop_trigger(ctx *Drop_triggerContext) {} + +// ExitDrop_trigger is called when production drop_trigger is exited. +func (s *BasePlSqlParserListener) ExitDrop_trigger(ctx *Drop_triggerContext) {} + +// EnterAlter_trigger is called when production alter_trigger is entered. +func (s *BasePlSqlParserListener) EnterAlter_trigger(ctx *Alter_triggerContext) {} + +// ExitAlter_trigger is called when production alter_trigger is exited. +func (s *BasePlSqlParserListener) ExitAlter_trigger(ctx *Alter_triggerContext) {} + +// EnterCreate_trigger is called when production create_trigger is entered. +func (s *BasePlSqlParserListener) EnterCreate_trigger(ctx *Create_triggerContext) {} + +// ExitCreate_trigger is called when production create_trigger is exited. +func (s *BasePlSqlParserListener) ExitCreate_trigger(ctx *Create_triggerContext) {} + +// EnterTrigger_follows_clause is called when production trigger_follows_clause is entered. +func (s *BasePlSqlParserListener) EnterTrigger_follows_clause(ctx *Trigger_follows_clauseContext) {} + +// ExitTrigger_follows_clause is called when production trigger_follows_clause is exited. +func (s *BasePlSqlParserListener) ExitTrigger_follows_clause(ctx *Trigger_follows_clauseContext) {} + +// EnterTrigger_when_clause is called when production trigger_when_clause is entered. +func (s *BasePlSqlParserListener) EnterTrigger_when_clause(ctx *Trigger_when_clauseContext) {} + +// ExitTrigger_when_clause is called when production trigger_when_clause is exited. +func (s *BasePlSqlParserListener) ExitTrigger_when_clause(ctx *Trigger_when_clauseContext) {} + +// EnterSimple_dml_trigger is called when production simple_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterSimple_dml_trigger(ctx *Simple_dml_triggerContext) {} + +// ExitSimple_dml_trigger is called when production simple_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitSimple_dml_trigger(ctx *Simple_dml_triggerContext) {} + +// EnterFor_each_row is called when production for_each_row is entered. +func (s *BasePlSqlParserListener) EnterFor_each_row(ctx *For_each_rowContext) {} + +// ExitFor_each_row is called when production for_each_row is exited. +func (s *BasePlSqlParserListener) ExitFor_each_row(ctx *For_each_rowContext) {} + +// EnterCompound_dml_trigger is called when production compound_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterCompound_dml_trigger(ctx *Compound_dml_triggerContext) {} + +// ExitCompound_dml_trigger is called when production compound_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitCompound_dml_trigger(ctx *Compound_dml_triggerContext) {} + +// EnterNon_dml_trigger is called when production non_dml_trigger is entered. +func (s *BasePlSqlParserListener) EnterNon_dml_trigger(ctx *Non_dml_triggerContext) {} + +// ExitNon_dml_trigger is called when production non_dml_trigger is exited. +func (s *BasePlSqlParserListener) ExitNon_dml_trigger(ctx *Non_dml_triggerContext) {} + +// EnterTrigger_body is called when production trigger_body is entered. +func (s *BasePlSqlParserListener) EnterTrigger_body(ctx *Trigger_bodyContext) {} + +// ExitTrigger_body is called when production trigger_body is exited. +func (s *BasePlSqlParserListener) ExitTrigger_body(ctx *Trigger_bodyContext) {} + +// EnterRoutine_clause is called when production routine_clause is entered. +func (s *BasePlSqlParserListener) EnterRoutine_clause(ctx *Routine_clauseContext) {} + +// ExitRoutine_clause is called when production routine_clause is exited. +func (s *BasePlSqlParserListener) ExitRoutine_clause(ctx *Routine_clauseContext) {} + +// EnterCompound_trigger_block is called when production compound_trigger_block is entered. +func (s *BasePlSqlParserListener) EnterCompound_trigger_block(ctx *Compound_trigger_blockContext) {} + +// ExitCompound_trigger_block is called when production compound_trigger_block is exited. +func (s *BasePlSqlParserListener) ExitCompound_trigger_block(ctx *Compound_trigger_blockContext) {} + +// EnterTiming_point_section is called when production timing_point_section is entered. +func (s *BasePlSqlParserListener) EnterTiming_point_section(ctx *Timing_point_sectionContext) {} + +// ExitTiming_point_section is called when production timing_point_section is exited. +func (s *BasePlSqlParserListener) ExitTiming_point_section(ctx *Timing_point_sectionContext) {} + +// EnterNon_dml_event is called when production non_dml_event is entered. +func (s *BasePlSqlParserListener) EnterNon_dml_event(ctx *Non_dml_eventContext) {} + +// ExitNon_dml_event is called when production non_dml_event is exited. +func (s *BasePlSqlParserListener) ExitNon_dml_event(ctx *Non_dml_eventContext) {} + +// EnterDml_event_clause is called when production dml_event_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_event_clause(ctx *Dml_event_clauseContext) {} + +// ExitDml_event_clause is called when production dml_event_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_event_clause(ctx *Dml_event_clauseContext) {} + +// EnterDml_event_element is called when production dml_event_element is entered. +func (s *BasePlSqlParserListener) EnterDml_event_element(ctx *Dml_event_elementContext) {} + +// ExitDml_event_element is called when production dml_event_element is exited. +func (s *BasePlSqlParserListener) ExitDml_event_element(ctx *Dml_event_elementContext) {} + +// EnterDml_event_nested_clause is called when production dml_event_nested_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) {} + +// ExitDml_event_nested_clause is called when production dml_event_nested_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) {} + +// EnterReferencing_clause is called when production referencing_clause is entered. +func (s *BasePlSqlParserListener) EnterReferencing_clause(ctx *Referencing_clauseContext) {} + +// ExitReferencing_clause is called when production referencing_clause is exited. +func (s *BasePlSqlParserListener) ExitReferencing_clause(ctx *Referencing_clauseContext) {} + +// EnterReferencing_element is called when production referencing_element is entered. +func (s *BasePlSqlParserListener) EnterReferencing_element(ctx *Referencing_elementContext) {} + +// ExitReferencing_element is called when production referencing_element is exited. +func (s *BasePlSqlParserListener) ExitReferencing_element(ctx *Referencing_elementContext) {} + +// EnterDrop_type is called when production drop_type is entered. +func (s *BasePlSqlParserListener) EnterDrop_type(ctx *Drop_typeContext) {} + +// ExitDrop_type is called when production drop_type is exited. +func (s *BasePlSqlParserListener) ExitDrop_type(ctx *Drop_typeContext) {} + +// EnterAlter_type is called when production alter_type is entered. +func (s *BasePlSqlParserListener) EnterAlter_type(ctx *Alter_typeContext) {} + +// ExitAlter_type is called when production alter_type is exited. +func (s *BasePlSqlParserListener) ExitAlter_type(ctx *Alter_typeContext) {} + +// EnterCompile_type_clause is called when production compile_type_clause is entered. +func (s *BasePlSqlParserListener) EnterCompile_type_clause(ctx *Compile_type_clauseContext) {} + +// ExitCompile_type_clause is called when production compile_type_clause is exited. +func (s *BasePlSqlParserListener) ExitCompile_type_clause(ctx *Compile_type_clauseContext) {} + +// EnterReplace_type_clause is called when production replace_type_clause is entered. +func (s *BasePlSqlParserListener) EnterReplace_type_clause(ctx *Replace_type_clauseContext) {} + +// ExitReplace_type_clause is called when production replace_type_clause is exited. +func (s *BasePlSqlParserListener) ExitReplace_type_clause(ctx *Replace_type_clauseContext) {} + +// EnterAlter_method_spec is called when production alter_method_spec is entered. +func (s *BasePlSqlParserListener) EnterAlter_method_spec(ctx *Alter_method_specContext) {} + +// ExitAlter_method_spec is called when production alter_method_spec is exited. +func (s *BasePlSqlParserListener) ExitAlter_method_spec(ctx *Alter_method_specContext) {} + +// EnterAlter_method_element is called when production alter_method_element is entered. +func (s *BasePlSqlParserListener) EnterAlter_method_element(ctx *Alter_method_elementContext) {} + +// ExitAlter_method_element is called when production alter_method_element is exited. +func (s *BasePlSqlParserListener) ExitAlter_method_element(ctx *Alter_method_elementContext) {} + +// EnterAlter_attribute_definition is called when production alter_attribute_definition is entered. +func (s *BasePlSqlParserListener) EnterAlter_attribute_definition(ctx *Alter_attribute_definitionContext) { +} + +// ExitAlter_attribute_definition is called when production alter_attribute_definition is exited. +func (s *BasePlSqlParserListener) ExitAlter_attribute_definition(ctx *Alter_attribute_definitionContext) { +} + +// EnterAttribute_definition is called when production attribute_definition is entered. +func (s *BasePlSqlParserListener) EnterAttribute_definition(ctx *Attribute_definitionContext) {} + +// ExitAttribute_definition is called when production attribute_definition is exited. +func (s *BasePlSqlParserListener) ExitAttribute_definition(ctx *Attribute_definitionContext) {} + +// EnterAlter_collection_clauses is called when production alter_collection_clauses is entered. +func (s *BasePlSqlParserListener) EnterAlter_collection_clauses(ctx *Alter_collection_clausesContext) { +} + +// ExitAlter_collection_clauses is called when production alter_collection_clauses is exited. +func (s *BasePlSqlParserListener) ExitAlter_collection_clauses(ctx *Alter_collection_clausesContext) { +} + +// EnterDependent_handling_clause is called when production dependent_handling_clause is entered. +func (s *BasePlSqlParserListener) EnterDependent_handling_clause(ctx *Dependent_handling_clauseContext) { +} + +// ExitDependent_handling_clause is called when production dependent_handling_clause is exited. +func (s *BasePlSqlParserListener) ExitDependent_handling_clause(ctx *Dependent_handling_clauseContext) { +} + +// EnterDependent_exceptions_part is called when production dependent_exceptions_part is entered. +func (s *BasePlSqlParserListener) EnterDependent_exceptions_part(ctx *Dependent_exceptions_partContext) { +} + +// ExitDependent_exceptions_part is called when production dependent_exceptions_part is exited. +func (s *BasePlSqlParserListener) ExitDependent_exceptions_part(ctx *Dependent_exceptions_partContext) { +} + +// EnterCreate_type is called when production create_type is entered. +func (s *BasePlSqlParserListener) EnterCreate_type(ctx *Create_typeContext) {} + +// ExitCreate_type is called when production create_type is exited. +func (s *BasePlSqlParserListener) ExitCreate_type(ctx *Create_typeContext) {} + +// EnterType_definition is called when production type_definition is entered. +func (s *BasePlSqlParserListener) EnterType_definition(ctx *Type_definitionContext) {} + +// ExitType_definition is called when production type_definition is exited. +func (s *BasePlSqlParserListener) ExitType_definition(ctx *Type_definitionContext) {} + +// EnterObject_type_def is called when production object_type_def is entered. +func (s *BasePlSqlParserListener) EnterObject_type_def(ctx *Object_type_defContext) {} + +// ExitObject_type_def is called when production object_type_def is exited. +func (s *BasePlSqlParserListener) ExitObject_type_def(ctx *Object_type_defContext) {} + +// EnterObject_as_part is called when production object_as_part is entered. +func (s *BasePlSqlParserListener) EnterObject_as_part(ctx *Object_as_partContext) {} + +// ExitObject_as_part is called when production object_as_part is exited. +func (s *BasePlSqlParserListener) ExitObject_as_part(ctx *Object_as_partContext) {} + +// EnterObject_under_part is called when production object_under_part is entered. +func (s *BasePlSqlParserListener) EnterObject_under_part(ctx *Object_under_partContext) {} + +// ExitObject_under_part is called when production object_under_part is exited. +func (s *BasePlSqlParserListener) ExitObject_under_part(ctx *Object_under_partContext) {} + +// EnterNested_table_type_def is called when production nested_table_type_def is entered. +func (s *BasePlSqlParserListener) EnterNested_table_type_def(ctx *Nested_table_type_defContext) {} + +// ExitNested_table_type_def is called when production nested_table_type_def is exited. +func (s *BasePlSqlParserListener) ExitNested_table_type_def(ctx *Nested_table_type_defContext) {} + +// EnterSqlj_object_type is called when production sqlj_object_type is entered. +func (s *BasePlSqlParserListener) EnterSqlj_object_type(ctx *Sqlj_object_typeContext) {} + +// ExitSqlj_object_type is called when production sqlj_object_type is exited. +func (s *BasePlSqlParserListener) ExitSqlj_object_type(ctx *Sqlj_object_typeContext) {} + +// EnterType_body is called when production type_body is entered. +func (s *BasePlSqlParserListener) EnterType_body(ctx *Type_bodyContext) {} + +// ExitType_body is called when production type_body is exited. +func (s *BasePlSqlParserListener) ExitType_body(ctx *Type_bodyContext) {} + +// EnterType_body_elements is called when production type_body_elements is entered. +func (s *BasePlSqlParserListener) EnterType_body_elements(ctx *Type_body_elementsContext) {} + +// ExitType_body_elements is called when production type_body_elements is exited. +func (s *BasePlSqlParserListener) ExitType_body_elements(ctx *Type_body_elementsContext) {} + +// EnterMap_order_func_declaration is called when production map_order_func_declaration is entered. +func (s *BasePlSqlParserListener) EnterMap_order_func_declaration(ctx *Map_order_func_declarationContext) { +} + +// ExitMap_order_func_declaration is called when production map_order_func_declaration is exited. +func (s *BasePlSqlParserListener) ExitMap_order_func_declaration(ctx *Map_order_func_declarationContext) { +} + +// EnterSubprog_decl_in_type is called when production subprog_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) {} + +// ExitSubprog_decl_in_type is called when production subprog_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) {} + +// EnterProc_decl_in_type is called when production proc_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterProc_decl_in_type(ctx *Proc_decl_in_typeContext) {} + +// ExitProc_decl_in_type is called when production proc_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitProc_decl_in_type(ctx *Proc_decl_in_typeContext) {} + +// EnterFunc_decl_in_type is called when production func_decl_in_type is entered. +func (s *BasePlSqlParserListener) EnterFunc_decl_in_type(ctx *Func_decl_in_typeContext) {} + +// ExitFunc_decl_in_type is called when production func_decl_in_type is exited. +func (s *BasePlSqlParserListener) ExitFunc_decl_in_type(ctx *Func_decl_in_typeContext) {} + +// EnterConstructor_declaration is called when production constructor_declaration is entered. +func (s *BasePlSqlParserListener) EnterConstructor_declaration(ctx *Constructor_declarationContext) {} + +// ExitConstructor_declaration is called when production constructor_declaration is exited. +func (s *BasePlSqlParserListener) ExitConstructor_declaration(ctx *Constructor_declarationContext) {} + +// EnterModifier_clause is called when production modifier_clause is entered. +func (s *BasePlSqlParserListener) EnterModifier_clause(ctx *Modifier_clauseContext) {} + +// ExitModifier_clause is called when production modifier_clause is exited. +func (s *BasePlSqlParserListener) ExitModifier_clause(ctx *Modifier_clauseContext) {} + +// EnterObject_member_spec is called when production object_member_spec is entered. +func (s *BasePlSqlParserListener) EnterObject_member_spec(ctx *Object_member_specContext) {} + +// ExitObject_member_spec is called when production object_member_spec is exited. +func (s *BasePlSqlParserListener) ExitObject_member_spec(ctx *Object_member_specContext) {} + +// EnterSqlj_object_type_attr is called when production sqlj_object_type_attr is entered. +func (s *BasePlSqlParserListener) EnterSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) {} + +// ExitSqlj_object_type_attr is called when production sqlj_object_type_attr is exited. +func (s *BasePlSqlParserListener) ExitSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) {} + +// EnterElement_spec is called when production element_spec is entered. +func (s *BasePlSqlParserListener) EnterElement_spec(ctx *Element_specContext) {} + +// ExitElement_spec is called when production element_spec is exited. +func (s *BasePlSqlParserListener) ExitElement_spec(ctx *Element_specContext) {} + +// EnterElement_spec_options is called when production element_spec_options is entered. +func (s *BasePlSqlParserListener) EnterElement_spec_options(ctx *Element_spec_optionsContext) {} + +// ExitElement_spec_options is called when production element_spec_options is exited. +func (s *BasePlSqlParserListener) ExitElement_spec_options(ctx *Element_spec_optionsContext) {} + +// EnterSubprogram_spec is called when production subprogram_spec is entered. +func (s *BasePlSqlParserListener) EnterSubprogram_spec(ctx *Subprogram_specContext) {} + +// ExitSubprogram_spec is called when production subprogram_spec is exited. +func (s *BasePlSqlParserListener) ExitSubprogram_spec(ctx *Subprogram_specContext) {} + +// EnterOverriding_subprogram_spec is called when production overriding_subprogram_spec is entered. +func (s *BasePlSqlParserListener) EnterOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) { +} + +// ExitOverriding_subprogram_spec is called when production overriding_subprogram_spec is exited. +func (s *BasePlSqlParserListener) ExitOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) { +} + +// EnterOverriding_function_spec is called when production overriding_function_spec is entered. +func (s *BasePlSqlParserListener) EnterOverriding_function_spec(ctx *Overriding_function_specContext) { +} + +// ExitOverriding_function_spec is called when production overriding_function_spec is exited. +func (s *BasePlSqlParserListener) ExitOverriding_function_spec(ctx *Overriding_function_specContext) { +} + +// EnterType_procedure_spec is called when production type_procedure_spec is entered. +func (s *BasePlSqlParserListener) EnterType_procedure_spec(ctx *Type_procedure_specContext) {} + +// ExitType_procedure_spec is called when production type_procedure_spec is exited. +func (s *BasePlSqlParserListener) ExitType_procedure_spec(ctx *Type_procedure_specContext) {} + +// EnterType_function_spec is called when production type_function_spec is entered. +func (s *BasePlSqlParserListener) EnterType_function_spec(ctx *Type_function_specContext) {} + +// ExitType_function_spec is called when production type_function_spec is exited. +func (s *BasePlSqlParserListener) ExitType_function_spec(ctx *Type_function_specContext) {} + +// EnterConstructor_spec is called when production constructor_spec is entered. +func (s *BasePlSqlParserListener) EnterConstructor_spec(ctx *Constructor_specContext) {} + +// ExitConstructor_spec is called when production constructor_spec is exited. +func (s *BasePlSqlParserListener) ExitConstructor_spec(ctx *Constructor_specContext) {} + +// EnterMap_order_function_spec is called when production map_order_function_spec is entered. +func (s *BasePlSqlParserListener) EnterMap_order_function_spec(ctx *Map_order_function_specContext) {} + +// ExitMap_order_function_spec is called when production map_order_function_spec is exited. +func (s *BasePlSqlParserListener) ExitMap_order_function_spec(ctx *Map_order_function_specContext) {} + +// EnterPragma_clause is called when production pragma_clause is entered. +func (s *BasePlSqlParserListener) EnterPragma_clause(ctx *Pragma_clauseContext) {} + +// ExitPragma_clause is called when production pragma_clause is exited. +func (s *BasePlSqlParserListener) ExitPragma_clause(ctx *Pragma_clauseContext) {} + +// EnterPragma_elements is called when production pragma_elements is entered. +func (s *BasePlSqlParserListener) EnterPragma_elements(ctx *Pragma_elementsContext) {} + +// ExitPragma_elements is called when production pragma_elements is exited. +func (s *BasePlSqlParserListener) ExitPragma_elements(ctx *Pragma_elementsContext) {} + +// EnterType_elements_parameter is called when production type_elements_parameter is entered. +func (s *BasePlSqlParserListener) EnterType_elements_parameter(ctx *Type_elements_parameterContext) {} + +// ExitType_elements_parameter is called when production type_elements_parameter is exited. +func (s *BasePlSqlParserListener) ExitType_elements_parameter(ctx *Type_elements_parameterContext) {} + +// EnterDrop_sequence is called when production drop_sequence is entered. +func (s *BasePlSqlParserListener) EnterDrop_sequence(ctx *Drop_sequenceContext) {} + +// ExitDrop_sequence is called when production drop_sequence is exited. +func (s *BasePlSqlParserListener) ExitDrop_sequence(ctx *Drop_sequenceContext) {} + +// EnterAlter_sequence is called when production alter_sequence is entered. +func (s *BasePlSqlParserListener) EnterAlter_sequence(ctx *Alter_sequenceContext) {} + +// ExitAlter_sequence is called when production alter_sequence is exited. +func (s *BasePlSqlParserListener) ExitAlter_sequence(ctx *Alter_sequenceContext) {} + +// EnterAlter_session is called when production alter_session is entered. +func (s *BasePlSqlParserListener) EnterAlter_session(ctx *Alter_sessionContext) {} + +// ExitAlter_session is called when production alter_session is exited. +func (s *BasePlSqlParserListener) ExitAlter_session(ctx *Alter_sessionContext) {} + +// EnterAlter_session_set_clause is called when production alter_session_set_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_session_set_clause(ctx *Alter_session_set_clauseContext) { +} + +// ExitAlter_session_set_clause is called when production alter_session_set_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_session_set_clause(ctx *Alter_session_set_clauseContext) { +} + +// EnterCreate_sequence is called when production create_sequence is entered. +func (s *BasePlSqlParserListener) EnterCreate_sequence(ctx *Create_sequenceContext) {} + +// ExitCreate_sequence is called when production create_sequence is exited. +func (s *BasePlSqlParserListener) ExitCreate_sequence(ctx *Create_sequenceContext) {} + +// EnterSequence_spec is called when production sequence_spec is entered. +func (s *BasePlSqlParserListener) EnterSequence_spec(ctx *Sequence_specContext) {} + +// ExitSequence_spec is called when production sequence_spec is exited. +func (s *BasePlSqlParserListener) ExitSequence_spec(ctx *Sequence_specContext) {} + +// EnterSequence_start_clause is called when production sequence_start_clause is entered. +func (s *BasePlSqlParserListener) EnterSequence_start_clause(ctx *Sequence_start_clauseContext) {} + +// ExitSequence_start_clause is called when production sequence_start_clause is exited. +func (s *BasePlSqlParserListener) ExitSequence_start_clause(ctx *Sequence_start_clauseContext) {} + +// EnterCreate_analytic_view is called when production create_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_analytic_view(ctx *Create_analytic_viewContext) {} + +// ExitCreate_analytic_view is called when production create_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_analytic_view(ctx *Create_analytic_viewContext) {} + +// EnterClassification_clause is called when production classification_clause is entered. +func (s *BasePlSqlParserListener) EnterClassification_clause(ctx *Classification_clauseContext) {} + +// ExitClassification_clause is called when production classification_clause is exited. +func (s *BasePlSqlParserListener) ExitClassification_clause(ctx *Classification_clauseContext) {} + +// EnterCaption_clause is called when production caption_clause is entered. +func (s *BasePlSqlParserListener) EnterCaption_clause(ctx *Caption_clauseContext) {} + +// ExitCaption_clause is called when production caption_clause is exited. +func (s *BasePlSqlParserListener) ExitCaption_clause(ctx *Caption_clauseContext) {} + +// EnterDescription_clause is called when production description_clause is entered. +func (s *BasePlSqlParserListener) EnterDescription_clause(ctx *Description_clauseContext) {} + +// ExitDescription_clause is called when production description_clause is exited. +func (s *BasePlSqlParserListener) ExitDescription_clause(ctx *Description_clauseContext) {} + +// EnterClassification_item is called when production classification_item is entered. +func (s *BasePlSqlParserListener) EnterClassification_item(ctx *Classification_itemContext) {} + +// ExitClassification_item is called when production classification_item is exited. +func (s *BasePlSqlParserListener) ExitClassification_item(ctx *Classification_itemContext) {} + +// EnterLanguage is called when production language is entered. +func (s *BasePlSqlParserListener) EnterLanguage(ctx *LanguageContext) {} + +// ExitLanguage is called when production language is exited. +func (s *BasePlSqlParserListener) ExitLanguage(ctx *LanguageContext) {} + +// EnterCav_using_clause is called when production cav_using_clause is entered. +func (s *BasePlSqlParserListener) EnterCav_using_clause(ctx *Cav_using_clauseContext) {} + +// ExitCav_using_clause is called when production cav_using_clause is exited. +func (s *BasePlSqlParserListener) ExitCav_using_clause(ctx *Cav_using_clauseContext) {} + +// EnterDim_by_clause is called when production dim_by_clause is entered. +func (s *BasePlSqlParserListener) EnterDim_by_clause(ctx *Dim_by_clauseContext) {} + +// ExitDim_by_clause is called when production dim_by_clause is exited. +func (s *BasePlSqlParserListener) ExitDim_by_clause(ctx *Dim_by_clauseContext) {} + +// EnterDim_key is called when production dim_key is entered. +func (s *BasePlSqlParserListener) EnterDim_key(ctx *Dim_keyContext) {} + +// ExitDim_key is called when production dim_key is exited. +func (s *BasePlSqlParserListener) ExitDim_key(ctx *Dim_keyContext) {} + +// EnterDim_ref is called when production dim_ref is entered. +func (s *BasePlSqlParserListener) EnterDim_ref(ctx *Dim_refContext) {} + +// ExitDim_ref is called when production dim_ref is exited. +func (s *BasePlSqlParserListener) ExitDim_ref(ctx *Dim_refContext) {} + +// EnterHier_ref is called when production hier_ref is entered. +func (s *BasePlSqlParserListener) EnterHier_ref(ctx *Hier_refContext) {} + +// ExitHier_ref is called when production hier_ref is exited. +func (s *BasePlSqlParserListener) ExitHier_ref(ctx *Hier_refContext) {} + +// EnterMeasures_clause is called when production measures_clause is entered. +func (s *BasePlSqlParserListener) EnterMeasures_clause(ctx *Measures_clauseContext) {} + +// ExitMeasures_clause is called when production measures_clause is exited. +func (s *BasePlSqlParserListener) ExitMeasures_clause(ctx *Measures_clauseContext) {} + +// EnterAv_measure is called when production av_measure is entered. +func (s *BasePlSqlParserListener) EnterAv_measure(ctx *Av_measureContext) {} + +// ExitAv_measure is called when production av_measure is exited. +func (s *BasePlSqlParserListener) ExitAv_measure(ctx *Av_measureContext) {} + +// EnterBase_meas_clause is called when production base_meas_clause is entered. +func (s *BasePlSqlParserListener) EnterBase_meas_clause(ctx *Base_meas_clauseContext) {} + +// ExitBase_meas_clause is called when production base_meas_clause is exited. +func (s *BasePlSqlParserListener) ExitBase_meas_clause(ctx *Base_meas_clauseContext) {} + +// EnterMeas_aggregate_clause is called when production meas_aggregate_clause is entered. +func (s *BasePlSqlParserListener) EnterMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) {} + +// ExitMeas_aggregate_clause is called when production meas_aggregate_clause is exited. +func (s *BasePlSqlParserListener) ExitMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) {} + +// EnterCalc_meas_clause is called when production calc_meas_clause is entered. +func (s *BasePlSqlParserListener) EnterCalc_meas_clause(ctx *Calc_meas_clauseContext) {} + +// ExitCalc_meas_clause is called when production calc_meas_clause is exited. +func (s *BasePlSqlParserListener) ExitCalc_meas_clause(ctx *Calc_meas_clauseContext) {} + +// EnterDefault_measure_clause is called when production default_measure_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_measure_clause(ctx *Default_measure_clauseContext) {} + +// ExitDefault_measure_clause is called when production default_measure_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_measure_clause(ctx *Default_measure_clauseContext) {} + +// EnterDefault_aggregate_clause is called when production default_aggregate_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) { +} + +// ExitDefault_aggregate_clause is called when production default_aggregate_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) { +} + +// EnterCache_clause is called when production cache_clause is entered. +func (s *BasePlSqlParserListener) EnterCache_clause(ctx *Cache_clauseContext) {} + +// ExitCache_clause is called when production cache_clause is exited. +func (s *BasePlSqlParserListener) ExitCache_clause(ctx *Cache_clauseContext) {} + +// EnterCache_specification is called when production cache_specification is entered. +func (s *BasePlSqlParserListener) EnterCache_specification(ctx *Cache_specificationContext) {} + +// ExitCache_specification is called when production cache_specification is exited. +func (s *BasePlSqlParserListener) ExitCache_specification(ctx *Cache_specificationContext) {} + +// EnterLevels_clause is called when production levels_clause is entered. +func (s *BasePlSqlParserListener) EnterLevels_clause(ctx *Levels_clauseContext) {} + +// ExitLevels_clause is called when production levels_clause is exited. +func (s *BasePlSqlParserListener) ExitLevels_clause(ctx *Levels_clauseContext) {} + +// EnterLevel_specification is called when production level_specification is entered. +func (s *BasePlSqlParserListener) EnterLevel_specification(ctx *Level_specificationContext) {} + +// ExitLevel_specification is called when production level_specification is exited. +func (s *BasePlSqlParserListener) ExitLevel_specification(ctx *Level_specificationContext) {} + +// EnterLevel_group_type is called when production level_group_type is entered. +func (s *BasePlSqlParserListener) EnterLevel_group_type(ctx *Level_group_typeContext) {} + +// ExitLevel_group_type is called when production level_group_type is exited. +func (s *BasePlSqlParserListener) ExitLevel_group_type(ctx *Level_group_typeContext) {} + +// EnterFact_columns_clause is called when production fact_columns_clause is entered. +func (s *BasePlSqlParserListener) EnterFact_columns_clause(ctx *Fact_columns_clauseContext) {} + +// ExitFact_columns_clause is called when production fact_columns_clause is exited. +func (s *BasePlSqlParserListener) ExitFact_columns_clause(ctx *Fact_columns_clauseContext) {} + +// EnterQry_transform_clause is called when production qry_transform_clause is entered. +func (s *BasePlSqlParserListener) EnterQry_transform_clause(ctx *Qry_transform_clauseContext) {} + +// ExitQry_transform_clause is called when production qry_transform_clause is exited. +func (s *BasePlSqlParserListener) ExitQry_transform_clause(ctx *Qry_transform_clauseContext) {} + +// EnterCreate_attribute_dimension is called when production create_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) { +} + +// ExitCreate_attribute_dimension is called when production create_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) { +} + +// EnterAd_using_clause is called when production ad_using_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_using_clause(ctx *Ad_using_clauseContext) {} + +// ExitAd_using_clause is called when production ad_using_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_using_clause(ctx *Ad_using_clauseContext) {} + +// EnterSource_clause is called when production source_clause is entered. +func (s *BasePlSqlParserListener) EnterSource_clause(ctx *Source_clauseContext) {} + +// ExitSource_clause is called when production source_clause is exited. +func (s *BasePlSqlParserListener) ExitSource_clause(ctx *Source_clauseContext) {} + +// EnterJoin_path_clause is called when production join_path_clause is entered. +func (s *BasePlSqlParserListener) EnterJoin_path_clause(ctx *Join_path_clauseContext) {} + +// ExitJoin_path_clause is called when production join_path_clause is exited. +func (s *BasePlSqlParserListener) ExitJoin_path_clause(ctx *Join_path_clauseContext) {} + +// EnterJoin_condition is called when production join_condition is entered. +func (s *BasePlSqlParserListener) EnterJoin_condition(ctx *Join_conditionContext) {} + +// ExitJoin_condition is called when production join_condition is exited. +func (s *BasePlSqlParserListener) ExitJoin_condition(ctx *Join_conditionContext) {} + +// EnterJoin_condition_item is called when production join_condition_item is entered. +func (s *BasePlSqlParserListener) EnterJoin_condition_item(ctx *Join_condition_itemContext) {} + +// ExitJoin_condition_item is called when production join_condition_item is exited. +func (s *BasePlSqlParserListener) ExitJoin_condition_item(ctx *Join_condition_itemContext) {} + +// EnterAttributes_clause is called when production attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterAttributes_clause(ctx *Attributes_clauseContext) {} + +// ExitAttributes_clause is called when production attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitAttributes_clause(ctx *Attributes_clauseContext) {} + +// EnterAd_attributes_clause is called when production ad_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_attributes_clause(ctx *Ad_attributes_clauseContext) {} + +// ExitAd_attributes_clause is called when production ad_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_attributes_clause(ctx *Ad_attributes_clauseContext) {} + +// EnterAd_level_clause is called when production ad_level_clause is entered. +func (s *BasePlSqlParserListener) EnterAd_level_clause(ctx *Ad_level_clauseContext) {} + +// ExitAd_level_clause is called when production ad_level_clause is exited. +func (s *BasePlSqlParserListener) ExitAd_level_clause(ctx *Ad_level_clauseContext) {} + +// EnterKey_clause is called when production key_clause is entered. +func (s *BasePlSqlParserListener) EnterKey_clause(ctx *Key_clauseContext) {} + +// ExitKey_clause is called when production key_clause is exited. +func (s *BasePlSqlParserListener) ExitKey_clause(ctx *Key_clauseContext) {} + +// EnterAlternate_key_clause is called when production alternate_key_clause is entered. +func (s *BasePlSqlParserListener) EnterAlternate_key_clause(ctx *Alternate_key_clauseContext) {} + +// ExitAlternate_key_clause is called when production alternate_key_clause is exited. +func (s *BasePlSqlParserListener) ExitAlternate_key_clause(ctx *Alternate_key_clauseContext) {} + +// EnterDim_order_clause is called when production dim_order_clause is entered. +func (s *BasePlSqlParserListener) EnterDim_order_clause(ctx *Dim_order_clauseContext) {} + +// ExitDim_order_clause is called when production dim_order_clause is exited. +func (s *BasePlSqlParserListener) ExitDim_order_clause(ctx *Dim_order_clauseContext) {} + +// EnterAll_clause is called when production all_clause is entered. +func (s *BasePlSqlParserListener) EnterAll_clause(ctx *All_clauseContext) {} + +// ExitAll_clause is called when production all_clause is exited. +func (s *BasePlSqlParserListener) ExitAll_clause(ctx *All_clauseContext) {} + +// EnterCreate_audit_policy is called when production create_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterCreate_audit_policy(ctx *Create_audit_policyContext) {} + +// ExitCreate_audit_policy is called when production create_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitCreate_audit_policy(ctx *Create_audit_policyContext) {} + +// EnterPrivilege_audit_clause is called when production privilege_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) {} + +// ExitPrivilege_audit_clause is called when production privilege_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) {} + +// EnterAction_audit_clause is called when production action_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterAction_audit_clause(ctx *Action_audit_clauseContext) {} + +// ExitAction_audit_clause is called when production action_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitAction_audit_clause(ctx *Action_audit_clauseContext) {} + +// EnterStandard_actions is called when production standard_actions is entered. +func (s *BasePlSqlParserListener) EnterStandard_actions(ctx *Standard_actionsContext) {} + +// ExitStandard_actions is called when production standard_actions is exited. +func (s *BasePlSqlParserListener) ExitStandard_actions(ctx *Standard_actionsContext) {} + +// EnterActions_clause is called when production actions_clause is entered. +func (s *BasePlSqlParserListener) EnterActions_clause(ctx *Actions_clauseContext) {} + +// ExitActions_clause is called when production actions_clause is exited. +func (s *BasePlSqlParserListener) ExitActions_clause(ctx *Actions_clauseContext) {} + +// EnterObject_action is called when production object_action is entered. +func (s *BasePlSqlParserListener) EnterObject_action(ctx *Object_actionContext) {} + +// ExitObject_action is called when production object_action is exited. +func (s *BasePlSqlParserListener) ExitObject_action(ctx *Object_actionContext) {} + +// EnterSystem_action is called when production system_action is entered. +func (s *BasePlSqlParserListener) EnterSystem_action(ctx *System_actionContext) {} + +// ExitSystem_action is called when production system_action is exited. +func (s *BasePlSqlParserListener) ExitSystem_action(ctx *System_actionContext) {} + +// EnterComponent_actions is called when production component_actions is entered. +func (s *BasePlSqlParserListener) EnterComponent_actions(ctx *Component_actionsContext) {} + +// ExitComponent_actions is called when production component_actions is exited. +func (s *BasePlSqlParserListener) ExitComponent_actions(ctx *Component_actionsContext) {} + +// EnterComponent_action is called when production component_action is entered. +func (s *BasePlSqlParserListener) EnterComponent_action(ctx *Component_actionContext) {} + +// ExitComponent_action is called when production component_action is exited. +func (s *BasePlSqlParserListener) ExitComponent_action(ctx *Component_actionContext) {} + +// EnterRole_audit_clause is called when production role_audit_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_audit_clause(ctx *Role_audit_clauseContext) {} + +// ExitRole_audit_clause is called when production role_audit_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_audit_clause(ctx *Role_audit_clauseContext) {} + +// EnterCreate_controlfile is called when production create_controlfile is entered. +func (s *BasePlSqlParserListener) EnterCreate_controlfile(ctx *Create_controlfileContext) {} + +// ExitCreate_controlfile is called when production create_controlfile is exited. +func (s *BasePlSqlParserListener) ExitCreate_controlfile(ctx *Create_controlfileContext) {} + +// EnterControlfile_options is called when production controlfile_options is entered. +func (s *BasePlSqlParserListener) EnterControlfile_options(ctx *Controlfile_optionsContext) {} + +// ExitControlfile_options is called when production controlfile_options is exited. +func (s *BasePlSqlParserListener) ExitControlfile_options(ctx *Controlfile_optionsContext) {} + +// EnterLogfile_clause is called when production logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterLogfile_clause(ctx *Logfile_clauseContext) {} + +// ExitLogfile_clause is called when production logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitLogfile_clause(ctx *Logfile_clauseContext) {} + +// EnterCharacter_set_clause is called when production character_set_clause is entered. +func (s *BasePlSqlParserListener) EnterCharacter_set_clause(ctx *Character_set_clauseContext) {} + +// ExitCharacter_set_clause is called when production character_set_clause is exited. +func (s *BasePlSqlParserListener) ExitCharacter_set_clause(ctx *Character_set_clauseContext) {} + +// EnterFile_specification is called when production file_specification is entered. +func (s *BasePlSqlParserListener) EnterFile_specification(ctx *File_specificationContext) {} + +// ExitFile_specification is called when production file_specification is exited. +func (s *BasePlSqlParserListener) ExitFile_specification(ctx *File_specificationContext) {} + +// EnterCreate_diskgroup is called when production create_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterCreate_diskgroup(ctx *Create_diskgroupContext) {} + +// ExitCreate_diskgroup is called when production create_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitCreate_diskgroup(ctx *Create_diskgroupContext) {} + +// EnterQualified_disk_clause is called when production qualified_disk_clause is entered. +func (s *BasePlSqlParserListener) EnterQualified_disk_clause(ctx *Qualified_disk_clauseContext) {} + +// ExitQualified_disk_clause is called when production qualified_disk_clause is exited. +func (s *BasePlSqlParserListener) ExitQualified_disk_clause(ctx *Qualified_disk_clauseContext) {} + +// EnterCreate_edition is called when production create_edition is entered. +func (s *BasePlSqlParserListener) EnterCreate_edition(ctx *Create_editionContext) {} + +// ExitCreate_edition is called when production create_edition is exited. +func (s *BasePlSqlParserListener) ExitCreate_edition(ctx *Create_editionContext) {} + +// EnterCreate_flashback_archive is called when production create_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterCreate_flashback_archive(ctx *Create_flashback_archiveContext) { +} + +// ExitCreate_flashback_archive is called when production create_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitCreate_flashback_archive(ctx *Create_flashback_archiveContext) { +} + +// EnterFlashback_archive_quota is called when production flashback_archive_quota is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_quota(ctx *Flashback_archive_quotaContext) {} + +// ExitFlashback_archive_quota is called when production flashback_archive_quota is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_quota(ctx *Flashback_archive_quotaContext) {} + +// EnterFlashback_archive_retention is called when production flashback_archive_retention is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_retention(ctx *Flashback_archive_retentionContext) { +} + +// ExitFlashback_archive_retention is called when production flashback_archive_retention is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_retention(ctx *Flashback_archive_retentionContext) { +} + +// EnterCreate_hierarchy is called when production create_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterCreate_hierarchy(ctx *Create_hierarchyContext) {} + +// ExitCreate_hierarchy is called when production create_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitCreate_hierarchy(ctx *Create_hierarchyContext) {} + +// EnterHier_using_clause is called when production hier_using_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_using_clause(ctx *Hier_using_clauseContext) {} + +// ExitHier_using_clause is called when production hier_using_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_using_clause(ctx *Hier_using_clauseContext) {} + +// EnterLevel_hier_clause is called when production level_hier_clause is entered. +func (s *BasePlSqlParserListener) EnterLevel_hier_clause(ctx *Level_hier_clauseContext) {} + +// ExitLevel_hier_clause is called when production level_hier_clause is exited. +func (s *BasePlSqlParserListener) ExitLevel_hier_clause(ctx *Level_hier_clauseContext) {} + +// EnterHier_attrs_clause is called when production hier_attrs_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_attrs_clause(ctx *Hier_attrs_clauseContext) {} + +// ExitHier_attrs_clause is called when production hier_attrs_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_attrs_clause(ctx *Hier_attrs_clauseContext) {} + +// EnterHier_attr_clause is called when production hier_attr_clause is entered. +func (s *BasePlSqlParserListener) EnterHier_attr_clause(ctx *Hier_attr_clauseContext) {} + +// ExitHier_attr_clause is called when production hier_attr_clause is exited. +func (s *BasePlSqlParserListener) ExitHier_attr_clause(ctx *Hier_attr_clauseContext) {} + +// EnterHier_attr_name is called when production hier_attr_name is entered. +func (s *BasePlSqlParserListener) EnterHier_attr_name(ctx *Hier_attr_nameContext) {} + +// ExitHier_attr_name is called when production hier_attr_name is exited. +func (s *BasePlSqlParserListener) ExitHier_attr_name(ctx *Hier_attr_nameContext) {} + +// EnterCreate_index is called when production create_index is entered. +func (s *BasePlSqlParserListener) EnterCreate_index(ctx *Create_indexContext) {} + +// ExitCreate_index is called when production create_index is exited. +func (s *BasePlSqlParserListener) ExitCreate_index(ctx *Create_indexContext) {} + +// EnterCluster_index_clause is called when production cluster_index_clause is entered. +func (s *BasePlSqlParserListener) EnterCluster_index_clause(ctx *Cluster_index_clauseContext) {} + +// ExitCluster_index_clause is called when production cluster_index_clause is exited. +func (s *BasePlSqlParserListener) ExitCluster_index_clause(ctx *Cluster_index_clauseContext) {} + +// EnterCluster_name is called when production cluster_name is entered. +func (s *BasePlSqlParserListener) EnterCluster_name(ctx *Cluster_nameContext) {} + +// ExitCluster_name is called when production cluster_name is exited. +func (s *BasePlSqlParserListener) ExitCluster_name(ctx *Cluster_nameContext) {} + +// EnterTable_index_clause is called when production table_index_clause is entered. +func (s *BasePlSqlParserListener) EnterTable_index_clause(ctx *Table_index_clauseContext) {} + +// ExitTable_index_clause is called when production table_index_clause is exited. +func (s *BasePlSqlParserListener) ExitTable_index_clause(ctx *Table_index_clauseContext) {} + +// EnterBitmap_join_index_clause is called when production bitmap_join_index_clause is entered. +func (s *BasePlSqlParserListener) EnterBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) { +} + +// ExitBitmap_join_index_clause is called when production bitmap_join_index_clause is exited. +func (s *BasePlSqlParserListener) ExitBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) { +} + +// EnterIndex_expr_option is called when production index_expr_option is entered. +func (s *BasePlSqlParserListener) EnterIndex_expr_option(ctx *Index_expr_optionContext) {} + +// ExitIndex_expr_option is called when production index_expr_option is exited. +func (s *BasePlSqlParserListener) ExitIndex_expr_option(ctx *Index_expr_optionContext) {} + +// EnterIndex_expr is called when production index_expr is entered. +func (s *BasePlSqlParserListener) EnterIndex_expr(ctx *Index_exprContext) {} + +// ExitIndex_expr is called when production index_expr is exited. +func (s *BasePlSqlParserListener) ExitIndex_expr(ctx *Index_exprContext) {} + +// EnterIndex_properties is called when production index_properties is entered. +func (s *BasePlSqlParserListener) EnterIndex_properties(ctx *Index_propertiesContext) {} + +// ExitIndex_properties is called when production index_properties is exited. +func (s *BasePlSqlParserListener) ExitIndex_properties(ctx *Index_propertiesContext) {} + +// EnterDomain_index_clause is called when production domain_index_clause is entered. +func (s *BasePlSqlParserListener) EnterDomain_index_clause(ctx *Domain_index_clauseContext) {} + +// ExitDomain_index_clause is called when production domain_index_clause is exited. +func (s *BasePlSqlParserListener) ExitDomain_index_clause(ctx *Domain_index_clauseContext) {} + +// EnterLocal_domain_index_clause is called when production local_domain_index_clause is entered. +func (s *BasePlSqlParserListener) EnterLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) { +} + +// ExitLocal_domain_index_clause is called when production local_domain_index_clause is exited. +func (s *BasePlSqlParserListener) ExitLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) { +} + +// EnterXmlindex_clause is called when production xmlindex_clause is entered. +func (s *BasePlSqlParserListener) EnterXmlindex_clause(ctx *Xmlindex_clauseContext) {} + +// ExitXmlindex_clause is called when production xmlindex_clause is exited. +func (s *BasePlSqlParserListener) ExitXmlindex_clause(ctx *Xmlindex_clauseContext) {} + +// EnterLocal_xmlindex_clause is called when production local_xmlindex_clause is entered. +func (s *BasePlSqlParserListener) EnterLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) {} + +// ExitLocal_xmlindex_clause is called when production local_xmlindex_clause is exited. +func (s *BasePlSqlParserListener) ExitLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) {} + +// EnterGlobal_partitioned_index is called when production global_partitioned_index is entered. +func (s *BasePlSqlParserListener) EnterGlobal_partitioned_index(ctx *Global_partitioned_indexContext) { +} + +// ExitGlobal_partitioned_index is called when production global_partitioned_index is exited. +func (s *BasePlSqlParserListener) ExitGlobal_partitioned_index(ctx *Global_partitioned_indexContext) { +} + +// EnterIndex_partitioning_clause is called when production index_partitioning_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) { +} + +// ExitIndex_partitioning_clause is called when production index_partitioning_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) { +} + +// EnterLocal_partitioned_index is called when production local_partitioned_index is entered. +func (s *BasePlSqlParserListener) EnterLocal_partitioned_index(ctx *Local_partitioned_indexContext) {} + +// ExitLocal_partitioned_index is called when production local_partitioned_index is exited. +func (s *BasePlSqlParserListener) ExitLocal_partitioned_index(ctx *Local_partitioned_indexContext) {} + +// EnterOn_range_partitioned_table is called when production on_range_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) { +} + +// ExitOn_range_partitioned_table is called when production on_range_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) { +} + +// EnterOn_list_partitioned_table is called when production on_list_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) { +} + +// ExitOn_list_partitioned_table is called when production on_list_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) { +} + +// EnterPartitioned_table is called when production partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterPartitioned_table(ctx *Partitioned_tableContext) {} + +// ExitPartitioned_table is called when production partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitPartitioned_table(ctx *Partitioned_tableContext) {} + +// EnterOn_hash_partitioned_table is called when production on_hash_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) { +} + +// ExitOn_hash_partitioned_table is called when production on_hash_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) { +} + +// EnterOn_hash_partitioned_clause is called when production on_hash_partitioned_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) { +} + +// ExitOn_hash_partitioned_clause is called when production on_hash_partitioned_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) { +} + +// EnterOn_comp_partitioned_table is called when production on_comp_partitioned_table is entered. +func (s *BasePlSqlParserListener) EnterOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) { +} + +// ExitOn_comp_partitioned_table is called when production on_comp_partitioned_table is exited. +func (s *BasePlSqlParserListener) ExitOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) { +} + +// EnterOn_comp_partitioned_clause is called when production on_comp_partitioned_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) { +} + +// ExitOn_comp_partitioned_clause is called when production on_comp_partitioned_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) { +} + +// EnterIndex_subpartition_clause is called when production index_subpartition_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) { +} + +// ExitIndex_subpartition_clause is called when production index_subpartition_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) { +} + +// EnterIndex_subpartition_subclause is called when production index_subpartition_subclause is entered. +func (s *BasePlSqlParserListener) EnterIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) { +} + +// ExitIndex_subpartition_subclause is called when production index_subpartition_subclause is exited. +func (s *BasePlSqlParserListener) ExitIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) { +} + +// EnterOdci_parameters is called when production odci_parameters is entered. +func (s *BasePlSqlParserListener) EnterOdci_parameters(ctx *Odci_parametersContext) {} + +// ExitOdci_parameters is called when production odci_parameters is exited. +func (s *BasePlSqlParserListener) ExitOdci_parameters(ctx *Odci_parametersContext) {} + +// EnterIndextype is called when production indextype is entered. +func (s *BasePlSqlParserListener) EnterIndextype(ctx *IndextypeContext) {} + +// ExitIndextype is called when production indextype is exited. +func (s *BasePlSqlParserListener) ExitIndextype(ctx *IndextypeContext) {} + +// EnterAlter_index is called when production alter_index is entered. +func (s *BasePlSqlParserListener) EnterAlter_index(ctx *Alter_indexContext) {} + +// ExitAlter_index is called when production alter_index is exited. +func (s *BasePlSqlParserListener) ExitAlter_index(ctx *Alter_indexContext) {} + +// EnterAlter_index_ops_set1 is called when production alter_index_ops_set1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) {} + +// ExitAlter_index_ops_set1 is called when production alter_index_ops_set1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) {} + +// EnterAlter_index_ops_set2 is called when production alter_index_ops_set2 is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) {} + +// ExitAlter_index_ops_set2 is called when production alter_index_ops_set2 is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) {} + +// EnterVisible_or_invisible is called when production visible_or_invisible is entered. +func (s *BasePlSqlParserListener) EnterVisible_or_invisible(ctx *Visible_or_invisibleContext) {} + +// ExitVisible_or_invisible is called when production visible_or_invisible is exited. +func (s *BasePlSqlParserListener) ExitVisible_or_invisible(ctx *Visible_or_invisibleContext) {} + +// EnterMonitoring_nomonitoring is called when production monitoring_nomonitoring is entered. +func (s *BasePlSqlParserListener) EnterMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) {} + +// ExitMonitoring_nomonitoring is called when production monitoring_nomonitoring is exited. +func (s *BasePlSqlParserListener) ExitMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) {} + +// EnterRebuild_clause is called when production rebuild_clause is entered. +func (s *BasePlSqlParserListener) EnterRebuild_clause(ctx *Rebuild_clauseContext) {} + +// ExitRebuild_clause is called when production rebuild_clause is exited. +func (s *BasePlSqlParserListener) ExitRebuild_clause(ctx *Rebuild_clauseContext) {} + +// EnterAlter_index_partitioning is called when production alter_index_partitioning is entered. +func (s *BasePlSqlParserListener) EnterAlter_index_partitioning(ctx *Alter_index_partitioningContext) { +} + +// ExitAlter_index_partitioning is called when production alter_index_partitioning is exited. +func (s *BasePlSqlParserListener) ExitAlter_index_partitioning(ctx *Alter_index_partitioningContext) { +} + +// EnterModify_index_default_attrs is called when production modify_index_default_attrs is entered. +func (s *BasePlSqlParserListener) EnterModify_index_default_attrs(ctx *Modify_index_default_attrsContext) { +} + +// ExitModify_index_default_attrs is called when production modify_index_default_attrs is exited. +func (s *BasePlSqlParserListener) ExitModify_index_default_attrs(ctx *Modify_index_default_attrsContext) { +} + +// EnterAdd_hash_index_partition is called when production add_hash_index_partition is entered. +func (s *BasePlSqlParserListener) EnterAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) { +} + +// ExitAdd_hash_index_partition is called when production add_hash_index_partition is exited. +func (s *BasePlSqlParserListener) ExitAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) { +} + +// EnterCoalesce_index_partition is called when production coalesce_index_partition is entered. +func (s *BasePlSqlParserListener) EnterCoalesce_index_partition(ctx *Coalesce_index_partitionContext) { +} + +// ExitCoalesce_index_partition is called when production coalesce_index_partition is exited. +func (s *BasePlSqlParserListener) ExitCoalesce_index_partition(ctx *Coalesce_index_partitionContext) { +} + +// EnterModify_index_partition is called when production modify_index_partition is entered. +func (s *BasePlSqlParserListener) EnterModify_index_partition(ctx *Modify_index_partitionContext) {} + +// ExitModify_index_partition is called when production modify_index_partition is exited. +func (s *BasePlSqlParserListener) ExitModify_index_partition(ctx *Modify_index_partitionContext) {} + +// EnterModify_index_partitions_ops is called when production modify_index_partitions_ops is entered. +func (s *BasePlSqlParserListener) EnterModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) { +} + +// ExitModify_index_partitions_ops is called when production modify_index_partitions_ops is exited. +func (s *BasePlSqlParserListener) ExitModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) { +} + +// EnterRename_index_partition is called when production rename_index_partition is entered. +func (s *BasePlSqlParserListener) EnterRename_index_partition(ctx *Rename_index_partitionContext) {} + +// ExitRename_index_partition is called when production rename_index_partition is exited. +func (s *BasePlSqlParserListener) ExitRename_index_partition(ctx *Rename_index_partitionContext) {} + +// EnterDrop_index_partition is called when production drop_index_partition is entered. +func (s *BasePlSqlParserListener) EnterDrop_index_partition(ctx *Drop_index_partitionContext) {} + +// ExitDrop_index_partition is called when production drop_index_partition is exited. +func (s *BasePlSqlParserListener) ExitDrop_index_partition(ctx *Drop_index_partitionContext) {} + +// EnterSplit_index_partition is called when production split_index_partition is entered. +func (s *BasePlSqlParserListener) EnterSplit_index_partition(ctx *Split_index_partitionContext) {} + +// ExitSplit_index_partition is called when production split_index_partition is exited. +func (s *BasePlSqlParserListener) ExitSplit_index_partition(ctx *Split_index_partitionContext) {} + +// EnterIndex_partition_description is called when production index_partition_description is entered. +func (s *BasePlSqlParserListener) EnterIndex_partition_description(ctx *Index_partition_descriptionContext) { +} + +// ExitIndex_partition_description is called when production index_partition_description is exited. +func (s *BasePlSqlParserListener) ExitIndex_partition_description(ctx *Index_partition_descriptionContext) { +} + +// EnterModify_index_subpartition is called when production modify_index_subpartition is entered. +func (s *BasePlSqlParserListener) EnterModify_index_subpartition(ctx *Modify_index_subpartitionContext) { +} + +// ExitModify_index_subpartition is called when production modify_index_subpartition is exited. +func (s *BasePlSqlParserListener) ExitModify_index_subpartition(ctx *Modify_index_subpartitionContext) { +} + +// EnterPartition_name_old is called when production partition_name_old is entered. +func (s *BasePlSqlParserListener) EnterPartition_name_old(ctx *Partition_name_oldContext) {} + +// ExitPartition_name_old is called when production partition_name_old is exited. +func (s *BasePlSqlParserListener) ExitPartition_name_old(ctx *Partition_name_oldContext) {} + +// EnterNew_partition_name is called when production new_partition_name is entered. +func (s *BasePlSqlParserListener) EnterNew_partition_name(ctx *New_partition_nameContext) {} + +// ExitNew_partition_name is called when production new_partition_name is exited. +func (s *BasePlSqlParserListener) ExitNew_partition_name(ctx *New_partition_nameContext) {} + +// EnterNew_index_name is called when production new_index_name is entered. +func (s *BasePlSqlParserListener) EnterNew_index_name(ctx *New_index_nameContext) {} + +// ExitNew_index_name is called when production new_index_name is exited. +func (s *BasePlSqlParserListener) ExitNew_index_name(ctx *New_index_nameContext) {} + +// EnterAlter_inmemory_join_group is called when production alter_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) { +} + +// ExitAlter_inmemory_join_group is called when production alter_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) { +} + +// EnterCreate_user is called when production create_user is entered. +func (s *BasePlSqlParserListener) EnterCreate_user(ctx *Create_userContext) {} + +// ExitCreate_user is called when production create_user is exited. +func (s *BasePlSqlParserListener) ExitCreate_user(ctx *Create_userContext) {} + +// EnterAlter_user is called when production alter_user is entered. +func (s *BasePlSqlParserListener) EnterAlter_user(ctx *Alter_userContext) {} + +// ExitAlter_user is called when production alter_user is exited. +func (s *BasePlSqlParserListener) ExitAlter_user(ctx *Alter_userContext) {} + +// EnterDrop_user is called when production drop_user is entered. +func (s *BasePlSqlParserListener) EnterDrop_user(ctx *Drop_userContext) {} + +// ExitDrop_user is called when production drop_user is exited. +func (s *BasePlSqlParserListener) ExitDrop_user(ctx *Drop_userContext) {} + +// EnterAlter_identified_by is called when production alter_identified_by is entered. +func (s *BasePlSqlParserListener) EnterAlter_identified_by(ctx *Alter_identified_byContext) {} + +// ExitAlter_identified_by is called when production alter_identified_by is exited. +func (s *BasePlSqlParserListener) ExitAlter_identified_by(ctx *Alter_identified_byContext) {} + +// EnterIdentified_by is called when production identified_by is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by(ctx *Identified_byContext) {} + +// ExitIdentified_by is called when production identified_by is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by(ctx *Identified_byContext) {} + +// EnterIdentified_other_clause is called when production identified_other_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentified_other_clause(ctx *Identified_other_clauseContext) {} + +// ExitIdentified_other_clause is called when production identified_other_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentified_other_clause(ctx *Identified_other_clauseContext) {} + +// EnterUser_tablespace_clause is called when production user_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_tablespace_clause(ctx *User_tablespace_clauseContext) {} + +// ExitUser_tablespace_clause is called when production user_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_tablespace_clause(ctx *User_tablespace_clauseContext) {} + +// EnterQuota_clause is called when production quota_clause is entered. +func (s *BasePlSqlParserListener) EnterQuota_clause(ctx *Quota_clauseContext) {} + +// ExitQuota_clause is called when production quota_clause is exited. +func (s *BasePlSqlParserListener) ExitQuota_clause(ctx *Quota_clauseContext) {} + +// EnterProfile_clause is called when production profile_clause is entered. +func (s *BasePlSqlParserListener) EnterProfile_clause(ctx *Profile_clauseContext) {} + +// ExitProfile_clause is called when production profile_clause is exited. +func (s *BasePlSqlParserListener) ExitProfile_clause(ctx *Profile_clauseContext) {} + +// EnterRole_clause is called when production role_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_clause(ctx *Role_clauseContext) {} + +// ExitRole_clause is called when production role_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_clause(ctx *Role_clauseContext) {} + +// EnterUser_default_role_clause is called when production user_default_role_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_default_role_clause(ctx *User_default_role_clauseContext) { +} + +// ExitUser_default_role_clause is called when production user_default_role_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_default_role_clause(ctx *User_default_role_clauseContext) { +} + +// EnterPassword_expire_clause is called when production password_expire_clause is entered. +func (s *BasePlSqlParserListener) EnterPassword_expire_clause(ctx *Password_expire_clauseContext) {} + +// ExitPassword_expire_clause is called when production password_expire_clause is exited. +func (s *BasePlSqlParserListener) ExitPassword_expire_clause(ctx *Password_expire_clauseContext) {} + +// EnterUser_lock_clause is called when production user_lock_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_lock_clause(ctx *User_lock_clauseContext) {} + +// ExitUser_lock_clause is called when production user_lock_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_lock_clause(ctx *User_lock_clauseContext) {} + +// EnterUser_editions_clause is called when production user_editions_clause is entered. +func (s *BasePlSqlParserListener) EnterUser_editions_clause(ctx *User_editions_clauseContext) {} + +// ExitUser_editions_clause is called when production user_editions_clause is exited. +func (s *BasePlSqlParserListener) ExitUser_editions_clause(ctx *User_editions_clauseContext) {} + +// EnterAlter_user_editions_clause is called when production alter_user_editions_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) { +} + +// ExitAlter_user_editions_clause is called when production alter_user_editions_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) { +} + +// EnterProxy_clause is called when production proxy_clause is entered. +func (s *BasePlSqlParserListener) EnterProxy_clause(ctx *Proxy_clauseContext) {} + +// ExitProxy_clause is called when production proxy_clause is exited. +func (s *BasePlSqlParserListener) ExitProxy_clause(ctx *Proxy_clauseContext) {} + +// EnterContainer_names is called when production container_names is entered. +func (s *BasePlSqlParserListener) EnterContainer_names(ctx *Container_namesContext) {} + +// ExitContainer_names is called when production container_names is exited. +func (s *BasePlSqlParserListener) ExitContainer_names(ctx *Container_namesContext) {} + +// EnterSet_container_data is called when production set_container_data is entered. +func (s *BasePlSqlParserListener) EnterSet_container_data(ctx *Set_container_dataContext) {} + +// ExitSet_container_data is called when production set_container_data is exited. +func (s *BasePlSqlParserListener) ExitSet_container_data(ctx *Set_container_dataContext) {} + +// EnterAdd_rem_container_data is called when production add_rem_container_data is entered. +func (s *BasePlSqlParserListener) EnterAdd_rem_container_data(ctx *Add_rem_container_dataContext) {} + +// ExitAdd_rem_container_data is called when production add_rem_container_data is exited. +func (s *BasePlSqlParserListener) ExitAdd_rem_container_data(ctx *Add_rem_container_dataContext) {} + +// EnterContainer_data_clause is called when production container_data_clause is entered. +func (s *BasePlSqlParserListener) EnterContainer_data_clause(ctx *Container_data_clauseContext) {} + +// ExitContainer_data_clause is called when production container_data_clause is exited. +func (s *BasePlSqlParserListener) ExitContainer_data_clause(ctx *Container_data_clauseContext) {} + +// EnterAdminister_key_management is called when production administer_key_management is entered. +func (s *BasePlSqlParserListener) EnterAdminister_key_management(ctx *Administer_key_managementContext) { +} + +// ExitAdminister_key_management is called when production administer_key_management is exited. +func (s *BasePlSqlParserListener) ExitAdminister_key_management(ctx *Administer_key_managementContext) { +} + +// EnterKeystore_management_clauses is called when production keystore_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterKeystore_management_clauses(ctx *Keystore_management_clausesContext) { +} + +// ExitKeystore_management_clauses is called when production keystore_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitKeystore_management_clauses(ctx *Keystore_management_clausesContext) { +} + +// EnterCreate_keystore is called when production create_keystore is entered. +func (s *BasePlSqlParserListener) EnterCreate_keystore(ctx *Create_keystoreContext) {} + +// ExitCreate_keystore is called when production create_keystore is exited. +func (s *BasePlSqlParserListener) ExitCreate_keystore(ctx *Create_keystoreContext) {} + +// EnterOpen_keystore is called when production open_keystore is entered. +func (s *BasePlSqlParserListener) EnterOpen_keystore(ctx *Open_keystoreContext) {} + +// ExitOpen_keystore is called when production open_keystore is exited. +func (s *BasePlSqlParserListener) ExitOpen_keystore(ctx *Open_keystoreContext) {} + +// EnterForce_keystore is called when production force_keystore is entered. +func (s *BasePlSqlParserListener) EnterForce_keystore(ctx *Force_keystoreContext) {} + +// ExitForce_keystore is called when production force_keystore is exited. +func (s *BasePlSqlParserListener) ExitForce_keystore(ctx *Force_keystoreContext) {} + +// EnterClose_keystore is called when production close_keystore is entered. +func (s *BasePlSqlParserListener) EnterClose_keystore(ctx *Close_keystoreContext) {} + +// ExitClose_keystore is called when production close_keystore is exited. +func (s *BasePlSqlParserListener) ExitClose_keystore(ctx *Close_keystoreContext) {} + +// EnterBackup_keystore is called when production backup_keystore is entered. +func (s *BasePlSqlParserListener) EnterBackup_keystore(ctx *Backup_keystoreContext) {} + +// ExitBackup_keystore is called when production backup_keystore is exited. +func (s *BasePlSqlParserListener) ExitBackup_keystore(ctx *Backup_keystoreContext) {} + +// EnterAlter_keystore_password is called when production alter_keystore_password is entered. +func (s *BasePlSqlParserListener) EnterAlter_keystore_password(ctx *Alter_keystore_passwordContext) {} + +// ExitAlter_keystore_password is called when production alter_keystore_password is exited. +func (s *BasePlSqlParserListener) ExitAlter_keystore_password(ctx *Alter_keystore_passwordContext) {} + +// EnterMerge_into_new_keystore is called when production merge_into_new_keystore is entered. +func (s *BasePlSqlParserListener) EnterMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) {} + +// ExitMerge_into_new_keystore is called when production merge_into_new_keystore is exited. +func (s *BasePlSqlParserListener) ExitMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) {} + +// EnterMerge_into_existing_keystore is called when production merge_into_existing_keystore is entered. +func (s *BasePlSqlParserListener) EnterMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) { +} + +// ExitMerge_into_existing_keystore is called when production merge_into_existing_keystore is exited. +func (s *BasePlSqlParserListener) ExitMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) { +} + +// EnterIsolate_keystore is called when production isolate_keystore is entered. +func (s *BasePlSqlParserListener) EnterIsolate_keystore(ctx *Isolate_keystoreContext) {} + +// ExitIsolate_keystore is called when production isolate_keystore is exited. +func (s *BasePlSqlParserListener) ExitIsolate_keystore(ctx *Isolate_keystoreContext) {} + +// EnterUnite_keystore is called when production unite_keystore is entered. +func (s *BasePlSqlParserListener) EnterUnite_keystore(ctx *Unite_keystoreContext) {} + +// ExitUnite_keystore is called when production unite_keystore is exited. +func (s *BasePlSqlParserListener) ExitUnite_keystore(ctx *Unite_keystoreContext) {} + +// EnterKey_management_clauses is called when production key_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterKey_management_clauses(ctx *Key_management_clausesContext) {} + +// ExitKey_management_clauses is called when production key_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitKey_management_clauses(ctx *Key_management_clausesContext) {} + +// EnterSet_key is called when production set_key is entered. +func (s *BasePlSqlParserListener) EnterSet_key(ctx *Set_keyContext) {} + +// ExitSet_key is called when production set_key is exited. +func (s *BasePlSqlParserListener) ExitSet_key(ctx *Set_keyContext) {} + +// EnterCreate_key is called when production create_key is entered. +func (s *BasePlSqlParserListener) EnterCreate_key(ctx *Create_keyContext) {} + +// ExitCreate_key is called when production create_key is exited. +func (s *BasePlSqlParserListener) ExitCreate_key(ctx *Create_keyContext) {} + +// EnterMkid is called when production mkid is entered. +func (s *BasePlSqlParserListener) EnterMkid(ctx *MkidContext) {} + +// ExitMkid is called when production mkid is exited. +func (s *BasePlSqlParserListener) ExitMkid(ctx *MkidContext) {} + +// EnterMk is called when production mk is entered. +func (s *BasePlSqlParserListener) EnterMk(ctx *MkContext) {} + +// ExitMk is called when production mk is exited. +func (s *BasePlSqlParserListener) ExitMk(ctx *MkContext) {} + +// EnterUse_key is called when production use_key is entered. +func (s *BasePlSqlParserListener) EnterUse_key(ctx *Use_keyContext) {} + +// ExitUse_key is called when production use_key is exited. +func (s *BasePlSqlParserListener) ExitUse_key(ctx *Use_keyContext) {} + +// EnterSet_key_tag is called when production set_key_tag is entered. +func (s *BasePlSqlParserListener) EnterSet_key_tag(ctx *Set_key_tagContext) {} + +// ExitSet_key_tag is called when production set_key_tag is exited. +func (s *BasePlSqlParserListener) ExitSet_key_tag(ctx *Set_key_tagContext) {} + +// EnterExport_keys is called when production export_keys is entered. +func (s *BasePlSqlParserListener) EnterExport_keys(ctx *Export_keysContext) {} + +// ExitExport_keys is called when production export_keys is exited. +func (s *BasePlSqlParserListener) ExitExport_keys(ctx *Export_keysContext) {} + +// EnterImport_keys is called when production import_keys is entered. +func (s *BasePlSqlParserListener) EnterImport_keys(ctx *Import_keysContext) {} + +// ExitImport_keys is called when production import_keys is exited. +func (s *BasePlSqlParserListener) ExitImport_keys(ctx *Import_keysContext) {} + +// EnterMigrate_keys is called when production migrate_keys is entered. +func (s *BasePlSqlParserListener) EnterMigrate_keys(ctx *Migrate_keysContext) {} + +// ExitMigrate_keys is called when production migrate_keys is exited. +func (s *BasePlSqlParserListener) ExitMigrate_keys(ctx *Migrate_keysContext) {} + +// EnterReverse_migrate_keys is called when production reverse_migrate_keys is entered. +func (s *BasePlSqlParserListener) EnterReverse_migrate_keys(ctx *Reverse_migrate_keysContext) {} + +// ExitReverse_migrate_keys is called when production reverse_migrate_keys is exited. +func (s *BasePlSqlParserListener) ExitReverse_migrate_keys(ctx *Reverse_migrate_keysContext) {} + +// EnterMove_keys is called when production move_keys is entered. +func (s *BasePlSqlParserListener) EnterMove_keys(ctx *Move_keysContext) {} + +// ExitMove_keys is called when production move_keys is exited. +func (s *BasePlSqlParserListener) ExitMove_keys(ctx *Move_keysContext) {} + +// EnterIdentified_by_store is called when production identified_by_store is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by_store(ctx *Identified_by_storeContext) {} + +// ExitIdentified_by_store is called when production identified_by_store is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by_store(ctx *Identified_by_storeContext) {} + +// EnterUsing_algorithm_clause is called when production using_algorithm_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) {} + +// ExitUsing_algorithm_clause is called when production using_algorithm_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) {} + +// EnterUsing_tag_clause is called when production using_tag_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_tag_clause(ctx *Using_tag_clauseContext) {} + +// ExitUsing_tag_clause is called when production using_tag_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_tag_clause(ctx *Using_tag_clauseContext) {} + +// EnterSecret_management_clauses is called when production secret_management_clauses is entered. +func (s *BasePlSqlParserListener) EnterSecret_management_clauses(ctx *Secret_management_clausesContext) { +} + +// ExitSecret_management_clauses is called when production secret_management_clauses is exited. +func (s *BasePlSqlParserListener) ExitSecret_management_clauses(ctx *Secret_management_clausesContext) { +} + +// EnterAdd_update_secret is called when production add_update_secret is entered. +func (s *BasePlSqlParserListener) EnterAdd_update_secret(ctx *Add_update_secretContext) {} + +// ExitAdd_update_secret is called when production add_update_secret is exited. +func (s *BasePlSqlParserListener) ExitAdd_update_secret(ctx *Add_update_secretContext) {} + +// EnterDelete_secret is called when production delete_secret is entered. +func (s *BasePlSqlParserListener) EnterDelete_secret(ctx *Delete_secretContext) {} + +// ExitDelete_secret is called when production delete_secret is exited. +func (s *BasePlSqlParserListener) ExitDelete_secret(ctx *Delete_secretContext) {} + +// EnterAdd_update_secret_seps is called when production add_update_secret_seps is entered. +func (s *BasePlSqlParserListener) EnterAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) {} + +// ExitAdd_update_secret_seps is called when production add_update_secret_seps is exited. +func (s *BasePlSqlParserListener) ExitAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) {} + +// EnterDelete_secret_seps is called when production delete_secret_seps is entered. +func (s *BasePlSqlParserListener) EnterDelete_secret_seps(ctx *Delete_secret_sepsContext) {} + +// ExitDelete_secret_seps is called when production delete_secret_seps is exited. +func (s *BasePlSqlParserListener) ExitDelete_secret_seps(ctx *Delete_secret_sepsContext) {} + +// EnterZero_downtime_software_patching_clauses is called when production zero_downtime_software_patching_clauses is entered. +func (s *BasePlSqlParserListener) EnterZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) { +} + +// ExitZero_downtime_software_patching_clauses is called when production zero_downtime_software_patching_clauses is exited. +func (s *BasePlSqlParserListener) ExitZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) { +} + +// EnterWith_backup_clause is called when production with_backup_clause is entered. +func (s *BasePlSqlParserListener) EnterWith_backup_clause(ctx *With_backup_clauseContext) {} + +// ExitWith_backup_clause is called when production with_backup_clause is exited. +func (s *BasePlSqlParserListener) ExitWith_backup_clause(ctx *With_backup_clauseContext) {} + +// EnterIdentified_by_password_clause is called when production identified_by_password_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) { +} + +// ExitIdentified_by_password_clause is called when production identified_by_password_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) { +} + +// EnterKeystore_password is called when production keystore_password is entered. +func (s *BasePlSqlParserListener) EnterKeystore_password(ctx *Keystore_passwordContext) {} + +// ExitKeystore_password is called when production keystore_password is exited. +func (s *BasePlSqlParserListener) ExitKeystore_password(ctx *Keystore_passwordContext) {} + +// EnterPath is called when production path is entered. +func (s *BasePlSqlParserListener) EnterPath(ctx *PathContext) {} + +// ExitPath is called when production path is exited. +func (s *BasePlSqlParserListener) ExitPath(ctx *PathContext) {} + +// EnterSecret is called when production secret is entered. +func (s *BasePlSqlParserListener) EnterSecret(ctx *SecretContext) {} + +// ExitSecret is called when production secret is exited. +func (s *BasePlSqlParserListener) ExitSecret(ctx *SecretContext) {} + +// EnterAnalyze is called when production analyze is entered. +func (s *BasePlSqlParserListener) EnterAnalyze(ctx *AnalyzeContext) {} + +// ExitAnalyze is called when production analyze is exited. +func (s *BasePlSqlParserListener) ExitAnalyze(ctx *AnalyzeContext) {} + +// EnterPartition_extention_clause is called when production partition_extention_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_extention_clause(ctx *Partition_extention_clauseContext) { +} + +// ExitPartition_extention_clause is called when production partition_extention_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_extention_clause(ctx *Partition_extention_clauseContext) { +} + +// EnterValidation_clauses is called when production validation_clauses is entered. +func (s *BasePlSqlParserListener) EnterValidation_clauses(ctx *Validation_clausesContext) {} + +// ExitValidation_clauses is called when production validation_clauses is exited. +func (s *BasePlSqlParserListener) ExitValidation_clauses(ctx *Validation_clausesContext) {} + +// EnterCompute_clauses is called when production compute_clauses is entered. +func (s *BasePlSqlParserListener) EnterCompute_clauses(ctx *Compute_clausesContext) {} + +// ExitCompute_clauses is called when production compute_clauses is exited. +func (s *BasePlSqlParserListener) ExitCompute_clauses(ctx *Compute_clausesContext) {} + +// EnterFor_clause is called when production for_clause is entered. +func (s *BasePlSqlParserListener) EnterFor_clause(ctx *For_clauseContext) {} + +// ExitFor_clause is called when production for_clause is exited. +func (s *BasePlSqlParserListener) ExitFor_clause(ctx *For_clauseContext) {} + +// EnterOnline_or_offline is called when production online_or_offline is entered. +func (s *BasePlSqlParserListener) EnterOnline_or_offline(ctx *Online_or_offlineContext) {} + +// ExitOnline_or_offline is called when production online_or_offline is exited. +func (s *BasePlSqlParserListener) ExitOnline_or_offline(ctx *Online_or_offlineContext) {} + +// EnterInto_clause1 is called when production into_clause1 is entered. +func (s *BasePlSqlParserListener) EnterInto_clause1(ctx *Into_clause1Context) {} + +// ExitInto_clause1 is called when production into_clause1 is exited. +func (s *BasePlSqlParserListener) ExitInto_clause1(ctx *Into_clause1Context) {} + +// EnterPartition_key_value is called when production partition_key_value is entered. +func (s *BasePlSqlParserListener) EnterPartition_key_value(ctx *Partition_key_valueContext) {} + +// ExitPartition_key_value is called when production partition_key_value is exited. +func (s *BasePlSqlParserListener) ExitPartition_key_value(ctx *Partition_key_valueContext) {} + +// EnterSubpartition_key_value is called when production subpartition_key_value is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_key_value(ctx *Subpartition_key_valueContext) {} + +// ExitSubpartition_key_value is called when production subpartition_key_value is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_key_value(ctx *Subpartition_key_valueContext) {} + +// EnterAssociate_statistics is called when production associate_statistics is entered. +func (s *BasePlSqlParserListener) EnterAssociate_statistics(ctx *Associate_statisticsContext) {} + +// ExitAssociate_statistics is called when production associate_statistics is exited. +func (s *BasePlSqlParserListener) ExitAssociate_statistics(ctx *Associate_statisticsContext) {} + +// EnterColumn_association is called when production column_association is entered. +func (s *BasePlSqlParserListener) EnterColumn_association(ctx *Column_associationContext) {} + +// ExitColumn_association is called when production column_association is exited. +func (s *BasePlSqlParserListener) ExitColumn_association(ctx *Column_associationContext) {} + +// EnterFunction_association is called when production function_association is entered. +func (s *BasePlSqlParserListener) EnterFunction_association(ctx *Function_associationContext) {} + +// ExitFunction_association is called when production function_association is exited. +func (s *BasePlSqlParserListener) ExitFunction_association(ctx *Function_associationContext) {} + +// EnterIndextype_name is called when production indextype_name is entered. +func (s *BasePlSqlParserListener) EnterIndextype_name(ctx *Indextype_nameContext) {} + +// ExitIndextype_name is called when production indextype_name is exited. +func (s *BasePlSqlParserListener) ExitIndextype_name(ctx *Indextype_nameContext) {} + +// EnterUsing_statistics_type is called when production using_statistics_type is entered. +func (s *BasePlSqlParserListener) EnterUsing_statistics_type(ctx *Using_statistics_typeContext) {} + +// ExitUsing_statistics_type is called when production using_statistics_type is exited. +func (s *BasePlSqlParserListener) ExitUsing_statistics_type(ctx *Using_statistics_typeContext) {} + +// EnterStatistics_type_name is called when production statistics_type_name is entered. +func (s *BasePlSqlParserListener) EnterStatistics_type_name(ctx *Statistics_type_nameContext) {} + +// ExitStatistics_type_name is called when production statistics_type_name is exited. +func (s *BasePlSqlParserListener) ExitStatistics_type_name(ctx *Statistics_type_nameContext) {} + +// EnterDefault_cost_clause is called when production default_cost_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_cost_clause(ctx *Default_cost_clauseContext) {} + +// ExitDefault_cost_clause is called when production default_cost_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_cost_clause(ctx *Default_cost_clauseContext) {} + +// EnterCpu_cost is called when production cpu_cost is entered. +func (s *BasePlSqlParserListener) EnterCpu_cost(ctx *Cpu_costContext) {} + +// ExitCpu_cost is called when production cpu_cost is exited. +func (s *BasePlSqlParserListener) ExitCpu_cost(ctx *Cpu_costContext) {} + +// EnterIo_cost is called when production io_cost is entered. +func (s *BasePlSqlParserListener) EnterIo_cost(ctx *Io_costContext) {} + +// ExitIo_cost is called when production io_cost is exited. +func (s *BasePlSqlParserListener) ExitIo_cost(ctx *Io_costContext) {} + +// EnterNetwork_cost is called when production network_cost is entered. +func (s *BasePlSqlParserListener) EnterNetwork_cost(ctx *Network_costContext) {} + +// ExitNetwork_cost is called when production network_cost is exited. +func (s *BasePlSqlParserListener) ExitNetwork_cost(ctx *Network_costContext) {} + +// EnterDefault_selectivity_clause is called when production default_selectivity_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) { +} + +// ExitDefault_selectivity_clause is called when production default_selectivity_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) { +} + +// EnterDefault_selectivity is called when production default_selectivity is entered. +func (s *BasePlSqlParserListener) EnterDefault_selectivity(ctx *Default_selectivityContext) {} + +// ExitDefault_selectivity is called when production default_selectivity is exited. +func (s *BasePlSqlParserListener) ExitDefault_selectivity(ctx *Default_selectivityContext) {} + +// EnterStorage_table_clause is called when production storage_table_clause is entered. +func (s *BasePlSqlParserListener) EnterStorage_table_clause(ctx *Storage_table_clauseContext) {} + +// ExitStorage_table_clause is called when production storage_table_clause is exited. +func (s *BasePlSqlParserListener) ExitStorage_table_clause(ctx *Storage_table_clauseContext) {} + +// EnterUnified_auditing is called when production unified_auditing is entered. +func (s *BasePlSqlParserListener) EnterUnified_auditing(ctx *Unified_auditingContext) {} + +// ExitUnified_auditing is called when production unified_auditing is exited. +func (s *BasePlSqlParserListener) ExitUnified_auditing(ctx *Unified_auditingContext) {} + +// EnterPolicy_name is called when production policy_name is entered. +func (s *BasePlSqlParserListener) EnterPolicy_name(ctx *Policy_nameContext) {} + +// ExitPolicy_name is called when production policy_name is exited. +func (s *BasePlSqlParserListener) ExitPolicy_name(ctx *Policy_nameContext) {} + +// EnterAudit_traditional is called when production audit_traditional is entered. +func (s *BasePlSqlParserListener) EnterAudit_traditional(ctx *Audit_traditionalContext) {} + +// ExitAudit_traditional is called when production audit_traditional is exited. +func (s *BasePlSqlParserListener) ExitAudit_traditional(ctx *Audit_traditionalContext) {} + +// EnterAudit_direct_path is called when production audit_direct_path is entered. +func (s *BasePlSqlParserListener) EnterAudit_direct_path(ctx *Audit_direct_pathContext) {} + +// ExitAudit_direct_path is called when production audit_direct_path is exited. +func (s *BasePlSqlParserListener) ExitAudit_direct_path(ctx *Audit_direct_pathContext) {} + +// EnterAudit_container_clause is called when production audit_container_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_container_clause(ctx *Audit_container_clauseContext) {} + +// ExitAudit_container_clause is called when production audit_container_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_container_clause(ctx *Audit_container_clauseContext) {} + +// EnterAudit_operation_clause is called when production audit_operation_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_operation_clause(ctx *Audit_operation_clauseContext) {} + +// ExitAudit_operation_clause is called when production audit_operation_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_operation_clause(ctx *Audit_operation_clauseContext) {} + +// EnterAuditing_by_clause is called when production auditing_by_clause is entered. +func (s *BasePlSqlParserListener) EnterAuditing_by_clause(ctx *Auditing_by_clauseContext) {} + +// ExitAuditing_by_clause is called when production auditing_by_clause is exited. +func (s *BasePlSqlParserListener) ExitAuditing_by_clause(ctx *Auditing_by_clauseContext) {} + +// EnterAudit_user is called when production audit_user is entered. +func (s *BasePlSqlParserListener) EnterAudit_user(ctx *Audit_userContext) {} + +// ExitAudit_user is called when production audit_user is exited. +func (s *BasePlSqlParserListener) ExitAudit_user(ctx *Audit_userContext) {} + +// EnterAudit_schema_object_clause is called when production audit_schema_object_clause is entered. +func (s *BasePlSqlParserListener) EnterAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) { +} + +// ExitAudit_schema_object_clause is called when production audit_schema_object_clause is exited. +func (s *BasePlSqlParserListener) ExitAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) { +} + +// EnterSql_operation is called when production sql_operation is entered. +func (s *BasePlSqlParserListener) EnterSql_operation(ctx *Sql_operationContext) {} + +// ExitSql_operation is called when production sql_operation is exited. +func (s *BasePlSqlParserListener) ExitSql_operation(ctx *Sql_operationContext) {} + +// EnterAuditing_on_clause is called when production auditing_on_clause is entered. +func (s *BasePlSqlParserListener) EnterAuditing_on_clause(ctx *Auditing_on_clauseContext) {} + +// ExitAuditing_on_clause is called when production auditing_on_clause is exited. +func (s *BasePlSqlParserListener) ExitAuditing_on_clause(ctx *Auditing_on_clauseContext) {} + +// EnterModel_name is called when production model_name is entered. +func (s *BasePlSqlParserListener) EnterModel_name(ctx *Model_nameContext) {} + +// ExitModel_name is called when production model_name is exited. +func (s *BasePlSqlParserListener) ExitModel_name(ctx *Model_nameContext) {} + +// EnterObject_name is called when production object_name is entered. +func (s *BasePlSqlParserListener) EnterObject_name(ctx *Object_nameContext) {} + +// ExitObject_name is called when production object_name is exited. +func (s *BasePlSqlParserListener) ExitObject_name(ctx *Object_nameContext) {} + +// EnterProfile_name is called when production profile_name is entered. +func (s *BasePlSqlParserListener) EnterProfile_name(ctx *Profile_nameContext) {} + +// ExitProfile_name is called when production profile_name is exited. +func (s *BasePlSqlParserListener) ExitProfile_name(ctx *Profile_nameContext) {} + +// EnterSql_statement_shortcut is called when production sql_statement_shortcut is entered. +func (s *BasePlSqlParserListener) EnterSql_statement_shortcut(ctx *Sql_statement_shortcutContext) {} + +// ExitSql_statement_shortcut is called when production sql_statement_shortcut is exited. +func (s *BasePlSqlParserListener) ExitSql_statement_shortcut(ctx *Sql_statement_shortcutContext) {} + +// EnterDrop_index is called when production drop_index is entered. +func (s *BasePlSqlParserListener) EnterDrop_index(ctx *Drop_indexContext) {} + +// ExitDrop_index is called when production drop_index is exited. +func (s *BasePlSqlParserListener) ExitDrop_index(ctx *Drop_indexContext) {} + +// EnterDisassociate_statistics is called when production disassociate_statistics is entered. +func (s *BasePlSqlParserListener) EnterDisassociate_statistics(ctx *Disassociate_statisticsContext) {} + +// ExitDisassociate_statistics is called when production disassociate_statistics is exited. +func (s *BasePlSqlParserListener) ExitDisassociate_statistics(ctx *Disassociate_statisticsContext) {} + +// EnterDrop_indextype is called when production drop_indextype is entered. +func (s *BasePlSqlParserListener) EnterDrop_indextype(ctx *Drop_indextypeContext) {} + +// ExitDrop_indextype is called when production drop_indextype is exited. +func (s *BasePlSqlParserListener) ExitDrop_indextype(ctx *Drop_indextypeContext) {} + +// EnterDrop_inmemory_join_group is called when production drop_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) { +} + +// ExitDrop_inmemory_join_group is called when production drop_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) { +} + +// EnterFlashback_table is called when production flashback_table is entered. +func (s *BasePlSqlParserListener) EnterFlashback_table(ctx *Flashback_tableContext) {} + +// ExitFlashback_table is called when production flashback_table is exited. +func (s *BasePlSqlParserListener) ExitFlashback_table(ctx *Flashback_tableContext) {} + +// EnterRestore_point is called when production restore_point is entered. +func (s *BasePlSqlParserListener) EnterRestore_point(ctx *Restore_pointContext) {} + +// ExitRestore_point is called when production restore_point is exited. +func (s *BasePlSqlParserListener) ExitRestore_point(ctx *Restore_pointContext) {} + +// EnterPurge_statement is called when production purge_statement is entered. +func (s *BasePlSqlParserListener) EnterPurge_statement(ctx *Purge_statementContext) {} + +// ExitPurge_statement is called when production purge_statement is exited. +func (s *BasePlSqlParserListener) ExitPurge_statement(ctx *Purge_statementContext) {} + +// EnterNoaudit_statement is called when production noaudit_statement is entered. +func (s *BasePlSqlParserListener) EnterNoaudit_statement(ctx *Noaudit_statementContext) {} + +// ExitNoaudit_statement is called when production noaudit_statement is exited. +func (s *BasePlSqlParserListener) ExitNoaudit_statement(ctx *Noaudit_statementContext) {} + +// EnterRename_object is called when production rename_object is entered. +func (s *BasePlSqlParserListener) EnterRename_object(ctx *Rename_objectContext) {} + +// ExitRename_object is called when production rename_object is exited. +func (s *BasePlSqlParserListener) ExitRename_object(ctx *Rename_objectContext) {} + +// EnterGrant_statement is called when production grant_statement is entered. +func (s *BasePlSqlParserListener) EnterGrant_statement(ctx *Grant_statementContext) {} + +// ExitGrant_statement is called when production grant_statement is exited. +func (s *BasePlSqlParserListener) ExitGrant_statement(ctx *Grant_statementContext) {} + +// EnterContainer_clause is called when production container_clause is entered. +func (s *BasePlSqlParserListener) EnterContainer_clause(ctx *Container_clauseContext) {} + +// ExitContainer_clause is called when production container_clause is exited. +func (s *BasePlSqlParserListener) ExitContainer_clause(ctx *Container_clauseContext) {} + +// EnterRevoke_statement is called when production revoke_statement is entered. +func (s *BasePlSqlParserListener) EnterRevoke_statement(ctx *Revoke_statementContext) {} + +// ExitRevoke_statement is called when production revoke_statement is exited. +func (s *BasePlSqlParserListener) ExitRevoke_statement(ctx *Revoke_statementContext) {} + +// EnterRevoke_system_privilege is called when production revoke_system_privilege is entered. +func (s *BasePlSqlParserListener) EnterRevoke_system_privilege(ctx *Revoke_system_privilegeContext) {} + +// ExitRevoke_system_privilege is called when production revoke_system_privilege is exited. +func (s *BasePlSqlParserListener) ExitRevoke_system_privilege(ctx *Revoke_system_privilegeContext) {} + +// EnterRevokee_clause is called when production revokee_clause is entered. +func (s *BasePlSqlParserListener) EnterRevokee_clause(ctx *Revokee_clauseContext) {} + +// ExitRevokee_clause is called when production revokee_clause is exited. +func (s *BasePlSqlParserListener) ExitRevokee_clause(ctx *Revokee_clauseContext) {} + +// EnterRevoke_object_privileges is called when production revoke_object_privileges is entered. +func (s *BasePlSqlParserListener) EnterRevoke_object_privileges(ctx *Revoke_object_privilegesContext) { +} + +// ExitRevoke_object_privileges is called when production revoke_object_privileges is exited. +func (s *BasePlSqlParserListener) ExitRevoke_object_privileges(ctx *Revoke_object_privilegesContext) { +} + +// EnterOn_object_clause is called when production on_object_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_object_clause(ctx *On_object_clauseContext) {} + +// ExitOn_object_clause is called when production on_object_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_object_clause(ctx *On_object_clauseContext) {} + +// EnterRevoke_roles_from_programs is called when production revoke_roles_from_programs is entered. +func (s *BasePlSqlParserListener) EnterRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) { +} + +// ExitRevoke_roles_from_programs is called when production revoke_roles_from_programs is exited. +func (s *BasePlSqlParserListener) ExitRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) { +} + +// EnterProgram_unit is called when production program_unit is entered. +func (s *BasePlSqlParserListener) EnterProgram_unit(ctx *Program_unitContext) {} + +// ExitProgram_unit is called when production program_unit is exited. +func (s *BasePlSqlParserListener) ExitProgram_unit(ctx *Program_unitContext) {} + +// EnterCreate_dimension is called when production create_dimension is entered. +func (s *BasePlSqlParserListener) EnterCreate_dimension(ctx *Create_dimensionContext) {} + +// ExitCreate_dimension is called when production create_dimension is exited. +func (s *BasePlSqlParserListener) ExitCreate_dimension(ctx *Create_dimensionContext) {} + +// EnterCreate_directory is called when production create_directory is entered. +func (s *BasePlSqlParserListener) EnterCreate_directory(ctx *Create_directoryContext) {} + +// ExitCreate_directory is called when production create_directory is exited. +func (s *BasePlSqlParserListener) ExitCreate_directory(ctx *Create_directoryContext) {} + +// EnterDirectory_name is called when production directory_name is entered. +func (s *BasePlSqlParserListener) EnterDirectory_name(ctx *Directory_nameContext) {} + +// ExitDirectory_name is called when production directory_name is exited. +func (s *BasePlSqlParserListener) ExitDirectory_name(ctx *Directory_nameContext) {} + +// EnterDirectory_path is called when production directory_path is entered. +func (s *BasePlSqlParserListener) EnterDirectory_path(ctx *Directory_pathContext) {} + +// ExitDirectory_path is called when production directory_path is exited. +func (s *BasePlSqlParserListener) ExitDirectory_path(ctx *Directory_pathContext) {} + +// EnterCreate_inmemory_join_group is called when production create_inmemory_join_group is entered. +func (s *BasePlSqlParserListener) EnterCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) { +} + +// ExitCreate_inmemory_join_group is called when production create_inmemory_join_group is exited. +func (s *BasePlSqlParserListener) ExitCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) { +} + +// EnterDrop_hierarchy is called when production drop_hierarchy is entered. +func (s *BasePlSqlParserListener) EnterDrop_hierarchy(ctx *Drop_hierarchyContext) {} + +// ExitDrop_hierarchy is called when production drop_hierarchy is exited. +func (s *BasePlSqlParserListener) ExitDrop_hierarchy(ctx *Drop_hierarchyContext) {} + +// EnterAlter_library is called when production alter_library is entered. +func (s *BasePlSqlParserListener) EnterAlter_library(ctx *Alter_libraryContext) {} + +// ExitAlter_library is called when production alter_library is exited. +func (s *BasePlSqlParserListener) ExitAlter_library(ctx *Alter_libraryContext) {} + +// EnterDrop_java is called when production drop_java is entered. +func (s *BasePlSqlParserListener) EnterDrop_java(ctx *Drop_javaContext) {} + +// ExitDrop_java is called when production drop_java is exited. +func (s *BasePlSqlParserListener) ExitDrop_java(ctx *Drop_javaContext) {} + +// EnterDrop_library is called when production drop_library is entered. +func (s *BasePlSqlParserListener) EnterDrop_library(ctx *Drop_libraryContext) {} + +// ExitDrop_library is called when production drop_library is exited. +func (s *BasePlSqlParserListener) ExitDrop_library(ctx *Drop_libraryContext) {} + +// EnterCreate_java is called when production create_java is entered. +func (s *BasePlSqlParserListener) EnterCreate_java(ctx *Create_javaContext) {} + +// ExitCreate_java is called when production create_java is exited. +func (s *BasePlSqlParserListener) ExitCreate_java(ctx *Create_javaContext) {} + +// EnterCreate_library is called when production create_library is entered. +func (s *BasePlSqlParserListener) EnterCreate_library(ctx *Create_libraryContext) {} + +// ExitCreate_library is called when production create_library is exited. +func (s *BasePlSqlParserListener) ExitCreate_library(ctx *Create_libraryContext) {} + +// EnterPlsql_library_source is called when production plsql_library_source is entered. +func (s *BasePlSqlParserListener) EnterPlsql_library_source(ctx *Plsql_library_sourceContext) {} + +// ExitPlsql_library_source is called when production plsql_library_source is exited. +func (s *BasePlSqlParserListener) ExitPlsql_library_source(ctx *Plsql_library_sourceContext) {} + +// EnterCredential_name is called when production credential_name is entered. +func (s *BasePlSqlParserListener) EnterCredential_name(ctx *Credential_nameContext) {} + +// ExitCredential_name is called when production credential_name is exited. +func (s *BasePlSqlParserListener) ExitCredential_name(ctx *Credential_nameContext) {} + +// EnterLibrary_editionable is called when production library_editionable is entered. +func (s *BasePlSqlParserListener) EnterLibrary_editionable(ctx *Library_editionableContext) {} + +// ExitLibrary_editionable is called when production library_editionable is exited. +func (s *BasePlSqlParserListener) ExitLibrary_editionable(ctx *Library_editionableContext) {} + +// EnterLibrary_debug is called when production library_debug is entered. +func (s *BasePlSqlParserListener) EnterLibrary_debug(ctx *Library_debugContext) {} + +// ExitLibrary_debug is called when production library_debug is exited. +func (s *BasePlSqlParserListener) ExitLibrary_debug(ctx *Library_debugContext) {} + +// EnterCompiler_parameters_clause is called when production compiler_parameters_clause is entered. +func (s *BasePlSqlParserListener) EnterCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) { +} + +// ExitCompiler_parameters_clause is called when production compiler_parameters_clause is exited. +func (s *BasePlSqlParserListener) ExitCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) { +} + +// EnterParameter_value is called when production parameter_value is entered. +func (s *BasePlSqlParserListener) EnterParameter_value(ctx *Parameter_valueContext) {} + +// ExitParameter_value is called when production parameter_value is exited. +func (s *BasePlSqlParserListener) ExitParameter_value(ctx *Parameter_valueContext) {} + +// EnterLibrary_name is called when production library_name is entered. +func (s *BasePlSqlParserListener) EnterLibrary_name(ctx *Library_nameContext) {} + +// ExitLibrary_name is called when production library_name is exited. +func (s *BasePlSqlParserListener) ExitLibrary_name(ctx *Library_nameContext) {} + +// EnterAlter_dimension is called when production alter_dimension is entered. +func (s *BasePlSqlParserListener) EnterAlter_dimension(ctx *Alter_dimensionContext) {} + +// ExitAlter_dimension is called when production alter_dimension is exited. +func (s *BasePlSqlParserListener) ExitAlter_dimension(ctx *Alter_dimensionContext) {} + +// EnterLevel_clause is called when production level_clause is entered. +func (s *BasePlSqlParserListener) EnterLevel_clause(ctx *Level_clauseContext) {} + +// ExitLevel_clause is called when production level_clause is exited. +func (s *BasePlSqlParserListener) ExitLevel_clause(ctx *Level_clauseContext) {} + +// EnterHierarchy_clause is called when production hierarchy_clause is entered. +func (s *BasePlSqlParserListener) EnterHierarchy_clause(ctx *Hierarchy_clauseContext) {} + +// ExitHierarchy_clause is called when production hierarchy_clause is exited. +func (s *BasePlSqlParserListener) ExitHierarchy_clause(ctx *Hierarchy_clauseContext) {} + +// EnterDimension_join_clause is called when production dimension_join_clause is entered. +func (s *BasePlSqlParserListener) EnterDimension_join_clause(ctx *Dimension_join_clauseContext) {} + +// ExitDimension_join_clause is called when production dimension_join_clause is exited. +func (s *BasePlSqlParserListener) ExitDimension_join_clause(ctx *Dimension_join_clauseContext) {} + +// EnterAttribute_clause is called when production attribute_clause is entered. +func (s *BasePlSqlParserListener) EnterAttribute_clause(ctx *Attribute_clauseContext) {} + +// ExitAttribute_clause is called when production attribute_clause is exited. +func (s *BasePlSqlParserListener) ExitAttribute_clause(ctx *Attribute_clauseContext) {} + +// EnterExtended_attribute_clause is called when production extended_attribute_clause is entered. +func (s *BasePlSqlParserListener) EnterExtended_attribute_clause(ctx *Extended_attribute_clauseContext) { +} + +// ExitExtended_attribute_clause is called when production extended_attribute_clause is exited. +func (s *BasePlSqlParserListener) ExitExtended_attribute_clause(ctx *Extended_attribute_clauseContext) { +} + +// EnterColumn_one_or_more_sub_clause is called when production column_one_or_more_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) { +} + +// ExitColumn_one_or_more_sub_clause is called when production column_one_or_more_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) { +} + +// EnterAlter_view is called when production alter_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_view(ctx *Alter_viewContext) {} + +// ExitAlter_view is called when production alter_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_view(ctx *Alter_viewContext) {} + +// EnterAlter_view_editionable is called when production alter_view_editionable is entered. +func (s *BasePlSqlParserListener) EnterAlter_view_editionable(ctx *Alter_view_editionableContext) {} + +// ExitAlter_view_editionable is called when production alter_view_editionable is exited. +func (s *BasePlSqlParserListener) ExitAlter_view_editionable(ctx *Alter_view_editionableContext) {} + +// EnterCreate_view is called when production create_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_view(ctx *Create_viewContext) {} + +// ExitCreate_view is called when production create_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_view(ctx *Create_viewContext) {} + +// EnterEditioning_clause is called when production editioning_clause is entered. +func (s *BasePlSqlParserListener) EnterEditioning_clause(ctx *Editioning_clauseContext) {} + +// ExitEditioning_clause is called when production editioning_clause is exited. +func (s *BasePlSqlParserListener) ExitEditioning_clause(ctx *Editioning_clauseContext) {} + +// EnterView_options is called when production view_options is entered. +func (s *BasePlSqlParserListener) EnterView_options(ctx *View_optionsContext) {} + +// ExitView_options is called when production view_options is exited. +func (s *BasePlSqlParserListener) ExitView_options(ctx *View_optionsContext) {} + +// EnterView_alias_constraint is called when production view_alias_constraint is entered. +func (s *BasePlSqlParserListener) EnterView_alias_constraint(ctx *View_alias_constraintContext) {} + +// ExitView_alias_constraint is called when production view_alias_constraint is exited. +func (s *BasePlSqlParserListener) ExitView_alias_constraint(ctx *View_alias_constraintContext) {} + +// EnterObject_view_clause is called when production object_view_clause is entered. +func (s *BasePlSqlParserListener) EnterObject_view_clause(ctx *Object_view_clauseContext) {} + +// ExitObject_view_clause is called when production object_view_clause is exited. +func (s *BasePlSqlParserListener) ExitObject_view_clause(ctx *Object_view_clauseContext) {} + +// EnterInline_constraint is called when production inline_constraint is entered. +func (s *BasePlSqlParserListener) EnterInline_constraint(ctx *Inline_constraintContext) {} + +// ExitInline_constraint is called when production inline_constraint is exited. +func (s *BasePlSqlParserListener) ExitInline_constraint(ctx *Inline_constraintContext) {} + +// EnterInline_ref_constraint is called when production inline_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterInline_ref_constraint(ctx *Inline_ref_constraintContext) {} + +// ExitInline_ref_constraint is called when production inline_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitInline_ref_constraint(ctx *Inline_ref_constraintContext) {} + +// EnterOut_of_line_ref_constraint is called when production out_of_line_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) { +} + +// ExitOut_of_line_ref_constraint is called when production out_of_line_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) { +} + +// EnterOut_of_line_constraint is called when production out_of_line_constraint is entered. +func (s *BasePlSqlParserListener) 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 *BasePlSqlParserListener) ExitOut_of_line_constraint(ctx *Out_of_line_constraintContext) {} + +// EnterConstraint_state is called when production constraint_state is entered. +func (s *BasePlSqlParserListener) EnterConstraint_state(ctx *Constraint_stateContext) {} + +// ExitConstraint_state is called when production constraint_state is exited. +func (s *BasePlSqlParserListener) ExitConstraint_state(ctx *Constraint_stateContext) {} + +// EnterXmltype_view_clause is called when production xmltype_view_clause is entered. +func (s *BasePlSqlParserListener) EnterXmltype_view_clause(ctx *Xmltype_view_clauseContext) {} + +// ExitXmltype_view_clause is called when production xmltype_view_clause is exited. +func (s *BasePlSqlParserListener) ExitXmltype_view_clause(ctx *Xmltype_view_clauseContext) {} + +// EnterXml_schema_spec is called when production xml_schema_spec is entered. +func (s *BasePlSqlParserListener) EnterXml_schema_spec(ctx *Xml_schema_specContext) {} + +// ExitXml_schema_spec is called when production xml_schema_spec is exited. +func (s *BasePlSqlParserListener) ExitXml_schema_spec(ctx *Xml_schema_specContext) {} + +// EnterXml_schema_url is called when production xml_schema_url is entered. +func (s *BasePlSqlParserListener) EnterXml_schema_url(ctx *Xml_schema_urlContext) {} + +// ExitXml_schema_url is called when production xml_schema_url is exited. +func (s *BasePlSqlParserListener) ExitXml_schema_url(ctx *Xml_schema_urlContext) {} + +// EnterElement is called when production element is entered. +func (s *BasePlSqlParserListener) EnterElement(ctx *ElementContext) {} + +// ExitElement is called when production element is exited. +func (s *BasePlSqlParserListener) ExitElement(ctx *ElementContext) {} + +// EnterAlter_tablespace is called when production alter_tablespace is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace(ctx *Alter_tablespaceContext) {} + +// ExitAlter_tablespace is called when production alter_tablespace is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace(ctx *Alter_tablespaceContext) {} + +// EnterDatafile_tempfile_clauses is called when production datafile_tempfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) { +} + +// ExitDatafile_tempfile_clauses is called when production datafile_tempfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) { +} + +// EnterTablespace_logging_clauses is called when production tablespace_logging_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) { +} + +// ExitTablespace_logging_clauses is called when production tablespace_logging_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) { +} + +// EnterTablespace_group_clause is called when production tablespace_group_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_group_clause(ctx *Tablespace_group_clauseContext) {} + +// ExitTablespace_group_clause is called when production tablespace_group_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_group_clause(ctx *Tablespace_group_clauseContext) {} + +// EnterTablespace_group_name is called when production tablespace_group_name is entered. +func (s *BasePlSqlParserListener) EnterTablespace_group_name(ctx *Tablespace_group_nameContext) {} + +// ExitTablespace_group_name is called when production tablespace_group_name is exited. +func (s *BasePlSqlParserListener) ExitTablespace_group_name(ctx *Tablespace_group_nameContext) {} + +// EnterTablespace_state_clauses is called when production tablespace_state_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_state_clauses(ctx *Tablespace_state_clausesContext) { +} + +// ExitTablespace_state_clauses is called when production tablespace_state_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_state_clauses(ctx *Tablespace_state_clausesContext) { +} + +// EnterFlashback_mode_clause is called when production flashback_mode_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_mode_clause(ctx *Flashback_mode_clauseContext) {} + +// ExitFlashback_mode_clause is called when production flashback_mode_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_mode_clause(ctx *Flashback_mode_clauseContext) {} + +// EnterNew_tablespace_name is called when production new_tablespace_name is entered. +func (s *BasePlSqlParserListener) EnterNew_tablespace_name(ctx *New_tablespace_nameContext) {} + +// ExitNew_tablespace_name is called when production new_tablespace_name is exited. +func (s *BasePlSqlParserListener) ExitNew_tablespace_name(ctx *New_tablespace_nameContext) {} + +// EnterCreate_tablespace is called when production create_tablespace is entered. +func (s *BasePlSqlParserListener) EnterCreate_tablespace(ctx *Create_tablespaceContext) {} + +// ExitCreate_tablespace is called when production create_tablespace is exited. +func (s *BasePlSqlParserListener) ExitCreate_tablespace(ctx *Create_tablespaceContext) {} + +// EnterPermanent_tablespace_clause is called when production permanent_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) { +} + +// ExitPermanent_tablespace_clause is called when production permanent_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) { +} + +// EnterTablespace_encryption_spec is called when production tablespace_encryption_spec is entered. +func (s *BasePlSqlParserListener) EnterTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) { +} + +// ExitTablespace_encryption_spec is called when production tablespace_encryption_spec is exited. +func (s *BasePlSqlParserListener) ExitTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) { +} + +// EnterLogging_clause is called when production logging_clause is entered. +func (s *BasePlSqlParserListener) EnterLogging_clause(ctx *Logging_clauseContext) {} + +// ExitLogging_clause is called when production logging_clause is exited. +func (s *BasePlSqlParserListener) ExitLogging_clause(ctx *Logging_clauseContext) {} + +// EnterExtent_management_clause is called when production extent_management_clause is entered. +func (s *BasePlSqlParserListener) EnterExtent_management_clause(ctx *Extent_management_clauseContext) { +} + +// ExitExtent_management_clause is called when production extent_management_clause is exited. +func (s *BasePlSqlParserListener) ExitExtent_management_clause(ctx *Extent_management_clauseContext) { +} + +// EnterSegment_management_clause is called when production segment_management_clause is entered. +func (s *BasePlSqlParserListener) EnterSegment_management_clause(ctx *Segment_management_clauseContext) { +} + +// ExitSegment_management_clause is called when production segment_management_clause is exited. +func (s *BasePlSqlParserListener) ExitSegment_management_clause(ctx *Segment_management_clauseContext) { +} + +// EnterTemporary_tablespace_clause is called when production temporary_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) { +} + +// ExitTemporary_tablespace_clause is called when production temporary_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) { +} + +// EnterUndo_tablespace_clause is called when production undo_tablespace_clause is entered. +func (s *BasePlSqlParserListener) EnterUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) {} + +// ExitUndo_tablespace_clause is called when production undo_tablespace_clause is exited. +func (s *BasePlSqlParserListener) ExitUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) {} + +// EnterTablespace_retention_clause is called when production tablespace_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) { +} + +// ExitTablespace_retention_clause is called when production tablespace_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) { +} + +// EnterCreate_tablespace_set is called when production create_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterCreate_tablespace_set(ctx *Create_tablespace_setContext) {} + +// ExitCreate_tablespace_set is called when production create_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitCreate_tablespace_set(ctx *Create_tablespace_setContext) {} + +// EnterPermanent_tablespace_attrs is called when production permanent_tablespace_attrs is entered. +func (s *BasePlSqlParserListener) EnterPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) { +} + +// ExitPermanent_tablespace_attrs is called when production permanent_tablespace_attrs is exited. +func (s *BasePlSqlParserListener) ExitPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) { +} + +// EnterTablespace_encryption_clause is called when production tablespace_encryption_clause is entered. +func (s *BasePlSqlParserListener) EnterTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) { +} + +// ExitTablespace_encryption_clause is called when production tablespace_encryption_clause is exited. +func (s *BasePlSqlParserListener) ExitTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) { +} + +// EnterDefault_tablespace_params is called when production default_tablespace_params is entered. +func (s *BasePlSqlParserListener) EnterDefault_tablespace_params(ctx *Default_tablespace_paramsContext) { +} + +// ExitDefault_tablespace_params is called when production default_tablespace_params is exited. +func (s *BasePlSqlParserListener) ExitDefault_tablespace_params(ctx *Default_tablespace_paramsContext) { +} + +// EnterDefault_table_compression is called when production default_table_compression is entered. +func (s *BasePlSqlParserListener) EnterDefault_table_compression(ctx *Default_table_compressionContext) { +} + +// ExitDefault_table_compression is called when production default_table_compression is exited. +func (s *BasePlSqlParserListener) ExitDefault_table_compression(ctx *Default_table_compressionContext) { +} + +// EnterLow_high is called when production low_high is entered. +func (s *BasePlSqlParserListener) EnterLow_high(ctx *Low_highContext) {} + +// ExitLow_high is called when production low_high is exited. +func (s *BasePlSqlParserListener) ExitLow_high(ctx *Low_highContext) {} + +// EnterDefault_index_compression is called when production default_index_compression is entered. +func (s *BasePlSqlParserListener) EnterDefault_index_compression(ctx *Default_index_compressionContext) { +} + +// ExitDefault_index_compression is called when production default_index_compression is exited. +func (s *BasePlSqlParserListener) ExitDefault_index_compression(ctx *Default_index_compressionContext) { +} + +// EnterInmmemory_clause is called when production inmmemory_clause is entered. +func (s *BasePlSqlParserListener) EnterInmmemory_clause(ctx *Inmmemory_clauseContext) {} + +// ExitInmmemory_clause is called when production inmmemory_clause is exited. +func (s *BasePlSqlParserListener) ExitInmmemory_clause(ctx *Inmmemory_clauseContext) {} + +// EnterDatafile_specification is called when production datafile_specification is entered. +func (s *BasePlSqlParserListener) EnterDatafile_specification(ctx *Datafile_specificationContext) {} + +// ExitDatafile_specification is called when production datafile_specification is exited. +func (s *BasePlSqlParserListener) ExitDatafile_specification(ctx *Datafile_specificationContext) {} + +// EnterTempfile_specification is called when production tempfile_specification is entered. +func (s *BasePlSqlParserListener) EnterTempfile_specification(ctx *Tempfile_specificationContext) {} + +// ExitTempfile_specification is called when production tempfile_specification is exited. +func (s *BasePlSqlParserListener) ExitTempfile_specification(ctx *Tempfile_specificationContext) {} + +// EnterDatafile_tempfile_spec is called when production datafile_tempfile_spec is entered. +func (s *BasePlSqlParserListener) EnterDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) {} + +// ExitDatafile_tempfile_spec is called when production datafile_tempfile_spec is exited. +func (s *BasePlSqlParserListener) ExitDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) {} + +// EnterRedo_log_file_spec is called when production redo_log_file_spec is entered. +func (s *BasePlSqlParserListener) EnterRedo_log_file_spec(ctx *Redo_log_file_specContext) {} + +// ExitRedo_log_file_spec is called when production redo_log_file_spec is exited. +func (s *BasePlSqlParserListener) ExitRedo_log_file_spec(ctx *Redo_log_file_specContext) {} + +// EnterAutoextend_clause is called when production autoextend_clause is entered. +func (s *BasePlSqlParserListener) EnterAutoextend_clause(ctx *Autoextend_clauseContext) {} + +// ExitAutoextend_clause is called when production autoextend_clause is exited. +func (s *BasePlSqlParserListener) ExitAutoextend_clause(ctx *Autoextend_clauseContext) {} + +// EnterMaxsize_clause is called when production maxsize_clause is entered. +func (s *BasePlSqlParserListener) EnterMaxsize_clause(ctx *Maxsize_clauseContext) {} + +// ExitMaxsize_clause is called when production maxsize_clause is exited. +func (s *BasePlSqlParserListener) ExitMaxsize_clause(ctx *Maxsize_clauseContext) {} + +// EnterBuild_clause is called when production build_clause is entered. +func (s *BasePlSqlParserListener) EnterBuild_clause(ctx *Build_clauseContext) {} + +// ExitBuild_clause is called when production build_clause is exited. +func (s *BasePlSqlParserListener) ExitBuild_clause(ctx *Build_clauseContext) {} + +// EnterPartial_index_clause is called when production partial_index_clause is entered. +func (s *BasePlSqlParserListener) EnterPartial_index_clause(ctx *Partial_index_clauseContext) {} + +// ExitPartial_index_clause is called when production partial_index_clause is exited. +func (s *BasePlSqlParserListener) ExitPartial_index_clause(ctx *Partial_index_clauseContext) {} + +// EnterParallel_clause is called when production parallel_clause is entered. +func (s *BasePlSqlParserListener) EnterParallel_clause(ctx *Parallel_clauseContext) {} + +// ExitParallel_clause is called when production parallel_clause is exited. +func (s *BasePlSqlParserListener) ExitParallel_clause(ctx *Parallel_clauseContext) {} + +// EnterAlter_materialized_view is called when production alter_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_view(ctx *Alter_materialized_viewContext) {} + +// ExitAlter_materialized_view is called when production alter_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_view(ctx *Alter_materialized_viewContext) {} + +// EnterAlter_mv_option1 is called when production alter_mv_option1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_mv_option1(ctx *Alter_mv_option1Context) {} + +// ExitAlter_mv_option1 is called when production alter_mv_option1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_mv_option1(ctx *Alter_mv_option1Context) {} + +// EnterAlter_mv_refresh is called when production alter_mv_refresh is entered. +func (s *BasePlSqlParserListener) EnterAlter_mv_refresh(ctx *Alter_mv_refreshContext) {} + +// ExitAlter_mv_refresh is called when production alter_mv_refresh is exited. +func (s *BasePlSqlParserListener) ExitAlter_mv_refresh(ctx *Alter_mv_refreshContext) {} + +// EnterRollback_segment is called when production rollback_segment is entered. +func (s *BasePlSqlParserListener) EnterRollback_segment(ctx *Rollback_segmentContext) {} + +// ExitRollback_segment is called when production rollback_segment is exited. +func (s *BasePlSqlParserListener) ExitRollback_segment(ctx *Rollback_segmentContext) {} + +// EnterModify_mv_column_clause is called when production modify_mv_column_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) {} + +// ExitModify_mv_column_clause is called when production modify_mv_column_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) {} + +// EnterAlter_materialized_view_log is called when production alter_materialized_view_log is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) { +} + +// ExitAlter_materialized_view_log is called when production alter_materialized_view_log is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) { +} + +// EnterAdd_mv_log_column_clause is called when production add_mv_log_column_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) { +} + +// ExitAdd_mv_log_column_clause is called when production add_mv_log_column_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) { +} + +// EnterMove_mv_log_clause is called when production move_mv_log_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_mv_log_clause(ctx *Move_mv_log_clauseContext) {} + +// ExitMove_mv_log_clause is called when production move_mv_log_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_mv_log_clause(ctx *Move_mv_log_clauseContext) {} + +// EnterMv_log_augmentation is called when production mv_log_augmentation is entered. +func (s *BasePlSqlParserListener) EnterMv_log_augmentation(ctx *Mv_log_augmentationContext) {} + +// ExitMv_log_augmentation is called when production mv_log_augmentation is exited. +func (s *BasePlSqlParserListener) ExitMv_log_augmentation(ctx *Mv_log_augmentationContext) {} + +// EnterDatetime_expr is called when production datetime_expr is entered. +func (s *BasePlSqlParserListener) EnterDatetime_expr(ctx *Datetime_exprContext) {} + +// ExitDatetime_expr is called when production datetime_expr is exited. +func (s *BasePlSqlParserListener) ExitDatetime_expr(ctx *Datetime_exprContext) {} + +// EnterInterval_expr is called when production interval_expr is entered. +func (s *BasePlSqlParserListener) EnterInterval_expr(ctx *Interval_exprContext) {} + +// ExitInterval_expr is called when production interval_expr is exited. +func (s *BasePlSqlParserListener) ExitInterval_expr(ctx *Interval_exprContext) {} + +// EnterSynchronous_or_asynchronous is called when production synchronous_or_asynchronous is entered. +func (s *BasePlSqlParserListener) EnterSynchronous_or_asynchronous(ctx *Synchronous_or_asynchronousContext) { +} + +// ExitSynchronous_or_asynchronous is called when production synchronous_or_asynchronous is exited. +func (s *BasePlSqlParserListener) ExitSynchronous_or_asynchronous(ctx *Synchronous_or_asynchronousContext) { +} + +// EnterIncluding_or_excluding is called when production including_or_excluding is entered. +func (s *BasePlSqlParserListener) EnterIncluding_or_excluding(ctx *Including_or_excludingContext) {} + +// ExitIncluding_or_excluding is called when production including_or_excluding is exited. +func (s *BasePlSqlParserListener) ExitIncluding_or_excluding(ctx *Including_or_excludingContext) {} + +// EnterCreate_materialized_view_log is called when production create_materialized_view_log is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_view_log(ctx *Create_materialized_view_logContext) { +} + +// ExitCreate_materialized_view_log is called when production create_materialized_view_log is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_view_log(ctx *Create_materialized_view_logContext) { +} + +// EnterNew_values_clause is called when production new_values_clause is entered. +func (s *BasePlSqlParserListener) EnterNew_values_clause(ctx *New_values_clauseContext) {} + +// ExitNew_values_clause is called when production new_values_clause is exited. +func (s *BasePlSqlParserListener) ExitNew_values_clause(ctx *New_values_clauseContext) {} + +// EnterMv_log_purge_clause is called when production mv_log_purge_clause is entered. +func (s *BasePlSqlParserListener) EnterMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) {} + +// ExitMv_log_purge_clause is called when production mv_log_purge_clause is exited. +func (s *BasePlSqlParserListener) ExitMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) {} + +// EnterCreate_materialized_zonemap is called when production create_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) { +} + +// ExitCreate_materialized_zonemap is called when production create_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) { +} + +// EnterAlter_materialized_zonemap is called when production alter_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) { +} + +// ExitAlter_materialized_zonemap is called when production alter_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) { +} + +// EnterDrop_materialized_zonemap is called when production drop_materialized_zonemap is entered. +func (s *BasePlSqlParserListener) EnterDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) { +} + +// ExitDrop_materialized_zonemap is called when production drop_materialized_zonemap is exited. +func (s *BasePlSqlParserListener) ExitDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) { +} + +// EnterZonemap_refresh_clause is called when production zonemap_refresh_clause is entered. +func (s *BasePlSqlParserListener) EnterZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) {} + +// ExitZonemap_refresh_clause is called when production zonemap_refresh_clause is exited. +func (s *BasePlSqlParserListener) ExitZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) {} + +// EnterZonemap_attributes is called when production zonemap_attributes is entered. +func (s *BasePlSqlParserListener) EnterZonemap_attributes(ctx *Zonemap_attributesContext) {} + +// ExitZonemap_attributes is called when production zonemap_attributes is exited. +func (s *BasePlSqlParserListener) ExitZonemap_attributes(ctx *Zonemap_attributesContext) {} + +// EnterZonemap_name is called when production zonemap_name is entered. +func (s *BasePlSqlParserListener) EnterZonemap_name(ctx *Zonemap_nameContext) {} + +// ExitZonemap_name is called when production zonemap_name is exited. +func (s *BasePlSqlParserListener) ExitZonemap_name(ctx *Zonemap_nameContext) {} + +// EnterOperator_name is called when production operator_name is entered. +func (s *BasePlSqlParserListener) EnterOperator_name(ctx *Operator_nameContext) {} + +// ExitOperator_name is called when production operator_name is exited. +func (s *BasePlSqlParserListener) ExitOperator_name(ctx *Operator_nameContext) {} + +// EnterOperator_function_name is called when production operator_function_name is entered. +func (s *BasePlSqlParserListener) EnterOperator_function_name(ctx *Operator_function_nameContext) {} + +// ExitOperator_function_name is called when production operator_function_name is exited. +func (s *BasePlSqlParserListener) ExitOperator_function_name(ctx *Operator_function_nameContext) {} + +// EnterCreate_zonemap_on_table is called when production create_zonemap_on_table is entered. +func (s *BasePlSqlParserListener) EnterCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) {} + +// ExitCreate_zonemap_on_table is called when production create_zonemap_on_table is exited. +func (s *BasePlSqlParserListener) ExitCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) {} + +// EnterCreate_zonemap_as_subquery is called when production create_zonemap_as_subquery is entered. +func (s *BasePlSqlParserListener) EnterCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) { +} + +// ExitCreate_zonemap_as_subquery is called when production create_zonemap_as_subquery is exited. +func (s *BasePlSqlParserListener) ExitCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) { +} + +// EnterAlter_operator is called when production alter_operator is entered. +func (s *BasePlSqlParserListener) EnterAlter_operator(ctx *Alter_operatorContext) {} + +// ExitAlter_operator is called when production alter_operator is exited. +func (s *BasePlSqlParserListener) ExitAlter_operator(ctx *Alter_operatorContext) {} + +// EnterDrop_operator is called when production drop_operator is entered. +func (s *BasePlSqlParserListener) EnterDrop_operator(ctx *Drop_operatorContext) {} + +// ExitDrop_operator is called when production drop_operator is exited. +func (s *BasePlSqlParserListener) ExitDrop_operator(ctx *Drop_operatorContext) {} + +// EnterCreate_operator is called when production create_operator is entered. +func (s *BasePlSqlParserListener) EnterCreate_operator(ctx *Create_operatorContext) {} + +// ExitCreate_operator is called when production create_operator is exited. +func (s *BasePlSqlParserListener) ExitCreate_operator(ctx *Create_operatorContext) {} + +// EnterBinding_clause is called when production binding_clause is entered. +func (s *BasePlSqlParserListener) EnterBinding_clause(ctx *Binding_clauseContext) {} + +// ExitBinding_clause is called when production binding_clause is exited. +func (s *BasePlSqlParserListener) ExitBinding_clause(ctx *Binding_clauseContext) {} + +// EnterAdd_binding_clause is called when production add_binding_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_binding_clause(ctx *Add_binding_clauseContext) {} + +// ExitAdd_binding_clause is called when production add_binding_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_binding_clause(ctx *Add_binding_clauseContext) {} + +// EnterImplementation_clause is called when production implementation_clause is entered. +func (s *BasePlSqlParserListener) EnterImplementation_clause(ctx *Implementation_clauseContext) {} + +// ExitImplementation_clause is called when production implementation_clause is exited. +func (s *BasePlSqlParserListener) ExitImplementation_clause(ctx *Implementation_clauseContext) {} + +// EnterPrimary_operator_list is called when production primary_operator_list is entered. +func (s *BasePlSqlParserListener) EnterPrimary_operator_list(ctx *Primary_operator_listContext) {} + +// ExitPrimary_operator_list is called when production primary_operator_list is exited. +func (s *BasePlSqlParserListener) ExitPrimary_operator_list(ctx *Primary_operator_listContext) {} + +// EnterPrimary_operator_item is called when production primary_operator_item is entered. +func (s *BasePlSqlParserListener) EnterPrimary_operator_item(ctx *Primary_operator_itemContext) {} + +// ExitPrimary_operator_item is called when production primary_operator_item is exited. +func (s *BasePlSqlParserListener) ExitPrimary_operator_item(ctx *Primary_operator_itemContext) {} + +// EnterOperator_context_clause is called when production operator_context_clause is entered. +func (s *BasePlSqlParserListener) EnterOperator_context_clause(ctx *Operator_context_clauseContext) {} + +// ExitOperator_context_clause is called when production operator_context_clause is exited. +func (s *BasePlSqlParserListener) ExitOperator_context_clause(ctx *Operator_context_clauseContext) {} + +// EnterUsing_function_clause is called when production using_function_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_function_clause(ctx *Using_function_clauseContext) {} + +// ExitUsing_function_clause is called when production using_function_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_function_clause(ctx *Using_function_clauseContext) {} + +// EnterDrop_binding_clause is called when production drop_binding_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_binding_clause(ctx *Drop_binding_clauseContext) {} + +// ExitDrop_binding_clause is called when production drop_binding_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_binding_clause(ctx *Drop_binding_clauseContext) {} + +// EnterCreate_materialized_view is called when production create_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// ExitCreate_materialized_view is called when production create_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitCreate_materialized_view(ctx *Create_materialized_viewContext) { +} + +// EnterScoped_table_ref_constraint is called when production scoped_table_ref_constraint is entered. +func (s *BasePlSqlParserListener) EnterScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) { +} + +// ExitScoped_table_ref_constraint is called when production scoped_table_ref_constraint is exited. +func (s *BasePlSqlParserListener) ExitScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) { +} + +// EnterMv_column_alias is called when production mv_column_alias is entered. +func (s *BasePlSqlParserListener) EnterMv_column_alias(ctx *Mv_column_aliasContext) {} + +// ExitMv_column_alias is called when production mv_column_alias is exited. +func (s *BasePlSqlParserListener) ExitMv_column_alias(ctx *Mv_column_aliasContext) {} + +// EnterCreate_mv_refresh is called when production create_mv_refresh is entered. +func (s *BasePlSqlParserListener) EnterCreate_mv_refresh(ctx *Create_mv_refreshContext) {} + +// ExitCreate_mv_refresh is called when production create_mv_refresh is exited. +func (s *BasePlSqlParserListener) ExitCreate_mv_refresh(ctx *Create_mv_refreshContext) {} + +// EnterDrop_materialized_view is called when production drop_materialized_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_materialized_view(ctx *Drop_materialized_viewContext) {} + +// ExitDrop_materialized_view is called when production drop_materialized_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_materialized_view(ctx *Drop_materialized_viewContext) {} + +// EnterCreate_context is called when production create_context is entered. +func (s *BasePlSqlParserListener) EnterCreate_context(ctx *Create_contextContext) {} + +// ExitCreate_context is called when production create_context is exited. +func (s *BasePlSqlParserListener) ExitCreate_context(ctx *Create_contextContext) {} + +// EnterOracle_namespace is called when production oracle_namespace is entered. +func (s *BasePlSqlParserListener) EnterOracle_namespace(ctx *Oracle_namespaceContext) {} + +// ExitOracle_namespace is called when production oracle_namespace is exited. +func (s *BasePlSqlParserListener) ExitOracle_namespace(ctx *Oracle_namespaceContext) {} + +// EnterCreate_cluster is called when production create_cluster is entered. +func (s *BasePlSqlParserListener) EnterCreate_cluster(ctx *Create_clusterContext) {} + +// ExitCreate_cluster is called when production create_cluster is exited. +func (s *BasePlSqlParserListener) ExitCreate_cluster(ctx *Create_clusterContext) {} + +// EnterCreate_profile is called when production create_profile is entered. +func (s *BasePlSqlParserListener) EnterCreate_profile(ctx *Create_profileContext) {} + +// ExitCreate_profile is called when production create_profile is exited. +func (s *BasePlSqlParserListener) ExitCreate_profile(ctx *Create_profileContext) {} + +// EnterResource_parameters is called when production resource_parameters is entered. +func (s *BasePlSqlParserListener) EnterResource_parameters(ctx *Resource_parametersContext) {} + +// ExitResource_parameters is called when production resource_parameters is exited. +func (s *BasePlSqlParserListener) ExitResource_parameters(ctx *Resource_parametersContext) {} + +// EnterPassword_parameters is called when production password_parameters is entered. +func (s *BasePlSqlParserListener) EnterPassword_parameters(ctx *Password_parametersContext) {} + +// ExitPassword_parameters is called when production password_parameters is exited. +func (s *BasePlSqlParserListener) ExitPassword_parameters(ctx *Password_parametersContext) {} + +// EnterCreate_lockdown_profile is called when production create_lockdown_profile is entered. +func (s *BasePlSqlParserListener) EnterCreate_lockdown_profile(ctx *Create_lockdown_profileContext) {} + +// ExitCreate_lockdown_profile is called when production create_lockdown_profile is exited. +func (s *BasePlSqlParserListener) ExitCreate_lockdown_profile(ctx *Create_lockdown_profileContext) {} + +// EnterStatic_base_profile is called when production static_base_profile is entered. +func (s *BasePlSqlParserListener) EnterStatic_base_profile(ctx *Static_base_profileContext) {} + +// ExitStatic_base_profile is called when production static_base_profile is exited. +func (s *BasePlSqlParserListener) ExitStatic_base_profile(ctx *Static_base_profileContext) {} + +// EnterDynamic_base_profile is called when production dynamic_base_profile is entered. +func (s *BasePlSqlParserListener) EnterDynamic_base_profile(ctx *Dynamic_base_profileContext) {} + +// ExitDynamic_base_profile is called when production dynamic_base_profile is exited. +func (s *BasePlSqlParserListener) ExitDynamic_base_profile(ctx *Dynamic_base_profileContext) {} + +// EnterCreate_outline is called when production create_outline is entered. +func (s *BasePlSqlParserListener) EnterCreate_outline(ctx *Create_outlineContext) {} + +// ExitCreate_outline is called when production create_outline is exited. +func (s *BasePlSqlParserListener) ExitCreate_outline(ctx *Create_outlineContext) {} + +// EnterCreate_restore_point is called when production create_restore_point is entered. +func (s *BasePlSqlParserListener) EnterCreate_restore_point(ctx *Create_restore_pointContext) {} + +// ExitCreate_restore_point is called when production create_restore_point is exited. +func (s *BasePlSqlParserListener) ExitCreate_restore_point(ctx *Create_restore_pointContext) {} + +// EnterCreate_role is called when production create_role is entered. +func (s *BasePlSqlParserListener) EnterCreate_role(ctx *Create_roleContext) {} + +// ExitCreate_role is called when production create_role is exited. +func (s *BasePlSqlParserListener) ExitCreate_role(ctx *Create_roleContext) {} + +// EnterCreate_table is called when production create_table is entered. +func (s *BasePlSqlParserListener) EnterCreate_table(ctx *Create_tableContext) {} + +// ExitCreate_table is called when production create_table is exited. +func (s *BasePlSqlParserListener) ExitCreate_table(ctx *Create_tableContext) {} + +// EnterXmltype_table is called when production xmltype_table is entered. +func (s *BasePlSqlParserListener) EnterXmltype_table(ctx *Xmltype_tableContext) {} + +// ExitXmltype_table is called when production xmltype_table is exited. +func (s *BasePlSqlParserListener) ExitXmltype_table(ctx *Xmltype_tableContext) {} + +// EnterXmltype_virtual_columns is called when production xmltype_virtual_columns is entered. +func (s *BasePlSqlParserListener) EnterXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) {} + +// ExitXmltype_virtual_columns is called when production xmltype_virtual_columns is exited. +func (s *BasePlSqlParserListener) ExitXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) {} + +// EnterXmltype_column_properties is called when production xmltype_column_properties is entered. +func (s *BasePlSqlParserListener) EnterXmltype_column_properties(ctx *Xmltype_column_propertiesContext) { +} + +// ExitXmltype_column_properties is called when production xmltype_column_properties is exited. +func (s *BasePlSqlParserListener) ExitXmltype_column_properties(ctx *Xmltype_column_propertiesContext) { +} + +// EnterXmltype_storage is called when production xmltype_storage is entered. +func (s *BasePlSqlParserListener) EnterXmltype_storage(ctx *Xmltype_storageContext) {} + +// ExitXmltype_storage is called when production xmltype_storage is exited. +func (s *BasePlSqlParserListener) ExitXmltype_storage(ctx *Xmltype_storageContext) {} + +// EnterXmlschema_spec is called when production xmlschema_spec is entered. +func (s *BasePlSqlParserListener) EnterXmlschema_spec(ctx *Xmlschema_specContext) {} + +// ExitXmlschema_spec is called when production xmlschema_spec is exited. +func (s *BasePlSqlParserListener) ExitXmlschema_spec(ctx *Xmlschema_specContext) {} + +// EnterObject_table is called when production object_table is entered. +func (s *BasePlSqlParserListener) EnterObject_table(ctx *Object_tableContext) {} + +// ExitObject_table is called when production object_table is exited. +func (s *BasePlSqlParserListener) ExitObject_table(ctx *Object_tableContext) {} + +// EnterObject_type is called when production object_type is entered. +func (s *BasePlSqlParserListener) EnterObject_type(ctx *Object_typeContext) {} + +// ExitObject_type is called when production object_type is exited. +func (s *BasePlSqlParserListener) ExitObject_type(ctx *Object_typeContext) {} + +// EnterOid_index_clause is called when production oid_index_clause is entered. +func (s *BasePlSqlParserListener) EnterOid_index_clause(ctx *Oid_index_clauseContext) {} + +// ExitOid_index_clause is called when production oid_index_clause is exited. +func (s *BasePlSqlParserListener) ExitOid_index_clause(ctx *Oid_index_clauseContext) {} + +// EnterOid_clause is called when production oid_clause is entered. +func (s *BasePlSqlParserListener) EnterOid_clause(ctx *Oid_clauseContext) {} + +// ExitOid_clause is called when production oid_clause is exited. +func (s *BasePlSqlParserListener) ExitOid_clause(ctx *Oid_clauseContext) {} + +// EnterObject_properties is called when production object_properties is entered. +func (s *BasePlSqlParserListener) EnterObject_properties(ctx *Object_propertiesContext) {} + +// ExitObject_properties is called when production object_properties is exited. +func (s *BasePlSqlParserListener) ExitObject_properties(ctx *Object_propertiesContext) {} + +// EnterObject_table_substitution is called when production object_table_substitution is entered. +func (s *BasePlSqlParserListener) EnterObject_table_substitution(ctx *Object_table_substitutionContext) { +} + +// ExitObject_table_substitution is called when production object_table_substitution is exited. +func (s *BasePlSqlParserListener) ExitObject_table_substitution(ctx *Object_table_substitutionContext) { +} + +// EnterRelational_table is called when production relational_table is entered. +func (s *BasePlSqlParserListener) EnterRelational_table(ctx *Relational_tableContext) {} + +// ExitRelational_table is called when production relational_table is exited. +func (s *BasePlSqlParserListener) ExitRelational_table(ctx *Relational_tableContext) {} + +// EnterImmutable_table_clauses is called when production immutable_table_clauses is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_clauses(ctx *Immutable_table_clausesContext) {} + +// ExitImmutable_table_clauses is called when production immutable_table_clauses is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_clauses(ctx *Immutable_table_clausesContext) {} + +// EnterImmutable_table_no_drop_clause is called when production immutable_table_no_drop_clause is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) { +} + +// ExitImmutable_table_no_drop_clause is called when production immutable_table_no_drop_clause is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) { +} + +// EnterImmutable_table_no_delete_clause is called when production immutable_table_no_delete_clause is entered. +func (s *BasePlSqlParserListener) EnterImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) { +} + +// ExitImmutable_table_no_delete_clause is called when production immutable_table_no_delete_clause is exited. +func (s *BasePlSqlParserListener) ExitImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) { +} + +// EnterBlockchain_table_clauses is called when production blockchain_table_clauses is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) { +} + +// ExitBlockchain_table_clauses is called when production blockchain_table_clauses is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) { +} + +// EnterBlockchain_drop_table_clause is called when production blockchain_drop_table_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) { +} + +// ExitBlockchain_drop_table_clause is called when production blockchain_drop_table_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) { +} + +// EnterBlockchain_row_retention_clause is called when production blockchain_row_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) { +} + +// ExitBlockchain_row_retention_clause is called when production blockchain_row_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) { +} + +// EnterBlockchain_hash_and_data_format_clause is called when production blockchain_hash_and_data_format_clause is entered. +func (s *BasePlSqlParserListener) EnterBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) { +} + +// ExitBlockchain_hash_and_data_format_clause is called when production blockchain_hash_and_data_format_clause is exited. +func (s *BasePlSqlParserListener) ExitBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) { +} + +// EnterCollation_name is called when production collation_name is entered. +func (s *BasePlSqlParserListener) EnterCollation_name(ctx *Collation_nameContext) {} + +// ExitCollation_name is called when production collation_name is exited. +func (s *BasePlSqlParserListener) ExitCollation_name(ctx *Collation_nameContext) {} + +// EnterTable_properties is called when production table_properties is entered. +func (s *BasePlSqlParserListener) EnterTable_properties(ctx *Table_propertiesContext) {} + +// ExitTable_properties is called when production table_properties is exited. +func (s *BasePlSqlParserListener) ExitTable_properties(ctx *Table_propertiesContext) {} + +// EnterRead_only_clause is called when production read_only_clause is entered. +func (s *BasePlSqlParserListener) EnterRead_only_clause(ctx *Read_only_clauseContext) {} + +// ExitRead_only_clause is called when production read_only_clause is exited. +func (s *BasePlSqlParserListener) ExitRead_only_clause(ctx *Read_only_clauseContext) {} + +// EnterIndexing_clause is called when production indexing_clause is entered. +func (s *BasePlSqlParserListener) EnterIndexing_clause(ctx *Indexing_clauseContext) {} + +// ExitIndexing_clause is called when production indexing_clause is exited. +func (s *BasePlSqlParserListener) ExitIndexing_clause(ctx *Indexing_clauseContext) {} + +// EnterAttribute_clustering_clause is called when production attribute_clustering_clause is entered. +func (s *BasePlSqlParserListener) EnterAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) { +} + +// ExitAttribute_clustering_clause is called when production attribute_clustering_clause is exited. +func (s *BasePlSqlParserListener) ExitAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) { +} + +// EnterClustering_join is called when production clustering_join is entered. +func (s *BasePlSqlParserListener) EnterClustering_join(ctx *Clustering_joinContext) {} + +// ExitClustering_join is called when production clustering_join is exited. +func (s *BasePlSqlParserListener) ExitClustering_join(ctx *Clustering_joinContext) {} + +// EnterClustering_join_item is called when production clustering_join_item is entered. +func (s *BasePlSqlParserListener) EnterClustering_join_item(ctx *Clustering_join_itemContext) {} + +// ExitClustering_join_item is called when production clustering_join_item is exited. +func (s *BasePlSqlParserListener) ExitClustering_join_item(ctx *Clustering_join_itemContext) {} + +// EnterEquijoin_condition is called when production equijoin_condition is entered. +func (s *BasePlSqlParserListener) EnterEquijoin_condition(ctx *Equijoin_conditionContext) {} + +// ExitEquijoin_condition is called when production equijoin_condition is exited. +func (s *BasePlSqlParserListener) ExitEquijoin_condition(ctx *Equijoin_conditionContext) {} + +// EnterCluster_clause is called when production cluster_clause is entered. +func (s *BasePlSqlParserListener) EnterCluster_clause(ctx *Cluster_clauseContext) {} + +// ExitCluster_clause is called when production cluster_clause is exited. +func (s *BasePlSqlParserListener) ExitCluster_clause(ctx *Cluster_clauseContext) {} + +// EnterClustering_columns is called when production clustering_columns is entered. +func (s *BasePlSqlParserListener) EnterClustering_columns(ctx *Clustering_columnsContext) {} + +// ExitClustering_columns is called when production clustering_columns is exited. +func (s *BasePlSqlParserListener) ExitClustering_columns(ctx *Clustering_columnsContext) {} + +// EnterClustering_column_group is called when production clustering_column_group is entered. +func (s *BasePlSqlParserListener) EnterClustering_column_group(ctx *Clustering_column_groupContext) {} + +// ExitClustering_column_group is called when production clustering_column_group is exited. +func (s *BasePlSqlParserListener) ExitClustering_column_group(ctx *Clustering_column_groupContext) {} + +// EnterYes_no is called when production yes_no is entered. +func (s *BasePlSqlParserListener) EnterYes_no(ctx *Yes_noContext) {} + +// ExitYes_no is called when production yes_no is exited. +func (s *BasePlSqlParserListener) ExitYes_no(ctx *Yes_noContext) {} + +// EnterZonemap_clause is called when production zonemap_clause is entered. +func (s *BasePlSqlParserListener) EnterZonemap_clause(ctx *Zonemap_clauseContext) {} + +// ExitZonemap_clause is called when production zonemap_clause is exited. +func (s *BasePlSqlParserListener) ExitZonemap_clause(ctx *Zonemap_clauseContext) {} + +// EnterLogical_replication_clause is called when production logical_replication_clause is entered. +func (s *BasePlSqlParserListener) EnterLogical_replication_clause(ctx *Logical_replication_clauseContext) { +} + +// ExitLogical_replication_clause is called when production logical_replication_clause is exited. +func (s *BasePlSqlParserListener) ExitLogical_replication_clause(ctx *Logical_replication_clauseContext) { +} + +// EnterTable_name is called when production table_name is entered. +func (s *BasePlSqlParserListener) EnterTable_name(ctx *Table_nameContext) {} + +// ExitTable_name is called when production table_name is exited. +func (s *BasePlSqlParserListener) ExitTable_name(ctx *Table_nameContext) {} + +// EnterRelational_property is called when production relational_property is entered. +func (s *BasePlSqlParserListener) EnterRelational_property(ctx *Relational_propertyContext) {} + +// ExitRelational_property is called when production relational_property is exited. +func (s *BasePlSqlParserListener) ExitRelational_property(ctx *Relational_propertyContext) {} + +// EnterTable_partitioning_clauses is called when production table_partitioning_clauses is entered. +func (s *BasePlSqlParserListener) EnterTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) { +} + +// ExitTable_partitioning_clauses is called when production table_partitioning_clauses is exited. +func (s *BasePlSqlParserListener) ExitTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) { +} + +// EnterRange_partitions is called when production range_partitions is entered. +func (s *BasePlSqlParserListener) EnterRange_partitions(ctx *Range_partitionsContext) {} + +// ExitRange_partitions is called when production range_partitions is exited. +func (s *BasePlSqlParserListener) ExitRange_partitions(ctx *Range_partitionsContext) {} + +// EnterList_partitions is called when production list_partitions is entered. +func (s *BasePlSqlParserListener) EnterList_partitions(ctx *List_partitionsContext) {} + +// ExitList_partitions is called when production list_partitions is exited. +func (s *BasePlSqlParserListener) ExitList_partitions(ctx *List_partitionsContext) {} + +// EnterHash_partitions is called when production hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterHash_partitions(ctx *Hash_partitionsContext) {} + +// ExitHash_partitions is called when production hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitHash_partitions(ctx *Hash_partitionsContext) {} + +// EnterIndividual_hash_partitions is called when production individual_hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) { +} + +// ExitIndividual_hash_partitions is called when production individual_hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) { +} + +// EnterHash_partitions_by_quantity is called when production hash_partitions_by_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) { +} + +// ExitHash_partitions_by_quantity is called when production hash_partitions_by_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) { +} + +// EnterHash_partition_quantity is called when production hash_partition_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_partition_quantity(ctx *Hash_partition_quantityContext) {} + +// ExitHash_partition_quantity is called when production hash_partition_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_partition_quantity(ctx *Hash_partition_quantityContext) {} + +// EnterComposite_range_partitions is called when production composite_range_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_range_partitions(ctx *Composite_range_partitionsContext) { +} + +// ExitComposite_range_partitions is called when production composite_range_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_range_partitions(ctx *Composite_range_partitionsContext) { +} + +// EnterComposite_list_partitions is called when production composite_list_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_list_partitions(ctx *Composite_list_partitionsContext) { +} + +// ExitComposite_list_partitions is called when production composite_list_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_list_partitions(ctx *Composite_list_partitionsContext) { +} + +// EnterComposite_hash_partitions is called when production composite_hash_partitions is entered. +func (s *BasePlSqlParserListener) EnterComposite_hash_partitions(ctx *Composite_hash_partitionsContext) { +} + +// ExitComposite_hash_partitions is called when production composite_hash_partitions is exited. +func (s *BasePlSqlParserListener) ExitComposite_hash_partitions(ctx *Composite_hash_partitionsContext) { +} + +// EnterReference_partitioning is called when production reference_partitioning is entered. +func (s *BasePlSqlParserListener) EnterReference_partitioning(ctx *Reference_partitioningContext) {} + +// ExitReference_partitioning is called when production reference_partitioning is exited. +func (s *BasePlSqlParserListener) ExitReference_partitioning(ctx *Reference_partitioningContext) {} + +// EnterReference_partition_desc is called when production reference_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterReference_partition_desc(ctx *Reference_partition_descContext) { +} + +// ExitReference_partition_desc is called when production reference_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitReference_partition_desc(ctx *Reference_partition_descContext) { +} + +// EnterSystem_partitioning is called when production system_partitioning is entered. +func (s *BasePlSqlParserListener) EnterSystem_partitioning(ctx *System_partitioningContext) {} + +// ExitSystem_partitioning is called when production system_partitioning is exited. +func (s *BasePlSqlParserListener) ExitSystem_partitioning(ctx *System_partitioningContext) {} + +// EnterRange_partition_desc is called when production range_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterRange_partition_desc(ctx *Range_partition_descContext) {} + +// ExitRange_partition_desc is called when production range_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitRange_partition_desc(ctx *Range_partition_descContext) {} + +// EnterList_partition_desc is called when production list_partition_desc is entered. +func (s *BasePlSqlParserListener) EnterList_partition_desc(ctx *List_partition_descContext) {} + +// ExitList_partition_desc is called when production list_partition_desc is exited. +func (s *BasePlSqlParserListener) ExitList_partition_desc(ctx *List_partition_descContext) {} + +// EnterSubpartition_template is called when production subpartition_template is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_template(ctx *Subpartition_templateContext) {} + +// ExitSubpartition_template is called when production subpartition_template is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_template(ctx *Subpartition_templateContext) {} + +// EnterHash_subpartition_quantity is called when production hash_subpartition_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) { +} + +// ExitHash_subpartition_quantity is called when production hash_subpartition_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) { +} + +// EnterSubpartition_by_range is called when production subpartition_by_range is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_range(ctx *Subpartition_by_rangeContext) {} + +// ExitSubpartition_by_range is called when production subpartition_by_range is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_range(ctx *Subpartition_by_rangeContext) {} + +// EnterSubpartition_by_list is called when production subpartition_by_list is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_list(ctx *Subpartition_by_listContext) {} + +// ExitSubpartition_by_list is called when production subpartition_by_list is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_list(ctx *Subpartition_by_listContext) {} + +// EnterSubpartition_by_hash is called when production subpartition_by_hash is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_by_hash(ctx *Subpartition_by_hashContext) {} + +// ExitSubpartition_by_hash is called when production subpartition_by_hash is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_by_hash(ctx *Subpartition_by_hashContext) {} + +// EnterSubpartition_name is called when production subpartition_name is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_name(ctx *Subpartition_nameContext) {} + +// ExitSubpartition_name is called when production subpartition_name is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_name(ctx *Subpartition_nameContext) {} + +// EnterRange_subpartition_desc is called when production range_subpartition_desc is entered. +func (s *BasePlSqlParserListener) EnterRange_subpartition_desc(ctx *Range_subpartition_descContext) {} + +// ExitRange_subpartition_desc is called when production range_subpartition_desc is exited. +func (s *BasePlSqlParserListener) ExitRange_subpartition_desc(ctx *Range_subpartition_descContext) {} + +// EnterList_subpartition_desc is called when production list_subpartition_desc is entered. +func (s *BasePlSqlParserListener) EnterList_subpartition_desc(ctx *List_subpartition_descContext) {} + +// ExitList_subpartition_desc is called when production list_subpartition_desc is exited. +func (s *BasePlSqlParserListener) ExitList_subpartition_desc(ctx *List_subpartition_descContext) {} + +// EnterIndividual_hash_subparts is called when production individual_hash_subparts is entered. +func (s *BasePlSqlParserListener) EnterIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) { +} + +// ExitIndividual_hash_subparts is called when production individual_hash_subparts is exited. +func (s *BasePlSqlParserListener) ExitIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) { +} + +// EnterHash_subparts_by_quantity is called when production hash_subparts_by_quantity is entered. +func (s *BasePlSqlParserListener) EnterHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) { +} + +// ExitHash_subparts_by_quantity is called when production hash_subparts_by_quantity is exited. +func (s *BasePlSqlParserListener) ExitHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) { +} + +// EnterRange_values_clause is called when production range_values_clause is entered. +func (s *BasePlSqlParserListener) EnterRange_values_clause(ctx *Range_values_clauseContext) {} + +// ExitRange_values_clause is called when production range_values_clause is exited. +func (s *BasePlSqlParserListener) ExitRange_values_clause(ctx *Range_values_clauseContext) {} + +// EnterList_values_clause is called when production list_values_clause is entered. +func (s *BasePlSqlParserListener) EnterList_values_clause(ctx *List_values_clauseContext) {} + +// ExitList_values_clause is called when production list_values_clause is exited. +func (s *BasePlSqlParserListener) ExitList_values_clause(ctx *List_values_clauseContext) {} + +// EnterTable_partition_description is called when production table_partition_description is entered. +func (s *BasePlSqlParserListener) EnterTable_partition_description(ctx *Table_partition_descriptionContext) { +} + +// ExitTable_partition_description is called when production table_partition_description is exited. +func (s *BasePlSqlParserListener) ExitTable_partition_description(ctx *Table_partition_descriptionContext) { +} + +// EnterPartitioning_storage_clause is called when production partitioning_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) { +} + +// ExitPartitioning_storage_clause is called when production partitioning_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) { +} + +// EnterLob_partitioning_storage is called when production lob_partitioning_storage is entered. +func (s *BasePlSqlParserListener) EnterLob_partitioning_storage(ctx *Lob_partitioning_storageContext) { +} + +// ExitLob_partitioning_storage is called when production lob_partitioning_storage is exited. +func (s *BasePlSqlParserListener) ExitLob_partitioning_storage(ctx *Lob_partitioning_storageContext) { +} + +// EnterDatatype_null_enable is called when production datatype_null_enable is entered. +func (s *BasePlSqlParserListener) EnterDatatype_null_enable(ctx *Datatype_null_enableContext) {} + +// ExitDatatype_null_enable is called when production datatype_null_enable is exited. +func (s *BasePlSqlParserListener) ExitDatatype_null_enable(ctx *Datatype_null_enableContext) {} + +// EnterSize_clause is called when production size_clause is entered. +func (s *BasePlSqlParserListener) EnterSize_clause(ctx *Size_clauseContext) {} + +// ExitSize_clause is called when production size_clause is exited. +func (s *BasePlSqlParserListener) ExitSize_clause(ctx *Size_clauseContext) {} + +// EnterTable_compression is called when production table_compression is entered. +func (s *BasePlSqlParserListener) EnterTable_compression(ctx *Table_compressionContext) {} + +// ExitTable_compression is called when production table_compression is exited. +func (s *BasePlSqlParserListener) ExitTable_compression(ctx *Table_compressionContext) {} + +// EnterInmemory_table_clause is called when production inmemory_table_clause is entered. +func (s *BasePlSqlParserListener) EnterInmemory_table_clause(ctx *Inmemory_table_clauseContext) {} + +// ExitInmemory_table_clause is called when production inmemory_table_clause is exited. +func (s *BasePlSqlParserListener) ExitInmemory_table_clause(ctx *Inmemory_table_clauseContext) {} + +// EnterInmemory_attributes is called when production inmemory_attributes is entered. +func (s *BasePlSqlParserListener) EnterInmemory_attributes(ctx *Inmemory_attributesContext) {} + +// ExitInmemory_attributes is called when production inmemory_attributes is exited. +func (s *BasePlSqlParserListener) ExitInmemory_attributes(ctx *Inmemory_attributesContext) {} + +// EnterInmemory_memcompress is called when production inmemory_memcompress is entered. +func (s *BasePlSqlParserListener) EnterInmemory_memcompress(ctx *Inmemory_memcompressContext) {} + +// ExitInmemory_memcompress is called when production inmemory_memcompress is exited. +func (s *BasePlSqlParserListener) ExitInmemory_memcompress(ctx *Inmemory_memcompressContext) {} + +// EnterInmemory_priority is called when production inmemory_priority is entered. +func (s *BasePlSqlParserListener) EnterInmemory_priority(ctx *Inmemory_priorityContext) {} + +// ExitInmemory_priority is called when production inmemory_priority is exited. +func (s *BasePlSqlParserListener) ExitInmemory_priority(ctx *Inmemory_priorityContext) {} + +// EnterInmemory_distribute is called when production inmemory_distribute is entered. +func (s *BasePlSqlParserListener) EnterInmemory_distribute(ctx *Inmemory_distributeContext) {} + +// ExitInmemory_distribute is called when production inmemory_distribute is exited. +func (s *BasePlSqlParserListener) ExitInmemory_distribute(ctx *Inmemory_distributeContext) {} + +// EnterInmemory_duplicate is called when production inmemory_duplicate is entered. +func (s *BasePlSqlParserListener) EnterInmemory_duplicate(ctx *Inmemory_duplicateContext) {} + +// ExitInmemory_duplicate is called when production inmemory_duplicate is exited. +func (s *BasePlSqlParserListener) ExitInmemory_duplicate(ctx *Inmemory_duplicateContext) {} + +// EnterInmemory_column_clause is called when production inmemory_column_clause is entered. +func (s *BasePlSqlParserListener) EnterInmemory_column_clause(ctx *Inmemory_column_clauseContext) {} + +// ExitInmemory_column_clause is called when production inmemory_column_clause is exited. +func (s *BasePlSqlParserListener) ExitInmemory_column_clause(ctx *Inmemory_column_clauseContext) {} + +// EnterPhysical_attributes_clause is called when production physical_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) { +} + +// ExitPhysical_attributes_clause is called when production physical_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) { +} + +// EnterStorage_clause is called when production storage_clause is entered. +func (s *BasePlSqlParserListener) EnterStorage_clause(ctx *Storage_clauseContext) {} + +// ExitStorage_clause is called when production storage_clause is exited. +func (s *BasePlSqlParserListener) ExitStorage_clause(ctx *Storage_clauseContext) {} + +// EnterDeferred_segment_creation is called when production deferred_segment_creation is entered. +func (s *BasePlSqlParserListener) EnterDeferred_segment_creation(ctx *Deferred_segment_creationContext) { +} + +// ExitDeferred_segment_creation is called when production deferred_segment_creation is exited. +func (s *BasePlSqlParserListener) ExitDeferred_segment_creation(ctx *Deferred_segment_creationContext) { +} + +// EnterSegment_attributes_clause is called when production segment_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterSegment_attributes_clause(ctx *Segment_attributes_clauseContext) { +} + +// ExitSegment_attributes_clause is called when production segment_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitSegment_attributes_clause(ctx *Segment_attributes_clauseContext) { +} + +// EnterPhysical_properties is called when production physical_properties is entered. +func (s *BasePlSqlParserListener) EnterPhysical_properties(ctx *Physical_propertiesContext) {} + +// ExitPhysical_properties is called when production physical_properties is exited. +func (s *BasePlSqlParserListener) ExitPhysical_properties(ctx *Physical_propertiesContext) {} + +// EnterIlm_clause is called when production ilm_clause is entered. +func (s *BasePlSqlParserListener) EnterIlm_clause(ctx *Ilm_clauseContext) {} + +// ExitIlm_clause is called when production ilm_clause is exited. +func (s *BasePlSqlParserListener) ExitIlm_clause(ctx *Ilm_clauseContext) {} + +// EnterIlm_policy_clause is called when production ilm_policy_clause is entered. +func (s *BasePlSqlParserListener) EnterIlm_policy_clause(ctx *Ilm_policy_clauseContext) {} + +// ExitIlm_policy_clause is called when production ilm_policy_clause is exited. +func (s *BasePlSqlParserListener) ExitIlm_policy_clause(ctx *Ilm_policy_clauseContext) {} + +// EnterIlm_compression_policy is called when production ilm_compression_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_compression_policy(ctx *Ilm_compression_policyContext) {} + +// ExitIlm_compression_policy is called when production ilm_compression_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_compression_policy(ctx *Ilm_compression_policyContext) {} + +// EnterIlm_tiering_policy is called when production ilm_tiering_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_tiering_policy(ctx *Ilm_tiering_policyContext) {} + +// ExitIlm_tiering_policy is called when production ilm_tiering_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_tiering_policy(ctx *Ilm_tiering_policyContext) {} + +// EnterIlm_after_on is called when production ilm_after_on is entered. +func (s *BasePlSqlParserListener) EnterIlm_after_on(ctx *Ilm_after_onContext) {} + +// ExitIlm_after_on is called when production ilm_after_on is exited. +func (s *BasePlSqlParserListener) ExitIlm_after_on(ctx *Ilm_after_onContext) {} + +// EnterSegment_group is called when production segment_group is entered. +func (s *BasePlSqlParserListener) EnterSegment_group(ctx *Segment_groupContext) {} + +// ExitSegment_group is called when production segment_group is exited. +func (s *BasePlSqlParserListener) ExitSegment_group(ctx *Segment_groupContext) {} + +// EnterIlm_inmemory_policy is called when production ilm_inmemory_policy is entered. +func (s *BasePlSqlParserListener) EnterIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) {} + +// ExitIlm_inmemory_policy is called when production ilm_inmemory_policy is exited. +func (s *BasePlSqlParserListener) ExitIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) {} + +// EnterIlm_time_period is called when production ilm_time_period is entered. +func (s *BasePlSqlParserListener) EnterIlm_time_period(ctx *Ilm_time_periodContext) {} + +// ExitIlm_time_period is called when production ilm_time_period is exited. +func (s *BasePlSqlParserListener) ExitIlm_time_period(ctx *Ilm_time_periodContext) {} + +// EnterHeap_org_table_clause is called when production heap_org_table_clause is entered. +func (s *BasePlSqlParserListener) EnterHeap_org_table_clause(ctx *Heap_org_table_clauseContext) {} + +// ExitHeap_org_table_clause is called when production heap_org_table_clause is exited. +func (s *BasePlSqlParserListener) ExitHeap_org_table_clause(ctx *Heap_org_table_clauseContext) {} + +// EnterExternal_table_clause is called when production external_table_clause is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_clause(ctx *External_table_clauseContext) {} + +// ExitExternal_table_clause is called when production external_table_clause is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_clause(ctx *External_table_clauseContext) {} + +// EnterAccess_driver_type is called when production access_driver_type is entered. +func (s *BasePlSqlParserListener) EnterAccess_driver_type(ctx *Access_driver_typeContext) {} + +// ExitAccess_driver_type is called when production access_driver_type is exited. +func (s *BasePlSqlParserListener) ExitAccess_driver_type(ctx *Access_driver_typeContext) {} + +// EnterExternal_table_data_props is called when production external_table_data_props is entered. +func (s *BasePlSqlParserListener) EnterExternal_table_data_props(ctx *External_table_data_propsContext) { +} + +// ExitExternal_table_data_props is called when production external_table_data_props is exited. +func (s *BasePlSqlParserListener) ExitExternal_table_data_props(ctx *External_table_data_propsContext) { +} + +// EnterOpaque_format_spec is called when production opaque_format_spec is entered. +func (s *BasePlSqlParserListener) EnterOpaque_format_spec(ctx *Opaque_format_specContext) {} + +// ExitOpaque_format_spec is called when production opaque_format_spec is exited. +func (s *BasePlSqlParserListener) ExitOpaque_format_spec(ctx *Opaque_format_specContext) {} + +// EnterRecord_format_info is called when production record_format_info is entered. +func (s *BasePlSqlParserListener) EnterRecord_format_info(ctx *Record_format_infoContext) {} + +// ExitRecord_format_info is called when production record_format_info is exited. +func (s *BasePlSqlParserListener) ExitRecord_format_info(ctx *Record_format_infoContext) {} + +// EnterEt_string is called when production et_string is entered. +func (s *BasePlSqlParserListener) EnterEt_string(ctx *Et_stringContext) {} + +// ExitEt_string is called when production et_string is exited. +func (s *BasePlSqlParserListener) ExitEt_string(ctx *Et_stringContext) {} + +// EnterEt_record_spec_options is called when production et_record_spec_options is entered. +func (s *BasePlSqlParserListener) EnterEt_record_spec_options(ctx *Et_record_spec_optionsContext) {} + +// ExitEt_record_spec_options is called when production et_record_spec_options is exited. +func (s *BasePlSqlParserListener) ExitEt_record_spec_options(ctx *Et_record_spec_optionsContext) {} + +// EnterEt_record_spec_option is called when production et_record_spec_option is entered. +func (s *BasePlSqlParserListener) EnterEt_record_spec_option(ctx *Et_record_spec_optionContext) {} + +// ExitEt_record_spec_option is called when production et_record_spec_option is exited. +func (s *BasePlSqlParserListener) ExitEt_record_spec_option(ctx *Et_record_spec_optionContext) {} + +// EnterEt_output_files is called when production et_output_files is entered. +func (s *BasePlSqlParserListener) EnterEt_output_files(ctx *Et_output_filesContext) {} + +// ExitEt_output_files is called when production et_output_files is exited. +func (s *BasePlSqlParserListener) ExitEt_output_files(ctx *Et_output_filesContext) {} + +// EnterEt_output_file is called when production et_output_file is entered. +func (s *BasePlSqlParserListener) EnterEt_output_file(ctx *Et_output_fileContext) {} + +// ExitEt_output_file is called when production et_output_file is exited. +func (s *BasePlSqlParserListener) ExitEt_output_file(ctx *Et_output_fileContext) {} + +// EnterDirectory_spec is called when production directory_spec is entered. +func (s *BasePlSqlParserListener) EnterDirectory_spec(ctx *Directory_specContext) {} + +// ExitDirectory_spec is called when production directory_spec is exited. +func (s *BasePlSqlParserListener) ExitDirectory_spec(ctx *Directory_specContext) {} + +// EnterFile_spec is called when production file_spec is entered. +func (s *BasePlSqlParserListener) EnterFile_spec(ctx *File_specContext) {} + +// ExitFile_spec is called when production file_spec is exited. +func (s *BasePlSqlParserListener) ExitFile_spec(ctx *File_specContext) {} + +// EnterField_definitions is called when production field_definitions is entered. +func (s *BasePlSqlParserListener) EnterField_definitions(ctx *Field_definitionsContext) {} + +// ExitField_definitions is called when production field_definitions is exited. +func (s *BasePlSqlParserListener) ExitField_definitions(ctx *Field_definitionsContext) {} + +// EnterField_options is called when production field_options is entered. +func (s *BasePlSqlParserListener) EnterField_options(ctx *Field_optionsContext) {} + +// ExitField_options is called when production field_options is exited. +func (s *BasePlSqlParserListener) ExitField_options(ctx *Field_optionsContext) {} + +// EnterField_option is called when production field_option is entered. +func (s *BasePlSqlParserListener) EnterField_option(ctx *Field_optionContext) {} + +// ExitField_option is called when production field_option is exited. +func (s *BasePlSqlParserListener) ExitField_option(ctx *Field_optionContext) {} + +// EnterField_list is called when production field_list is entered. +func (s *BasePlSqlParserListener) EnterField_list(ctx *Field_listContext) {} + +// ExitField_list is called when production field_list is exited. +func (s *BasePlSqlParserListener) ExitField_list(ctx *Field_listContext) {} + +// EnterField_item is called when production field_item is entered. +func (s *BasePlSqlParserListener) EnterField_item(ctx *Field_itemContext) {} + +// ExitField_item is called when production field_item is exited. +func (s *BasePlSqlParserListener) ExitField_item(ctx *Field_itemContext) {} + +// EnterField_name is called when production field_name is entered. +func (s *BasePlSqlParserListener) EnterField_name(ctx *Field_nameContext) {} + +// ExitField_name is called when production field_name is exited. +func (s *BasePlSqlParserListener) ExitField_name(ctx *Field_nameContext) {} + +// EnterPos_spec is called when production pos_spec is entered. +func (s *BasePlSqlParserListener) EnterPos_spec(ctx *Pos_specContext) {} + +// ExitPos_spec is called when production pos_spec is exited. +func (s *BasePlSqlParserListener) ExitPos_spec(ctx *Pos_specContext) {} + +// EnterPos_start is called when production pos_start is entered. +func (s *BasePlSqlParserListener) EnterPos_start(ctx *Pos_startContext) {} + +// ExitPos_start is called when production pos_start is exited. +func (s *BasePlSqlParserListener) ExitPos_start(ctx *Pos_startContext) {} + +// EnterPos_increment is called when production pos_increment is entered. +func (s *BasePlSqlParserListener) EnterPos_increment(ctx *Pos_incrementContext) {} + +// ExitPos_increment is called when production pos_increment is exited. +func (s *BasePlSqlParserListener) ExitPos_increment(ctx *Pos_incrementContext) {} + +// EnterPos_end is called when production pos_end is entered. +func (s *BasePlSqlParserListener) EnterPos_end(ctx *Pos_endContext) {} + +// ExitPos_end is called when production pos_end is exited. +func (s *BasePlSqlParserListener) ExitPos_end(ctx *Pos_endContext) {} + +// EnterPos_length is called when production pos_length is entered. +func (s *BasePlSqlParserListener) EnterPos_length(ctx *Pos_lengthContext) {} + +// ExitPos_length is called when production pos_length is exited. +func (s *BasePlSqlParserListener) ExitPos_length(ctx *Pos_lengthContext) {} + +// EnterDatatype_spec is called when production datatype_spec is entered. +func (s *BasePlSqlParserListener) EnterDatatype_spec(ctx *Datatype_specContext) {} + +// ExitDatatype_spec is called when production datatype_spec is exited. +func (s *BasePlSqlParserListener) ExitDatatype_spec(ctx *Datatype_specContext) {} + +// EnterInit_spec is called when production init_spec is entered. +func (s *BasePlSqlParserListener) EnterInit_spec(ctx *Init_specContext) {} + +// ExitInit_spec is called when production init_spec is exited. +func (s *BasePlSqlParserListener) ExitInit_spec(ctx *Init_specContext) {} + +// EnterLls_clause is called when production lls_clause is entered. +func (s *BasePlSqlParserListener) EnterLls_clause(ctx *Lls_clauseContext) {} + +// ExitLls_clause is called when production lls_clause is exited. +func (s *BasePlSqlParserListener) ExitLls_clause(ctx *Lls_clauseContext) {} + +// EnterDelim_spec is called when production delim_spec is entered. +func (s *BasePlSqlParserListener) EnterDelim_spec(ctx *Delim_specContext) {} + +// ExitDelim_spec is called when production delim_spec is exited. +func (s *BasePlSqlParserListener) ExitDelim_spec(ctx *Delim_specContext) {} + +// EnterTrim_spec is called when production trim_spec is entered. +func (s *BasePlSqlParserListener) EnterTrim_spec(ctx *Trim_specContext) {} + +// ExitTrim_spec is called when production trim_spec is exited. +func (s *BasePlSqlParserListener) ExitTrim_spec(ctx *Trim_specContext) {} + +// EnterField_date_format is called when production field_date_format is entered. +func (s *BasePlSqlParserListener) EnterField_date_format(ctx *Field_date_formatContext) {} + +// ExitField_date_format is called when production field_date_format is exited. +func (s *BasePlSqlParserListener) ExitField_date_format(ctx *Field_date_formatContext) {} + +// EnterColumn_transforms is called when production column_transforms is entered. +func (s *BasePlSqlParserListener) EnterColumn_transforms(ctx *Column_transformsContext) {} + +// ExitColumn_transforms is called when production column_transforms is exited. +func (s *BasePlSqlParserListener) ExitColumn_transforms(ctx *Column_transformsContext) {} + +// EnterTransform is called when production transform is entered. +func (s *BasePlSqlParserListener) EnterTransform(ctx *TransformContext) {} + +// ExitTransform is called when production transform is exited. +func (s *BasePlSqlParserListener) ExitTransform(ctx *TransformContext) {} + +// EnterSource_field is called when production source_field is entered. +func (s *BasePlSqlParserListener) EnterSource_field(ctx *Source_fieldContext) {} + +// ExitSource_field is called when production source_field is exited. +func (s *BasePlSqlParserListener) ExitSource_field(ctx *Source_fieldContext) {} + +// EnterLobfile_item is called when production lobfile_item is entered. +func (s *BasePlSqlParserListener) EnterLobfile_item(ctx *Lobfile_itemContext) {} + +// ExitLobfile_item is called when production lobfile_item is exited. +func (s *BasePlSqlParserListener) ExitLobfile_item(ctx *Lobfile_itemContext) {} + +// EnterLobfile_attr_list is called when production lobfile_attr_list is entered. +func (s *BasePlSqlParserListener) EnterLobfile_attr_list(ctx *Lobfile_attr_listContext) {} + +// ExitLobfile_attr_list is called when production lobfile_attr_list is exited. +func (s *BasePlSqlParserListener) ExitLobfile_attr_list(ctx *Lobfile_attr_listContext) {} + +// EnterConcat_item is called when production concat_item is entered. +func (s *BasePlSqlParserListener) EnterConcat_item(ctx *Concat_itemContext) {} + +// ExitConcat_item is called when production concat_item is exited. +func (s *BasePlSqlParserListener) ExitConcat_item(ctx *Concat_itemContext) {} + +// EnterRow_movement_clause is called when production row_movement_clause is entered. +func (s *BasePlSqlParserListener) EnterRow_movement_clause(ctx *Row_movement_clauseContext) {} + +// ExitRow_movement_clause is called when production row_movement_clause is exited. +func (s *BasePlSqlParserListener) ExitRow_movement_clause(ctx *Row_movement_clauseContext) {} + +// EnterFlashback_archive_clause is called when production flashback_archive_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_archive_clause(ctx *Flashback_archive_clauseContext) { +} + +// ExitFlashback_archive_clause is called when production flashback_archive_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_archive_clause(ctx *Flashback_archive_clauseContext) { +} + +// EnterLog_grp is called when production log_grp is entered. +func (s *BasePlSqlParserListener) EnterLog_grp(ctx *Log_grpContext) {} + +// ExitLog_grp is called when production log_grp is exited. +func (s *BasePlSqlParserListener) ExitLog_grp(ctx *Log_grpContext) {} + +// EnterSupplemental_table_logging is called when production supplemental_table_logging is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_table_logging(ctx *Supplemental_table_loggingContext) { +} + +// ExitSupplemental_table_logging is called when production supplemental_table_logging is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_table_logging(ctx *Supplemental_table_loggingContext) { +} + +// EnterSupplemental_log_grp_clause is called when production supplemental_log_grp_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) { +} + +// ExitSupplemental_log_grp_clause is called when production supplemental_log_grp_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) { +} + +// EnterSupplemental_id_key_clause is called when production supplemental_id_key_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) { +} + +// ExitSupplemental_id_key_clause is called when production supplemental_id_key_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) { +} + +// EnterAllocate_extent_clause is called when production allocate_extent_clause is entered. +func (s *BasePlSqlParserListener) EnterAllocate_extent_clause(ctx *Allocate_extent_clauseContext) {} + +// ExitAllocate_extent_clause is called when production allocate_extent_clause is exited. +func (s *BasePlSqlParserListener) ExitAllocate_extent_clause(ctx *Allocate_extent_clauseContext) {} + +// EnterDeallocate_unused_clause is called when production deallocate_unused_clause is entered. +func (s *BasePlSqlParserListener) EnterDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) { +} + +// ExitDeallocate_unused_clause is called when production deallocate_unused_clause is exited. +func (s *BasePlSqlParserListener) ExitDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) { +} + +// EnterShrink_clause is called when production shrink_clause is entered. +func (s *BasePlSqlParserListener) EnterShrink_clause(ctx *Shrink_clauseContext) {} + +// ExitShrink_clause is called when production shrink_clause is exited. +func (s *BasePlSqlParserListener) ExitShrink_clause(ctx *Shrink_clauseContext) {} + +// EnterRecords_per_block_clause is called when production records_per_block_clause is entered. +func (s *BasePlSqlParserListener) EnterRecords_per_block_clause(ctx *Records_per_block_clauseContext) { +} + +// ExitRecords_per_block_clause is called when production records_per_block_clause is exited. +func (s *BasePlSqlParserListener) ExitRecords_per_block_clause(ctx *Records_per_block_clauseContext) { +} + +// EnterUpgrade_table_clause is called when production upgrade_table_clause is entered. +func (s *BasePlSqlParserListener) EnterUpgrade_table_clause(ctx *Upgrade_table_clauseContext) {} + +// ExitUpgrade_table_clause is called when production upgrade_table_clause is exited. +func (s *BasePlSqlParserListener) ExitUpgrade_table_clause(ctx *Upgrade_table_clauseContext) {} + +// EnterTruncate_table is called when production truncate_table is entered. +func (s *BasePlSqlParserListener) EnterTruncate_table(ctx *Truncate_tableContext) {} + +// ExitTruncate_table is called when production truncate_table is exited. +func (s *BasePlSqlParserListener) ExitTruncate_table(ctx *Truncate_tableContext) {} + +// EnterDrop_table is called when production drop_table is entered. +func (s *BasePlSqlParserListener) EnterDrop_table(ctx *Drop_tableContext) {} + +// ExitDrop_table is called when production drop_table is exited. +func (s *BasePlSqlParserListener) ExitDrop_table(ctx *Drop_tableContext) {} + +// EnterDrop_tablespace is called when production drop_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDrop_tablespace(ctx *Drop_tablespaceContext) {} + +// ExitDrop_tablespace is called when production drop_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDrop_tablespace(ctx *Drop_tablespaceContext) {} + +// EnterDrop_tablespace_set is called when production drop_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterDrop_tablespace_set(ctx *Drop_tablespace_setContext) {} + +// ExitDrop_tablespace_set is called when production drop_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitDrop_tablespace_set(ctx *Drop_tablespace_setContext) {} + +// EnterIncluding_contents_clause is called when production including_contents_clause is entered. +func (s *BasePlSqlParserListener) EnterIncluding_contents_clause(ctx *Including_contents_clauseContext) { +} + +// ExitIncluding_contents_clause is called when production including_contents_clause is exited. +func (s *BasePlSqlParserListener) ExitIncluding_contents_clause(ctx *Including_contents_clauseContext) { +} + +// EnterDrop_view is called when production drop_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_view(ctx *Drop_viewContext) {} + +// ExitDrop_view is called when production drop_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_view(ctx *Drop_viewContext) {} + +// EnterComment_on_column is called when production comment_on_column is entered. +func (s *BasePlSqlParserListener) EnterComment_on_column(ctx *Comment_on_columnContext) {} + +// ExitComment_on_column is called when production comment_on_column is exited. +func (s *BasePlSqlParserListener) ExitComment_on_column(ctx *Comment_on_columnContext) {} + +// EnterEnable_or_disable is called when production enable_or_disable is entered. +func (s *BasePlSqlParserListener) EnterEnable_or_disable(ctx *Enable_or_disableContext) {} + +// ExitEnable_or_disable is called when production enable_or_disable is exited. +func (s *BasePlSqlParserListener) ExitEnable_or_disable(ctx *Enable_or_disableContext) {} + +// EnterAllow_or_disallow is called when production allow_or_disallow is entered. +func (s *BasePlSqlParserListener) EnterAllow_or_disallow(ctx *Allow_or_disallowContext) {} + +// ExitAllow_or_disallow is called when production allow_or_disallow is exited. +func (s *BasePlSqlParserListener) ExitAllow_or_disallow(ctx *Allow_or_disallowContext) {} + +// EnterAlter_synonym is called when production alter_synonym is entered. +func (s *BasePlSqlParserListener) EnterAlter_synonym(ctx *Alter_synonymContext) {} + +// ExitAlter_synonym is called when production alter_synonym is exited. +func (s *BasePlSqlParserListener) ExitAlter_synonym(ctx *Alter_synonymContext) {} + +// EnterCreate_synonym is called when production create_synonym is entered. +func (s *BasePlSqlParserListener) EnterCreate_synonym(ctx *Create_synonymContext) {} + +// ExitCreate_synonym is called when production create_synonym is exited. +func (s *BasePlSqlParserListener) ExitCreate_synonym(ctx *Create_synonymContext) {} + +// EnterDrop_synonym is called when production drop_synonym is entered. +func (s *BasePlSqlParserListener) EnterDrop_synonym(ctx *Drop_synonymContext) {} + +// ExitDrop_synonym is called when production drop_synonym is exited. +func (s *BasePlSqlParserListener) ExitDrop_synonym(ctx *Drop_synonymContext) {} + +// EnterCreate_spfile is called when production create_spfile is entered. +func (s *BasePlSqlParserListener) EnterCreate_spfile(ctx *Create_spfileContext) {} + +// ExitCreate_spfile is called when production create_spfile is exited. +func (s *BasePlSqlParserListener) ExitCreate_spfile(ctx *Create_spfileContext) {} + +// EnterSpfile_name is called when production spfile_name is entered. +func (s *BasePlSqlParserListener) EnterSpfile_name(ctx *Spfile_nameContext) {} + +// ExitSpfile_name is called when production spfile_name is exited. +func (s *BasePlSqlParserListener) ExitSpfile_name(ctx *Spfile_nameContext) {} + +// EnterPfile_name is called when production pfile_name is entered. +func (s *BasePlSqlParserListener) EnterPfile_name(ctx *Pfile_nameContext) {} + +// ExitPfile_name is called when production pfile_name is exited. +func (s *BasePlSqlParserListener) ExitPfile_name(ctx *Pfile_nameContext) {} + +// EnterComment_on_table is called when production comment_on_table is entered. +func (s *BasePlSqlParserListener) EnterComment_on_table(ctx *Comment_on_tableContext) {} + +// ExitComment_on_table is called when production comment_on_table is exited. +func (s *BasePlSqlParserListener) ExitComment_on_table(ctx *Comment_on_tableContext) {} + +// EnterComment_on_materialized is called when production comment_on_materialized is entered. +func (s *BasePlSqlParserListener) EnterComment_on_materialized(ctx *Comment_on_materializedContext) {} + +// ExitComment_on_materialized is called when production comment_on_materialized is exited. +func (s *BasePlSqlParserListener) ExitComment_on_materialized(ctx *Comment_on_materializedContext) {} + +// EnterAlter_analytic_view is called when production alter_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterAlter_analytic_view(ctx *Alter_analytic_viewContext) {} + +// ExitAlter_analytic_view is called when production alter_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitAlter_analytic_view(ctx *Alter_analytic_viewContext) {} + +// EnterAlter_add_cache_clause is called when production alter_add_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) {} + +// ExitAlter_add_cache_clause is called when production alter_add_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) {} + +// EnterLevels_item is called when production levels_item is entered. +func (s *BasePlSqlParserListener) EnterLevels_item(ctx *Levels_itemContext) {} + +// ExitLevels_item is called when production levels_item is exited. +func (s *BasePlSqlParserListener) ExitLevels_item(ctx *Levels_itemContext) {} + +// EnterMeasure_list is called when production measure_list is entered. +func (s *BasePlSqlParserListener) EnterMeasure_list(ctx *Measure_listContext) {} + +// ExitMeasure_list is called when production measure_list is exited. +func (s *BasePlSqlParserListener) ExitMeasure_list(ctx *Measure_listContext) {} + +// EnterAlter_drop_cache_clause is called when production alter_drop_cache_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) {} + +// ExitAlter_drop_cache_clause is called when production alter_drop_cache_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) {} + +// EnterAlter_attribute_dimension is called when production alter_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) { +} + +// ExitAlter_attribute_dimension is called when production alter_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) { +} + +// EnterAlter_audit_policy is called when production alter_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterAlter_audit_policy(ctx *Alter_audit_policyContext) {} + +// ExitAlter_audit_policy is called when production alter_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitAlter_audit_policy(ctx *Alter_audit_policyContext) {} + +// EnterAlter_cluster is called when production alter_cluster is entered. +func (s *BasePlSqlParserListener) EnterAlter_cluster(ctx *Alter_clusterContext) {} + +// ExitAlter_cluster is called when production alter_cluster is exited. +func (s *BasePlSqlParserListener) ExitAlter_cluster(ctx *Alter_clusterContext) {} + +// EnterDrop_analytic_view is called when production drop_analytic_view is entered. +func (s *BasePlSqlParserListener) EnterDrop_analytic_view(ctx *Drop_analytic_viewContext) {} + +// ExitDrop_analytic_view is called when production drop_analytic_view is exited. +func (s *BasePlSqlParserListener) ExitDrop_analytic_view(ctx *Drop_analytic_viewContext) {} + +// EnterDrop_attribute_dimension is called when production drop_attribute_dimension is entered. +func (s *BasePlSqlParserListener) EnterDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) { +} + +// ExitDrop_attribute_dimension is called when production drop_attribute_dimension is exited. +func (s *BasePlSqlParserListener) ExitDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) { +} + +// EnterDrop_audit_policy is called when production drop_audit_policy is entered. +func (s *BasePlSqlParserListener) EnterDrop_audit_policy(ctx *Drop_audit_policyContext) {} + +// ExitDrop_audit_policy is called when production drop_audit_policy is exited. +func (s *BasePlSqlParserListener) ExitDrop_audit_policy(ctx *Drop_audit_policyContext) {} + +// EnterDrop_flashback_archive is called when production drop_flashback_archive is entered. +func (s *BasePlSqlParserListener) EnterDrop_flashback_archive(ctx *Drop_flashback_archiveContext) {} + +// ExitDrop_flashback_archive is called when production drop_flashback_archive is exited. +func (s *BasePlSqlParserListener) ExitDrop_flashback_archive(ctx *Drop_flashback_archiveContext) {} + +// EnterDrop_cluster is called when production drop_cluster is entered. +func (s *BasePlSqlParserListener) EnterDrop_cluster(ctx *Drop_clusterContext) {} + +// ExitDrop_cluster is called when production drop_cluster is exited. +func (s *BasePlSqlParserListener) ExitDrop_cluster(ctx *Drop_clusterContext) {} + +// EnterDrop_context is called when production drop_context is entered. +func (s *BasePlSqlParserListener) EnterDrop_context(ctx *Drop_contextContext) {} + +// ExitDrop_context is called when production drop_context is exited. +func (s *BasePlSqlParserListener) ExitDrop_context(ctx *Drop_contextContext) {} + +// EnterDrop_directory is called when production drop_directory is entered. +func (s *BasePlSqlParserListener) EnterDrop_directory(ctx *Drop_directoryContext) {} + +// ExitDrop_directory is called when production drop_directory is exited. +func (s *BasePlSqlParserListener) ExitDrop_directory(ctx *Drop_directoryContext) {} + +// EnterDrop_diskgroup is called when production drop_diskgroup is entered. +func (s *BasePlSqlParserListener) EnterDrop_diskgroup(ctx *Drop_diskgroupContext) {} + +// ExitDrop_diskgroup is called when production drop_diskgroup is exited. +func (s *BasePlSqlParserListener) ExitDrop_diskgroup(ctx *Drop_diskgroupContext) {} + +// EnterDrop_edition is called when production drop_edition is entered. +func (s *BasePlSqlParserListener) EnterDrop_edition(ctx *Drop_editionContext) {} + +// ExitDrop_edition is called when production drop_edition is exited. +func (s *BasePlSqlParserListener) ExitDrop_edition(ctx *Drop_editionContext) {} + +// EnterTruncate_cluster is called when production truncate_cluster is entered. +func (s *BasePlSqlParserListener) EnterTruncate_cluster(ctx *Truncate_clusterContext) {} + +// ExitTruncate_cluster is called when production truncate_cluster is exited. +func (s *BasePlSqlParserListener) ExitTruncate_cluster(ctx *Truncate_clusterContext) {} + +// EnterCache_or_nocache is called when production cache_or_nocache is entered. +func (s *BasePlSqlParserListener) EnterCache_or_nocache(ctx *Cache_or_nocacheContext) {} + +// ExitCache_or_nocache is called when production cache_or_nocache is exited. +func (s *BasePlSqlParserListener) ExitCache_or_nocache(ctx *Cache_or_nocacheContext) {} + +// EnterDatabase_name is called when production database_name is entered. +func (s *BasePlSqlParserListener) EnterDatabase_name(ctx *Database_nameContext) {} + +// ExitDatabase_name is called when production database_name is exited. +func (s *BasePlSqlParserListener) ExitDatabase_name(ctx *Database_nameContext) {} + +// EnterAlter_database is called when production alter_database is entered. +func (s *BasePlSqlParserListener) EnterAlter_database(ctx *Alter_databaseContext) {} + +// ExitAlter_database is called when production alter_database is exited. +func (s *BasePlSqlParserListener) ExitAlter_database(ctx *Alter_databaseContext) {} + +// EnterDatabase_clause is called when production database_clause is entered. +func (s *BasePlSqlParserListener) EnterDatabase_clause(ctx *Database_clauseContext) {} + +// ExitDatabase_clause is called when production database_clause is exited. +func (s *BasePlSqlParserListener) ExitDatabase_clause(ctx *Database_clauseContext) {} + +// EnterStartup_clauses is called when production startup_clauses is entered. +func (s *BasePlSqlParserListener) EnterStartup_clauses(ctx *Startup_clausesContext) {} + +// ExitStartup_clauses is called when production startup_clauses is exited. +func (s *BasePlSqlParserListener) ExitStartup_clauses(ctx *Startup_clausesContext) {} + +// EnterResetlogs_or_noresetlogs is called when production resetlogs_or_noresetlogs is entered. +func (s *BasePlSqlParserListener) EnterResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) { +} + +// ExitResetlogs_or_noresetlogs is called when production resetlogs_or_noresetlogs is exited. +func (s *BasePlSqlParserListener) ExitResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) { +} + +// EnterUpgrade_or_downgrade is called when production upgrade_or_downgrade is entered. +func (s *BasePlSqlParserListener) EnterUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) {} + +// ExitUpgrade_or_downgrade is called when production upgrade_or_downgrade is exited. +func (s *BasePlSqlParserListener) ExitUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) {} + +// EnterRecovery_clauses is called when production recovery_clauses is entered. +func (s *BasePlSqlParserListener) EnterRecovery_clauses(ctx *Recovery_clausesContext) {} + +// ExitRecovery_clauses is called when production recovery_clauses is exited. +func (s *BasePlSqlParserListener) ExitRecovery_clauses(ctx *Recovery_clausesContext) {} + +// EnterBegin_or_end is called when production begin_or_end is entered. +func (s *BasePlSqlParserListener) EnterBegin_or_end(ctx *Begin_or_endContext) {} + +// ExitBegin_or_end is called when production begin_or_end is exited. +func (s *BasePlSqlParserListener) ExitBegin_or_end(ctx *Begin_or_endContext) {} + +// EnterGeneral_recovery is called when production general_recovery is entered. +func (s *BasePlSqlParserListener) EnterGeneral_recovery(ctx *General_recoveryContext) {} + +// ExitGeneral_recovery is called when production general_recovery is exited. +func (s *BasePlSqlParserListener) ExitGeneral_recovery(ctx *General_recoveryContext) {} + +// EnterFull_database_recovery is called when production full_database_recovery is entered. +func (s *BasePlSqlParserListener) EnterFull_database_recovery(ctx *Full_database_recoveryContext) {} + +// ExitFull_database_recovery is called when production full_database_recovery is exited. +func (s *BasePlSqlParserListener) ExitFull_database_recovery(ctx *Full_database_recoveryContext) {} + +// EnterPartial_database_recovery is called when production partial_database_recovery is entered. +func (s *BasePlSqlParserListener) EnterPartial_database_recovery(ctx *Partial_database_recoveryContext) { +} + +// ExitPartial_database_recovery is called when production partial_database_recovery is exited. +func (s *BasePlSqlParserListener) ExitPartial_database_recovery(ctx *Partial_database_recoveryContext) { +} + +// EnterPartial_database_recovery_10g is called when production partial_database_recovery_10g is entered. +func (s *BasePlSqlParserListener) EnterPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) { +} + +// ExitPartial_database_recovery_10g is called when production partial_database_recovery_10g is exited. +func (s *BasePlSqlParserListener) ExitPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) { +} + +// EnterManaged_standby_recovery is called when production managed_standby_recovery is entered. +func (s *BasePlSqlParserListener) EnterManaged_standby_recovery(ctx *Managed_standby_recoveryContext) { +} + +// ExitManaged_standby_recovery is called when production managed_standby_recovery is exited. +func (s *BasePlSqlParserListener) ExitManaged_standby_recovery(ctx *Managed_standby_recoveryContext) { +} + +// EnterDb_name is called when production db_name is entered. +func (s *BasePlSqlParserListener) EnterDb_name(ctx *Db_nameContext) {} + +// ExitDb_name is called when production db_name is exited. +func (s *BasePlSqlParserListener) ExitDb_name(ctx *Db_nameContext) {} + +// EnterDatabase_file_clauses is called when production database_file_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatabase_file_clauses(ctx *Database_file_clausesContext) {} + +// ExitDatabase_file_clauses is called when production database_file_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatabase_file_clauses(ctx *Database_file_clausesContext) {} + +// EnterCreate_datafile_clause is called when production create_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterCreate_datafile_clause(ctx *Create_datafile_clauseContext) {} + +// ExitCreate_datafile_clause is called when production create_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitCreate_datafile_clause(ctx *Create_datafile_clauseContext) {} + +// EnterAlter_datafile_clause is called when production alter_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_datafile_clause(ctx *Alter_datafile_clauseContext) {} + +// ExitAlter_datafile_clause is called when production alter_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_datafile_clause(ctx *Alter_datafile_clauseContext) {} + +// EnterAlter_tempfile_clause is called when production alter_tempfile_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) {} + +// ExitAlter_tempfile_clause is called when production alter_tempfile_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) {} + +// EnterMove_datafile_clause is called when production move_datafile_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_datafile_clause(ctx *Move_datafile_clauseContext) {} + +// ExitMove_datafile_clause is called when production move_datafile_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_datafile_clause(ctx *Move_datafile_clauseContext) {} + +// EnterLogfile_clauses is called when production logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterLogfile_clauses(ctx *Logfile_clausesContext) {} + +// ExitLogfile_clauses is called when production logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitLogfile_clauses(ctx *Logfile_clausesContext) {} + +// EnterAdd_logfile_clauses is called when production add_logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterAdd_logfile_clauses(ctx *Add_logfile_clausesContext) {} + +// ExitAdd_logfile_clauses is called when production add_logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitAdd_logfile_clauses(ctx *Add_logfile_clausesContext) {} + +// EnterGroup_redo_logfile is called when production group_redo_logfile is entered. +func (s *BasePlSqlParserListener) EnterGroup_redo_logfile(ctx *Group_redo_logfileContext) {} + +// ExitGroup_redo_logfile is called when production group_redo_logfile is exited. +func (s *BasePlSqlParserListener) ExitGroup_redo_logfile(ctx *Group_redo_logfileContext) {} + +// EnterDrop_logfile_clauses is called when production drop_logfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) {} + +// ExitDrop_logfile_clauses is called when production drop_logfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) {} + +// EnterSwitch_logfile_clause is called when production switch_logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) {} + +// ExitSwitch_logfile_clause is called when production switch_logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) {} + +// EnterSupplemental_db_logging is called when production supplemental_db_logging is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_db_logging(ctx *Supplemental_db_loggingContext) {} + +// ExitSupplemental_db_logging is called when production supplemental_db_logging is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_db_logging(ctx *Supplemental_db_loggingContext) {} + +// EnterAdd_or_drop is called when production add_or_drop is entered. +func (s *BasePlSqlParserListener) EnterAdd_or_drop(ctx *Add_or_dropContext) {} + +// ExitAdd_or_drop is called when production add_or_drop is exited. +func (s *BasePlSqlParserListener) ExitAdd_or_drop(ctx *Add_or_dropContext) {} + +// EnterSupplemental_plsql_clause is called when production supplemental_plsql_clause is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) { +} + +// ExitSupplemental_plsql_clause is called when production supplemental_plsql_clause is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) { +} + +// EnterLogfile_descriptor is called when production logfile_descriptor is entered. +func (s *BasePlSqlParserListener) EnterLogfile_descriptor(ctx *Logfile_descriptorContext) {} + +// ExitLogfile_descriptor is called when production logfile_descriptor is exited. +func (s *BasePlSqlParserListener) ExitLogfile_descriptor(ctx *Logfile_descriptorContext) {} + +// EnterControlfile_clauses is called when production controlfile_clauses is entered. +func (s *BasePlSqlParserListener) EnterControlfile_clauses(ctx *Controlfile_clausesContext) {} + +// ExitControlfile_clauses is called when production controlfile_clauses is exited. +func (s *BasePlSqlParserListener) ExitControlfile_clauses(ctx *Controlfile_clausesContext) {} + +// EnterTrace_file_clause is called when production trace_file_clause is entered. +func (s *BasePlSqlParserListener) EnterTrace_file_clause(ctx *Trace_file_clauseContext) {} + +// ExitTrace_file_clause is called when production trace_file_clause is exited. +func (s *BasePlSqlParserListener) ExitTrace_file_clause(ctx *Trace_file_clauseContext) {} + +// EnterStandby_database_clauses is called when production standby_database_clauses is entered. +func (s *BasePlSqlParserListener) EnterStandby_database_clauses(ctx *Standby_database_clausesContext) { +} + +// ExitStandby_database_clauses is called when production standby_database_clauses is exited. +func (s *BasePlSqlParserListener) ExitStandby_database_clauses(ctx *Standby_database_clausesContext) { +} + +// EnterActivate_standby_db_clause is called when production activate_standby_db_clause is entered. +func (s *BasePlSqlParserListener) EnterActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) { +} + +// ExitActivate_standby_db_clause is called when production activate_standby_db_clause is exited. +func (s *BasePlSqlParserListener) ExitActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) { +} + +// EnterMaximize_standby_db_clause is called when production maximize_standby_db_clause is entered. +func (s *BasePlSqlParserListener) EnterMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) { +} + +// ExitMaximize_standby_db_clause is called when production maximize_standby_db_clause is exited. +func (s *BasePlSqlParserListener) ExitMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) { +} + +// EnterRegister_logfile_clause is called when production register_logfile_clause is entered. +func (s *BasePlSqlParserListener) EnterRegister_logfile_clause(ctx *Register_logfile_clauseContext) {} + +// ExitRegister_logfile_clause is called when production register_logfile_clause is exited. +func (s *BasePlSqlParserListener) ExitRegister_logfile_clause(ctx *Register_logfile_clauseContext) {} + +// EnterCommit_switchover_clause is called when production commit_switchover_clause is entered. +func (s *BasePlSqlParserListener) EnterCommit_switchover_clause(ctx *Commit_switchover_clauseContext) { +} + +// ExitCommit_switchover_clause is called when production commit_switchover_clause is exited. +func (s *BasePlSqlParserListener) ExitCommit_switchover_clause(ctx *Commit_switchover_clauseContext) { +} + +// EnterStart_standby_clause is called when production start_standby_clause is entered. +func (s *BasePlSqlParserListener) EnterStart_standby_clause(ctx *Start_standby_clauseContext) {} + +// ExitStart_standby_clause is called when production start_standby_clause is exited. +func (s *BasePlSqlParserListener) ExitStart_standby_clause(ctx *Start_standby_clauseContext) {} + +// EnterStop_standby_clause is called when production stop_standby_clause is entered. +func (s *BasePlSqlParserListener) EnterStop_standby_clause(ctx *Stop_standby_clauseContext) {} + +// ExitStop_standby_clause is called when production stop_standby_clause is exited. +func (s *BasePlSqlParserListener) ExitStop_standby_clause(ctx *Stop_standby_clauseContext) {} + +// EnterConvert_database_clause is called when production convert_database_clause is entered. +func (s *BasePlSqlParserListener) EnterConvert_database_clause(ctx *Convert_database_clauseContext) {} + +// ExitConvert_database_clause is called when production convert_database_clause is exited. +func (s *BasePlSqlParserListener) ExitConvert_database_clause(ctx *Convert_database_clauseContext) {} + +// EnterDefault_settings_clause is called when production default_settings_clause is entered. +func (s *BasePlSqlParserListener) EnterDefault_settings_clause(ctx *Default_settings_clauseContext) {} + +// ExitDefault_settings_clause is called when production default_settings_clause is exited. +func (s *BasePlSqlParserListener) ExitDefault_settings_clause(ctx *Default_settings_clauseContext) {} + +// EnterSet_time_zone_clause is called when production set_time_zone_clause is entered. +func (s *BasePlSqlParserListener) EnterSet_time_zone_clause(ctx *Set_time_zone_clauseContext) {} + +// ExitSet_time_zone_clause is called when production set_time_zone_clause is exited. +func (s *BasePlSqlParserListener) ExitSet_time_zone_clause(ctx *Set_time_zone_clauseContext) {} + +// EnterInstance_clauses is called when production instance_clauses is entered. +func (s *BasePlSqlParserListener) EnterInstance_clauses(ctx *Instance_clausesContext) {} + +// ExitInstance_clauses is called when production instance_clauses is exited. +func (s *BasePlSqlParserListener) ExitInstance_clauses(ctx *Instance_clausesContext) {} + +// EnterSecurity_clause is called when production security_clause is entered. +func (s *BasePlSqlParserListener) EnterSecurity_clause(ctx *Security_clauseContext) {} + +// ExitSecurity_clause is called when production security_clause is exited. +func (s *BasePlSqlParserListener) ExitSecurity_clause(ctx *Security_clauseContext) {} + +// EnterDomain is called when production domain is entered. +func (s *BasePlSqlParserListener) EnterDomain(ctx *DomainContext) {} + +// ExitDomain is called when production domain is exited. +func (s *BasePlSqlParserListener) ExitDomain(ctx *DomainContext) {} + +// EnterDatabase is called when production database is entered. +func (s *BasePlSqlParserListener) EnterDatabase(ctx *DatabaseContext) {} + +// ExitDatabase is called when production database is exited. +func (s *BasePlSqlParserListener) ExitDatabase(ctx *DatabaseContext) {} + +// EnterEdition_name is called when production edition_name is entered. +func (s *BasePlSqlParserListener) EnterEdition_name(ctx *Edition_nameContext) {} + +// ExitEdition_name is called when production edition_name is exited. +func (s *BasePlSqlParserListener) ExitEdition_name(ctx *Edition_nameContext) {} + +// EnterFilenumber is called when production filenumber is entered. +func (s *BasePlSqlParserListener) EnterFilenumber(ctx *FilenumberContext) {} + +// ExitFilenumber is called when production filenumber is exited. +func (s *BasePlSqlParserListener) ExitFilenumber(ctx *FilenumberContext) {} + +// EnterFilename is called when production filename is entered. +func (s *BasePlSqlParserListener) EnterFilename(ctx *FilenameContext) {} + +// ExitFilename is called when production filename is exited. +func (s *BasePlSqlParserListener) ExitFilename(ctx *FilenameContext) {} + +// EnterPrepare_clause is called when production prepare_clause is entered. +func (s *BasePlSqlParserListener) EnterPrepare_clause(ctx *Prepare_clauseContext) {} + +// ExitPrepare_clause is called when production prepare_clause is exited. +func (s *BasePlSqlParserListener) ExitPrepare_clause(ctx *Prepare_clauseContext) {} + +// EnterDrop_mirror_clause is called when production drop_mirror_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_mirror_clause(ctx *Drop_mirror_clauseContext) {} + +// ExitDrop_mirror_clause is called when production drop_mirror_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_mirror_clause(ctx *Drop_mirror_clauseContext) {} + +// EnterLost_write_protection is called when production lost_write_protection is entered. +func (s *BasePlSqlParserListener) EnterLost_write_protection(ctx *Lost_write_protectionContext) {} + +// ExitLost_write_protection is called when production lost_write_protection is exited. +func (s *BasePlSqlParserListener) ExitLost_write_protection(ctx *Lost_write_protectionContext) {} + +// EnterCdb_fleet_clauses is called when production cdb_fleet_clauses is entered. +func (s *BasePlSqlParserListener) EnterCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) {} + +// ExitCdb_fleet_clauses is called when production cdb_fleet_clauses is exited. +func (s *BasePlSqlParserListener) ExitCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) {} + +// EnterLead_cdb_clause is called when production lead_cdb_clause is entered. +func (s *BasePlSqlParserListener) EnterLead_cdb_clause(ctx *Lead_cdb_clauseContext) {} + +// ExitLead_cdb_clause is called when production lead_cdb_clause is exited. +func (s *BasePlSqlParserListener) ExitLead_cdb_clause(ctx *Lead_cdb_clauseContext) {} + +// EnterLead_cdb_uri_clause is called when production lead_cdb_uri_clause is entered. +func (s *BasePlSqlParserListener) EnterLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) {} + +// ExitLead_cdb_uri_clause is called when production lead_cdb_uri_clause is exited. +func (s *BasePlSqlParserListener) ExitLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) {} + +// EnterProperty_clauses is called when production property_clauses is entered. +func (s *BasePlSqlParserListener) EnterProperty_clauses(ctx *Property_clausesContext) {} + +// ExitProperty_clauses is called when production property_clauses is exited. +func (s *BasePlSqlParserListener) ExitProperty_clauses(ctx *Property_clausesContext) {} + +// EnterReplay_upgrade_clauses is called when production replay_upgrade_clauses is entered. +func (s *BasePlSqlParserListener) EnterReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) {} + +// ExitReplay_upgrade_clauses is called when production replay_upgrade_clauses is exited. +func (s *BasePlSqlParserListener) ExitReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) {} + +// EnterAlter_database_link is called when production alter_database_link is entered. +func (s *BasePlSqlParserListener) EnterAlter_database_link(ctx *Alter_database_linkContext) {} + +// ExitAlter_database_link is called when production alter_database_link is exited. +func (s *BasePlSqlParserListener) ExitAlter_database_link(ctx *Alter_database_linkContext) {} + +// EnterPassword_value is called when production password_value is entered. +func (s *BasePlSqlParserListener) EnterPassword_value(ctx *Password_valueContext) {} + +// ExitPassword_value is called when production password_value is exited. +func (s *BasePlSqlParserListener) ExitPassword_value(ctx *Password_valueContext) {} + +// EnterLink_authentication is called when production link_authentication is entered. +func (s *BasePlSqlParserListener) EnterLink_authentication(ctx *Link_authenticationContext) {} + +// ExitLink_authentication is called when production link_authentication is exited. +func (s *BasePlSqlParserListener) ExitLink_authentication(ctx *Link_authenticationContext) {} + +// EnterCreate_database is called when production create_database is entered. +func (s *BasePlSqlParserListener) EnterCreate_database(ctx *Create_databaseContext) {} + +// ExitCreate_database is called when production create_database is exited. +func (s *BasePlSqlParserListener) ExitCreate_database(ctx *Create_databaseContext) {} + +// EnterDatabase_logging_clauses is called when production database_logging_clauses is entered. +func (s *BasePlSqlParserListener) EnterDatabase_logging_clauses(ctx *Database_logging_clausesContext) { +} + +// ExitDatabase_logging_clauses is called when production database_logging_clauses is exited. +func (s *BasePlSqlParserListener) ExitDatabase_logging_clauses(ctx *Database_logging_clausesContext) { +} + +// EnterDatabase_logging_sub_clause is called when production database_logging_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) { +} + +// ExitDatabase_logging_sub_clause is called when production database_logging_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) { +} + +// EnterTablespace_clauses is called when production tablespace_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_clauses(ctx *Tablespace_clausesContext) {} + +// ExitTablespace_clauses is called when production tablespace_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_clauses(ctx *Tablespace_clausesContext) {} + +// EnterEnable_pluggable_database is called when production enable_pluggable_database is entered. +func (s *BasePlSqlParserListener) EnterEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) { +} + +// ExitEnable_pluggable_database is called when production enable_pluggable_database is exited. +func (s *BasePlSqlParserListener) ExitEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) { +} + +// EnterFile_name_convert is called when production file_name_convert is entered. +func (s *BasePlSqlParserListener) EnterFile_name_convert(ctx *File_name_convertContext) {} + +// ExitFile_name_convert is called when production file_name_convert is exited. +func (s *BasePlSqlParserListener) ExitFile_name_convert(ctx *File_name_convertContext) {} + +// EnterFilename_convert_sub_clause is called when production filename_convert_sub_clause is entered. +func (s *BasePlSqlParserListener) EnterFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) { +} + +// ExitFilename_convert_sub_clause is called when production filename_convert_sub_clause is exited. +func (s *BasePlSqlParserListener) ExitFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) { +} + +// EnterTablespace_datafile_clauses is called when production tablespace_datafile_clauses is entered. +func (s *BasePlSqlParserListener) EnterTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) { +} + +// ExitTablespace_datafile_clauses is called when production tablespace_datafile_clauses is exited. +func (s *BasePlSqlParserListener) ExitTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) { +} + +// EnterUndo_mode_clause is called when production undo_mode_clause is entered. +func (s *BasePlSqlParserListener) EnterUndo_mode_clause(ctx *Undo_mode_clauseContext) {} + +// ExitUndo_mode_clause is called when production undo_mode_clause is exited. +func (s *BasePlSqlParserListener) ExitUndo_mode_clause(ctx *Undo_mode_clauseContext) {} + +// EnterDefault_tablespace is called when production default_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDefault_tablespace(ctx *Default_tablespaceContext) {} + +// ExitDefault_tablespace is called when production default_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDefault_tablespace(ctx *Default_tablespaceContext) {} + +// EnterDefault_temp_tablespace is called when production default_temp_tablespace is entered. +func (s *BasePlSqlParserListener) EnterDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) {} + +// ExitDefault_temp_tablespace is called when production default_temp_tablespace is exited. +func (s *BasePlSqlParserListener) ExitDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) {} + +// EnterUndo_tablespace is called when production undo_tablespace is entered. +func (s *BasePlSqlParserListener) EnterUndo_tablespace(ctx *Undo_tablespaceContext) {} + +// ExitUndo_tablespace is called when production undo_tablespace is exited. +func (s *BasePlSqlParserListener) ExitUndo_tablespace(ctx *Undo_tablespaceContext) {} + +// EnterDrop_database is called when production drop_database is entered. +func (s *BasePlSqlParserListener) EnterDrop_database(ctx *Drop_databaseContext) {} + +// ExitDrop_database is called when production drop_database is exited. +func (s *BasePlSqlParserListener) ExitDrop_database(ctx *Drop_databaseContext) {} + +// EnterCreate_database_link is called when production create_database_link is entered. +func (s *BasePlSqlParserListener) EnterCreate_database_link(ctx *Create_database_linkContext) {} + +// ExitCreate_database_link is called when production create_database_link is exited. +func (s *BasePlSqlParserListener) ExitCreate_database_link(ctx *Create_database_linkContext) {} + +// EnterDblink is called when production dblink is entered. +func (s *BasePlSqlParserListener) EnterDblink(ctx *DblinkContext) {} + +// ExitDblink is called when production dblink is exited. +func (s *BasePlSqlParserListener) ExitDblink(ctx *DblinkContext) {} + +// EnterDrop_database_link is called when production drop_database_link is entered. +func (s *BasePlSqlParserListener) EnterDrop_database_link(ctx *Drop_database_linkContext) {} + +// ExitDrop_database_link is called when production drop_database_link is exited. +func (s *BasePlSqlParserListener) ExitDrop_database_link(ctx *Drop_database_linkContext) {} + +// EnterAlter_tablespace_set is called when production alter_tablespace_set is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_set(ctx *Alter_tablespace_setContext) {} + +// ExitAlter_tablespace_set is called when production alter_tablespace_set is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_set(ctx *Alter_tablespace_setContext) {} + +// EnterAlter_tablespace_attrs is called when production alter_tablespace_attrs is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) {} + +// ExitAlter_tablespace_attrs is called when production alter_tablespace_attrs is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) {} + +// EnterAlter_tablespace_encryption is called when production alter_tablespace_encryption is entered. +func (s *BasePlSqlParserListener) EnterAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) { +} + +// ExitAlter_tablespace_encryption is called when production alter_tablespace_encryption is exited. +func (s *BasePlSqlParserListener) ExitAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) { +} + +// EnterTs_file_name_convert is called when production ts_file_name_convert is entered. +func (s *BasePlSqlParserListener) EnterTs_file_name_convert(ctx *Ts_file_name_convertContext) {} + +// ExitTs_file_name_convert is called when production ts_file_name_convert is exited. +func (s *BasePlSqlParserListener) ExitTs_file_name_convert(ctx *Ts_file_name_convertContext) {} + +// EnterAlter_role is called when production alter_role is entered. +func (s *BasePlSqlParserListener) EnterAlter_role(ctx *Alter_roleContext) {} + +// ExitAlter_role is called when production alter_role is exited. +func (s *BasePlSqlParserListener) ExitAlter_role(ctx *Alter_roleContext) {} + +// EnterRole_identified_clause is called when production role_identified_clause is entered. +func (s *BasePlSqlParserListener) EnterRole_identified_clause(ctx *Role_identified_clauseContext) {} + +// ExitRole_identified_clause is called when production role_identified_clause is exited. +func (s *BasePlSqlParserListener) ExitRole_identified_clause(ctx *Role_identified_clauseContext) {} + +// EnterAlter_table is called when production alter_table is entered. +func (s *BasePlSqlParserListener) EnterAlter_table(ctx *Alter_tableContext) {} + +// ExitAlter_table is called when production alter_table is exited. +func (s *BasePlSqlParserListener) ExitAlter_table(ctx *Alter_tableContext) {} + +// EnterMemoptimize_read_write_clause is called when production memoptimize_read_write_clause is entered. +func (s *BasePlSqlParserListener) EnterMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) { +} + +// ExitMemoptimize_read_write_clause is called when production memoptimize_read_write_clause is exited. +func (s *BasePlSqlParserListener) ExitMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) { +} + +// EnterAlter_table_properties is called when production alter_table_properties is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_properties(ctx *Alter_table_propertiesContext) {} + +// ExitAlter_table_properties is called when production alter_table_properties is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_properties(ctx *Alter_table_propertiesContext) {} + +// EnterAlter_table_partitioning is called when production alter_table_partitioning is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_partitioning(ctx *Alter_table_partitioningContext) { +} + +// ExitAlter_table_partitioning is called when production alter_table_partitioning is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_partitioning(ctx *Alter_table_partitioningContext) { +} + +// EnterAdd_table_partition is called when production add_table_partition is entered. +func (s *BasePlSqlParserListener) EnterAdd_table_partition(ctx *Add_table_partitionContext) {} + +// ExitAdd_table_partition is called when production add_table_partition is exited. +func (s *BasePlSqlParserListener) ExitAdd_table_partition(ctx *Add_table_partitionContext) {} + +// EnterDrop_table_partition is called when production drop_table_partition is entered. +func (s *BasePlSqlParserListener) EnterDrop_table_partition(ctx *Drop_table_partitionContext) {} + +// ExitDrop_table_partition is called when production drop_table_partition is exited. +func (s *BasePlSqlParserListener) ExitDrop_table_partition(ctx *Drop_table_partitionContext) {} + +// EnterMerge_table_partition is called when production merge_table_partition is entered. +func (s *BasePlSqlParserListener) EnterMerge_table_partition(ctx *Merge_table_partitionContext) {} + +// ExitMerge_table_partition is called when production merge_table_partition is exited. +func (s *BasePlSqlParserListener) ExitMerge_table_partition(ctx *Merge_table_partitionContext) {} + +// EnterModify_table_partition is called when production modify_table_partition is entered. +func (s *BasePlSqlParserListener) EnterModify_table_partition(ctx *Modify_table_partitionContext) {} + +// ExitModify_table_partition is called when production modify_table_partition is exited. +func (s *BasePlSqlParserListener) ExitModify_table_partition(ctx *Modify_table_partitionContext) {} + +// EnterSplit_table_partition is called when production split_table_partition is entered. +func (s *BasePlSqlParserListener) EnterSplit_table_partition(ctx *Split_table_partitionContext) {} + +// ExitSplit_table_partition is called when production split_table_partition is exited. +func (s *BasePlSqlParserListener) ExitSplit_table_partition(ctx *Split_table_partitionContext) {} + +// EnterTruncate_table_partition is called when production truncate_table_partition is entered. +func (s *BasePlSqlParserListener) EnterTruncate_table_partition(ctx *Truncate_table_partitionContext) { +} + +// ExitTruncate_table_partition is called when production truncate_table_partition is exited. +func (s *BasePlSqlParserListener) ExitTruncate_table_partition(ctx *Truncate_table_partitionContext) { +} + +// EnterExchange_table_partition is called when production exchange_table_partition is entered. +func (s *BasePlSqlParserListener) EnterExchange_table_partition(ctx *Exchange_table_partitionContext) { +} + +// ExitExchange_table_partition is called when production exchange_table_partition is exited. +func (s *BasePlSqlParserListener) ExitExchange_table_partition(ctx *Exchange_table_partitionContext) { +} + +// EnterCoalesce_table_partition is called when production coalesce_table_partition is entered. +func (s *BasePlSqlParserListener) EnterCoalesce_table_partition(ctx *Coalesce_table_partitionContext) { +} + +// ExitCoalesce_table_partition is called when production coalesce_table_partition is exited. +func (s *BasePlSqlParserListener) ExitCoalesce_table_partition(ctx *Coalesce_table_partitionContext) { +} + +// EnterAlter_interval_partition is called when production alter_interval_partition is entered. +func (s *BasePlSqlParserListener) EnterAlter_interval_partition(ctx *Alter_interval_partitionContext) { +} + +// ExitAlter_interval_partition is called when production alter_interval_partition is exited. +func (s *BasePlSqlParserListener) ExitAlter_interval_partition(ctx *Alter_interval_partitionContext) { +} + +// EnterPartition_extended_names is called when production partition_extended_names is entered. +func (s *BasePlSqlParserListener) EnterPartition_extended_names(ctx *Partition_extended_namesContext) { +} + +// ExitPartition_extended_names is called when production partition_extended_names is exited. +func (s *BasePlSqlParserListener) ExitPartition_extended_names(ctx *Partition_extended_namesContext) { +} + +// EnterSubpartition_extended_names is called when production subpartition_extended_names is entered. +func (s *BasePlSqlParserListener) EnterSubpartition_extended_names(ctx *Subpartition_extended_namesContext) { +} + +// ExitSubpartition_extended_names is called when production subpartition_extended_names is exited. +func (s *BasePlSqlParserListener) ExitSubpartition_extended_names(ctx *Subpartition_extended_namesContext) { +} + +// EnterAlter_table_properties_1 is called when production alter_table_properties_1 is entered. +func (s *BasePlSqlParserListener) EnterAlter_table_properties_1(ctx *Alter_table_properties_1Context) { +} + +// ExitAlter_table_properties_1 is called when production alter_table_properties_1 is exited. +func (s *BasePlSqlParserListener) ExitAlter_table_properties_1(ctx *Alter_table_properties_1Context) { +} + +// EnterAlter_iot_clauses is called when production alter_iot_clauses is entered. +func (s *BasePlSqlParserListener) EnterAlter_iot_clauses(ctx *Alter_iot_clausesContext) {} + +// ExitAlter_iot_clauses is called when production alter_iot_clauses is exited. +func (s *BasePlSqlParserListener) ExitAlter_iot_clauses(ctx *Alter_iot_clausesContext) {} + +// EnterAlter_mapping_table_clause is called when production alter_mapping_table_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) { +} + +// ExitAlter_mapping_table_clause is called when production alter_mapping_table_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) { +} + +// EnterAlter_overflow_clause is called when production alter_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterAlter_overflow_clause(ctx *Alter_overflow_clauseContext) {} + +// ExitAlter_overflow_clause is called when production alter_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitAlter_overflow_clause(ctx *Alter_overflow_clauseContext) {} + +// EnterAdd_overflow_clause is called when production add_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_overflow_clause(ctx *Add_overflow_clauseContext) {} + +// ExitAdd_overflow_clause is called when production add_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_overflow_clause(ctx *Add_overflow_clauseContext) {} + +// EnterUpdate_index_clauses is called when production update_index_clauses is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_clauses(ctx *Update_index_clausesContext) {} + +// ExitUpdate_index_clauses is called when production update_index_clauses is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_clauses(ctx *Update_index_clausesContext) {} + +// EnterUpdate_global_index_clause is called when production update_global_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_global_index_clause(ctx *Update_global_index_clauseContext) { +} + +// ExitUpdate_global_index_clause is called when production update_global_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_global_index_clause(ctx *Update_global_index_clauseContext) { +} + +// EnterUpdate_all_indexes_clause is called when production update_all_indexes_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) { +} + +// ExitUpdate_all_indexes_clause is called when production update_all_indexes_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) { +} + +// EnterUpdate_all_indexes_index_clause is called when production update_all_indexes_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) { +} + +// ExitUpdate_all_indexes_index_clause is called when production update_all_indexes_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) { +} + +// EnterUpdate_index_partition is called when production update_index_partition is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_partition(ctx *Update_index_partitionContext) {} + +// ExitUpdate_index_partition is called when production update_index_partition is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_partition(ctx *Update_index_partitionContext) {} + +// EnterUpdate_index_subpartition is called when production update_index_subpartition is entered. +func (s *BasePlSqlParserListener) EnterUpdate_index_subpartition(ctx *Update_index_subpartitionContext) { +} + +// ExitUpdate_index_subpartition is called when production update_index_subpartition is exited. +func (s *BasePlSqlParserListener) ExitUpdate_index_subpartition(ctx *Update_index_subpartitionContext) { +} + +// EnterEnable_disable_clause is called when production enable_disable_clause is entered. +func (s *BasePlSqlParserListener) EnterEnable_disable_clause(ctx *Enable_disable_clauseContext) {} + +// ExitEnable_disable_clause is called when production enable_disable_clause is exited. +func (s *BasePlSqlParserListener) ExitEnable_disable_clause(ctx *Enable_disable_clauseContext) {} + +// EnterUsing_index_clause is called when production using_index_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_index_clause(ctx *Using_index_clauseContext) {} + +// ExitUsing_index_clause is called when production using_index_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_index_clause(ctx *Using_index_clauseContext) {} + +// EnterIndex_attributes is called when production index_attributes is entered. +func (s *BasePlSqlParserListener) EnterIndex_attributes(ctx *Index_attributesContext) {} + +// ExitIndex_attributes is called when production index_attributes is exited. +func (s *BasePlSqlParserListener) ExitIndex_attributes(ctx *Index_attributesContext) {} + +// EnterSort_or_nosort is called when production sort_or_nosort is entered. +func (s *BasePlSqlParserListener) EnterSort_or_nosort(ctx *Sort_or_nosortContext) {} + +// ExitSort_or_nosort is called when production sort_or_nosort is exited. +func (s *BasePlSqlParserListener) ExitSort_or_nosort(ctx *Sort_or_nosortContext) {} + +// EnterExceptions_clause is called when production exceptions_clause is entered. +func (s *BasePlSqlParserListener) EnterExceptions_clause(ctx *Exceptions_clauseContext) {} + +// ExitExceptions_clause is called when production exceptions_clause is exited. +func (s *BasePlSqlParserListener) ExitExceptions_clause(ctx *Exceptions_clauseContext) {} + +// EnterMove_table_clause is called when production move_table_clause is entered. +func (s *BasePlSqlParserListener) EnterMove_table_clause(ctx *Move_table_clauseContext) {} + +// ExitMove_table_clause is called when production move_table_clause is exited. +func (s *BasePlSqlParserListener) ExitMove_table_clause(ctx *Move_table_clauseContext) {} + +// EnterIndex_org_table_clause is called when production index_org_table_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_org_table_clause(ctx *Index_org_table_clauseContext) {} + +// ExitIndex_org_table_clause is called when production index_org_table_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_org_table_clause(ctx *Index_org_table_clauseContext) {} + +// EnterMapping_table_clause is called when production mapping_table_clause is entered. +func (s *BasePlSqlParserListener) EnterMapping_table_clause(ctx *Mapping_table_clauseContext) {} + +// ExitMapping_table_clause is called when production mapping_table_clause is exited. +func (s *BasePlSqlParserListener) ExitMapping_table_clause(ctx *Mapping_table_clauseContext) {} + +// EnterKey_compression is called when production key_compression is entered. +func (s *BasePlSqlParserListener) EnterKey_compression(ctx *Key_compressionContext) {} + +// ExitKey_compression is called when production key_compression is exited. +func (s *BasePlSqlParserListener) ExitKey_compression(ctx *Key_compressionContext) {} + +// EnterIndex_org_overflow_clause is called when production index_org_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) { +} + +// ExitIndex_org_overflow_clause is called when production index_org_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) { +} + +// EnterColumn_clauses is called when production column_clauses is entered. +func (s *BasePlSqlParserListener) EnterColumn_clauses(ctx *Column_clausesContext) {} + +// ExitColumn_clauses is called when production column_clauses is exited. +func (s *BasePlSqlParserListener) ExitColumn_clauses(ctx *Column_clausesContext) {} + +// EnterModify_collection_retrieval is called when production modify_collection_retrieval is entered. +func (s *BasePlSqlParserListener) EnterModify_collection_retrieval(ctx *Modify_collection_retrievalContext) { +} + +// ExitModify_collection_retrieval is called when production modify_collection_retrieval is exited. +func (s *BasePlSqlParserListener) ExitModify_collection_retrieval(ctx *Modify_collection_retrievalContext) { +} + +// EnterCollection_item is called when production collection_item is entered. +func (s *BasePlSqlParserListener) EnterCollection_item(ctx *Collection_itemContext) {} + +// ExitCollection_item is called when production collection_item is exited. +func (s *BasePlSqlParserListener) ExitCollection_item(ctx *Collection_itemContext) {} + +// EnterRename_column_clause is called when production rename_column_clause is entered. +func (s *BasePlSqlParserListener) EnterRename_column_clause(ctx *Rename_column_clauseContext) {} + +// ExitRename_column_clause is called when production rename_column_clause is exited. +func (s *BasePlSqlParserListener) ExitRename_column_clause(ctx *Rename_column_clauseContext) {} + +// EnterOld_column_name is called when production old_column_name is entered. +func (s *BasePlSqlParserListener) EnterOld_column_name(ctx *Old_column_nameContext) {} + +// ExitOld_column_name is called when production old_column_name is exited. +func (s *BasePlSqlParserListener) ExitOld_column_name(ctx *Old_column_nameContext) {} + +// EnterNew_column_name is called when production new_column_name is entered. +func (s *BasePlSqlParserListener) EnterNew_column_name(ctx *New_column_nameContext) {} + +// ExitNew_column_name is called when production new_column_name is exited. +func (s *BasePlSqlParserListener) ExitNew_column_name(ctx *New_column_nameContext) {} + +// EnterAdd_modify_drop_column_clauses is called when production add_modify_drop_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) { +} + +// ExitAdd_modify_drop_column_clauses is called when production add_modify_drop_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) { +} + +// EnterDrop_column_clause is called when production drop_column_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_column_clause(ctx *Drop_column_clauseContext) {} + +// ExitDrop_column_clause is called when production drop_column_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_column_clause(ctx *Drop_column_clauseContext) {} + +// EnterModify_column_clauses is called when production modify_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterModify_column_clauses(ctx *Modify_column_clausesContext) {} + +// ExitModify_column_clauses is called when production modify_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitModify_column_clauses(ctx *Modify_column_clausesContext) {} + +// EnterModify_col_visibility is called when production modify_col_visibility is entered. +func (s *BasePlSqlParserListener) EnterModify_col_visibility(ctx *Modify_col_visibilityContext) {} + +// ExitModify_col_visibility is called when production modify_col_visibility is exited. +func (s *BasePlSqlParserListener) ExitModify_col_visibility(ctx *Modify_col_visibilityContext) {} + +// EnterModify_col_properties is called when production modify_col_properties is entered. +func (s *BasePlSqlParserListener) EnterModify_col_properties(ctx *Modify_col_propertiesContext) {} + +// ExitModify_col_properties is called when production modify_col_properties is exited. +func (s *BasePlSqlParserListener) ExitModify_col_properties(ctx *Modify_col_propertiesContext) {} + +// EnterModify_col_substitutable is called when production modify_col_substitutable is entered. +func (s *BasePlSqlParserListener) EnterModify_col_substitutable(ctx *Modify_col_substitutableContext) { +} + +// ExitModify_col_substitutable is called when production modify_col_substitutable is exited. +func (s *BasePlSqlParserListener) ExitModify_col_substitutable(ctx *Modify_col_substitutableContext) { +} + +// EnterAdd_column_clause is called when production add_column_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_column_clause(ctx *Add_column_clauseContext) {} + +// ExitAdd_column_clause is called when production add_column_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_column_clause(ctx *Add_column_clauseContext) {} + +// EnterAlter_varray_col_properties is called when production alter_varray_col_properties is entered. +func (s *BasePlSqlParserListener) EnterAlter_varray_col_properties(ctx *Alter_varray_col_propertiesContext) { +} + +// ExitAlter_varray_col_properties is called when production alter_varray_col_properties is exited. +func (s *BasePlSqlParserListener) ExitAlter_varray_col_properties(ctx *Alter_varray_col_propertiesContext) { +} + +// EnterVarray_col_properties is called when production varray_col_properties is entered. +func (s *BasePlSqlParserListener) EnterVarray_col_properties(ctx *Varray_col_propertiesContext) {} + +// ExitVarray_col_properties is called when production varray_col_properties is exited. +func (s *BasePlSqlParserListener) ExitVarray_col_properties(ctx *Varray_col_propertiesContext) {} + +// EnterVarray_storage_clause is called when production varray_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterVarray_storage_clause(ctx *Varray_storage_clauseContext) {} + +// ExitVarray_storage_clause is called when production varray_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitVarray_storage_clause(ctx *Varray_storage_clauseContext) {} + +// EnterLob_segname is called when production lob_segname is entered. +func (s *BasePlSqlParserListener) EnterLob_segname(ctx *Lob_segnameContext) {} + +// ExitLob_segname is called when production lob_segname is exited. +func (s *BasePlSqlParserListener) ExitLob_segname(ctx *Lob_segnameContext) {} + +// EnterLob_item is called when production lob_item is entered. +func (s *BasePlSqlParserListener) EnterLob_item(ctx *Lob_itemContext) {} + +// ExitLob_item is called when production lob_item is exited. +func (s *BasePlSqlParserListener) ExitLob_item(ctx *Lob_itemContext) {} + +// EnterLob_storage_parameters is called when production lob_storage_parameters is entered. +func (s *BasePlSqlParserListener) EnterLob_storage_parameters(ctx *Lob_storage_parametersContext) {} + +// ExitLob_storage_parameters is called when production lob_storage_parameters is exited. +func (s *BasePlSqlParserListener) ExitLob_storage_parameters(ctx *Lob_storage_parametersContext) {} + +// EnterLob_storage_clause is called when production lob_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_storage_clause(ctx *Lob_storage_clauseContext) {} + +// ExitLob_storage_clause is called when production lob_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_storage_clause(ctx *Lob_storage_clauseContext) {} + +// EnterModify_lob_storage_clause is called when production modify_lob_storage_clause is entered. +func (s *BasePlSqlParserListener) EnterModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) { +} + +// ExitModify_lob_storage_clause is called when production modify_lob_storage_clause is exited. +func (s *BasePlSqlParserListener) ExitModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) { +} + +// EnterModify_lob_parameters is called when production modify_lob_parameters is entered. +func (s *BasePlSqlParserListener) EnterModify_lob_parameters(ctx *Modify_lob_parametersContext) {} + +// ExitModify_lob_parameters is called when production modify_lob_parameters is exited. +func (s *BasePlSqlParserListener) ExitModify_lob_parameters(ctx *Modify_lob_parametersContext) {} + +// EnterLob_parameters is called when production lob_parameters is entered. +func (s *BasePlSqlParserListener) EnterLob_parameters(ctx *Lob_parametersContext) {} + +// ExitLob_parameters is called when production lob_parameters is exited. +func (s *BasePlSqlParserListener) ExitLob_parameters(ctx *Lob_parametersContext) {} + +// EnterLob_deduplicate_clause is called when production lob_deduplicate_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) {} + +// ExitLob_deduplicate_clause is called when production lob_deduplicate_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) {} + +// EnterLob_compression_clause is called when production lob_compression_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_compression_clause(ctx *Lob_compression_clauseContext) {} + +// ExitLob_compression_clause is called when production lob_compression_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_compression_clause(ctx *Lob_compression_clauseContext) {} + +// EnterLob_retention_clause is called when production lob_retention_clause is entered. +func (s *BasePlSqlParserListener) EnterLob_retention_clause(ctx *Lob_retention_clauseContext) {} + +// ExitLob_retention_clause is called when production lob_retention_clause is exited. +func (s *BasePlSqlParserListener) ExitLob_retention_clause(ctx *Lob_retention_clauseContext) {} + +// EnterEncryption_spec is called when production encryption_spec is entered. +func (s *BasePlSqlParserListener) EnterEncryption_spec(ctx *Encryption_specContext) {} + +// ExitEncryption_spec is called when production encryption_spec is exited. +func (s *BasePlSqlParserListener) ExitEncryption_spec(ctx *Encryption_specContext) {} + +// EnterTablespace is called when production tablespace is entered. +func (s *BasePlSqlParserListener) EnterTablespace(ctx *TablespaceContext) {} + +// ExitTablespace is called when production tablespace is exited. +func (s *BasePlSqlParserListener) ExitTablespace(ctx *TablespaceContext) {} + +// EnterVarray_item is called when production varray_item is entered. +func (s *BasePlSqlParserListener) EnterVarray_item(ctx *Varray_itemContext) {} + +// ExitVarray_item is called when production varray_item is exited. +func (s *BasePlSqlParserListener) ExitVarray_item(ctx *Varray_itemContext) {} + +// EnterColumn_properties is called when production column_properties is entered. +func (s *BasePlSqlParserListener) EnterColumn_properties(ctx *Column_propertiesContext) {} + +// ExitColumn_properties is called when production column_properties is exited. +func (s *BasePlSqlParserListener) ExitColumn_properties(ctx *Column_propertiesContext) {} + +// EnterLob_partition_storage is called when production lob_partition_storage is entered. +func (s *BasePlSqlParserListener) EnterLob_partition_storage(ctx *Lob_partition_storageContext) {} + +// ExitLob_partition_storage is called when production lob_partition_storage is exited. +func (s *BasePlSqlParserListener) ExitLob_partition_storage(ctx *Lob_partition_storageContext) {} + +// EnterPeriod_definition is called when production period_definition is entered. +func (s *BasePlSqlParserListener) EnterPeriod_definition(ctx *Period_definitionContext) {} + +// ExitPeriod_definition is called when production period_definition is exited. +func (s *BasePlSqlParserListener) ExitPeriod_definition(ctx *Period_definitionContext) {} + +// EnterStart_time_column is called when production start_time_column is entered. +func (s *BasePlSqlParserListener) EnterStart_time_column(ctx *Start_time_columnContext) {} + +// ExitStart_time_column is called when production start_time_column is exited. +func (s *BasePlSqlParserListener) ExitStart_time_column(ctx *Start_time_columnContext) {} + +// EnterEnd_time_column is called when production end_time_column is entered. +func (s *BasePlSqlParserListener) EnterEnd_time_column(ctx *End_time_columnContext) {} + +// ExitEnd_time_column is called when production end_time_column is exited. +func (s *BasePlSqlParserListener) ExitEnd_time_column(ctx *End_time_columnContext) {} + +// EnterColumn_definition is called when production column_definition is entered. +func (s *BasePlSqlParserListener) EnterColumn_definition(ctx *Column_definitionContext) {} + +// ExitColumn_definition is called when production column_definition is exited. +func (s *BasePlSqlParserListener) ExitColumn_definition(ctx *Column_definitionContext) {} + +// EnterColumn_collation_name is called when production column_collation_name is entered. +func (s *BasePlSqlParserListener) EnterColumn_collation_name(ctx *Column_collation_nameContext) {} + +// ExitColumn_collation_name is called when production column_collation_name is exited. +func (s *BasePlSqlParserListener) ExitColumn_collation_name(ctx *Column_collation_nameContext) {} + +// EnterIdentity_clause is called when production identity_clause is entered. +func (s *BasePlSqlParserListener) EnterIdentity_clause(ctx *Identity_clauseContext) {} + +// ExitIdentity_clause is called when production identity_clause is exited. +func (s *BasePlSqlParserListener) ExitIdentity_clause(ctx *Identity_clauseContext) {} + +// EnterIdentity_options_parentheses is called when production identity_options_parentheses is entered. +func (s *BasePlSqlParserListener) EnterIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) { +} + +// ExitIdentity_options_parentheses is called when production identity_options_parentheses is exited. +func (s *BasePlSqlParserListener) ExitIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) { +} + +// EnterIdentity_options is called when production identity_options is entered. +func (s *BasePlSqlParserListener) EnterIdentity_options(ctx *Identity_optionsContext) {} + +// ExitIdentity_options is called when production identity_options is exited. +func (s *BasePlSqlParserListener) ExitIdentity_options(ctx *Identity_optionsContext) {} + +// EnterVirtual_column_definition is called when production virtual_column_definition is entered. +func (s *BasePlSqlParserListener) EnterVirtual_column_definition(ctx *Virtual_column_definitionContext) { +} + +// ExitVirtual_column_definition is called when production virtual_column_definition is exited. +func (s *BasePlSqlParserListener) ExitVirtual_column_definition(ctx *Virtual_column_definitionContext) { +} + +// EnterAutogenerated_sequence_definition is called when production autogenerated_sequence_definition is entered. +func (s *BasePlSqlParserListener) EnterAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) { +} + +// ExitAutogenerated_sequence_definition is called when production autogenerated_sequence_definition is exited. +func (s *BasePlSqlParserListener) ExitAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) { +} + +// EnterEvaluation_edition_clause is called when production evaluation_edition_clause is entered. +func (s *BasePlSqlParserListener) EnterEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) { +} + +// ExitEvaluation_edition_clause is called when production evaluation_edition_clause is exited. +func (s *BasePlSqlParserListener) ExitEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) { +} + +// EnterOut_of_line_part_storage is called when production out_of_line_part_storage is entered. +func (s *BasePlSqlParserListener) EnterOut_of_line_part_storage(ctx *Out_of_line_part_storageContext) { +} + +// ExitOut_of_line_part_storage is called when production out_of_line_part_storage is exited. +func (s *BasePlSqlParserListener) ExitOut_of_line_part_storage(ctx *Out_of_line_part_storageContext) { +} + +// EnterNested_table_col_properties is called when production nested_table_col_properties is entered. +func (s *BasePlSqlParserListener) EnterNested_table_col_properties(ctx *Nested_table_col_propertiesContext) { +} + +// ExitNested_table_col_properties is called when production nested_table_col_properties is exited. +func (s *BasePlSqlParserListener) ExitNested_table_col_properties(ctx *Nested_table_col_propertiesContext) { +} + +// EnterNested_item is called when production nested_item is entered. +func (s *BasePlSqlParserListener) EnterNested_item(ctx *Nested_itemContext) {} + +// ExitNested_item is called when production nested_item is exited. +func (s *BasePlSqlParserListener) ExitNested_item(ctx *Nested_itemContext) {} + +// EnterSubstitutable_column_clause is called when production substitutable_column_clause is entered. +func (s *BasePlSqlParserListener) EnterSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) { +} + +// ExitSubstitutable_column_clause is called when production substitutable_column_clause is exited. +func (s *BasePlSqlParserListener) ExitSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) { +} + +// EnterPartition_name is called when production partition_name is entered. +func (s *BasePlSqlParserListener) EnterPartition_name(ctx *Partition_nameContext) {} + +// ExitPartition_name is called when production partition_name is exited. +func (s *BasePlSqlParserListener) ExitPartition_name(ctx *Partition_nameContext) {} + +// EnterSupplemental_logging_props is called when production supplemental_logging_props is entered. +func (s *BasePlSqlParserListener) EnterSupplemental_logging_props(ctx *Supplemental_logging_propsContext) { +} + +// ExitSupplemental_logging_props is called when production supplemental_logging_props is exited. +func (s *BasePlSqlParserListener) ExitSupplemental_logging_props(ctx *Supplemental_logging_propsContext) { +} + +// EnterColumn_or_attribute is called when production column_or_attribute is entered. +func (s *BasePlSqlParserListener) EnterColumn_or_attribute(ctx *Column_or_attributeContext) {} + +// ExitColumn_or_attribute is called when production column_or_attribute is exited. +func (s *BasePlSqlParserListener) ExitColumn_or_attribute(ctx *Column_or_attributeContext) {} + +// EnterObject_type_col_properties is called when production object_type_col_properties is entered. +func (s *BasePlSqlParserListener) EnterObject_type_col_properties(ctx *Object_type_col_propertiesContext) { +} + +// ExitObject_type_col_properties is called when production object_type_col_properties is exited. +func (s *BasePlSqlParserListener) ExitObject_type_col_properties(ctx *Object_type_col_propertiesContext) { +} + +// EnterConstraint_clauses is called when production constraint_clauses is entered. +func (s *BasePlSqlParserListener) EnterConstraint_clauses(ctx *Constraint_clausesContext) {} + +// ExitConstraint_clauses is called when production constraint_clauses is exited. +func (s *BasePlSqlParserListener) ExitConstraint_clauses(ctx *Constraint_clausesContext) {} + +// EnterOld_constraint_name is called when production old_constraint_name is entered. +func (s *BasePlSqlParserListener) EnterOld_constraint_name(ctx *Old_constraint_nameContext) {} + +// ExitOld_constraint_name is called when production old_constraint_name is exited. +func (s *BasePlSqlParserListener) ExitOld_constraint_name(ctx *Old_constraint_nameContext) {} + +// EnterNew_constraint_name is called when production new_constraint_name is entered. +func (s *BasePlSqlParserListener) EnterNew_constraint_name(ctx *New_constraint_nameContext) {} + +// ExitNew_constraint_name is called when production new_constraint_name is exited. +func (s *BasePlSqlParserListener) ExitNew_constraint_name(ctx *New_constraint_nameContext) {} + +// EnterDrop_constraint_clause is called when production drop_constraint_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_constraint_clause(ctx *Drop_constraint_clauseContext) {} + +// ExitDrop_constraint_clause is called when production drop_constraint_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_constraint_clause(ctx *Drop_constraint_clauseContext) {} + +// EnterDrop_primary_key_or_unique_or_generic_clause is called when production drop_primary_key_or_unique_or_generic_clause is entered. +func (s *BasePlSqlParserListener) EnterDrop_primary_key_or_unique_or_generic_clause(ctx *Drop_primary_key_or_unique_or_generic_clauseContext) { +} + +// ExitDrop_primary_key_or_unique_or_generic_clause is called when production drop_primary_key_or_unique_or_generic_clause is exited. +func (s *BasePlSqlParserListener) ExitDrop_primary_key_or_unique_or_generic_clause(ctx *Drop_primary_key_or_unique_or_generic_clauseContext) { +} + +// EnterAdd_constraint is called when production add_constraint is entered. +func (s *BasePlSqlParserListener) EnterAdd_constraint(ctx *Add_constraintContext) {} + +// ExitAdd_constraint is called when production add_constraint is exited. +func (s *BasePlSqlParserListener) ExitAdd_constraint(ctx *Add_constraintContext) {} + +// EnterAdd_constraint_clause is called when production add_constraint_clause is entered. +func (s *BasePlSqlParserListener) EnterAdd_constraint_clause(ctx *Add_constraint_clauseContext) {} + +// ExitAdd_constraint_clause is called when production add_constraint_clause is exited. +func (s *BasePlSqlParserListener) ExitAdd_constraint_clause(ctx *Add_constraint_clauseContext) {} + +// EnterCheck_constraint is called when production check_constraint is entered. +func (s *BasePlSqlParserListener) EnterCheck_constraint(ctx *Check_constraintContext) {} + +// ExitCheck_constraint is called when production check_constraint is exited. +func (s *BasePlSqlParserListener) ExitCheck_constraint(ctx *Check_constraintContext) {} + +// EnterDrop_constraint is called when production drop_constraint is entered. +func (s *BasePlSqlParserListener) EnterDrop_constraint(ctx *Drop_constraintContext) {} + +// ExitDrop_constraint is called when production drop_constraint is exited. +func (s *BasePlSqlParserListener) ExitDrop_constraint(ctx *Drop_constraintContext) {} + +// EnterEnable_constraint is called when production enable_constraint is entered. +func (s *BasePlSqlParserListener) EnterEnable_constraint(ctx *Enable_constraintContext) {} + +// ExitEnable_constraint is called when production enable_constraint is exited. +func (s *BasePlSqlParserListener) ExitEnable_constraint(ctx *Enable_constraintContext) {} + +// EnterDisable_constraint is called when production disable_constraint is entered. +func (s *BasePlSqlParserListener) EnterDisable_constraint(ctx *Disable_constraintContext) {} + +// ExitDisable_constraint is called when production disable_constraint is exited. +func (s *BasePlSqlParserListener) ExitDisable_constraint(ctx *Disable_constraintContext) {} + +// EnterForeign_key_clause is called when production foreign_key_clause is entered. +func (s *BasePlSqlParserListener) EnterForeign_key_clause(ctx *Foreign_key_clauseContext) {} + +// ExitForeign_key_clause is called when production foreign_key_clause is exited. +func (s *BasePlSqlParserListener) ExitForeign_key_clause(ctx *Foreign_key_clauseContext) {} + +// EnterReferences_clause is called when production references_clause is entered. +func (s *BasePlSqlParserListener) EnterReferences_clause(ctx *References_clauseContext) {} + +// ExitReferences_clause is called when production references_clause is exited. +func (s *BasePlSqlParserListener) ExitReferences_clause(ctx *References_clauseContext) {} + +// EnterOn_delete_clause is called when production on_delete_clause is entered. +func (s *BasePlSqlParserListener) EnterOn_delete_clause(ctx *On_delete_clauseContext) {} + +// ExitOn_delete_clause is called when production on_delete_clause is exited. +func (s *BasePlSqlParserListener) ExitOn_delete_clause(ctx *On_delete_clauseContext) {} + +// EnterUnique_key_clause is called when production unique_key_clause is entered. +func (s *BasePlSqlParserListener) EnterUnique_key_clause(ctx *Unique_key_clauseContext) {} + +// ExitUnique_key_clause is called when production unique_key_clause is exited. +func (s *BasePlSqlParserListener) ExitUnique_key_clause(ctx *Unique_key_clauseContext) {} + +// EnterPrimary_key_clause is called when production primary_key_clause is entered. +func (s *BasePlSqlParserListener) EnterPrimary_key_clause(ctx *Primary_key_clauseContext) {} + +// ExitPrimary_key_clause is called when production primary_key_clause is exited. +func (s *BasePlSqlParserListener) ExitPrimary_key_clause(ctx *Primary_key_clauseContext) {} + +// EnterAnonymous_block is called when production anonymous_block is entered. +func (s *BasePlSqlParserListener) EnterAnonymous_block(ctx *Anonymous_blockContext) {} + +// ExitAnonymous_block is called when production anonymous_block is exited. +func (s *BasePlSqlParserListener) ExitAnonymous_block(ctx *Anonymous_blockContext) {} + +// EnterInvoker_rights_clause is called when production invoker_rights_clause is entered. +func (s *BasePlSqlParserListener) EnterInvoker_rights_clause(ctx *Invoker_rights_clauseContext) {} + +// ExitInvoker_rights_clause is called when production invoker_rights_clause is exited. +func (s *BasePlSqlParserListener) ExitInvoker_rights_clause(ctx *Invoker_rights_clauseContext) {} + +// EnterCall_spec is called when production call_spec is entered. +func (s *BasePlSqlParserListener) EnterCall_spec(ctx *Call_specContext) {} + +// ExitCall_spec is called when production call_spec is exited. +func (s *BasePlSqlParserListener) ExitCall_spec(ctx *Call_specContext) {} + +// EnterJava_spec is called when production java_spec is entered. +func (s *BasePlSqlParserListener) EnterJava_spec(ctx *Java_specContext) {} + +// ExitJava_spec is called when production java_spec is exited. +func (s *BasePlSqlParserListener) ExitJava_spec(ctx *Java_specContext) {} + +// EnterC_spec is called when production c_spec is entered. +func (s *BasePlSqlParserListener) EnterC_spec(ctx *C_specContext) {} + +// ExitC_spec is called when production c_spec is exited. +func (s *BasePlSqlParserListener) ExitC_spec(ctx *C_specContext) {} + +// EnterC_agent_in_clause is called when production c_agent_in_clause is entered. +func (s *BasePlSqlParserListener) EnterC_agent_in_clause(ctx *C_agent_in_clauseContext) {} + +// ExitC_agent_in_clause is called when production c_agent_in_clause is exited. +func (s *BasePlSqlParserListener) ExitC_agent_in_clause(ctx *C_agent_in_clauseContext) {} + +// EnterC_parameters_clause is called when production c_parameters_clause is entered. +func (s *BasePlSqlParserListener) EnterC_parameters_clause(ctx *C_parameters_clauseContext) {} + +// ExitC_parameters_clause is called when production c_parameters_clause is exited. +func (s *BasePlSqlParserListener) ExitC_parameters_clause(ctx *C_parameters_clauseContext) {} + +// EnterParameter is called when production parameter is entered. +func (s *BasePlSqlParserListener) EnterParameter(ctx *ParameterContext) {} + +// ExitParameter is called when production parameter is exited. +func (s *BasePlSqlParserListener) ExitParameter(ctx *ParameterContext) {} + +// EnterDefault_value_part is called when production default_value_part is entered. +func (s *BasePlSqlParserListener) EnterDefault_value_part(ctx *Default_value_partContext) {} + +// ExitDefault_value_part is called when production default_value_part is exited. +func (s *BasePlSqlParserListener) ExitDefault_value_part(ctx *Default_value_partContext) {} + +// EnterSeq_of_declare_specs is called when production seq_of_declare_specs is entered. +func (s *BasePlSqlParserListener) EnterSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) {} + +// ExitSeq_of_declare_specs is called when production seq_of_declare_specs is exited. +func (s *BasePlSqlParserListener) ExitSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) {} + +// EnterDeclare_spec is called when production declare_spec is entered. +func (s *BasePlSqlParserListener) EnterDeclare_spec(ctx *Declare_specContext) {} + +// ExitDeclare_spec is called when production declare_spec is exited. +func (s *BasePlSqlParserListener) ExitDeclare_spec(ctx *Declare_specContext) {} + +// EnterVariable_declaration is called when production variable_declaration is entered. +func (s *BasePlSqlParserListener) EnterVariable_declaration(ctx *Variable_declarationContext) {} + +// ExitVariable_declaration is called when production variable_declaration is exited. +func (s *BasePlSqlParserListener) ExitVariable_declaration(ctx *Variable_declarationContext) {} + +// EnterSubtype_declaration is called when production subtype_declaration is entered. +func (s *BasePlSqlParserListener) EnterSubtype_declaration(ctx *Subtype_declarationContext) {} + +// ExitSubtype_declaration is called when production subtype_declaration is exited. +func (s *BasePlSqlParserListener) ExitSubtype_declaration(ctx *Subtype_declarationContext) {} + +// EnterCursor_declaration is called when production cursor_declaration is entered. +func (s *BasePlSqlParserListener) EnterCursor_declaration(ctx *Cursor_declarationContext) {} + +// ExitCursor_declaration is called when production cursor_declaration is exited. +func (s *BasePlSqlParserListener) ExitCursor_declaration(ctx *Cursor_declarationContext) {} + +// EnterParameter_spec is called when production parameter_spec is entered. +func (s *BasePlSqlParserListener) EnterParameter_spec(ctx *Parameter_specContext) {} + +// ExitParameter_spec is called when production parameter_spec is exited. +func (s *BasePlSqlParserListener) ExitParameter_spec(ctx *Parameter_specContext) {} + +// EnterException_declaration is called when production exception_declaration is entered. +func (s *BasePlSqlParserListener) EnterException_declaration(ctx *Exception_declarationContext) {} + +// ExitException_declaration is called when production exception_declaration is exited. +func (s *BasePlSqlParserListener) ExitException_declaration(ctx *Exception_declarationContext) {} + +// EnterPragma_declaration is called when production pragma_declaration is entered. +func (s *BasePlSqlParserListener) EnterPragma_declaration(ctx *Pragma_declarationContext) {} + +// ExitPragma_declaration is called when production pragma_declaration is exited. +func (s *BasePlSqlParserListener) ExitPragma_declaration(ctx *Pragma_declarationContext) {} + +// EnterRecord_type_def is called when production record_type_def is entered. +func (s *BasePlSqlParserListener) EnterRecord_type_def(ctx *Record_type_defContext) {} + +// ExitRecord_type_def is called when production record_type_def is exited. +func (s *BasePlSqlParserListener) ExitRecord_type_def(ctx *Record_type_defContext) {} + +// EnterField_spec is called when production field_spec is entered. +func (s *BasePlSqlParserListener) EnterField_spec(ctx *Field_specContext) {} + +// ExitField_spec is called when production field_spec is exited. +func (s *BasePlSqlParserListener) ExitField_spec(ctx *Field_specContext) {} + +// EnterRef_cursor_type_def is called when production ref_cursor_type_def is entered. +func (s *BasePlSqlParserListener) EnterRef_cursor_type_def(ctx *Ref_cursor_type_defContext) {} + +// ExitRef_cursor_type_def is called when production ref_cursor_type_def is exited. +func (s *BasePlSqlParserListener) ExitRef_cursor_type_def(ctx *Ref_cursor_type_defContext) {} + +// EnterType_declaration is called when production type_declaration is entered. +func (s *BasePlSqlParserListener) EnterType_declaration(ctx *Type_declarationContext) {} + +// ExitType_declaration is called when production type_declaration is exited. +func (s *BasePlSqlParserListener) ExitType_declaration(ctx *Type_declarationContext) {} + +// EnterTable_type_def is called when production table_type_def is entered. +func (s *BasePlSqlParserListener) EnterTable_type_def(ctx *Table_type_defContext) {} + +// ExitTable_type_def is called when production table_type_def is exited. +func (s *BasePlSqlParserListener) ExitTable_type_def(ctx *Table_type_defContext) {} + +// EnterTable_indexed_by_part is called when production table_indexed_by_part is entered. +func (s *BasePlSqlParserListener) EnterTable_indexed_by_part(ctx *Table_indexed_by_partContext) {} + +// ExitTable_indexed_by_part is called when production table_indexed_by_part is exited. +func (s *BasePlSqlParserListener) ExitTable_indexed_by_part(ctx *Table_indexed_by_partContext) {} + +// EnterVarray_type_def is called when production varray_type_def is entered. +func (s *BasePlSqlParserListener) EnterVarray_type_def(ctx *Varray_type_defContext) {} + +// ExitVarray_type_def is called when production varray_type_def is exited. +func (s *BasePlSqlParserListener) ExitVarray_type_def(ctx *Varray_type_defContext) {} + +// EnterSeq_of_statements is called when production seq_of_statements is entered. +func (s *BasePlSqlParserListener) EnterSeq_of_statements(ctx *Seq_of_statementsContext) {} + +// ExitSeq_of_statements is called when production seq_of_statements is exited. +func (s *BasePlSqlParserListener) ExitSeq_of_statements(ctx *Seq_of_statementsContext) {} + +// EnterLabel_declaration is called when production label_declaration is entered. +func (s *BasePlSqlParserListener) EnterLabel_declaration(ctx *Label_declarationContext) {} + +// ExitLabel_declaration is called when production label_declaration is exited. +func (s *BasePlSqlParserListener) ExitLabel_declaration(ctx *Label_declarationContext) {} + +// EnterStatement is called when production statement is entered. +func (s *BasePlSqlParserListener) EnterStatement(ctx *StatementContext) {} + +// ExitStatement is called when production statement is exited. +func (s *BasePlSqlParserListener) ExitStatement(ctx *StatementContext) {} + +// EnterSwallow_to_semi is called when production swallow_to_semi is entered. +func (s *BasePlSqlParserListener) EnterSwallow_to_semi(ctx *Swallow_to_semiContext) {} + +// ExitSwallow_to_semi is called when production swallow_to_semi is exited. +func (s *BasePlSqlParserListener) ExitSwallow_to_semi(ctx *Swallow_to_semiContext) {} + +// EnterAssignment_statement is called when production assignment_statement is entered. +func (s *BasePlSqlParserListener) EnterAssignment_statement(ctx *Assignment_statementContext) {} + +// ExitAssignment_statement is called when production assignment_statement is exited. +func (s *BasePlSqlParserListener) ExitAssignment_statement(ctx *Assignment_statementContext) {} + +// EnterContinue_statement is called when production continue_statement is entered. +func (s *BasePlSqlParserListener) EnterContinue_statement(ctx *Continue_statementContext) {} + +// ExitContinue_statement is called when production continue_statement is exited. +func (s *BasePlSqlParserListener) ExitContinue_statement(ctx *Continue_statementContext) {} + +// EnterExit_statement is called when production exit_statement is entered. +func (s *BasePlSqlParserListener) EnterExit_statement(ctx *Exit_statementContext) {} + +// ExitExit_statement is called when production exit_statement is exited. +func (s *BasePlSqlParserListener) ExitExit_statement(ctx *Exit_statementContext) {} + +// EnterGoto_statement is called when production goto_statement is entered. +func (s *BasePlSqlParserListener) EnterGoto_statement(ctx *Goto_statementContext) {} + +// ExitGoto_statement is called when production goto_statement is exited. +func (s *BasePlSqlParserListener) ExitGoto_statement(ctx *Goto_statementContext) {} + +// EnterIf_statement is called when production if_statement is entered. +func (s *BasePlSqlParserListener) EnterIf_statement(ctx *If_statementContext) {} + +// ExitIf_statement is called when production if_statement is exited. +func (s *BasePlSqlParserListener) ExitIf_statement(ctx *If_statementContext) {} + +// EnterElsif_part is called when production elsif_part is entered. +func (s *BasePlSqlParserListener) EnterElsif_part(ctx *Elsif_partContext) {} + +// ExitElsif_part is called when production elsif_part is exited. +func (s *BasePlSqlParserListener) ExitElsif_part(ctx *Elsif_partContext) {} + +// EnterElse_part is called when production else_part is entered. +func (s *BasePlSqlParserListener) EnterElse_part(ctx *Else_partContext) {} + +// ExitElse_part is called when production else_part is exited. +func (s *BasePlSqlParserListener) ExitElse_part(ctx *Else_partContext) {} + +// EnterLoop_statement is called when production loop_statement is entered. +func (s *BasePlSqlParserListener) EnterLoop_statement(ctx *Loop_statementContext) {} + +// ExitLoop_statement is called when production loop_statement is exited. +func (s *BasePlSqlParserListener) ExitLoop_statement(ctx *Loop_statementContext) {} + +// EnterCursor_loop_param is called when production cursor_loop_param is entered. +func (s *BasePlSqlParserListener) EnterCursor_loop_param(ctx *Cursor_loop_paramContext) {} + +// ExitCursor_loop_param is called when production cursor_loop_param is exited. +func (s *BasePlSqlParserListener) ExitCursor_loop_param(ctx *Cursor_loop_paramContext) {} + +// EnterForall_statement is called when production forall_statement is entered. +func (s *BasePlSqlParserListener) EnterForall_statement(ctx *Forall_statementContext) {} + +// ExitForall_statement is called when production forall_statement is exited. +func (s *BasePlSqlParserListener) ExitForall_statement(ctx *Forall_statementContext) {} + +// EnterBounds_clause is called when production bounds_clause is entered. +func (s *BasePlSqlParserListener) EnterBounds_clause(ctx *Bounds_clauseContext) {} + +// ExitBounds_clause is called when production bounds_clause is exited. +func (s *BasePlSqlParserListener) ExitBounds_clause(ctx *Bounds_clauseContext) {} + +// EnterBetween_bound is called when production between_bound is entered. +func (s *BasePlSqlParserListener) EnterBetween_bound(ctx *Between_boundContext) {} + +// ExitBetween_bound is called when production between_bound is exited. +func (s *BasePlSqlParserListener) ExitBetween_bound(ctx *Between_boundContext) {} + +// EnterLower_bound is called when production lower_bound is entered. +func (s *BasePlSqlParserListener) EnterLower_bound(ctx *Lower_boundContext) {} + +// ExitLower_bound is called when production lower_bound is exited. +func (s *BasePlSqlParserListener) ExitLower_bound(ctx *Lower_boundContext) {} + +// EnterUpper_bound is called when production upper_bound is entered. +func (s *BasePlSqlParserListener) EnterUpper_bound(ctx *Upper_boundContext) {} + +// ExitUpper_bound is called when production upper_bound is exited. +func (s *BasePlSqlParserListener) ExitUpper_bound(ctx *Upper_boundContext) {} + +// EnterNull_statement is called when production null_statement is entered. +func (s *BasePlSqlParserListener) EnterNull_statement(ctx *Null_statementContext) {} + +// ExitNull_statement is called when production null_statement is exited. +func (s *BasePlSqlParserListener) ExitNull_statement(ctx *Null_statementContext) {} + +// EnterRaise_statement is called when production raise_statement is entered. +func (s *BasePlSqlParserListener) EnterRaise_statement(ctx *Raise_statementContext) {} + +// ExitRaise_statement is called when production raise_statement is exited. +func (s *BasePlSqlParserListener) ExitRaise_statement(ctx *Raise_statementContext) {} + +// EnterReturn_statement is called when production return_statement is entered. +func (s *BasePlSqlParserListener) EnterReturn_statement(ctx *Return_statementContext) {} + +// ExitReturn_statement is called when production return_statement is exited. +func (s *BasePlSqlParserListener) ExitReturn_statement(ctx *Return_statementContext) {} + +// EnterCall_statement is called when production call_statement is entered. +func (s *BasePlSqlParserListener) EnterCall_statement(ctx *Call_statementContext) {} + +// ExitCall_statement is called when production call_statement is exited. +func (s *BasePlSqlParserListener) ExitCall_statement(ctx *Call_statementContext) {} + +// EnterPipe_row_statement is called when production pipe_row_statement is entered. +func (s *BasePlSqlParserListener) EnterPipe_row_statement(ctx *Pipe_row_statementContext) {} + +// ExitPipe_row_statement is called when production pipe_row_statement is exited. +func (s *BasePlSqlParserListener) ExitPipe_row_statement(ctx *Pipe_row_statementContext) {} + +// EnterBody is called when production body is entered. +func (s *BasePlSqlParserListener) EnterBody(ctx *BodyContext) {} + +// ExitBody is called when production body is exited. +func (s *BasePlSqlParserListener) ExitBody(ctx *BodyContext) {} + +// EnterException_handler is called when production exception_handler is entered. +func (s *BasePlSqlParserListener) EnterException_handler(ctx *Exception_handlerContext) {} + +// ExitException_handler is called when production exception_handler is exited. +func (s *BasePlSqlParserListener) ExitException_handler(ctx *Exception_handlerContext) {} + +// EnterTrigger_block is called when production trigger_block is entered. +func (s *BasePlSqlParserListener) EnterTrigger_block(ctx *Trigger_blockContext) {} + +// ExitTrigger_block is called when production trigger_block is exited. +func (s *BasePlSqlParserListener) ExitTrigger_block(ctx *Trigger_blockContext) {} + +// EnterBlock is called when production block is entered. +func (s *BasePlSqlParserListener) EnterBlock(ctx *BlockContext) {} + +// ExitBlock is called when production block is exited. +func (s *BasePlSqlParserListener) ExitBlock(ctx *BlockContext) {} + +// EnterSql_statement is called when production sql_statement is entered. +func (s *BasePlSqlParserListener) EnterSql_statement(ctx *Sql_statementContext) {} + +// ExitSql_statement is called when production sql_statement is exited. +func (s *BasePlSqlParserListener) ExitSql_statement(ctx *Sql_statementContext) {} + +// EnterExecute_immediate is called when production execute_immediate is entered. +func (s *BasePlSqlParserListener) EnterExecute_immediate(ctx *Execute_immediateContext) {} + +// ExitExecute_immediate is called when production execute_immediate is exited. +func (s *BasePlSqlParserListener) ExitExecute_immediate(ctx *Execute_immediateContext) {} + +// EnterDynamic_returning_clause is called when production dynamic_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) { +} + +// ExitDynamic_returning_clause is called when production dynamic_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) { +} + +// EnterData_manipulation_language_statements is called when production data_manipulation_language_statements is entered. +func (s *BasePlSqlParserListener) EnterData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) { +} + +// ExitData_manipulation_language_statements is called when production data_manipulation_language_statements is exited. +func (s *BasePlSqlParserListener) ExitData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) { +} + +// EnterCursor_manipulation_statements is called when production cursor_manipulation_statements is entered. +func (s *BasePlSqlParserListener) EnterCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) { +} + +// ExitCursor_manipulation_statements is called when production cursor_manipulation_statements is exited. +func (s *BasePlSqlParserListener) ExitCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) { +} + +// EnterClose_statement is called when production close_statement is entered. +func (s *BasePlSqlParserListener) EnterClose_statement(ctx *Close_statementContext) {} + +// ExitClose_statement is called when production close_statement is exited. +func (s *BasePlSqlParserListener) ExitClose_statement(ctx *Close_statementContext) {} + +// EnterOpen_statement is called when production open_statement is entered. +func (s *BasePlSqlParserListener) EnterOpen_statement(ctx *Open_statementContext) {} + +// ExitOpen_statement is called when production open_statement is exited. +func (s *BasePlSqlParserListener) ExitOpen_statement(ctx *Open_statementContext) {} + +// EnterFetch_statement is called when production fetch_statement is entered. +func (s *BasePlSqlParserListener) EnterFetch_statement(ctx *Fetch_statementContext) {} + +// ExitFetch_statement is called when production fetch_statement is exited. +func (s *BasePlSqlParserListener) ExitFetch_statement(ctx *Fetch_statementContext) {} + +// EnterOpen_for_statement is called when production open_for_statement is entered. +func (s *BasePlSqlParserListener) EnterOpen_for_statement(ctx *Open_for_statementContext) {} + +// ExitOpen_for_statement is called when production open_for_statement is exited. +func (s *BasePlSqlParserListener) ExitOpen_for_statement(ctx *Open_for_statementContext) {} + +// EnterTransaction_control_statements is called when production transaction_control_statements is entered. +func (s *BasePlSqlParserListener) EnterTransaction_control_statements(ctx *Transaction_control_statementsContext) { +} + +// ExitTransaction_control_statements is called when production transaction_control_statements is exited. +func (s *BasePlSqlParserListener) ExitTransaction_control_statements(ctx *Transaction_control_statementsContext) { +} + +// EnterSet_transaction_command is called when production set_transaction_command is entered. +func (s *BasePlSqlParserListener) EnterSet_transaction_command(ctx *Set_transaction_commandContext) {} + +// ExitSet_transaction_command is called when production set_transaction_command is exited. +func (s *BasePlSqlParserListener) ExitSet_transaction_command(ctx *Set_transaction_commandContext) {} + +// EnterSet_constraint_command is called when production set_constraint_command is entered. +func (s *BasePlSqlParserListener) EnterSet_constraint_command(ctx *Set_constraint_commandContext) {} + +// ExitSet_constraint_command is called when production set_constraint_command is exited. +func (s *BasePlSqlParserListener) ExitSet_constraint_command(ctx *Set_constraint_commandContext) {} + +// EnterCommit_statement is called when production commit_statement is entered. +func (s *BasePlSqlParserListener) EnterCommit_statement(ctx *Commit_statementContext) {} + +// ExitCommit_statement is called when production commit_statement is exited. +func (s *BasePlSqlParserListener) ExitCommit_statement(ctx *Commit_statementContext) {} + +// EnterWrite_clause is called when production write_clause is entered. +func (s *BasePlSqlParserListener) EnterWrite_clause(ctx *Write_clauseContext) {} + +// ExitWrite_clause is called when production write_clause is exited. +func (s *BasePlSqlParserListener) ExitWrite_clause(ctx *Write_clauseContext) {} + +// EnterRollback_statement is called when production rollback_statement is entered. +func (s *BasePlSqlParserListener) EnterRollback_statement(ctx *Rollback_statementContext) {} + +// ExitRollback_statement is called when production rollback_statement is exited. +func (s *BasePlSqlParserListener) ExitRollback_statement(ctx *Rollback_statementContext) {} + +// EnterSavepoint_statement is called when production savepoint_statement is entered. +func (s *BasePlSqlParserListener) EnterSavepoint_statement(ctx *Savepoint_statementContext) {} + +// ExitSavepoint_statement is called when production savepoint_statement is exited. +func (s *BasePlSqlParserListener) ExitSavepoint_statement(ctx *Savepoint_statementContext) {} + +// EnterExplain_statement is called when production explain_statement is entered. +func (s *BasePlSqlParserListener) EnterExplain_statement(ctx *Explain_statementContext) {} + +// ExitExplain_statement is called when production explain_statement is exited. +func (s *BasePlSqlParserListener) ExitExplain_statement(ctx *Explain_statementContext) {} + +// EnterSelect_only_statement is called when production select_only_statement is entered. +func (s *BasePlSqlParserListener) EnterSelect_only_statement(ctx *Select_only_statementContext) {} + +// ExitSelect_only_statement is called when production select_only_statement is exited. +func (s *BasePlSqlParserListener) ExitSelect_only_statement(ctx *Select_only_statementContext) {} + +// EnterSelect_statement is called when production select_statement is entered. +func (s *BasePlSqlParserListener) EnterSelect_statement(ctx *Select_statementContext) {} + +// ExitSelect_statement is called when production select_statement is exited. +func (s *BasePlSqlParserListener) ExitSelect_statement(ctx *Select_statementContext) {} + +// EnterSubquery_factoring_clause is called when production subquery_factoring_clause is entered. +func (s *BasePlSqlParserListener) EnterSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) { +} + +// ExitSubquery_factoring_clause is called when production subquery_factoring_clause is exited. +func (s *BasePlSqlParserListener) ExitSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) { +} + +// EnterFactoring_element is called when production factoring_element is entered. +func (s *BasePlSqlParserListener) EnterFactoring_element(ctx *Factoring_elementContext) {} + +// ExitFactoring_element is called when production factoring_element is exited. +func (s *BasePlSqlParserListener) ExitFactoring_element(ctx *Factoring_elementContext) {} + +// EnterSearch_clause is called when production search_clause is entered. +func (s *BasePlSqlParserListener) EnterSearch_clause(ctx *Search_clauseContext) {} + +// ExitSearch_clause is called when production search_clause is exited. +func (s *BasePlSqlParserListener) ExitSearch_clause(ctx *Search_clauseContext) {} + +// EnterCycle_clause is called when production cycle_clause is entered. +func (s *BasePlSqlParserListener) EnterCycle_clause(ctx *Cycle_clauseContext) {} + +// ExitCycle_clause is called when production cycle_clause is exited. +func (s *BasePlSqlParserListener) ExitCycle_clause(ctx *Cycle_clauseContext) {} + +// EnterSubquery is called when production subquery is entered. +func (s *BasePlSqlParserListener) EnterSubquery(ctx *SubqueryContext) {} + +// ExitSubquery is called when production subquery is exited. +func (s *BasePlSqlParserListener) ExitSubquery(ctx *SubqueryContext) {} + +// EnterSubquery_basic_elements is called when production subquery_basic_elements is entered. +func (s *BasePlSqlParserListener) EnterSubquery_basic_elements(ctx *Subquery_basic_elementsContext) {} + +// ExitSubquery_basic_elements is called when production subquery_basic_elements is exited. +func (s *BasePlSqlParserListener) ExitSubquery_basic_elements(ctx *Subquery_basic_elementsContext) {} + +// EnterSubquery_operation_part is called when production subquery_operation_part is entered. +func (s *BasePlSqlParserListener) EnterSubquery_operation_part(ctx *Subquery_operation_partContext) {} + +// ExitSubquery_operation_part is called when production subquery_operation_part is exited. +func (s *BasePlSqlParserListener) ExitSubquery_operation_part(ctx *Subquery_operation_partContext) {} + +// EnterQuery_block is called when production query_block is entered. +func (s *BasePlSqlParserListener) EnterQuery_block(ctx *Query_blockContext) {} + +// ExitQuery_block is called when production query_block is exited. +func (s *BasePlSqlParserListener) ExitQuery_block(ctx *Query_blockContext) {} + +// EnterSelected_list is called when production selected_list is entered. +func (s *BasePlSqlParserListener) EnterSelected_list(ctx *Selected_listContext) {} + +// ExitSelected_list is called when production selected_list is exited. +func (s *BasePlSqlParserListener) ExitSelected_list(ctx *Selected_listContext) {} + +// EnterFrom_clause is called when production from_clause is entered. +func (s *BasePlSqlParserListener) EnterFrom_clause(ctx *From_clauseContext) {} + +// ExitFrom_clause is called when production from_clause is exited. +func (s *BasePlSqlParserListener) ExitFrom_clause(ctx *From_clauseContext) {} + +// EnterSelect_list_elements is called when production select_list_elements is entered. +func (s *BasePlSqlParserListener) EnterSelect_list_elements(ctx *Select_list_elementsContext) {} + +// ExitSelect_list_elements is called when production select_list_elements is exited. +func (s *BasePlSqlParserListener) ExitSelect_list_elements(ctx *Select_list_elementsContext) {} + +// EnterTable_wild is called when production table_wild is entered. +func (s *BasePlSqlParserListener) EnterTable_wild(ctx *Table_wildContext) {} + +// ExitTable_wild is called when production table_wild is exited. +func (s *BasePlSqlParserListener) ExitTable_wild(ctx *Table_wildContext) {} + +// EnterTable_ref_list is called when production table_ref_list is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_list(ctx *Table_ref_listContext) {} + +// ExitTable_ref_list is called when production table_ref_list is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_list(ctx *Table_ref_listContext) {} + +// EnterTable_ref is called when production table_ref is entered. +func (s *BasePlSqlParserListener) EnterTable_ref(ctx *Table_refContext) {} + +// ExitTable_ref is called when production table_ref is exited. +func (s *BasePlSqlParserListener) ExitTable_ref(ctx *Table_refContext) {} + +// EnterTable_ref_aux is called when production table_ref_aux is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux(ctx *Table_ref_auxContext) {} + +// ExitTable_ref_aux is called when production table_ref_aux is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux(ctx *Table_ref_auxContext) {} + +// EnterTable_ref_aux_internal_one is called when production table_ref_aux_internal_one is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) { +} + +// ExitTable_ref_aux_internal_one is called when production table_ref_aux_internal_one is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) { +} + +// EnterTable_ref_aux_internal_two is called when production table_ref_aux_internal_two is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) { +} + +// ExitTable_ref_aux_internal_two is called when production table_ref_aux_internal_two is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) { +} + +// EnterTable_ref_aux_internal_three is called when production table_ref_aux_internal_three is entered. +func (s *BasePlSqlParserListener) EnterTable_ref_aux_internal_three(ctx *Table_ref_aux_internal_threeContext) { +} + +// ExitTable_ref_aux_internal_three is called when production table_ref_aux_internal_three is exited. +func (s *BasePlSqlParserListener) ExitTable_ref_aux_internal_three(ctx *Table_ref_aux_internal_threeContext) { +} + +// EnterJoin_clause is called when production join_clause is entered. +func (s *BasePlSqlParserListener) EnterJoin_clause(ctx *Join_clauseContext) {} + +// ExitJoin_clause is called when production join_clause is exited. +func (s *BasePlSqlParserListener) ExitJoin_clause(ctx *Join_clauseContext) {} + +// EnterJoin_on_part is called when production join_on_part is entered. +func (s *BasePlSqlParserListener) EnterJoin_on_part(ctx *Join_on_partContext) {} + +// ExitJoin_on_part is called when production join_on_part is exited. +func (s *BasePlSqlParserListener) ExitJoin_on_part(ctx *Join_on_partContext) {} + +// EnterJoin_using_part is called when production join_using_part is entered. +func (s *BasePlSqlParserListener) EnterJoin_using_part(ctx *Join_using_partContext) {} + +// ExitJoin_using_part is called when production join_using_part is exited. +func (s *BasePlSqlParserListener) ExitJoin_using_part(ctx *Join_using_partContext) {} + +// EnterOuter_join_type is called when production outer_join_type is entered. +func (s *BasePlSqlParserListener) EnterOuter_join_type(ctx *Outer_join_typeContext) {} + +// ExitOuter_join_type is called when production outer_join_type is exited. +func (s *BasePlSqlParserListener) ExitOuter_join_type(ctx *Outer_join_typeContext) {} + +// EnterQuery_partition_clause is called when production query_partition_clause is entered. +func (s *BasePlSqlParserListener) EnterQuery_partition_clause(ctx *Query_partition_clauseContext) {} + +// ExitQuery_partition_clause is called when production query_partition_clause is exited. +func (s *BasePlSqlParserListener) ExitQuery_partition_clause(ctx *Query_partition_clauseContext) {} + +// EnterFlashback_query_clause is called when production flashback_query_clause is entered. +func (s *BasePlSqlParserListener) EnterFlashback_query_clause(ctx *Flashback_query_clauseContext) {} + +// ExitFlashback_query_clause is called when production flashback_query_clause is exited. +func (s *BasePlSqlParserListener) ExitFlashback_query_clause(ctx *Flashback_query_clauseContext) {} + +// EnterPivot_clause is called when production pivot_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_clause(ctx *Pivot_clauseContext) {} + +// ExitPivot_clause is called when production pivot_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_clause(ctx *Pivot_clauseContext) {} + +// EnterPivot_element is called when production pivot_element is entered. +func (s *BasePlSqlParserListener) EnterPivot_element(ctx *Pivot_elementContext) {} + +// ExitPivot_element is called when production pivot_element is exited. +func (s *BasePlSqlParserListener) ExitPivot_element(ctx *Pivot_elementContext) {} + +// EnterPivot_for_clause is called when production pivot_for_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_for_clause(ctx *Pivot_for_clauseContext) {} + +// ExitPivot_for_clause is called when production pivot_for_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_for_clause(ctx *Pivot_for_clauseContext) {} + +// EnterPivot_in_clause is called when production pivot_in_clause is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause(ctx *Pivot_in_clauseContext) {} + +// ExitPivot_in_clause is called when production pivot_in_clause is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause(ctx *Pivot_in_clauseContext) {} + +// EnterPivot_in_clause_element is called when production pivot_in_clause_element is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) {} + +// ExitPivot_in_clause_element is called when production pivot_in_clause_element is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) {} + +// EnterPivot_in_clause_elements is called when production pivot_in_clause_elements is entered. +func (s *BasePlSqlParserListener) EnterPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) { +} + +// ExitPivot_in_clause_elements is called when production pivot_in_clause_elements is exited. +func (s *BasePlSqlParserListener) ExitPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) { +} + +// EnterUnpivot_clause is called when production unpivot_clause is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// ExitUnpivot_clause is called when production unpivot_clause is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_clause(ctx *Unpivot_clauseContext) {} + +// EnterUnpivot_in_clause is called when production unpivot_in_clause is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_in_clause(ctx *Unpivot_in_clauseContext) {} + +// ExitUnpivot_in_clause is called when production unpivot_in_clause is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_in_clause(ctx *Unpivot_in_clauseContext) {} + +// EnterUnpivot_in_elements is called when production unpivot_in_elements is entered. +func (s *BasePlSqlParserListener) EnterUnpivot_in_elements(ctx *Unpivot_in_elementsContext) {} + +// ExitUnpivot_in_elements is called when production unpivot_in_elements is exited. +func (s *BasePlSqlParserListener) ExitUnpivot_in_elements(ctx *Unpivot_in_elementsContext) {} + +// EnterHierarchical_query_clause is called when production hierarchical_query_clause is entered. +func (s *BasePlSqlParserListener) EnterHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) { +} + +// ExitHierarchical_query_clause is called when production hierarchical_query_clause is exited. +func (s *BasePlSqlParserListener) ExitHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) { +} + +// EnterStart_part is called when production start_part is entered. +func (s *BasePlSqlParserListener) EnterStart_part(ctx *Start_partContext) {} + +// ExitStart_part is called when production start_part is exited. +func (s *BasePlSqlParserListener) ExitStart_part(ctx *Start_partContext) {} + +// EnterGroup_by_clause is called when production group_by_clause is entered. +func (s *BasePlSqlParserListener) EnterGroup_by_clause(ctx *Group_by_clauseContext) {} + +// ExitGroup_by_clause is called when production group_by_clause is exited. +func (s *BasePlSqlParserListener) ExitGroup_by_clause(ctx *Group_by_clauseContext) {} + +// EnterGroup_by_elements is called when production group_by_elements is entered. +func (s *BasePlSqlParserListener) EnterGroup_by_elements(ctx *Group_by_elementsContext) {} + +// ExitGroup_by_elements is called when production group_by_elements is exited. +func (s *BasePlSqlParserListener) ExitGroup_by_elements(ctx *Group_by_elementsContext) {} + +// EnterRollup_cube_clause is called when production rollup_cube_clause is entered. +func (s *BasePlSqlParserListener) EnterRollup_cube_clause(ctx *Rollup_cube_clauseContext) {} + +// ExitRollup_cube_clause is called when production rollup_cube_clause is exited. +func (s *BasePlSqlParserListener) ExitRollup_cube_clause(ctx *Rollup_cube_clauseContext) {} + +// EnterGrouping_sets_clause is called when production grouping_sets_clause is entered. +func (s *BasePlSqlParserListener) EnterGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// ExitGrouping_sets_clause is called when production grouping_sets_clause is exited. +func (s *BasePlSqlParserListener) ExitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) {} + +// EnterGrouping_sets_elements is called when production grouping_sets_elements is entered. +func (s *BasePlSqlParserListener) EnterGrouping_sets_elements(ctx *Grouping_sets_elementsContext) {} + +// ExitGrouping_sets_elements is called when production grouping_sets_elements is exited. +func (s *BasePlSqlParserListener) ExitGrouping_sets_elements(ctx *Grouping_sets_elementsContext) {} + +// EnterHaving_clause is called when production having_clause is entered. +func (s *BasePlSqlParserListener) EnterHaving_clause(ctx *Having_clauseContext) {} + +// ExitHaving_clause is called when production having_clause is exited. +func (s *BasePlSqlParserListener) ExitHaving_clause(ctx *Having_clauseContext) {} + +// EnterModel_clause is called when production model_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_clause(ctx *Model_clauseContext) {} + +// ExitModel_clause is called when production model_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_clause(ctx *Model_clauseContext) {} + +// EnterCell_reference_options is called when production cell_reference_options is entered. +func (s *BasePlSqlParserListener) EnterCell_reference_options(ctx *Cell_reference_optionsContext) {} + +// ExitCell_reference_options is called when production cell_reference_options is exited. +func (s *BasePlSqlParserListener) ExitCell_reference_options(ctx *Cell_reference_optionsContext) {} + +// EnterReturn_rows_clause is called when production return_rows_clause is entered. +func (s *BasePlSqlParserListener) EnterReturn_rows_clause(ctx *Return_rows_clauseContext) {} + +// ExitReturn_rows_clause is called when production return_rows_clause is exited. +func (s *BasePlSqlParserListener) ExitReturn_rows_clause(ctx *Return_rows_clauseContext) {} + +// EnterReference_model is called when production reference_model is entered. +func (s *BasePlSqlParserListener) EnterReference_model(ctx *Reference_modelContext) {} + +// ExitReference_model is called when production reference_model is exited. +func (s *BasePlSqlParserListener) ExitReference_model(ctx *Reference_modelContext) {} + +// EnterMain_model is called when production main_model is entered. +func (s *BasePlSqlParserListener) EnterMain_model(ctx *Main_modelContext) {} + +// ExitMain_model is called when production main_model is exited. +func (s *BasePlSqlParserListener) ExitMain_model(ctx *Main_modelContext) {} + +// EnterModel_column_clauses is called when production model_column_clauses is entered. +func (s *BasePlSqlParserListener) EnterModel_column_clauses(ctx *Model_column_clausesContext) {} + +// ExitModel_column_clauses is called when production model_column_clauses is exited. +func (s *BasePlSqlParserListener) ExitModel_column_clauses(ctx *Model_column_clausesContext) {} + +// EnterModel_column_partition_part is called when production model_column_partition_part is entered. +func (s *BasePlSqlParserListener) EnterModel_column_partition_part(ctx *Model_column_partition_partContext) { +} + +// ExitModel_column_partition_part is called when production model_column_partition_part is exited. +func (s *BasePlSqlParserListener) ExitModel_column_partition_part(ctx *Model_column_partition_partContext) { +} + +// EnterModel_column_list is called when production model_column_list is entered. +func (s *BasePlSqlParserListener) EnterModel_column_list(ctx *Model_column_listContext) {} + +// ExitModel_column_list is called when production model_column_list is exited. +func (s *BasePlSqlParserListener) ExitModel_column_list(ctx *Model_column_listContext) {} + +// EnterModel_column is called when production model_column is entered. +func (s *BasePlSqlParserListener) EnterModel_column(ctx *Model_columnContext) {} + +// ExitModel_column is called when production model_column is exited. +func (s *BasePlSqlParserListener) ExitModel_column(ctx *Model_columnContext) {} + +// EnterModel_rules_clause is called when production model_rules_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_clause(ctx *Model_rules_clauseContext) {} + +// ExitModel_rules_clause is called when production model_rules_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_clause(ctx *Model_rules_clauseContext) {} + +// EnterModel_rules_part is called when production model_rules_part is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_part(ctx *Model_rules_partContext) {} + +// ExitModel_rules_part is called when production model_rules_part is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_part(ctx *Model_rules_partContext) {} + +// EnterModel_rules_element is called when production model_rules_element is entered. +func (s *BasePlSqlParserListener) EnterModel_rules_element(ctx *Model_rules_elementContext) {} + +// ExitModel_rules_element is called when production model_rules_element is exited. +func (s *BasePlSqlParserListener) ExitModel_rules_element(ctx *Model_rules_elementContext) {} + +// EnterCell_assignment is called when production cell_assignment is entered. +func (s *BasePlSqlParserListener) EnterCell_assignment(ctx *Cell_assignmentContext) {} + +// ExitCell_assignment is called when production cell_assignment is exited. +func (s *BasePlSqlParserListener) ExitCell_assignment(ctx *Cell_assignmentContext) {} + +// EnterModel_iterate_clause is called when production model_iterate_clause is entered. +func (s *BasePlSqlParserListener) EnterModel_iterate_clause(ctx *Model_iterate_clauseContext) {} + +// ExitModel_iterate_clause is called when production model_iterate_clause is exited. +func (s *BasePlSqlParserListener) ExitModel_iterate_clause(ctx *Model_iterate_clauseContext) {} + +// EnterUntil_part is called when production until_part is entered. +func (s *BasePlSqlParserListener) EnterUntil_part(ctx *Until_partContext) {} + +// ExitUntil_part is called when production until_part is exited. +func (s *BasePlSqlParserListener) ExitUntil_part(ctx *Until_partContext) {} + +// EnterOrder_by_clause is called when production order_by_clause is entered. +func (s *BasePlSqlParserListener) EnterOrder_by_clause(ctx *Order_by_clauseContext) {} + +// ExitOrder_by_clause is called when production order_by_clause is exited. +func (s *BasePlSqlParserListener) ExitOrder_by_clause(ctx *Order_by_clauseContext) {} + +// EnterOrder_by_elements is called when production order_by_elements is entered. +func (s *BasePlSqlParserListener) EnterOrder_by_elements(ctx *Order_by_elementsContext) {} + +// ExitOrder_by_elements is called when production order_by_elements is exited. +func (s *BasePlSqlParserListener) ExitOrder_by_elements(ctx *Order_by_elementsContext) {} + +// EnterOffset_clause is called when production offset_clause is entered. +func (s *BasePlSqlParserListener) EnterOffset_clause(ctx *Offset_clauseContext) {} + +// ExitOffset_clause is called when production offset_clause is exited. +func (s *BasePlSqlParserListener) ExitOffset_clause(ctx *Offset_clauseContext) {} + +// EnterFetch_clause is called when production fetch_clause is entered. +func (s *BasePlSqlParserListener) EnterFetch_clause(ctx *Fetch_clauseContext) {} + +// ExitFetch_clause is called when production fetch_clause is exited. +func (s *BasePlSqlParserListener) ExitFetch_clause(ctx *Fetch_clauseContext) {} + +// EnterFor_update_clause is called when production for_update_clause is entered. +func (s *BasePlSqlParserListener) EnterFor_update_clause(ctx *For_update_clauseContext) {} + +// ExitFor_update_clause is called when production for_update_clause is exited. +func (s *BasePlSqlParserListener) ExitFor_update_clause(ctx *For_update_clauseContext) {} + +// EnterFor_update_of_part is called when production for_update_of_part is entered. +func (s *BasePlSqlParserListener) EnterFor_update_of_part(ctx *For_update_of_partContext) {} + +// ExitFor_update_of_part is called when production for_update_of_part is exited. +func (s *BasePlSqlParserListener) ExitFor_update_of_part(ctx *For_update_of_partContext) {} + +// EnterFor_update_options is called when production for_update_options is entered. +func (s *BasePlSqlParserListener) EnterFor_update_options(ctx *For_update_optionsContext) {} + +// ExitFor_update_options is called when production for_update_options is exited. +func (s *BasePlSqlParserListener) ExitFor_update_options(ctx *For_update_optionsContext) {} + +// EnterUpdate_statement is called when production update_statement is entered. +func (s *BasePlSqlParserListener) EnterUpdate_statement(ctx *Update_statementContext) {} + +// ExitUpdate_statement is called when production update_statement is exited. +func (s *BasePlSqlParserListener) ExitUpdate_statement(ctx *Update_statementContext) {} + +// EnterUpdate_set_clause is called when production update_set_clause is entered. +func (s *BasePlSqlParserListener) EnterUpdate_set_clause(ctx *Update_set_clauseContext) {} + +// ExitUpdate_set_clause is called when production update_set_clause is exited. +func (s *BasePlSqlParserListener) ExitUpdate_set_clause(ctx *Update_set_clauseContext) {} + +// EnterColumn_based_update_set_clause is called when production column_based_update_set_clause is entered. +func (s *BasePlSqlParserListener) EnterColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) { +} + +// ExitColumn_based_update_set_clause is called when production column_based_update_set_clause is exited. +func (s *BasePlSqlParserListener) ExitColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) { +} + +// EnterDelete_statement is called when production delete_statement is entered. +func (s *BasePlSqlParserListener) EnterDelete_statement(ctx *Delete_statementContext) {} + +// ExitDelete_statement is called when production delete_statement is exited. +func (s *BasePlSqlParserListener) ExitDelete_statement(ctx *Delete_statementContext) {} + +// EnterInsert_statement is called when production insert_statement is entered. +func (s *BasePlSqlParserListener) EnterInsert_statement(ctx *Insert_statementContext) {} + +// ExitInsert_statement is called when production insert_statement is exited. +func (s *BasePlSqlParserListener) ExitInsert_statement(ctx *Insert_statementContext) {} + +// EnterSingle_table_insert is called when production single_table_insert is entered. +func (s *BasePlSqlParserListener) EnterSingle_table_insert(ctx *Single_table_insertContext) {} + +// ExitSingle_table_insert is called when production single_table_insert is exited. +func (s *BasePlSqlParserListener) ExitSingle_table_insert(ctx *Single_table_insertContext) {} + +// EnterMulti_table_insert is called when production multi_table_insert is entered. +func (s *BasePlSqlParserListener) EnterMulti_table_insert(ctx *Multi_table_insertContext) {} + +// ExitMulti_table_insert is called when production multi_table_insert is exited. +func (s *BasePlSqlParserListener) ExitMulti_table_insert(ctx *Multi_table_insertContext) {} + +// EnterMulti_table_element is called when production multi_table_element is entered. +func (s *BasePlSqlParserListener) EnterMulti_table_element(ctx *Multi_table_elementContext) {} + +// ExitMulti_table_element is called when production multi_table_element is exited. +func (s *BasePlSqlParserListener) ExitMulti_table_element(ctx *Multi_table_elementContext) {} + +// EnterConditional_insert_clause is called when production conditional_insert_clause is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_clause(ctx *Conditional_insert_clauseContext) { +} + +// ExitConditional_insert_clause is called when production conditional_insert_clause is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_clause(ctx *Conditional_insert_clauseContext) { +} + +// EnterConditional_insert_when_part is called when production conditional_insert_when_part is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_when_part(ctx *Conditional_insert_when_partContext) { +} + +// ExitConditional_insert_when_part is called when production conditional_insert_when_part is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_when_part(ctx *Conditional_insert_when_partContext) { +} + +// EnterConditional_insert_else_part is called when production conditional_insert_else_part is entered. +func (s *BasePlSqlParserListener) EnterConditional_insert_else_part(ctx *Conditional_insert_else_partContext) { +} + +// ExitConditional_insert_else_part is called when production conditional_insert_else_part is exited. +func (s *BasePlSqlParserListener) ExitConditional_insert_else_part(ctx *Conditional_insert_else_partContext) { +} + +// EnterInsert_into_clause is called when production insert_into_clause is entered. +func (s *BasePlSqlParserListener) EnterInsert_into_clause(ctx *Insert_into_clauseContext) {} + +// ExitInsert_into_clause is called when production insert_into_clause is exited. +func (s *BasePlSqlParserListener) ExitInsert_into_clause(ctx *Insert_into_clauseContext) {} + +// EnterValues_clause is called when production values_clause is entered. +func (s *BasePlSqlParserListener) EnterValues_clause(ctx *Values_clauseContext) {} + +// ExitValues_clause is called when production values_clause is exited. +func (s *BasePlSqlParserListener) ExitValues_clause(ctx *Values_clauseContext) {} + +// EnterMerge_statement is called when production merge_statement is entered. +func (s *BasePlSqlParserListener) EnterMerge_statement(ctx *Merge_statementContext) {} + +// ExitMerge_statement is called when production merge_statement is exited. +func (s *BasePlSqlParserListener) ExitMerge_statement(ctx *Merge_statementContext) {} + +// EnterMerge_update_clause is called when production merge_update_clause is entered. +func (s *BasePlSqlParserListener) EnterMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// ExitMerge_update_clause is called when production merge_update_clause is exited. +func (s *BasePlSqlParserListener) ExitMerge_update_clause(ctx *Merge_update_clauseContext) {} + +// EnterMerge_element is called when production merge_element is entered. +func (s *BasePlSqlParserListener) EnterMerge_element(ctx *Merge_elementContext) {} + +// ExitMerge_element is called when production merge_element is exited. +func (s *BasePlSqlParserListener) ExitMerge_element(ctx *Merge_elementContext) {} + +// EnterMerge_update_delete_part is called when production merge_update_delete_part is entered. +func (s *BasePlSqlParserListener) EnterMerge_update_delete_part(ctx *Merge_update_delete_partContext) { +} + +// ExitMerge_update_delete_part is called when production merge_update_delete_part is exited. +func (s *BasePlSqlParserListener) ExitMerge_update_delete_part(ctx *Merge_update_delete_partContext) { +} + +// EnterMerge_insert_clause is called when production merge_insert_clause is entered. +func (s *BasePlSqlParserListener) EnterMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// ExitMerge_insert_clause is called when production merge_insert_clause is exited. +func (s *BasePlSqlParserListener) ExitMerge_insert_clause(ctx *Merge_insert_clauseContext) {} + +// EnterSelected_tableview is called when production selected_tableview is entered. +func (s *BasePlSqlParserListener) EnterSelected_tableview(ctx *Selected_tableviewContext) {} + +// ExitSelected_tableview is called when production selected_tableview is exited. +func (s *BasePlSqlParserListener) ExitSelected_tableview(ctx *Selected_tableviewContext) {} + +// EnterLock_table_statement is called when production lock_table_statement is entered. +func (s *BasePlSqlParserListener) EnterLock_table_statement(ctx *Lock_table_statementContext) {} + +// ExitLock_table_statement is called when production lock_table_statement is exited. +func (s *BasePlSqlParserListener) ExitLock_table_statement(ctx *Lock_table_statementContext) {} + +// EnterWait_nowait_part is called when production wait_nowait_part is entered. +func (s *BasePlSqlParserListener) EnterWait_nowait_part(ctx *Wait_nowait_partContext) {} + +// ExitWait_nowait_part is called when production wait_nowait_part is exited. +func (s *BasePlSqlParserListener) ExitWait_nowait_part(ctx *Wait_nowait_partContext) {} + +// EnterLock_table_element is called when production lock_table_element is entered. +func (s *BasePlSqlParserListener) EnterLock_table_element(ctx *Lock_table_elementContext) {} + +// ExitLock_table_element is called when production lock_table_element is exited. +func (s *BasePlSqlParserListener) ExitLock_table_element(ctx *Lock_table_elementContext) {} + +// EnterLock_mode is called when production lock_mode is entered. +func (s *BasePlSqlParserListener) EnterLock_mode(ctx *Lock_modeContext) {} + +// ExitLock_mode is called when production lock_mode is exited. +func (s *BasePlSqlParserListener) ExitLock_mode(ctx *Lock_modeContext) {} + +// EnterGeneral_table_ref is called when production general_table_ref is entered. +func (s *BasePlSqlParserListener) EnterGeneral_table_ref(ctx *General_table_refContext) {} + +// ExitGeneral_table_ref is called when production general_table_ref is exited. +func (s *BasePlSqlParserListener) ExitGeneral_table_ref(ctx *General_table_refContext) {} + +// EnterStatic_returning_clause is called when production static_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterStatic_returning_clause(ctx *Static_returning_clauseContext) {} + +// ExitStatic_returning_clause is called when production static_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitStatic_returning_clause(ctx *Static_returning_clauseContext) {} + +// EnterError_logging_clause is called when production error_logging_clause is entered. +func (s *BasePlSqlParserListener) EnterError_logging_clause(ctx *Error_logging_clauseContext) {} + +// ExitError_logging_clause is called when production error_logging_clause is exited. +func (s *BasePlSqlParserListener) ExitError_logging_clause(ctx *Error_logging_clauseContext) {} + +// EnterError_logging_into_part is called when production error_logging_into_part is entered. +func (s *BasePlSqlParserListener) EnterError_logging_into_part(ctx *Error_logging_into_partContext) {} + +// ExitError_logging_into_part is called when production error_logging_into_part is exited. +func (s *BasePlSqlParserListener) ExitError_logging_into_part(ctx *Error_logging_into_partContext) {} + +// EnterError_logging_reject_part is called when production error_logging_reject_part is entered. +func (s *BasePlSqlParserListener) EnterError_logging_reject_part(ctx *Error_logging_reject_partContext) { +} + +// ExitError_logging_reject_part is called when production error_logging_reject_part is exited. +func (s *BasePlSqlParserListener) ExitError_logging_reject_part(ctx *Error_logging_reject_partContext) { +} + +// EnterDml_table_expression_clause is called when production dml_table_expression_clause is entered. +func (s *BasePlSqlParserListener) EnterDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) { +} + +// ExitDml_table_expression_clause is called when production dml_table_expression_clause is exited. +func (s *BasePlSqlParserListener) ExitDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) { +} + +// EnterTable_collection_expression is called when production table_collection_expression is entered. +func (s *BasePlSqlParserListener) EnterTable_collection_expression(ctx *Table_collection_expressionContext) { +} + +// ExitTable_collection_expression is called when production table_collection_expression is exited. +func (s *BasePlSqlParserListener) ExitTable_collection_expression(ctx *Table_collection_expressionContext) { +} + +// EnterSubquery_restriction_clause is called when production subquery_restriction_clause is entered. +func (s *BasePlSqlParserListener) EnterSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) { +} + +// ExitSubquery_restriction_clause is called when production subquery_restriction_clause is exited. +func (s *BasePlSqlParserListener) ExitSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) { +} + +// EnterSample_clause is called when production sample_clause is entered. +func (s *BasePlSqlParserListener) EnterSample_clause(ctx *Sample_clauseContext) {} + +// ExitSample_clause is called when production sample_clause is exited. +func (s *BasePlSqlParserListener) ExitSample_clause(ctx *Sample_clauseContext) {} + +// EnterSeed_part is called when production seed_part is entered. +func (s *BasePlSqlParserListener) EnterSeed_part(ctx *Seed_partContext) {} + +// ExitSeed_part is called when production seed_part is exited. +func (s *BasePlSqlParserListener) ExitSeed_part(ctx *Seed_partContext) {} + +// EnterCondition is called when production condition is entered. +func (s *BasePlSqlParserListener) EnterCondition(ctx *ConditionContext) {} + +// ExitCondition is called when production condition is exited. +func (s *BasePlSqlParserListener) ExitCondition(ctx *ConditionContext) {} + +// EnterJson_condition is called when production json_condition is entered. +func (s *BasePlSqlParserListener) EnterJson_condition(ctx *Json_conditionContext) {} + +// ExitJson_condition is called when production json_condition is exited. +func (s *BasePlSqlParserListener) ExitJson_condition(ctx *Json_conditionContext) {} + +// EnterExpressions is called when production expressions is entered. +func (s *BasePlSqlParserListener) EnterExpressions(ctx *ExpressionsContext) {} + +// ExitExpressions is called when production expressions is exited. +func (s *BasePlSqlParserListener) ExitExpressions(ctx *ExpressionsContext) {} + +// EnterExpression is called when production expression is entered. +func (s *BasePlSqlParserListener) EnterExpression(ctx *ExpressionContext) {} + +// ExitExpression is called when production expression is exited. +func (s *BasePlSqlParserListener) ExitExpression(ctx *ExpressionContext) {} + +// EnterCursor_expression is called when production cursor_expression is entered. +func (s *BasePlSqlParserListener) EnterCursor_expression(ctx *Cursor_expressionContext) {} + +// ExitCursor_expression is called when production cursor_expression is exited. +func (s *BasePlSqlParserListener) ExitCursor_expression(ctx *Cursor_expressionContext) {} + +// EnterLogical_expression is called when production logical_expression is entered. +func (s *BasePlSqlParserListener) EnterLogical_expression(ctx *Logical_expressionContext) {} + +// ExitLogical_expression is called when production logical_expression is exited. +func (s *BasePlSqlParserListener) ExitLogical_expression(ctx *Logical_expressionContext) {} + +// EnterUnary_logical_expression is called when production unary_logical_expression is entered. +func (s *BasePlSqlParserListener) EnterUnary_logical_expression(ctx *Unary_logical_expressionContext) { +} + +// ExitUnary_logical_expression is called when production unary_logical_expression is exited. +func (s *BasePlSqlParserListener) ExitUnary_logical_expression(ctx *Unary_logical_expressionContext) { +} + +// EnterLogical_operation is called when production logical_operation is entered. +func (s *BasePlSqlParserListener) EnterLogical_operation(ctx *Logical_operationContext) {} + +// ExitLogical_operation is called when production logical_operation is exited. +func (s *BasePlSqlParserListener) ExitLogical_operation(ctx *Logical_operationContext) {} + +// EnterMultiset_expression is called when production multiset_expression is entered. +func (s *BasePlSqlParserListener) EnterMultiset_expression(ctx *Multiset_expressionContext) {} + +// ExitMultiset_expression is called when production multiset_expression is exited. +func (s *BasePlSqlParserListener) ExitMultiset_expression(ctx *Multiset_expressionContext) {} + +// EnterRelational_expression is called when production relational_expression is entered. +func (s *BasePlSqlParserListener) EnterRelational_expression(ctx *Relational_expressionContext) {} + +// ExitRelational_expression is called when production relational_expression is exited. +func (s *BasePlSqlParserListener) ExitRelational_expression(ctx *Relational_expressionContext) {} + +// EnterCompound_expression is called when production compound_expression is entered. +func (s *BasePlSqlParserListener) EnterCompound_expression(ctx *Compound_expressionContext) {} + +// ExitCompound_expression is called when production compound_expression is exited. +func (s *BasePlSqlParserListener) ExitCompound_expression(ctx *Compound_expressionContext) {} + +// EnterRelational_operator is called when production relational_operator is entered. +func (s *BasePlSqlParserListener) EnterRelational_operator(ctx *Relational_operatorContext) {} + +// ExitRelational_operator is called when production relational_operator is exited. +func (s *BasePlSqlParserListener) ExitRelational_operator(ctx *Relational_operatorContext) {} + +// EnterIn_elements is called when production in_elements is entered. +func (s *BasePlSqlParserListener) EnterIn_elements(ctx *In_elementsContext) {} + +// ExitIn_elements is called when production in_elements is exited. +func (s *BasePlSqlParserListener) ExitIn_elements(ctx *In_elementsContext) {} + +// EnterBetween_elements is called when production between_elements is entered. +func (s *BasePlSqlParserListener) EnterBetween_elements(ctx *Between_elementsContext) {} + +// ExitBetween_elements is called when production between_elements is exited. +func (s *BasePlSqlParserListener) ExitBetween_elements(ctx *Between_elementsContext) {} + +// EnterConcatenation is called when production concatenation is entered. +func (s *BasePlSqlParserListener) EnterConcatenation(ctx *ConcatenationContext) {} + +// ExitConcatenation is called when production concatenation is exited. +func (s *BasePlSqlParserListener) ExitConcatenation(ctx *ConcatenationContext) {} + +// EnterInterval_expression is called when production interval_expression is entered. +func (s *BasePlSqlParserListener) EnterInterval_expression(ctx *Interval_expressionContext) {} + +// ExitInterval_expression is called when production interval_expression is exited. +func (s *BasePlSqlParserListener) ExitInterval_expression(ctx *Interval_expressionContext) {} + +// EnterModel_expression is called when production model_expression is entered. +func (s *BasePlSqlParserListener) EnterModel_expression(ctx *Model_expressionContext) {} + +// ExitModel_expression is called when production model_expression is exited. +func (s *BasePlSqlParserListener) ExitModel_expression(ctx *Model_expressionContext) {} + +// EnterModel_expression_element is called when production model_expression_element is entered. +func (s *BasePlSqlParserListener) EnterModel_expression_element(ctx *Model_expression_elementContext) { +} + +// ExitModel_expression_element is called when production model_expression_element is exited. +func (s *BasePlSqlParserListener) ExitModel_expression_element(ctx *Model_expression_elementContext) { +} + +// EnterSingle_column_for_loop is called when production single_column_for_loop is entered. +func (s *BasePlSqlParserListener) EnterSingle_column_for_loop(ctx *Single_column_for_loopContext) {} + +// ExitSingle_column_for_loop is called when production single_column_for_loop is exited. +func (s *BasePlSqlParserListener) ExitSingle_column_for_loop(ctx *Single_column_for_loopContext) {} + +// EnterMulti_column_for_loop is called when production multi_column_for_loop is entered. +func (s *BasePlSqlParserListener) EnterMulti_column_for_loop(ctx *Multi_column_for_loopContext) {} + +// ExitMulti_column_for_loop is called when production multi_column_for_loop is exited. +func (s *BasePlSqlParserListener) ExitMulti_column_for_loop(ctx *Multi_column_for_loopContext) {} + +// EnterUnary_expression is called when production unary_expression is entered. +func (s *BasePlSqlParserListener) EnterUnary_expression(ctx *Unary_expressionContext) {} + +// ExitUnary_expression is called when production unary_expression is exited. +func (s *BasePlSqlParserListener) ExitUnary_expression(ctx *Unary_expressionContext) {} + +// EnterCase_statement is called when production case_statement is entered. +func (s *BasePlSqlParserListener) EnterCase_statement(ctx *Case_statementContext) {} + +// ExitCase_statement is called when production case_statement is exited. +func (s *BasePlSqlParserListener) ExitCase_statement(ctx *Case_statementContext) {} + +// EnterSimple_case_statement is called when production simple_case_statement is entered. +func (s *BasePlSqlParserListener) EnterSimple_case_statement(ctx *Simple_case_statementContext) {} + +// ExitSimple_case_statement is called when production simple_case_statement is exited. +func (s *BasePlSqlParserListener) ExitSimple_case_statement(ctx *Simple_case_statementContext) {} + +// EnterSimple_case_when_part is called when production simple_case_when_part is entered. +func (s *BasePlSqlParserListener) EnterSimple_case_when_part(ctx *Simple_case_when_partContext) {} + +// ExitSimple_case_when_part is called when production simple_case_when_part is exited. +func (s *BasePlSqlParserListener) ExitSimple_case_when_part(ctx *Simple_case_when_partContext) {} + +// EnterSearched_case_statement is called when production searched_case_statement is entered. +func (s *BasePlSqlParserListener) EnterSearched_case_statement(ctx *Searched_case_statementContext) {} + +// ExitSearched_case_statement is called when production searched_case_statement is exited. +func (s *BasePlSqlParserListener) ExitSearched_case_statement(ctx *Searched_case_statementContext) {} + +// EnterSearched_case_when_part is called when production searched_case_when_part is entered. +func (s *BasePlSqlParserListener) EnterSearched_case_when_part(ctx *Searched_case_when_partContext) {} + +// ExitSearched_case_when_part is called when production searched_case_when_part is exited. +func (s *BasePlSqlParserListener) ExitSearched_case_when_part(ctx *Searched_case_when_partContext) {} + +// EnterCase_else_part is called when production case_else_part is entered. +func (s *BasePlSqlParserListener) EnterCase_else_part(ctx *Case_else_partContext) {} + +// ExitCase_else_part is called when production case_else_part is exited. +func (s *BasePlSqlParserListener) ExitCase_else_part(ctx *Case_else_partContext) {} + +// EnterAtom is called when production atom is entered. +func (s *BasePlSqlParserListener) EnterAtom(ctx *AtomContext) {} + +// ExitAtom is called when production atom is exited. +func (s *BasePlSqlParserListener) ExitAtom(ctx *AtomContext) {} + +// EnterQuantified_expression is called when production quantified_expression is entered. +func (s *BasePlSqlParserListener) EnterQuantified_expression(ctx *Quantified_expressionContext) {} + +// ExitQuantified_expression is called when production quantified_expression is exited. +func (s *BasePlSqlParserListener) ExitQuantified_expression(ctx *Quantified_expressionContext) {} + +// EnterString_function is called when production string_function is entered. +func (s *BasePlSqlParserListener) EnterString_function(ctx *String_functionContext) {} + +// ExitString_function is called when production string_function is exited. +func (s *BasePlSqlParserListener) ExitString_function(ctx *String_functionContext) {} + +// EnterStandard_function is called when production standard_function is entered. +func (s *BasePlSqlParserListener) EnterStandard_function(ctx *Standard_functionContext) {} + +// ExitStandard_function is called when production standard_function is exited. +func (s *BasePlSqlParserListener) ExitStandard_function(ctx *Standard_functionContext) {} + +// EnterJson_function is called when production json_function is entered. +func (s *BasePlSqlParserListener) EnterJson_function(ctx *Json_functionContext) {} + +// ExitJson_function is called when production json_function is exited. +func (s *BasePlSqlParserListener) ExitJson_function(ctx *Json_functionContext) {} + +// EnterJson_object_content is called when production json_object_content is entered. +func (s *BasePlSqlParserListener) EnterJson_object_content(ctx *Json_object_contentContext) {} + +// ExitJson_object_content is called when production json_object_content is exited. +func (s *BasePlSqlParserListener) ExitJson_object_content(ctx *Json_object_contentContext) {} + +// EnterJson_object_entry is called when production json_object_entry is entered. +func (s *BasePlSqlParserListener) EnterJson_object_entry(ctx *Json_object_entryContext) {} + +// ExitJson_object_entry is called when production json_object_entry is exited. +func (s *BasePlSqlParserListener) ExitJson_object_entry(ctx *Json_object_entryContext) {} + +// EnterJson_table_clause is called when production json_table_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_table_clause(ctx *Json_table_clauseContext) {} + +// ExitJson_table_clause is called when production json_table_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_table_clause(ctx *Json_table_clauseContext) {} + +// EnterJson_array_element is called when production json_array_element is entered. +func (s *BasePlSqlParserListener) EnterJson_array_element(ctx *Json_array_elementContext) {} + +// ExitJson_array_element is called when production json_array_element is exited. +func (s *BasePlSqlParserListener) ExitJson_array_element(ctx *Json_array_elementContext) {} + +// EnterJson_on_null_clause is called when production json_on_null_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_on_null_clause(ctx *Json_on_null_clauseContext) {} + +// ExitJson_on_null_clause is called when production json_on_null_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_on_null_clause(ctx *Json_on_null_clauseContext) {} + +// EnterJson_return_clause is called when production json_return_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_return_clause(ctx *Json_return_clauseContext) {} + +// ExitJson_return_clause is called when production json_return_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_return_clause(ctx *Json_return_clauseContext) {} + +// EnterJson_transform_op is called when production json_transform_op is entered. +func (s *BasePlSqlParserListener) EnterJson_transform_op(ctx *Json_transform_opContext) {} + +// ExitJson_transform_op is called when production json_transform_op is exited. +func (s *BasePlSqlParserListener) ExitJson_transform_op(ctx *Json_transform_opContext) {} + +// EnterJson_column_clause is called when production json_column_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_column_clause(ctx *Json_column_clauseContext) {} + +// ExitJson_column_clause is called when production json_column_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_column_clause(ctx *Json_column_clauseContext) {} + +// EnterJson_column_definition is called when production json_column_definition is entered. +func (s *BasePlSqlParserListener) EnterJson_column_definition(ctx *Json_column_definitionContext) {} + +// ExitJson_column_definition is called when production json_column_definition is exited. +func (s *BasePlSqlParserListener) ExitJson_column_definition(ctx *Json_column_definitionContext) {} + +// EnterJson_query_returning_clause is called when production json_query_returning_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_returning_clause(ctx *Json_query_returning_clauseContext) { +} + +// ExitJson_query_returning_clause is called when production json_query_returning_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_returning_clause(ctx *Json_query_returning_clauseContext) { +} + +// EnterJson_query_return_type is called when production json_query_return_type is entered. +func (s *BasePlSqlParserListener) EnterJson_query_return_type(ctx *Json_query_return_typeContext) {} + +// ExitJson_query_return_type is called when production json_query_return_type is exited. +func (s *BasePlSqlParserListener) ExitJson_query_return_type(ctx *Json_query_return_typeContext) {} + +// EnterJson_query_wrapper_clause is called when production json_query_wrapper_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) { +} + +// ExitJson_query_wrapper_clause is called when production json_query_wrapper_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) { +} + +// EnterJson_query_on_error_clause is called when production json_query_on_error_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) { +} + +// ExitJson_query_on_error_clause is called when production json_query_on_error_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) { +} + +// EnterJson_query_on_empty_clause is called when production json_query_on_empty_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) { +} + +// ExitJson_query_on_empty_clause is called when production json_query_on_empty_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) { +} + +// EnterJson_value_return_clause is called when production json_value_return_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_value_return_clause(ctx *Json_value_return_clauseContext) { +} + +// ExitJson_value_return_clause is called when production json_value_return_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_value_return_clause(ctx *Json_value_return_clauseContext) { +} + +// EnterJson_value_return_type is called when production json_value_return_type is entered. +func (s *BasePlSqlParserListener) EnterJson_value_return_type(ctx *Json_value_return_typeContext) {} + +// ExitJson_value_return_type is called when production json_value_return_type is exited. +func (s *BasePlSqlParserListener) ExitJson_value_return_type(ctx *Json_value_return_typeContext) {} + +// EnterJson_value_on_mismatch_clause is called when production json_value_on_mismatch_clause is entered. +func (s *BasePlSqlParserListener) EnterJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) { +} + +// ExitJson_value_on_mismatch_clause is called when production json_value_on_mismatch_clause is exited. +func (s *BasePlSqlParserListener) ExitJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) { +} + +// EnterLiteral is called when production literal is entered. +func (s *BasePlSqlParserListener) EnterLiteral(ctx *LiteralContext) {} + +// ExitLiteral is called when production literal is exited. +func (s *BasePlSqlParserListener) ExitLiteral(ctx *LiteralContext) {} + +// EnterNumeric_function_wrapper is called when production numeric_function_wrapper is entered. +func (s *BasePlSqlParserListener) EnterNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) { +} + +// ExitNumeric_function_wrapper is called when production numeric_function_wrapper is exited. +func (s *BasePlSqlParserListener) ExitNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) { +} + +// EnterNumeric_function is called when production numeric_function is entered. +func (s *BasePlSqlParserListener) EnterNumeric_function(ctx *Numeric_functionContext) {} + +// ExitNumeric_function is called when production numeric_function is exited. +func (s *BasePlSqlParserListener) ExitNumeric_function(ctx *Numeric_functionContext) {} + +// EnterListagg_overflow_clause is called when production listagg_overflow_clause is entered. +func (s *BasePlSqlParserListener) EnterListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) {} + +// ExitListagg_overflow_clause is called when production listagg_overflow_clause is exited. +func (s *BasePlSqlParserListener) ExitListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) {} + +// EnterOther_function is called when production other_function is entered. +func (s *BasePlSqlParserListener) EnterOther_function(ctx *Other_functionContext) {} + +// ExitOther_function is called when production other_function is exited. +func (s *BasePlSqlParserListener) ExitOther_function(ctx *Other_functionContext) {} + +// EnterOver_clause_keyword is called when production over_clause_keyword is entered. +func (s *BasePlSqlParserListener) EnterOver_clause_keyword(ctx *Over_clause_keywordContext) {} + +// ExitOver_clause_keyword is called when production over_clause_keyword is exited. +func (s *BasePlSqlParserListener) ExitOver_clause_keyword(ctx *Over_clause_keywordContext) {} + +// EnterWithin_or_over_clause_keyword is called when production within_or_over_clause_keyword is entered. +func (s *BasePlSqlParserListener) EnterWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) { +} + +// ExitWithin_or_over_clause_keyword is called when production within_or_over_clause_keyword is exited. +func (s *BasePlSqlParserListener) ExitWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) { +} + +// EnterStandard_prediction_function_keyword is called when production standard_prediction_function_keyword is entered. +func (s *BasePlSqlParserListener) EnterStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) { +} + +// ExitStandard_prediction_function_keyword is called when production standard_prediction_function_keyword is exited. +func (s *BasePlSqlParserListener) ExitStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) { +} + +// EnterOver_clause is called when production over_clause is entered. +func (s *BasePlSqlParserListener) EnterOver_clause(ctx *Over_clauseContext) {} + +// ExitOver_clause is called when production over_clause is exited. +func (s *BasePlSqlParserListener) ExitOver_clause(ctx *Over_clauseContext) {} + +// EnterWindowing_clause is called when production windowing_clause is entered. +func (s *BasePlSqlParserListener) EnterWindowing_clause(ctx *Windowing_clauseContext) {} + +// ExitWindowing_clause is called when production windowing_clause is exited. +func (s *BasePlSqlParserListener) ExitWindowing_clause(ctx *Windowing_clauseContext) {} + +// EnterWindowing_type is called when production windowing_type is entered. +func (s *BasePlSqlParserListener) EnterWindowing_type(ctx *Windowing_typeContext) {} + +// ExitWindowing_type is called when production windowing_type is exited. +func (s *BasePlSqlParserListener) ExitWindowing_type(ctx *Windowing_typeContext) {} + +// EnterWindowing_elements is called when production windowing_elements is entered. +func (s *BasePlSqlParserListener) EnterWindowing_elements(ctx *Windowing_elementsContext) {} + +// ExitWindowing_elements is called when production windowing_elements is exited. +func (s *BasePlSqlParserListener) ExitWindowing_elements(ctx *Windowing_elementsContext) {} + +// EnterUsing_clause is called when production using_clause is entered. +func (s *BasePlSqlParserListener) EnterUsing_clause(ctx *Using_clauseContext) {} + +// ExitUsing_clause is called when production using_clause is exited. +func (s *BasePlSqlParserListener) ExitUsing_clause(ctx *Using_clauseContext) {} + +// EnterUsing_element is called when production using_element is entered. +func (s *BasePlSqlParserListener) EnterUsing_element(ctx *Using_elementContext) {} + +// ExitUsing_element is called when production using_element is exited. +func (s *BasePlSqlParserListener) ExitUsing_element(ctx *Using_elementContext) {} + +// EnterCollect_order_by_part is called when production collect_order_by_part is entered. +func (s *BasePlSqlParserListener) EnterCollect_order_by_part(ctx *Collect_order_by_partContext) {} + +// ExitCollect_order_by_part is called when production collect_order_by_part is exited. +func (s *BasePlSqlParserListener) ExitCollect_order_by_part(ctx *Collect_order_by_partContext) {} + +// EnterWithin_or_over_part is called when production within_or_over_part is entered. +func (s *BasePlSqlParserListener) EnterWithin_or_over_part(ctx *Within_or_over_partContext) {} + +// ExitWithin_or_over_part is called when production within_or_over_part is exited. +func (s *BasePlSqlParserListener) ExitWithin_or_over_part(ctx *Within_or_over_partContext) {} + +// EnterCost_matrix_clause is called when production cost_matrix_clause is entered. +func (s *BasePlSqlParserListener) EnterCost_matrix_clause(ctx *Cost_matrix_clauseContext) {} + +// ExitCost_matrix_clause is called when production cost_matrix_clause is exited. +func (s *BasePlSqlParserListener) ExitCost_matrix_clause(ctx *Cost_matrix_clauseContext) {} + +// EnterXml_passing_clause is called when production xml_passing_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_passing_clause(ctx *Xml_passing_clauseContext) {} + +// ExitXml_passing_clause is called when production xml_passing_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_passing_clause(ctx *Xml_passing_clauseContext) {} + +// EnterXml_attributes_clause is called when production xml_attributes_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_attributes_clause(ctx *Xml_attributes_clauseContext) {} + +// ExitXml_attributes_clause is called when production xml_attributes_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_attributes_clause(ctx *Xml_attributes_clauseContext) {} + +// EnterXml_namespaces_clause is called when production xml_namespaces_clause is entered. +func (s *BasePlSqlParserListener) EnterXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) {} + +// ExitXml_namespaces_clause is called when production xml_namespaces_clause is exited. +func (s *BasePlSqlParserListener) ExitXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) {} + +// EnterXml_table_column is called when production xml_table_column is entered. +func (s *BasePlSqlParserListener) EnterXml_table_column(ctx *Xml_table_columnContext) {} + +// ExitXml_table_column is called when production xml_table_column is exited. +func (s *BasePlSqlParserListener) ExitXml_table_column(ctx *Xml_table_columnContext) {} + +// EnterXml_general_default_part is called when production xml_general_default_part is entered. +func (s *BasePlSqlParserListener) EnterXml_general_default_part(ctx *Xml_general_default_partContext) { +} + +// ExitXml_general_default_part is called when production xml_general_default_part is exited. +func (s *BasePlSqlParserListener) ExitXml_general_default_part(ctx *Xml_general_default_partContext) { +} + +// EnterXml_multiuse_expression_element is called when production xml_multiuse_expression_element is entered. +func (s *BasePlSqlParserListener) EnterXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) { +} + +// ExitXml_multiuse_expression_element is called when production xml_multiuse_expression_element is exited. +func (s *BasePlSqlParserListener) ExitXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) { +} + +// EnterXmlroot_param_version_part is called when production xmlroot_param_version_part is entered. +func (s *BasePlSqlParserListener) EnterXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) { +} + +// ExitXmlroot_param_version_part is called when production xmlroot_param_version_part is exited. +func (s *BasePlSqlParserListener) ExitXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) { +} + +// EnterXmlroot_param_standalone_part is called when production xmlroot_param_standalone_part is entered. +func (s *BasePlSqlParserListener) EnterXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) { +} + +// ExitXmlroot_param_standalone_part is called when production xmlroot_param_standalone_part is exited. +func (s *BasePlSqlParserListener) ExitXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) { +} + +// EnterXmlserialize_param_enconding_part is called when production xmlserialize_param_enconding_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) { +} + +// ExitXmlserialize_param_enconding_part is called when production xmlserialize_param_enconding_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) { +} + +// EnterXmlserialize_param_version_part is called when production xmlserialize_param_version_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) { +} + +// ExitXmlserialize_param_version_part is called when production xmlserialize_param_version_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) { +} + +// EnterXmlserialize_param_ident_part is called when production xmlserialize_param_ident_part is entered. +func (s *BasePlSqlParserListener) EnterXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) { +} + +// ExitXmlserialize_param_ident_part is called when production xmlserialize_param_ident_part is exited. +func (s *BasePlSqlParserListener) ExitXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) { +} + +// EnterSql_plus_command is called when production sql_plus_command is entered. +func (s *BasePlSqlParserListener) EnterSql_plus_command(ctx *Sql_plus_commandContext) {} + +// ExitSql_plus_command is called when production sql_plus_command is exited. +func (s *BasePlSqlParserListener) ExitSql_plus_command(ctx *Sql_plus_commandContext) {} + +// EnterWhenever_command is called when production whenever_command is entered. +func (s *BasePlSqlParserListener) EnterWhenever_command(ctx *Whenever_commandContext) {} + +// ExitWhenever_command is called when production whenever_command is exited. +func (s *BasePlSqlParserListener) ExitWhenever_command(ctx *Whenever_commandContext) {} + +// EnterSet_command is called when production set_command is entered. +func (s *BasePlSqlParserListener) EnterSet_command(ctx *Set_commandContext) {} + +// ExitSet_command is called when production set_command is exited. +func (s *BasePlSqlParserListener) ExitSet_command(ctx *Set_commandContext) {} + +// EnterTiming_command is called when production timing_command is entered. +func (s *BasePlSqlParserListener) EnterTiming_command(ctx *Timing_commandContext) {} + +// ExitTiming_command is called when production timing_command is exited. +func (s *BasePlSqlParserListener) ExitTiming_command(ctx *Timing_commandContext) {} + +// EnterPartition_extension_clause is called when production partition_extension_clause is entered. +func (s *BasePlSqlParserListener) EnterPartition_extension_clause(ctx *Partition_extension_clauseContext) { +} + +// ExitPartition_extension_clause is called when production partition_extension_clause is exited. +func (s *BasePlSqlParserListener) ExitPartition_extension_clause(ctx *Partition_extension_clauseContext) { +} + +// EnterColumn_alias is called when production column_alias is entered. +func (s *BasePlSqlParserListener) EnterColumn_alias(ctx *Column_aliasContext) {} + +// ExitColumn_alias is called when production column_alias is exited. +func (s *BasePlSqlParserListener) ExitColumn_alias(ctx *Column_aliasContext) {} + +// EnterTable_alias is called when production table_alias is entered. +func (s *BasePlSqlParserListener) EnterTable_alias(ctx *Table_aliasContext) {} + +// ExitTable_alias is called when production table_alias is exited. +func (s *BasePlSqlParserListener) ExitTable_alias(ctx *Table_aliasContext) {} + +// EnterWhere_clause is called when production where_clause is entered. +func (s *BasePlSqlParserListener) EnterWhere_clause(ctx *Where_clauseContext) {} + +// ExitWhere_clause is called when production where_clause is exited. +func (s *BasePlSqlParserListener) ExitWhere_clause(ctx *Where_clauseContext) {} + +// EnterQuantitative_where_stmt is called when production quantitative_where_stmt is entered. +func (s *BasePlSqlParserListener) EnterQuantitative_where_stmt(ctx *Quantitative_where_stmtContext) {} + +// ExitQuantitative_where_stmt is called when production quantitative_where_stmt is exited. +func (s *BasePlSqlParserListener) ExitQuantitative_where_stmt(ctx *Quantitative_where_stmtContext) {} + +// EnterInto_clause is called when production into_clause is entered. +func (s *BasePlSqlParserListener) EnterInto_clause(ctx *Into_clauseContext) {} + +// ExitInto_clause is called when production into_clause is exited. +func (s *BasePlSqlParserListener) ExitInto_clause(ctx *Into_clauseContext) {} + +// EnterXml_column_name is called when production xml_column_name is entered. +func (s *BasePlSqlParserListener) EnterXml_column_name(ctx *Xml_column_nameContext) {} + +// ExitXml_column_name is called when production xml_column_name is exited. +func (s *BasePlSqlParserListener) ExitXml_column_name(ctx *Xml_column_nameContext) {} + +// EnterCost_class_name is called when production cost_class_name is entered. +func (s *BasePlSqlParserListener) EnterCost_class_name(ctx *Cost_class_nameContext) {} + +// ExitCost_class_name is called when production cost_class_name is exited. +func (s *BasePlSqlParserListener) ExitCost_class_name(ctx *Cost_class_nameContext) {} + +// EnterAttribute_name is called when production attribute_name is entered. +func (s *BasePlSqlParserListener) EnterAttribute_name(ctx *Attribute_nameContext) {} + +// ExitAttribute_name is called when production attribute_name is exited. +func (s *BasePlSqlParserListener) ExitAttribute_name(ctx *Attribute_nameContext) {} + +// EnterSavepoint_name is called when production savepoint_name is entered. +func (s *BasePlSqlParserListener) EnterSavepoint_name(ctx *Savepoint_nameContext) {} + +// ExitSavepoint_name is called when production savepoint_name is exited. +func (s *BasePlSqlParserListener) ExitSavepoint_name(ctx *Savepoint_nameContext) {} + +// EnterRollback_segment_name is called when production rollback_segment_name is entered. +func (s *BasePlSqlParserListener) EnterRollback_segment_name(ctx *Rollback_segment_nameContext) {} + +// ExitRollback_segment_name is called when production rollback_segment_name is exited. +func (s *BasePlSqlParserListener) ExitRollback_segment_name(ctx *Rollback_segment_nameContext) {} + +// EnterTable_var_name is called when production table_var_name is entered. +func (s *BasePlSqlParserListener) EnterTable_var_name(ctx *Table_var_nameContext) {} + +// ExitTable_var_name is called when production table_var_name is exited. +func (s *BasePlSqlParserListener) ExitTable_var_name(ctx *Table_var_nameContext) {} + +// EnterSchema_name is called when production schema_name is entered. +func (s *BasePlSqlParserListener) EnterSchema_name(ctx *Schema_nameContext) {} + +// ExitSchema_name is called when production schema_name is exited. +func (s *BasePlSqlParserListener) ExitSchema_name(ctx *Schema_nameContext) {} + +// EnterRoutine_name is called when production routine_name is entered. +func (s *BasePlSqlParserListener) EnterRoutine_name(ctx *Routine_nameContext) {} + +// ExitRoutine_name is called when production routine_name is exited. +func (s *BasePlSqlParserListener) ExitRoutine_name(ctx *Routine_nameContext) {} + +// EnterPackage_name is called when production package_name is entered. +func (s *BasePlSqlParserListener) EnterPackage_name(ctx *Package_nameContext) {} + +// ExitPackage_name is called when production package_name is exited. +func (s *BasePlSqlParserListener) ExitPackage_name(ctx *Package_nameContext) {} + +// EnterImplementation_type_name is called when production implementation_type_name is entered. +func (s *BasePlSqlParserListener) EnterImplementation_type_name(ctx *Implementation_type_nameContext) { +} + +// ExitImplementation_type_name is called when production implementation_type_name is exited. +func (s *BasePlSqlParserListener) ExitImplementation_type_name(ctx *Implementation_type_nameContext) { +} + +// EnterParameter_name is called when production parameter_name is entered. +func (s *BasePlSqlParserListener) EnterParameter_name(ctx *Parameter_nameContext) {} + +// ExitParameter_name is called when production parameter_name is exited. +func (s *BasePlSqlParserListener) ExitParameter_name(ctx *Parameter_nameContext) {} + +// EnterReference_model_name is called when production reference_model_name is entered. +func (s *BasePlSqlParserListener) EnterReference_model_name(ctx *Reference_model_nameContext) {} + +// ExitReference_model_name is called when production reference_model_name is exited. +func (s *BasePlSqlParserListener) ExitReference_model_name(ctx *Reference_model_nameContext) {} + +// EnterMain_model_name is called when production main_model_name is entered. +func (s *BasePlSqlParserListener) EnterMain_model_name(ctx *Main_model_nameContext) {} + +// ExitMain_model_name is called when production main_model_name is exited. +func (s *BasePlSqlParserListener) ExitMain_model_name(ctx *Main_model_nameContext) {} + +// EnterContainer_tableview_name is called when production container_tableview_name is entered. +func (s *BasePlSqlParserListener) EnterContainer_tableview_name(ctx *Container_tableview_nameContext) { +} + +// ExitContainer_tableview_name is called when production container_tableview_name is exited. +func (s *BasePlSqlParserListener) ExitContainer_tableview_name(ctx *Container_tableview_nameContext) { +} + +// EnterAggregate_function_name is called when production aggregate_function_name is entered. +func (s *BasePlSqlParserListener) EnterAggregate_function_name(ctx *Aggregate_function_nameContext) {} + +// ExitAggregate_function_name is called when production aggregate_function_name is exited. +func (s *BasePlSqlParserListener) ExitAggregate_function_name(ctx *Aggregate_function_nameContext) {} + +// EnterQuery_name is called when production query_name is entered. +func (s *BasePlSqlParserListener) EnterQuery_name(ctx *Query_nameContext) {} + +// ExitQuery_name is called when production query_name is exited. +func (s *BasePlSqlParserListener) ExitQuery_name(ctx *Query_nameContext) {} + +// EnterGrantee_name is called when production grantee_name is entered. +func (s *BasePlSqlParserListener) EnterGrantee_name(ctx *Grantee_nameContext) {} + +// ExitGrantee_name is called when production grantee_name is exited. +func (s *BasePlSqlParserListener) ExitGrantee_name(ctx *Grantee_nameContext) {} + +// EnterRole_name is called when production role_name is entered. +func (s *BasePlSqlParserListener) EnterRole_name(ctx *Role_nameContext) {} + +// ExitRole_name is called when production role_name is exited. +func (s *BasePlSqlParserListener) ExitRole_name(ctx *Role_nameContext) {} + +// EnterConstraint_name is called when production constraint_name is entered. +func (s *BasePlSqlParserListener) EnterConstraint_name(ctx *Constraint_nameContext) {} + +// ExitConstraint_name is called when production constraint_name is exited. +func (s *BasePlSqlParserListener) ExitConstraint_name(ctx *Constraint_nameContext) {} + +// EnterLabel_name is called when production label_name is entered. +func (s *BasePlSqlParserListener) EnterLabel_name(ctx *Label_nameContext) {} + +// ExitLabel_name is called when production label_name is exited. +func (s *BasePlSqlParserListener) ExitLabel_name(ctx *Label_nameContext) {} + +// EnterType_name is called when production type_name is entered. +func (s *BasePlSqlParserListener) EnterType_name(ctx *Type_nameContext) {} + +// ExitType_name is called when production type_name is exited. +func (s *BasePlSqlParserListener) ExitType_name(ctx *Type_nameContext) {} + +// EnterSequence_name is called when production sequence_name is entered. +func (s *BasePlSqlParserListener) EnterSequence_name(ctx *Sequence_nameContext) {} + +// ExitSequence_name is called when production sequence_name is exited. +func (s *BasePlSqlParserListener) ExitSequence_name(ctx *Sequence_nameContext) {} + +// EnterException_name is called when production exception_name is entered. +func (s *BasePlSqlParserListener) EnterException_name(ctx *Exception_nameContext) {} + +// ExitException_name is called when production exception_name is exited. +func (s *BasePlSqlParserListener) ExitException_name(ctx *Exception_nameContext) {} + +// EnterFunction_name is called when production function_name is entered. +func (s *BasePlSqlParserListener) EnterFunction_name(ctx *Function_nameContext) {} + +// ExitFunction_name is called when production function_name is exited. +func (s *BasePlSqlParserListener) ExitFunction_name(ctx *Function_nameContext) {} + +// EnterProcedure_name is called when production procedure_name is entered. +func (s *BasePlSqlParserListener) EnterProcedure_name(ctx *Procedure_nameContext) {} + +// ExitProcedure_name is called when production procedure_name is exited. +func (s *BasePlSqlParserListener) ExitProcedure_name(ctx *Procedure_nameContext) {} + +// EnterTrigger_name is called when production trigger_name is entered. +func (s *BasePlSqlParserListener) EnterTrigger_name(ctx *Trigger_nameContext) {} + +// ExitTrigger_name is called when production trigger_name is exited. +func (s *BasePlSqlParserListener) ExitTrigger_name(ctx *Trigger_nameContext) {} + +// EnterVariable_name is called when production variable_name is entered. +func (s *BasePlSqlParserListener) EnterVariable_name(ctx *Variable_nameContext) {} + +// ExitVariable_name is called when production variable_name is exited. +func (s *BasePlSqlParserListener) ExitVariable_name(ctx *Variable_nameContext) {} + +// EnterIndex_name is called when production index_name is entered. +func (s *BasePlSqlParserListener) EnterIndex_name(ctx *Index_nameContext) {} + +// ExitIndex_name is called when production index_name is exited. +func (s *BasePlSqlParserListener) ExitIndex_name(ctx *Index_nameContext) {} + +// EnterCursor_name is called when production cursor_name is entered. +func (s *BasePlSqlParserListener) EnterCursor_name(ctx *Cursor_nameContext) {} + +// ExitCursor_name is called when production cursor_name is exited. +func (s *BasePlSqlParserListener) ExitCursor_name(ctx *Cursor_nameContext) {} + +// EnterRecord_name is called when production record_name is entered. +func (s *BasePlSqlParserListener) EnterRecord_name(ctx *Record_nameContext) {} + +// ExitRecord_name is called when production record_name is exited. +func (s *BasePlSqlParserListener) ExitRecord_name(ctx *Record_nameContext) {} + +// EnterCollection_name is called when production collection_name is entered. +func (s *BasePlSqlParserListener) EnterCollection_name(ctx *Collection_nameContext) {} + +// ExitCollection_name is called when production collection_name is exited. +func (s *BasePlSqlParserListener) ExitCollection_name(ctx *Collection_nameContext) {} + +// EnterLink_name is called when production link_name is entered. +func (s *BasePlSqlParserListener) EnterLink_name(ctx *Link_nameContext) {} + +// ExitLink_name is called when production link_name is exited. +func (s *BasePlSqlParserListener) ExitLink_name(ctx *Link_nameContext) {} + +// EnterColumn_name is called when production column_name is entered. +func (s *BasePlSqlParserListener) EnterColumn_name(ctx *Column_nameContext) {} + +// ExitColumn_name is called when production column_name is exited. +func (s *BasePlSqlParserListener) ExitColumn_name(ctx *Column_nameContext) {} + +// EnterTableview_name is called when production tableview_name is entered. +func (s *BasePlSqlParserListener) EnterTableview_name(ctx *Tableview_nameContext) {} + +// ExitTableview_name is called when production tableview_name is exited. +func (s *BasePlSqlParserListener) ExitTableview_name(ctx *Tableview_nameContext) {} + +// EnterXmltable is called when production xmltable is entered. +func (s *BasePlSqlParserListener) EnterXmltable(ctx *XmltableContext) {} + +// ExitXmltable is called when production xmltable is exited. +func (s *BasePlSqlParserListener) ExitXmltable(ctx *XmltableContext) {} + +// EnterChar_set_name is called when production char_set_name is entered. +func (s *BasePlSqlParserListener) EnterChar_set_name(ctx *Char_set_nameContext) {} + +// ExitChar_set_name is called when production char_set_name is exited. +func (s *BasePlSqlParserListener) ExitChar_set_name(ctx *Char_set_nameContext) {} + +// EnterSynonym_name is called when production synonym_name is entered. +func (s *BasePlSqlParserListener) EnterSynonym_name(ctx *Synonym_nameContext) {} + +// ExitSynonym_name is called when production synonym_name is exited. +func (s *BasePlSqlParserListener) ExitSynonym_name(ctx *Synonym_nameContext) {} + +// EnterSchema_object_name is called when production schema_object_name is entered. +func (s *BasePlSqlParserListener) EnterSchema_object_name(ctx *Schema_object_nameContext) {} + +// ExitSchema_object_name is called when production schema_object_name is exited. +func (s *BasePlSqlParserListener) ExitSchema_object_name(ctx *Schema_object_nameContext) {} + +// EnterDir_object_name is called when production dir_object_name is entered. +func (s *BasePlSqlParserListener) EnterDir_object_name(ctx *Dir_object_nameContext) {} + +// ExitDir_object_name is called when production dir_object_name is exited. +func (s *BasePlSqlParserListener) ExitDir_object_name(ctx *Dir_object_nameContext) {} + +// EnterUser_object_name is called when production user_object_name is entered. +func (s *BasePlSqlParserListener) EnterUser_object_name(ctx *User_object_nameContext) {} + +// ExitUser_object_name is called when production user_object_name is exited. +func (s *BasePlSqlParserListener) ExitUser_object_name(ctx *User_object_nameContext) {} + +// EnterGrant_object_name is called when production grant_object_name is entered. +func (s *BasePlSqlParserListener) EnterGrant_object_name(ctx *Grant_object_nameContext) {} + +// ExitGrant_object_name is called when production grant_object_name is exited. +func (s *BasePlSqlParserListener) ExitGrant_object_name(ctx *Grant_object_nameContext) {} + +// EnterColumn_list is called when production column_list is entered. +func (s *BasePlSqlParserListener) EnterColumn_list(ctx *Column_listContext) {} + +// ExitColumn_list is called when production column_list is exited. +func (s *BasePlSqlParserListener) ExitColumn_list(ctx *Column_listContext) {} + +// EnterParen_column_list is called when production paren_column_list is entered. +func (s *BasePlSqlParserListener) EnterParen_column_list(ctx *Paren_column_listContext) {} + +// ExitParen_column_list is called when production paren_column_list is exited. +func (s *BasePlSqlParserListener) ExitParen_column_list(ctx *Paren_column_listContext) {} + +// EnterKeep_clause is called when production keep_clause is entered. +func (s *BasePlSqlParserListener) EnterKeep_clause(ctx *Keep_clauseContext) {} + +// ExitKeep_clause is called when production keep_clause is exited. +func (s *BasePlSqlParserListener) ExitKeep_clause(ctx *Keep_clauseContext) {} + +// EnterFunction_argument is called when production function_argument is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument(ctx *Function_argumentContext) {} + +// ExitFunction_argument is called when production function_argument is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument(ctx *Function_argumentContext) {} + +// EnterFunction_argument_analytic is called when production function_argument_analytic is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument_analytic(ctx *Function_argument_analyticContext) { +} + +// ExitFunction_argument_analytic is called when production function_argument_analytic is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument_analytic(ctx *Function_argument_analyticContext) { +} + +// EnterFunction_argument_modeling is called when production function_argument_modeling is entered. +func (s *BasePlSqlParserListener) EnterFunction_argument_modeling(ctx *Function_argument_modelingContext) { +} + +// ExitFunction_argument_modeling is called when production function_argument_modeling is exited. +func (s *BasePlSqlParserListener) ExitFunction_argument_modeling(ctx *Function_argument_modelingContext) { +} + +// EnterRespect_or_ignore_nulls is called when production respect_or_ignore_nulls is entered. +func (s *BasePlSqlParserListener) EnterRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) {} + +// ExitRespect_or_ignore_nulls is called when production respect_or_ignore_nulls is exited. +func (s *BasePlSqlParserListener) ExitRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) {} + +// EnterArgument is called when production argument is entered. +func (s *BasePlSqlParserListener) EnterArgument(ctx *ArgumentContext) {} + +// ExitArgument is called when production argument is exited. +func (s *BasePlSqlParserListener) ExitArgument(ctx *ArgumentContext) {} + +// EnterType_spec is called when production type_spec is entered. +func (s *BasePlSqlParserListener) EnterType_spec(ctx *Type_specContext) {} + +// ExitType_spec is called when production type_spec is exited. +func (s *BasePlSqlParserListener) ExitType_spec(ctx *Type_specContext) {} + +// EnterDatatype is called when production datatype is entered. +func (s *BasePlSqlParserListener) EnterDatatype(ctx *DatatypeContext) {} + +// ExitDatatype is called when production datatype is exited. +func (s *BasePlSqlParserListener) ExitDatatype(ctx *DatatypeContext) {} + +// EnterPrecision_part is called when production precision_part is entered. +func (s *BasePlSqlParserListener) EnterPrecision_part(ctx *Precision_partContext) {} + +// ExitPrecision_part is called when production precision_part is exited. +func (s *BasePlSqlParserListener) ExitPrecision_part(ctx *Precision_partContext) {} + +// EnterNative_datatype_element is called when production native_datatype_element is entered. +func (s *BasePlSqlParserListener) EnterNative_datatype_element(ctx *Native_datatype_elementContext) {} + +// ExitNative_datatype_element is called when production native_datatype_element is exited. +func (s *BasePlSqlParserListener) ExitNative_datatype_element(ctx *Native_datatype_elementContext) {} + +// EnterBind_variable is called when production bind_variable is entered. +func (s *BasePlSqlParserListener) EnterBind_variable(ctx *Bind_variableContext) {} + +// ExitBind_variable is called when production bind_variable is exited. +func (s *BasePlSqlParserListener) ExitBind_variable(ctx *Bind_variableContext) {} + +// EnterGeneral_element is called when production general_element is entered. +func (s *BasePlSqlParserListener) EnterGeneral_element(ctx *General_elementContext) {} + +// ExitGeneral_element is called when production general_element is exited. +func (s *BasePlSqlParserListener) ExitGeneral_element(ctx *General_elementContext) {} + +// EnterGeneral_element_part is called when production general_element_part is entered. +func (s *BasePlSqlParserListener) EnterGeneral_element_part(ctx *General_element_partContext) {} + +// ExitGeneral_element_part is called when production general_element_part is exited. +func (s *BasePlSqlParserListener) ExitGeneral_element_part(ctx *General_element_partContext) {} + +// EnterTable_element is called when production table_element is entered. +func (s *BasePlSqlParserListener) EnterTable_element(ctx *Table_elementContext) {} + +// ExitTable_element is called when production table_element is exited. +func (s *BasePlSqlParserListener) ExitTable_element(ctx *Table_elementContext) {} + +// EnterObject_privilege is called when production object_privilege is entered. +func (s *BasePlSqlParserListener) EnterObject_privilege(ctx *Object_privilegeContext) {} + +// ExitObject_privilege is called when production object_privilege is exited. +func (s *BasePlSqlParserListener) ExitObject_privilege(ctx *Object_privilegeContext) {} + +// EnterSystem_privilege is called when production system_privilege is entered. +func (s *BasePlSqlParserListener) EnterSystem_privilege(ctx *System_privilegeContext) {} + +// ExitSystem_privilege is called when production system_privilege is exited. +func (s *BasePlSqlParserListener) ExitSystem_privilege(ctx *System_privilegeContext) {} + +// EnterConstant is called when production constant is entered. +func (s *BasePlSqlParserListener) EnterConstant(ctx *ConstantContext) {} + +// ExitConstant is called when production constant is exited. +func (s *BasePlSqlParserListener) ExitConstant(ctx *ConstantContext) {} + +// EnterConstant_without_variable is called when production constant_without_variable is entered. +func (s *BasePlSqlParserListener) EnterConstant_without_variable(ctx *Constant_without_variableContext) { +} + +// ExitConstant_without_variable is called when production constant_without_variable is exited. +func (s *BasePlSqlParserListener) ExitConstant_without_variable(ctx *Constant_without_variableContext) { +} + +// EnterNumeric is called when production numeric is entered. +func (s *BasePlSqlParserListener) EnterNumeric(ctx *NumericContext) {} + +// ExitNumeric is called when production numeric is exited. +func (s *BasePlSqlParserListener) ExitNumeric(ctx *NumericContext) {} + +// EnterNumeric_negative is called when production numeric_negative is entered. +func (s *BasePlSqlParserListener) EnterNumeric_negative(ctx *Numeric_negativeContext) {} + +// ExitNumeric_negative is called when production numeric_negative is exited. +func (s *BasePlSqlParserListener) ExitNumeric_negative(ctx *Numeric_negativeContext) {} + +// EnterQuoted_string is called when production quoted_string is entered. +func (s *BasePlSqlParserListener) EnterQuoted_string(ctx *Quoted_stringContext) {} + +// ExitQuoted_string is called when production quoted_string is exited. +func (s *BasePlSqlParserListener) ExitQuoted_string(ctx *Quoted_stringContext) {} + +// EnterChar_str is called when production char_str is entered. +func (s *BasePlSqlParserListener) EnterChar_str(ctx *Char_strContext) {} + +// ExitChar_str is called when production char_str is exited. +func (s *BasePlSqlParserListener) ExitChar_str(ctx *Char_strContext) {} + +// EnterIdentifier is called when production identifier is entered. +func (s *BasePlSqlParserListener) EnterIdentifier(ctx *IdentifierContext) {} + +// ExitIdentifier is called when production identifier is exited. +func (s *BasePlSqlParserListener) ExitIdentifier(ctx *IdentifierContext) {} + +// EnterId_expression is called when production id_expression is entered. +func (s *BasePlSqlParserListener) EnterId_expression(ctx *Id_expressionContext) {} + +// ExitId_expression is called when production id_expression is exited. +func (s *BasePlSqlParserListener) ExitId_expression(ctx *Id_expressionContext) {} + +// EnterOuter_join_sign is called when production outer_join_sign is entered. +func (s *BasePlSqlParserListener) EnterOuter_join_sign(ctx *Outer_join_signContext) {} + +// ExitOuter_join_sign is called when production outer_join_sign is exited. +func (s *BasePlSqlParserListener) ExitOuter_join_sign(ctx *Outer_join_signContext) {} + +// EnterRegular_id is called when production regular_id is entered. +func (s *BasePlSqlParserListener) EnterRegular_id(ctx *Regular_idContext) {} + +// ExitRegular_id is called when production regular_id is exited. +func (s *BasePlSqlParserListener) ExitRegular_id(ctx *Regular_idContext) {} + +// EnterNon_reserved_keywords_in_12c is called when production non_reserved_keywords_in_12c is entered. +func (s *BasePlSqlParserListener) EnterNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) { +} + +// ExitNon_reserved_keywords_in_12c is called when production non_reserved_keywords_in_12c is exited. +func (s *BasePlSqlParserListener) ExitNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) { +} + +// EnterNon_reserved_keywords_pre12c is called when production non_reserved_keywords_pre12c is entered. +func (s *BasePlSqlParserListener) EnterNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) { +} + +// ExitNon_reserved_keywords_pre12c is called when production non_reserved_keywords_pre12c is exited. +func (s *BasePlSqlParserListener) ExitNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) { +} + +// EnterString_function_name is called when production string_function_name is entered. +func (s *BasePlSqlParserListener) EnterString_function_name(ctx *String_function_nameContext) {} + +// ExitString_function_name is called when production string_function_name is exited. +func (s *BasePlSqlParserListener) ExitString_function_name(ctx *String_function_nameContext) {} + +// EnterNumeric_function_name is called when production numeric_function_name is entered. +func (s *BasePlSqlParserListener) EnterNumeric_function_name(ctx *Numeric_function_nameContext) {} + +// ExitNumeric_function_name is called when production numeric_function_name is exited. +func (s *BasePlSqlParserListener) ExitNumeric_function_name(ctx *Numeric_function_nameContext) {} diff --git a/plsql/plsqlparser_base_visitor.go b/plsql/plsqlparser_base_visitor.go new file mode 100644 index 0000000..0302dc3 --- /dev/null +++ b/plsql/plsqlparser_base_visitor.go @@ -0,0 +1,4800 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +type BasePlSqlParserVisitor struct { + *antlr.BaseParseTreeVisitor +} + +func (v *BasePlSqlParserVisitor) VisitSql_script(ctx *Sql_scriptContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnit_statement(ctx *Unit_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_diskgroup(ctx *Alter_diskgroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_disk_clause(ctx *Add_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_disk_clause(ctx *Drop_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitResize_disk_clause(ctx *Resize_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReplace_disk_clause(ctx *Replace_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWait_nowait(ctx *Wait_nowaitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRename_disk_clause(ctx *Rename_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisk_online_clause(ctx *Disk_online_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisk_offline_clause(ctx *Disk_offline_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTimeout_clause(ctx *Timeout_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPhase(ctx *PhaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQualified_template_clause(ctx *Qualified_template_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRedundancy_clause(ctx *Redundancy_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStriping_clause(ctx *Striping_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitForce_noforce(ctx *Force_noforceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDir_name(ctx *Dir_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_volume_clause(ctx *Add_volume_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_volume_clause(ctx *Modify_volume_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_attributes(ctx *Diskgroup_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_diskgroup_file(ctx *Modify_diskgroup_fileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisk_region_clause(ctx *Disk_region_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsergroup_clauses(ctx *Usergroup_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_clauses(ctx *User_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_permissions_clause(ctx *File_permissions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_owner_clause(ctx *File_owner_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitScrub_clause(ctx *Scrub_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuotagroup_clauses(ctx *Quotagroup_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProperty_name(ctx *Property_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProperty_value(ctx *Property_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFilegroup_clauses(ctx *Filegroup_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuorum_regular(ctx *Quorum_regularContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUndrop_disk_clause(ctx *Undrop_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDiskgroup_availability(ctx *Diskgroup_availabilityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnable_disable_volume(ctx *Enable_disable_volumeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_function(ctx *Drop_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_flashback_archive(ctx *Alter_flashback_archiveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_hierarchy(ctx *Alter_hierarchyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_function(ctx *Alter_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_java(ctx *Alter_javaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMatch_string(ctx *Match_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_function_body(ctx *Create_function_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSql_macro_body(ctx *Sql_macro_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParallel_enable_clause(ctx *Parallel_enable_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_by_clause(ctx *Partition_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitResult_cache_clause(ctx *Result_cache_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRelies_on_part(ctx *Relies_on_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStreaming_clause(ctx *Streaming_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_outline(ctx *Alter_outlineContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOutline_options(ctx *Outline_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLockdown_feature(ctx *Lockdown_featureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLockdown_options(ctx *Lockdown_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLockdown_statements(ctx *Lockdown_statementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStatement_clauses(ctx *Statement_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClause_options(ctx *Clause_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOption_values(ctx *Option_valuesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitString_list(ctx *String_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisable_enable(ctx *Disable_enableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_package(ctx *Drop_packageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_package(ctx *Alter_packageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_package(ctx *Create_packageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_package_body(ctx *Create_package_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPackage_obj_spec(ctx *Package_obj_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProcedure_spec(ctx *Procedure_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_spec(ctx *Function_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPackage_obj_body(ctx *Package_obj_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_procedure(ctx *Drop_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_procedure(ctx *Alter_procedureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_body(ctx *Function_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProcedure_body(ctx *Procedure_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_procedure_body(ctx *Create_procedure_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_resource_cost(ctx *Alter_resource_costContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_outline(ctx *Drop_outlineContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_rollback_segment(ctx *Alter_rollback_segmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_restore_point(ctx *Drop_restore_pointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_rollback_segment(ctx *Drop_rollback_segmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_role(ctx *Drop_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPmem_filestore_options(ctx *Pmem_filestore_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_path(ctx *File_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_rollback_segment(ctx *Create_rollback_segmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_trigger(ctx *Drop_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_trigger(ctx *Alter_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_trigger(ctx *Create_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrigger_follows_clause(ctx *Trigger_follows_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrigger_when_clause(ctx *Trigger_when_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSimple_dml_trigger(ctx *Simple_dml_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFor_each_row(ctx *For_each_rowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompound_dml_trigger(ctx *Compound_dml_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNon_dml_trigger(ctx *Non_dml_triggerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrigger_body(ctx *Trigger_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRoutine_clause(ctx *Routine_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompound_trigger_block(ctx *Compound_trigger_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTiming_point_section(ctx *Timing_point_sectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNon_dml_event(ctx *Non_dml_eventContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDml_event_clause(ctx *Dml_event_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDml_event_element(ctx *Dml_event_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReferencing_clause(ctx *Referencing_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReferencing_element(ctx *Referencing_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_type(ctx *Drop_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_type(ctx *Alter_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompile_type_clause(ctx *Compile_type_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReplace_type_clause(ctx *Replace_type_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_method_spec(ctx *Alter_method_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_method_element(ctx *Alter_method_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_attribute_definition(ctx *Alter_attribute_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAttribute_definition(ctx *Attribute_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_collection_clauses(ctx *Alter_collection_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDependent_handling_clause(ctx *Dependent_handling_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDependent_exceptions_part(ctx *Dependent_exceptions_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_type(ctx *Create_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_definition(ctx *Type_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_type_def(ctx *Object_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_as_part(ctx *Object_as_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_under_part(ctx *Object_under_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNested_table_type_def(ctx *Nested_table_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSqlj_object_type(ctx *Sqlj_object_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_body(ctx *Type_bodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_body_elements(ctx *Type_body_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMap_order_func_declaration(ctx *Map_order_func_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProc_decl_in_type(ctx *Proc_decl_in_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunc_decl_in_type(ctx *Func_decl_in_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstructor_declaration(ctx *Constructor_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModifier_clause(ctx *Modifier_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_member_spec(ctx *Object_member_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitElement_spec(ctx *Element_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitElement_spec_options(ctx *Element_spec_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubprogram_spec(ctx *Subprogram_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOverriding_function_spec(ctx *Overriding_function_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_procedure_spec(ctx *Type_procedure_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_function_spec(ctx *Type_function_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstructor_spec(ctx *Constructor_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMap_order_function_spec(ctx *Map_order_function_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPragma_clause(ctx *Pragma_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPragma_elements(ctx *Pragma_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_elements_parameter(ctx *Type_elements_parameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_session(ctx *Alter_sessionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_session_set_clause(ctx *Alter_session_set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_sequence(ctx *Create_sequenceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSequence_spec(ctx *Sequence_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSequence_start_clause(ctx *Sequence_start_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_analytic_view(ctx *Create_analytic_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClassification_clause(ctx *Classification_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCaption_clause(ctx *Caption_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDescription_clause(ctx *Description_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClassification_item(ctx *Classification_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLanguage(ctx *LanguageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCav_using_clause(ctx *Cav_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDim_by_clause(ctx *Dim_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDim_key(ctx *Dim_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDim_ref(ctx *Dim_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHier_ref(ctx *Hier_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMeasures_clause(ctx *Measures_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAv_measure(ctx *Av_measureContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBase_meas_clause(ctx *Base_meas_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCalc_meas_clause(ctx *Calc_meas_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_measure_clause(ctx *Default_measure_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCache_clause(ctx *Cache_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCache_specification(ctx *Cache_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevels_clause(ctx *Levels_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevel_specification(ctx *Level_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevel_group_type(ctx *Level_group_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFact_columns_clause(ctx *Fact_columns_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQry_transform_clause(ctx *Qry_transform_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAd_using_clause(ctx *Ad_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSource_clause(ctx *Source_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_path_clause(ctx *Join_path_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_condition(ctx *Join_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_condition_item(ctx *Join_condition_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAttributes_clause(ctx *Attributes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAd_attributes_clause(ctx *Ad_attributes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAd_level_clause(ctx *Ad_level_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKey_clause(ctx *Key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlternate_key_clause(ctx *Alternate_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDim_order_clause(ctx *Dim_order_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAll_clause(ctx *All_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_audit_policy(ctx *Create_audit_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAction_audit_clause(ctx *Action_audit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStandard_actions(ctx *Standard_actionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitActions_clause(ctx *Actions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_action(ctx *Object_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSystem_action(ctx *System_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComponent_actions(ctx *Component_actionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComponent_action(ctx *Component_actionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRole_audit_clause(ctx *Role_audit_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_controlfile(ctx *Create_controlfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitControlfile_options(ctx *Controlfile_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogfile_clause(ctx *Logfile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCharacter_set_clause(ctx *Character_set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_specification(ctx *File_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_diskgroup(ctx *Create_diskgroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQualified_disk_clause(ctx *Qualified_disk_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_edition(ctx *Create_editionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_flashback_archive(ctx *Create_flashback_archiveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_archive_quota(ctx *Flashback_archive_quotaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_archive_retention(ctx *Flashback_archive_retentionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_hierarchy(ctx *Create_hierarchyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHier_using_clause(ctx *Hier_using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevel_hier_clause(ctx *Level_hier_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHier_attrs_clause(ctx *Hier_attrs_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHier_attr_clause(ctx *Hier_attr_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHier_attr_name(ctx *Hier_attr_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_index(ctx *Create_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCluster_index_clause(ctx *Cluster_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCluster_name(ctx *Cluster_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_index_clause(ctx *Table_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_expr_option(ctx *Index_expr_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_expr(ctx *Index_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_properties(ctx *Index_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDomain_index_clause(ctx *Domain_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlindex_clause(ctx *Xmlindex_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGlobal_partitioned_index(ctx *Global_partitioned_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLocal_partitioned_index(ctx *Local_partitioned_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartitioned_table(ctx *Partitioned_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOdci_parameters(ctx *Odci_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndextype(ctx *IndextypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_index(ctx *Alter_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVisible_or_invisible(ctx *Visible_or_invisibleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRebuild_clause(ctx *Rebuild_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_index_partitioning(ctx *Alter_index_partitioningContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_index_default_attrs(ctx *Modify_index_default_attrsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCoalesce_index_partition(ctx *Coalesce_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_index_partition(ctx *Modify_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRename_index_partition(ctx *Rename_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_index_partition(ctx *Drop_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSplit_index_partition(ctx *Split_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_partition_description(ctx *Index_partition_descriptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_index_subpartition(ctx *Modify_index_subpartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_name_old(ctx *Partition_name_oldContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_partition_name(ctx *New_partition_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_index_name(ctx *New_index_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_user(ctx *Create_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_user(ctx *Alter_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_user(ctx *Drop_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_identified_by(ctx *Alter_identified_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentified_by(ctx *Identified_byContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentified_other_clause(ctx *Identified_other_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_tablespace_clause(ctx *User_tablespace_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuota_clause(ctx *Quota_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProfile_clause(ctx *Profile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRole_clause(ctx *Role_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_default_role_clause(ctx *User_default_role_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPassword_expire_clause(ctx *Password_expire_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_lock_clause(ctx *User_lock_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_editions_clause(ctx *User_editions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProxy_clause(ctx *Proxy_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitContainer_names(ctx *Container_namesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_container_data(ctx *Set_container_dataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_rem_container_data(ctx *Add_rem_container_dataContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitContainer_data_clause(ctx *Container_data_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdminister_key_management(ctx *Administer_key_managementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKeystore_management_clauses(ctx *Keystore_management_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_keystore(ctx *Create_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOpen_keystore(ctx *Open_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitForce_keystore(ctx *Force_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClose_keystore(ctx *Close_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBackup_keystore(ctx *Backup_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_keystore_password(ctx *Alter_keystore_passwordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIsolate_keystore(ctx *Isolate_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnite_keystore(ctx *Unite_keystoreContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKey_management_clauses(ctx *Key_management_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_key(ctx *Set_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_key(ctx *Create_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMkid(ctx *MkidContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMk(ctx *MkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUse_key(ctx *Use_keyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_key_tag(ctx *Set_key_tagContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExport_keys(ctx *Export_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImport_keys(ctx *Import_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMigrate_keys(ctx *Migrate_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReverse_migrate_keys(ctx *Reverse_migrate_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMove_keys(ctx *Move_keysContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentified_by_store(ctx *Identified_by_storeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_tag_clause(ctx *Using_tag_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSecret_management_clauses(ctx *Secret_management_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_update_secret(ctx *Add_update_secretContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDelete_secret(ctx *Delete_secretContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDelete_secret_seps(ctx *Delete_secret_sepsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWith_backup_clause(ctx *With_backup_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKeystore_password(ctx *Keystore_passwordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPath(ctx *PathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSecret(ctx *SecretContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAnalyze(ctx *AnalyzeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_extention_clause(ctx *Partition_extention_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitValidation_clauses(ctx *Validation_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompute_clauses(ctx *Compute_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFor_clause(ctx *For_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOnline_or_offline(ctx *Online_or_offlineContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInto_clause1(ctx *Into_clause1Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_key_value(ctx *Partition_key_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_key_value(ctx *Subpartition_key_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAssociate_statistics(ctx *Associate_statisticsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_association(ctx *Column_associationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_association(ctx *Function_associationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndextype_name(ctx *Indextype_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_statistics_type(ctx *Using_statistics_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStatistics_type_name(ctx *Statistics_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_cost_clause(ctx *Default_cost_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCpu_cost(ctx *Cpu_costContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIo_cost(ctx *Io_costContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNetwork_cost(ctx *Network_costContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_selectivity(ctx *Default_selectivityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStorage_table_clause(ctx *Storage_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnified_auditing(ctx *Unified_auditingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPolicy_name(ctx *Policy_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_traditional(ctx *Audit_traditionalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_direct_path(ctx *Audit_direct_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_container_clause(ctx *Audit_container_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_operation_clause(ctx *Audit_operation_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAuditing_by_clause(ctx *Auditing_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_user(ctx *Audit_userContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSql_operation(ctx *Sql_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAuditing_on_clause(ctx *Auditing_on_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_name(ctx *Model_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_name(ctx *Object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProfile_name(ctx *Profile_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSql_statement_shortcut(ctx *Sql_statement_shortcutContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_index(ctx *Drop_indexContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisassociate_statistics(ctx *Disassociate_statisticsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_indextype(ctx *Drop_indextypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_table(ctx *Flashback_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRestore_point(ctx *Restore_pointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPurge_statement(ctx *Purge_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNoaudit_statement(ctx *Noaudit_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRename_object(ctx *Rename_objectContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGrant_statement(ctx *Grant_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitContainer_clause(ctx *Container_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRevoke_statement(ctx *Revoke_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRevoke_system_privilege(ctx *Revoke_system_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRevokee_clause(ctx *Revokee_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRevoke_object_privileges(ctx *Revoke_object_privilegesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_object_clause(ctx *On_object_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProgram_unit(ctx *Program_unitContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_dimension(ctx *Create_dimensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_directory(ctx *Create_directoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDirectory_name(ctx *Directory_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDirectory_path(ctx *Directory_pathContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_hierarchy(ctx *Drop_hierarchyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_library(ctx *Alter_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_java(ctx *Drop_javaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_library(ctx *Drop_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_java(ctx *Create_javaContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_library(ctx *Create_libraryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPlsql_library_source(ctx *Plsql_library_sourceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCredential_name(ctx *Credential_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLibrary_editionable(ctx *Library_editionableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLibrary_debug(ctx *Library_debugContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParameter_value(ctx *Parameter_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLibrary_name(ctx *Library_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_dimension(ctx *Alter_dimensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevel_clause(ctx *Level_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHierarchy_clause(ctx *Hierarchy_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDimension_join_clause(ctx *Dimension_join_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAttribute_clause(ctx *Attribute_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExtended_attribute_clause(ctx *Extended_attribute_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_view(ctx *Alter_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_view_editionable(ctx *Alter_view_editionableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_view(ctx *Create_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEditioning_clause(ctx *Editioning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitView_options(ctx *View_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitView_alias_constraint(ctx *View_alias_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_view_clause(ctx *Object_view_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInline_constraint(ctx *Inline_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInline_ref_constraint(ctx *Inline_ref_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOut_of_line_constraint(ctx *Out_of_line_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstraint_state(ctx *Constraint_stateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltype_view_clause(ctx *Xmltype_view_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_schema_spec(ctx *Xml_schema_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_schema_url(ctx *Xml_schema_urlContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitElement(ctx *ElementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_tablespace(ctx *Alter_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_group_clause(ctx *Tablespace_group_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_group_name(ctx *Tablespace_group_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_state_clauses(ctx *Tablespace_state_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_mode_clause(ctx *Flashback_mode_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_tablespace_name(ctx *New_tablespace_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_tablespace(ctx *Create_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogging_clause(ctx *Logging_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExtent_management_clause(ctx *Extent_management_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSegment_management_clause(ctx *Segment_management_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_tablespace_set(ctx *Create_tablespace_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_tablespace_params(ctx *Default_tablespace_paramsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_table_compression(ctx *Default_table_compressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLow_high(ctx *Low_highContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_index_compression(ctx *Default_index_compressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmmemory_clause(ctx *Inmmemory_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatafile_specification(ctx *Datafile_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTempfile_specification(ctx *Tempfile_specificationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRedo_log_file_spec(ctx *Redo_log_file_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAutoextend_clause(ctx *Autoextend_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMaxsize_clause(ctx *Maxsize_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBuild_clause(ctx *Build_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartial_index_clause(ctx *Partial_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParallel_clause(ctx *Parallel_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_materialized_view(ctx *Alter_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_mv_option1(ctx *Alter_mv_option1Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_mv_refresh(ctx *Alter_mv_refreshContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRollback_segment(ctx *Rollback_segmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMove_mv_log_clause(ctx *Move_mv_log_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMv_log_augmentation(ctx *Mv_log_augmentationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatetime_expr(ctx *Datetime_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInterval_expr(ctx *Interval_exprContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSynchronous_or_asynchronous(ctx *Synchronous_or_asynchronousContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIncluding_or_excluding(ctx *Including_or_excludingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_materialized_view_log(ctx *Create_materialized_view_logContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_values_clause(ctx *New_values_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitZonemap_attributes(ctx *Zonemap_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitZonemap_name(ctx *Zonemap_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOperator_name(ctx *Operator_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOperator_function_name(ctx *Operator_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_operator(ctx *Alter_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_operator(ctx *Drop_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_operator(ctx *Create_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBinding_clause(ctx *Binding_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_binding_clause(ctx *Add_binding_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImplementation_clause(ctx *Implementation_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrimary_operator_list(ctx *Primary_operator_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrimary_operator_item(ctx *Primary_operator_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOperator_context_clause(ctx *Operator_context_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_function_clause(ctx *Using_function_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_binding_clause(ctx *Drop_binding_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_materialized_view(ctx *Create_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMv_column_alias(ctx *Mv_column_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_mv_refresh(ctx *Create_mv_refreshContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_materialized_view(ctx *Drop_materialized_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_context(ctx *Create_contextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOracle_namespace(ctx *Oracle_namespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_cluster(ctx *Create_clusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_profile(ctx *Create_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitResource_parameters(ctx *Resource_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPassword_parameters(ctx *Password_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_lockdown_profile(ctx *Create_lockdown_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStatic_base_profile(ctx *Static_base_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDynamic_base_profile(ctx *Dynamic_base_profileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_outline(ctx *Create_outlineContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_restore_point(ctx *Create_restore_pointContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_role(ctx *Create_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_table(ctx *Create_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltype_table(ctx *Xmltype_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltype_column_properties(ctx *Xmltype_column_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltype_storage(ctx *Xmltype_storageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlschema_spec(ctx *Xmlschema_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_table(ctx *Object_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_type(ctx *Object_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOid_index_clause(ctx *Oid_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOid_clause(ctx *Oid_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_properties(ctx *Object_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_table_substitution(ctx *Object_table_substitutionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRelational_table(ctx *Relational_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImmutable_table_clauses(ctx *Immutable_table_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCollation_name(ctx *Collation_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_properties(ctx *Table_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRead_only_clause(ctx *Read_only_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndexing_clause(ctx *Indexing_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClustering_join(ctx *Clustering_joinContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClustering_join_item(ctx *Clustering_join_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEquijoin_condition(ctx *Equijoin_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCluster_clause(ctx *Cluster_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClustering_columns(ctx *Clustering_columnsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClustering_column_group(ctx *Clustering_column_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitYes_no(ctx *Yes_noContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitZonemap_clause(ctx *Zonemap_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogical_replication_clause(ctx *Logical_replication_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_name(ctx *Table_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRelational_property(ctx *Relational_propertyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRange_partitions(ctx *Range_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitList_partitions(ctx *List_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHash_partitions(ctx *Hash_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHash_partition_quantity(ctx *Hash_partition_quantityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComposite_range_partitions(ctx *Composite_range_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComposite_list_partitions(ctx *Composite_list_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComposite_hash_partitions(ctx *Composite_hash_partitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReference_partitioning(ctx *Reference_partitioningContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReference_partition_desc(ctx *Reference_partition_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSystem_partitioning(ctx *System_partitioningContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRange_partition_desc(ctx *Range_partition_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitList_partition_desc(ctx *List_partition_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_template(ctx *Subpartition_templateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_by_range(ctx *Subpartition_by_rangeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_by_list(ctx *Subpartition_by_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_by_hash(ctx *Subpartition_by_hashContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_name(ctx *Subpartition_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRange_subpartition_desc(ctx *Range_subpartition_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitList_subpartition_desc(ctx *List_subpartition_descContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRange_values_clause(ctx *Range_values_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitList_values_clause(ctx *List_values_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_partition_description(ctx *Table_partition_descriptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_partitioning_storage(ctx *Lob_partitioning_storageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatatype_null_enable(ctx *Datatype_null_enableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSize_clause(ctx *Size_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_compression(ctx *Table_compressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_table_clause(ctx *Inmemory_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_attributes(ctx *Inmemory_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_memcompress(ctx *Inmemory_memcompressContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_priority(ctx *Inmemory_priorityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_distribute(ctx *Inmemory_distributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_duplicate(ctx *Inmemory_duplicateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInmemory_column_clause(ctx *Inmemory_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStorage_clause(ctx *Storage_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDeferred_segment_creation(ctx *Deferred_segment_creationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSegment_attributes_clause(ctx *Segment_attributes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPhysical_properties(ctx *Physical_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_clause(ctx *Ilm_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_policy_clause(ctx *Ilm_policy_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_compression_policy(ctx *Ilm_compression_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_tiering_policy(ctx *Ilm_tiering_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_after_on(ctx *Ilm_after_onContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSegment_group(ctx *Segment_groupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIlm_time_period(ctx *Ilm_time_periodContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHeap_org_table_clause(ctx *Heap_org_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExternal_table_clause(ctx *External_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAccess_driver_type(ctx *Access_driver_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExternal_table_data_props(ctx *External_table_data_propsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOpaque_format_spec(ctx *Opaque_format_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRecord_format_info(ctx *Record_format_infoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEt_string(ctx *Et_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEt_record_spec_options(ctx *Et_record_spec_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEt_record_spec_option(ctx *Et_record_spec_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEt_output_files(ctx *Et_output_filesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEt_output_file(ctx *Et_output_fileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDirectory_spec(ctx *Directory_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_spec(ctx *File_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_definitions(ctx *Field_definitionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_options(ctx *Field_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_option(ctx *Field_optionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_list(ctx *Field_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_item(ctx *Field_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_name(ctx *Field_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPos_spec(ctx *Pos_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPos_start(ctx *Pos_startContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPos_increment(ctx *Pos_incrementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPos_end(ctx *Pos_endContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPos_length(ctx *Pos_lengthContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatatype_spec(ctx *Datatype_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInit_spec(ctx *Init_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLls_clause(ctx *Lls_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDelim_spec(ctx *Delim_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrim_spec(ctx *Trim_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_date_format(ctx *Field_date_formatContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_transforms(ctx *Column_transformsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTransform(ctx *TransformContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSource_field(ctx *Source_fieldContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLobfile_item(ctx *Lobfile_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLobfile_attr_list(ctx *Lobfile_attr_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConcat_item(ctx *Concat_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRow_movement_clause(ctx *Row_movement_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_archive_clause(ctx *Flashback_archive_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLog_grp(ctx *Log_grpContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_table_logging(ctx *Supplemental_table_loggingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAllocate_extent_clause(ctx *Allocate_extent_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitShrink_clause(ctx *Shrink_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRecords_per_block_clause(ctx *Records_per_block_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpgrade_table_clause(ctx *Upgrade_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTruncate_table(ctx *Truncate_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_table(ctx *Drop_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_tablespace(ctx *Drop_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_tablespace_set(ctx *Drop_tablespace_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIncluding_contents_clause(ctx *Including_contents_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_view(ctx *Drop_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComment_on_column(ctx *Comment_on_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnable_or_disable(ctx *Enable_or_disableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAllow_or_disallow(ctx *Allow_or_disallowContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_synonym(ctx *Alter_synonymContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_synonym(ctx *Create_synonymContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_synonym(ctx *Drop_synonymContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_spfile(ctx *Create_spfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSpfile_name(ctx *Spfile_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPfile_name(ctx *Pfile_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComment_on_table(ctx *Comment_on_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitComment_on_materialized(ctx *Comment_on_materializedContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_analytic_view(ctx *Alter_analytic_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLevels_item(ctx *Levels_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMeasure_list(ctx *Measure_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_audit_policy(ctx *Alter_audit_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_cluster(ctx *Alter_clusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_analytic_view(ctx *Drop_analytic_viewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_audit_policy(ctx *Drop_audit_policyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_flashback_archive(ctx *Drop_flashback_archiveContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_cluster(ctx *Drop_clusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_context(ctx *Drop_contextContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_directory(ctx *Drop_directoryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_diskgroup(ctx *Drop_diskgroupContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_edition(ctx *Drop_editionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTruncate_cluster(ctx *Truncate_clusterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCache_or_nocache(ctx *Cache_or_nocacheContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase_name(ctx *Database_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_database(ctx *Alter_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase_clause(ctx *Database_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStartup_clauses(ctx *Startup_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRecovery_clauses(ctx *Recovery_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBegin_or_end(ctx *Begin_or_endContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGeneral_recovery(ctx *General_recoveryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFull_database_recovery(ctx *Full_database_recoveryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartial_database_recovery(ctx *Partial_database_recoveryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitManaged_standby_recovery(ctx *Managed_standby_recoveryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDb_name(ctx *Db_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase_file_clauses(ctx *Database_file_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_datafile_clause(ctx *Create_datafile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_datafile_clause(ctx *Alter_datafile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMove_datafile_clause(ctx *Move_datafile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogfile_clauses(ctx *Logfile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_logfile_clauses(ctx *Add_logfile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGroup_redo_logfile(ctx *Group_redo_logfileContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_db_logging(ctx *Supplemental_db_loggingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_or_drop(ctx *Add_or_dropContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogfile_descriptor(ctx *Logfile_descriptorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitControlfile_clauses(ctx *Controlfile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrace_file_clause(ctx *Trace_file_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStandby_database_clauses(ctx *Standby_database_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRegister_logfile_clause(ctx *Register_logfile_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCommit_switchover_clause(ctx *Commit_switchover_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStart_standby_clause(ctx *Start_standby_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStop_standby_clause(ctx *Stop_standby_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConvert_database_clause(ctx *Convert_database_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_settings_clause(ctx *Default_settings_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_time_zone_clause(ctx *Set_time_zone_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInstance_clauses(ctx *Instance_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSecurity_clause(ctx *Security_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDomain(ctx *DomainContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase(ctx *DatabaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEdition_name(ctx *Edition_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFilenumber(ctx *FilenumberContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFilename(ctx *FilenameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrepare_clause(ctx *Prepare_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_mirror_clause(ctx *Drop_mirror_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLost_write_protection(ctx *Lost_write_protectionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLead_cdb_clause(ctx *Lead_cdb_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProperty_clauses(ctx *Property_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_database_link(ctx *Alter_database_linkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPassword_value(ctx *Password_valueContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLink_authentication(ctx *Link_authenticationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_database(ctx *Create_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase_logging_clauses(ctx *Database_logging_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_clauses(ctx *Tablespace_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFile_name_convert(ctx *File_name_convertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUndo_mode_clause(ctx *Undo_mode_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_tablespace(ctx *Default_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUndo_tablespace(ctx *Undo_tablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_database(ctx *Drop_databaseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCreate_database_link(ctx *Create_database_linkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDblink(ctx *DblinkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_database_link(ctx *Drop_database_linkContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_tablespace_set(ctx *Alter_tablespace_setContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTs_file_name_convert(ctx *Ts_file_name_convertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_role(ctx *Alter_roleContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRole_identified_clause(ctx *Role_identified_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_table(ctx *Alter_tableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_table_properties(ctx *Alter_table_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_table_partitioning(ctx *Alter_table_partitioningContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_table_partition(ctx *Add_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_table_partition(ctx *Drop_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_table_partition(ctx *Merge_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_table_partition(ctx *Modify_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSplit_table_partition(ctx *Split_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTruncate_table_partition(ctx *Truncate_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExchange_table_partition(ctx *Exchange_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCoalesce_table_partition(ctx *Coalesce_table_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_interval_partition(ctx *Alter_interval_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_extended_names(ctx *Partition_extended_namesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubpartition_extended_names(ctx *Subpartition_extended_namesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_table_properties_1(ctx *Alter_table_properties_1Context) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_iot_clauses(ctx *Alter_iot_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_overflow_clause(ctx *Alter_overflow_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_overflow_clause(ctx *Add_overflow_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_index_clauses(ctx *Update_index_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_global_index_clause(ctx *Update_global_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_index_partition(ctx *Update_index_partitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_index_subpartition(ctx *Update_index_subpartitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnable_disable_clause(ctx *Enable_disable_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_index_clause(ctx *Using_index_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_attributes(ctx *Index_attributesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSort_or_nosort(ctx *Sort_or_nosortContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExceptions_clause(ctx *Exceptions_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMove_table_clause(ctx *Move_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_org_table_clause(ctx *Index_org_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMapping_table_clause(ctx *Mapping_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKey_compression(ctx *Key_compressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_clauses(ctx *Column_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_collection_retrieval(ctx *Modify_collection_retrievalContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCollection_item(ctx *Collection_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRename_column_clause(ctx *Rename_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOld_column_name(ctx *Old_column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_column_name(ctx *New_column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_column_clause(ctx *Drop_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_column_clauses(ctx *Modify_column_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_col_visibility(ctx *Modify_col_visibilityContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_col_properties(ctx *Modify_col_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_col_substitutable(ctx *Modify_col_substitutableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_column_clause(ctx *Add_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAlter_varray_col_properties(ctx *Alter_varray_col_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVarray_col_properties(ctx *Varray_col_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVarray_storage_clause(ctx *Varray_storage_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_segname(ctx *Lob_segnameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_item(ctx *Lob_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_storage_parameters(ctx *Lob_storage_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_storage_clause(ctx *Lob_storage_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModify_lob_parameters(ctx *Modify_lob_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_parameters(ctx *Lob_parametersContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_compression_clause(ctx *Lob_compression_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_retention_clause(ctx *Lob_retention_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEncryption_spec(ctx *Encryption_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTablespace(ctx *TablespaceContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVarray_item(ctx *Varray_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_properties(ctx *Column_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLob_partition_storage(ctx *Lob_partition_storageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPeriod_definition(ctx *Period_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStart_time_column(ctx *Start_time_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnd_time_column(ctx *End_time_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_definition(ctx *Column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_collation_name(ctx *Column_collation_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentity_clause(ctx *Identity_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentity_options(ctx *Identity_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVirtual_column_definition(ctx *Virtual_column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOut_of_line_part_storage(ctx *Out_of_line_part_storageContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNested_table_col_properties(ctx *Nested_table_col_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNested_item(ctx *Nested_itemContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_name(ctx *Partition_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSupplemental_logging_props(ctx *Supplemental_logging_propsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_or_attribute(ctx *Column_or_attributeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_type_col_properties(ctx *Object_type_col_propertiesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstraint_clauses(ctx *Constraint_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOld_constraint_name(ctx *Old_constraint_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNew_constraint_name(ctx *New_constraint_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_constraint_clause(ctx *Drop_constraint_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_primary_key_or_unique_or_generic_clause(ctx *Drop_primary_key_or_unique_or_generic_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_constraint(ctx *Add_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAdd_constraint_clause(ctx *Add_constraint_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCheck_constraint(ctx *Check_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDrop_constraint(ctx *Drop_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitEnable_constraint(ctx *Enable_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDisable_constraint(ctx *Disable_constraintContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitForeign_key_clause(ctx *Foreign_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReferences_clause(ctx *References_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOn_delete_clause(ctx *On_delete_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnique_key_clause(ctx *Unique_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrimary_key_clause(ctx *Primary_key_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAnonymous_block(ctx *Anonymous_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInvoker_rights_clause(ctx *Invoker_rights_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCall_spec(ctx *Call_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJava_spec(ctx *Java_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitC_spec(ctx *C_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitC_agent_in_clause(ctx *C_agent_in_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitC_parameters_clause(ctx *C_parameters_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParameter(ctx *ParameterContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDefault_value_part(ctx *Default_value_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDeclare_spec(ctx *Declare_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVariable_declaration(ctx *Variable_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubtype_declaration(ctx *Subtype_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCursor_declaration(ctx *Cursor_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParameter_spec(ctx *Parameter_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitException_declaration(ctx *Exception_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPragma_declaration(ctx *Pragma_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRecord_type_def(ctx *Record_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitField_spec(ctx *Field_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRef_cursor_type_def(ctx *Ref_cursor_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_declaration(ctx *Type_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_type_def(ctx *Table_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_indexed_by_part(ctx *Table_indexed_by_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVarray_type_def(ctx *Varray_type_defContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSeq_of_statements(ctx *Seq_of_statementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLabel_declaration(ctx *Label_declarationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStatement(ctx *StatementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSwallow_to_semi(ctx *Swallow_to_semiContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAssignment_statement(ctx *Assignment_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitContinue_statement(ctx *Continue_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExit_statement(ctx *Exit_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGoto_statement(ctx *Goto_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIf_statement(ctx *If_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitElsif_part(ctx *Elsif_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitElse_part(ctx *Else_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLoop_statement(ctx *Loop_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCursor_loop_param(ctx *Cursor_loop_paramContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitForall_statement(ctx *Forall_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBounds_clause(ctx *Bounds_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBetween_bound(ctx *Between_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLower_bound(ctx *Lower_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpper_bound(ctx *Upper_boundContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNull_statement(ctx *Null_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRaise_statement(ctx *Raise_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReturn_statement(ctx *Return_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCall_statement(ctx *Call_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPipe_row_statement(ctx *Pipe_row_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBody(ctx *BodyContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitException_handler(ctx *Exception_handlerContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrigger_block(ctx *Trigger_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBlock(ctx *BlockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSql_statement(ctx *Sql_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExecute_immediate(ctx *Execute_immediateContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitClose_statement(ctx *Close_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOpen_statement(ctx *Open_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFetch_statement(ctx *Fetch_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOpen_for_statement(ctx *Open_for_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTransaction_control_statements(ctx *Transaction_control_statementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_transaction_command(ctx *Set_transaction_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_constraint_command(ctx *Set_constraint_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCommit_statement(ctx *Commit_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWrite_clause(ctx *Write_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRollback_statement(ctx *Rollback_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSavepoint_statement(ctx *Savepoint_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExplain_statement(ctx *Explain_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSelect_only_statement(ctx *Select_only_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSelect_statement(ctx *Select_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFactoring_element(ctx *Factoring_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSearch_clause(ctx *Search_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCycle_clause(ctx *Cycle_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubquery(ctx *SubqueryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubquery_basic_elements(ctx *Subquery_basic_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubquery_operation_part(ctx *Subquery_operation_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuery_block(ctx *Query_blockContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSelected_list(ctx *Selected_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFrom_clause(ctx *From_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSelect_list_elements(ctx *Select_list_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_wild(ctx *Table_wildContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref_list(ctx *Table_ref_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref(ctx *Table_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref_aux(ctx *Table_ref_auxContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_ref_aux_internal_three(ctx *Table_ref_aux_internal_threeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_clause(ctx *Join_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_on_part(ctx *Join_on_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJoin_using_part(ctx *Join_using_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOuter_join_type(ctx *Outer_join_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuery_partition_clause(ctx *Query_partition_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFlashback_query_clause(ctx *Flashback_query_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_clause(ctx *Pivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_element(ctx *Pivot_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_for_clause(ctx *Pivot_for_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_in_clause(ctx *Pivot_in_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnpivot_in_clause(ctx *Unpivot_in_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnpivot_in_elements(ctx *Unpivot_in_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStart_part(ctx *Start_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGroup_by_elements(ctx *Group_by_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRollup_cube_clause(ctx *Rollup_cube_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGrouping_sets_elements(ctx *Grouping_sets_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitHaving_clause(ctx *Having_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_clause(ctx *Model_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCell_reference_options(ctx *Cell_reference_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReturn_rows_clause(ctx *Return_rows_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReference_model(ctx *Reference_modelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMain_model(ctx *Main_modelContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_column_clauses(ctx *Model_column_clausesContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_column_partition_part(ctx *Model_column_partition_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_column_list(ctx *Model_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_column(ctx *Model_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_rules_clause(ctx *Model_rules_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_rules_part(ctx *Model_rules_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_rules_element(ctx *Model_rules_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCell_assignment(ctx *Cell_assignmentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_iterate_clause(ctx *Model_iterate_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUntil_part(ctx *Until_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOrder_by_elements(ctx *Order_by_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOffset_clause(ctx *Offset_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFetch_clause(ctx *Fetch_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFor_update_clause(ctx *For_update_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFor_update_of_part(ctx *For_update_of_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFor_update_options(ctx *For_update_optionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_statement(ctx *Update_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUpdate_set_clause(ctx *Update_set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDelete_statement(ctx *Delete_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInsert_statement(ctx *Insert_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSingle_table_insert(ctx *Single_table_insertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMulti_table_insert(ctx *Multi_table_insertContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMulti_table_element(ctx *Multi_table_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConditional_insert_clause(ctx *Conditional_insert_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConditional_insert_when_part(ctx *Conditional_insert_when_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConditional_insert_else_part(ctx *Conditional_insert_else_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInsert_into_clause(ctx *Insert_into_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitValues_clause(ctx *Values_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_statement(ctx *Merge_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_update_clause(ctx *Merge_update_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_element(ctx *Merge_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_update_delete_part(ctx *Merge_update_delete_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMerge_insert_clause(ctx *Merge_insert_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSelected_tableview(ctx *Selected_tableviewContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLock_table_statement(ctx *Lock_table_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWait_nowait_part(ctx *Wait_nowait_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLock_table_element(ctx *Lock_table_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLock_mode(ctx *Lock_modeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGeneral_table_ref(ctx *General_table_refContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStatic_returning_clause(ctx *Static_returning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitError_logging_clause(ctx *Error_logging_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitError_logging_into_part(ctx *Error_logging_into_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitError_logging_reject_part(ctx *Error_logging_reject_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_collection_expression(ctx *Table_collection_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSample_clause(ctx *Sample_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSeed_part(ctx *Seed_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCondition(ctx *ConditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_condition(ctx *Json_conditionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExpressions(ctx *ExpressionsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitExpression(ctx *ExpressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCursor_expression(ctx *Cursor_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogical_expression(ctx *Logical_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnary_logical_expression(ctx *Unary_logical_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLogical_operation(ctx *Logical_operationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMultiset_expression(ctx *Multiset_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRelational_expression(ctx *Relational_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCompound_expression(ctx *Compound_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRelational_operator(ctx *Relational_operatorContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIn_elements(ctx *In_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBetween_elements(ctx *Between_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConcatenation(ctx *ConcatenationContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInterval_expression(ctx *Interval_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_expression(ctx *Model_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitModel_expression_element(ctx *Model_expression_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSingle_column_for_loop(ctx *Single_column_for_loopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMulti_column_for_loop(ctx *Multi_column_for_loopContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUnary_expression(ctx *Unary_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCase_statement(ctx *Case_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSimple_case_statement(ctx *Simple_case_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSimple_case_when_part(ctx *Simple_case_when_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSearched_case_statement(ctx *Searched_case_statementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSearched_case_when_part(ctx *Searched_case_when_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCase_else_part(ctx *Case_else_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAtom(ctx *AtomContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuantified_expression(ctx *Quantified_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitString_function(ctx *String_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStandard_function(ctx *Standard_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_function(ctx *Json_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_object_content(ctx *Json_object_contentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_object_entry(ctx *Json_object_entryContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_table_clause(ctx *Json_table_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_array_element(ctx *Json_array_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_on_null_clause(ctx *Json_on_null_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_return_clause(ctx *Json_return_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_transform_op(ctx *Json_transform_opContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_column_clause(ctx *Json_column_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_column_definition(ctx *Json_column_definitionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_query_returning_clause(ctx *Json_query_returning_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_query_return_type(ctx *Json_query_return_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_value_return_clause(ctx *Json_value_return_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_value_return_type(ctx *Json_value_return_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLiteral(ctx *LiteralContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNumeric_function(ctx *Numeric_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOther_function(ctx *Other_functionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOver_clause_keyword(ctx *Over_clause_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOver_clause(ctx *Over_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWindowing_clause(ctx *Windowing_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWindowing_type(ctx *Windowing_typeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWindowing_elements(ctx *Windowing_elementsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_clause(ctx *Using_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUsing_element(ctx *Using_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCollect_order_by_part(ctx *Collect_order_by_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWithin_or_over_part(ctx *Within_or_over_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCost_matrix_clause(ctx *Cost_matrix_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_passing_clause(ctx *Xml_passing_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_attributes_clause(ctx *Xml_attributes_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_table_column(ctx *Xml_table_columnContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_general_default_part(ctx *Xml_general_default_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSql_plus_command(ctx *Sql_plus_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWhenever_command(ctx *Whenever_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSet_command(ctx *Set_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTiming_command(ctx *Timing_commandContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPartition_extension_clause(ctx *Partition_extension_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_alias(ctx *Column_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_alias(ctx *Table_aliasContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitWhere_clause(ctx *Where_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuantitative_where_stmt(ctx *Quantitative_where_stmtContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitInto_clause(ctx *Into_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXml_column_name(ctx *Xml_column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCost_class_name(ctx *Cost_class_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAttribute_name(ctx *Attribute_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSavepoint_name(ctx *Savepoint_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRollback_segment_name(ctx *Rollback_segment_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_var_name(ctx *Table_var_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSchema_name(ctx *Schema_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRoutine_name(ctx *Routine_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPackage_name(ctx *Package_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitImplementation_type_name(ctx *Implementation_type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParameter_name(ctx *Parameter_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitReference_model_name(ctx *Reference_model_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitMain_model_name(ctx *Main_model_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitContainer_tableview_name(ctx *Container_tableview_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitAggregate_function_name(ctx *Aggregate_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuery_name(ctx *Query_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGrantee_name(ctx *Grantee_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRole_name(ctx *Role_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstraint_name(ctx *Constraint_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLabel_name(ctx *Label_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_name(ctx *Type_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSequence_name(ctx *Sequence_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitException_name(ctx *Exception_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_name(ctx *Function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitProcedure_name(ctx *Procedure_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTrigger_name(ctx *Trigger_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitVariable_name(ctx *Variable_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIndex_name(ctx *Index_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCursor_name(ctx *Cursor_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRecord_name(ctx *Record_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitCollection_name(ctx *Collection_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitLink_name(ctx *Link_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_name(ctx *Column_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTableview_name(ctx *Tableview_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitXmltable(ctx *XmltableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitChar_set_name(ctx *Char_set_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSynonym_name(ctx *Synonym_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSchema_object_name(ctx *Schema_object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDir_object_name(ctx *Dir_object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitUser_object_name(ctx *User_object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGrant_object_name(ctx *Grant_object_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitColumn_list(ctx *Column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitParen_column_list(ctx *Paren_column_listContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitKeep_clause(ctx *Keep_clauseContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_argument(ctx *Function_argumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_argument_analytic(ctx *Function_argument_analyticContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitFunction_argument_modeling(ctx *Function_argument_modelingContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitArgument(ctx *ArgumentContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitType_spec(ctx *Type_specContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitDatatype(ctx *DatatypeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitPrecision_part(ctx *Precision_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNative_datatype_element(ctx *Native_datatype_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitBind_variable(ctx *Bind_variableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGeneral_element(ctx *General_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitGeneral_element_part(ctx *General_element_partContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitTable_element(ctx *Table_elementContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitObject_privilege(ctx *Object_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitSystem_privilege(ctx *System_privilegeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstant(ctx *ConstantContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitConstant_without_variable(ctx *Constant_without_variableContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNumeric(ctx *NumericContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNumeric_negative(ctx *Numeric_negativeContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitQuoted_string(ctx *Quoted_stringContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitChar_str(ctx *Char_strContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitIdentifier(ctx *IdentifierContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitId_expression(ctx *Id_expressionContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitOuter_join_sign(ctx *Outer_join_signContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitRegular_id(ctx *Regular_idContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitString_function_name(ctx *String_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} + +func (v *BasePlSqlParserVisitor) VisitNumeric_function_name(ctx *Numeric_function_nameContext) interface{} { + return v.VisitChildren(ctx) +} diff --git a/plsql/plsqlparser_listener.go b/plsql/plsqlparser_listener.go new file mode 100644 index 0000000..1ef9e87 --- /dev/null +++ b/plsql/plsqlparser_listener.go @@ -0,0 +1,7197 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +// PlSqlParserListener is a complete listener for a parse tree produced by PlSqlParser. +type PlSqlParserListener interface { + antlr.ParseTreeListener + + // EnterSql_script is called when entering the sql_script production. + EnterSql_script(c *Sql_scriptContext) + + // EnterUnit_statement is called when entering the unit_statement production. + EnterUnit_statement(c *Unit_statementContext) + + // EnterAlter_diskgroup is called when entering the alter_diskgroup production. + EnterAlter_diskgroup(c *Alter_diskgroupContext) + + // EnterAdd_disk_clause is called when entering the add_disk_clause production. + EnterAdd_disk_clause(c *Add_disk_clauseContext) + + // EnterDrop_disk_clause is called when entering the drop_disk_clause production. + EnterDrop_disk_clause(c *Drop_disk_clauseContext) + + // EnterResize_disk_clause is called when entering the resize_disk_clause production. + EnterResize_disk_clause(c *Resize_disk_clauseContext) + + // EnterReplace_disk_clause is called when entering the replace_disk_clause production. + EnterReplace_disk_clause(c *Replace_disk_clauseContext) + + // EnterWait_nowait is called when entering the wait_nowait production. + EnterWait_nowait(c *Wait_nowaitContext) + + // EnterRename_disk_clause is called when entering the rename_disk_clause production. + EnterRename_disk_clause(c *Rename_disk_clauseContext) + + // EnterDisk_online_clause is called when entering the disk_online_clause production. + EnterDisk_online_clause(c *Disk_online_clauseContext) + + // EnterDisk_offline_clause is called when entering the disk_offline_clause production. + EnterDisk_offline_clause(c *Disk_offline_clauseContext) + + // EnterTimeout_clause is called when entering the timeout_clause production. + EnterTimeout_clause(c *Timeout_clauseContext) + + // EnterRebalance_diskgroup_clause is called when entering the rebalance_diskgroup_clause production. + EnterRebalance_diskgroup_clause(c *Rebalance_diskgroup_clauseContext) + + // EnterPhase is called when entering the phase production. + EnterPhase(c *PhaseContext) + + // EnterCheck_diskgroup_clause is called when entering the check_diskgroup_clause production. + EnterCheck_diskgroup_clause(c *Check_diskgroup_clauseContext) + + // EnterDiskgroup_template_clauses is called when entering the diskgroup_template_clauses production. + EnterDiskgroup_template_clauses(c *Diskgroup_template_clausesContext) + + // EnterQualified_template_clause is called when entering the qualified_template_clause production. + EnterQualified_template_clause(c *Qualified_template_clauseContext) + + // EnterRedundancy_clause is called when entering the redundancy_clause production. + EnterRedundancy_clause(c *Redundancy_clauseContext) + + // EnterStriping_clause is called when entering the striping_clause production. + EnterStriping_clause(c *Striping_clauseContext) + + // EnterForce_noforce is called when entering the force_noforce production. + EnterForce_noforce(c *Force_noforceContext) + + // EnterDiskgroup_directory_clauses is called when entering the diskgroup_directory_clauses production. + EnterDiskgroup_directory_clauses(c *Diskgroup_directory_clausesContext) + + // EnterDir_name is called when entering the dir_name production. + EnterDir_name(c *Dir_nameContext) + + // EnterDiskgroup_alias_clauses is called when entering the diskgroup_alias_clauses production. + EnterDiskgroup_alias_clauses(c *Diskgroup_alias_clausesContext) + + // EnterDiskgroup_volume_clauses is called when entering the diskgroup_volume_clauses production. + EnterDiskgroup_volume_clauses(c *Diskgroup_volume_clausesContext) + + // EnterAdd_volume_clause is called when entering the add_volume_clause production. + EnterAdd_volume_clause(c *Add_volume_clauseContext) + + // EnterModify_volume_clause is called when entering the modify_volume_clause production. + EnterModify_volume_clause(c *Modify_volume_clauseContext) + + // EnterDiskgroup_attributes is called when entering the diskgroup_attributes production. + EnterDiskgroup_attributes(c *Diskgroup_attributesContext) + + // EnterModify_diskgroup_file is called when entering the modify_diskgroup_file production. + EnterModify_diskgroup_file(c *Modify_diskgroup_fileContext) + + // EnterDisk_region_clause is called when entering the disk_region_clause production. + EnterDisk_region_clause(c *Disk_region_clauseContext) + + // EnterDrop_diskgroup_file_clause is called when entering the drop_diskgroup_file_clause production. + EnterDrop_diskgroup_file_clause(c *Drop_diskgroup_file_clauseContext) + + // EnterConvert_redundancy_clause is called when entering the convert_redundancy_clause production. + EnterConvert_redundancy_clause(c *Convert_redundancy_clauseContext) + + // EnterUsergroup_clauses is called when entering the usergroup_clauses production. + EnterUsergroup_clauses(c *Usergroup_clausesContext) + + // EnterUser_clauses is called when entering the user_clauses production. + EnterUser_clauses(c *User_clausesContext) + + // EnterFile_permissions_clause is called when entering the file_permissions_clause production. + EnterFile_permissions_clause(c *File_permissions_clauseContext) + + // EnterFile_owner_clause is called when entering the file_owner_clause production. + EnterFile_owner_clause(c *File_owner_clauseContext) + + // EnterScrub_clause is called when entering the scrub_clause production. + EnterScrub_clause(c *Scrub_clauseContext) + + // EnterQuotagroup_clauses is called when entering the quotagroup_clauses production. + EnterQuotagroup_clauses(c *Quotagroup_clausesContext) + + // EnterProperty_name is called when entering the property_name production. + EnterProperty_name(c *Property_nameContext) + + // EnterProperty_value is called when entering the property_value production. + EnterProperty_value(c *Property_valueContext) + + // EnterFilegroup_clauses is called when entering the filegroup_clauses production. + EnterFilegroup_clauses(c *Filegroup_clausesContext) + + // EnterAdd_filegroup_clause is called when entering the add_filegroup_clause production. + EnterAdd_filegroup_clause(c *Add_filegroup_clauseContext) + + // EnterModify_filegroup_clause is called when entering the modify_filegroup_clause production. + EnterModify_filegroup_clause(c *Modify_filegroup_clauseContext) + + // EnterMove_to_filegroup_clause is called when entering the move_to_filegroup_clause production. + EnterMove_to_filegroup_clause(c *Move_to_filegroup_clauseContext) + + // EnterDrop_filegroup_clause is called when entering the drop_filegroup_clause production. + EnterDrop_filegroup_clause(c *Drop_filegroup_clauseContext) + + // EnterQuorum_regular is called when entering the quorum_regular production. + EnterQuorum_regular(c *Quorum_regularContext) + + // EnterUndrop_disk_clause is called when entering the undrop_disk_clause production. + EnterUndrop_disk_clause(c *Undrop_disk_clauseContext) + + // EnterDiskgroup_availability is called when entering the diskgroup_availability production. + EnterDiskgroup_availability(c *Diskgroup_availabilityContext) + + // EnterEnable_disable_volume is called when entering the enable_disable_volume production. + EnterEnable_disable_volume(c *Enable_disable_volumeContext) + + // EnterDrop_function is called when entering the drop_function production. + EnterDrop_function(c *Drop_functionContext) + + // EnterAlter_flashback_archive is called when entering the alter_flashback_archive production. + EnterAlter_flashback_archive(c *Alter_flashback_archiveContext) + + // EnterAlter_hierarchy is called when entering the alter_hierarchy production. + EnterAlter_hierarchy(c *Alter_hierarchyContext) + + // EnterAlter_function is called when entering the alter_function production. + EnterAlter_function(c *Alter_functionContext) + + // EnterAlter_java is called when entering the alter_java production. + EnterAlter_java(c *Alter_javaContext) + + // EnterMatch_string is called when entering the match_string production. + EnterMatch_string(c *Match_stringContext) + + // EnterCreate_function_body is called when entering the create_function_body production. + EnterCreate_function_body(c *Create_function_bodyContext) + + // EnterSql_macro_body is called when entering the sql_macro_body production. + EnterSql_macro_body(c *Sql_macro_bodyContext) + + // EnterParallel_enable_clause is called when entering the parallel_enable_clause production. + EnterParallel_enable_clause(c *Parallel_enable_clauseContext) + + // EnterPartition_by_clause is called when entering the partition_by_clause production. + EnterPartition_by_clause(c *Partition_by_clauseContext) + + // EnterResult_cache_clause is called when entering the result_cache_clause production. + EnterResult_cache_clause(c *Result_cache_clauseContext) + + // EnterRelies_on_part is called when entering the relies_on_part production. + EnterRelies_on_part(c *Relies_on_partContext) + + // EnterStreaming_clause is called when entering the streaming_clause production. + EnterStreaming_clause(c *Streaming_clauseContext) + + // EnterAlter_outline is called when entering the alter_outline production. + EnterAlter_outline(c *Alter_outlineContext) + + // EnterOutline_options is called when entering the outline_options production. + EnterOutline_options(c *Outline_optionsContext) + + // EnterAlter_lockdown_profile is called when entering the alter_lockdown_profile production. + EnterAlter_lockdown_profile(c *Alter_lockdown_profileContext) + + // EnterLockdown_feature is called when entering the lockdown_feature production. + EnterLockdown_feature(c *Lockdown_featureContext) + + // EnterLockdown_options is called when entering the lockdown_options production. + EnterLockdown_options(c *Lockdown_optionsContext) + + // EnterLockdown_statements is called when entering the lockdown_statements production. + EnterLockdown_statements(c *Lockdown_statementsContext) + + // EnterStatement_clauses is called when entering the statement_clauses production. + EnterStatement_clauses(c *Statement_clausesContext) + + // EnterClause_options is called when entering the clause_options production. + EnterClause_options(c *Clause_optionsContext) + + // EnterOption_values is called when entering the option_values production. + EnterOption_values(c *Option_valuesContext) + + // EnterString_list is called when entering the string_list production. + EnterString_list(c *String_listContext) + + // EnterDisable_enable is called when entering the disable_enable production. + EnterDisable_enable(c *Disable_enableContext) + + // EnterDrop_lockdown_profile is called when entering the drop_lockdown_profile production. + EnterDrop_lockdown_profile(c *Drop_lockdown_profileContext) + + // EnterDrop_package is called when entering the drop_package production. + EnterDrop_package(c *Drop_packageContext) + + // EnterAlter_package is called when entering the alter_package production. + EnterAlter_package(c *Alter_packageContext) + + // EnterCreate_package is called when entering the create_package production. + EnterCreate_package(c *Create_packageContext) + + // EnterCreate_package_body is called when entering the create_package_body production. + EnterCreate_package_body(c *Create_package_bodyContext) + + // EnterPackage_obj_spec is called when entering the package_obj_spec production. + EnterPackage_obj_spec(c *Package_obj_specContext) + + // EnterProcedure_spec is called when entering the procedure_spec production. + EnterProcedure_spec(c *Procedure_specContext) + + // EnterFunction_spec is called when entering the function_spec production. + EnterFunction_spec(c *Function_specContext) + + // EnterPackage_obj_body is called when entering the package_obj_body production. + EnterPackage_obj_body(c *Package_obj_bodyContext) + + // EnterAlter_pmem_filestore is called when entering the alter_pmem_filestore production. + EnterAlter_pmem_filestore(c *Alter_pmem_filestoreContext) + + // EnterDrop_pmem_filestore is called when entering the drop_pmem_filestore production. + EnterDrop_pmem_filestore(c *Drop_pmem_filestoreContext) + + // EnterDrop_procedure is called when entering the drop_procedure production. + EnterDrop_procedure(c *Drop_procedureContext) + + // EnterAlter_procedure is called when entering the alter_procedure production. + EnterAlter_procedure(c *Alter_procedureContext) + + // EnterFunction_body is called when entering the function_body production. + EnterFunction_body(c *Function_bodyContext) + + // EnterProcedure_body is called when entering the procedure_body production. + EnterProcedure_body(c *Procedure_bodyContext) + + // EnterCreate_procedure_body is called when entering the create_procedure_body production. + EnterCreate_procedure_body(c *Create_procedure_bodyContext) + + // EnterAlter_resource_cost is called when entering the alter_resource_cost production. + EnterAlter_resource_cost(c *Alter_resource_costContext) + + // EnterDrop_outline is called when entering the drop_outline production. + EnterDrop_outline(c *Drop_outlineContext) + + // EnterAlter_rollback_segment is called when entering the alter_rollback_segment production. + EnterAlter_rollback_segment(c *Alter_rollback_segmentContext) + + // EnterDrop_restore_point is called when entering the drop_restore_point production. + EnterDrop_restore_point(c *Drop_restore_pointContext) + + // EnterDrop_rollback_segment is called when entering the drop_rollback_segment production. + EnterDrop_rollback_segment(c *Drop_rollback_segmentContext) + + // EnterDrop_role is called when entering the drop_role production. + EnterDrop_role(c *Drop_roleContext) + + // EnterCreate_pmem_filestore is called when entering the create_pmem_filestore production. + EnterCreate_pmem_filestore(c *Create_pmem_filestoreContext) + + // EnterPmem_filestore_options is called when entering the pmem_filestore_options production. + EnterPmem_filestore_options(c *Pmem_filestore_optionsContext) + + // EnterFile_path is called when entering the file_path production. + EnterFile_path(c *File_pathContext) + + // EnterCreate_rollback_segment is called when entering the create_rollback_segment production. + EnterCreate_rollback_segment(c *Create_rollback_segmentContext) + + // EnterDrop_trigger is called when entering the drop_trigger production. + EnterDrop_trigger(c *Drop_triggerContext) + + // EnterAlter_trigger is called when entering the alter_trigger production. + EnterAlter_trigger(c *Alter_triggerContext) + + // EnterCreate_trigger is called when entering the create_trigger production. + EnterCreate_trigger(c *Create_triggerContext) + + // EnterTrigger_follows_clause is called when entering the trigger_follows_clause production. + EnterTrigger_follows_clause(c *Trigger_follows_clauseContext) + + // EnterTrigger_when_clause is called when entering the trigger_when_clause production. + EnterTrigger_when_clause(c *Trigger_when_clauseContext) + + // EnterSimple_dml_trigger is called when entering the simple_dml_trigger production. + EnterSimple_dml_trigger(c *Simple_dml_triggerContext) + + // EnterFor_each_row is called when entering the for_each_row production. + EnterFor_each_row(c *For_each_rowContext) + + // EnterCompound_dml_trigger is called when entering the compound_dml_trigger production. + EnterCompound_dml_trigger(c *Compound_dml_triggerContext) + + // EnterNon_dml_trigger is called when entering the non_dml_trigger production. + EnterNon_dml_trigger(c *Non_dml_triggerContext) + + // EnterTrigger_body is called when entering the trigger_body production. + EnterTrigger_body(c *Trigger_bodyContext) + + // EnterRoutine_clause is called when entering the routine_clause production. + EnterRoutine_clause(c *Routine_clauseContext) + + // EnterCompound_trigger_block is called when entering the compound_trigger_block production. + EnterCompound_trigger_block(c *Compound_trigger_blockContext) + + // EnterTiming_point_section is called when entering the timing_point_section production. + EnterTiming_point_section(c *Timing_point_sectionContext) + + // EnterNon_dml_event is called when entering the non_dml_event production. + EnterNon_dml_event(c *Non_dml_eventContext) + + // EnterDml_event_clause is called when entering the dml_event_clause production. + EnterDml_event_clause(c *Dml_event_clauseContext) + + // EnterDml_event_element is called when entering the dml_event_element production. + EnterDml_event_element(c *Dml_event_elementContext) + + // EnterDml_event_nested_clause is called when entering the dml_event_nested_clause production. + EnterDml_event_nested_clause(c *Dml_event_nested_clauseContext) + + // EnterReferencing_clause is called when entering the referencing_clause production. + EnterReferencing_clause(c *Referencing_clauseContext) + + // EnterReferencing_element is called when entering the referencing_element production. + EnterReferencing_element(c *Referencing_elementContext) + + // EnterDrop_type is called when entering the drop_type production. + EnterDrop_type(c *Drop_typeContext) + + // EnterAlter_type is called when entering the alter_type production. + EnterAlter_type(c *Alter_typeContext) + + // EnterCompile_type_clause is called when entering the compile_type_clause production. + EnterCompile_type_clause(c *Compile_type_clauseContext) + + // EnterReplace_type_clause is called when entering the replace_type_clause production. + EnterReplace_type_clause(c *Replace_type_clauseContext) + + // EnterAlter_method_spec is called when entering the alter_method_spec production. + EnterAlter_method_spec(c *Alter_method_specContext) + + // EnterAlter_method_element is called when entering the alter_method_element production. + EnterAlter_method_element(c *Alter_method_elementContext) + + // EnterAlter_attribute_definition is called when entering the alter_attribute_definition production. + EnterAlter_attribute_definition(c *Alter_attribute_definitionContext) + + // EnterAttribute_definition is called when entering the attribute_definition production. + EnterAttribute_definition(c *Attribute_definitionContext) + + // EnterAlter_collection_clauses is called when entering the alter_collection_clauses production. + EnterAlter_collection_clauses(c *Alter_collection_clausesContext) + + // EnterDependent_handling_clause is called when entering the dependent_handling_clause production. + EnterDependent_handling_clause(c *Dependent_handling_clauseContext) + + // EnterDependent_exceptions_part is called when entering the dependent_exceptions_part production. + EnterDependent_exceptions_part(c *Dependent_exceptions_partContext) + + // EnterCreate_type is called when entering the create_type production. + EnterCreate_type(c *Create_typeContext) + + // EnterType_definition is called when entering the type_definition production. + EnterType_definition(c *Type_definitionContext) + + // EnterObject_type_def is called when entering the object_type_def production. + EnterObject_type_def(c *Object_type_defContext) + + // EnterObject_as_part is called when entering the object_as_part production. + EnterObject_as_part(c *Object_as_partContext) + + // EnterObject_under_part is called when entering the object_under_part production. + EnterObject_under_part(c *Object_under_partContext) + + // EnterNested_table_type_def is called when entering the nested_table_type_def production. + EnterNested_table_type_def(c *Nested_table_type_defContext) + + // EnterSqlj_object_type is called when entering the sqlj_object_type production. + EnterSqlj_object_type(c *Sqlj_object_typeContext) + + // EnterType_body is called when entering the type_body production. + EnterType_body(c *Type_bodyContext) + + // EnterType_body_elements is called when entering the type_body_elements production. + EnterType_body_elements(c *Type_body_elementsContext) + + // EnterMap_order_func_declaration is called when entering the map_order_func_declaration production. + EnterMap_order_func_declaration(c *Map_order_func_declarationContext) + + // EnterSubprog_decl_in_type is called when entering the subprog_decl_in_type production. + EnterSubprog_decl_in_type(c *Subprog_decl_in_typeContext) + + // EnterProc_decl_in_type is called when entering the proc_decl_in_type production. + EnterProc_decl_in_type(c *Proc_decl_in_typeContext) + + // EnterFunc_decl_in_type is called when entering the func_decl_in_type production. + EnterFunc_decl_in_type(c *Func_decl_in_typeContext) + + // EnterConstructor_declaration is called when entering the constructor_declaration production. + EnterConstructor_declaration(c *Constructor_declarationContext) + + // EnterModifier_clause is called when entering the modifier_clause production. + EnterModifier_clause(c *Modifier_clauseContext) + + // EnterObject_member_spec is called when entering the object_member_spec production. + EnterObject_member_spec(c *Object_member_specContext) + + // EnterSqlj_object_type_attr is called when entering the sqlj_object_type_attr production. + EnterSqlj_object_type_attr(c *Sqlj_object_type_attrContext) + + // EnterElement_spec is called when entering the element_spec production. + EnterElement_spec(c *Element_specContext) + + // EnterElement_spec_options is called when entering the element_spec_options production. + EnterElement_spec_options(c *Element_spec_optionsContext) + + // EnterSubprogram_spec is called when entering the subprogram_spec production. + EnterSubprogram_spec(c *Subprogram_specContext) + + // EnterOverriding_subprogram_spec is called when entering the overriding_subprogram_spec production. + EnterOverriding_subprogram_spec(c *Overriding_subprogram_specContext) + + // EnterOverriding_function_spec is called when entering the overriding_function_spec production. + EnterOverriding_function_spec(c *Overriding_function_specContext) + + // EnterType_procedure_spec is called when entering the type_procedure_spec production. + EnterType_procedure_spec(c *Type_procedure_specContext) + + // EnterType_function_spec is called when entering the type_function_spec production. + EnterType_function_spec(c *Type_function_specContext) + + // EnterConstructor_spec is called when entering the constructor_spec production. + EnterConstructor_spec(c *Constructor_specContext) + + // EnterMap_order_function_spec is called when entering the map_order_function_spec production. + EnterMap_order_function_spec(c *Map_order_function_specContext) + + // EnterPragma_clause is called when entering the pragma_clause production. + EnterPragma_clause(c *Pragma_clauseContext) + + // EnterPragma_elements is called when entering the pragma_elements production. + EnterPragma_elements(c *Pragma_elementsContext) + + // EnterType_elements_parameter is called when entering the type_elements_parameter production. + EnterType_elements_parameter(c *Type_elements_parameterContext) + + // EnterDrop_sequence is called when entering the drop_sequence production. + EnterDrop_sequence(c *Drop_sequenceContext) + + // 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_set_clause is called when entering the alter_session_set_clause production. + EnterAlter_session_set_clause(c *Alter_session_set_clauseContext) + + // EnterCreate_sequence is called when entering the create_sequence production. + EnterCreate_sequence(c *Create_sequenceContext) + + // EnterSequence_spec is called when entering the sequence_spec production. + EnterSequence_spec(c *Sequence_specContext) + + // EnterSequence_start_clause is called when entering the sequence_start_clause production. + EnterSequence_start_clause(c *Sequence_start_clauseContext) + + // EnterCreate_analytic_view is called when entering the create_analytic_view production. + EnterCreate_analytic_view(c *Create_analytic_viewContext) + + // EnterClassification_clause is called when entering the classification_clause production. + EnterClassification_clause(c *Classification_clauseContext) + + // EnterCaption_clause is called when entering the caption_clause production. + EnterCaption_clause(c *Caption_clauseContext) + + // EnterDescription_clause is called when entering the description_clause production. + EnterDescription_clause(c *Description_clauseContext) + + // EnterClassification_item is called when entering the classification_item production. + EnterClassification_item(c *Classification_itemContext) + + // EnterLanguage is called when entering the language production. + EnterLanguage(c *LanguageContext) + + // EnterCav_using_clause is called when entering the cav_using_clause production. + EnterCav_using_clause(c *Cav_using_clauseContext) + + // EnterDim_by_clause is called when entering the dim_by_clause production. + EnterDim_by_clause(c *Dim_by_clauseContext) + + // EnterDim_key is called when entering the dim_key production. + EnterDim_key(c *Dim_keyContext) + + // EnterDim_ref is called when entering the dim_ref production. + EnterDim_ref(c *Dim_refContext) + + // EnterHier_ref is called when entering the hier_ref production. + EnterHier_ref(c *Hier_refContext) + + // EnterMeasures_clause is called when entering the measures_clause production. + EnterMeasures_clause(c *Measures_clauseContext) + + // EnterAv_measure is called when entering the av_measure production. + EnterAv_measure(c *Av_measureContext) + + // EnterBase_meas_clause is called when entering the base_meas_clause production. + EnterBase_meas_clause(c *Base_meas_clauseContext) + + // EnterMeas_aggregate_clause is called when entering the meas_aggregate_clause production. + EnterMeas_aggregate_clause(c *Meas_aggregate_clauseContext) + + // EnterCalc_meas_clause is called when entering the calc_meas_clause production. + EnterCalc_meas_clause(c *Calc_meas_clauseContext) + + // EnterDefault_measure_clause is called when entering the default_measure_clause production. + EnterDefault_measure_clause(c *Default_measure_clauseContext) + + // EnterDefault_aggregate_clause is called when entering the default_aggregate_clause production. + EnterDefault_aggregate_clause(c *Default_aggregate_clauseContext) + + // EnterCache_clause is called when entering the cache_clause production. + EnterCache_clause(c *Cache_clauseContext) + + // EnterCache_specification is called when entering the cache_specification production. + EnterCache_specification(c *Cache_specificationContext) + + // EnterLevels_clause is called when entering the levels_clause production. + EnterLevels_clause(c *Levels_clauseContext) + + // EnterLevel_specification is called when entering the level_specification production. + EnterLevel_specification(c *Level_specificationContext) + + // EnterLevel_group_type is called when entering the level_group_type production. + EnterLevel_group_type(c *Level_group_typeContext) + + // EnterFact_columns_clause is called when entering the fact_columns_clause production. + EnterFact_columns_clause(c *Fact_columns_clauseContext) + + // EnterQry_transform_clause is called when entering the qry_transform_clause production. + EnterQry_transform_clause(c *Qry_transform_clauseContext) + + // EnterCreate_attribute_dimension is called when entering the create_attribute_dimension production. + EnterCreate_attribute_dimension(c *Create_attribute_dimensionContext) + + // EnterAd_using_clause is called when entering the ad_using_clause production. + EnterAd_using_clause(c *Ad_using_clauseContext) + + // EnterSource_clause is called when entering the source_clause production. + EnterSource_clause(c *Source_clauseContext) + + // EnterJoin_path_clause is called when entering the join_path_clause production. + EnterJoin_path_clause(c *Join_path_clauseContext) + + // EnterJoin_condition is called when entering the join_condition production. + EnterJoin_condition(c *Join_conditionContext) + + // EnterJoin_condition_item is called when entering the join_condition_item production. + EnterJoin_condition_item(c *Join_condition_itemContext) + + // EnterAttributes_clause is called when entering the attributes_clause production. + EnterAttributes_clause(c *Attributes_clauseContext) + + // EnterAd_attributes_clause is called when entering the ad_attributes_clause production. + EnterAd_attributes_clause(c *Ad_attributes_clauseContext) + + // EnterAd_level_clause is called when entering the ad_level_clause production. + EnterAd_level_clause(c *Ad_level_clauseContext) + + // EnterKey_clause is called when entering the key_clause production. + EnterKey_clause(c *Key_clauseContext) + + // EnterAlternate_key_clause is called when entering the alternate_key_clause production. + EnterAlternate_key_clause(c *Alternate_key_clauseContext) + + // EnterDim_order_clause is called when entering the dim_order_clause production. + EnterDim_order_clause(c *Dim_order_clauseContext) + + // EnterAll_clause is called when entering the all_clause production. + EnterAll_clause(c *All_clauseContext) + + // EnterCreate_audit_policy is called when entering the create_audit_policy production. + EnterCreate_audit_policy(c *Create_audit_policyContext) + + // EnterPrivilege_audit_clause is called when entering the privilege_audit_clause production. + EnterPrivilege_audit_clause(c *Privilege_audit_clauseContext) + + // EnterAction_audit_clause is called when entering the action_audit_clause production. + EnterAction_audit_clause(c *Action_audit_clauseContext) + + // EnterStandard_actions is called when entering the standard_actions production. + EnterStandard_actions(c *Standard_actionsContext) + + // EnterActions_clause is called when entering the actions_clause production. + EnterActions_clause(c *Actions_clauseContext) + + // EnterObject_action is called when entering the object_action production. + EnterObject_action(c *Object_actionContext) + + // EnterSystem_action is called when entering the system_action production. + EnterSystem_action(c *System_actionContext) + + // EnterComponent_actions is called when entering the component_actions production. + EnterComponent_actions(c *Component_actionsContext) + + // EnterComponent_action is called when entering the component_action production. + EnterComponent_action(c *Component_actionContext) + + // EnterRole_audit_clause is called when entering the role_audit_clause production. + EnterRole_audit_clause(c *Role_audit_clauseContext) + + // EnterCreate_controlfile is called when entering the create_controlfile production. + EnterCreate_controlfile(c *Create_controlfileContext) + + // EnterControlfile_options is called when entering the controlfile_options production. + EnterControlfile_options(c *Controlfile_optionsContext) + + // EnterLogfile_clause is called when entering the logfile_clause production. + EnterLogfile_clause(c *Logfile_clauseContext) + + // EnterCharacter_set_clause is called when entering the character_set_clause production. + EnterCharacter_set_clause(c *Character_set_clauseContext) + + // EnterFile_specification is called when entering the file_specification production. + EnterFile_specification(c *File_specificationContext) + + // EnterCreate_diskgroup is called when entering the create_diskgroup production. + EnterCreate_diskgroup(c *Create_diskgroupContext) + + // EnterQualified_disk_clause is called when entering the qualified_disk_clause production. + EnterQualified_disk_clause(c *Qualified_disk_clauseContext) + + // EnterCreate_edition is called when entering the create_edition production. + EnterCreate_edition(c *Create_editionContext) + + // EnterCreate_flashback_archive is called when entering the create_flashback_archive production. + EnterCreate_flashback_archive(c *Create_flashback_archiveContext) + + // EnterFlashback_archive_quota is called when entering the flashback_archive_quota production. + EnterFlashback_archive_quota(c *Flashback_archive_quotaContext) + + // EnterFlashback_archive_retention is called when entering the flashback_archive_retention production. + EnterFlashback_archive_retention(c *Flashback_archive_retentionContext) + + // EnterCreate_hierarchy is called when entering the create_hierarchy production. + EnterCreate_hierarchy(c *Create_hierarchyContext) + + // EnterHier_using_clause is called when entering the hier_using_clause production. + EnterHier_using_clause(c *Hier_using_clauseContext) + + // EnterLevel_hier_clause is called when entering the level_hier_clause production. + EnterLevel_hier_clause(c *Level_hier_clauseContext) + + // EnterHier_attrs_clause is called when entering the hier_attrs_clause production. + EnterHier_attrs_clause(c *Hier_attrs_clauseContext) + + // EnterHier_attr_clause is called when entering the hier_attr_clause production. + EnterHier_attr_clause(c *Hier_attr_clauseContext) + + // EnterHier_attr_name is called when entering the hier_attr_name production. + EnterHier_attr_name(c *Hier_attr_nameContext) + + // EnterCreate_index is called when entering the create_index production. + EnterCreate_index(c *Create_indexContext) + + // EnterCluster_index_clause is called when entering the cluster_index_clause production. + EnterCluster_index_clause(c *Cluster_index_clauseContext) + + // EnterCluster_name is called when entering the cluster_name production. + EnterCluster_name(c *Cluster_nameContext) + + // EnterTable_index_clause is called when entering the table_index_clause production. + EnterTable_index_clause(c *Table_index_clauseContext) + + // EnterBitmap_join_index_clause is called when entering the bitmap_join_index_clause production. + EnterBitmap_join_index_clause(c *Bitmap_join_index_clauseContext) + + // EnterIndex_expr_option is called when entering the index_expr_option production. + EnterIndex_expr_option(c *Index_expr_optionContext) + + // EnterIndex_expr is called when entering the index_expr production. + EnterIndex_expr(c *Index_exprContext) + + // EnterIndex_properties is called when entering the index_properties production. + EnterIndex_properties(c *Index_propertiesContext) + + // EnterDomain_index_clause is called when entering the domain_index_clause production. + EnterDomain_index_clause(c *Domain_index_clauseContext) + + // EnterLocal_domain_index_clause is called when entering the local_domain_index_clause production. + EnterLocal_domain_index_clause(c *Local_domain_index_clauseContext) + + // EnterXmlindex_clause is called when entering the xmlindex_clause production. + EnterXmlindex_clause(c *Xmlindex_clauseContext) + + // EnterLocal_xmlindex_clause is called when entering the local_xmlindex_clause production. + EnterLocal_xmlindex_clause(c *Local_xmlindex_clauseContext) + + // EnterGlobal_partitioned_index is called when entering the global_partitioned_index production. + EnterGlobal_partitioned_index(c *Global_partitioned_indexContext) + + // EnterIndex_partitioning_clause is called when entering the index_partitioning_clause production. + EnterIndex_partitioning_clause(c *Index_partitioning_clauseContext) + + // EnterLocal_partitioned_index is called when entering the local_partitioned_index production. + EnterLocal_partitioned_index(c *Local_partitioned_indexContext) + + // EnterOn_range_partitioned_table is called when entering the on_range_partitioned_table production. + EnterOn_range_partitioned_table(c *On_range_partitioned_tableContext) + + // EnterOn_list_partitioned_table is called when entering the on_list_partitioned_table production. + EnterOn_list_partitioned_table(c *On_list_partitioned_tableContext) + + // EnterPartitioned_table is called when entering the partitioned_table production. + EnterPartitioned_table(c *Partitioned_tableContext) + + // EnterOn_hash_partitioned_table is called when entering the on_hash_partitioned_table production. + EnterOn_hash_partitioned_table(c *On_hash_partitioned_tableContext) + + // EnterOn_hash_partitioned_clause is called when entering the on_hash_partitioned_clause production. + EnterOn_hash_partitioned_clause(c *On_hash_partitioned_clauseContext) + + // EnterOn_comp_partitioned_table is called when entering the on_comp_partitioned_table production. + EnterOn_comp_partitioned_table(c *On_comp_partitioned_tableContext) + + // EnterOn_comp_partitioned_clause is called when entering the on_comp_partitioned_clause production. + EnterOn_comp_partitioned_clause(c *On_comp_partitioned_clauseContext) + + // EnterIndex_subpartition_clause is called when entering the index_subpartition_clause production. + EnterIndex_subpartition_clause(c *Index_subpartition_clauseContext) + + // EnterIndex_subpartition_subclause is called when entering the index_subpartition_subclause production. + EnterIndex_subpartition_subclause(c *Index_subpartition_subclauseContext) + + // EnterOdci_parameters is called when entering the odci_parameters production. + EnterOdci_parameters(c *Odci_parametersContext) + + // EnterIndextype is called when entering the indextype production. + EnterIndextype(c *IndextypeContext) + + // EnterAlter_index is called when entering the alter_index production. + EnterAlter_index(c *Alter_indexContext) + + // EnterAlter_index_ops_set1 is called when entering the alter_index_ops_set1 production. + EnterAlter_index_ops_set1(c *Alter_index_ops_set1Context) + + // EnterAlter_index_ops_set2 is called when entering the alter_index_ops_set2 production. + EnterAlter_index_ops_set2(c *Alter_index_ops_set2Context) + + // EnterVisible_or_invisible is called when entering the visible_or_invisible production. + EnterVisible_or_invisible(c *Visible_or_invisibleContext) + + // EnterMonitoring_nomonitoring is called when entering the monitoring_nomonitoring production. + EnterMonitoring_nomonitoring(c *Monitoring_nomonitoringContext) + + // EnterRebuild_clause is called when entering the rebuild_clause production. + EnterRebuild_clause(c *Rebuild_clauseContext) + + // EnterAlter_index_partitioning is called when entering the alter_index_partitioning production. + EnterAlter_index_partitioning(c *Alter_index_partitioningContext) + + // EnterModify_index_default_attrs is called when entering the modify_index_default_attrs production. + EnterModify_index_default_attrs(c *Modify_index_default_attrsContext) + + // EnterAdd_hash_index_partition is called when entering the add_hash_index_partition production. + EnterAdd_hash_index_partition(c *Add_hash_index_partitionContext) + + // EnterCoalesce_index_partition is called when entering the coalesce_index_partition production. + EnterCoalesce_index_partition(c *Coalesce_index_partitionContext) + + // EnterModify_index_partition is called when entering the modify_index_partition production. + EnterModify_index_partition(c *Modify_index_partitionContext) + + // EnterModify_index_partitions_ops is called when entering the modify_index_partitions_ops production. + EnterModify_index_partitions_ops(c *Modify_index_partitions_opsContext) + + // EnterRename_index_partition is called when entering the rename_index_partition production. + EnterRename_index_partition(c *Rename_index_partitionContext) + + // EnterDrop_index_partition is called when entering the drop_index_partition production. + EnterDrop_index_partition(c *Drop_index_partitionContext) + + // EnterSplit_index_partition is called when entering the split_index_partition production. + EnterSplit_index_partition(c *Split_index_partitionContext) + + // EnterIndex_partition_description is called when entering the index_partition_description production. + EnterIndex_partition_description(c *Index_partition_descriptionContext) + + // EnterModify_index_subpartition is called when entering the modify_index_subpartition production. + EnterModify_index_subpartition(c *Modify_index_subpartitionContext) + + // EnterPartition_name_old is called when entering the partition_name_old production. + EnterPartition_name_old(c *Partition_name_oldContext) + + // EnterNew_partition_name is called when entering the new_partition_name production. + EnterNew_partition_name(c *New_partition_nameContext) + + // EnterNew_index_name is called when entering the new_index_name production. + EnterNew_index_name(c *New_index_nameContext) + + // EnterAlter_inmemory_join_group is called when entering the alter_inmemory_join_group production. + EnterAlter_inmemory_join_group(c *Alter_inmemory_join_groupContext) + + // EnterCreate_user is called when entering the create_user production. + EnterCreate_user(c *Create_userContext) + + // EnterAlter_user is called when entering the alter_user production. + EnterAlter_user(c *Alter_userContext) + + // EnterDrop_user is called when entering the drop_user production. + EnterDrop_user(c *Drop_userContext) + + // EnterAlter_identified_by is called when entering the alter_identified_by production. + EnterAlter_identified_by(c *Alter_identified_byContext) + + // EnterIdentified_by is called when entering the identified_by production. + EnterIdentified_by(c *Identified_byContext) + + // EnterIdentified_other_clause is called when entering the identified_other_clause production. + EnterIdentified_other_clause(c *Identified_other_clauseContext) + + // EnterUser_tablespace_clause is called when entering the user_tablespace_clause production. + EnterUser_tablespace_clause(c *User_tablespace_clauseContext) + + // EnterQuota_clause is called when entering the quota_clause production. + EnterQuota_clause(c *Quota_clauseContext) + + // EnterProfile_clause is called when entering the profile_clause production. + EnterProfile_clause(c *Profile_clauseContext) + + // EnterRole_clause is called when entering the role_clause production. + EnterRole_clause(c *Role_clauseContext) + + // EnterUser_default_role_clause is called when entering the user_default_role_clause production. + EnterUser_default_role_clause(c *User_default_role_clauseContext) + + // EnterPassword_expire_clause is called when entering the password_expire_clause production. + EnterPassword_expire_clause(c *Password_expire_clauseContext) + + // EnterUser_lock_clause is called when entering the user_lock_clause production. + EnterUser_lock_clause(c *User_lock_clauseContext) + + // EnterUser_editions_clause is called when entering the user_editions_clause production. + EnterUser_editions_clause(c *User_editions_clauseContext) + + // EnterAlter_user_editions_clause is called when entering the alter_user_editions_clause production. + EnterAlter_user_editions_clause(c *Alter_user_editions_clauseContext) + + // EnterProxy_clause is called when entering the proxy_clause production. + EnterProxy_clause(c *Proxy_clauseContext) + + // EnterContainer_names is called when entering the container_names production. + EnterContainer_names(c *Container_namesContext) + + // EnterSet_container_data is called when entering the set_container_data production. + EnterSet_container_data(c *Set_container_dataContext) + + // EnterAdd_rem_container_data is called when entering the add_rem_container_data production. + EnterAdd_rem_container_data(c *Add_rem_container_dataContext) + + // EnterContainer_data_clause is called when entering the container_data_clause production. + EnterContainer_data_clause(c *Container_data_clauseContext) + + // EnterAdminister_key_management is called when entering the administer_key_management production. + EnterAdminister_key_management(c *Administer_key_managementContext) + + // EnterKeystore_management_clauses is called when entering the keystore_management_clauses production. + EnterKeystore_management_clauses(c *Keystore_management_clausesContext) + + // EnterCreate_keystore is called when entering the create_keystore production. + EnterCreate_keystore(c *Create_keystoreContext) + + // EnterOpen_keystore is called when entering the open_keystore production. + EnterOpen_keystore(c *Open_keystoreContext) + + // EnterForce_keystore is called when entering the force_keystore production. + EnterForce_keystore(c *Force_keystoreContext) + + // EnterClose_keystore is called when entering the close_keystore production. + EnterClose_keystore(c *Close_keystoreContext) + + // EnterBackup_keystore is called when entering the backup_keystore production. + EnterBackup_keystore(c *Backup_keystoreContext) + + // EnterAlter_keystore_password is called when entering the alter_keystore_password production. + EnterAlter_keystore_password(c *Alter_keystore_passwordContext) + + // EnterMerge_into_new_keystore is called when entering the merge_into_new_keystore production. + EnterMerge_into_new_keystore(c *Merge_into_new_keystoreContext) + + // EnterMerge_into_existing_keystore is called when entering the merge_into_existing_keystore production. + EnterMerge_into_existing_keystore(c *Merge_into_existing_keystoreContext) + + // EnterIsolate_keystore is called when entering the isolate_keystore production. + EnterIsolate_keystore(c *Isolate_keystoreContext) + + // EnterUnite_keystore is called when entering the unite_keystore production. + EnterUnite_keystore(c *Unite_keystoreContext) + + // EnterKey_management_clauses is called when entering the key_management_clauses production. + EnterKey_management_clauses(c *Key_management_clausesContext) + + // EnterSet_key is called when entering the set_key production. + EnterSet_key(c *Set_keyContext) + + // EnterCreate_key is called when entering the create_key production. + EnterCreate_key(c *Create_keyContext) + + // EnterMkid is called when entering the mkid production. + EnterMkid(c *MkidContext) + + // EnterMk is called when entering the mk production. + EnterMk(c *MkContext) + + // EnterUse_key is called when entering the use_key production. + EnterUse_key(c *Use_keyContext) + + // EnterSet_key_tag is called when entering the set_key_tag production. + EnterSet_key_tag(c *Set_key_tagContext) + + // EnterExport_keys is called when entering the export_keys production. + EnterExport_keys(c *Export_keysContext) + + // EnterImport_keys is called when entering the import_keys production. + EnterImport_keys(c *Import_keysContext) + + // EnterMigrate_keys is called when entering the migrate_keys production. + EnterMigrate_keys(c *Migrate_keysContext) + + // EnterReverse_migrate_keys is called when entering the reverse_migrate_keys production. + EnterReverse_migrate_keys(c *Reverse_migrate_keysContext) + + // EnterMove_keys is called when entering the move_keys production. + EnterMove_keys(c *Move_keysContext) + + // EnterIdentified_by_store is called when entering the identified_by_store production. + EnterIdentified_by_store(c *Identified_by_storeContext) + + // EnterUsing_algorithm_clause is called when entering the using_algorithm_clause production. + EnterUsing_algorithm_clause(c *Using_algorithm_clauseContext) + + // EnterUsing_tag_clause is called when entering the using_tag_clause production. + EnterUsing_tag_clause(c *Using_tag_clauseContext) + + // EnterSecret_management_clauses is called when entering the secret_management_clauses production. + EnterSecret_management_clauses(c *Secret_management_clausesContext) + + // EnterAdd_update_secret is called when entering the add_update_secret production. + EnterAdd_update_secret(c *Add_update_secretContext) + + // EnterDelete_secret is called when entering the delete_secret production. + EnterDelete_secret(c *Delete_secretContext) + + // EnterAdd_update_secret_seps is called when entering the add_update_secret_seps production. + EnterAdd_update_secret_seps(c *Add_update_secret_sepsContext) + + // EnterDelete_secret_seps is called when entering the delete_secret_seps production. + EnterDelete_secret_seps(c *Delete_secret_sepsContext) + + // EnterZero_downtime_software_patching_clauses is called when entering the zero_downtime_software_patching_clauses production. + EnterZero_downtime_software_patching_clauses(c *Zero_downtime_software_patching_clausesContext) + + // EnterWith_backup_clause is called when entering the with_backup_clause production. + EnterWith_backup_clause(c *With_backup_clauseContext) + + // EnterIdentified_by_password_clause is called when entering the identified_by_password_clause production. + EnterIdentified_by_password_clause(c *Identified_by_password_clauseContext) + + // EnterKeystore_password is called when entering the keystore_password production. + EnterKeystore_password(c *Keystore_passwordContext) + + // EnterPath is called when entering the path production. + EnterPath(c *PathContext) + + // EnterSecret is called when entering the secret production. + EnterSecret(c *SecretContext) + + // EnterAnalyze is called when entering the analyze production. + EnterAnalyze(c *AnalyzeContext) + + // EnterPartition_extention_clause is called when entering the partition_extention_clause production. + EnterPartition_extention_clause(c *Partition_extention_clauseContext) + + // EnterValidation_clauses is called when entering the validation_clauses production. + EnterValidation_clauses(c *Validation_clausesContext) + + // EnterCompute_clauses is called when entering the compute_clauses production. + EnterCompute_clauses(c *Compute_clausesContext) + + // EnterFor_clause is called when entering the for_clause production. + EnterFor_clause(c *For_clauseContext) + + // EnterOnline_or_offline is called when entering the online_or_offline production. + EnterOnline_or_offline(c *Online_or_offlineContext) + + // EnterInto_clause1 is called when entering the into_clause1 production. + EnterInto_clause1(c *Into_clause1Context) + + // EnterPartition_key_value is called when entering the partition_key_value production. + EnterPartition_key_value(c *Partition_key_valueContext) + + // EnterSubpartition_key_value is called when entering the subpartition_key_value production. + EnterSubpartition_key_value(c *Subpartition_key_valueContext) + + // EnterAssociate_statistics is called when entering the associate_statistics production. + EnterAssociate_statistics(c *Associate_statisticsContext) + + // EnterColumn_association is called when entering the column_association production. + EnterColumn_association(c *Column_associationContext) + + // EnterFunction_association is called when entering the function_association production. + EnterFunction_association(c *Function_associationContext) + + // EnterIndextype_name is called when entering the indextype_name production. + EnterIndextype_name(c *Indextype_nameContext) + + // EnterUsing_statistics_type is called when entering the using_statistics_type production. + EnterUsing_statistics_type(c *Using_statistics_typeContext) + + // EnterStatistics_type_name is called when entering the statistics_type_name production. + EnterStatistics_type_name(c *Statistics_type_nameContext) + + // EnterDefault_cost_clause is called when entering the default_cost_clause production. + EnterDefault_cost_clause(c *Default_cost_clauseContext) + + // EnterCpu_cost is called when entering the cpu_cost production. + EnterCpu_cost(c *Cpu_costContext) + + // EnterIo_cost is called when entering the io_cost production. + EnterIo_cost(c *Io_costContext) + + // EnterNetwork_cost is called when entering the network_cost production. + EnterNetwork_cost(c *Network_costContext) + + // EnterDefault_selectivity_clause is called when entering the default_selectivity_clause production. + EnterDefault_selectivity_clause(c *Default_selectivity_clauseContext) + + // EnterDefault_selectivity is called when entering the default_selectivity production. + EnterDefault_selectivity(c *Default_selectivityContext) + + // EnterStorage_table_clause is called when entering the storage_table_clause production. + EnterStorage_table_clause(c *Storage_table_clauseContext) + + // EnterUnified_auditing is called when entering the unified_auditing production. + EnterUnified_auditing(c *Unified_auditingContext) + + // EnterPolicy_name is called when entering the policy_name production. + EnterPolicy_name(c *Policy_nameContext) + + // EnterAudit_traditional is called when entering the audit_traditional production. + EnterAudit_traditional(c *Audit_traditionalContext) + + // EnterAudit_direct_path is called when entering the audit_direct_path production. + EnterAudit_direct_path(c *Audit_direct_pathContext) + + // EnterAudit_container_clause is called when entering the audit_container_clause production. + EnterAudit_container_clause(c *Audit_container_clauseContext) + + // EnterAudit_operation_clause is called when entering the audit_operation_clause production. + EnterAudit_operation_clause(c *Audit_operation_clauseContext) + + // EnterAuditing_by_clause is called when entering the auditing_by_clause production. + EnterAuditing_by_clause(c *Auditing_by_clauseContext) + + // EnterAudit_user is called when entering the audit_user production. + EnterAudit_user(c *Audit_userContext) + + // EnterAudit_schema_object_clause is called when entering the audit_schema_object_clause production. + EnterAudit_schema_object_clause(c *Audit_schema_object_clauseContext) + + // EnterSql_operation is called when entering the sql_operation production. + EnterSql_operation(c *Sql_operationContext) + + // EnterAuditing_on_clause is called when entering the auditing_on_clause production. + EnterAuditing_on_clause(c *Auditing_on_clauseContext) + + // EnterModel_name is called when entering the model_name production. + EnterModel_name(c *Model_nameContext) + + // EnterObject_name is called when entering the object_name production. + EnterObject_name(c *Object_nameContext) + + // EnterProfile_name is called when entering the profile_name production. + EnterProfile_name(c *Profile_nameContext) + + // EnterSql_statement_shortcut is called when entering the sql_statement_shortcut production. + EnterSql_statement_shortcut(c *Sql_statement_shortcutContext) + + // EnterDrop_index is called when entering the drop_index production. + EnterDrop_index(c *Drop_indexContext) + + // EnterDisassociate_statistics is called when entering the disassociate_statistics production. + EnterDisassociate_statistics(c *Disassociate_statisticsContext) + + // EnterDrop_indextype is called when entering the drop_indextype production. + EnterDrop_indextype(c *Drop_indextypeContext) + + // EnterDrop_inmemory_join_group is called when entering the drop_inmemory_join_group production. + EnterDrop_inmemory_join_group(c *Drop_inmemory_join_groupContext) + + // EnterFlashback_table is called when entering the flashback_table production. + EnterFlashback_table(c *Flashback_tableContext) + + // EnterRestore_point is called when entering the restore_point production. + EnterRestore_point(c *Restore_pointContext) + + // EnterPurge_statement is called when entering the purge_statement production. + EnterPurge_statement(c *Purge_statementContext) + + // EnterNoaudit_statement is called when entering the noaudit_statement production. + EnterNoaudit_statement(c *Noaudit_statementContext) + + // EnterRename_object is called when entering the rename_object production. + EnterRename_object(c *Rename_objectContext) + + // EnterGrant_statement is called when entering the grant_statement production. + EnterGrant_statement(c *Grant_statementContext) + + // EnterContainer_clause is called when entering the container_clause production. + EnterContainer_clause(c *Container_clauseContext) + + // EnterRevoke_statement is called when entering the revoke_statement production. + EnterRevoke_statement(c *Revoke_statementContext) + + // EnterRevoke_system_privilege is called when entering the revoke_system_privilege production. + EnterRevoke_system_privilege(c *Revoke_system_privilegeContext) + + // EnterRevokee_clause is called when entering the revokee_clause production. + EnterRevokee_clause(c *Revokee_clauseContext) + + // EnterRevoke_object_privileges is called when entering the revoke_object_privileges production. + EnterRevoke_object_privileges(c *Revoke_object_privilegesContext) + + // EnterOn_object_clause is called when entering the on_object_clause production. + EnterOn_object_clause(c *On_object_clauseContext) + + // EnterRevoke_roles_from_programs is called when entering the revoke_roles_from_programs production. + EnterRevoke_roles_from_programs(c *Revoke_roles_from_programsContext) + + // EnterProgram_unit is called when entering the program_unit production. + EnterProgram_unit(c *Program_unitContext) + + // EnterCreate_dimension is called when entering the create_dimension production. + EnterCreate_dimension(c *Create_dimensionContext) + + // EnterCreate_directory is called when entering the create_directory production. + EnterCreate_directory(c *Create_directoryContext) + + // EnterDirectory_name is called when entering the directory_name production. + EnterDirectory_name(c *Directory_nameContext) + + // EnterDirectory_path is called when entering the directory_path production. + EnterDirectory_path(c *Directory_pathContext) + + // EnterCreate_inmemory_join_group is called when entering the create_inmemory_join_group production. + EnterCreate_inmemory_join_group(c *Create_inmemory_join_groupContext) + + // EnterDrop_hierarchy is called when entering the drop_hierarchy production. + EnterDrop_hierarchy(c *Drop_hierarchyContext) + + // EnterAlter_library is called when entering the alter_library production. + EnterAlter_library(c *Alter_libraryContext) + + // EnterDrop_java is called when entering the drop_java production. + EnterDrop_java(c *Drop_javaContext) + + // EnterDrop_library is called when entering the drop_library production. + EnterDrop_library(c *Drop_libraryContext) + + // EnterCreate_java is called when entering the create_java production. + EnterCreate_java(c *Create_javaContext) + + // EnterCreate_library is called when entering the create_library production. + EnterCreate_library(c *Create_libraryContext) + + // EnterPlsql_library_source is called when entering the plsql_library_source production. + EnterPlsql_library_source(c *Plsql_library_sourceContext) + + // EnterCredential_name is called when entering the credential_name production. + EnterCredential_name(c *Credential_nameContext) + + // EnterLibrary_editionable is called when entering the library_editionable production. + EnterLibrary_editionable(c *Library_editionableContext) + + // EnterLibrary_debug is called when entering the library_debug production. + EnterLibrary_debug(c *Library_debugContext) + + // EnterCompiler_parameters_clause is called when entering the compiler_parameters_clause production. + EnterCompiler_parameters_clause(c *Compiler_parameters_clauseContext) + + // EnterParameter_value is called when entering the parameter_value production. + EnterParameter_value(c *Parameter_valueContext) + + // EnterLibrary_name is called when entering the library_name production. + EnterLibrary_name(c *Library_nameContext) + + // EnterAlter_dimension is called when entering the alter_dimension production. + EnterAlter_dimension(c *Alter_dimensionContext) + + // EnterLevel_clause is called when entering the level_clause production. + EnterLevel_clause(c *Level_clauseContext) + + // EnterHierarchy_clause is called when entering the hierarchy_clause production. + EnterHierarchy_clause(c *Hierarchy_clauseContext) + + // EnterDimension_join_clause is called when entering the dimension_join_clause production. + EnterDimension_join_clause(c *Dimension_join_clauseContext) + + // EnterAttribute_clause is called when entering the attribute_clause production. + EnterAttribute_clause(c *Attribute_clauseContext) + + // EnterExtended_attribute_clause is called when entering the extended_attribute_clause production. + EnterExtended_attribute_clause(c *Extended_attribute_clauseContext) + + // EnterColumn_one_or_more_sub_clause is called when entering the column_one_or_more_sub_clause production. + EnterColumn_one_or_more_sub_clause(c *Column_one_or_more_sub_clauseContext) + + // EnterAlter_view is called when entering the alter_view production. + EnterAlter_view(c *Alter_viewContext) + + // EnterAlter_view_editionable is called when entering the alter_view_editionable production. + EnterAlter_view_editionable(c *Alter_view_editionableContext) + + // EnterCreate_view is called when entering the create_view production. + EnterCreate_view(c *Create_viewContext) + + // EnterEditioning_clause is called when entering the editioning_clause production. + EnterEditioning_clause(c *Editioning_clauseContext) + + // EnterView_options is called when entering the view_options production. + EnterView_options(c *View_optionsContext) + + // EnterView_alias_constraint is called when entering the view_alias_constraint production. + EnterView_alias_constraint(c *View_alias_constraintContext) + + // EnterObject_view_clause is called when entering the object_view_clause production. + EnterObject_view_clause(c *Object_view_clauseContext) + + // EnterInline_constraint is called when entering the inline_constraint production. + EnterInline_constraint(c *Inline_constraintContext) + + // EnterInline_ref_constraint is called when entering the inline_ref_constraint production. + EnterInline_ref_constraint(c *Inline_ref_constraintContext) + + // EnterOut_of_line_ref_constraint is called when entering the out_of_line_ref_constraint production. + EnterOut_of_line_ref_constraint(c *Out_of_line_ref_constraintContext) + + // EnterOut_of_line_constraint is called when entering the out_of_line_constraint production. + EnterOut_of_line_constraint(c *Out_of_line_constraintContext) + + // EnterConstraint_state is called when entering the constraint_state production. + EnterConstraint_state(c *Constraint_stateContext) + + // EnterXmltype_view_clause is called when entering the xmltype_view_clause production. + EnterXmltype_view_clause(c *Xmltype_view_clauseContext) + + // EnterXml_schema_spec is called when entering the xml_schema_spec production. + EnterXml_schema_spec(c *Xml_schema_specContext) + + // EnterXml_schema_url is called when entering the xml_schema_url production. + EnterXml_schema_url(c *Xml_schema_urlContext) + + // EnterElement is called when entering the element production. + EnterElement(c *ElementContext) + + // EnterAlter_tablespace is called when entering the alter_tablespace production. + EnterAlter_tablespace(c *Alter_tablespaceContext) + + // EnterDatafile_tempfile_clauses is called when entering the datafile_tempfile_clauses production. + EnterDatafile_tempfile_clauses(c *Datafile_tempfile_clausesContext) + + // EnterTablespace_logging_clauses is called when entering the tablespace_logging_clauses production. + EnterTablespace_logging_clauses(c *Tablespace_logging_clausesContext) + + // EnterTablespace_group_clause is called when entering the tablespace_group_clause production. + EnterTablespace_group_clause(c *Tablespace_group_clauseContext) + + // EnterTablespace_group_name is called when entering the tablespace_group_name production. + EnterTablespace_group_name(c *Tablespace_group_nameContext) + + // EnterTablespace_state_clauses is called when entering the tablespace_state_clauses production. + EnterTablespace_state_clauses(c *Tablespace_state_clausesContext) + + // EnterFlashback_mode_clause is called when entering the flashback_mode_clause production. + EnterFlashback_mode_clause(c *Flashback_mode_clauseContext) + + // EnterNew_tablespace_name is called when entering the new_tablespace_name production. + EnterNew_tablespace_name(c *New_tablespace_nameContext) + + // EnterCreate_tablespace is called when entering the create_tablespace production. + EnterCreate_tablespace(c *Create_tablespaceContext) + + // EnterPermanent_tablespace_clause is called when entering the permanent_tablespace_clause production. + EnterPermanent_tablespace_clause(c *Permanent_tablespace_clauseContext) + + // EnterTablespace_encryption_spec is called when entering the tablespace_encryption_spec production. + EnterTablespace_encryption_spec(c *Tablespace_encryption_specContext) + + // EnterLogging_clause is called when entering the logging_clause production. + EnterLogging_clause(c *Logging_clauseContext) + + // EnterExtent_management_clause is called when entering the extent_management_clause production. + EnterExtent_management_clause(c *Extent_management_clauseContext) + + // EnterSegment_management_clause is called when entering the segment_management_clause production. + EnterSegment_management_clause(c *Segment_management_clauseContext) + + // EnterTemporary_tablespace_clause is called when entering the temporary_tablespace_clause production. + EnterTemporary_tablespace_clause(c *Temporary_tablespace_clauseContext) + + // EnterUndo_tablespace_clause is called when entering the undo_tablespace_clause production. + EnterUndo_tablespace_clause(c *Undo_tablespace_clauseContext) + + // EnterTablespace_retention_clause is called when entering the tablespace_retention_clause production. + EnterTablespace_retention_clause(c *Tablespace_retention_clauseContext) + + // EnterCreate_tablespace_set is called when entering the create_tablespace_set production. + EnterCreate_tablespace_set(c *Create_tablespace_setContext) + + // EnterPermanent_tablespace_attrs is called when entering the permanent_tablespace_attrs production. + EnterPermanent_tablespace_attrs(c *Permanent_tablespace_attrsContext) + + // EnterTablespace_encryption_clause is called when entering the tablespace_encryption_clause production. + EnterTablespace_encryption_clause(c *Tablespace_encryption_clauseContext) + + // EnterDefault_tablespace_params is called when entering the default_tablespace_params production. + EnterDefault_tablespace_params(c *Default_tablespace_paramsContext) + + // EnterDefault_table_compression is called when entering the default_table_compression production. + EnterDefault_table_compression(c *Default_table_compressionContext) + + // EnterLow_high is called when entering the low_high production. + EnterLow_high(c *Low_highContext) + + // EnterDefault_index_compression is called when entering the default_index_compression production. + EnterDefault_index_compression(c *Default_index_compressionContext) + + // EnterInmmemory_clause is called when entering the inmmemory_clause production. + EnterInmmemory_clause(c *Inmmemory_clauseContext) + + // EnterDatafile_specification is called when entering the datafile_specification production. + EnterDatafile_specification(c *Datafile_specificationContext) + + // EnterTempfile_specification is called when entering the tempfile_specification production. + EnterTempfile_specification(c *Tempfile_specificationContext) + + // EnterDatafile_tempfile_spec is called when entering the datafile_tempfile_spec production. + EnterDatafile_tempfile_spec(c *Datafile_tempfile_specContext) + + // EnterRedo_log_file_spec is called when entering the redo_log_file_spec production. + EnterRedo_log_file_spec(c *Redo_log_file_specContext) + + // EnterAutoextend_clause is called when entering the autoextend_clause production. + EnterAutoextend_clause(c *Autoextend_clauseContext) + + // EnterMaxsize_clause is called when entering the maxsize_clause production. + EnterMaxsize_clause(c *Maxsize_clauseContext) + + // EnterBuild_clause is called when entering the build_clause production. + EnterBuild_clause(c *Build_clauseContext) + + // EnterPartial_index_clause is called when entering the partial_index_clause production. + EnterPartial_index_clause(c *Partial_index_clauseContext) + + // EnterParallel_clause is called when entering the parallel_clause production. + EnterParallel_clause(c *Parallel_clauseContext) + + // EnterAlter_materialized_view is called when entering the alter_materialized_view production. + EnterAlter_materialized_view(c *Alter_materialized_viewContext) + + // EnterAlter_mv_option1 is called when entering the alter_mv_option1 production. + EnterAlter_mv_option1(c *Alter_mv_option1Context) + + // EnterAlter_mv_refresh is called when entering the alter_mv_refresh production. + EnterAlter_mv_refresh(c *Alter_mv_refreshContext) + + // EnterRollback_segment is called when entering the rollback_segment production. + EnterRollback_segment(c *Rollback_segmentContext) + + // EnterModify_mv_column_clause is called when entering the modify_mv_column_clause production. + EnterModify_mv_column_clause(c *Modify_mv_column_clauseContext) + + // EnterAlter_materialized_view_log is called when entering the alter_materialized_view_log production. + EnterAlter_materialized_view_log(c *Alter_materialized_view_logContext) + + // EnterAdd_mv_log_column_clause is called when entering the add_mv_log_column_clause production. + EnterAdd_mv_log_column_clause(c *Add_mv_log_column_clauseContext) + + // EnterMove_mv_log_clause is called when entering the move_mv_log_clause production. + EnterMove_mv_log_clause(c *Move_mv_log_clauseContext) + + // EnterMv_log_augmentation is called when entering the mv_log_augmentation production. + EnterMv_log_augmentation(c *Mv_log_augmentationContext) + + // EnterDatetime_expr is called when entering the datetime_expr production. + EnterDatetime_expr(c *Datetime_exprContext) + + // EnterInterval_expr is called when entering the interval_expr production. + EnterInterval_expr(c *Interval_exprContext) + + // EnterSynchronous_or_asynchronous is called when entering the synchronous_or_asynchronous production. + EnterSynchronous_or_asynchronous(c *Synchronous_or_asynchronousContext) + + // EnterIncluding_or_excluding is called when entering the including_or_excluding production. + EnterIncluding_or_excluding(c *Including_or_excludingContext) + + // EnterCreate_materialized_view_log is called when entering the create_materialized_view_log production. + EnterCreate_materialized_view_log(c *Create_materialized_view_logContext) + + // EnterNew_values_clause is called when entering the new_values_clause production. + EnterNew_values_clause(c *New_values_clauseContext) + + // EnterMv_log_purge_clause is called when entering the mv_log_purge_clause production. + EnterMv_log_purge_clause(c *Mv_log_purge_clauseContext) + + // EnterCreate_materialized_zonemap is called when entering the create_materialized_zonemap production. + EnterCreate_materialized_zonemap(c *Create_materialized_zonemapContext) + + // EnterAlter_materialized_zonemap is called when entering the alter_materialized_zonemap production. + EnterAlter_materialized_zonemap(c *Alter_materialized_zonemapContext) + + // EnterDrop_materialized_zonemap is called when entering the drop_materialized_zonemap production. + EnterDrop_materialized_zonemap(c *Drop_materialized_zonemapContext) + + // EnterZonemap_refresh_clause is called when entering the zonemap_refresh_clause production. + EnterZonemap_refresh_clause(c *Zonemap_refresh_clauseContext) + + // EnterZonemap_attributes is called when entering the zonemap_attributes production. + EnterZonemap_attributes(c *Zonemap_attributesContext) + + // EnterZonemap_name is called when entering the zonemap_name production. + EnterZonemap_name(c *Zonemap_nameContext) + + // EnterOperator_name is called when entering the operator_name production. + EnterOperator_name(c *Operator_nameContext) + + // EnterOperator_function_name is called when entering the operator_function_name production. + EnterOperator_function_name(c *Operator_function_nameContext) + + // EnterCreate_zonemap_on_table is called when entering the create_zonemap_on_table production. + EnterCreate_zonemap_on_table(c *Create_zonemap_on_tableContext) + + // EnterCreate_zonemap_as_subquery is called when entering the create_zonemap_as_subquery production. + EnterCreate_zonemap_as_subquery(c *Create_zonemap_as_subqueryContext) + + // EnterAlter_operator is called when entering the alter_operator production. + EnterAlter_operator(c *Alter_operatorContext) + + // EnterDrop_operator is called when entering the drop_operator production. + EnterDrop_operator(c *Drop_operatorContext) + + // EnterCreate_operator is called when entering the create_operator production. + EnterCreate_operator(c *Create_operatorContext) + + // EnterBinding_clause is called when entering the binding_clause production. + EnterBinding_clause(c *Binding_clauseContext) + + // EnterAdd_binding_clause is called when entering the add_binding_clause production. + EnterAdd_binding_clause(c *Add_binding_clauseContext) + + // EnterImplementation_clause is called when entering the implementation_clause production. + EnterImplementation_clause(c *Implementation_clauseContext) + + // EnterPrimary_operator_list is called when entering the primary_operator_list production. + EnterPrimary_operator_list(c *Primary_operator_listContext) + + // EnterPrimary_operator_item is called when entering the primary_operator_item production. + EnterPrimary_operator_item(c *Primary_operator_itemContext) + + // EnterOperator_context_clause is called when entering the operator_context_clause production. + EnterOperator_context_clause(c *Operator_context_clauseContext) + + // EnterUsing_function_clause is called when entering the using_function_clause production. + EnterUsing_function_clause(c *Using_function_clauseContext) + + // EnterDrop_binding_clause is called when entering the drop_binding_clause production. + EnterDrop_binding_clause(c *Drop_binding_clauseContext) + + // EnterCreate_materialized_view is called when entering the create_materialized_view production. + EnterCreate_materialized_view(c *Create_materialized_viewContext) + + // EnterScoped_table_ref_constraint is called when entering the scoped_table_ref_constraint production. + EnterScoped_table_ref_constraint(c *Scoped_table_ref_constraintContext) + + // EnterMv_column_alias is called when entering the mv_column_alias production. + EnterMv_column_alias(c *Mv_column_aliasContext) + + // EnterCreate_mv_refresh is called when entering the create_mv_refresh production. + EnterCreate_mv_refresh(c *Create_mv_refreshContext) + + // EnterDrop_materialized_view is called when entering the drop_materialized_view production. + EnterDrop_materialized_view(c *Drop_materialized_viewContext) + + // EnterCreate_context is called when entering the create_context production. + EnterCreate_context(c *Create_contextContext) + + // EnterOracle_namespace is called when entering the oracle_namespace production. + EnterOracle_namespace(c *Oracle_namespaceContext) + + // EnterCreate_cluster is called when entering the create_cluster production. + EnterCreate_cluster(c *Create_clusterContext) + + // EnterCreate_profile is called when entering the create_profile production. + EnterCreate_profile(c *Create_profileContext) + + // EnterResource_parameters is called when entering the resource_parameters production. + EnterResource_parameters(c *Resource_parametersContext) + + // EnterPassword_parameters is called when entering the password_parameters production. + EnterPassword_parameters(c *Password_parametersContext) + + // EnterCreate_lockdown_profile is called when entering the create_lockdown_profile production. + EnterCreate_lockdown_profile(c *Create_lockdown_profileContext) + + // EnterStatic_base_profile is called when entering the static_base_profile production. + EnterStatic_base_profile(c *Static_base_profileContext) + + // EnterDynamic_base_profile is called when entering the dynamic_base_profile production. + EnterDynamic_base_profile(c *Dynamic_base_profileContext) + + // EnterCreate_outline is called when entering the create_outline production. + EnterCreate_outline(c *Create_outlineContext) + + // EnterCreate_restore_point is called when entering the create_restore_point production. + EnterCreate_restore_point(c *Create_restore_pointContext) + + // EnterCreate_role is called when entering the create_role production. + EnterCreate_role(c *Create_roleContext) + + // EnterCreate_table is called when entering the create_table production. + EnterCreate_table(c *Create_tableContext) + + // EnterXmltype_table is called when entering the xmltype_table production. + EnterXmltype_table(c *Xmltype_tableContext) + + // EnterXmltype_virtual_columns is called when entering the xmltype_virtual_columns production. + EnterXmltype_virtual_columns(c *Xmltype_virtual_columnsContext) + + // EnterXmltype_column_properties is called when entering the xmltype_column_properties production. + EnterXmltype_column_properties(c *Xmltype_column_propertiesContext) + + // EnterXmltype_storage is called when entering the xmltype_storage production. + EnterXmltype_storage(c *Xmltype_storageContext) + + // EnterXmlschema_spec is called when entering the xmlschema_spec production. + EnterXmlschema_spec(c *Xmlschema_specContext) + + // EnterObject_table is called when entering the object_table production. + EnterObject_table(c *Object_tableContext) + + // EnterObject_type is called when entering the object_type production. + EnterObject_type(c *Object_typeContext) + + // EnterOid_index_clause is called when entering the oid_index_clause production. + EnterOid_index_clause(c *Oid_index_clauseContext) + + // EnterOid_clause is called when entering the oid_clause production. + EnterOid_clause(c *Oid_clauseContext) + + // EnterObject_properties is called when entering the object_properties production. + EnterObject_properties(c *Object_propertiesContext) + + // EnterObject_table_substitution is called when entering the object_table_substitution production. + EnterObject_table_substitution(c *Object_table_substitutionContext) + + // EnterRelational_table is called when entering the relational_table production. + EnterRelational_table(c *Relational_tableContext) + + // EnterImmutable_table_clauses is called when entering the immutable_table_clauses production. + EnterImmutable_table_clauses(c *Immutable_table_clausesContext) + + // EnterImmutable_table_no_drop_clause is called when entering the immutable_table_no_drop_clause production. + EnterImmutable_table_no_drop_clause(c *Immutable_table_no_drop_clauseContext) + + // EnterImmutable_table_no_delete_clause is called when entering the immutable_table_no_delete_clause production. + EnterImmutable_table_no_delete_clause(c *Immutable_table_no_delete_clauseContext) + + // EnterBlockchain_table_clauses is called when entering the blockchain_table_clauses production. + EnterBlockchain_table_clauses(c *Blockchain_table_clausesContext) + + // EnterBlockchain_drop_table_clause is called when entering the blockchain_drop_table_clause production. + EnterBlockchain_drop_table_clause(c *Blockchain_drop_table_clauseContext) + + // EnterBlockchain_row_retention_clause is called when entering the blockchain_row_retention_clause production. + EnterBlockchain_row_retention_clause(c *Blockchain_row_retention_clauseContext) + + // EnterBlockchain_hash_and_data_format_clause is called when entering the blockchain_hash_and_data_format_clause production. + EnterBlockchain_hash_and_data_format_clause(c *Blockchain_hash_and_data_format_clauseContext) + + // EnterCollation_name is called when entering the collation_name production. + EnterCollation_name(c *Collation_nameContext) + + // EnterTable_properties is called when entering the table_properties production. + EnterTable_properties(c *Table_propertiesContext) + + // EnterRead_only_clause is called when entering the read_only_clause production. + EnterRead_only_clause(c *Read_only_clauseContext) + + // EnterIndexing_clause is called when entering the indexing_clause production. + EnterIndexing_clause(c *Indexing_clauseContext) + + // EnterAttribute_clustering_clause is called when entering the attribute_clustering_clause production. + EnterAttribute_clustering_clause(c *Attribute_clustering_clauseContext) + + // EnterClustering_join is called when entering the clustering_join production. + EnterClustering_join(c *Clustering_joinContext) + + // EnterClustering_join_item is called when entering the clustering_join_item production. + EnterClustering_join_item(c *Clustering_join_itemContext) + + // EnterEquijoin_condition is called when entering the equijoin_condition production. + EnterEquijoin_condition(c *Equijoin_conditionContext) + + // EnterCluster_clause is called when entering the cluster_clause production. + EnterCluster_clause(c *Cluster_clauseContext) + + // EnterClustering_columns is called when entering the clustering_columns production. + EnterClustering_columns(c *Clustering_columnsContext) + + // EnterClustering_column_group is called when entering the clustering_column_group production. + EnterClustering_column_group(c *Clustering_column_groupContext) + + // EnterYes_no is called when entering the yes_no production. + EnterYes_no(c *Yes_noContext) + + // EnterZonemap_clause is called when entering the zonemap_clause production. + EnterZonemap_clause(c *Zonemap_clauseContext) + + // EnterLogical_replication_clause is called when entering the logical_replication_clause production. + EnterLogical_replication_clause(c *Logical_replication_clauseContext) + + // EnterTable_name is called when entering the table_name production. + EnterTable_name(c *Table_nameContext) + + // EnterRelational_property is called when entering the relational_property production. + EnterRelational_property(c *Relational_propertyContext) + + // EnterTable_partitioning_clauses is called when entering the table_partitioning_clauses production. + EnterTable_partitioning_clauses(c *Table_partitioning_clausesContext) + + // EnterRange_partitions is called when entering the range_partitions production. + EnterRange_partitions(c *Range_partitionsContext) + + // EnterList_partitions is called when entering the list_partitions production. + EnterList_partitions(c *List_partitionsContext) + + // EnterHash_partitions is called when entering the hash_partitions production. + EnterHash_partitions(c *Hash_partitionsContext) + + // EnterIndividual_hash_partitions is called when entering the individual_hash_partitions production. + EnterIndividual_hash_partitions(c *Individual_hash_partitionsContext) + + // EnterHash_partitions_by_quantity is called when entering the hash_partitions_by_quantity production. + EnterHash_partitions_by_quantity(c *Hash_partitions_by_quantityContext) + + // EnterHash_partition_quantity is called when entering the hash_partition_quantity production. + EnterHash_partition_quantity(c *Hash_partition_quantityContext) + + // EnterComposite_range_partitions is called when entering the composite_range_partitions production. + EnterComposite_range_partitions(c *Composite_range_partitionsContext) + + // EnterComposite_list_partitions is called when entering the composite_list_partitions production. + EnterComposite_list_partitions(c *Composite_list_partitionsContext) + + // EnterComposite_hash_partitions is called when entering the composite_hash_partitions production. + EnterComposite_hash_partitions(c *Composite_hash_partitionsContext) + + // EnterReference_partitioning is called when entering the reference_partitioning production. + EnterReference_partitioning(c *Reference_partitioningContext) + + // EnterReference_partition_desc is called when entering the reference_partition_desc production. + EnterReference_partition_desc(c *Reference_partition_descContext) + + // EnterSystem_partitioning is called when entering the system_partitioning production. + EnterSystem_partitioning(c *System_partitioningContext) + + // EnterRange_partition_desc is called when entering the range_partition_desc production. + EnterRange_partition_desc(c *Range_partition_descContext) + + // EnterList_partition_desc is called when entering the list_partition_desc production. + EnterList_partition_desc(c *List_partition_descContext) + + // EnterSubpartition_template is called when entering the subpartition_template production. + EnterSubpartition_template(c *Subpartition_templateContext) + + // EnterHash_subpartition_quantity is called when entering the hash_subpartition_quantity production. + EnterHash_subpartition_quantity(c *Hash_subpartition_quantityContext) + + // EnterSubpartition_by_range is called when entering the subpartition_by_range production. + EnterSubpartition_by_range(c *Subpartition_by_rangeContext) + + // EnterSubpartition_by_list is called when entering the subpartition_by_list production. + EnterSubpartition_by_list(c *Subpartition_by_listContext) + + // EnterSubpartition_by_hash is called when entering the subpartition_by_hash production. + EnterSubpartition_by_hash(c *Subpartition_by_hashContext) + + // EnterSubpartition_name is called when entering the subpartition_name production. + EnterSubpartition_name(c *Subpartition_nameContext) + + // EnterRange_subpartition_desc is called when entering the range_subpartition_desc production. + EnterRange_subpartition_desc(c *Range_subpartition_descContext) + + // EnterList_subpartition_desc is called when entering the list_subpartition_desc production. + EnterList_subpartition_desc(c *List_subpartition_descContext) + + // EnterIndividual_hash_subparts is called when entering the individual_hash_subparts production. + EnterIndividual_hash_subparts(c *Individual_hash_subpartsContext) + + // EnterHash_subparts_by_quantity is called when entering the hash_subparts_by_quantity production. + EnterHash_subparts_by_quantity(c *Hash_subparts_by_quantityContext) + + // EnterRange_values_clause is called when entering the range_values_clause production. + EnterRange_values_clause(c *Range_values_clauseContext) + + // EnterList_values_clause is called when entering the list_values_clause production. + EnterList_values_clause(c *List_values_clauseContext) + + // EnterTable_partition_description is called when entering the table_partition_description production. + EnterTable_partition_description(c *Table_partition_descriptionContext) + + // EnterPartitioning_storage_clause is called when entering the partitioning_storage_clause production. + EnterPartitioning_storage_clause(c *Partitioning_storage_clauseContext) + + // EnterLob_partitioning_storage is called when entering the lob_partitioning_storage production. + EnterLob_partitioning_storage(c *Lob_partitioning_storageContext) + + // EnterDatatype_null_enable is called when entering the datatype_null_enable production. + EnterDatatype_null_enable(c *Datatype_null_enableContext) + + // EnterSize_clause is called when entering the size_clause production. + EnterSize_clause(c *Size_clauseContext) + + // EnterTable_compression is called when entering the table_compression production. + EnterTable_compression(c *Table_compressionContext) + + // EnterInmemory_table_clause is called when entering the inmemory_table_clause production. + EnterInmemory_table_clause(c *Inmemory_table_clauseContext) + + // EnterInmemory_attributes is called when entering the inmemory_attributes production. + EnterInmemory_attributes(c *Inmemory_attributesContext) + + // EnterInmemory_memcompress is called when entering the inmemory_memcompress production. + EnterInmemory_memcompress(c *Inmemory_memcompressContext) + + // EnterInmemory_priority is called when entering the inmemory_priority production. + EnterInmemory_priority(c *Inmemory_priorityContext) + + // EnterInmemory_distribute is called when entering the inmemory_distribute production. + EnterInmemory_distribute(c *Inmemory_distributeContext) + + // EnterInmemory_duplicate is called when entering the inmemory_duplicate production. + EnterInmemory_duplicate(c *Inmemory_duplicateContext) + + // EnterInmemory_column_clause is called when entering the inmemory_column_clause production. + EnterInmemory_column_clause(c *Inmemory_column_clauseContext) + + // EnterPhysical_attributes_clause is called when entering the physical_attributes_clause production. + EnterPhysical_attributes_clause(c *Physical_attributes_clauseContext) + + // EnterStorage_clause is called when entering the storage_clause production. + EnterStorage_clause(c *Storage_clauseContext) + + // EnterDeferred_segment_creation is called when entering the deferred_segment_creation production. + EnterDeferred_segment_creation(c *Deferred_segment_creationContext) + + // EnterSegment_attributes_clause is called when entering the segment_attributes_clause production. + EnterSegment_attributes_clause(c *Segment_attributes_clauseContext) + + // EnterPhysical_properties is called when entering the physical_properties production. + EnterPhysical_properties(c *Physical_propertiesContext) + + // EnterIlm_clause is called when entering the ilm_clause production. + EnterIlm_clause(c *Ilm_clauseContext) + + // EnterIlm_policy_clause is called when entering the ilm_policy_clause production. + EnterIlm_policy_clause(c *Ilm_policy_clauseContext) + + // EnterIlm_compression_policy is called when entering the ilm_compression_policy production. + EnterIlm_compression_policy(c *Ilm_compression_policyContext) + + // EnterIlm_tiering_policy is called when entering the ilm_tiering_policy production. + EnterIlm_tiering_policy(c *Ilm_tiering_policyContext) + + // EnterIlm_after_on is called when entering the ilm_after_on production. + EnterIlm_after_on(c *Ilm_after_onContext) + + // EnterSegment_group is called when entering the segment_group production. + EnterSegment_group(c *Segment_groupContext) + + // EnterIlm_inmemory_policy is called when entering the ilm_inmemory_policy production. + EnterIlm_inmemory_policy(c *Ilm_inmemory_policyContext) + + // EnterIlm_time_period is called when entering the ilm_time_period production. + EnterIlm_time_period(c *Ilm_time_periodContext) + + // EnterHeap_org_table_clause is called when entering the heap_org_table_clause production. + EnterHeap_org_table_clause(c *Heap_org_table_clauseContext) + + // EnterExternal_table_clause is called when entering the external_table_clause production. + EnterExternal_table_clause(c *External_table_clauseContext) + + // EnterAccess_driver_type is called when entering the access_driver_type production. + EnterAccess_driver_type(c *Access_driver_typeContext) + + // EnterExternal_table_data_props is called when entering the external_table_data_props production. + EnterExternal_table_data_props(c *External_table_data_propsContext) + + // EnterOpaque_format_spec is called when entering the opaque_format_spec production. + EnterOpaque_format_spec(c *Opaque_format_specContext) + + // EnterRecord_format_info is called when entering the record_format_info production. + EnterRecord_format_info(c *Record_format_infoContext) + + // EnterEt_string is called when entering the et_string production. + EnterEt_string(c *Et_stringContext) + + // EnterEt_record_spec_options is called when entering the et_record_spec_options production. + EnterEt_record_spec_options(c *Et_record_spec_optionsContext) + + // EnterEt_record_spec_option is called when entering the et_record_spec_option production. + EnterEt_record_spec_option(c *Et_record_spec_optionContext) + + // EnterEt_output_files is called when entering the et_output_files production. + EnterEt_output_files(c *Et_output_filesContext) + + // EnterEt_output_file is called when entering the et_output_file production. + EnterEt_output_file(c *Et_output_fileContext) + + // EnterDirectory_spec is called when entering the directory_spec production. + EnterDirectory_spec(c *Directory_specContext) + + // EnterFile_spec is called when entering the file_spec production. + EnterFile_spec(c *File_specContext) + + // EnterField_definitions is called when entering the field_definitions production. + EnterField_definitions(c *Field_definitionsContext) + + // EnterField_options is called when entering the field_options production. + EnterField_options(c *Field_optionsContext) + + // EnterField_option is called when entering the field_option production. + EnterField_option(c *Field_optionContext) + + // EnterField_list is called when entering the field_list production. + EnterField_list(c *Field_listContext) + + // EnterField_item is called when entering the field_item production. + EnterField_item(c *Field_itemContext) + + // EnterField_name is called when entering the field_name production. + EnterField_name(c *Field_nameContext) + + // EnterPos_spec is called when entering the pos_spec production. + EnterPos_spec(c *Pos_specContext) + + // EnterPos_start is called when entering the pos_start production. + EnterPos_start(c *Pos_startContext) + + // EnterPos_increment is called when entering the pos_increment production. + EnterPos_increment(c *Pos_incrementContext) + + // EnterPos_end is called when entering the pos_end production. + EnterPos_end(c *Pos_endContext) + + // EnterPos_length is called when entering the pos_length production. + EnterPos_length(c *Pos_lengthContext) + + // EnterDatatype_spec is called when entering the datatype_spec production. + EnterDatatype_spec(c *Datatype_specContext) + + // EnterInit_spec is called when entering the init_spec production. + EnterInit_spec(c *Init_specContext) + + // EnterLls_clause is called when entering the lls_clause production. + EnterLls_clause(c *Lls_clauseContext) + + // EnterDelim_spec is called when entering the delim_spec production. + EnterDelim_spec(c *Delim_specContext) + + // EnterTrim_spec is called when entering the trim_spec production. + EnterTrim_spec(c *Trim_specContext) + + // EnterField_date_format is called when entering the field_date_format production. + EnterField_date_format(c *Field_date_formatContext) + + // EnterColumn_transforms is called when entering the column_transforms production. + EnterColumn_transforms(c *Column_transformsContext) + + // EnterTransform is called when entering the transform production. + EnterTransform(c *TransformContext) + + // EnterSource_field is called when entering the source_field production. + EnterSource_field(c *Source_fieldContext) + + // EnterLobfile_item is called when entering the lobfile_item production. + EnterLobfile_item(c *Lobfile_itemContext) + + // EnterLobfile_attr_list is called when entering the lobfile_attr_list production. + EnterLobfile_attr_list(c *Lobfile_attr_listContext) + + // EnterConcat_item is called when entering the concat_item production. + EnterConcat_item(c *Concat_itemContext) + + // EnterRow_movement_clause is called when entering the row_movement_clause production. + EnterRow_movement_clause(c *Row_movement_clauseContext) + + // EnterFlashback_archive_clause is called when entering the flashback_archive_clause production. + EnterFlashback_archive_clause(c *Flashback_archive_clauseContext) + + // EnterLog_grp is called when entering the log_grp production. + EnterLog_grp(c *Log_grpContext) + + // EnterSupplemental_table_logging is called when entering the supplemental_table_logging production. + EnterSupplemental_table_logging(c *Supplemental_table_loggingContext) + + // EnterSupplemental_log_grp_clause is called when entering the supplemental_log_grp_clause production. + EnterSupplemental_log_grp_clause(c *Supplemental_log_grp_clauseContext) + + // EnterSupplemental_id_key_clause is called when entering the supplemental_id_key_clause production. + EnterSupplemental_id_key_clause(c *Supplemental_id_key_clauseContext) + + // EnterAllocate_extent_clause is called when entering the allocate_extent_clause production. + EnterAllocate_extent_clause(c *Allocate_extent_clauseContext) + + // EnterDeallocate_unused_clause is called when entering the deallocate_unused_clause production. + EnterDeallocate_unused_clause(c *Deallocate_unused_clauseContext) + + // EnterShrink_clause is called when entering the shrink_clause production. + EnterShrink_clause(c *Shrink_clauseContext) + + // EnterRecords_per_block_clause is called when entering the records_per_block_clause production. + EnterRecords_per_block_clause(c *Records_per_block_clauseContext) + + // EnterUpgrade_table_clause is called when entering the upgrade_table_clause production. + EnterUpgrade_table_clause(c *Upgrade_table_clauseContext) + + // EnterTruncate_table is called when entering the truncate_table production. + EnterTruncate_table(c *Truncate_tableContext) + + // EnterDrop_table is called when entering the drop_table production. + EnterDrop_table(c *Drop_tableContext) + + // EnterDrop_tablespace is called when entering the drop_tablespace production. + EnterDrop_tablespace(c *Drop_tablespaceContext) + + // EnterDrop_tablespace_set is called when entering the drop_tablespace_set production. + EnterDrop_tablespace_set(c *Drop_tablespace_setContext) + + // EnterIncluding_contents_clause is called when entering the including_contents_clause production. + EnterIncluding_contents_clause(c *Including_contents_clauseContext) + + // EnterDrop_view is called when entering the drop_view production. + EnterDrop_view(c *Drop_viewContext) + + // EnterComment_on_column is called when entering the comment_on_column production. + EnterComment_on_column(c *Comment_on_columnContext) + + // EnterEnable_or_disable is called when entering the enable_or_disable production. + EnterEnable_or_disable(c *Enable_or_disableContext) + + // EnterAllow_or_disallow is called when entering the allow_or_disallow production. + EnterAllow_or_disallow(c *Allow_or_disallowContext) + + // EnterAlter_synonym is called when entering the alter_synonym production. + EnterAlter_synonym(c *Alter_synonymContext) + + // EnterCreate_synonym is called when entering the create_synonym production. + EnterCreate_synonym(c *Create_synonymContext) + + // EnterDrop_synonym is called when entering the drop_synonym production. + EnterDrop_synonym(c *Drop_synonymContext) + + // EnterCreate_spfile is called when entering the create_spfile production. + EnterCreate_spfile(c *Create_spfileContext) + + // EnterSpfile_name is called when entering the spfile_name production. + EnterSpfile_name(c *Spfile_nameContext) + + // EnterPfile_name is called when entering the pfile_name production. + EnterPfile_name(c *Pfile_nameContext) + + // EnterComment_on_table is called when entering the comment_on_table production. + EnterComment_on_table(c *Comment_on_tableContext) + + // EnterComment_on_materialized is called when entering the comment_on_materialized production. + EnterComment_on_materialized(c *Comment_on_materializedContext) + + // EnterAlter_analytic_view is called when entering the alter_analytic_view production. + EnterAlter_analytic_view(c *Alter_analytic_viewContext) + + // EnterAlter_add_cache_clause is called when entering the alter_add_cache_clause production. + EnterAlter_add_cache_clause(c *Alter_add_cache_clauseContext) + + // EnterLevels_item is called when entering the levels_item production. + EnterLevels_item(c *Levels_itemContext) + + // EnterMeasure_list is called when entering the measure_list production. + EnterMeasure_list(c *Measure_listContext) + + // EnterAlter_drop_cache_clause is called when entering the alter_drop_cache_clause production. + EnterAlter_drop_cache_clause(c *Alter_drop_cache_clauseContext) + + // EnterAlter_attribute_dimension is called when entering the alter_attribute_dimension production. + EnterAlter_attribute_dimension(c *Alter_attribute_dimensionContext) + + // EnterAlter_audit_policy is called when entering the alter_audit_policy production. + EnterAlter_audit_policy(c *Alter_audit_policyContext) + + // EnterAlter_cluster is called when entering the alter_cluster production. + EnterAlter_cluster(c *Alter_clusterContext) + + // EnterDrop_analytic_view is called when entering the drop_analytic_view production. + EnterDrop_analytic_view(c *Drop_analytic_viewContext) + + // EnterDrop_attribute_dimension is called when entering the drop_attribute_dimension production. + EnterDrop_attribute_dimension(c *Drop_attribute_dimensionContext) + + // EnterDrop_audit_policy is called when entering the drop_audit_policy production. + EnterDrop_audit_policy(c *Drop_audit_policyContext) + + // EnterDrop_flashback_archive is called when entering the drop_flashback_archive production. + EnterDrop_flashback_archive(c *Drop_flashback_archiveContext) + + // EnterDrop_cluster is called when entering the drop_cluster production. + EnterDrop_cluster(c *Drop_clusterContext) + + // EnterDrop_context is called when entering the drop_context production. + EnterDrop_context(c *Drop_contextContext) + + // EnterDrop_directory is called when entering the drop_directory production. + EnterDrop_directory(c *Drop_directoryContext) + + // EnterDrop_diskgroup is called when entering the drop_diskgroup production. + EnterDrop_diskgroup(c *Drop_diskgroupContext) + + // EnterDrop_edition is called when entering the drop_edition production. + EnterDrop_edition(c *Drop_editionContext) + + // EnterTruncate_cluster is called when entering the truncate_cluster production. + EnterTruncate_cluster(c *Truncate_clusterContext) + + // EnterCache_or_nocache is called when entering the cache_or_nocache production. + EnterCache_or_nocache(c *Cache_or_nocacheContext) + + // EnterDatabase_name is called when entering the database_name production. + EnterDatabase_name(c *Database_nameContext) + + // EnterAlter_database is called when entering the alter_database production. + EnterAlter_database(c *Alter_databaseContext) + + // EnterDatabase_clause is called when entering the database_clause production. + EnterDatabase_clause(c *Database_clauseContext) + + // EnterStartup_clauses is called when entering the startup_clauses production. + EnterStartup_clauses(c *Startup_clausesContext) + + // EnterResetlogs_or_noresetlogs is called when entering the resetlogs_or_noresetlogs production. + EnterResetlogs_or_noresetlogs(c *Resetlogs_or_noresetlogsContext) + + // EnterUpgrade_or_downgrade is called when entering the upgrade_or_downgrade production. + EnterUpgrade_or_downgrade(c *Upgrade_or_downgradeContext) + + // EnterRecovery_clauses is called when entering the recovery_clauses production. + EnterRecovery_clauses(c *Recovery_clausesContext) + + // EnterBegin_or_end is called when entering the begin_or_end production. + EnterBegin_or_end(c *Begin_or_endContext) + + // EnterGeneral_recovery is called when entering the general_recovery production. + EnterGeneral_recovery(c *General_recoveryContext) + + // EnterFull_database_recovery is called when entering the full_database_recovery production. + EnterFull_database_recovery(c *Full_database_recoveryContext) + + // EnterPartial_database_recovery is called when entering the partial_database_recovery production. + EnterPartial_database_recovery(c *Partial_database_recoveryContext) + + // EnterPartial_database_recovery_10g is called when entering the partial_database_recovery_10g production. + EnterPartial_database_recovery_10g(c *Partial_database_recovery_10gContext) + + // EnterManaged_standby_recovery is called when entering the managed_standby_recovery production. + EnterManaged_standby_recovery(c *Managed_standby_recoveryContext) + + // EnterDb_name is called when entering the db_name production. + EnterDb_name(c *Db_nameContext) + + // EnterDatabase_file_clauses is called when entering the database_file_clauses production. + EnterDatabase_file_clauses(c *Database_file_clausesContext) + + // EnterCreate_datafile_clause is called when entering the create_datafile_clause production. + EnterCreate_datafile_clause(c *Create_datafile_clauseContext) + + // EnterAlter_datafile_clause is called when entering the alter_datafile_clause production. + EnterAlter_datafile_clause(c *Alter_datafile_clauseContext) + + // EnterAlter_tempfile_clause is called when entering the alter_tempfile_clause production. + EnterAlter_tempfile_clause(c *Alter_tempfile_clauseContext) + + // EnterMove_datafile_clause is called when entering the move_datafile_clause production. + EnterMove_datafile_clause(c *Move_datafile_clauseContext) + + // EnterLogfile_clauses is called when entering the logfile_clauses production. + EnterLogfile_clauses(c *Logfile_clausesContext) + + // EnterAdd_logfile_clauses is called when entering the add_logfile_clauses production. + EnterAdd_logfile_clauses(c *Add_logfile_clausesContext) + + // EnterGroup_redo_logfile is called when entering the group_redo_logfile production. + EnterGroup_redo_logfile(c *Group_redo_logfileContext) + + // EnterDrop_logfile_clauses is called when entering the drop_logfile_clauses production. + EnterDrop_logfile_clauses(c *Drop_logfile_clausesContext) + + // EnterSwitch_logfile_clause is called when entering the switch_logfile_clause production. + EnterSwitch_logfile_clause(c *Switch_logfile_clauseContext) + + // EnterSupplemental_db_logging is called when entering the supplemental_db_logging production. + EnterSupplemental_db_logging(c *Supplemental_db_loggingContext) + + // EnterAdd_or_drop is called when entering the add_or_drop production. + EnterAdd_or_drop(c *Add_or_dropContext) + + // EnterSupplemental_plsql_clause is called when entering the supplemental_plsql_clause production. + EnterSupplemental_plsql_clause(c *Supplemental_plsql_clauseContext) + + // EnterLogfile_descriptor is called when entering the logfile_descriptor production. + EnterLogfile_descriptor(c *Logfile_descriptorContext) + + // EnterControlfile_clauses is called when entering the controlfile_clauses production. + EnterControlfile_clauses(c *Controlfile_clausesContext) + + // EnterTrace_file_clause is called when entering the trace_file_clause production. + EnterTrace_file_clause(c *Trace_file_clauseContext) + + // EnterStandby_database_clauses is called when entering the standby_database_clauses production. + EnterStandby_database_clauses(c *Standby_database_clausesContext) + + // EnterActivate_standby_db_clause is called when entering the activate_standby_db_clause production. + EnterActivate_standby_db_clause(c *Activate_standby_db_clauseContext) + + // EnterMaximize_standby_db_clause is called when entering the maximize_standby_db_clause production. + EnterMaximize_standby_db_clause(c *Maximize_standby_db_clauseContext) + + // EnterRegister_logfile_clause is called when entering the register_logfile_clause production. + EnterRegister_logfile_clause(c *Register_logfile_clauseContext) + + // EnterCommit_switchover_clause is called when entering the commit_switchover_clause production. + EnterCommit_switchover_clause(c *Commit_switchover_clauseContext) + + // EnterStart_standby_clause is called when entering the start_standby_clause production. + EnterStart_standby_clause(c *Start_standby_clauseContext) + + // EnterStop_standby_clause is called when entering the stop_standby_clause production. + EnterStop_standby_clause(c *Stop_standby_clauseContext) + + // EnterConvert_database_clause is called when entering the convert_database_clause production. + EnterConvert_database_clause(c *Convert_database_clauseContext) + + // EnterDefault_settings_clause is called when entering the default_settings_clause production. + EnterDefault_settings_clause(c *Default_settings_clauseContext) + + // EnterSet_time_zone_clause is called when entering the set_time_zone_clause production. + EnterSet_time_zone_clause(c *Set_time_zone_clauseContext) + + // EnterInstance_clauses is called when entering the instance_clauses production. + EnterInstance_clauses(c *Instance_clausesContext) + + // EnterSecurity_clause is called when entering the security_clause production. + EnterSecurity_clause(c *Security_clauseContext) + + // EnterDomain is called when entering the domain production. + EnterDomain(c *DomainContext) + + // EnterDatabase is called when entering the database production. + EnterDatabase(c *DatabaseContext) + + // EnterEdition_name is called when entering the edition_name production. + EnterEdition_name(c *Edition_nameContext) + + // EnterFilenumber is called when entering the filenumber production. + EnterFilenumber(c *FilenumberContext) + + // EnterFilename is called when entering the filename production. + EnterFilename(c *FilenameContext) + + // EnterPrepare_clause is called when entering the prepare_clause production. + EnterPrepare_clause(c *Prepare_clauseContext) + + // EnterDrop_mirror_clause is called when entering the drop_mirror_clause production. + EnterDrop_mirror_clause(c *Drop_mirror_clauseContext) + + // EnterLost_write_protection is called when entering the lost_write_protection production. + EnterLost_write_protection(c *Lost_write_protectionContext) + + // EnterCdb_fleet_clauses is called when entering the cdb_fleet_clauses production. + EnterCdb_fleet_clauses(c *Cdb_fleet_clausesContext) + + // EnterLead_cdb_clause is called when entering the lead_cdb_clause production. + EnterLead_cdb_clause(c *Lead_cdb_clauseContext) + + // EnterLead_cdb_uri_clause is called when entering the lead_cdb_uri_clause production. + EnterLead_cdb_uri_clause(c *Lead_cdb_uri_clauseContext) + + // EnterProperty_clauses is called when entering the property_clauses production. + EnterProperty_clauses(c *Property_clausesContext) + + // EnterReplay_upgrade_clauses is called when entering the replay_upgrade_clauses production. + EnterReplay_upgrade_clauses(c *Replay_upgrade_clausesContext) + + // EnterAlter_database_link is called when entering the alter_database_link production. + EnterAlter_database_link(c *Alter_database_linkContext) + + // EnterPassword_value is called when entering the password_value production. + EnterPassword_value(c *Password_valueContext) + + // EnterLink_authentication is called when entering the link_authentication production. + EnterLink_authentication(c *Link_authenticationContext) + + // EnterCreate_database is called when entering the create_database production. + EnterCreate_database(c *Create_databaseContext) + + // EnterDatabase_logging_clauses is called when entering the database_logging_clauses production. + EnterDatabase_logging_clauses(c *Database_logging_clausesContext) + + // EnterDatabase_logging_sub_clause is called when entering the database_logging_sub_clause production. + EnterDatabase_logging_sub_clause(c *Database_logging_sub_clauseContext) + + // EnterTablespace_clauses is called when entering the tablespace_clauses production. + EnterTablespace_clauses(c *Tablespace_clausesContext) + + // EnterEnable_pluggable_database is called when entering the enable_pluggable_database production. + EnterEnable_pluggable_database(c *Enable_pluggable_databaseContext) + + // EnterFile_name_convert is called when entering the file_name_convert production. + EnterFile_name_convert(c *File_name_convertContext) + + // EnterFilename_convert_sub_clause is called when entering the filename_convert_sub_clause production. + EnterFilename_convert_sub_clause(c *Filename_convert_sub_clauseContext) + + // EnterTablespace_datafile_clauses is called when entering the tablespace_datafile_clauses production. + EnterTablespace_datafile_clauses(c *Tablespace_datafile_clausesContext) + + // EnterUndo_mode_clause is called when entering the undo_mode_clause production. + EnterUndo_mode_clause(c *Undo_mode_clauseContext) + + // EnterDefault_tablespace is called when entering the default_tablespace production. + EnterDefault_tablespace(c *Default_tablespaceContext) + + // EnterDefault_temp_tablespace is called when entering the default_temp_tablespace production. + EnterDefault_temp_tablespace(c *Default_temp_tablespaceContext) + + // EnterUndo_tablespace is called when entering the undo_tablespace production. + EnterUndo_tablespace(c *Undo_tablespaceContext) + + // EnterDrop_database is called when entering the drop_database production. + EnterDrop_database(c *Drop_databaseContext) + + // EnterCreate_database_link is called when entering the create_database_link production. + EnterCreate_database_link(c *Create_database_linkContext) + + // EnterDblink is called when entering the dblink production. + EnterDblink(c *DblinkContext) + + // EnterDrop_database_link is called when entering the drop_database_link production. + EnterDrop_database_link(c *Drop_database_linkContext) + + // EnterAlter_tablespace_set is called when entering the alter_tablespace_set production. + EnterAlter_tablespace_set(c *Alter_tablespace_setContext) + + // EnterAlter_tablespace_attrs is called when entering the alter_tablespace_attrs production. + EnterAlter_tablespace_attrs(c *Alter_tablespace_attrsContext) + + // EnterAlter_tablespace_encryption is called when entering the alter_tablespace_encryption production. + EnterAlter_tablespace_encryption(c *Alter_tablespace_encryptionContext) + + // EnterTs_file_name_convert is called when entering the ts_file_name_convert production. + EnterTs_file_name_convert(c *Ts_file_name_convertContext) + + // EnterAlter_role is called when entering the alter_role production. + EnterAlter_role(c *Alter_roleContext) + + // EnterRole_identified_clause is called when entering the role_identified_clause production. + EnterRole_identified_clause(c *Role_identified_clauseContext) + + // EnterAlter_table is called when entering the alter_table production. + EnterAlter_table(c *Alter_tableContext) + + // EnterMemoptimize_read_write_clause is called when entering the memoptimize_read_write_clause production. + EnterMemoptimize_read_write_clause(c *Memoptimize_read_write_clauseContext) + + // EnterAlter_table_properties is called when entering the alter_table_properties production. + EnterAlter_table_properties(c *Alter_table_propertiesContext) + + // EnterAlter_table_partitioning is called when entering the alter_table_partitioning production. + EnterAlter_table_partitioning(c *Alter_table_partitioningContext) + + // EnterAdd_table_partition is called when entering the add_table_partition production. + EnterAdd_table_partition(c *Add_table_partitionContext) + + // EnterDrop_table_partition is called when entering the drop_table_partition production. + EnterDrop_table_partition(c *Drop_table_partitionContext) + + // EnterMerge_table_partition is called when entering the merge_table_partition production. + EnterMerge_table_partition(c *Merge_table_partitionContext) + + // EnterModify_table_partition is called when entering the modify_table_partition production. + EnterModify_table_partition(c *Modify_table_partitionContext) + + // EnterSplit_table_partition is called when entering the split_table_partition production. + EnterSplit_table_partition(c *Split_table_partitionContext) + + // EnterTruncate_table_partition is called when entering the truncate_table_partition production. + EnterTruncate_table_partition(c *Truncate_table_partitionContext) + + // EnterExchange_table_partition is called when entering the exchange_table_partition production. + EnterExchange_table_partition(c *Exchange_table_partitionContext) + + // EnterCoalesce_table_partition is called when entering the coalesce_table_partition production. + EnterCoalesce_table_partition(c *Coalesce_table_partitionContext) + + // EnterAlter_interval_partition is called when entering the alter_interval_partition production. + EnterAlter_interval_partition(c *Alter_interval_partitionContext) + + // EnterPartition_extended_names is called when entering the partition_extended_names production. + EnterPartition_extended_names(c *Partition_extended_namesContext) + + // EnterSubpartition_extended_names is called when entering the subpartition_extended_names production. + EnterSubpartition_extended_names(c *Subpartition_extended_namesContext) + + // EnterAlter_table_properties_1 is called when entering the alter_table_properties_1 production. + EnterAlter_table_properties_1(c *Alter_table_properties_1Context) + + // EnterAlter_iot_clauses is called when entering the alter_iot_clauses production. + EnterAlter_iot_clauses(c *Alter_iot_clausesContext) + + // EnterAlter_mapping_table_clause is called when entering the alter_mapping_table_clause production. + EnterAlter_mapping_table_clause(c *Alter_mapping_table_clauseContext) + + // EnterAlter_overflow_clause is called when entering the alter_overflow_clause production. + EnterAlter_overflow_clause(c *Alter_overflow_clauseContext) + + // EnterAdd_overflow_clause is called when entering the add_overflow_clause production. + EnterAdd_overflow_clause(c *Add_overflow_clauseContext) + + // EnterUpdate_index_clauses is called when entering the update_index_clauses production. + EnterUpdate_index_clauses(c *Update_index_clausesContext) + + // EnterUpdate_global_index_clause is called when entering the update_global_index_clause production. + EnterUpdate_global_index_clause(c *Update_global_index_clauseContext) + + // EnterUpdate_all_indexes_clause is called when entering the update_all_indexes_clause production. + EnterUpdate_all_indexes_clause(c *Update_all_indexes_clauseContext) + + // EnterUpdate_all_indexes_index_clause is called when entering the update_all_indexes_index_clause production. + EnterUpdate_all_indexes_index_clause(c *Update_all_indexes_index_clauseContext) + + // EnterUpdate_index_partition is called when entering the update_index_partition production. + EnterUpdate_index_partition(c *Update_index_partitionContext) + + // EnterUpdate_index_subpartition is called when entering the update_index_subpartition production. + EnterUpdate_index_subpartition(c *Update_index_subpartitionContext) + + // EnterEnable_disable_clause is called when entering the enable_disable_clause production. + EnterEnable_disable_clause(c *Enable_disable_clauseContext) + + // EnterUsing_index_clause is called when entering the using_index_clause production. + EnterUsing_index_clause(c *Using_index_clauseContext) + + // EnterIndex_attributes is called when entering the index_attributes production. + EnterIndex_attributes(c *Index_attributesContext) + + // EnterSort_or_nosort is called when entering the sort_or_nosort production. + EnterSort_or_nosort(c *Sort_or_nosortContext) + + // EnterExceptions_clause is called when entering the exceptions_clause production. + EnterExceptions_clause(c *Exceptions_clauseContext) + + // EnterMove_table_clause is called when entering the move_table_clause production. + EnterMove_table_clause(c *Move_table_clauseContext) + + // EnterIndex_org_table_clause is called when entering the index_org_table_clause production. + EnterIndex_org_table_clause(c *Index_org_table_clauseContext) + + // EnterMapping_table_clause is called when entering the mapping_table_clause production. + EnterMapping_table_clause(c *Mapping_table_clauseContext) + + // EnterKey_compression is called when entering the key_compression production. + EnterKey_compression(c *Key_compressionContext) + + // EnterIndex_org_overflow_clause is called when entering the index_org_overflow_clause production. + EnterIndex_org_overflow_clause(c *Index_org_overflow_clauseContext) + + // EnterColumn_clauses is called when entering the column_clauses production. + EnterColumn_clauses(c *Column_clausesContext) + + // EnterModify_collection_retrieval is called when entering the modify_collection_retrieval production. + EnterModify_collection_retrieval(c *Modify_collection_retrievalContext) + + // EnterCollection_item is called when entering the collection_item production. + EnterCollection_item(c *Collection_itemContext) + + // EnterRename_column_clause is called when entering the rename_column_clause production. + EnterRename_column_clause(c *Rename_column_clauseContext) + + // EnterOld_column_name is called when entering the old_column_name production. + EnterOld_column_name(c *Old_column_nameContext) + + // EnterNew_column_name is called when entering the new_column_name production. + EnterNew_column_name(c *New_column_nameContext) + + // EnterAdd_modify_drop_column_clauses is called when entering the add_modify_drop_column_clauses production. + EnterAdd_modify_drop_column_clauses(c *Add_modify_drop_column_clausesContext) + + // EnterDrop_column_clause is called when entering the drop_column_clause production. + EnterDrop_column_clause(c *Drop_column_clauseContext) + + // EnterModify_column_clauses is called when entering the modify_column_clauses production. + EnterModify_column_clauses(c *Modify_column_clausesContext) + + // EnterModify_col_visibility is called when entering the modify_col_visibility production. + EnterModify_col_visibility(c *Modify_col_visibilityContext) + + // EnterModify_col_properties is called when entering the modify_col_properties production. + EnterModify_col_properties(c *Modify_col_propertiesContext) + + // EnterModify_col_substitutable is called when entering the modify_col_substitutable production. + EnterModify_col_substitutable(c *Modify_col_substitutableContext) + + // EnterAdd_column_clause is called when entering the add_column_clause production. + EnterAdd_column_clause(c *Add_column_clauseContext) + + // EnterAlter_varray_col_properties is called when entering the alter_varray_col_properties production. + EnterAlter_varray_col_properties(c *Alter_varray_col_propertiesContext) + + // EnterVarray_col_properties is called when entering the varray_col_properties production. + EnterVarray_col_properties(c *Varray_col_propertiesContext) + + // EnterVarray_storage_clause is called when entering the varray_storage_clause production. + EnterVarray_storage_clause(c *Varray_storage_clauseContext) + + // EnterLob_segname is called when entering the lob_segname production. + EnterLob_segname(c *Lob_segnameContext) + + // EnterLob_item is called when entering the lob_item production. + EnterLob_item(c *Lob_itemContext) + + // EnterLob_storage_parameters is called when entering the lob_storage_parameters production. + EnterLob_storage_parameters(c *Lob_storage_parametersContext) + + // EnterLob_storage_clause is called when entering the lob_storage_clause production. + EnterLob_storage_clause(c *Lob_storage_clauseContext) + + // EnterModify_lob_storage_clause is called when entering the modify_lob_storage_clause production. + EnterModify_lob_storage_clause(c *Modify_lob_storage_clauseContext) + + // EnterModify_lob_parameters is called when entering the modify_lob_parameters production. + EnterModify_lob_parameters(c *Modify_lob_parametersContext) + + // EnterLob_parameters is called when entering the lob_parameters production. + EnterLob_parameters(c *Lob_parametersContext) + + // EnterLob_deduplicate_clause is called when entering the lob_deduplicate_clause production. + EnterLob_deduplicate_clause(c *Lob_deduplicate_clauseContext) + + // EnterLob_compression_clause is called when entering the lob_compression_clause production. + EnterLob_compression_clause(c *Lob_compression_clauseContext) + + // EnterLob_retention_clause is called when entering the lob_retention_clause production. + EnterLob_retention_clause(c *Lob_retention_clauseContext) + + // EnterEncryption_spec is called when entering the encryption_spec production. + EnterEncryption_spec(c *Encryption_specContext) + + // EnterTablespace is called when entering the tablespace production. + EnterTablespace(c *TablespaceContext) + + // EnterVarray_item is called when entering the varray_item production. + EnterVarray_item(c *Varray_itemContext) + + // EnterColumn_properties is called when entering the column_properties production. + EnterColumn_properties(c *Column_propertiesContext) + + // EnterLob_partition_storage is called when entering the lob_partition_storage production. + EnterLob_partition_storage(c *Lob_partition_storageContext) + + // EnterPeriod_definition is called when entering the period_definition production. + EnterPeriod_definition(c *Period_definitionContext) + + // EnterStart_time_column is called when entering the start_time_column production. + EnterStart_time_column(c *Start_time_columnContext) + + // EnterEnd_time_column is called when entering the end_time_column production. + EnterEnd_time_column(c *End_time_columnContext) + + // EnterColumn_definition is called when entering the column_definition production. + EnterColumn_definition(c *Column_definitionContext) + + // EnterColumn_collation_name is called when entering the column_collation_name production. + EnterColumn_collation_name(c *Column_collation_nameContext) + + // EnterIdentity_clause is called when entering the identity_clause production. + EnterIdentity_clause(c *Identity_clauseContext) + + // EnterIdentity_options_parentheses is called when entering the identity_options_parentheses production. + EnterIdentity_options_parentheses(c *Identity_options_parenthesesContext) + + // EnterIdentity_options is called when entering the identity_options production. + EnterIdentity_options(c *Identity_optionsContext) + + // EnterVirtual_column_definition is called when entering the virtual_column_definition production. + EnterVirtual_column_definition(c *Virtual_column_definitionContext) + + // EnterAutogenerated_sequence_definition is called when entering the autogenerated_sequence_definition production. + EnterAutogenerated_sequence_definition(c *Autogenerated_sequence_definitionContext) + + // EnterEvaluation_edition_clause is called when entering the evaluation_edition_clause production. + EnterEvaluation_edition_clause(c *Evaluation_edition_clauseContext) + + // EnterOut_of_line_part_storage is called when entering the out_of_line_part_storage production. + EnterOut_of_line_part_storage(c *Out_of_line_part_storageContext) + + // EnterNested_table_col_properties is called when entering the nested_table_col_properties production. + EnterNested_table_col_properties(c *Nested_table_col_propertiesContext) + + // EnterNested_item is called when entering the nested_item production. + EnterNested_item(c *Nested_itemContext) + + // EnterSubstitutable_column_clause is called when entering the substitutable_column_clause production. + EnterSubstitutable_column_clause(c *Substitutable_column_clauseContext) + + // EnterPartition_name is called when entering the partition_name production. + EnterPartition_name(c *Partition_nameContext) + + // EnterSupplemental_logging_props is called when entering the supplemental_logging_props production. + EnterSupplemental_logging_props(c *Supplemental_logging_propsContext) + + // EnterColumn_or_attribute is called when entering the column_or_attribute production. + EnterColumn_or_attribute(c *Column_or_attributeContext) + + // EnterObject_type_col_properties is called when entering the object_type_col_properties production. + EnterObject_type_col_properties(c *Object_type_col_propertiesContext) + + // EnterConstraint_clauses is called when entering the constraint_clauses production. + EnterConstraint_clauses(c *Constraint_clausesContext) + + // EnterOld_constraint_name is called when entering the old_constraint_name production. + EnterOld_constraint_name(c *Old_constraint_nameContext) + + // EnterNew_constraint_name is called when entering the new_constraint_name production. + EnterNew_constraint_name(c *New_constraint_nameContext) + + // EnterDrop_constraint_clause is called when entering the drop_constraint_clause production. + EnterDrop_constraint_clause(c *Drop_constraint_clauseContext) + + // EnterDrop_primary_key_or_unique_or_generic_clause is called when entering the drop_primary_key_or_unique_or_generic_clause production. + EnterDrop_primary_key_or_unique_or_generic_clause(c *Drop_primary_key_or_unique_or_generic_clauseContext) + + // EnterAdd_constraint is called when entering the add_constraint production. + EnterAdd_constraint(c *Add_constraintContext) + + // EnterAdd_constraint_clause is called when entering the add_constraint_clause production. + EnterAdd_constraint_clause(c *Add_constraint_clauseContext) + + // EnterCheck_constraint is called when entering the check_constraint production. + EnterCheck_constraint(c *Check_constraintContext) + + // EnterDrop_constraint is called when entering the drop_constraint production. + EnterDrop_constraint(c *Drop_constraintContext) + + // EnterEnable_constraint is called when entering the enable_constraint production. + EnterEnable_constraint(c *Enable_constraintContext) + + // EnterDisable_constraint is called when entering the disable_constraint production. + EnterDisable_constraint(c *Disable_constraintContext) + + // EnterForeign_key_clause is called when entering the foreign_key_clause production. + EnterForeign_key_clause(c *Foreign_key_clauseContext) + + // EnterReferences_clause is called when entering the references_clause production. + EnterReferences_clause(c *References_clauseContext) + + // EnterOn_delete_clause is called when entering the on_delete_clause production. + EnterOn_delete_clause(c *On_delete_clauseContext) + + // EnterUnique_key_clause is called when entering the unique_key_clause production. + EnterUnique_key_clause(c *Unique_key_clauseContext) + + // EnterPrimary_key_clause is called when entering the primary_key_clause production. + EnterPrimary_key_clause(c *Primary_key_clauseContext) + + // EnterAnonymous_block is called when entering the anonymous_block production. + EnterAnonymous_block(c *Anonymous_blockContext) + + // EnterInvoker_rights_clause is called when entering the invoker_rights_clause production. + EnterInvoker_rights_clause(c *Invoker_rights_clauseContext) + + // EnterCall_spec is called when entering the call_spec production. + EnterCall_spec(c *Call_specContext) + + // EnterJava_spec is called when entering the java_spec production. + EnterJava_spec(c *Java_specContext) + + // EnterC_spec is called when entering the c_spec production. + EnterC_spec(c *C_specContext) + + // EnterC_agent_in_clause is called when entering the c_agent_in_clause production. + EnterC_agent_in_clause(c *C_agent_in_clauseContext) + + // EnterC_parameters_clause is called when entering the c_parameters_clause production. + EnterC_parameters_clause(c *C_parameters_clauseContext) + + // EnterParameter is called when entering the parameter production. + EnterParameter(c *ParameterContext) + + // EnterDefault_value_part is called when entering the default_value_part production. + EnterDefault_value_part(c *Default_value_partContext) + + // EnterSeq_of_declare_specs is called when entering the seq_of_declare_specs production. + EnterSeq_of_declare_specs(c *Seq_of_declare_specsContext) + + // EnterDeclare_spec is called when entering the declare_spec production. + EnterDeclare_spec(c *Declare_specContext) + + // EnterVariable_declaration is called when entering the variable_declaration production. + EnterVariable_declaration(c *Variable_declarationContext) + + // EnterSubtype_declaration is called when entering the subtype_declaration production. + EnterSubtype_declaration(c *Subtype_declarationContext) + + // EnterCursor_declaration is called when entering the cursor_declaration production. + EnterCursor_declaration(c *Cursor_declarationContext) + + // EnterParameter_spec is called when entering the parameter_spec production. + EnterParameter_spec(c *Parameter_specContext) + + // EnterException_declaration is called when entering the exception_declaration production. + EnterException_declaration(c *Exception_declarationContext) + + // EnterPragma_declaration is called when entering the pragma_declaration production. + EnterPragma_declaration(c *Pragma_declarationContext) + + // EnterRecord_type_def is called when entering the record_type_def production. + EnterRecord_type_def(c *Record_type_defContext) + + // EnterField_spec is called when entering the field_spec production. + EnterField_spec(c *Field_specContext) + + // EnterRef_cursor_type_def is called when entering the ref_cursor_type_def production. + EnterRef_cursor_type_def(c *Ref_cursor_type_defContext) + + // EnterType_declaration is called when entering the type_declaration production. + EnterType_declaration(c *Type_declarationContext) + + // EnterTable_type_def is called when entering the table_type_def production. + EnterTable_type_def(c *Table_type_defContext) + + // EnterTable_indexed_by_part is called when entering the table_indexed_by_part production. + EnterTable_indexed_by_part(c *Table_indexed_by_partContext) + + // EnterVarray_type_def is called when entering the varray_type_def production. + EnterVarray_type_def(c *Varray_type_defContext) + + // EnterSeq_of_statements is called when entering the seq_of_statements production. + EnterSeq_of_statements(c *Seq_of_statementsContext) + + // EnterLabel_declaration is called when entering the label_declaration production. + EnterLabel_declaration(c *Label_declarationContext) + + // EnterStatement is called when entering the statement production. + EnterStatement(c *StatementContext) + + // EnterSwallow_to_semi is called when entering the swallow_to_semi production. + EnterSwallow_to_semi(c *Swallow_to_semiContext) + + // EnterAssignment_statement is called when entering the assignment_statement production. + EnterAssignment_statement(c *Assignment_statementContext) + + // EnterContinue_statement is called when entering the continue_statement production. + EnterContinue_statement(c *Continue_statementContext) + + // EnterExit_statement is called when entering the exit_statement production. + EnterExit_statement(c *Exit_statementContext) + + // EnterGoto_statement is called when entering the goto_statement production. + EnterGoto_statement(c *Goto_statementContext) + + // EnterIf_statement is called when entering the if_statement production. + EnterIf_statement(c *If_statementContext) + + // EnterElsif_part is called when entering the elsif_part production. + EnterElsif_part(c *Elsif_partContext) + + // EnterElse_part is called when entering the else_part production. + EnterElse_part(c *Else_partContext) + + // EnterLoop_statement is called when entering the loop_statement production. + EnterLoop_statement(c *Loop_statementContext) + + // EnterCursor_loop_param is called when entering the cursor_loop_param production. + EnterCursor_loop_param(c *Cursor_loop_paramContext) + + // EnterForall_statement is called when entering the forall_statement production. + EnterForall_statement(c *Forall_statementContext) + + // EnterBounds_clause is called when entering the bounds_clause production. + EnterBounds_clause(c *Bounds_clauseContext) + + // EnterBetween_bound is called when entering the between_bound production. + EnterBetween_bound(c *Between_boundContext) + + // EnterLower_bound is called when entering the lower_bound production. + EnterLower_bound(c *Lower_boundContext) + + // EnterUpper_bound is called when entering the upper_bound production. + EnterUpper_bound(c *Upper_boundContext) + + // EnterNull_statement is called when entering the null_statement production. + EnterNull_statement(c *Null_statementContext) + + // EnterRaise_statement is called when entering the raise_statement production. + EnterRaise_statement(c *Raise_statementContext) + + // EnterReturn_statement is called when entering the return_statement production. + EnterReturn_statement(c *Return_statementContext) + + // EnterCall_statement is called when entering the call_statement production. + EnterCall_statement(c *Call_statementContext) + + // EnterPipe_row_statement is called when entering the pipe_row_statement production. + EnterPipe_row_statement(c *Pipe_row_statementContext) + + // EnterBody is called when entering the body production. + EnterBody(c *BodyContext) + + // EnterException_handler is called when entering the exception_handler production. + EnterException_handler(c *Exception_handlerContext) + + // EnterTrigger_block is called when entering the trigger_block production. + EnterTrigger_block(c *Trigger_blockContext) + + // EnterBlock is called when entering the block production. + EnterBlock(c *BlockContext) + + // EnterSql_statement is called when entering the sql_statement production. + EnterSql_statement(c *Sql_statementContext) + + // EnterExecute_immediate is called when entering the execute_immediate production. + EnterExecute_immediate(c *Execute_immediateContext) + + // EnterDynamic_returning_clause is called when entering the dynamic_returning_clause production. + EnterDynamic_returning_clause(c *Dynamic_returning_clauseContext) + + // EnterData_manipulation_language_statements is called when entering the data_manipulation_language_statements production. + EnterData_manipulation_language_statements(c *Data_manipulation_language_statementsContext) + + // EnterCursor_manipulation_statements is called when entering the cursor_manipulation_statements production. + EnterCursor_manipulation_statements(c *Cursor_manipulation_statementsContext) + + // EnterClose_statement is called when entering the close_statement production. + EnterClose_statement(c *Close_statementContext) + + // EnterOpen_statement is called when entering the open_statement production. + EnterOpen_statement(c *Open_statementContext) + + // EnterFetch_statement is called when entering the fetch_statement production. + EnterFetch_statement(c *Fetch_statementContext) + + // EnterOpen_for_statement is called when entering the open_for_statement production. + EnterOpen_for_statement(c *Open_for_statementContext) + + // EnterTransaction_control_statements is called when entering the transaction_control_statements production. + EnterTransaction_control_statements(c *Transaction_control_statementsContext) + + // EnterSet_transaction_command is called when entering the set_transaction_command production. + EnterSet_transaction_command(c *Set_transaction_commandContext) + + // EnterSet_constraint_command is called when entering the set_constraint_command production. + EnterSet_constraint_command(c *Set_constraint_commandContext) + + // EnterCommit_statement is called when entering the commit_statement production. + EnterCommit_statement(c *Commit_statementContext) + + // EnterWrite_clause is called when entering the write_clause production. + EnterWrite_clause(c *Write_clauseContext) + + // EnterRollback_statement is called when entering the rollback_statement production. + EnterRollback_statement(c *Rollback_statementContext) + + // EnterSavepoint_statement is called when entering the savepoint_statement production. + EnterSavepoint_statement(c *Savepoint_statementContext) + + // EnterExplain_statement is called when entering the explain_statement production. + EnterExplain_statement(c *Explain_statementContext) + + // EnterSelect_only_statement is called when entering the select_only_statement production. + EnterSelect_only_statement(c *Select_only_statementContext) + + // EnterSelect_statement is called when entering the select_statement production. + EnterSelect_statement(c *Select_statementContext) + + // EnterSubquery_factoring_clause is called when entering the subquery_factoring_clause production. + EnterSubquery_factoring_clause(c *Subquery_factoring_clauseContext) + + // EnterFactoring_element is called when entering the factoring_element production. + EnterFactoring_element(c *Factoring_elementContext) + + // EnterSearch_clause is called when entering the search_clause production. + EnterSearch_clause(c *Search_clauseContext) + + // EnterCycle_clause is called when entering the cycle_clause production. + EnterCycle_clause(c *Cycle_clauseContext) + + // EnterSubquery is called when entering the subquery production. + EnterSubquery(c *SubqueryContext) + + // EnterSubquery_basic_elements is called when entering the subquery_basic_elements production. + EnterSubquery_basic_elements(c *Subquery_basic_elementsContext) + + // EnterSubquery_operation_part is called when entering the subquery_operation_part production. + EnterSubquery_operation_part(c *Subquery_operation_partContext) + + // EnterQuery_block is called when entering the query_block production. + EnterQuery_block(c *Query_blockContext) + + // EnterSelected_list is called when entering the selected_list production. + EnterSelected_list(c *Selected_listContext) + + // EnterFrom_clause is called when entering the from_clause production. + EnterFrom_clause(c *From_clauseContext) + + // EnterSelect_list_elements is called when entering the select_list_elements production. + EnterSelect_list_elements(c *Select_list_elementsContext) + + // EnterTable_wild is called when entering the table_wild production. + EnterTable_wild(c *Table_wildContext) + + // EnterTable_ref_list is called when entering the table_ref_list production. + EnterTable_ref_list(c *Table_ref_listContext) + + // EnterTable_ref is called when entering the table_ref production. + EnterTable_ref(c *Table_refContext) + + // EnterTable_ref_aux is called when entering the table_ref_aux production. + EnterTable_ref_aux(c *Table_ref_auxContext) + + // EnterTable_ref_aux_internal_one is called when entering the table_ref_aux_internal_one production. + EnterTable_ref_aux_internal_one(c *Table_ref_aux_internal_oneContext) + + // EnterTable_ref_aux_internal_two is called when entering the table_ref_aux_internal_two production. + EnterTable_ref_aux_internal_two(c *Table_ref_aux_internal_twoContext) + + // EnterTable_ref_aux_internal_three is called when entering the table_ref_aux_internal_three production. + EnterTable_ref_aux_internal_three(c *Table_ref_aux_internal_threeContext) + + // EnterJoin_clause is called when entering the join_clause production. + EnterJoin_clause(c *Join_clauseContext) + + // EnterJoin_on_part is called when entering the join_on_part production. + EnterJoin_on_part(c *Join_on_partContext) + + // EnterJoin_using_part is called when entering the join_using_part production. + EnterJoin_using_part(c *Join_using_partContext) + + // EnterOuter_join_type is called when entering the outer_join_type production. + EnterOuter_join_type(c *Outer_join_typeContext) + + // EnterQuery_partition_clause is called when entering the query_partition_clause production. + EnterQuery_partition_clause(c *Query_partition_clauseContext) + + // EnterFlashback_query_clause is called when entering the flashback_query_clause production. + EnterFlashback_query_clause(c *Flashback_query_clauseContext) + + // EnterPivot_clause is called when entering the pivot_clause production. + EnterPivot_clause(c *Pivot_clauseContext) + + // EnterPivot_element is called when entering the pivot_element production. + EnterPivot_element(c *Pivot_elementContext) + + // EnterPivot_for_clause is called when entering the pivot_for_clause production. + EnterPivot_for_clause(c *Pivot_for_clauseContext) + + // EnterPivot_in_clause is called when entering the pivot_in_clause production. + EnterPivot_in_clause(c *Pivot_in_clauseContext) + + // EnterPivot_in_clause_element is called when entering the pivot_in_clause_element production. + EnterPivot_in_clause_element(c *Pivot_in_clause_elementContext) + + // EnterPivot_in_clause_elements is called when entering the pivot_in_clause_elements production. + EnterPivot_in_clause_elements(c *Pivot_in_clause_elementsContext) + + // EnterUnpivot_clause is called when entering the unpivot_clause production. + EnterUnpivot_clause(c *Unpivot_clauseContext) + + // EnterUnpivot_in_clause is called when entering the unpivot_in_clause production. + EnterUnpivot_in_clause(c *Unpivot_in_clauseContext) + + // EnterUnpivot_in_elements is called when entering the unpivot_in_elements production. + EnterUnpivot_in_elements(c *Unpivot_in_elementsContext) + + // EnterHierarchical_query_clause is called when entering the hierarchical_query_clause production. + EnterHierarchical_query_clause(c *Hierarchical_query_clauseContext) + + // EnterStart_part is called when entering the start_part production. + EnterStart_part(c *Start_partContext) + + // EnterGroup_by_clause is called when entering the group_by_clause production. + EnterGroup_by_clause(c *Group_by_clauseContext) + + // EnterGroup_by_elements is called when entering the group_by_elements production. + EnterGroup_by_elements(c *Group_by_elementsContext) + + // EnterRollup_cube_clause is called when entering the rollup_cube_clause production. + EnterRollup_cube_clause(c *Rollup_cube_clauseContext) + + // EnterGrouping_sets_clause is called when entering the grouping_sets_clause production. + EnterGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // EnterGrouping_sets_elements is called when entering the grouping_sets_elements production. + EnterGrouping_sets_elements(c *Grouping_sets_elementsContext) + + // EnterHaving_clause is called when entering the having_clause production. + EnterHaving_clause(c *Having_clauseContext) + + // EnterModel_clause is called when entering the model_clause production. + EnterModel_clause(c *Model_clauseContext) + + // EnterCell_reference_options is called when entering the cell_reference_options production. + EnterCell_reference_options(c *Cell_reference_optionsContext) + + // EnterReturn_rows_clause is called when entering the return_rows_clause production. + EnterReturn_rows_clause(c *Return_rows_clauseContext) + + // EnterReference_model is called when entering the reference_model production. + EnterReference_model(c *Reference_modelContext) + + // EnterMain_model is called when entering the main_model production. + EnterMain_model(c *Main_modelContext) + + // EnterModel_column_clauses is called when entering the model_column_clauses production. + EnterModel_column_clauses(c *Model_column_clausesContext) + + // EnterModel_column_partition_part is called when entering the model_column_partition_part production. + EnterModel_column_partition_part(c *Model_column_partition_partContext) + + // EnterModel_column_list is called when entering the model_column_list production. + EnterModel_column_list(c *Model_column_listContext) + + // EnterModel_column is called when entering the model_column production. + EnterModel_column(c *Model_columnContext) + + // EnterModel_rules_clause is called when entering the model_rules_clause production. + EnterModel_rules_clause(c *Model_rules_clauseContext) + + // EnterModel_rules_part is called when entering the model_rules_part production. + EnterModel_rules_part(c *Model_rules_partContext) + + // EnterModel_rules_element is called when entering the model_rules_element production. + EnterModel_rules_element(c *Model_rules_elementContext) + + // EnterCell_assignment is called when entering the cell_assignment production. + EnterCell_assignment(c *Cell_assignmentContext) + + // EnterModel_iterate_clause is called when entering the model_iterate_clause production. + EnterModel_iterate_clause(c *Model_iterate_clauseContext) + + // EnterUntil_part is called when entering the until_part production. + EnterUntil_part(c *Until_partContext) + + // EnterOrder_by_clause is called when entering the order_by_clause production. + EnterOrder_by_clause(c *Order_by_clauseContext) + + // EnterOrder_by_elements is called when entering the order_by_elements production. + EnterOrder_by_elements(c *Order_by_elementsContext) + + // EnterOffset_clause is called when entering the offset_clause production. + EnterOffset_clause(c *Offset_clauseContext) + + // EnterFetch_clause is called when entering the fetch_clause production. + EnterFetch_clause(c *Fetch_clauseContext) + + // EnterFor_update_clause is called when entering the for_update_clause production. + EnterFor_update_clause(c *For_update_clauseContext) + + // EnterFor_update_of_part is called when entering the for_update_of_part production. + EnterFor_update_of_part(c *For_update_of_partContext) + + // EnterFor_update_options is called when entering the for_update_options production. + EnterFor_update_options(c *For_update_optionsContext) + + // EnterUpdate_statement is called when entering the update_statement production. + EnterUpdate_statement(c *Update_statementContext) + + // EnterUpdate_set_clause is called when entering the update_set_clause production. + EnterUpdate_set_clause(c *Update_set_clauseContext) + + // EnterColumn_based_update_set_clause is called when entering the column_based_update_set_clause production. + EnterColumn_based_update_set_clause(c *Column_based_update_set_clauseContext) + + // EnterDelete_statement is called when entering the delete_statement production. + EnterDelete_statement(c *Delete_statementContext) + + // EnterInsert_statement is called when entering the insert_statement production. + EnterInsert_statement(c *Insert_statementContext) + + // EnterSingle_table_insert is called when entering the single_table_insert production. + EnterSingle_table_insert(c *Single_table_insertContext) + + // EnterMulti_table_insert is called when entering the multi_table_insert production. + EnterMulti_table_insert(c *Multi_table_insertContext) + + // EnterMulti_table_element is called when entering the multi_table_element production. + EnterMulti_table_element(c *Multi_table_elementContext) + + // EnterConditional_insert_clause is called when entering the conditional_insert_clause production. + EnterConditional_insert_clause(c *Conditional_insert_clauseContext) + + // EnterConditional_insert_when_part is called when entering the conditional_insert_when_part production. + EnterConditional_insert_when_part(c *Conditional_insert_when_partContext) + + // EnterConditional_insert_else_part is called when entering the conditional_insert_else_part production. + EnterConditional_insert_else_part(c *Conditional_insert_else_partContext) + + // EnterInsert_into_clause is called when entering the insert_into_clause production. + EnterInsert_into_clause(c *Insert_into_clauseContext) + + // EnterValues_clause is called when entering the values_clause production. + EnterValues_clause(c *Values_clauseContext) + + // EnterMerge_statement is called when entering the merge_statement production. + EnterMerge_statement(c *Merge_statementContext) + + // EnterMerge_update_clause is called when entering the merge_update_clause production. + EnterMerge_update_clause(c *Merge_update_clauseContext) + + // EnterMerge_element is called when entering the merge_element production. + EnterMerge_element(c *Merge_elementContext) + + // EnterMerge_update_delete_part is called when entering the merge_update_delete_part production. + EnterMerge_update_delete_part(c *Merge_update_delete_partContext) + + // EnterMerge_insert_clause is called when entering the merge_insert_clause production. + EnterMerge_insert_clause(c *Merge_insert_clauseContext) + + // EnterSelected_tableview is called when entering the selected_tableview production. + EnterSelected_tableview(c *Selected_tableviewContext) + + // EnterLock_table_statement is called when entering the lock_table_statement production. + EnterLock_table_statement(c *Lock_table_statementContext) + + // EnterWait_nowait_part is called when entering the wait_nowait_part production. + EnterWait_nowait_part(c *Wait_nowait_partContext) + + // EnterLock_table_element is called when entering the lock_table_element production. + EnterLock_table_element(c *Lock_table_elementContext) + + // EnterLock_mode is called when entering the lock_mode production. + EnterLock_mode(c *Lock_modeContext) + + // EnterGeneral_table_ref is called when entering the general_table_ref production. + EnterGeneral_table_ref(c *General_table_refContext) + + // EnterStatic_returning_clause is called when entering the static_returning_clause production. + EnterStatic_returning_clause(c *Static_returning_clauseContext) + + // EnterError_logging_clause is called when entering the error_logging_clause production. + EnterError_logging_clause(c *Error_logging_clauseContext) + + // EnterError_logging_into_part is called when entering the error_logging_into_part production. + EnterError_logging_into_part(c *Error_logging_into_partContext) + + // EnterError_logging_reject_part is called when entering the error_logging_reject_part production. + EnterError_logging_reject_part(c *Error_logging_reject_partContext) + + // EnterDml_table_expression_clause is called when entering the dml_table_expression_clause production. + EnterDml_table_expression_clause(c *Dml_table_expression_clauseContext) + + // EnterTable_collection_expression is called when entering the table_collection_expression production. + EnterTable_collection_expression(c *Table_collection_expressionContext) + + // EnterSubquery_restriction_clause is called when entering the subquery_restriction_clause production. + EnterSubquery_restriction_clause(c *Subquery_restriction_clauseContext) + + // EnterSample_clause is called when entering the sample_clause production. + EnterSample_clause(c *Sample_clauseContext) + + // EnterSeed_part is called when entering the seed_part production. + EnterSeed_part(c *Seed_partContext) + + // EnterCondition is called when entering the condition production. + EnterCondition(c *ConditionContext) + + // EnterJson_condition is called when entering the json_condition production. + EnterJson_condition(c *Json_conditionContext) + + // EnterExpressions is called when entering the expressions production. + EnterExpressions(c *ExpressionsContext) + + // EnterExpression is called when entering the expression production. + EnterExpression(c *ExpressionContext) + + // EnterCursor_expression is called when entering the cursor_expression production. + EnterCursor_expression(c *Cursor_expressionContext) + + // EnterLogical_expression is called when entering the logical_expression production. + EnterLogical_expression(c *Logical_expressionContext) + + // EnterUnary_logical_expression is called when entering the unary_logical_expression production. + EnterUnary_logical_expression(c *Unary_logical_expressionContext) + + // EnterLogical_operation is called when entering the logical_operation production. + EnterLogical_operation(c *Logical_operationContext) + + // EnterMultiset_expression is called when entering the multiset_expression production. + EnterMultiset_expression(c *Multiset_expressionContext) + + // EnterRelational_expression is called when entering the relational_expression production. + EnterRelational_expression(c *Relational_expressionContext) + + // EnterCompound_expression is called when entering the compound_expression production. + EnterCompound_expression(c *Compound_expressionContext) + + // EnterRelational_operator is called when entering the relational_operator production. + EnterRelational_operator(c *Relational_operatorContext) + + // EnterIn_elements is called when entering the in_elements production. + EnterIn_elements(c *In_elementsContext) + + // EnterBetween_elements is called when entering the between_elements production. + EnterBetween_elements(c *Between_elementsContext) + + // EnterConcatenation is called when entering the concatenation production. + EnterConcatenation(c *ConcatenationContext) + + // EnterInterval_expression is called when entering the interval_expression production. + EnterInterval_expression(c *Interval_expressionContext) + + // EnterModel_expression is called when entering the model_expression production. + EnterModel_expression(c *Model_expressionContext) + + // EnterModel_expression_element is called when entering the model_expression_element production. + EnterModel_expression_element(c *Model_expression_elementContext) + + // EnterSingle_column_for_loop is called when entering the single_column_for_loop production. + EnterSingle_column_for_loop(c *Single_column_for_loopContext) + + // EnterMulti_column_for_loop is called when entering the multi_column_for_loop production. + EnterMulti_column_for_loop(c *Multi_column_for_loopContext) + + // EnterUnary_expression is called when entering the unary_expression production. + EnterUnary_expression(c *Unary_expressionContext) + + // EnterCase_statement is called when entering the case_statement production. + EnterCase_statement(c *Case_statementContext) + + // EnterSimple_case_statement is called when entering the simple_case_statement production. + EnterSimple_case_statement(c *Simple_case_statementContext) + + // EnterSimple_case_when_part is called when entering the simple_case_when_part production. + EnterSimple_case_when_part(c *Simple_case_when_partContext) + + // EnterSearched_case_statement is called when entering the searched_case_statement production. + EnterSearched_case_statement(c *Searched_case_statementContext) + + // EnterSearched_case_when_part is called when entering the searched_case_when_part production. + EnterSearched_case_when_part(c *Searched_case_when_partContext) + + // EnterCase_else_part is called when entering the case_else_part production. + EnterCase_else_part(c *Case_else_partContext) + + // EnterAtom is called when entering the atom production. + EnterAtom(c *AtomContext) + + // EnterQuantified_expression is called when entering the quantified_expression production. + EnterQuantified_expression(c *Quantified_expressionContext) + + // EnterString_function is called when entering the string_function production. + EnterString_function(c *String_functionContext) + + // EnterStandard_function is called when entering the standard_function production. + EnterStandard_function(c *Standard_functionContext) + + // EnterJson_function is called when entering the json_function production. + EnterJson_function(c *Json_functionContext) + + // EnterJson_object_content is called when entering the json_object_content production. + EnterJson_object_content(c *Json_object_contentContext) + + // EnterJson_object_entry is called when entering the json_object_entry production. + EnterJson_object_entry(c *Json_object_entryContext) + + // EnterJson_table_clause is called when entering the json_table_clause production. + EnterJson_table_clause(c *Json_table_clauseContext) + + // EnterJson_array_element is called when entering the json_array_element production. + EnterJson_array_element(c *Json_array_elementContext) + + // EnterJson_on_null_clause is called when entering the json_on_null_clause production. + EnterJson_on_null_clause(c *Json_on_null_clauseContext) + + // EnterJson_return_clause is called when entering the json_return_clause production. + EnterJson_return_clause(c *Json_return_clauseContext) + + // EnterJson_transform_op is called when entering the json_transform_op production. + EnterJson_transform_op(c *Json_transform_opContext) + + // EnterJson_column_clause is called when entering the json_column_clause production. + EnterJson_column_clause(c *Json_column_clauseContext) + + // EnterJson_column_definition is called when entering the json_column_definition production. + EnterJson_column_definition(c *Json_column_definitionContext) + + // EnterJson_query_returning_clause is called when entering the json_query_returning_clause production. + EnterJson_query_returning_clause(c *Json_query_returning_clauseContext) + + // EnterJson_query_return_type is called when entering the json_query_return_type production. + EnterJson_query_return_type(c *Json_query_return_typeContext) + + // EnterJson_query_wrapper_clause is called when entering the json_query_wrapper_clause production. + EnterJson_query_wrapper_clause(c *Json_query_wrapper_clauseContext) + + // EnterJson_query_on_error_clause is called when entering the json_query_on_error_clause production. + EnterJson_query_on_error_clause(c *Json_query_on_error_clauseContext) + + // EnterJson_query_on_empty_clause is called when entering the json_query_on_empty_clause production. + EnterJson_query_on_empty_clause(c *Json_query_on_empty_clauseContext) + + // EnterJson_value_return_clause is called when entering the json_value_return_clause production. + EnterJson_value_return_clause(c *Json_value_return_clauseContext) + + // EnterJson_value_return_type is called when entering the json_value_return_type production. + EnterJson_value_return_type(c *Json_value_return_typeContext) + + // EnterJson_value_on_mismatch_clause is called when entering the json_value_on_mismatch_clause production. + EnterJson_value_on_mismatch_clause(c *Json_value_on_mismatch_clauseContext) + + // EnterLiteral is called when entering the literal production. + EnterLiteral(c *LiteralContext) + + // EnterNumeric_function_wrapper is called when entering the numeric_function_wrapper production. + EnterNumeric_function_wrapper(c *Numeric_function_wrapperContext) + + // EnterNumeric_function is called when entering the numeric_function production. + EnterNumeric_function(c *Numeric_functionContext) + + // EnterListagg_overflow_clause is called when entering the listagg_overflow_clause production. + EnterListagg_overflow_clause(c *Listagg_overflow_clauseContext) + + // EnterOther_function is called when entering the other_function production. + EnterOther_function(c *Other_functionContext) + + // EnterOver_clause_keyword is called when entering the over_clause_keyword production. + EnterOver_clause_keyword(c *Over_clause_keywordContext) + + // EnterWithin_or_over_clause_keyword is called when entering the within_or_over_clause_keyword production. + EnterWithin_or_over_clause_keyword(c *Within_or_over_clause_keywordContext) + + // EnterStandard_prediction_function_keyword is called when entering the standard_prediction_function_keyword production. + EnterStandard_prediction_function_keyword(c *Standard_prediction_function_keywordContext) + + // EnterOver_clause is called when entering the over_clause production. + EnterOver_clause(c *Over_clauseContext) + + // EnterWindowing_clause is called when entering the windowing_clause production. + EnterWindowing_clause(c *Windowing_clauseContext) + + // EnterWindowing_type is called when entering the windowing_type production. + EnterWindowing_type(c *Windowing_typeContext) + + // EnterWindowing_elements is called when entering the windowing_elements production. + EnterWindowing_elements(c *Windowing_elementsContext) + + // EnterUsing_clause is called when entering the using_clause production. + EnterUsing_clause(c *Using_clauseContext) + + // EnterUsing_element is called when entering the using_element production. + EnterUsing_element(c *Using_elementContext) + + // EnterCollect_order_by_part is called when entering the collect_order_by_part production. + EnterCollect_order_by_part(c *Collect_order_by_partContext) + + // EnterWithin_or_over_part is called when entering the within_or_over_part production. + EnterWithin_or_over_part(c *Within_or_over_partContext) + + // EnterCost_matrix_clause is called when entering the cost_matrix_clause production. + EnterCost_matrix_clause(c *Cost_matrix_clauseContext) + + // EnterXml_passing_clause is called when entering the xml_passing_clause production. + EnterXml_passing_clause(c *Xml_passing_clauseContext) + + // EnterXml_attributes_clause is called when entering the xml_attributes_clause production. + EnterXml_attributes_clause(c *Xml_attributes_clauseContext) + + // EnterXml_namespaces_clause is called when entering the xml_namespaces_clause production. + EnterXml_namespaces_clause(c *Xml_namespaces_clauseContext) + + // EnterXml_table_column is called when entering the xml_table_column production. + EnterXml_table_column(c *Xml_table_columnContext) + + // EnterXml_general_default_part is called when entering the xml_general_default_part production. + EnterXml_general_default_part(c *Xml_general_default_partContext) + + // EnterXml_multiuse_expression_element is called when entering the xml_multiuse_expression_element production. + EnterXml_multiuse_expression_element(c *Xml_multiuse_expression_elementContext) + + // EnterXmlroot_param_version_part is called when entering the xmlroot_param_version_part production. + EnterXmlroot_param_version_part(c *Xmlroot_param_version_partContext) + + // EnterXmlroot_param_standalone_part is called when entering the xmlroot_param_standalone_part production. + EnterXmlroot_param_standalone_part(c *Xmlroot_param_standalone_partContext) + + // EnterXmlserialize_param_enconding_part is called when entering the xmlserialize_param_enconding_part production. + EnterXmlserialize_param_enconding_part(c *Xmlserialize_param_enconding_partContext) + + // EnterXmlserialize_param_version_part is called when entering the xmlserialize_param_version_part production. + EnterXmlserialize_param_version_part(c *Xmlserialize_param_version_partContext) + + // EnterXmlserialize_param_ident_part is called when entering the xmlserialize_param_ident_part production. + EnterXmlserialize_param_ident_part(c *Xmlserialize_param_ident_partContext) + + // EnterSql_plus_command is called when entering the sql_plus_command production. + EnterSql_plus_command(c *Sql_plus_commandContext) + + // EnterWhenever_command is called when entering the whenever_command production. + EnterWhenever_command(c *Whenever_commandContext) + + // EnterSet_command is called when entering the set_command production. + EnterSet_command(c *Set_commandContext) + + // EnterTiming_command is called when entering the timing_command production. + EnterTiming_command(c *Timing_commandContext) + + // EnterPartition_extension_clause is called when entering the partition_extension_clause production. + EnterPartition_extension_clause(c *Partition_extension_clauseContext) + + // EnterColumn_alias is called when entering the column_alias production. + EnterColumn_alias(c *Column_aliasContext) + + // EnterTable_alias is called when entering the table_alias production. + EnterTable_alias(c *Table_aliasContext) + + // EnterWhere_clause is called when entering the where_clause production. + EnterWhere_clause(c *Where_clauseContext) + + // EnterQuantitative_where_stmt is called when entering the quantitative_where_stmt production. + EnterQuantitative_where_stmt(c *Quantitative_where_stmtContext) + + // EnterInto_clause is called when entering the into_clause production. + EnterInto_clause(c *Into_clauseContext) + + // EnterXml_column_name is called when entering the xml_column_name production. + EnterXml_column_name(c *Xml_column_nameContext) + + // EnterCost_class_name is called when entering the cost_class_name production. + EnterCost_class_name(c *Cost_class_nameContext) + + // EnterAttribute_name is called when entering the attribute_name production. + EnterAttribute_name(c *Attribute_nameContext) + + // EnterSavepoint_name is called when entering the savepoint_name production. + EnterSavepoint_name(c *Savepoint_nameContext) + + // EnterRollback_segment_name is called when entering the rollback_segment_name production. + EnterRollback_segment_name(c *Rollback_segment_nameContext) + + // EnterTable_var_name is called when entering the table_var_name production. + EnterTable_var_name(c *Table_var_nameContext) + + // EnterSchema_name is called when entering the schema_name production. + EnterSchema_name(c *Schema_nameContext) + + // EnterRoutine_name is called when entering the routine_name production. + EnterRoutine_name(c *Routine_nameContext) + + // EnterPackage_name is called when entering the package_name production. + EnterPackage_name(c *Package_nameContext) + + // EnterImplementation_type_name is called when entering the implementation_type_name production. + EnterImplementation_type_name(c *Implementation_type_nameContext) + + // EnterParameter_name is called when entering the parameter_name production. + EnterParameter_name(c *Parameter_nameContext) + + // EnterReference_model_name is called when entering the reference_model_name production. + EnterReference_model_name(c *Reference_model_nameContext) + + // EnterMain_model_name is called when entering the main_model_name production. + EnterMain_model_name(c *Main_model_nameContext) + + // EnterContainer_tableview_name is called when entering the container_tableview_name production. + EnterContainer_tableview_name(c *Container_tableview_nameContext) + + // EnterAggregate_function_name is called when entering the aggregate_function_name production. + EnterAggregate_function_name(c *Aggregate_function_nameContext) + + // EnterQuery_name is called when entering the query_name production. + EnterQuery_name(c *Query_nameContext) + + // EnterGrantee_name is called when entering the grantee_name production. + EnterGrantee_name(c *Grantee_nameContext) + + // EnterRole_name is called when entering the role_name production. + EnterRole_name(c *Role_nameContext) + + // EnterConstraint_name is called when entering the constraint_name production. + EnterConstraint_name(c *Constraint_nameContext) + + // EnterLabel_name is called when entering the label_name production. + EnterLabel_name(c *Label_nameContext) + + // EnterType_name is called when entering the type_name production. + EnterType_name(c *Type_nameContext) + + // EnterSequence_name is called when entering the sequence_name production. + EnterSequence_name(c *Sequence_nameContext) + + // EnterException_name is called when entering the exception_name production. + EnterException_name(c *Exception_nameContext) + + // EnterFunction_name is called when entering the function_name production. + EnterFunction_name(c *Function_nameContext) + + // EnterProcedure_name is called when entering the procedure_name production. + EnterProcedure_name(c *Procedure_nameContext) + + // EnterTrigger_name is called when entering the trigger_name production. + EnterTrigger_name(c *Trigger_nameContext) + + // EnterVariable_name is called when entering the variable_name production. + EnterVariable_name(c *Variable_nameContext) + + // EnterIndex_name is called when entering the index_name production. + EnterIndex_name(c *Index_nameContext) + + // EnterCursor_name is called when entering the cursor_name production. + EnterCursor_name(c *Cursor_nameContext) + + // EnterRecord_name is called when entering the record_name production. + EnterRecord_name(c *Record_nameContext) + + // EnterCollection_name is called when entering the collection_name production. + EnterCollection_name(c *Collection_nameContext) + + // EnterLink_name is called when entering the link_name production. + EnterLink_name(c *Link_nameContext) + + // EnterColumn_name is called when entering the column_name production. + EnterColumn_name(c *Column_nameContext) + + // EnterTableview_name is called when entering the tableview_name production. + EnterTableview_name(c *Tableview_nameContext) + + // EnterXmltable is called when entering the xmltable production. + EnterXmltable(c *XmltableContext) + + // EnterChar_set_name is called when entering the char_set_name production. + EnterChar_set_name(c *Char_set_nameContext) + + // EnterSynonym_name is called when entering the synonym_name production. + EnterSynonym_name(c *Synonym_nameContext) + + // EnterSchema_object_name is called when entering the schema_object_name production. + EnterSchema_object_name(c *Schema_object_nameContext) + + // EnterDir_object_name is called when entering the dir_object_name production. + EnterDir_object_name(c *Dir_object_nameContext) + + // EnterUser_object_name is called when entering the user_object_name production. + EnterUser_object_name(c *User_object_nameContext) + + // EnterGrant_object_name is called when entering the grant_object_name production. + EnterGrant_object_name(c *Grant_object_nameContext) + + // EnterColumn_list is called when entering the column_list production. + EnterColumn_list(c *Column_listContext) + + // EnterParen_column_list is called when entering the paren_column_list production. + EnterParen_column_list(c *Paren_column_listContext) + + // EnterKeep_clause is called when entering the keep_clause production. + EnterKeep_clause(c *Keep_clauseContext) + + // EnterFunction_argument is called when entering the function_argument production. + EnterFunction_argument(c *Function_argumentContext) + + // EnterFunction_argument_analytic is called when entering the function_argument_analytic production. + EnterFunction_argument_analytic(c *Function_argument_analyticContext) + + // EnterFunction_argument_modeling is called when entering the function_argument_modeling production. + EnterFunction_argument_modeling(c *Function_argument_modelingContext) + + // EnterRespect_or_ignore_nulls is called when entering the respect_or_ignore_nulls production. + EnterRespect_or_ignore_nulls(c *Respect_or_ignore_nullsContext) + + // EnterArgument is called when entering the argument production. + EnterArgument(c *ArgumentContext) + + // EnterType_spec is called when entering the type_spec production. + EnterType_spec(c *Type_specContext) + + // EnterDatatype is called when entering the datatype production. + EnterDatatype(c *DatatypeContext) + + // EnterPrecision_part is called when entering the precision_part production. + EnterPrecision_part(c *Precision_partContext) + + // EnterNative_datatype_element is called when entering the native_datatype_element production. + EnterNative_datatype_element(c *Native_datatype_elementContext) + + // EnterBind_variable is called when entering the bind_variable production. + EnterBind_variable(c *Bind_variableContext) + + // EnterGeneral_element is called when entering the general_element production. + EnterGeneral_element(c *General_elementContext) + + // EnterGeneral_element_part is called when entering the general_element_part production. + EnterGeneral_element_part(c *General_element_partContext) + + // EnterTable_element is called when entering the table_element production. + EnterTable_element(c *Table_elementContext) + + // EnterObject_privilege is called when entering the object_privilege production. + EnterObject_privilege(c *Object_privilegeContext) + + // EnterSystem_privilege is called when entering the system_privilege production. + EnterSystem_privilege(c *System_privilegeContext) + + // EnterConstant is called when entering the constant production. + EnterConstant(c *ConstantContext) + + // EnterConstant_without_variable is called when entering the constant_without_variable production. + EnterConstant_without_variable(c *Constant_without_variableContext) + + // EnterNumeric is called when entering the numeric production. + EnterNumeric(c *NumericContext) + + // EnterNumeric_negative is called when entering the numeric_negative production. + EnterNumeric_negative(c *Numeric_negativeContext) + + // EnterQuoted_string is called when entering the quoted_string production. + EnterQuoted_string(c *Quoted_stringContext) + + // EnterChar_str is called when entering the char_str production. + EnterChar_str(c *Char_strContext) + + // EnterIdentifier is called when entering the identifier production. + EnterIdentifier(c *IdentifierContext) + + // EnterId_expression is called when entering the id_expression production. + EnterId_expression(c *Id_expressionContext) + + // EnterOuter_join_sign is called when entering the outer_join_sign production. + EnterOuter_join_sign(c *Outer_join_signContext) + + // EnterRegular_id is called when entering the regular_id production. + EnterRegular_id(c *Regular_idContext) + + // EnterNon_reserved_keywords_in_12c is called when entering the non_reserved_keywords_in_12c production. + EnterNon_reserved_keywords_in_12c(c *Non_reserved_keywords_in_12cContext) + + // EnterNon_reserved_keywords_pre12c is called when entering the non_reserved_keywords_pre12c production. + EnterNon_reserved_keywords_pre12c(c *Non_reserved_keywords_pre12cContext) + + // EnterString_function_name is called when entering the string_function_name production. + EnterString_function_name(c *String_function_nameContext) + + // EnterNumeric_function_name is called when entering the numeric_function_name production. + EnterNumeric_function_name(c *Numeric_function_nameContext) + + // ExitSql_script is called when exiting the sql_script production. + ExitSql_script(c *Sql_scriptContext) + + // ExitUnit_statement is called when exiting the unit_statement production. + ExitUnit_statement(c *Unit_statementContext) + + // ExitAlter_diskgroup is called when exiting the alter_diskgroup production. + ExitAlter_diskgroup(c *Alter_diskgroupContext) + + // ExitAdd_disk_clause is called when exiting the add_disk_clause production. + ExitAdd_disk_clause(c *Add_disk_clauseContext) + + // ExitDrop_disk_clause is called when exiting the drop_disk_clause production. + ExitDrop_disk_clause(c *Drop_disk_clauseContext) + + // ExitResize_disk_clause is called when exiting the resize_disk_clause production. + ExitResize_disk_clause(c *Resize_disk_clauseContext) + + // ExitReplace_disk_clause is called when exiting the replace_disk_clause production. + ExitReplace_disk_clause(c *Replace_disk_clauseContext) + + // ExitWait_nowait is called when exiting the wait_nowait production. + ExitWait_nowait(c *Wait_nowaitContext) + + // ExitRename_disk_clause is called when exiting the rename_disk_clause production. + ExitRename_disk_clause(c *Rename_disk_clauseContext) + + // ExitDisk_online_clause is called when exiting the disk_online_clause production. + ExitDisk_online_clause(c *Disk_online_clauseContext) + + // ExitDisk_offline_clause is called when exiting the disk_offline_clause production. + ExitDisk_offline_clause(c *Disk_offline_clauseContext) + + // ExitTimeout_clause is called when exiting the timeout_clause production. + ExitTimeout_clause(c *Timeout_clauseContext) + + // ExitRebalance_diskgroup_clause is called when exiting the rebalance_diskgroup_clause production. + ExitRebalance_diskgroup_clause(c *Rebalance_diskgroup_clauseContext) + + // ExitPhase is called when exiting the phase production. + ExitPhase(c *PhaseContext) + + // ExitCheck_diskgroup_clause is called when exiting the check_diskgroup_clause production. + ExitCheck_diskgroup_clause(c *Check_diskgroup_clauseContext) + + // ExitDiskgroup_template_clauses is called when exiting the diskgroup_template_clauses production. + ExitDiskgroup_template_clauses(c *Diskgroup_template_clausesContext) + + // ExitQualified_template_clause is called when exiting the qualified_template_clause production. + ExitQualified_template_clause(c *Qualified_template_clauseContext) + + // ExitRedundancy_clause is called when exiting the redundancy_clause production. + ExitRedundancy_clause(c *Redundancy_clauseContext) + + // ExitStriping_clause is called when exiting the striping_clause production. + ExitStriping_clause(c *Striping_clauseContext) + + // ExitForce_noforce is called when exiting the force_noforce production. + ExitForce_noforce(c *Force_noforceContext) + + // ExitDiskgroup_directory_clauses is called when exiting the diskgroup_directory_clauses production. + ExitDiskgroup_directory_clauses(c *Diskgroup_directory_clausesContext) + + // ExitDir_name is called when exiting the dir_name production. + ExitDir_name(c *Dir_nameContext) + + // ExitDiskgroup_alias_clauses is called when exiting the diskgroup_alias_clauses production. + ExitDiskgroup_alias_clauses(c *Diskgroup_alias_clausesContext) + + // ExitDiskgroup_volume_clauses is called when exiting the diskgroup_volume_clauses production. + ExitDiskgroup_volume_clauses(c *Diskgroup_volume_clausesContext) + + // ExitAdd_volume_clause is called when exiting the add_volume_clause production. + ExitAdd_volume_clause(c *Add_volume_clauseContext) + + // ExitModify_volume_clause is called when exiting the modify_volume_clause production. + ExitModify_volume_clause(c *Modify_volume_clauseContext) + + // ExitDiskgroup_attributes is called when exiting the diskgroup_attributes production. + ExitDiskgroup_attributes(c *Diskgroup_attributesContext) + + // ExitModify_diskgroup_file is called when exiting the modify_diskgroup_file production. + ExitModify_diskgroup_file(c *Modify_diskgroup_fileContext) + + // ExitDisk_region_clause is called when exiting the disk_region_clause production. + ExitDisk_region_clause(c *Disk_region_clauseContext) + + // ExitDrop_diskgroup_file_clause is called when exiting the drop_diskgroup_file_clause production. + ExitDrop_diskgroup_file_clause(c *Drop_diskgroup_file_clauseContext) + + // ExitConvert_redundancy_clause is called when exiting the convert_redundancy_clause production. + ExitConvert_redundancy_clause(c *Convert_redundancy_clauseContext) + + // ExitUsergroup_clauses is called when exiting the usergroup_clauses production. + ExitUsergroup_clauses(c *Usergroup_clausesContext) + + // ExitUser_clauses is called when exiting the user_clauses production. + ExitUser_clauses(c *User_clausesContext) + + // ExitFile_permissions_clause is called when exiting the file_permissions_clause production. + ExitFile_permissions_clause(c *File_permissions_clauseContext) + + // ExitFile_owner_clause is called when exiting the file_owner_clause production. + ExitFile_owner_clause(c *File_owner_clauseContext) + + // ExitScrub_clause is called when exiting the scrub_clause production. + ExitScrub_clause(c *Scrub_clauseContext) + + // ExitQuotagroup_clauses is called when exiting the quotagroup_clauses production. + ExitQuotagroup_clauses(c *Quotagroup_clausesContext) + + // ExitProperty_name is called when exiting the property_name production. + ExitProperty_name(c *Property_nameContext) + + // ExitProperty_value is called when exiting the property_value production. + ExitProperty_value(c *Property_valueContext) + + // ExitFilegroup_clauses is called when exiting the filegroup_clauses production. + ExitFilegroup_clauses(c *Filegroup_clausesContext) + + // ExitAdd_filegroup_clause is called when exiting the add_filegroup_clause production. + ExitAdd_filegroup_clause(c *Add_filegroup_clauseContext) + + // ExitModify_filegroup_clause is called when exiting the modify_filegroup_clause production. + ExitModify_filegroup_clause(c *Modify_filegroup_clauseContext) + + // ExitMove_to_filegroup_clause is called when exiting the move_to_filegroup_clause production. + ExitMove_to_filegroup_clause(c *Move_to_filegroup_clauseContext) + + // ExitDrop_filegroup_clause is called when exiting the drop_filegroup_clause production. + ExitDrop_filegroup_clause(c *Drop_filegroup_clauseContext) + + // ExitQuorum_regular is called when exiting the quorum_regular production. + ExitQuorum_regular(c *Quorum_regularContext) + + // ExitUndrop_disk_clause is called when exiting the undrop_disk_clause production. + ExitUndrop_disk_clause(c *Undrop_disk_clauseContext) + + // ExitDiskgroup_availability is called when exiting the diskgroup_availability production. + ExitDiskgroup_availability(c *Diskgroup_availabilityContext) + + // ExitEnable_disable_volume is called when exiting the enable_disable_volume production. + ExitEnable_disable_volume(c *Enable_disable_volumeContext) + + // ExitDrop_function is called when exiting the drop_function production. + ExitDrop_function(c *Drop_functionContext) + + // ExitAlter_flashback_archive is called when exiting the alter_flashback_archive production. + ExitAlter_flashback_archive(c *Alter_flashback_archiveContext) + + // ExitAlter_hierarchy is called when exiting the alter_hierarchy production. + ExitAlter_hierarchy(c *Alter_hierarchyContext) + + // ExitAlter_function is called when exiting the alter_function production. + ExitAlter_function(c *Alter_functionContext) + + // ExitAlter_java is called when exiting the alter_java production. + ExitAlter_java(c *Alter_javaContext) + + // ExitMatch_string is called when exiting the match_string production. + ExitMatch_string(c *Match_stringContext) + + // ExitCreate_function_body is called when exiting the create_function_body production. + ExitCreate_function_body(c *Create_function_bodyContext) + + // ExitSql_macro_body is called when exiting the sql_macro_body production. + ExitSql_macro_body(c *Sql_macro_bodyContext) + + // ExitParallel_enable_clause is called when exiting the parallel_enable_clause production. + ExitParallel_enable_clause(c *Parallel_enable_clauseContext) + + // ExitPartition_by_clause is called when exiting the partition_by_clause production. + ExitPartition_by_clause(c *Partition_by_clauseContext) + + // ExitResult_cache_clause is called when exiting the result_cache_clause production. + ExitResult_cache_clause(c *Result_cache_clauseContext) + + // ExitRelies_on_part is called when exiting the relies_on_part production. + ExitRelies_on_part(c *Relies_on_partContext) + + // ExitStreaming_clause is called when exiting the streaming_clause production. + ExitStreaming_clause(c *Streaming_clauseContext) + + // ExitAlter_outline is called when exiting the alter_outline production. + ExitAlter_outline(c *Alter_outlineContext) + + // ExitOutline_options is called when exiting the outline_options production. + ExitOutline_options(c *Outline_optionsContext) + + // ExitAlter_lockdown_profile is called when exiting the alter_lockdown_profile production. + ExitAlter_lockdown_profile(c *Alter_lockdown_profileContext) + + // ExitLockdown_feature is called when exiting the lockdown_feature production. + ExitLockdown_feature(c *Lockdown_featureContext) + + // ExitLockdown_options is called when exiting the lockdown_options production. + ExitLockdown_options(c *Lockdown_optionsContext) + + // ExitLockdown_statements is called when exiting the lockdown_statements production. + ExitLockdown_statements(c *Lockdown_statementsContext) + + // ExitStatement_clauses is called when exiting the statement_clauses production. + ExitStatement_clauses(c *Statement_clausesContext) + + // ExitClause_options is called when exiting the clause_options production. + ExitClause_options(c *Clause_optionsContext) + + // ExitOption_values is called when exiting the option_values production. + ExitOption_values(c *Option_valuesContext) + + // ExitString_list is called when exiting the string_list production. + ExitString_list(c *String_listContext) + + // ExitDisable_enable is called when exiting the disable_enable production. + ExitDisable_enable(c *Disable_enableContext) + + // ExitDrop_lockdown_profile is called when exiting the drop_lockdown_profile production. + ExitDrop_lockdown_profile(c *Drop_lockdown_profileContext) + + // ExitDrop_package is called when exiting the drop_package production. + ExitDrop_package(c *Drop_packageContext) + + // ExitAlter_package is called when exiting the alter_package production. + ExitAlter_package(c *Alter_packageContext) + + // ExitCreate_package is called when exiting the create_package production. + ExitCreate_package(c *Create_packageContext) + + // ExitCreate_package_body is called when exiting the create_package_body production. + ExitCreate_package_body(c *Create_package_bodyContext) + + // ExitPackage_obj_spec is called when exiting the package_obj_spec production. + ExitPackage_obj_spec(c *Package_obj_specContext) + + // ExitProcedure_spec is called when exiting the procedure_spec production. + ExitProcedure_spec(c *Procedure_specContext) + + // ExitFunction_spec is called when exiting the function_spec production. + ExitFunction_spec(c *Function_specContext) + + // ExitPackage_obj_body is called when exiting the package_obj_body production. + ExitPackage_obj_body(c *Package_obj_bodyContext) + + // ExitAlter_pmem_filestore is called when exiting the alter_pmem_filestore production. + ExitAlter_pmem_filestore(c *Alter_pmem_filestoreContext) + + // ExitDrop_pmem_filestore is called when exiting the drop_pmem_filestore production. + ExitDrop_pmem_filestore(c *Drop_pmem_filestoreContext) + + // ExitDrop_procedure is called when exiting the drop_procedure production. + ExitDrop_procedure(c *Drop_procedureContext) + + // ExitAlter_procedure is called when exiting the alter_procedure production. + ExitAlter_procedure(c *Alter_procedureContext) + + // ExitFunction_body is called when exiting the function_body production. + ExitFunction_body(c *Function_bodyContext) + + // ExitProcedure_body is called when exiting the procedure_body production. + ExitProcedure_body(c *Procedure_bodyContext) + + // ExitCreate_procedure_body is called when exiting the create_procedure_body production. + ExitCreate_procedure_body(c *Create_procedure_bodyContext) + + // ExitAlter_resource_cost is called when exiting the alter_resource_cost production. + ExitAlter_resource_cost(c *Alter_resource_costContext) + + // ExitDrop_outline is called when exiting the drop_outline production. + ExitDrop_outline(c *Drop_outlineContext) + + // ExitAlter_rollback_segment is called when exiting the alter_rollback_segment production. + ExitAlter_rollback_segment(c *Alter_rollback_segmentContext) + + // ExitDrop_restore_point is called when exiting the drop_restore_point production. + ExitDrop_restore_point(c *Drop_restore_pointContext) + + // ExitDrop_rollback_segment is called when exiting the drop_rollback_segment production. + ExitDrop_rollback_segment(c *Drop_rollback_segmentContext) + + // ExitDrop_role is called when exiting the drop_role production. + ExitDrop_role(c *Drop_roleContext) + + // ExitCreate_pmem_filestore is called when exiting the create_pmem_filestore production. + ExitCreate_pmem_filestore(c *Create_pmem_filestoreContext) + + // ExitPmem_filestore_options is called when exiting the pmem_filestore_options production. + ExitPmem_filestore_options(c *Pmem_filestore_optionsContext) + + // ExitFile_path is called when exiting the file_path production. + ExitFile_path(c *File_pathContext) + + // ExitCreate_rollback_segment is called when exiting the create_rollback_segment production. + ExitCreate_rollback_segment(c *Create_rollback_segmentContext) + + // ExitDrop_trigger is called when exiting the drop_trigger production. + ExitDrop_trigger(c *Drop_triggerContext) + + // ExitAlter_trigger is called when exiting the alter_trigger production. + ExitAlter_trigger(c *Alter_triggerContext) + + // ExitCreate_trigger is called when exiting the create_trigger production. + ExitCreate_trigger(c *Create_triggerContext) + + // ExitTrigger_follows_clause is called when exiting the trigger_follows_clause production. + ExitTrigger_follows_clause(c *Trigger_follows_clauseContext) + + // ExitTrigger_when_clause is called when exiting the trigger_when_clause production. + ExitTrigger_when_clause(c *Trigger_when_clauseContext) + + // ExitSimple_dml_trigger is called when exiting the simple_dml_trigger production. + ExitSimple_dml_trigger(c *Simple_dml_triggerContext) + + // ExitFor_each_row is called when exiting the for_each_row production. + ExitFor_each_row(c *For_each_rowContext) + + // ExitCompound_dml_trigger is called when exiting the compound_dml_trigger production. + ExitCompound_dml_trigger(c *Compound_dml_triggerContext) + + // ExitNon_dml_trigger is called when exiting the non_dml_trigger production. + ExitNon_dml_trigger(c *Non_dml_triggerContext) + + // ExitTrigger_body is called when exiting the trigger_body production. + ExitTrigger_body(c *Trigger_bodyContext) + + // ExitRoutine_clause is called when exiting the routine_clause production. + ExitRoutine_clause(c *Routine_clauseContext) + + // ExitCompound_trigger_block is called when exiting the compound_trigger_block production. + ExitCompound_trigger_block(c *Compound_trigger_blockContext) + + // ExitTiming_point_section is called when exiting the timing_point_section production. + ExitTiming_point_section(c *Timing_point_sectionContext) + + // ExitNon_dml_event is called when exiting the non_dml_event production. + ExitNon_dml_event(c *Non_dml_eventContext) + + // ExitDml_event_clause is called when exiting the dml_event_clause production. + ExitDml_event_clause(c *Dml_event_clauseContext) + + // ExitDml_event_element is called when exiting the dml_event_element production. + ExitDml_event_element(c *Dml_event_elementContext) + + // ExitDml_event_nested_clause is called when exiting the dml_event_nested_clause production. + ExitDml_event_nested_clause(c *Dml_event_nested_clauseContext) + + // ExitReferencing_clause is called when exiting the referencing_clause production. + ExitReferencing_clause(c *Referencing_clauseContext) + + // ExitReferencing_element is called when exiting the referencing_element production. + ExitReferencing_element(c *Referencing_elementContext) + + // ExitDrop_type is called when exiting the drop_type production. + ExitDrop_type(c *Drop_typeContext) + + // ExitAlter_type is called when exiting the alter_type production. + ExitAlter_type(c *Alter_typeContext) + + // ExitCompile_type_clause is called when exiting the compile_type_clause production. + ExitCompile_type_clause(c *Compile_type_clauseContext) + + // ExitReplace_type_clause is called when exiting the replace_type_clause production. + ExitReplace_type_clause(c *Replace_type_clauseContext) + + // ExitAlter_method_spec is called when exiting the alter_method_spec production. + ExitAlter_method_spec(c *Alter_method_specContext) + + // ExitAlter_method_element is called when exiting the alter_method_element production. + ExitAlter_method_element(c *Alter_method_elementContext) + + // ExitAlter_attribute_definition is called when exiting the alter_attribute_definition production. + ExitAlter_attribute_definition(c *Alter_attribute_definitionContext) + + // ExitAttribute_definition is called when exiting the attribute_definition production. + ExitAttribute_definition(c *Attribute_definitionContext) + + // ExitAlter_collection_clauses is called when exiting the alter_collection_clauses production. + ExitAlter_collection_clauses(c *Alter_collection_clausesContext) + + // ExitDependent_handling_clause is called when exiting the dependent_handling_clause production. + ExitDependent_handling_clause(c *Dependent_handling_clauseContext) + + // ExitDependent_exceptions_part is called when exiting the dependent_exceptions_part production. + ExitDependent_exceptions_part(c *Dependent_exceptions_partContext) + + // ExitCreate_type is called when exiting the create_type production. + ExitCreate_type(c *Create_typeContext) + + // ExitType_definition is called when exiting the type_definition production. + ExitType_definition(c *Type_definitionContext) + + // ExitObject_type_def is called when exiting the object_type_def production. + ExitObject_type_def(c *Object_type_defContext) + + // ExitObject_as_part is called when exiting the object_as_part production. + ExitObject_as_part(c *Object_as_partContext) + + // ExitObject_under_part is called when exiting the object_under_part production. + ExitObject_under_part(c *Object_under_partContext) + + // ExitNested_table_type_def is called when exiting the nested_table_type_def production. + ExitNested_table_type_def(c *Nested_table_type_defContext) + + // ExitSqlj_object_type is called when exiting the sqlj_object_type production. + ExitSqlj_object_type(c *Sqlj_object_typeContext) + + // ExitType_body is called when exiting the type_body production. + ExitType_body(c *Type_bodyContext) + + // ExitType_body_elements is called when exiting the type_body_elements production. + ExitType_body_elements(c *Type_body_elementsContext) + + // ExitMap_order_func_declaration is called when exiting the map_order_func_declaration production. + ExitMap_order_func_declaration(c *Map_order_func_declarationContext) + + // ExitSubprog_decl_in_type is called when exiting the subprog_decl_in_type production. + ExitSubprog_decl_in_type(c *Subprog_decl_in_typeContext) + + // ExitProc_decl_in_type is called when exiting the proc_decl_in_type production. + ExitProc_decl_in_type(c *Proc_decl_in_typeContext) + + // ExitFunc_decl_in_type is called when exiting the func_decl_in_type production. + ExitFunc_decl_in_type(c *Func_decl_in_typeContext) + + // ExitConstructor_declaration is called when exiting the constructor_declaration production. + ExitConstructor_declaration(c *Constructor_declarationContext) + + // ExitModifier_clause is called when exiting the modifier_clause production. + ExitModifier_clause(c *Modifier_clauseContext) + + // ExitObject_member_spec is called when exiting the object_member_spec production. + ExitObject_member_spec(c *Object_member_specContext) + + // ExitSqlj_object_type_attr is called when exiting the sqlj_object_type_attr production. + ExitSqlj_object_type_attr(c *Sqlj_object_type_attrContext) + + // ExitElement_spec is called when exiting the element_spec production. + ExitElement_spec(c *Element_specContext) + + // ExitElement_spec_options is called when exiting the element_spec_options production. + ExitElement_spec_options(c *Element_spec_optionsContext) + + // ExitSubprogram_spec is called when exiting the subprogram_spec production. + ExitSubprogram_spec(c *Subprogram_specContext) + + // ExitOverriding_subprogram_spec is called when exiting the overriding_subprogram_spec production. + ExitOverriding_subprogram_spec(c *Overriding_subprogram_specContext) + + // ExitOverriding_function_spec is called when exiting the overriding_function_spec production. + ExitOverriding_function_spec(c *Overriding_function_specContext) + + // ExitType_procedure_spec is called when exiting the type_procedure_spec production. + ExitType_procedure_spec(c *Type_procedure_specContext) + + // ExitType_function_spec is called when exiting the type_function_spec production. + ExitType_function_spec(c *Type_function_specContext) + + // ExitConstructor_spec is called when exiting the constructor_spec production. + ExitConstructor_spec(c *Constructor_specContext) + + // ExitMap_order_function_spec is called when exiting the map_order_function_spec production. + ExitMap_order_function_spec(c *Map_order_function_specContext) + + // ExitPragma_clause is called when exiting the pragma_clause production. + ExitPragma_clause(c *Pragma_clauseContext) + + // ExitPragma_elements is called when exiting the pragma_elements production. + ExitPragma_elements(c *Pragma_elementsContext) + + // ExitType_elements_parameter is called when exiting the type_elements_parameter production. + ExitType_elements_parameter(c *Type_elements_parameterContext) + + // ExitDrop_sequence is called when exiting the drop_sequence production. + ExitDrop_sequence(c *Drop_sequenceContext) + + // 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_set_clause is called when exiting the alter_session_set_clause production. + ExitAlter_session_set_clause(c *Alter_session_set_clauseContext) + + // ExitCreate_sequence is called when exiting the create_sequence production. + ExitCreate_sequence(c *Create_sequenceContext) + + // ExitSequence_spec is called when exiting the sequence_spec production. + ExitSequence_spec(c *Sequence_specContext) + + // ExitSequence_start_clause is called when exiting the sequence_start_clause production. + ExitSequence_start_clause(c *Sequence_start_clauseContext) + + // ExitCreate_analytic_view is called when exiting the create_analytic_view production. + ExitCreate_analytic_view(c *Create_analytic_viewContext) + + // ExitClassification_clause is called when exiting the classification_clause production. + ExitClassification_clause(c *Classification_clauseContext) + + // ExitCaption_clause is called when exiting the caption_clause production. + ExitCaption_clause(c *Caption_clauseContext) + + // ExitDescription_clause is called when exiting the description_clause production. + ExitDescription_clause(c *Description_clauseContext) + + // ExitClassification_item is called when exiting the classification_item production. + ExitClassification_item(c *Classification_itemContext) + + // ExitLanguage is called when exiting the language production. + ExitLanguage(c *LanguageContext) + + // ExitCav_using_clause is called when exiting the cav_using_clause production. + ExitCav_using_clause(c *Cav_using_clauseContext) + + // ExitDim_by_clause is called when exiting the dim_by_clause production. + ExitDim_by_clause(c *Dim_by_clauseContext) + + // ExitDim_key is called when exiting the dim_key production. + ExitDim_key(c *Dim_keyContext) + + // ExitDim_ref is called when exiting the dim_ref production. + ExitDim_ref(c *Dim_refContext) + + // ExitHier_ref is called when exiting the hier_ref production. + ExitHier_ref(c *Hier_refContext) + + // ExitMeasures_clause is called when exiting the measures_clause production. + ExitMeasures_clause(c *Measures_clauseContext) + + // ExitAv_measure is called when exiting the av_measure production. + ExitAv_measure(c *Av_measureContext) + + // ExitBase_meas_clause is called when exiting the base_meas_clause production. + ExitBase_meas_clause(c *Base_meas_clauseContext) + + // ExitMeas_aggregate_clause is called when exiting the meas_aggregate_clause production. + ExitMeas_aggregate_clause(c *Meas_aggregate_clauseContext) + + // ExitCalc_meas_clause is called when exiting the calc_meas_clause production. + ExitCalc_meas_clause(c *Calc_meas_clauseContext) + + // ExitDefault_measure_clause is called when exiting the default_measure_clause production. + ExitDefault_measure_clause(c *Default_measure_clauseContext) + + // ExitDefault_aggregate_clause is called when exiting the default_aggregate_clause production. + ExitDefault_aggregate_clause(c *Default_aggregate_clauseContext) + + // ExitCache_clause is called when exiting the cache_clause production. + ExitCache_clause(c *Cache_clauseContext) + + // ExitCache_specification is called when exiting the cache_specification production. + ExitCache_specification(c *Cache_specificationContext) + + // ExitLevels_clause is called when exiting the levels_clause production. + ExitLevels_clause(c *Levels_clauseContext) + + // ExitLevel_specification is called when exiting the level_specification production. + ExitLevel_specification(c *Level_specificationContext) + + // ExitLevel_group_type is called when exiting the level_group_type production. + ExitLevel_group_type(c *Level_group_typeContext) + + // ExitFact_columns_clause is called when exiting the fact_columns_clause production. + ExitFact_columns_clause(c *Fact_columns_clauseContext) + + // ExitQry_transform_clause is called when exiting the qry_transform_clause production. + ExitQry_transform_clause(c *Qry_transform_clauseContext) + + // ExitCreate_attribute_dimension is called when exiting the create_attribute_dimension production. + ExitCreate_attribute_dimension(c *Create_attribute_dimensionContext) + + // ExitAd_using_clause is called when exiting the ad_using_clause production. + ExitAd_using_clause(c *Ad_using_clauseContext) + + // ExitSource_clause is called when exiting the source_clause production. + ExitSource_clause(c *Source_clauseContext) + + // ExitJoin_path_clause is called when exiting the join_path_clause production. + ExitJoin_path_clause(c *Join_path_clauseContext) + + // ExitJoin_condition is called when exiting the join_condition production. + ExitJoin_condition(c *Join_conditionContext) + + // ExitJoin_condition_item is called when exiting the join_condition_item production. + ExitJoin_condition_item(c *Join_condition_itemContext) + + // ExitAttributes_clause is called when exiting the attributes_clause production. + ExitAttributes_clause(c *Attributes_clauseContext) + + // ExitAd_attributes_clause is called when exiting the ad_attributes_clause production. + ExitAd_attributes_clause(c *Ad_attributes_clauseContext) + + // ExitAd_level_clause is called when exiting the ad_level_clause production. + ExitAd_level_clause(c *Ad_level_clauseContext) + + // ExitKey_clause is called when exiting the key_clause production. + ExitKey_clause(c *Key_clauseContext) + + // ExitAlternate_key_clause is called when exiting the alternate_key_clause production. + ExitAlternate_key_clause(c *Alternate_key_clauseContext) + + // ExitDim_order_clause is called when exiting the dim_order_clause production. + ExitDim_order_clause(c *Dim_order_clauseContext) + + // ExitAll_clause is called when exiting the all_clause production. + ExitAll_clause(c *All_clauseContext) + + // ExitCreate_audit_policy is called when exiting the create_audit_policy production. + ExitCreate_audit_policy(c *Create_audit_policyContext) + + // ExitPrivilege_audit_clause is called when exiting the privilege_audit_clause production. + ExitPrivilege_audit_clause(c *Privilege_audit_clauseContext) + + // ExitAction_audit_clause is called when exiting the action_audit_clause production. + ExitAction_audit_clause(c *Action_audit_clauseContext) + + // ExitStandard_actions is called when exiting the standard_actions production. + ExitStandard_actions(c *Standard_actionsContext) + + // ExitActions_clause is called when exiting the actions_clause production. + ExitActions_clause(c *Actions_clauseContext) + + // ExitObject_action is called when exiting the object_action production. + ExitObject_action(c *Object_actionContext) + + // ExitSystem_action is called when exiting the system_action production. + ExitSystem_action(c *System_actionContext) + + // ExitComponent_actions is called when exiting the component_actions production. + ExitComponent_actions(c *Component_actionsContext) + + // ExitComponent_action is called when exiting the component_action production. + ExitComponent_action(c *Component_actionContext) + + // ExitRole_audit_clause is called when exiting the role_audit_clause production. + ExitRole_audit_clause(c *Role_audit_clauseContext) + + // ExitCreate_controlfile is called when exiting the create_controlfile production. + ExitCreate_controlfile(c *Create_controlfileContext) + + // ExitControlfile_options is called when exiting the controlfile_options production. + ExitControlfile_options(c *Controlfile_optionsContext) + + // ExitLogfile_clause is called when exiting the logfile_clause production. + ExitLogfile_clause(c *Logfile_clauseContext) + + // ExitCharacter_set_clause is called when exiting the character_set_clause production. + ExitCharacter_set_clause(c *Character_set_clauseContext) + + // ExitFile_specification is called when exiting the file_specification production. + ExitFile_specification(c *File_specificationContext) + + // ExitCreate_diskgroup is called when exiting the create_diskgroup production. + ExitCreate_diskgroup(c *Create_diskgroupContext) + + // ExitQualified_disk_clause is called when exiting the qualified_disk_clause production. + ExitQualified_disk_clause(c *Qualified_disk_clauseContext) + + // ExitCreate_edition is called when exiting the create_edition production. + ExitCreate_edition(c *Create_editionContext) + + // ExitCreate_flashback_archive is called when exiting the create_flashback_archive production. + ExitCreate_flashback_archive(c *Create_flashback_archiveContext) + + // ExitFlashback_archive_quota is called when exiting the flashback_archive_quota production. + ExitFlashback_archive_quota(c *Flashback_archive_quotaContext) + + // ExitFlashback_archive_retention is called when exiting the flashback_archive_retention production. + ExitFlashback_archive_retention(c *Flashback_archive_retentionContext) + + // ExitCreate_hierarchy is called when exiting the create_hierarchy production. + ExitCreate_hierarchy(c *Create_hierarchyContext) + + // ExitHier_using_clause is called when exiting the hier_using_clause production. + ExitHier_using_clause(c *Hier_using_clauseContext) + + // ExitLevel_hier_clause is called when exiting the level_hier_clause production. + ExitLevel_hier_clause(c *Level_hier_clauseContext) + + // ExitHier_attrs_clause is called when exiting the hier_attrs_clause production. + ExitHier_attrs_clause(c *Hier_attrs_clauseContext) + + // ExitHier_attr_clause is called when exiting the hier_attr_clause production. + ExitHier_attr_clause(c *Hier_attr_clauseContext) + + // ExitHier_attr_name is called when exiting the hier_attr_name production. + ExitHier_attr_name(c *Hier_attr_nameContext) + + // ExitCreate_index is called when exiting the create_index production. + ExitCreate_index(c *Create_indexContext) + + // ExitCluster_index_clause is called when exiting the cluster_index_clause production. + ExitCluster_index_clause(c *Cluster_index_clauseContext) + + // ExitCluster_name is called when exiting the cluster_name production. + ExitCluster_name(c *Cluster_nameContext) + + // ExitTable_index_clause is called when exiting the table_index_clause production. + ExitTable_index_clause(c *Table_index_clauseContext) + + // ExitBitmap_join_index_clause is called when exiting the bitmap_join_index_clause production. + ExitBitmap_join_index_clause(c *Bitmap_join_index_clauseContext) + + // ExitIndex_expr_option is called when exiting the index_expr_option production. + ExitIndex_expr_option(c *Index_expr_optionContext) + + // ExitIndex_expr is called when exiting the index_expr production. + ExitIndex_expr(c *Index_exprContext) + + // ExitIndex_properties is called when exiting the index_properties production. + ExitIndex_properties(c *Index_propertiesContext) + + // ExitDomain_index_clause is called when exiting the domain_index_clause production. + ExitDomain_index_clause(c *Domain_index_clauseContext) + + // ExitLocal_domain_index_clause is called when exiting the local_domain_index_clause production. + ExitLocal_domain_index_clause(c *Local_domain_index_clauseContext) + + // ExitXmlindex_clause is called when exiting the xmlindex_clause production. + ExitXmlindex_clause(c *Xmlindex_clauseContext) + + // ExitLocal_xmlindex_clause is called when exiting the local_xmlindex_clause production. + ExitLocal_xmlindex_clause(c *Local_xmlindex_clauseContext) + + // ExitGlobal_partitioned_index is called when exiting the global_partitioned_index production. + ExitGlobal_partitioned_index(c *Global_partitioned_indexContext) + + // ExitIndex_partitioning_clause is called when exiting the index_partitioning_clause production. + ExitIndex_partitioning_clause(c *Index_partitioning_clauseContext) + + // ExitLocal_partitioned_index is called when exiting the local_partitioned_index production. + ExitLocal_partitioned_index(c *Local_partitioned_indexContext) + + // ExitOn_range_partitioned_table is called when exiting the on_range_partitioned_table production. + ExitOn_range_partitioned_table(c *On_range_partitioned_tableContext) + + // ExitOn_list_partitioned_table is called when exiting the on_list_partitioned_table production. + ExitOn_list_partitioned_table(c *On_list_partitioned_tableContext) + + // ExitPartitioned_table is called when exiting the partitioned_table production. + ExitPartitioned_table(c *Partitioned_tableContext) + + // ExitOn_hash_partitioned_table is called when exiting the on_hash_partitioned_table production. + ExitOn_hash_partitioned_table(c *On_hash_partitioned_tableContext) + + // ExitOn_hash_partitioned_clause is called when exiting the on_hash_partitioned_clause production. + ExitOn_hash_partitioned_clause(c *On_hash_partitioned_clauseContext) + + // ExitOn_comp_partitioned_table is called when exiting the on_comp_partitioned_table production. + ExitOn_comp_partitioned_table(c *On_comp_partitioned_tableContext) + + // ExitOn_comp_partitioned_clause is called when exiting the on_comp_partitioned_clause production. + ExitOn_comp_partitioned_clause(c *On_comp_partitioned_clauseContext) + + // ExitIndex_subpartition_clause is called when exiting the index_subpartition_clause production. + ExitIndex_subpartition_clause(c *Index_subpartition_clauseContext) + + // ExitIndex_subpartition_subclause is called when exiting the index_subpartition_subclause production. + ExitIndex_subpartition_subclause(c *Index_subpartition_subclauseContext) + + // ExitOdci_parameters is called when exiting the odci_parameters production. + ExitOdci_parameters(c *Odci_parametersContext) + + // ExitIndextype is called when exiting the indextype production. + ExitIndextype(c *IndextypeContext) + + // ExitAlter_index is called when exiting the alter_index production. + ExitAlter_index(c *Alter_indexContext) + + // ExitAlter_index_ops_set1 is called when exiting the alter_index_ops_set1 production. + ExitAlter_index_ops_set1(c *Alter_index_ops_set1Context) + + // ExitAlter_index_ops_set2 is called when exiting the alter_index_ops_set2 production. + ExitAlter_index_ops_set2(c *Alter_index_ops_set2Context) + + // ExitVisible_or_invisible is called when exiting the visible_or_invisible production. + ExitVisible_or_invisible(c *Visible_or_invisibleContext) + + // ExitMonitoring_nomonitoring is called when exiting the monitoring_nomonitoring production. + ExitMonitoring_nomonitoring(c *Monitoring_nomonitoringContext) + + // ExitRebuild_clause is called when exiting the rebuild_clause production. + ExitRebuild_clause(c *Rebuild_clauseContext) + + // ExitAlter_index_partitioning is called when exiting the alter_index_partitioning production. + ExitAlter_index_partitioning(c *Alter_index_partitioningContext) + + // ExitModify_index_default_attrs is called when exiting the modify_index_default_attrs production. + ExitModify_index_default_attrs(c *Modify_index_default_attrsContext) + + // ExitAdd_hash_index_partition is called when exiting the add_hash_index_partition production. + ExitAdd_hash_index_partition(c *Add_hash_index_partitionContext) + + // ExitCoalesce_index_partition is called when exiting the coalesce_index_partition production. + ExitCoalesce_index_partition(c *Coalesce_index_partitionContext) + + // ExitModify_index_partition is called when exiting the modify_index_partition production. + ExitModify_index_partition(c *Modify_index_partitionContext) + + // ExitModify_index_partitions_ops is called when exiting the modify_index_partitions_ops production. + ExitModify_index_partitions_ops(c *Modify_index_partitions_opsContext) + + // ExitRename_index_partition is called when exiting the rename_index_partition production. + ExitRename_index_partition(c *Rename_index_partitionContext) + + // ExitDrop_index_partition is called when exiting the drop_index_partition production. + ExitDrop_index_partition(c *Drop_index_partitionContext) + + // ExitSplit_index_partition is called when exiting the split_index_partition production. + ExitSplit_index_partition(c *Split_index_partitionContext) + + // ExitIndex_partition_description is called when exiting the index_partition_description production. + ExitIndex_partition_description(c *Index_partition_descriptionContext) + + // ExitModify_index_subpartition is called when exiting the modify_index_subpartition production. + ExitModify_index_subpartition(c *Modify_index_subpartitionContext) + + // ExitPartition_name_old is called when exiting the partition_name_old production. + ExitPartition_name_old(c *Partition_name_oldContext) + + // ExitNew_partition_name is called when exiting the new_partition_name production. + ExitNew_partition_name(c *New_partition_nameContext) + + // ExitNew_index_name is called when exiting the new_index_name production. + ExitNew_index_name(c *New_index_nameContext) + + // ExitAlter_inmemory_join_group is called when exiting the alter_inmemory_join_group production. + ExitAlter_inmemory_join_group(c *Alter_inmemory_join_groupContext) + + // ExitCreate_user is called when exiting the create_user production. + ExitCreate_user(c *Create_userContext) + + // ExitAlter_user is called when exiting the alter_user production. + ExitAlter_user(c *Alter_userContext) + + // ExitDrop_user is called when exiting the drop_user production. + ExitDrop_user(c *Drop_userContext) + + // ExitAlter_identified_by is called when exiting the alter_identified_by production. + ExitAlter_identified_by(c *Alter_identified_byContext) + + // ExitIdentified_by is called when exiting the identified_by production. + ExitIdentified_by(c *Identified_byContext) + + // ExitIdentified_other_clause is called when exiting the identified_other_clause production. + ExitIdentified_other_clause(c *Identified_other_clauseContext) + + // ExitUser_tablespace_clause is called when exiting the user_tablespace_clause production. + ExitUser_tablespace_clause(c *User_tablespace_clauseContext) + + // ExitQuota_clause is called when exiting the quota_clause production. + ExitQuota_clause(c *Quota_clauseContext) + + // ExitProfile_clause is called when exiting the profile_clause production. + ExitProfile_clause(c *Profile_clauseContext) + + // ExitRole_clause is called when exiting the role_clause production. + ExitRole_clause(c *Role_clauseContext) + + // ExitUser_default_role_clause is called when exiting the user_default_role_clause production. + ExitUser_default_role_clause(c *User_default_role_clauseContext) + + // ExitPassword_expire_clause is called when exiting the password_expire_clause production. + ExitPassword_expire_clause(c *Password_expire_clauseContext) + + // ExitUser_lock_clause is called when exiting the user_lock_clause production. + ExitUser_lock_clause(c *User_lock_clauseContext) + + // ExitUser_editions_clause is called when exiting the user_editions_clause production. + ExitUser_editions_clause(c *User_editions_clauseContext) + + // ExitAlter_user_editions_clause is called when exiting the alter_user_editions_clause production. + ExitAlter_user_editions_clause(c *Alter_user_editions_clauseContext) + + // ExitProxy_clause is called when exiting the proxy_clause production. + ExitProxy_clause(c *Proxy_clauseContext) + + // ExitContainer_names is called when exiting the container_names production. + ExitContainer_names(c *Container_namesContext) + + // ExitSet_container_data is called when exiting the set_container_data production. + ExitSet_container_data(c *Set_container_dataContext) + + // ExitAdd_rem_container_data is called when exiting the add_rem_container_data production. + ExitAdd_rem_container_data(c *Add_rem_container_dataContext) + + // ExitContainer_data_clause is called when exiting the container_data_clause production. + ExitContainer_data_clause(c *Container_data_clauseContext) + + // ExitAdminister_key_management is called when exiting the administer_key_management production. + ExitAdminister_key_management(c *Administer_key_managementContext) + + // ExitKeystore_management_clauses is called when exiting the keystore_management_clauses production. + ExitKeystore_management_clauses(c *Keystore_management_clausesContext) + + // ExitCreate_keystore is called when exiting the create_keystore production. + ExitCreate_keystore(c *Create_keystoreContext) + + // ExitOpen_keystore is called when exiting the open_keystore production. + ExitOpen_keystore(c *Open_keystoreContext) + + // ExitForce_keystore is called when exiting the force_keystore production. + ExitForce_keystore(c *Force_keystoreContext) + + // ExitClose_keystore is called when exiting the close_keystore production. + ExitClose_keystore(c *Close_keystoreContext) + + // ExitBackup_keystore is called when exiting the backup_keystore production. + ExitBackup_keystore(c *Backup_keystoreContext) + + // ExitAlter_keystore_password is called when exiting the alter_keystore_password production. + ExitAlter_keystore_password(c *Alter_keystore_passwordContext) + + // ExitMerge_into_new_keystore is called when exiting the merge_into_new_keystore production. + ExitMerge_into_new_keystore(c *Merge_into_new_keystoreContext) + + // ExitMerge_into_existing_keystore is called when exiting the merge_into_existing_keystore production. + ExitMerge_into_existing_keystore(c *Merge_into_existing_keystoreContext) + + // ExitIsolate_keystore is called when exiting the isolate_keystore production. + ExitIsolate_keystore(c *Isolate_keystoreContext) + + // ExitUnite_keystore is called when exiting the unite_keystore production. + ExitUnite_keystore(c *Unite_keystoreContext) + + // ExitKey_management_clauses is called when exiting the key_management_clauses production. + ExitKey_management_clauses(c *Key_management_clausesContext) + + // ExitSet_key is called when exiting the set_key production. + ExitSet_key(c *Set_keyContext) + + // ExitCreate_key is called when exiting the create_key production. + ExitCreate_key(c *Create_keyContext) + + // ExitMkid is called when exiting the mkid production. + ExitMkid(c *MkidContext) + + // ExitMk is called when exiting the mk production. + ExitMk(c *MkContext) + + // ExitUse_key is called when exiting the use_key production. + ExitUse_key(c *Use_keyContext) + + // ExitSet_key_tag is called when exiting the set_key_tag production. + ExitSet_key_tag(c *Set_key_tagContext) + + // ExitExport_keys is called when exiting the export_keys production. + ExitExport_keys(c *Export_keysContext) + + // ExitImport_keys is called when exiting the import_keys production. + ExitImport_keys(c *Import_keysContext) + + // ExitMigrate_keys is called when exiting the migrate_keys production. + ExitMigrate_keys(c *Migrate_keysContext) + + // ExitReverse_migrate_keys is called when exiting the reverse_migrate_keys production. + ExitReverse_migrate_keys(c *Reverse_migrate_keysContext) + + // ExitMove_keys is called when exiting the move_keys production. + ExitMove_keys(c *Move_keysContext) + + // ExitIdentified_by_store is called when exiting the identified_by_store production. + ExitIdentified_by_store(c *Identified_by_storeContext) + + // ExitUsing_algorithm_clause is called when exiting the using_algorithm_clause production. + ExitUsing_algorithm_clause(c *Using_algorithm_clauseContext) + + // ExitUsing_tag_clause is called when exiting the using_tag_clause production. + ExitUsing_tag_clause(c *Using_tag_clauseContext) + + // ExitSecret_management_clauses is called when exiting the secret_management_clauses production. + ExitSecret_management_clauses(c *Secret_management_clausesContext) + + // ExitAdd_update_secret is called when exiting the add_update_secret production. + ExitAdd_update_secret(c *Add_update_secretContext) + + // ExitDelete_secret is called when exiting the delete_secret production. + ExitDelete_secret(c *Delete_secretContext) + + // ExitAdd_update_secret_seps is called when exiting the add_update_secret_seps production. + ExitAdd_update_secret_seps(c *Add_update_secret_sepsContext) + + // ExitDelete_secret_seps is called when exiting the delete_secret_seps production. + ExitDelete_secret_seps(c *Delete_secret_sepsContext) + + // ExitZero_downtime_software_patching_clauses is called when exiting the zero_downtime_software_patching_clauses production. + ExitZero_downtime_software_patching_clauses(c *Zero_downtime_software_patching_clausesContext) + + // ExitWith_backup_clause is called when exiting the with_backup_clause production. + ExitWith_backup_clause(c *With_backup_clauseContext) + + // ExitIdentified_by_password_clause is called when exiting the identified_by_password_clause production. + ExitIdentified_by_password_clause(c *Identified_by_password_clauseContext) + + // ExitKeystore_password is called when exiting the keystore_password production. + ExitKeystore_password(c *Keystore_passwordContext) + + // ExitPath is called when exiting the path production. + ExitPath(c *PathContext) + + // ExitSecret is called when exiting the secret production. + ExitSecret(c *SecretContext) + + // ExitAnalyze is called when exiting the analyze production. + ExitAnalyze(c *AnalyzeContext) + + // ExitPartition_extention_clause is called when exiting the partition_extention_clause production. + ExitPartition_extention_clause(c *Partition_extention_clauseContext) + + // ExitValidation_clauses is called when exiting the validation_clauses production. + ExitValidation_clauses(c *Validation_clausesContext) + + // ExitCompute_clauses is called when exiting the compute_clauses production. + ExitCompute_clauses(c *Compute_clausesContext) + + // ExitFor_clause is called when exiting the for_clause production. + ExitFor_clause(c *For_clauseContext) + + // ExitOnline_or_offline is called when exiting the online_or_offline production. + ExitOnline_or_offline(c *Online_or_offlineContext) + + // ExitInto_clause1 is called when exiting the into_clause1 production. + ExitInto_clause1(c *Into_clause1Context) + + // ExitPartition_key_value is called when exiting the partition_key_value production. + ExitPartition_key_value(c *Partition_key_valueContext) + + // ExitSubpartition_key_value is called when exiting the subpartition_key_value production. + ExitSubpartition_key_value(c *Subpartition_key_valueContext) + + // ExitAssociate_statistics is called when exiting the associate_statistics production. + ExitAssociate_statistics(c *Associate_statisticsContext) + + // ExitColumn_association is called when exiting the column_association production. + ExitColumn_association(c *Column_associationContext) + + // ExitFunction_association is called when exiting the function_association production. + ExitFunction_association(c *Function_associationContext) + + // ExitIndextype_name is called when exiting the indextype_name production. + ExitIndextype_name(c *Indextype_nameContext) + + // ExitUsing_statistics_type is called when exiting the using_statistics_type production. + ExitUsing_statistics_type(c *Using_statistics_typeContext) + + // ExitStatistics_type_name is called when exiting the statistics_type_name production. + ExitStatistics_type_name(c *Statistics_type_nameContext) + + // ExitDefault_cost_clause is called when exiting the default_cost_clause production. + ExitDefault_cost_clause(c *Default_cost_clauseContext) + + // ExitCpu_cost is called when exiting the cpu_cost production. + ExitCpu_cost(c *Cpu_costContext) + + // ExitIo_cost is called when exiting the io_cost production. + ExitIo_cost(c *Io_costContext) + + // ExitNetwork_cost is called when exiting the network_cost production. + ExitNetwork_cost(c *Network_costContext) + + // ExitDefault_selectivity_clause is called when exiting the default_selectivity_clause production. + ExitDefault_selectivity_clause(c *Default_selectivity_clauseContext) + + // ExitDefault_selectivity is called when exiting the default_selectivity production. + ExitDefault_selectivity(c *Default_selectivityContext) + + // ExitStorage_table_clause is called when exiting the storage_table_clause production. + ExitStorage_table_clause(c *Storage_table_clauseContext) + + // ExitUnified_auditing is called when exiting the unified_auditing production. + ExitUnified_auditing(c *Unified_auditingContext) + + // ExitPolicy_name is called when exiting the policy_name production. + ExitPolicy_name(c *Policy_nameContext) + + // ExitAudit_traditional is called when exiting the audit_traditional production. + ExitAudit_traditional(c *Audit_traditionalContext) + + // ExitAudit_direct_path is called when exiting the audit_direct_path production. + ExitAudit_direct_path(c *Audit_direct_pathContext) + + // ExitAudit_container_clause is called when exiting the audit_container_clause production. + ExitAudit_container_clause(c *Audit_container_clauseContext) + + // ExitAudit_operation_clause is called when exiting the audit_operation_clause production. + ExitAudit_operation_clause(c *Audit_operation_clauseContext) + + // ExitAuditing_by_clause is called when exiting the auditing_by_clause production. + ExitAuditing_by_clause(c *Auditing_by_clauseContext) + + // ExitAudit_user is called when exiting the audit_user production. + ExitAudit_user(c *Audit_userContext) + + // ExitAudit_schema_object_clause is called when exiting the audit_schema_object_clause production. + ExitAudit_schema_object_clause(c *Audit_schema_object_clauseContext) + + // ExitSql_operation is called when exiting the sql_operation production. + ExitSql_operation(c *Sql_operationContext) + + // ExitAuditing_on_clause is called when exiting the auditing_on_clause production. + ExitAuditing_on_clause(c *Auditing_on_clauseContext) + + // ExitModel_name is called when exiting the model_name production. + ExitModel_name(c *Model_nameContext) + + // ExitObject_name is called when exiting the object_name production. + ExitObject_name(c *Object_nameContext) + + // ExitProfile_name is called when exiting the profile_name production. + ExitProfile_name(c *Profile_nameContext) + + // ExitSql_statement_shortcut is called when exiting the sql_statement_shortcut production. + ExitSql_statement_shortcut(c *Sql_statement_shortcutContext) + + // ExitDrop_index is called when exiting the drop_index production. + ExitDrop_index(c *Drop_indexContext) + + // ExitDisassociate_statistics is called when exiting the disassociate_statistics production. + ExitDisassociate_statistics(c *Disassociate_statisticsContext) + + // ExitDrop_indextype is called when exiting the drop_indextype production. + ExitDrop_indextype(c *Drop_indextypeContext) + + // ExitDrop_inmemory_join_group is called when exiting the drop_inmemory_join_group production. + ExitDrop_inmemory_join_group(c *Drop_inmemory_join_groupContext) + + // ExitFlashback_table is called when exiting the flashback_table production. + ExitFlashback_table(c *Flashback_tableContext) + + // ExitRestore_point is called when exiting the restore_point production. + ExitRestore_point(c *Restore_pointContext) + + // ExitPurge_statement is called when exiting the purge_statement production. + ExitPurge_statement(c *Purge_statementContext) + + // ExitNoaudit_statement is called when exiting the noaudit_statement production. + ExitNoaudit_statement(c *Noaudit_statementContext) + + // ExitRename_object is called when exiting the rename_object production. + ExitRename_object(c *Rename_objectContext) + + // ExitGrant_statement is called when exiting the grant_statement production. + ExitGrant_statement(c *Grant_statementContext) + + // ExitContainer_clause is called when exiting the container_clause production. + ExitContainer_clause(c *Container_clauseContext) + + // ExitRevoke_statement is called when exiting the revoke_statement production. + ExitRevoke_statement(c *Revoke_statementContext) + + // ExitRevoke_system_privilege is called when exiting the revoke_system_privilege production. + ExitRevoke_system_privilege(c *Revoke_system_privilegeContext) + + // ExitRevokee_clause is called when exiting the revokee_clause production. + ExitRevokee_clause(c *Revokee_clauseContext) + + // ExitRevoke_object_privileges is called when exiting the revoke_object_privileges production. + ExitRevoke_object_privileges(c *Revoke_object_privilegesContext) + + // ExitOn_object_clause is called when exiting the on_object_clause production. + ExitOn_object_clause(c *On_object_clauseContext) + + // ExitRevoke_roles_from_programs is called when exiting the revoke_roles_from_programs production. + ExitRevoke_roles_from_programs(c *Revoke_roles_from_programsContext) + + // ExitProgram_unit is called when exiting the program_unit production. + ExitProgram_unit(c *Program_unitContext) + + // ExitCreate_dimension is called when exiting the create_dimension production. + ExitCreate_dimension(c *Create_dimensionContext) + + // ExitCreate_directory is called when exiting the create_directory production. + ExitCreate_directory(c *Create_directoryContext) + + // ExitDirectory_name is called when exiting the directory_name production. + ExitDirectory_name(c *Directory_nameContext) + + // ExitDirectory_path is called when exiting the directory_path production. + ExitDirectory_path(c *Directory_pathContext) + + // ExitCreate_inmemory_join_group is called when exiting the create_inmemory_join_group production. + ExitCreate_inmemory_join_group(c *Create_inmemory_join_groupContext) + + // ExitDrop_hierarchy is called when exiting the drop_hierarchy production. + ExitDrop_hierarchy(c *Drop_hierarchyContext) + + // ExitAlter_library is called when exiting the alter_library production. + ExitAlter_library(c *Alter_libraryContext) + + // ExitDrop_java is called when exiting the drop_java production. + ExitDrop_java(c *Drop_javaContext) + + // ExitDrop_library is called when exiting the drop_library production. + ExitDrop_library(c *Drop_libraryContext) + + // ExitCreate_java is called when exiting the create_java production. + ExitCreate_java(c *Create_javaContext) + + // ExitCreate_library is called when exiting the create_library production. + ExitCreate_library(c *Create_libraryContext) + + // ExitPlsql_library_source is called when exiting the plsql_library_source production. + ExitPlsql_library_source(c *Plsql_library_sourceContext) + + // ExitCredential_name is called when exiting the credential_name production. + ExitCredential_name(c *Credential_nameContext) + + // ExitLibrary_editionable is called when exiting the library_editionable production. + ExitLibrary_editionable(c *Library_editionableContext) + + // ExitLibrary_debug is called when exiting the library_debug production. + ExitLibrary_debug(c *Library_debugContext) + + // ExitCompiler_parameters_clause is called when exiting the compiler_parameters_clause production. + ExitCompiler_parameters_clause(c *Compiler_parameters_clauseContext) + + // ExitParameter_value is called when exiting the parameter_value production. + ExitParameter_value(c *Parameter_valueContext) + + // ExitLibrary_name is called when exiting the library_name production. + ExitLibrary_name(c *Library_nameContext) + + // ExitAlter_dimension is called when exiting the alter_dimension production. + ExitAlter_dimension(c *Alter_dimensionContext) + + // ExitLevel_clause is called when exiting the level_clause production. + ExitLevel_clause(c *Level_clauseContext) + + // ExitHierarchy_clause is called when exiting the hierarchy_clause production. + ExitHierarchy_clause(c *Hierarchy_clauseContext) + + // ExitDimension_join_clause is called when exiting the dimension_join_clause production. + ExitDimension_join_clause(c *Dimension_join_clauseContext) + + // ExitAttribute_clause is called when exiting the attribute_clause production. + ExitAttribute_clause(c *Attribute_clauseContext) + + // ExitExtended_attribute_clause is called when exiting the extended_attribute_clause production. + ExitExtended_attribute_clause(c *Extended_attribute_clauseContext) + + // ExitColumn_one_or_more_sub_clause is called when exiting the column_one_or_more_sub_clause production. + ExitColumn_one_or_more_sub_clause(c *Column_one_or_more_sub_clauseContext) + + // ExitAlter_view is called when exiting the alter_view production. + ExitAlter_view(c *Alter_viewContext) + + // ExitAlter_view_editionable is called when exiting the alter_view_editionable production. + ExitAlter_view_editionable(c *Alter_view_editionableContext) + + // ExitCreate_view is called when exiting the create_view production. + ExitCreate_view(c *Create_viewContext) + + // ExitEditioning_clause is called when exiting the editioning_clause production. + ExitEditioning_clause(c *Editioning_clauseContext) + + // ExitView_options is called when exiting the view_options production. + ExitView_options(c *View_optionsContext) + + // ExitView_alias_constraint is called when exiting the view_alias_constraint production. + ExitView_alias_constraint(c *View_alias_constraintContext) + + // ExitObject_view_clause is called when exiting the object_view_clause production. + ExitObject_view_clause(c *Object_view_clauseContext) + + // ExitInline_constraint is called when exiting the inline_constraint production. + ExitInline_constraint(c *Inline_constraintContext) + + // ExitInline_ref_constraint is called when exiting the inline_ref_constraint production. + ExitInline_ref_constraint(c *Inline_ref_constraintContext) + + // ExitOut_of_line_ref_constraint is called when exiting the out_of_line_ref_constraint production. + ExitOut_of_line_ref_constraint(c *Out_of_line_ref_constraintContext) + + // ExitOut_of_line_constraint is called when exiting the out_of_line_constraint production. + ExitOut_of_line_constraint(c *Out_of_line_constraintContext) + + // ExitConstraint_state is called when exiting the constraint_state production. + ExitConstraint_state(c *Constraint_stateContext) + + // ExitXmltype_view_clause is called when exiting the xmltype_view_clause production. + ExitXmltype_view_clause(c *Xmltype_view_clauseContext) + + // ExitXml_schema_spec is called when exiting the xml_schema_spec production. + ExitXml_schema_spec(c *Xml_schema_specContext) + + // ExitXml_schema_url is called when exiting the xml_schema_url production. + ExitXml_schema_url(c *Xml_schema_urlContext) + + // ExitElement is called when exiting the element production. + ExitElement(c *ElementContext) + + // ExitAlter_tablespace is called when exiting the alter_tablespace production. + ExitAlter_tablespace(c *Alter_tablespaceContext) + + // ExitDatafile_tempfile_clauses is called when exiting the datafile_tempfile_clauses production. + ExitDatafile_tempfile_clauses(c *Datafile_tempfile_clausesContext) + + // ExitTablespace_logging_clauses is called when exiting the tablespace_logging_clauses production. + ExitTablespace_logging_clauses(c *Tablespace_logging_clausesContext) + + // ExitTablespace_group_clause is called when exiting the tablespace_group_clause production. + ExitTablespace_group_clause(c *Tablespace_group_clauseContext) + + // ExitTablespace_group_name is called when exiting the tablespace_group_name production. + ExitTablespace_group_name(c *Tablespace_group_nameContext) + + // ExitTablespace_state_clauses is called when exiting the tablespace_state_clauses production. + ExitTablespace_state_clauses(c *Tablespace_state_clausesContext) + + // ExitFlashback_mode_clause is called when exiting the flashback_mode_clause production. + ExitFlashback_mode_clause(c *Flashback_mode_clauseContext) + + // ExitNew_tablespace_name is called when exiting the new_tablespace_name production. + ExitNew_tablespace_name(c *New_tablespace_nameContext) + + // ExitCreate_tablespace is called when exiting the create_tablespace production. + ExitCreate_tablespace(c *Create_tablespaceContext) + + // ExitPermanent_tablespace_clause is called when exiting the permanent_tablespace_clause production. + ExitPermanent_tablespace_clause(c *Permanent_tablespace_clauseContext) + + // ExitTablespace_encryption_spec is called when exiting the tablespace_encryption_spec production. + ExitTablespace_encryption_spec(c *Tablespace_encryption_specContext) + + // ExitLogging_clause is called when exiting the logging_clause production. + ExitLogging_clause(c *Logging_clauseContext) + + // ExitExtent_management_clause is called when exiting the extent_management_clause production. + ExitExtent_management_clause(c *Extent_management_clauseContext) + + // ExitSegment_management_clause is called when exiting the segment_management_clause production. + ExitSegment_management_clause(c *Segment_management_clauseContext) + + // ExitTemporary_tablespace_clause is called when exiting the temporary_tablespace_clause production. + ExitTemporary_tablespace_clause(c *Temporary_tablespace_clauseContext) + + // ExitUndo_tablespace_clause is called when exiting the undo_tablespace_clause production. + ExitUndo_tablespace_clause(c *Undo_tablespace_clauseContext) + + // ExitTablespace_retention_clause is called when exiting the tablespace_retention_clause production. + ExitTablespace_retention_clause(c *Tablespace_retention_clauseContext) + + // ExitCreate_tablespace_set is called when exiting the create_tablespace_set production. + ExitCreate_tablespace_set(c *Create_tablespace_setContext) + + // ExitPermanent_tablespace_attrs is called when exiting the permanent_tablespace_attrs production. + ExitPermanent_tablespace_attrs(c *Permanent_tablespace_attrsContext) + + // ExitTablespace_encryption_clause is called when exiting the tablespace_encryption_clause production. + ExitTablespace_encryption_clause(c *Tablespace_encryption_clauseContext) + + // ExitDefault_tablespace_params is called when exiting the default_tablespace_params production. + ExitDefault_tablespace_params(c *Default_tablespace_paramsContext) + + // ExitDefault_table_compression is called when exiting the default_table_compression production. + ExitDefault_table_compression(c *Default_table_compressionContext) + + // ExitLow_high is called when exiting the low_high production. + ExitLow_high(c *Low_highContext) + + // ExitDefault_index_compression is called when exiting the default_index_compression production. + ExitDefault_index_compression(c *Default_index_compressionContext) + + // ExitInmmemory_clause is called when exiting the inmmemory_clause production. + ExitInmmemory_clause(c *Inmmemory_clauseContext) + + // ExitDatafile_specification is called when exiting the datafile_specification production. + ExitDatafile_specification(c *Datafile_specificationContext) + + // ExitTempfile_specification is called when exiting the tempfile_specification production. + ExitTempfile_specification(c *Tempfile_specificationContext) + + // ExitDatafile_tempfile_spec is called when exiting the datafile_tempfile_spec production. + ExitDatafile_tempfile_spec(c *Datafile_tempfile_specContext) + + // ExitRedo_log_file_spec is called when exiting the redo_log_file_spec production. + ExitRedo_log_file_spec(c *Redo_log_file_specContext) + + // ExitAutoextend_clause is called when exiting the autoextend_clause production. + ExitAutoextend_clause(c *Autoextend_clauseContext) + + // ExitMaxsize_clause is called when exiting the maxsize_clause production. + ExitMaxsize_clause(c *Maxsize_clauseContext) + + // ExitBuild_clause is called when exiting the build_clause production. + ExitBuild_clause(c *Build_clauseContext) + + // ExitPartial_index_clause is called when exiting the partial_index_clause production. + ExitPartial_index_clause(c *Partial_index_clauseContext) + + // ExitParallel_clause is called when exiting the parallel_clause production. + ExitParallel_clause(c *Parallel_clauseContext) + + // ExitAlter_materialized_view is called when exiting the alter_materialized_view production. + ExitAlter_materialized_view(c *Alter_materialized_viewContext) + + // ExitAlter_mv_option1 is called when exiting the alter_mv_option1 production. + ExitAlter_mv_option1(c *Alter_mv_option1Context) + + // ExitAlter_mv_refresh is called when exiting the alter_mv_refresh production. + ExitAlter_mv_refresh(c *Alter_mv_refreshContext) + + // ExitRollback_segment is called when exiting the rollback_segment production. + ExitRollback_segment(c *Rollback_segmentContext) + + // ExitModify_mv_column_clause is called when exiting the modify_mv_column_clause production. + ExitModify_mv_column_clause(c *Modify_mv_column_clauseContext) + + // ExitAlter_materialized_view_log is called when exiting the alter_materialized_view_log production. + ExitAlter_materialized_view_log(c *Alter_materialized_view_logContext) + + // ExitAdd_mv_log_column_clause is called when exiting the add_mv_log_column_clause production. + ExitAdd_mv_log_column_clause(c *Add_mv_log_column_clauseContext) + + // ExitMove_mv_log_clause is called when exiting the move_mv_log_clause production. + ExitMove_mv_log_clause(c *Move_mv_log_clauseContext) + + // ExitMv_log_augmentation is called when exiting the mv_log_augmentation production. + ExitMv_log_augmentation(c *Mv_log_augmentationContext) + + // ExitDatetime_expr is called when exiting the datetime_expr production. + ExitDatetime_expr(c *Datetime_exprContext) + + // ExitInterval_expr is called when exiting the interval_expr production. + ExitInterval_expr(c *Interval_exprContext) + + // ExitSynchronous_or_asynchronous is called when exiting the synchronous_or_asynchronous production. + ExitSynchronous_or_asynchronous(c *Synchronous_or_asynchronousContext) + + // ExitIncluding_or_excluding is called when exiting the including_or_excluding production. + ExitIncluding_or_excluding(c *Including_or_excludingContext) + + // ExitCreate_materialized_view_log is called when exiting the create_materialized_view_log production. + ExitCreate_materialized_view_log(c *Create_materialized_view_logContext) + + // ExitNew_values_clause is called when exiting the new_values_clause production. + ExitNew_values_clause(c *New_values_clauseContext) + + // ExitMv_log_purge_clause is called when exiting the mv_log_purge_clause production. + ExitMv_log_purge_clause(c *Mv_log_purge_clauseContext) + + // ExitCreate_materialized_zonemap is called when exiting the create_materialized_zonemap production. + ExitCreate_materialized_zonemap(c *Create_materialized_zonemapContext) + + // ExitAlter_materialized_zonemap is called when exiting the alter_materialized_zonemap production. + ExitAlter_materialized_zonemap(c *Alter_materialized_zonemapContext) + + // ExitDrop_materialized_zonemap is called when exiting the drop_materialized_zonemap production. + ExitDrop_materialized_zonemap(c *Drop_materialized_zonemapContext) + + // ExitZonemap_refresh_clause is called when exiting the zonemap_refresh_clause production. + ExitZonemap_refresh_clause(c *Zonemap_refresh_clauseContext) + + // ExitZonemap_attributes is called when exiting the zonemap_attributes production. + ExitZonemap_attributes(c *Zonemap_attributesContext) + + // ExitZonemap_name is called when exiting the zonemap_name production. + ExitZonemap_name(c *Zonemap_nameContext) + + // ExitOperator_name is called when exiting the operator_name production. + ExitOperator_name(c *Operator_nameContext) + + // ExitOperator_function_name is called when exiting the operator_function_name production. + ExitOperator_function_name(c *Operator_function_nameContext) + + // ExitCreate_zonemap_on_table is called when exiting the create_zonemap_on_table production. + ExitCreate_zonemap_on_table(c *Create_zonemap_on_tableContext) + + // ExitCreate_zonemap_as_subquery is called when exiting the create_zonemap_as_subquery production. + ExitCreate_zonemap_as_subquery(c *Create_zonemap_as_subqueryContext) + + // ExitAlter_operator is called when exiting the alter_operator production. + ExitAlter_operator(c *Alter_operatorContext) + + // ExitDrop_operator is called when exiting the drop_operator production. + ExitDrop_operator(c *Drop_operatorContext) + + // ExitCreate_operator is called when exiting the create_operator production. + ExitCreate_operator(c *Create_operatorContext) + + // ExitBinding_clause is called when exiting the binding_clause production. + ExitBinding_clause(c *Binding_clauseContext) + + // ExitAdd_binding_clause is called when exiting the add_binding_clause production. + ExitAdd_binding_clause(c *Add_binding_clauseContext) + + // ExitImplementation_clause is called when exiting the implementation_clause production. + ExitImplementation_clause(c *Implementation_clauseContext) + + // ExitPrimary_operator_list is called when exiting the primary_operator_list production. + ExitPrimary_operator_list(c *Primary_operator_listContext) + + // ExitPrimary_operator_item is called when exiting the primary_operator_item production. + ExitPrimary_operator_item(c *Primary_operator_itemContext) + + // ExitOperator_context_clause is called when exiting the operator_context_clause production. + ExitOperator_context_clause(c *Operator_context_clauseContext) + + // ExitUsing_function_clause is called when exiting the using_function_clause production. + ExitUsing_function_clause(c *Using_function_clauseContext) + + // ExitDrop_binding_clause is called when exiting the drop_binding_clause production. + ExitDrop_binding_clause(c *Drop_binding_clauseContext) + + // ExitCreate_materialized_view is called when exiting the create_materialized_view production. + ExitCreate_materialized_view(c *Create_materialized_viewContext) + + // ExitScoped_table_ref_constraint is called when exiting the scoped_table_ref_constraint production. + ExitScoped_table_ref_constraint(c *Scoped_table_ref_constraintContext) + + // ExitMv_column_alias is called when exiting the mv_column_alias production. + ExitMv_column_alias(c *Mv_column_aliasContext) + + // ExitCreate_mv_refresh is called when exiting the create_mv_refresh production. + ExitCreate_mv_refresh(c *Create_mv_refreshContext) + + // ExitDrop_materialized_view is called when exiting the drop_materialized_view production. + ExitDrop_materialized_view(c *Drop_materialized_viewContext) + + // ExitCreate_context is called when exiting the create_context production. + ExitCreate_context(c *Create_contextContext) + + // ExitOracle_namespace is called when exiting the oracle_namespace production. + ExitOracle_namespace(c *Oracle_namespaceContext) + + // ExitCreate_cluster is called when exiting the create_cluster production. + ExitCreate_cluster(c *Create_clusterContext) + + // ExitCreate_profile is called when exiting the create_profile production. + ExitCreate_profile(c *Create_profileContext) + + // ExitResource_parameters is called when exiting the resource_parameters production. + ExitResource_parameters(c *Resource_parametersContext) + + // ExitPassword_parameters is called when exiting the password_parameters production. + ExitPassword_parameters(c *Password_parametersContext) + + // ExitCreate_lockdown_profile is called when exiting the create_lockdown_profile production. + ExitCreate_lockdown_profile(c *Create_lockdown_profileContext) + + // ExitStatic_base_profile is called when exiting the static_base_profile production. + ExitStatic_base_profile(c *Static_base_profileContext) + + // ExitDynamic_base_profile is called when exiting the dynamic_base_profile production. + ExitDynamic_base_profile(c *Dynamic_base_profileContext) + + // ExitCreate_outline is called when exiting the create_outline production. + ExitCreate_outline(c *Create_outlineContext) + + // ExitCreate_restore_point is called when exiting the create_restore_point production. + ExitCreate_restore_point(c *Create_restore_pointContext) + + // ExitCreate_role is called when exiting the create_role production. + ExitCreate_role(c *Create_roleContext) + + // ExitCreate_table is called when exiting the create_table production. + ExitCreate_table(c *Create_tableContext) + + // ExitXmltype_table is called when exiting the xmltype_table production. + ExitXmltype_table(c *Xmltype_tableContext) + + // ExitXmltype_virtual_columns is called when exiting the xmltype_virtual_columns production. + ExitXmltype_virtual_columns(c *Xmltype_virtual_columnsContext) + + // ExitXmltype_column_properties is called when exiting the xmltype_column_properties production. + ExitXmltype_column_properties(c *Xmltype_column_propertiesContext) + + // ExitXmltype_storage is called when exiting the xmltype_storage production. + ExitXmltype_storage(c *Xmltype_storageContext) + + // ExitXmlschema_spec is called when exiting the xmlschema_spec production. + ExitXmlschema_spec(c *Xmlschema_specContext) + + // ExitObject_table is called when exiting the object_table production. + ExitObject_table(c *Object_tableContext) + + // ExitObject_type is called when exiting the object_type production. + ExitObject_type(c *Object_typeContext) + + // ExitOid_index_clause is called when exiting the oid_index_clause production. + ExitOid_index_clause(c *Oid_index_clauseContext) + + // ExitOid_clause is called when exiting the oid_clause production. + ExitOid_clause(c *Oid_clauseContext) + + // ExitObject_properties is called when exiting the object_properties production. + ExitObject_properties(c *Object_propertiesContext) + + // ExitObject_table_substitution is called when exiting the object_table_substitution production. + ExitObject_table_substitution(c *Object_table_substitutionContext) + + // ExitRelational_table is called when exiting the relational_table production. + ExitRelational_table(c *Relational_tableContext) + + // ExitImmutable_table_clauses is called when exiting the immutable_table_clauses production. + ExitImmutable_table_clauses(c *Immutable_table_clausesContext) + + // ExitImmutable_table_no_drop_clause is called when exiting the immutable_table_no_drop_clause production. + ExitImmutable_table_no_drop_clause(c *Immutable_table_no_drop_clauseContext) + + // ExitImmutable_table_no_delete_clause is called when exiting the immutable_table_no_delete_clause production. + ExitImmutable_table_no_delete_clause(c *Immutable_table_no_delete_clauseContext) + + // ExitBlockchain_table_clauses is called when exiting the blockchain_table_clauses production. + ExitBlockchain_table_clauses(c *Blockchain_table_clausesContext) + + // ExitBlockchain_drop_table_clause is called when exiting the blockchain_drop_table_clause production. + ExitBlockchain_drop_table_clause(c *Blockchain_drop_table_clauseContext) + + // ExitBlockchain_row_retention_clause is called when exiting the blockchain_row_retention_clause production. + ExitBlockchain_row_retention_clause(c *Blockchain_row_retention_clauseContext) + + // ExitBlockchain_hash_and_data_format_clause is called when exiting the blockchain_hash_and_data_format_clause production. + ExitBlockchain_hash_and_data_format_clause(c *Blockchain_hash_and_data_format_clauseContext) + + // ExitCollation_name is called when exiting the collation_name production. + ExitCollation_name(c *Collation_nameContext) + + // ExitTable_properties is called when exiting the table_properties production. + ExitTable_properties(c *Table_propertiesContext) + + // ExitRead_only_clause is called when exiting the read_only_clause production. + ExitRead_only_clause(c *Read_only_clauseContext) + + // ExitIndexing_clause is called when exiting the indexing_clause production. + ExitIndexing_clause(c *Indexing_clauseContext) + + // ExitAttribute_clustering_clause is called when exiting the attribute_clustering_clause production. + ExitAttribute_clustering_clause(c *Attribute_clustering_clauseContext) + + // ExitClustering_join is called when exiting the clustering_join production. + ExitClustering_join(c *Clustering_joinContext) + + // ExitClustering_join_item is called when exiting the clustering_join_item production. + ExitClustering_join_item(c *Clustering_join_itemContext) + + // ExitEquijoin_condition is called when exiting the equijoin_condition production. + ExitEquijoin_condition(c *Equijoin_conditionContext) + + // ExitCluster_clause is called when exiting the cluster_clause production. + ExitCluster_clause(c *Cluster_clauseContext) + + // ExitClustering_columns is called when exiting the clustering_columns production. + ExitClustering_columns(c *Clustering_columnsContext) + + // ExitClustering_column_group is called when exiting the clustering_column_group production. + ExitClustering_column_group(c *Clustering_column_groupContext) + + // ExitYes_no is called when exiting the yes_no production. + ExitYes_no(c *Yes_noContext) + + // ExitZonemap_clause is called when exiting the zonemap_clause production. + ExitZonemap_clause(c *Zonemap_clauseContext) + + // ExitLogical_replication_clause is called when exiting the logical_replication_clause production. + ExitLogical_replication_clause(c *Logical_replication_clauseContext) + + // ExitTable_name is called when exiting the table_name production. + ExitTable_name(c *Table_nameContext) + + // ExitRelational_property is called when exiting the relational_property production. + ExitRelational_property(c *Relational_propertyContext) + + // ExitTable_partitioning_clauses is called when exiting the table_partitioning_clauses production. + ExitTable_partitioning_clauses(c *Table_partitioning_clausesContext) + + // ExitRange_partitions is called when exiting the range_partitions production. + ExitRange_partitions(c *Range_partitionsContext) + + // ExitList_partitions is called when exiting the list_partitions production. + ExitList_partitions(c *List_partitionsContext) + + // ExitHash_partitions is called when exiting the hash_partitions production. + ExitHash_partitions(c *Hash_partitionsContext) + + // ExitIndividual_hash_partitions is called when exiting the individual_hash_partitions production. + ExitIndividual_hash_partitions(c *Individual_hash_partitionsContext) + + // ExitHash_partitions_by_quantity is called when exiting the hash_partitions_by_quantity production. + ExitHash_partitions_by_quantity(c *Hash_partitions_by_quantityContext) + + // ExitHash_partition_quantity is called when exiting the hash_partition_quantity production. + ExitHash_partition_quantity(c *Hash_partition_quantityContext) + + // ExitComposite_range_partitions is called when exiting the composite_range_partitions production. + ExitComposite_range_partitions(c *Composite_range_partitionsContext) + + // ExitComposite_list_partitions is called when exiting the composite_list_partitions production. + ExitComposite_list_partitions(c *Composite_list_partitionsContext) + + // ExitComposite_hash_partitions is called when exiting the composite_hash_partitions production. + ExitComposite_hash_partitions(c *Composite_hash_partitionsContext) + + // ExitReference_partitioning is called when exiting the reference_partitioning production. + ExitReference_partitioning(c *Reference_partitioningContext) + + // ExitReference_partition_desc is called when exiting the reference_partition_desc production. + ExitReference_partition_desc(c *Reference_partition_descContext) + + // ExitSystem_partitioning is called when exiting the system_partitioning production. + ExitSystem_partitioning(c *System_partitioningContext) + + // ExitRange_partition_desc is called when exiting the range_partition_desc production. + ExitRange_partition_desc(c *Range_partition_descContext) + + // ExitList_partition_desc is called when exiting the list_partition_desc production. + ExitList_partition_desc(c *List_partition_descContext) + + // ExitSubpartition_template is called when exiting the subpartition_template production. + ExitSubpartition_template(c *Subpartition_templateContext) + + // ExitHash_subpartition_quantity is called when exiting the hash_subpartition_quantity production. + ExitHash_subpartition_quantity(c *Hash_subpartition_quantityContext) + + // ExitSubpartition_by_range is called when exiting the subpartition_by_range production. + ExitSubpartition_by_range(c *Subpartition_by_rangeContext) + + // ExitSubpartition_by_list is called when exiting the subpartition_by_list production. + ExitSubpartition_by_list(c *Subpartition_by_listContext) + + // ExitSubpartition_by_hash is called when exiting the subpartition_by_hash production. + ExitSubpartition_by_hash(c *Subpartition_by_hashContext) + + // ExitSubpartition_name is called when exiting the subpartition_name production. + ExitSubpartition_name(c *Subpartition_nameContext) + + // ExitRange_subpartition_desc is called when exiting the range_subpartition_desc production. + ExitRange_subpartition_desc(c *Range_subpartition_descContext) + + // ExitList_subpartition_desc is called when exiting the list_subpartition_desc production. + ExitList_subpartition_desc(c *List_subpartition_descContext) + + // ExitIndividual_hash_subparts is called when exiting the individual_hash_subparts production. + ExitIndividual_hash_subparts(c *Individual_hash_subpartsContext) + + // ExitHash_subparts_by_quantity is called when exiting the hash_subparts_by_quantity production. + ExitHash_subparts_by_quantity(c *Hash_subparts_by_quantityContext) + + // ExitRange_values_clause is called when exiting the range_values_clause production. + ExitRange_values_clause(c *Range_values_clauseContext) + + // ExitList_values_clause is called when exiting the list_values_clause production. + ExitList_values_clause(c *List_values_clauseContext) + + // ExitTable_partition_description is called when exiting the table_partition_description production. + ExitTable_partition_description(c *Table_partition_descriptionContext) + + // ExitPartitioning_storage_clause is called when exiting the partitioning_storage_clause production. + ExitPartitioning_storage_clause(c *Partitioning_storage_clauseContext) + + // ExitLob_partitioning_storage is called when exiting the lob_partitioning_storage production. + ExitLob_partitioning_storage(c *Lob_partitioning_storageContext) + + // ExitDatatype_null_enable is called when exiting the datatype_null_enable production. + ExitDatatype_null_enable(c *Datatype_null_enableContext) + + // ExitSize_clause is called when exiting the size_clause production. + ExitSize_clause(c *Size_clauseContext) + + // ExitTable_compression is called when exiting the table_compression production. + ExitTable_compression(c *Table_compressionContext) + + // ExitInmemory_table_clause is called when exiting the inmemory_table_clause production. + ExitInmemory_table_clause(c *Inmemory_table_clauseContext) + + // ExitInmemory_attributes is called when exiting the inmemory_attributes production. + ExitInmemory_attributes(c *Inmemory_attributesContext) + + // ExitInmemory_memcompress is called when exiting the inmemory_memcompress production. + ExitInmemory_memcompress(c *Inmemory_memcompressContext) + + // ExitInmemory_priority is called when exiting the inmemory_priority production. + ExitInmemory_priority(c *Inmemory_priorityContext) + + // ExitInmemory_distribute is called when exiting the inmemory_distribute production. + ExitInmemory_distribute(c *Inmemory_distributeContext) + + // ExitInmemory_duplicate is called when exiting the inmemory_duplicate production. + ExitInmemory_duplicate(c *Inmemory_duplicateContext) + + // ExitInmemory_column_clause is called when exiting the inmemory_column_clause production. + ExitInmemory_column_clause(c *Inmemory_column_clauseContext) + + // ExitPhysical_attributes_clause is called when exiting the physical_attributes_clause production. + ExitPhysical_attributes_clause(c *Physical_attributes_clauseContext) + + // ExitStorage_clause is called when exiting the storage_clause production. + ExitStorage_clause(c *Storage_clauseContext) + + // ExitDeferred_segment_creation is called when exiting the deferred_segment_creation production. + ExitDeferred_segment_creation(c *Deferred_segment_creationContext) + + // ExitSegment_attributes_clause is called when exiting the segment_attributes_clause production. + ExitSegment_attributes_clause(c *Segment_attributes_clauseContext) + + // ExitPhysical_properties is called when exiting the physical_properties production. + ExitPhysical_properties(c *Physical_propertiesContext) + + // ExitIlm_clause is called when exiting the ilm_clause production. + ExitIlm_clause(c *Ilm_clauseContext) + + // ExitIlm_policy_clause is called when exiting the ilm_policy_clause production. + ExitIlm_policy_clause(c *Ilm_policy_clauseContext) + + // ExitIlm_compression_policy is called when exiting the ilm_compression_policy production. + ExitIlm_compression_policy(c *Ilm_compression_policyContext) + + // ExitIlm_tiering_policy is called when exiting the ilm_tiering_policy production. + ExitIlm_tiering_policy(c *Ilm_tiering_policyContext) + + // ExitIlm_after_on is called when exiting the ilm_after_on production. + ExitIlm_after_on(c *Ilm_after_onContext) + + // ExitSegment_group is called when exiting the segment_group production. + ExitSegment_group(c *Segment_groupContext) + + // ExitIlm_inmemory_policy is called when exiting the ilm_inmemory_policy production. + ExitIlm_inmemory_policy(c *Ilm_inmemory_policyContext) + + // ExitIlm_time_period is called when exiting the ilm_time_period production. + ExitIlm_time_period(c *Ilm_time_periodContext) + + // ExitHeap_org_table_clause is called when exiting the heap_org_table_clause production. + ExitHeap_org_table_clause(c *Heap_org_table_clauseContext) + + // ExitExternal_table_clause is called when exiting the external_table_clause production. + ExitExternal_table_clause(c *External_table_clauseContext) + + // ExitAccess_driver_type is called when exiting the access_driver_type production. + ExitAccess_driver_type(c *Access_driver_typeContext) + + // ExitExternal_table_data_props is called when exiting the external_table_data_props production. + ExitExternal_table_data_props(c *External_table_data_propsContext) + + // ExitOpaque_format_spec is called when exiting the opaque_format_spec production. + ExitOpaque_format_spec(c *Opaque_format_specContext) + + // ExitRecord_format_info is called when exiting the record_format_info production. + ExitRecord_format_info(c *Record_format_infoContext) + + // ExitEt_string is called when exiting the et_string production. + ExitEt_string(c *Et_stringContext) + + // ExitEt_record_spec_options is called when exiting the et_record_spec_options production. + ExitEt_record_spec_options(c *Et_record_spec_optionsContext) + + // ExitEt_record_spec_option is called when exiting the et_record_spec_option production. + ExitEt_record_spec_option(c *Et_record_spec_optionContext) + + // ExitEt_output_files is called when exiting the et_output_files production. + ExitEt_output_files(c *Et_output_filesContext) + + // ExitEt_output_file is called when exiting the et_output_file production. + ExitEt_output_file(c *Et_output_fileContext) + + // ExitDirectory_spec is called when exiting the directory_spec production. + ExitDirectory_spec(c *Directory_specContext) + + // ExitFile_spec is called when exiting the file_spec production. + ExitFile_spec(c *File_specContext) + + // ExitField_definitions is called when exiting the field_definitions production. + ExitField_definitions(c *Field_definitionsContext) + + // ExitField_options is called when exiting the field_options production. + ExitField_options(c *Field_optionsContext) + + // ExitField_option is called when exiting the field_option production. + ExitField_option(c *Field_optionContext) + + // ExitField_list is called when exiting the field_list production. + ExitField_list(c *Field_listContext) + + // ExitField_item is called when exiting the field_item production. + ExitField_item(c *Field_itemContext) + + // ExitField_name is called when exiting the field_name production. + ExitField_name(c *Field_nameContext) + + // ExitPos_spec is called when exiting the pos_spec production. + ExitPos_spec(c *Pos_specContext) + + // ExitPos_start is called when exiting the pos_start production. + ExitPos_start(c *Pos_startContext) + + // ExitPos_increment is called when exiting the pos_increment production. + ExitPos_increment(c *Pos_incrementContext) + + // ExitPos_end is called when exiting the pos_end production. + ExitPos_end(c *Pos_endContext) + + // ExitPos_length is called when exiting the pos_length production. + ExitPos_length(c *Pos_lengthContext) + + // ExitDatatype_spec is called when exiting the datatype_spec production. + ExitDatatype_spec(c *Datatype_specContext) + + // ExitInit_spec is called when exiting the init_spec production. + ExitInit_spec(c *Init_specContext) + + // ExitLls_clause is called when exiting the lls_clause production. + ExitLls_clause(c *Lls_clauseContext) + + // ExitDelim_spec is called when exiting the delim_spec production. + ExitDelim_spec(c *Delim_specContext) + + // ExitTrim_spec is called when exiting the trim_spec production. + ExitTrim_spec(c *Trim_specContext) + + // ExitField_date_format is called when exiting the field_date_format production. + ExitField_date_format(c *Field_date_formatContext) + + // ExitColumn_transforms is called when exiting the column_transforms production. + ExitColumn_transforms(c *Column_transformsContext) + + // ExitTransform is called when exiting the transform production. + ExitTransform(c *TransformContext) + + // ExitSource_field is called when exiting the source_field production. + ExitSource_field(c *Source_fieldContext) + + // ExitLobfile_item is called when exiting the lobfile_item production. + ExitLobfile_item(c *Lobfile_itemContext) + + // ExitLobfile_attr_list is called when exiting the lobfile_attr_list production. + ExitLobfile_attr_list(c *Lobfile_attr_listContext) + + // ExitConcat_item is called when exiting the concat_item production. + ExitConcat_item(c *Concat_itemContext) + + // ExitRow_movement_clause is called when exiting the row_movement_clause production. + ExitRow_movement_clause(c *Row_movement_clauseContext) + + // ExitFlashback_archive_clause is called when exiting the flashback_archive_clause production. + ExitFlashback_archive_clause(c *Flashback_archive_clauseContext) + + // ExitLog_grp is called when exiting the log_grp production. + ExitLog_grp(c *Log_grpContext) + + // ExitSupplemental_table_logging is called when exiting the supplemental_table_logging production. + ExitSupplemental_table_logging(c *Supplemental_table_loggingContext) + + // ExitSupplemental_log_grp_clause is called when exiting the supplemental_log_grp_clause production. + ExitSupplemental_log_grp_clause(c *Supplemental_log_grp_clauseContext) + + // ExitSupplemental_id_key_clause is called when exiting the supplemental_id_key_clause production. + ExitSupplemental_id_key_clause(c *Supplemental_id_key_clauseContext) + + // ExitAllocate_extent_clause is called when exiting the allocate_extent_clause production. + ExitAllocate_extent_clause(c *Allocate_extent_clauseContext) + + // ExitDeallocate_unused_clause is called when exiting the deallocate_unused_clause production. + ExitDeallocate_unused_clause(c *Deallocate_unused_clauseContext) + + // ExitShrink_clause is called when exiting the shrink_clause production. + ExitShrink_clause(c *Shrink_clauseContext) + + // ExitRecords_per_block_clause is called when exiting the records_per_block_clause production. + ExitRecords_per_block_clause(c *Records_per_block_clauseContext) + + // ExitUpgrade_table_clause is called when exiting the upgrade_table_clause production. + ExitUpgrade_table_clause(c *Upgrade_table_clauseContext) + + // ExitTruncate_table is called when exiting the truncate_table production. + ExitTruncate_table(c *Truncate_tableContext) + + // ExitDrop_table is called when exiting the drop_table production. + ExitDrop_table(c *Drop_tableContext) + + // ExitDrop_tablespace is called when exiting the drop_tablespace production. + ExitDrop_tablespace(c *Drop_tablespaceContext) + + // ExitDrop_tablespace_set is called when exiting the drop_tablespace_set production. + ExitDrop_tablespace_set(c *Drop_tablespace_setContext) + + // ExitIncluding_contents_clause is called when exiting the including_contents_clause production. + ExitIncluding_contents_clause(c *Including_contents_clauseContext) + + // ExitDrop_view is called when exiting the drop_view production. + ExitDrop_view(c *Drop_viewContext) + + // ExitComment_on_column is called when exiting the comment_on_column production. + ExitComment_on_column(c *Comment_on_columnContext) + + // ExitEnable_or_disable is called when exiting the enable_or_disable production. + ExitEnable_or_disable(c *Enable_or_disableContext) + + // ExitAllow_or_disallow is called when exiting the allow_or_disallow production. + ExitAllow_or_disallow(c *Allow_or_disallowContext) + + // ExitAlter_synonym is called when exiting the alter_synonym production. + ExitAlter_synonym(c *Alter_synonymContext) + + // ExitCreate_synonym is called when exiting the create_synonym production. + ExitCreate_synonym(c *Create_synonymContext) + + // ExitDrop_synonym is called when exiting the drop_synonym production. + ExitDrop_synonym(c *Drop_synonymContext) + + // ExitCreate_spfile is called when exiting the create_spfile production. + ExitCreate_spfile(c *Create_spfileContext) + + // ExitSpfile_name is called when exiting the spfile_name production. + ExitSpfile_name(c *Spfile_nameContext) + + // ExitPfile_name is called when exiting the pfile_name production. + ExitPfile_name(c *Pfile_nameContext) + + // ExitComment_on_table is called when exiting the comment_on_table production. + ExitComment_on_table(c *Comment_on_tableContext) + + // ExitComment_on_materialized is called when exiting the comment_on_materialized production. + ExitComment_on_materialized(c *Comment_on_materializedContext) + + // ExitAlter_analytic_view is called when exiting the alter_analytic_view production. + ExitAlter_analytic_view(c *Alter_analytic_viewContext) + + // ExitAlter_add_cache_clause is called when exiting the alter_add_cache_clause production. + ExitAlter_add_cache_clause(c *Alter_add_cache_clauseContext) + + // ExitLevels_item is called when exiting the levels_item production. + ExitLevels_item(c *Levels_itemContext) + + // ExitMeasure_list is called when exiting the measure_list production. + ExitMeasure_list(c *Measure_listContext) + + // ExitAlter_drop_cache_clause is called when exiting the alter_drop_cache_clause production. + ExitAlter_drop_cache_clause(c *Alter_drop_cache_clauseContext) + + // ExitAlter_attribute_dimension is called when exiting the alter_attribute_dimension production. + ExitAlter_attribute_dimension(c *Alter_attribute_dimensionContext) + + // ExitAlter_audit_policy is called when exiting the alter_audit_policy production. + ExitAlter_audit_policy(c *Alter_audit_policyContext) + + // ExitAlter_cluster is called when exiting the alter_cluster production. + ExitAlter_cluster(c *Alter_clusterContext) + + // ExitDrop_analytic_view is called when exiting the drop_analytic_view production. + ExitDrop_analytic_view(c *Drop_analytic_viewContext) + + // ExitDrop_attribute_dimension is called when exiting the drop_attribute_dimension production. + ExitDrop_attribute_dimension(c *Drop_attribute_dimensionContext) + + // ExitDrop_audit_policy is called when exiting the drop_audit_policy production. + ExitDrop_audit_policy(c *Drop_audit_policyContext) + + // ExitDrop_flashback_archive is called when exiting the drop_flashback_archive production. + ExitDrop_flashback_archive(c *Drop_flashback_archiveContext) + + // ExitDrop_cluster is called when exiting the drop_cluster production. + ExitDrop_cluster(c *Drop_clusterContext) + + // ExitDrop_context is called when exiting the drop_context production. + ExitDrop_context(c *Drop_contextContext) + + // ExitDrop_directory is called when exiting the drop_directory production. + ExitDrop_directory(c *Drop_directoryContext) + + // ExitDrop_diskgroup is called when exiting the drop_diskgroup production. + ExitDrop_diskgroup(c *Drop_diskgroupContext) + + // ExitDrop_edition is called when exiting the drop_edition production. + ExitDrop_edition(c *Drop_editionContext) + + // ExitTruncate_cluster is called when exiting the truncate_cluster production. + ExitTruncate_cluster(c *Truncate_clusterContext) + + // ExitCache_or_nocache is called when exiting the cache_or_nocache production. + ExitCache_or_nocache(c *Cache_or_nocacheContext) + + // ExitDatabase_name is called when exiting the database_name production. + ExitDatabase_name(c *Database_nameContext) + + // ExitAlter_database is called when exiting the alter_database production. + ExitAlter_database(c *Alter_databaseContext) + + // ExitDatabase_clause is called when exiting the database_clause production. + ExitDatabase_clause(c *Database_clauseContext) + + // ExitStartup_clauses is called when exiting the startup_clauses production. + ExitStartup_clauses(c *Startup_clausesContext) + + // ExitResetlogs_or_noresetlogs is called when exiting the resetlogs_or_noresetlogs production. + ExitResetlogs_or_noresetlogs(c *Resetlogs_or_noresetlogsContext) + + // ExitUpgrade_or_downgrade is called when exiting the upgrade_or_downgrade production. + ExitUpgrade_or_downgrade(c *Upgrade_or_downgradeContext) + + // ExitRecovery_clauses is called when exiting the recovery_clauses production. + ExitRecovery_clauses(c *Recovery_clausesContext) + + // ExitBegin_or_end is called when exiting the begin_or_end production. + ExitBegin_or_end(c *Begin_or_endContext) + + // ExitGeneral_recovery is called when exiting the general_recovery production. + ExitGeneral_recovery(c *General_recoveryContext) + + // ExitFull_database_recovery is called when exiting the full_database_recovery production. + ExitFull_database_recovery(c *Full_database_recoveryContext) + + // ExitPartial_database_recovery is called when exiting the partial_database_recovery production. + ExitPartial_database_recovery(c *Partial_database_recoveryContext) + + // ExitPartial_database_recovery_10g is called when exiting the partial_database_recovery_10g production. + ExitPartial_database_recovery_10g(c *Partial_database_recovery_10gContext) + + // ExitManaged_standby_recovery is called when exiting the managed_standby_recovery production. + ExitManaged_standby_recovery(c *Managed_standby_recoveryContext) + + // ExitDb_name is called when exiting the db_name production. + ExitDb_name(c *Db_nameContext) + + // ExitDatabase_file_clauses is called when exiting the database_file_clauses production. + ExitDatabase_file_clauses(c *Database_file_clausesContext) + + // ExitCreate_datafile_clause is called when exiting the create_datafile_clause production. + ExitCreate_datafile_clause(c *Create_datafile_clauseContext) + + // ExitAlter_datafile_clause is called when exiting the alter_datafile_clause production. + ExitAlter_datafile_clause(c *Alter_datafile_clauseContext) + + // ExitAlter_tempfile_clause is called when exiting the alter_tempfile_clause production. + ExitAlter_tempfile_clause(c *Alter_tempfile_clauseContext) + + // ExitMove_datafile_clause is called when exiting the move_datafile_clause production. + ExitMove_datafile_clause(c *Move_datafile_clauseContext) + + // ExitLogfile_clauses is called when exiting the logfile_clauses production. + ExitLogfile_clauses(c *Logfile_clausesContext) + + // ExitAdd_logfile_clauses is called when exiting the add_logfile_clauses production. + ExitAdd_logfile_clauses(c *Add_logfile_clausesContext) + + // ExitGroup_redo_logfile is called when exiting the group_redo_logfile production. + ExitGroup_redo_logfile(c *Group_redo_logfileContext) + + // ExitDrop_logfile_clauses is called when exiting the drop_logfile_clauses production. + ExitDrop_logfile_clauses(c *Drop_logfile_clausesContext) + + // ExitSwitch_logfile_clause is called when exiting the switch_logfile_clause production. + ExitSwitch_logfile_clause(c *Switch_logfile_clauseContext) + + // ExitSupplemental_db_logging is called when exiting the supplemental_db_logging production. + ExitSupplemental_db_logging(c *Supplemental_db_loggingContext) + + // ExitAdd_or_drop is called when exiting the add_or_drop production. + ExitAdd_or_drop(c *Add_or_dropContext) + + // ExitSupplemental_plsql_clause is called when exiting the supplemental_plsql_clause production. + ExitSupplemental_plsql_clause(c *Supplemental_plsql_clauseContext) + + // ExitLogfile_descriptor is called when exiting the logfile_descriptor production. + ExitLogfile_descriptor(c *Logfile_descriptorContext) + + // ExitControlfile_clauses is called when exiting the controlfile_clauses production. + ExitControlfile_clauses(c *Controlfile_clausesContext) + + // ExitTrace_file_clause is called when exiting the trace_file_clause production. + ExitTrace_file_clause(c *Trace_file_clauseContext) + + // ExitStandby_database_clauses is called when exiting the standby_database_clauses production. + ExitStandby_database_clauses(c *Standby_database_clausesContext) + + // ExitActivate_standby_db_clause is called when exiting the activate_standby_db_clause production. + ExitActivate_standby_db_clause(c *Activate_standby_db_clauseContext) + + // ExitMaximize_standby_db_clause is called when exiting the maximize_standby_db_clause production. + ExitMaximize_standby_db_clause(c *Maximize_standby_db_clauseContext) + + // ExitRegister_logfile_clause is called when exiting the register_logfile_clause production. + ExitRegister_logfile_clause(c *Register_logfile_clauseContext) + + // ExitCommit_switchover_clause is called when exiting the commit_switchover_clause production. + ExitCommit_switchover_clause(c *Commit_switchover_clauseContext) + + // ExitStart_standby_clause is called when exiting the start_standby_clause production. + ExitStart_standby_clause(c *Start_standby_clauseContext) + + // ExitStop_standby_clause is called when exiting the stop_standby_clause production. + ExitStop_standby_clause(c *Stop_standby_clauseContext) + + // ExitConvert_database_clause is called when exiting the convert_database_clause production. + ExitConvert_database_clause(c *Convert_database_clauseContext) + + // ExitDefault_settings_clause is called when exiting the default_settings_clause production. + ExitDefault_settings_clause(c *Default_settings_clauseContext) + + // ExitSet_time_zone_clause is called when exiting the set_time_zone_clause production. + ExitSet_time_zone_clause(c *Set_time_zone_clauseContext) + + // ExitInstance_clauses is called when exiting the instance_clauses production. + ExitInstance_clauses(c *Instance_clausesContext) + + // ExitSecurity_clause is called when exiting the security_clause production. + ExitSecurity_clause(c *Security_clauseContext) + + // ExitDomain is called when exiting the domain production. + ExitDomain(c *DomainContext) + + // ExitDatabase is called when exiting the database production. + ExitDatabase(c *DatabaseContext) + + // ExitEdition_name is called when exiting the edition_name production. + ExitEdition_name(c *Edition_nameContext) + + // ExitFilenumber is called when exiting the filenumber production. + ExitFilenumber(c *FilenumberContext) + + // ExitFilename is called when exiting the filename production. + ExitFilename(c *FilenameContext) + + // ExitPrepare_clause is called when exiting the prepare_clause production. + ExitPrepare_clause(c *Prepare_clauseContext) + + // ExitDrop_mirror_clause is called when exiting the drop_mirror_clause production. + ExitDrop_mirror_clause(c *Drop_mirror_clauseContext) + + // ExitLost_write_protection is called when exiting the lost_write_protection production. + ExitLost_write_protection(c *Lost_write_protectionContext) + + // ExitCdb_fleet_clauses is called when exiting the cdb_fleet_clauses production. + ExitCdb_fleet_clauses(c *Cdb_fleet_clausesContext) + + // ExitLead_cdb_clause is called when exiting the lead_cdb_clause production. + ExitLead_cdb_clause(c *Lead_cdb_clauseContext) + + // ExitLead_cdb_uri_clause is called when exiting the lead_cdb_uri_clause production. + ExitLead_cdb_uri_clause(c *Lead_cdb_uri_clauseContext) + + // ExitProperty_clauses is called when exiting the property_clauses production. + ExitProperty_clauses(c *Property_clausesContext) + + // ExitReplay_upgrade_clauses is called when exiting the replay_upgrade_clauses production. + ExitReplay_upgrade_clauses(c *Replay_upgrade_clausesContext) + + // ExitAlter_database_link is called when exiting the alter_database_link production. + ExitAlter_database_link(c *Alter_database_linkContext) + + // ExitPassword_value is called when exiting the password_value production. + ExitPassword_value(c *Password_valueContext) + + // ExitLink_authentication is called when exiting the link_authentication production. + ExitLink_authentication(c *Link_authenticationContext) + + // ExitCreate_database is called when exiting the create_database production. + ExitCreate_database(c *Create_databaseContext) + + // ExitDatabase_logging_clauses is called when exiting the database_logging_clauses production. + ExitDatabase_logging_clauses(c *Database_logging_clausesContext) + + // ExitDatabase_logging_sub_clause is called when exiting the database_logging_sub_clause production. + ExitDatabase_logging_sub_clause(c *Database_logging_sub_clauseContext) + + // ExitTablespace_clauses is called when exiting the tablespace_clauses production. + ExitTablespace_clauses(c *Tablespace_clausesContext) + + // ExitEnable_pluggable_database is called when exiting the enable_pluggable_database production. + ExitEnable_pluggable_database(c *Enable_pluggable_databaseContext) + + // ExitFile_name_convert is called when exiting the file_name_convert production. + ExitFile_name_convert(c *File_name_convertContext) + + // ExitFilename_convert_sub_clause is called when exiting the filename_convert_sub_clause production. + ExitFilename_convert_sub_clause(c *Filename_convert_sub_clauseContext) + + // ExitTablespace_datafile_clauses is called when exiting the tablespace_datafile_clauses production. + ExitTablespace_datafile_clauses(c *Tablespace_datafile_clausesContext) + + // ExitUndo_mode_clause is called when exiting the undo_mode_clause production. + ExitUndo_mode_clause(c *Undo_mode_clauseContext) + + // ExitDefault_tablespace is called when exiting the default_tablespace production. + ExitDefault_tablespace(c *Default_tablespaceContext) + + // ExitDefault_temp_tablespace is called when exiting the default_temp_tablespace production. + ExitDefault_temp_tablespace(c *Default_temp_tablespaceContext) + + // ExitUndo_tablespace is called when exiting the undo_tablespace production. + ExitUndo_tablespace(c *Undo_tablespaceContext) + + // ExitDrop_database is called when exiting the drop_database production. + ExitDrop_database(c *Drop_databaseContext) + + // ExitCreate_database_link is called when exiting the create_database_link production. + ExitCreate_database_link(c *Create_database_linkContext) + + // ExitDblink is called when exiting the dblink production. + ExitDblink(c *DblinkContext) + + // ExitDrop_database_link is called when exiting the drop_database_link production. + ExitDrop_database_link(c *Drop_database_linkContext) + + // ExitAlter_tablespace_set is called when exiting the alter_tablespace_set production. + ExitAlter_tablespace_set(c *Alter_tablespace_setContext) + + // ExitAlter_tablespace_attrs is called when exiting the alter_tablespace_attrs production. + ExitAlter_tablespace_attrs(c *Alter_tablespace_attrsContext) + + // ExitAlter_tablespace_encryption is called when exiting the alter_tablespace_encryption production. + ExitAlter_tablespace_encryption(c *Alter_tablespace_encryptionContext) + + // ExitTs_file_name_convert is called when exiting the ts_file_name_convert production. + ExitTs_file_name_convert(c *Ts_file_name_convertContext) + + // ExitAlter_role is called when exiting the alter_role production. + ExitAlter_role(c *Alter_roleContext) + + // ExitRole_identified_clause is called when exiting the role_identified_clause production. + ExitRole_identified_clause(c *Role_identified_clauseContext) + + // ExitAlter_table is called when exiting the alter_table production. + ExitAlter_table(c *Alter_tableContext) + + // ExitMemoptimize_read_write_clause is called when exiting the memoptimize_read_write_clause production. + ExitMemoptimize_read_write_clause(c *Memoptimize_read_write_clauseContext) + + // ExitAlter_table_properties is called when exiting the alter_table_properties production. + ExitAlter_table_properties(c *Alter_table_propertiesContext) + + // ExitAlter_table_partitioning is called when exiting the alter_table_partitioning production. + ExitAlter_table_partitioning(c *Alter_table_partitioningContext) + + // ExitAdd_table_partition is called when exiting the add_table_partition production. + ExitAdd_table_partition(c *Add_table_partitionContext) + + // ExitDrop_table_partition is called when exiting the drop_table_partition production. + ExitDrop_table_partition(c *Drop_table_partitionContext) + + // ExitMerge_table_partition is called when exiting the merge_table_partition production. + ExitMerge_table_partition(c *Merge_table_partitionContext) + + // ExitModify_table_partition is called when exiting the modify_table_partition production. + ExitModify_table_partition(c *Modify_table_partitionContext) + + // ExitSplit_table_partition is called when exiting the split_table_partition production. + ExitSplit_table_partition(c *Split_table_partitionContext) + + // ExitTruncate_table_partition is called when exiting the truncate_table_partition production. + ExitTruncate_table_partition(c *Truncate_table_partitionContext) + + // ExitExchange_table_partition is called when exiting the exchange_table_partition production. + ExitExchange_table_partition(c *Exchange_table_partitionContext) + + // ExitCoalesce_table_partition is called when exiting the coalesce_table_partition production. + ExitCoalesce_table_partition(c *Coalesce_table_partitionContext) + + // ExitAlter_interval_partition is called when exiting the alter_interval_partition production. + ExitAlter_interval_partition(c *Alter_interval_partitionContext) + + // ExitPartition_extended_names is called when exiting the partition_extended_names production. + ExitPartition_extended_names(c *Partition_extended_namesContext) + + // ExitSubpartition_extended_names is called when exiting the subpartition_extended_names production. + ExitSubpartition_extended_names(c *Subpartition_extended_namesContext) + + // ExitAlter_table_properties_1 is called when exiting the alter_table_properties_1 production. + ExitAlter_table_properties_1(c *Alter_table_properties_1Context) + + // ExitAlter_iot_clauses is called when exiting the alter_iot_clauses production. + ExitAlter_iot_clauses(c *Alter_iot_clausesContext) + + // ExitAlter_mapping_table_clause is called when exiting the alter_mapping_table_clause production. + ExitAlter_mapping_table_clause(c *Alter_mapping_table_clauseContext) + + // ExitAlter_overflow_clause is called when exiting the alter_overflow_clause production. + ExitAlter_overflow_clause(c *Alter_overflow_clauseContext) + + // ExitAdd_overflow_clause is called when exiting the add_overflow_clause production. + ExitAdd_overflow_clause(c *Add_overflow_clauseContext) + + // ExitUpdate_index_clauses is called when exiting the update_index_clauses production. + ExitUpdate_index_clauses(c *Update_index_clausesContext) + + // ExitUpdate_global_index_clause is called when exiting the update_global_index_clause production. + ExitUpdate_global_index_clause(c *Update_global_index_clauseContext) + + // ExitUpdate_all_indexes_clause is called when exiting the update_all_indexes_clause production. + ExitUpdate_all_indexes_clause(c *Update_all_indexes_clauseContext) + + // ExitUpdate_all_indexes_index_clause is called when exiting the update_all_indexes_index_clause production. + ExitUpdate_all_indexes_index_clause(c *Update_all_indexes_index_clauseContext) + + // ExitUpdate_index_partition is called when exiting the update_index_partition production. + ExitUpdate_index_partition(c *Update_index_partitionContext) + + // ExitUpdate_index_subpartition is called when exiting the update_index_subpartition production. + ExitUpdate_index_subpartition(c *Update_index_subpartitionContext) + + // ExitEnable_disable_clause is called when exiting the enable_disable_clause production. + ExitEnable_disable_clause(c *Enable_disable_clauseContext) + + // ExitUsing_index_clause is called when exiting the using_index_clause production. + ExitUsing_index_clause(c *Using_index_clauseContext) + + // ExitIndex_attributes is called when exiting the index_attributes production. + ExitIndex_attributes(c *Index_attributesContext) + + // ExitSort_or_nosort is called when exiting the sort_or_nosort production. + ExitSort_or_nosort(c *Sort_or_nosortContext) + + // ExitExceptions_clause is called when exiting the exceptions_clause production. + ExitExceptions_clause(c *Exceptions_clauseContext) + + // ExitMove_table_clause is called when exiting the move_table_clause production. + ExitMove_table_clause(c *Move_table_clauseContext) + + // ExitIndex_org_table_clause is called when exiting the index_org_table_clause production. + ExitIndex_org_table_clause(c *Index_org_table_clauseContext) + + // ExitMapping_table_clause is called when exiting the mapping_table_clause production. + ExitMapping_table_clause(c *Mapping_table_clauseContext) + + // ExitKey_compression is called when exiting the key_compression production. + ExitKey_compression(c *Key_compressionContext) + + // ExitIndex_org_overflow_clause is called when exiting the index_org_overflow_clause production. + ExitIndex_org_overflow_clause(c *Index_org_overflow_clauseContext) + + // ExitColumn_clauses is called when exiting the column_clauses production. + ExitColumn_clauses(c *Column_clausesContext) + + // ExitModify_collection_retrieval is called when exiting the modify_collection_retrieval production. + ExitModify_collection_retrieval(c *Modify_collection_retrievalContext) + + // ExitCollection_item is called when exiting the collection_item production. + ExitCollection_item(c *Collection_itemContext) + + // ExitRename_column_clause is called when exiting the rename_column_clause production. + ExitRename_column_clause(c *Rename_column_clauseContext) + + // ExitOld_column_name is called when exiting the old_column_name production. + ExitOld_column_name(c *Old_column_nameContext) + + // ExitNew_column_name is called when exiting the new_column_name production. + ExitNew_column_name(c *New_column_nameContext) + + // ExitAdd_modify_drop_column_clauses is called when exiting the add_modify_drop_column_clauses production. + ExitAdd_modify_drop_column_clauses(c *Add_modify_drop_column_clausesContext) + + // ExitDrop_column_clause is called when exiting the drop_column_clause production. + ExitDrop_column_clause(c *Drop_column_clauseContext) + + // ExitModify_column_clauses is called when exiting the modify_column_clauses production. + ExitModify_column_clauses(c *Modify_column_clausesContext) + + // ExitModify_col_visibility is called when exiting the modify_col_visibility production. + ExitModify_col_visibility(c *Modify_col_visibilityContext) + + // ExitModify_col_properties is called when exiting the modify_col_properties production. + ExitModify_col_properties(c *Modify_col_propertiesContext) + + // ExitModify_col_substitutable is called when exiting the modify_col_substitutable production. + ExitModify_col_substitutable(c *Modify_col_substitutableContext) + + // ExitAdd_column_clause is called when exiting the add_column_clause production. + ExitAdd_column_clause(c *Add_column_clauseContext) + + // ExitAlter_varray_col_properties is called when exiting the alter_varray_col_properties production. + ExitAlter_varray_col_properties(c *Alter_varray_col_propertiesContext) + + // ExitVarray_col_properties is called when exiting the varray_col_properties production. + ExitVarray_col_properties(c *Varray_col_propertiesContext) + + // ExitVarray_storage_clause is called when exiting the varray_storage_clause production. + ExitVarray_storage_clause(c *Varray_storage_clauseContext) + + // ExitLob_segname is called when exiting the lob_segname production. + ExitLob_segname(c *Lob_segnameContext) + + // ExitLob_item is called when exiting the lob_item production. + ExitLob_item(c *Lob_itemContext) + + // ExitLob_storage_parameters is called when exiting the lob_storage_parameters production. + ExitLob_storage_parameters(c *Lob_storage_parametersContext) + + // ExitLob_storage_clause is called when exiting the lob_storage_clause production. + ExitLob_storage_clause(c *Lob_storage_clauseContext) + + // ExitModify_lob_storage_clause is called when exiting the modify_lob_storage_clause production. + ExitModify_lob_storage_clause(c *Modify_lob_storage_clauseContext) + + // ExitModify_lob_parameters is called when exiting the modify_lob_parameters production. + ExitModify_lob_parameters(c *Modify_lob_parametersContext) + + // ExitLob_parameters is called when exiting the lob_parameters production. + ExitLob_parameters(c *Lob_parametersContext) + + // ExitLob_deduplicate_clause is called when exiting the lob_deduplicate_clause production. + ExitLob_deduplicate_clause(c *Lob_deduplicate_clauseContext) + + // ExitLob_compression_clause is called when exiting the lob_compression_clause production. + ExitLob_compression_clause(c *Lob_compression_clauseContext) + + // ExitLob_retention_clause is called when exiting the lob_retention_clause production. + ExitLob_retention_clause(c *Lob_retention_clauseContext) + + // ExitEncryption_spec is called when exiting the encryption_spec production. + ExitEncryption_spec(c *Encryption_specContext) + + // ExitTablespace is called when exiting the tablespace production. + ExitTablespace(c *TablespaceContext) + + // ExitVarray_item is called when exiting the varray_item production. + ExitVarray_item(c *Varray_itemContext) + + // ExitColumn_properties is called when exiting the column_properties production. + ExitColumn_properties(c *Column_propertiesContext) + + // ExitLob_partition_storage is called when exiting the lob_partition_storage production. + ExitLob_partition_storage(c *Lob_partition_storageContext) + + // ExitPeriod_definition is called when exiting the period_definition production. + ExitPeriod_definition(c *Period_definitionContext) + + // ExitStart_time_column is called when exiting the start_time_column production. + ExitStart_time_column(c *Start_time_columnContext) + + // ExitEnd_time_column is called when exiting the end_time_column production. + ExitEnd_time_column(c *End_time_columnContext) + + // ExitColumn_definition is called when exiting the column_definition production. + ExitColumn_definition(c *Column_definitionContext) + + // ExitColumn_collation_name is called when exiting the column_collation_name production. + ExitColumn_collation_name(c *Column_collation_nameContext) + + // ExitIdentity_clause is called when exiting the identity_clause production. + ExitIdentity_clause(c *Identity_clauseContext) + + // ExitIdentity_options_parentheses is called when exiting the identity_options_parentheses production. + ExitIdentity_options_parentheses(c *Identity_options_parenthesesContext) + + // ExitIdentity_options is called when exiting the identity_options production. + ExitIdentity_options(c *Identity_optionsContext) + + // ExitVirtual_column_definition is called when exiting the virtual_column_definition production. + ExitVirtual_column_definition(c *Virtual_column_definitionContext) + + // ExitAutogenerated_sequence_definition is called when exiting the autogenerated_sequence_definition production. + ExitAutogenerated_sequence_definition(c *Autogenerated_sequence_definitionContext) + + // ExitEvaluation_edition_clause is called when exiting the evaluation_edition_clause production. + ExitEvaluation_edition_clause(c *Evaluation_edition_clauseContext) + + // ExitOut_of_line_part_storage is called when exiting the out_of_line_part_storage production. + ExitOut_of_line_part_storage(c *Out_of_line_part_storageContext) + + // ExitNested_table_col_properties is called when exiting the nested_table_col_properties production. + ExitNested_table_col_properties(c *Nested_table_col_propertiesContext) + + // ExitNested_item is called when exiting the nested_item production. + ExitNested_item(c *Nested_itemContext) + + // ExitSubstitutable_column_clause is called when exiting the substitutable_column_clause production. + ExitSubstitutable_column_clause(c *Substitutable_column_clauseContext) + + // ExitPartition_name is called when exiting the partition_name production. + ExitPartition_name(c *Partition_nameContext) + + // ExitSupplemental_logging_props is called when exiting the supplemental_logging_props production. + ExitSupplemental_logging_props(c *Supplemental_logging_propsContext) + + // ExitColumn_or_attribute is called when exiting the column_or_attribute production. + ExitColumn_or_attribute(c *Column_or_attributeContext) + + // ExitObject_type_col_properties is called when exiting the object_type_col_properties production. + ExitObject_type_col_properties(c *Object_type_col_propertiesContext) + + // ExitConstraint_clauses is called when exiting the constraint_clauses production. + ExitConstraint_clauses(c *Constraint_clausesContext) + + // ExitOld_constraint_name is called when exiting the old_constraint_name production. + ExitOld_constraint_name(c *Old_constraint_nameContext) + + // ExitNew_constraint_name is called when exiting the new_constraint_name production. + ExitNew_constraint_name(c *New_constraint_nameContext) + + // ExitDrop_constraint_clause is called when exiting the drop_constraint_clause production. + ExitDrop_constraint_clause(c *Drop_constraint_clauseContext) + + // ExitDrop_primary_key_or_unique_or_generic_clause is called when exiting the drop_primary_key_or_unique_or_generic_clause production. + ExitDrop_primary_key_or_unique_or_generic_clause(c *Drop_primary_key_or_unique_or_generic_clauseContext) + + // ExitAdd_constraint is called when exiting the add_constraint production. + ExitAdd_constraint(c *Add_constraintContext) + + // ExitAdd_constraint_clause is called when exiting the add_constraint_clause production. + ExitAdd_constraint_clause(c *Add_constraint_clauseContext) + + // ExitCheck_constraint is called when exiting the check_constraint production. + ExitCheck_constraint(c *Check_constraintContext) + + // ExitDrop_constraint is called when exiting the drop_constraint production. + ExitDrop_constraint(c *Drop_constraintContext) + + // ExitEnable_constraint is called when exiting the enable_constraint production. + ExitEnable_constraint(c *Enable_constraintContext) + + // ExitDisable_constraint is called when exiting the disable_constraint production. + ExitDisable_constraint(c *Disable_constraintContext) + + // ExitForeign_key_clause is called when exiting the foreign_key_clause production. + ExitForeign_key_clause(c *Foreign_key_clauseContext) + + // ExitReferences_clause is called when exiting the references_clause production. + ExitReferences_clause(c *References_clauseContext) + + // ExitOn_delete_clause is called when exiting the on_delete_clause production. + ExitOn_delete_clause(c *On_delete_clauseContext) + + // ExitUnique_key_clause is called when exiting the unique_key_clause production. + ExitUnique_key_clause(c *Unique_key_clauseContext) + + // ExitPrimary_key_clause is called when exiting the primary_key_clause production. + ExitPrimary_key_clause(c *Primary_key_clauseContext) + + // ExitAnonymous_block is called when exiting the anonymous_block production. + ExitAnonymous_block(c *Anonymous_blockContext) + + // ExitInvoker_rights_clause is called when exiting the invoker_rights_clause production. + ExitInvoker_rights_clause(c *Invoker_rights_clauseContext) + + // ExitCall_spec is called when exiting the call_spec production. + ExitCall_spec(c *Call_specContext) + + // ExitJava_spec is called when exiting the java_spec production. + ExitJava_spec(c *Java_specContext) + + // ExitC_spec is called when exiting the c_spec production. + ExitC_spec(c *C_specContext) + + // ExitC_agent_in_clause is called when exiting the c_agent_in_clause production. + ExitC_agent_in_clause(c *C_agent_in_clauseContext) + + // ExitC_parameters_clause is called when exiting the c_parameters_clause production. + ExitC_parameters_clause(c *C_parameters_clauseContext) + + // ExitParameter is called when exiting the parameter production. + ExitParameter(c *ParameterContext) + + // ExitDefault_value_part is called when exiting the default_value_part production. + ExitDefault_value_part(c *Default_value_partContext) + + // ExitSeq_of_declare_specs is called when exiting the seq_of_declare_specs production. + ExitSeq_of_declare_specs(c *Seq_of_declare_specsContext) + + // ExitDeclare_spec is called when exiting the declare_spec production. + ExitDeclare_spec(c *Declare_specContext) + + // ExitVariable_declaration is called when exiting the variable_declaration production. + ExitVariable_declaration(c *Variable_declarationContext) + + // ExitSubtype_declaration is called when exiting the subtype_declaration production. + ExitSubtype_declaration(c *Subtype_declarationContext) + + // ExitCursor_declaration is called when exiting the cursor_declaration production. + ExitCursor_declaration(c *Cursor_declarationContext) + + // ExitParameter_spec is called when exiting the parameter_spec production. + ExitParameter_spec(c *Parameter_specContext) + + // ExitException_declaration is called when exiting the exception_declaration production. + ExitException_declaration(c *Exception_declarationContext) + + // ExitPragma_declaration is called when exiting the pragma_declaration production. + ExitPragma_declaration(c *Pragma_declarationContext) + + // ExitRecord_type_def is called when exiting the record_type_def production. + ExitRecord_type_def(c *Record_type_defContext) + + // ExitField_spec is called when exiting the field_spec production. + ExitField_spec(c *Field_specContext) + + // ExitRef_cursor_type_def is called when exiting the ref_cursor_type_def production. + ExitRef_cursor_type_def(c *Ref_cursor_type_defContext) + + // ExitType_declaration is called when exiting the type_declaration production. + ExitType_declaration(c *Type_declarationContext) + + // ExitTable_type_def is called when exiting the table_type_def production. + ExitTable_type_def(c *Table_type_defContext) + + // ExitTable_indexed_by_part is called when exiting the table_indexed_by_part production. + ExitTable_indexed_by_part(c *Table_indexed_by_partContext) + + // ExitVarray_type_def is called when exiting the varray_type_def production. + ExitVarray_type_def(c *Varray_type_defContext) + + // ExitSeq_of_statements is called when exiting the seq_of_statements production. + ExitSeq_of_statements(c *Seq_of_statementsContext) + + // ExitLabel_declaration is called when exiting the label_declaration production. + ExitLabel_declaration(c *Label_declarationContext) + + // ExitStatement is called when exiting the statement production. + ExitStatement(c *StatementContext) + + // ExitSwallow_to_semi is called when exiting the swallow_to_semi production. + ExitSwallow_to_semi(c *Swallow_to_semiContext) + + // ExitAssignment_statement is called when exiting the assignment_statement production. + ExitAssignment_statement(c *Assignment_statementContext) + + // ExitContinue_statement is called when exiting the continue_statement production. + ExitContinue_statement(c *Continue_statementContext) + + // ExitExit_statement is called when exiting the exit_statement production. + ExitExit_statement(c *Exit_statementContext) + + // ExitGoto_statement is called when exiting the goto_statement production. + ExitGoto_statement(c *Goto_statementContext) + + // ExitIf_statement is called when exiting the if_statement production. + ExitIf_statement(c *If_statementContext) + + // ExitElsif_part is called when exiting the elsif_part production. + ExitElsif_part(c *Elsif_partContext) + + // ExitElse_part is called when exiting the else_part production. + ExitElse_part(c *Else_partContext) + + // ExitLoop_statement is called when exiting the loop_statement production. + ExitLoop_statement(c *Loop_statementContext) + + // ExitCursor_loop_param is called when exiting the cursor_loop_param production. + ExitCursor_loop_param(c *Cursor_loop_paramContext) + + // ExitForall_statement is called when exiting the forall_statement production. + ExitForall_statement(c *Forall_statementContext) + + // ExitBounds_clause is called when exiting the bounds_clause production. + ExitBounds_clause(c *Bounds_clauseContext) + + // ExitBetween_bound is called when exiting the between_bound production. + ExitBetween_bound(c *Between_boundContext) + + // ExitLower_bound is called when exiting the lower_bound production. + ExitLower_bound(c *Lower_boundContext) + + // ExitUpper_bound is called when exiting the upper_bound production. + ExitUpper_bound(c *Upper_boundContext) + + // ExitNull_statement is called when exiting the null_statement production. + ExitNull_statement(c *Null_statementContext) + + // ExitRaise_statement is called when exiting the raise_statement production. + ExitRaise_statement(c *Raise_statementContext) + + // ExitReturn_statement is called when exiting the return_statement production. + ExitReturn_statement(c *Return_statementContext) + + // ExitCall_statement is called when exiting the call_statement production. + ExitCall_statement(c *Call_statementContext) + + // ExitPipe_row_statement is called when exiting the pipe_row_statement production. + ExitPipe_row_statement(c *Pipe_row_statementContext) + + // ExitBody is called when exiting the body production. + ExitBody(c *BodyContext) + + // ExitException_handler is called when exiting the exception_handler production. + ExitException_handler(c *Exception_handlerContext) + + // ExitTrigger_block is called when exiting the trigger_block production. + ExitTrigger_block(c *Trigger_blockContext) + + // ExitBlock is called when exiting the block production. + ExitBlock(c *BlockContext) + + // ExitSql_statement is called when exiting the sql_statement production. + ExitSql_statement(c *Sql_statementContext) + + // ExitExecute_immediate is called when exiting the execute_immediate production. + ExitExecute_immediate(c *Execute_immediateContext) + + // ExitDynamic_returning_clause is called when exiting the dynamic_returning_clause production. + ExitDynamic_returning_clause(c *Dynamic_returning_clauseContext) + + // ExitData_manipulation_language_statements is called when exiting the data_manipulation_language_statements production. + ExitData_manipulation_language_statements(c *Data_manipulation_language_statementsContext) + + // ExitCursor_manipulation_statements is called when exiting the cursor_manipulation_statements production. + ExitCursor_manipulation_statements(c *Cursor_manipulation_statementsContext) + + // ExitClose_statement is called when exiting the close_statement production. + ExitClose_statement(c *Close_statementContext) + + // ExitOpen_statement is called when exiting the open_statement production. + ExitOpen_statement(c *Open_statementContext) + + // ExitFetch_statement is called when exiting the fetch_statement production. + ExitFetch_statement(c *Fetch_statementContext) + + // ExitOpen_for_statement is called when exiting the open_for_statement production. + ExitOpen_for_statement(c *Open_for_statementContext) + + // ExitTransaction_control_statements is called when exiting the transaction_control_statements production. + ExitTransaction_control_statements(c *Transaction_control_statementsContext) + + // ExitSet_transaction_command is called when exiting the set_transaction_command production. + ExitSet_transaction_command(c *Set_transaction_commandContext) + + // ExitSet_constraint_command is called when exiting the set_constraint_command production. + ExitSet_constraint_command(c *Set_constraint_commandContext) + + // ExitCommit_statement is called when exiting the commit_statement production. + ExitCommit_statement(c *Commit_statementContext) + + // ExitWrite_clause is called when exiting the write_clause production. + ExitWrite_clause(c *Write_clauseContext) + + // ExitRollback_statement is called when exiting the rollback_statement production. + ExitRollback_statement(c *Rollback_statementContext) + + // ExitSavepoint_statement is called when exiting the savepoint_statement production. + ExitSavepoint_statement(c *Savepoint_statementContext) + + // ExitExplain_statement is called when exiting the explain_statement production. + ExitExplain_statement(c *Explain_statementContext) + + // ExitSelect_only_statement is called when exiting the select_only_statement production. + ExitSelect_only_statement(c *Select_only_statementContext) + + // ExitSelect_statement is called when exiting the select_statement production. + ExitSelect_statement(c *Select_statementContext) + + // ExitSubquery_factoring_clause is called when exiting the subquery_factoring_clause production. + ExitSubquery_factoring_clause(c *Subquery_factoring_clauseContext) + + // ExitFactoring_element is called when exiting the factoring_element production. + ExitFactoring_element(c *Factoring_elementContext) + + // ExitSearch_clause is called when exiting the search_clause production. + ExitSearch_clause(c *Search_clauseContext) + + // ExitCycle_clause is called when exiting the cycle_clause production. + ExitCycle_clause(c *Cycle_clauseContext) + + // ExitSubquery is called when exiting the subquery production. + ExitSubquery(c *SubqueryContext) + + // ExitSubquery_basic_elements is called when exiting the subquery_basic_elements production. + ExitSubquery_basic_elements(c *Subquery_basic_elementsContext) + + // ExitSubquery_operation_part is called when exiting the subquery_operation_part production. + ExitSubquery_operation_part(c *Subquery_operation_partContext) + + // ExitQuery_block is called when exiting the query_block production. + ExitQuery_block(c *Query_blockContext) + + // ExitSelected_list is called when exiting the selected_list production. + ExitSelected_list(c *Selected_listContext) + + // ExitFrom_clause is called when exiting the from_clause production. + ExitFrom_clause(c *From_clauseContext) + + // ExitSelect_list_elements is called when exiting the select_list_elements production. + ExitSelect_list_elements(c *Select_list_elementsContext) + + // ExitTable_wild is called when exiting the table_wild production. + ExitTable_wild(c *Table_wildContext) + + // ExitTable_ref_list is called when exiting the table_ref_list production. + ExitTable_ref_list(c *Table_ref_listContext) + + // ExitTable_ref is called when exiting the table_ref production. + ExitTable_ref(c *Table_refContext) + + // ExitTable_ref_aux is called when exiting the table_ref_aux production. + ExitTable_ref_aux(c *Table_ref_auxContext) + + // ExitTable_ref_aux_internal_one is called when exiting the table_ref_aux_internal_one production. + ExitTable_ref_aux_internal_one(c *Table_ref_aux_internal_oneContext) + + // ExitTable_ref_aux_internal_two is called when exiting the table_ref_aux_internal_two production. + ExitTable_ref_aux_internal_two(c *Table_ref_aux_internal_twoContext) + + // ExitTable_ref_aux_internal_three is called when exiting the table_ref_aux_internal_three production. + ExitTable_ref_aux_internal_three(c *Table_ref_aux_internal_threeContext) + + // ExitJoin_clause is called when exiting the join_clause production. + ExitJoin_clause(c *Join_clauseContext) + + // ExitJoin_on_part is called when exiting the join_on_part production. + ExitJoin_on_part(c *Join_on_partContext) + + // ExitJoin_using_part is called when exiting the join_using_part production. + ExitJoin_using_part(c *Join_using_partContext) + + // ExitOuter_join_type is called when exiting the outer_join_type production. + ExitOuter_join_type(c *Outer_join_typeContext) + + // ExitQuery_partition_clause is called when exiting the query_partition_clause production. + ExitQuery_partition_clause(c *Query_partition_clauseContext) + + // ExitFlashback_query_clause is called when exiting the flashback_query_clause production. + ExitFlashback_query_clause(c *Flashback_query_clauseContext) + + // ExitPivot_clause is called when exiting the pivot_clause production. + ExitPivot_clause(c *Pivot_clauseContext) + + // ExitPivot_element is called when exiting the pivot_element production. + ExitPivot_element(c *Pivot_elementContext) + + // ExitPivot_for_clause is called when exiting the pivot_for_clause production. + ExitPivot_for_clause(c *Pivot_for_clauseContext) + + // ExitPivot_in_clause is called when exiting the pivot_in_clause production. + ExitPivot_in_clause(c *Pivot_in_clauseContext) + + // ExitPivot_in_clause_element is called when exiting the pivot_in_clause_element production. + ExitPivot_in_clause_element(c *Pivot_in_clause_elementContext) + + // ExitPivot_in_clause_elements is called when exiting the pivot_in_clause_elements production. + ExitPivot_in_clause_elements(c *Pivot_in_clause_elementsContext) + + // ExitUnpivot_clause is called when exiting the unpivot_clause production. + ExitUnpivot_clause(c *Unpivot_clauseContext) + + // ExitUnpivot_in_clause is called when exiting the unpivot_in_clause production. + ExitUnpivot_in_clause(c *Unpivot_in_clauseContext) + + // ExitUnpivot_in_elements is called when exiting the unpivot_in_elements production. + ExitUnpivot_in_elements(c *Unpivot_in_elementsContext) + + // ExitHierarchical_query_clause is called when exiting the hierarchical_query_clause production. + ExitHierarchical_query_clause(c *Hierarchical_query_clauseContext) + + // ExitStart_part is called when exiting the start_part production. + ExitStart_part(c *Start_partContext) + + // ExitGroup_by_clause is called when exiting the group_by_clause production. + ExitGroup_by_clause(c *Group_by_clauseContext) + + // ExitGroup_by_elements is called when exiting the group_by_elements production. + ExitGroup_by_elements(c *Group_by_elementsContext) + + // ExitRollup_cube_clause is called when exiting the rollup_cube_clause production. + ExitRollup_cube_clause(c *Rollup_cube_clauseContext) + + // ExitGrouping_sets_clause is called when exiting the grouping_sets_clause production. + ExitGrouping_sets_clause(c *Grouping_sets_clauseContext) + + // ExitGrouping_sets_elements is called when exiting the grouping_sets_elements production. + ExitGrouping_sets_elements(c *Grouping_sets_elementsContext) + + // ExitHaving_clause is called when exiting the having_clause production. + ExitHaving_clause(c *Having_clauseContext) + + // ExitModel_clause is called when exiting the model_clause production. + ExitModel_clause(c *Model_clauseContext) + + // ExitCell_reference_options is called when exiting the cell_reference_options production. + ExitCell_reference_options(c *Cell_reference_optionsContext) + + // ExitReturn_rows_clause is called when exiting the return_rows_clause production. + ExitReturn_rows_clause(c *Return_rows_clauseContext) + + // ExitReference_model is called when exiting the reference_model production. + ExitReference_model(c *Reference_modelContext) + + // ExitMain_model is called when exiting the main_model production. + ExitMain_model(c *Main_modelContext) + + // ExitModel_column_clauses is called when exiting the model_column_clauses production. + ExitModel_column_clauses(c *Model_column_clausesContext) + + // ExitModel_column_partition_part is called when exiting the model_column_partition_part production. + ExitModel_column_partition_part(c *Model_column_partition_partContext) + + // ExitModel_column_list is called when exiting the model_column_list production. + ExitModel_column_list(c *Model_column_listContext) + + // ExitModel_column is called when exiting the model_column production. + ExitModel_column(c *Model_columnContext) + + // ExitModel_rules_clause is called when exiting the model_rules_clause production. + ExitModel_rules_clause(c *Model_rules_clauseContext) + + // ExitModel_rules_part is called when exiting the model_rules_part production. + ExitModel_rules_part(c *Model_rules_partContext) + + // ExitModel_rules_element is called when exiting the model_rules_element production. + ExitModel_rules_element(c *Model_rules_elementContext) + + // ExitCell_assignment is called when exiting the cell_assignment production. + ExitCell_assignment(c *Cell_assignmentContext) + + // ExitModel_iterate_clause is called when exiting the model_iterate_clause production. + ExitModel_iterate_clause(c *Model_iterate_clauseContext) + + // ExitUntil_part is called when exiting the until_part production. + ExitUntil_part(c *Until_partContext) + + // ExitOrder_by_clause is called when exiting the order_by_clause production. + ExitOrder_by_clause(c *Order_by_clauseContext) + + // ExitOrder_by_elements is called when exiting the order_by_elements production. + ExitOrder_by_elements(c *Order_by_elementsContext) + + // ExitOffset_clause is called when exiting the offset_clause production. + ExitOffset_clause(c *Offset_clauseContext) + + // ExitFetch_clause is called when exiting the fetch_clause production. + ExitFetch_clause(c *Fetch_clauseContext) + + // ExitFor_update_clause is called when exiting the for_update_clause production. + ExitFor_update_clause(c *For_update_clauseContext) + + // ExitFor_update_of_part is called when exiting the for_update_of_part production. + ExitFor_update_of_part(c *For_update_of_partContext) + + // ExitFor_update_options is called when exiting the for_update_options production. + ExitFor_update_options(c *For_update_optionsContext) + + // ExitUpdate_statement is called when exiting the update_statement production. + ExitUpdate_statement(c *Update_statementContext) + + // ExitUpdate_set_clause is called when exiting the update_set_clause production. + ExitUpdate_set_clause(c *Update_set_clauseContext) + + // ExitColumn_based_update_set_clause is called when exiting the column_based_update_set_clause production. + ExitColumn_based_update_set_clause(c *Column_based_update_set_clauseContext) + + // ExitDelete_statement is called when exiting the delete_statement production. + ExitDelete_statement(c *Delete_statementContext) + + // ExitInsert_statement is called when exiting the insert_statement production. + ExitInsert_statement(c *Insert_statementContext) + + // ExitSingle_table_insert is called when exiting the single_table_insert production. + ExitSingle_table_insert(c *Single_table_insertContext) + + // ExitMulti_table_insert is called when exiting the multi_table_insert production. + ExitMulti_table_insert(c *Multi_table_insertContext) + + // ExitMulti_table_element is called when exiting the multi_table_element production. + ExitMulti_table_element(c *Multi_table_elementContext) + + // ExitConditional_insert_clause is called when exiting the conditional_insert_clause production. + ExitConditional_insert_clause(c *Conditional_insert_clauseContext) + + // ExitConditional_insert_when_part is called when exiting the conditional_insert_when_part production. + ExitConditional_insert_when_part(c *Conditional_insert_when_partContext) + + // ExitConditional_insert_else_part is called when exiting the conditional_insert_else_part production. + ExitConditional_insert_else_part(c *Conditional_insert_else_partContext) + + // ExitInsert_into_clause is called when exiting the insert_into_clause production. + ExitInsert_into_clause(c *Insert_into_clauseContext) + + // ExitValues_clause is called when exiting the values_clause production. + ExitValues_clause(c *Values_clauseContext) + + // ExitMerge_statement is called when exiting the merge_statement production. + ExitMerge_statement(c *Merge_statementContext) + + // ExitMerge_update_clause is called when exiting the merge_update_clause production. + ExitMerge_update_clause(c *Merge_update_clauseContext) + + // ExitMerge_element is called when exiting the merge_element production. + ExitMerge_element(c *Merge_elementContext) + + // ExitMerge_update_delete_part is called when exiting the merge_update_delete_part production. + ExitMerge_update_delete_part(c *Merge_update_delete_partContext) + + // ExitMerge_insert_clause is called when exiting the merge_insert_clause production. + ExitMerge_insert_clause(c *Merge_insert_clauseContext) + + // ExitSelected_tableview is called when exiting the selected_tableview production. + ExitSelected_tableview(c *Selected_tableviewContext) + + // ExitLock_table_statement is called when exiting the lock_table_statement production. + ExitLock_table_statement(c *Lock_table_statementContext) + + // ExitWait_nowait_part is called when exiting the wait_nowait_part production. + ExitWait_nowait_part(c *Wait_nowait_partContext) + + // ExitLock_table_element is called when exiting the lock_table_element production. + ExitLock_table_element(c *Lock_table_elementContext) + + // ExitLock_mode is called when exiting the lock_mode production. + ExitLock_mode(c *Lock_modeContext) + + // ExitGeneral_table_ref is called when exiting the general_table_ref production. + ExitGeneral_table_ref(c *General_table_refContext) + + // ExitStatic_returning_clause is called when exiting the static_returning_clause production. + ExitStatic_returning_clause(c *Static_returning_clauseContext) + + // ExitError_logging_clause is called when exiting the error_logging_clause production. + ExitError_logging_clause(c *Error_logging_clauseContext) + + // ExitError_logging_into_part is called when exiting the error_logging_into_part production. + ExitError_logging_into_part(c *Error_logging_into_partContext) + + // ExitError_logging_reject_part is called when exiting the error_logging_reject_part production. + ExitError_logging_reject_part(c *Error_logging_reject_partContext) + + // ExitDml_table_expression_clause is called when exiting the dml_table_expression_clause production. + ExitDml_table_expression_clause(c *Dml_table_expression_clauseContext) + + // ExitTable_collection_expression is called when exiting the table_collection_expression production. + ExitTable_collection_expression(c *Table_collection_expressionContext) + + // ExitSubquery_restriction_clause is called when exiting the subquery_restriction_clause production. + ExitSubquery_restriction_clause(c *Subquery_restriction_clauseContext) + + // ExitSample_clause is called when exiting the sample_clause production. + ExitSample_clause(c *Sample_clauseContext) + + // ExitSeed_part is called when exiting the seed_part production. + ExitSeed_part(c *Seed_partContext) + + // ExitCondition is called when exiting the condition production. + ExitCondition(c *ConditionContext) + + // ExitJson_condition is called when exiting the json_condition production. + ExitJson_condition(c *Json_conditionContext) + + // ExitExpressions is called when exiting the expressions production. + ExitExpressions(c *ExpressionsContext) + + // ExitExpression is called when exiting the expression production. + ExitExpression(c *ExpressionContext) + + // ExitCursor_expression is called when exiting the cursor_expression production. + ExitCursor_expression(c *Cursor_expressionContext) + + // ExitLogical_expression is called when exiting the logical_expression production. + ExitLogical_expression(c *Logical_expressionContext) + + // ExitUnary_logical_expression is called when exiting the unary_logical_expression production. + ExitUnary_logical_expression(c *Unary_logical_expressionContext) + + // ExitLogical_operation is called when exiting the logical_operation production. + ExitLogical_operation(c *Logical_operationContext) + + // ExitMultiset_expression is called when exiting the multiset_expression production. + ExitMultiset_expression(c *Multiset_expressionContext) + + // ExitRelational_expression is called when exiting the relational_expression production. + ExitRelational_expression(c *Relational_expressionContext) + + // ExitCompound_expression is called when exiting the compound_expression production. + ExitCompound_expression(c *Compound_expressionContext) + + // ExitRelational_operator is called when exiting the relational_operator production. + ExitRelational_operator(c *Relational_operatorContext) + + // ExitIn_elements is called when exiting the in_elements production. + ExitIn_elements(c *In_elementsContext) + + // ExitBetween_elements is called when exiting the between_elements production. + ExitBetween_elements(c *Between_elementsContext) + + // ExitConcatenation is called when exiting the concatenation production. + ExitConcatenation(c *ConcatenationContext) + + // ExitInterval_expression is called when exiting the interval_expression production. + ExitInterval_expression(c *Interval_expressionContext) + + // ExitModel_expression is called when exiting the model_expression production. + ExitModel_expression(c *Model_expressionContext) + + // ExitModel_expression_element is called when exiting the model_expression_element production. + ExitModel_expression_element(c *Model_expression_elementContext) + + // ExitSingle_column_for_loop is called when exiting the single_column_for_loop production. + ExitSingle_column_for_loop(c *Single_column_for_loopContext) + + // ExitMulti_column_for_loop is called when exiting the multi_column_for_loop production. + ExitMulti_column_for_loop(c *Multi_column_for_loopContext) + + // ExitUnary_expression is called when exiting the unary_expression production. + ExitUnary_expression(c *Unary_expressionContext) + + // ExitCase_statement is called when exiting the case_statement production. + ExitCase_statement(c *Case_statementContext) + + // ExitSimple_case_statement is called when exiting the simple_case_statement production. + ExitSimple_case_statement(c *Simple_case_statementContext) + + // ExitSimple_case_when_part is called when exiting the simple_case_when_part production. + ExitSimple_case_when_part(c *Simple_case_when_partContext) + + // ExitSearched_case_statement is called when exiting the searched_case_statement production. + ExitSearched_case_statement(c *Searched_case_statementContext) + + // ExitSearched_case_when_part is called when exiting the searched_case_when_part production. + ExitSearched_case_when_part(c *Searched_case_when_partContext) + + // ExitCase_else_part is called when exiting the case_else_part production. + ExitCase_else_part(c *Case_else_partContext) + + // ExitAtom is called when exiting the atom production. + ExitAtom(c *AtomContext) + + // ExitQuantified_expression is called when exiting the quantified_expression production. + ExitQuantified_expression(c *Quantified_expressionContext) + + // ExitString_function is called when exiting the string_function production. + ExitString_function(c *String_functionContext) + + // ExitStandard_function is called when exiting the standard_function production. + ExitStandard_function(c *Standard_functionContext) + + // ExitJson_function is called when exiting the json_function production. + ExitJson_function(c *Json_functionContext) + + // ExitJson_object_content is called when exiting the json_object_content production. + ExitJson_object_content(c *Json_object_contentContext) + + // ExitJson_object_entry is called when exiting the json_object_entry production. + ExitJson_object_entry(c *Json_object_entryContext) + + // ExitJson_table_clause is called when exiting the json_table_clause production. + ExitJson_table_clause(c *Json_table_clauseContext) + + // ExitJson_array_element is called when exiting the json_array_element production. + ExitJson_array_element(c *Json_array_elementContext) + + // ExitJson_on_null_clause is called when exiting the json_on_null_clause production. + ExitJson_on_null_clause(c *Json_on_null_clauseContext) + + // ExitJson_return_clause is called when exiting the json_return_clause production. + ExitJson_return_clause(c *Json_return_clauseContext) + + // ExitJson_transform_op is called when exiting the json_transform_op production. + ExitJson_transform_op(c *Json_transform_opContext) + + // ExitJson_column_clause is called when exiting the json_column_clause production. + ExitJson_column_clause(c *Json_column_clauseContext) + + // ExitJson_column_definition is called when exiting the json_column_definition production. + ExitJson_column_definition(c *Json_column_definitionContext) + + // ExitJson_query_returning_clause is called when exiting the json_query_returning_clause production. + ExitJson_query_returning_clause(c *Json_query_returning_clauseContext) + + // ExitJson_query_return_type is called when exiting the json_query_return_type production. + ExitJson_query_return_type(c *Json_query_return_typeContext) + + // ExitJson_query_wrapper_clause is called when exiting the json_query_wrapper_clause production. + ExitJson_query_wrapper_clause(c *Json_query_wrapper_clauseContext) + + // ExitJson_query_on_error_clause is called when exiting the json_query_on_error_clause production. + ExitJson_query_on_error_clause(c *Json_query_on_error_clauseContext) + + // ExitJson_query_on_empty_clause is called when exiting the json_query_on_empty_clause production. + ExitJson_query_on_empty_clause(c *Json_query_on_empty_clauseContext) + + // ExitJson_value_return_clause is called when exiting the json_value_return_clause production. + ExitJson_value_return_clause(c *Json_value_return_clauseContext) + + // ExitJson_value_return_type is called when exiting the json_value_return_type production. + ExitJson_value_return_type(c *Json_value_return_typeContext) + + // ExitJson_value_on_mismatch_clause is called when exiting the json_value_on_mismatch_clause production. + ExitJson_value_on_mismatch_clause(c *Json_value_on_mismatch_clauseContext) + + // ExitLiteral is called when exiting the literal production. + ExitLiteral(c *LiteralContext) + + // ExitNumeric_function_wrapper is called when exiting the numeric_function_wrapper production. + ExitNumeric_function_wrapper(c *Numeric_function_wrapperContext) + + // ExitNumeric_function is called when exiting the numeric_function production. + ExitNumeric_function(c *Numeric_functionContext) + + // ExitListagg_overflow_clause is called when exiting the listagg_overflow_clause production. + ExitListagg_overflow_clause(c *Listagg_overflow_clauseContext) + + // ExitOther_function is called when exiting the other_function production. + ExitOther_function(c *Other_functionContext) + + // ExitOver_clause_keyword is called when exiting the over_clause_keyword production. + ExitOver_clause_keyword(c *Over_clause_keywordContext) + + // ExitWithin_or_over_clause_keyword is called when exiting the within_or_over_clause_keyword production. + ExitWithin_or_over_clause_keyword(c *Within_or_over_clause_keywordContext) + + // ExitStandard_prediction_function_keyword is called when exiting the standard_prediction_function_keyword production. + ExitStandard_prediction_function_keyword(c *Standard_prediction_function_keywordContext) + + // ExitOver_clause is called when exiting the over_clause production. + ExitOver_clause(c *Over_clauseContext) + + // ExitWindowing_clause is called when exiting the windowing_clause production. + ExitWindowing_clause(c *Windowing_clauseContext) + + // ExitWindowing_type is called when exiting the windowing_type production. + ExitWindowing_type(c *Windowing_typeContext) + + // ExitWindowing_elements is called when exiting the windowing_elements production. + ExitWindowing_elements(c *Windowing_elementsContext) + + // ExitUsing_clause is called when exiting the using_clause production. + ExitUsing_clause(c *Using_clauseContext) + + // ExitUsing_element is called when exiting the using_element production. + ExitUsing_element(c *Using_elementContext) + + // ExitCollect_order_by_part is called when exiting the collect_order_by_part production. + ExitCollect_order_by_part(c *Collect_order_by_partContext) + + // ExitWithin_or_over_part is called when exiting the within_or_over_part production. + ExitWithin_or_over_part(c *Within_or_over_partContext) + + // ExitCost_matrix_clause is called when exiting the cost_matrix_clause production. + ExitCost_matrix_clause(c *Cost_matrix_clauseContext) + + // ExitXml_passing_clause is called when exiting the xml_passing_clause production. + ExitXml_passing_clause(c *Xml_passing_clauseContext) + + // ExitXml_attributes_clause is called when exiting the xml_attributes_clause production. + ExitXml_attributes_clause(c *Xml_attributes_clauseContext) + + // ExitXml_namespaces_clause is called when exiting the xml_namespaces_clause production. + ExitXml_namespaces_clause(c *Xml_namespaces_clauseContext) + + // ExitXml_table_column is called when exiting the xml_table_column production. + ExitXml_table_column(c *Xml_table_columnContext) + + // ExitXml_general_default_part is called when exiting the xml_general_default_part production. + ExitXml_general_default_part(c *Xml_general_default_partContext) + + // ExitXml_multiuse_expression_element is called when exiting the xml_multiuse_expression_element production. + ExitXml_multiuse_expression_element(c *Xml_multiuse_expression_elementContext) + + // ExitXmlroot_param_version_part is called when exiting the xmlroot_param_version_part production. + ExitXmlroot_param_version_part(c *Xmlroot_param_version_partContext) + + // ExitXmlroot_param_standalone_part is called when exiting the xmlroot_param_standalone_part production. + ExitXmlroot_param_standalone_part(c *Xmlroot_param_standalone_partContext) + + // ExitXmlserialize_param_enconding_part is called when exiting the xmlserialize_param_enconding_part production. + ExitXmlserialize_param_enconding_part(c *Xmlserialize_param_enconding_partContext) + + // ExitXmlserialize_param_version_part is called when exiting the xmlserialize_param_version_part production. + ExitXmlserialize_param_version_part(c *Xmlserialize_param_version_partContext) + + // ExitXmlserialize_param_ident_part is called when exiting the xmlserialize_param_ident_part production. + ExitXmlserialize_param_ident_part(c *Xmlserialize_param_ident_partContext) + + // ExitSql_plus_command is called when exiting the sql_plus_command production. + ExitSql_plus_command(c *Sql_plus_commandContext) + + // ExitWhenever_command is called when exiting the whenever_command production. + ExitWhenever_command(c *Whenever_commandContext) + + // ExitSet_command is called when exiting the set_command production. + ExitSet_command(c *Set_commandContext) + + // ExitTiming_command is called when exiting the timing_command production. + ExitTiming_command(c *Timing_commandContext) + + // ExitPartition_extension_clause is called when exiting the partition_extension_clause production. + ExitPartition_extension_clause(c *Partition_extension_clauseContext) + + // ExitColumn_alias is called when exiting the column_alias production. + ExitColumn_alias(c *Column_aliasContext) + + // ExitTable_alias is called when exiting the table_alias production. + ExitTable_alias(c *Table_aliasContext) + + // ExitWhere_clause is called when exiting the where_clause production. + ExitWhere_clause(c *Where_clauseContext) + + // ExitQuantitative_where_stmt is called when exiting the quantitative_where_stmt production. + ExitQuantitative_where_stmt(c *Quantitative_where_stmtContext) + + // ExitInto_clause is called when exiting the into_clause production. + ExitInto_clause(c *Into_clauseContext) + + // ExitXml_column_name is called when exiting the xml_column_name production. + ExitXml_column_name(c *Xml_column_nameContext) + + // ExitCost_class_name is called when exiting the cost_class_name production. + ExitCost_class_name(c *Cost_class_nameContext) + + // ExitAttribute_name is called when exiting the attribute_name production. + ExitAttribute_name(c *Attribute_nameContext) + + // ExitSavepoint_name is called when exiting the savepoint_name production. + ExitSavepoint_name(c *Savepoint_nameContext) + + // ExitRollback_segment_name is called when exiting the rollback_segment_name production. + ExitRollback_segment_name(c *Rollback_segment_nameContext) + + // ExitTable_var_name is called when exiting the table_var_name production. + ExitTable_var_name(c *Table_var_nameContext) + + // ExitSchema_name is called when exiting the schema_name production. + ExitSchema_name(c *Schema_nameContext) + + // ExitRoutine_name is called when exiting the routine_name production. + ExitRoutine_name(c *Routine_nameContext) + + // ExitPackage_name is called when exiting the package_name production. + ExitPackage_name(c *Package_nameContext) + + // ExitImplementation_type_name is called when exiting the implementation_type_name production. + ExitImplementation_type_name(c *Implementation_type_nameContext) + + // ExitParameter_name is called when exiting the parameter_name production. + ExitParameter_name(c *Parameter_nameContext) + + // ExitReference_model_name is called when exiting the reference_model_name production. + ExitReference_model_name(c *Reference_model_nameContext) + + // ExitMain_model_name is called when exiting the main_model_name production. + ExitMain_model_name(c *Main_model_nameContext) + + // ExitContainer_tableview_name is called when exiting the container_tableview_name production. + ExitContainer_tableview_name(c *Container_tableview_nameContext) + + // ExitAggregate_function_name is called when exiting the aggregate_function_name production. + ExitAggregate_function_name(c *Aggregate_function_nameContext) + + // ExitQuery_name is called when exiting the query_name production. + ExitQuery_name(c *Query_nameContext) + + // ExitGrantee_name is called when exiting the grantee_name production. + ExitGrantee_name(c *Grantee_nameContext) + + // ExitRole_name is called when exiting the role_name production. + ExitRole_name(c *Role_nameContext) + + // ExitConstraint_name is called when exiting the constraint_name production. + ExitConstraint_name(c *Constraint_nameContext) + + // ExitLabel_name is called when exiting the label_name production. + ExitLabel_name(c *Label_nameContext) + + // ExitType_name is called when exiting the type_name production. + ExitType_name(c *Type_nameContext) + + // ExitSequence_name is called when exiting the sequence_name production. + ExitSequence_name(c *Sequence_nameContext) + + // ExitException_name is called when exiting the exception_name production. + ExitException_name(c *Exception_nameContext) + + // ExitFunction_name is called when exiting the function_name production. + ExitFunction_name(c *Function_nameContext) + + // ExitProcedure_name is called when exiting the procedure_name production. + ExitProcedure_name(c *Procedure_nameContext) + + // ExitTrigger_name is called when exiting the trigger_name production. + ExitTrigger_name(c *Trigger_nameContext) + + // ExitVariable_name is called when exiting the variable_name production. + ExitVariable_name(c *Variable_nameContext) + + // ExitIndex_name is called when exiting the index_name production. + ExitIndex_name(c *Index_nameContext) + + // ExitCursor_name is called when exiting the cursor_name production. + ExitCursor_name(c *Cursor_nameContext) + + // ExitRecord_name is called when exiting the record_name production. + ExitRecord_name(c *Record_nameContext) + + // ExitCollection_name is called when exiting the collection_name production. + ExitCollection_name(c *Collection_nameContext) + + // ExitLink_name is called when exiting the link_name production. + ExitLink_name(c *Link_nameContext) + + // ExitColumn_name is called when exiting the column_name production. + ExitColumn_name(c *Column_nameContext) + + // ExitTableview_name is called when exiting the tableview_name production. + ExitTableview_name(c *Tableview_nameContext) + + // ExitXmltable is called when exiting the xmltable production. + ExitXmltable(c *XmltableContext) + + // ExitChar_set_name is called when exiting the char_set_name production. + ExitChar_set_name(c *Char_set_nameContext) + + // ExitSynonym_name is called when exiting the synonym_name production. + ExitSynonym_name(c *Synonym_nameContext) + + // ExitSchema_object_name is called when exiting the schema_object_name production. + ExitSchema_object_name(c *Schema_object_nameContext) + + // ExitDir_object_name is called when exiting the dir_object_name production. + ExitDir_object_name(c *Dir_object_nameContext) + + // ExitUser_object_name is called when exiting the user_object_name production. + ExitUser_object_name(c *User_object_nameContext) + + // ExitGrant_object_name is called when exiting the grant_object_name production. + ExitGrant_object_name(c *Grant_object_nameContext) + + // ExitColumn_list is called when exiting the column_list production. + ExitColumn_list(c *Column_listContext) + + // ExitParen_column_list is called when exiting the paren_column_list production. + ExitParen_column_list(c *Paren_column_listContext) + + // ExitKeep_clause is called when exiting the keep_clause production. + ExitKeep_clause(c *Keep_clauseContext) + + // ExitFunction_argument is called when exiting the function_argument production. + ExitFunction_argument(c *Function_argumentContext) + + // ExitFunction_argument_analytic is called when exiting the function_argument_analytic production. + ExitFunction_argument_analytic(c *Function_argument_analyticContext) + + // ExitFunction_argument_modeling is called when exiting the function_argument_modeling production. + ExitFunction_argument_modeling(c *Function_argument_modelingContext) + + // ExitRespect_or_ignore_nulls is called when exiting the respect_or_ignore_nulls production. + ExitRespect_or_ignore_nulls(c *Respect_or_ignore_nullsContext) + + // ExitArgument is called when exiting the argument production. + ExitArgument(c *ArgumentContext) + + // ExitType_spec is called when exiting the type_spec production. + ExitType_spec(c *Type_specContext) + + // ExitDatatype is called when exiting the datatype production. + ExitDatatype(c *DatatypeContext) + + // ExitPrecision_part is called when exiting the precision_part production. + ExitPrecision_part(c *Precision_partContext) + + // ExitNative_datatype_element is called when exiting the native_datatype_element production. + ExitNative_datatype_element(c *Native_datatype_elementContext) + + // ExitBind_variable is called when exiting the bind_variable production. + ExitBind_variable(c *Bind_variableContext) + + // ExitGeneral_element is called when exiting the general_element production. + ExitGeneral_element(c *General_elementContext) + + // ExitGeneral_element_part is called when exiting the general_element_part production. + ExitGeneral_element_part(c *General_element_partContext) + + // ExitTable_element is called when exiting the table_element production. + ExitTable_element(c *Table_elementContext) + + // ExitObject_privilege is called when exiting the object_privilege production. + ExitObject_privilege(c *Object_privilegeContext) + + // ExitSystem_privilege is called when exiting the system_privilege production. + ExitSystem_privilege(c *System_privilegeContext) + + // ExitConstant is called when exiting the constant production. + ExitConstant(c *ConstantContext) + + // ExitConstant_without_variable is called when exiting the constant_without_variable production. + ExitConstant_without_variable(c *Constant_without_variableContext) + + // ExitNumeric is called when exiting the numeric production. + ExitNumeric(c *NumericContext) + + // ExitNumeric_negative is called when exiting the numeric_negative production. + ExitNumeric_negative(c *Numeric_negativeContext) + + // ExitQuoted_string is called when exiting the quoted_string production. + ExitQuoted_string(c *Quoted_stringContext) + + // ExitChar_str is called when exiting the char_str production. + ExitChar_str(c *Char_strContext) + + // ExitIdentifier is called when exiting the identifier production. + ExitIdentifier(c *IdentifierContext) + + // ExitId_expression is called when exiting the id_expression production. + ExitId_expression(c *Id_expressionContext) + + // ExitOuter_join_sign is called when exiting the outer_join_sign production. + ExitOuter_join_sign(c *Outer_join_signContext) + + // ExitRegular_id is called when exiting the regular_id production. + ExitRegular_id(c *Regular_idContext) + + // ExitNon_reserved_keywords_in_12c is called when exiting the non_reserved_keywords_in_12c production. + ExitNon_reserved_keywords_in_12c(c *Non_reserved_keywords_in_12cContext) + + // ExitNon_reserved_keywords_pre12c is called when exiting the non_reserved_keywords_pre12c production. + ExitNon_reserved_keywords_pre12c(c *Non_reserved_keywords_pre12cContext) + + // ExitString_function_name is called when exiting the string_function_name production. + ExitString_function_name(c *String_function_nameContext) + + // ExitNumeric_function_name is called when exiting the numeric_function_name production. + ExitNumeric_function_name(c *Numeric_function_nameContext) +} diff --git a/plsql/plsqlparser_visitor.go b/plsql/plsqlparser_visitor.go new file mode 100644 index 0000000..76173af --- /dev/null +++ b/plsql/plsqlparser_visitor.go @@ -0,0 +1,3603 @@ +// Code generated from PlSqlParser.g4 by ANTLR 4.13.2. DO NOT EDIT. + +package plsql // PlSqlParser +import "github.com/antlr4-go/antlr/v4" + +// A complete Visitor for a parse tree produced by PlSqlParser. +type PlSqlParserVisitor interface { + antlr.ParseTreeVisitor + + // Visit a parse tree produced by PlSqlParser#sql_script. + VisitSql_script(ctx *Sql_scriptContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unit_statement. + VisitUnit_statement(ctx *Unit_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_diskgroup. + VisitAlter_diskgroup(ctx *Alter_diskgroupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_disk_clause. + VisitAdd_disk_clause(ctx *Add_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_disk_clause. + VisitDrop_disk_clause(ctx *Drop_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#resize_disk_clause. + VisitResize_disk_clause(ctx *Resize_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#replace_disk_clause. + VisitReplace_disk_clause(ctx *Replace_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#wait_nowait. + VisitWait_nowait(ctx *Wait_nowaitContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rename_disk_clause. + VisitRename_disk_clause(ctx *Rename_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disk_online_clause. + VisitDisk_online_clause(ctx *Disk_online_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disk_offline_clause. + VisitDisk_offline_clause(ctx *Disk_offline_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#timeout_clause. + VisitTimeout_clause(ctx *Timeout_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rebalance_diskgroup_clause. + VisitRebalance_diskgroup_clause(ctx *Rebalance_diskgroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#phase. + VisitPhase(ctx *PhaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#check_diskgroup_clause. + VisitCheck_diskgroup_clause(ctx *Check_diskgroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_template_clauses. + VisitDiskgroup_template_clauses(ctx *Diskgroup_template_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#qualified_template_clause. + VisitQualified_template_clause(ctx *Qualified_template_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#redundancy_clause. + VisitRedundancy_clause(ctx *Redundancy_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#striping_clause. + VisitStriping_clause(ctx *Striping_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#force_noforce. + VisitForce_noforce(ctx *Force_noforceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_directory_clauses. + VisitDiskgroup_directory_clauses(ctx *Diskgroup_directory_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dir_name. + VisitDir_name(ctx *Dir_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_alias_clauses. + VisitDiskgroup_alias_clauses(ctx *Diskgroup_alias_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_volume_clauses. + VisitDiskgroup_volume_clauses(ctx *Diskgroup_volume_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_volume_clause. + VisitAdd_volume_clause(ctx *Add_volume_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_volume_clause. + VisitModify_volume_clause(ctx *Modify_volume_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_attributes. + VisitDiskgroup_attributes(ctx *Diskgroup_attributesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_diskgroup_file. + VisitModify_diskgroup_file(ctx *Modify_diskgroup_fileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disk_region_clause. + VisitDisk_region_clause(ctx *Disk_region_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_diskgroup_file_clause. + VisitDrop_diskgroup_file_clause(ctx *Drop_diskgroup_file_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#convert_redundancy_clause. + VisitConvert_redundancy_clause(ctx *Convert_redundancy_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#usergroup_clauses. + VisitUsergroup_clauses(ctx *Usergroup_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_clauses. + VisitUser_clauses(ctx *User_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_permissions_clause. + VisitFile_permissions_clause(ctx *File_permissions_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_owner_clause. + VisitFile_owner_clause(ctx *File_owner_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#scrub_clause. + VisitScrub_clause(ctx *Scrub_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quotagroup_clauses. + VisitQuotagroup_clauses(ctx *Quotagroup_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#property_name. + VisitProperty_name(ctx *Property_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#property_value. + VisitProperty_value(ctx *Property_valueContext) interface{} + + // Visit a parse tree produced by PlSqlParser#filegroup_clauses. + VisitFilegroup_clauses(ctx *Filegroup_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_filegroup_clause. + VisitAdd_filegroup_clause(ctx *Add_filegroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_filegroup_clause. + VisitModify_filegroup_clause(ctx *Modify_filegroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#move_to_filegroup_clause. + VisitMove_to_filegroup_clause(ctx *Move_to_filegroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_filegroup_clause. + VisitDrop_filegroup_clause(ctx *Drop_filegroup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quorum_regular. + VisitQuorum_regular(ctx *Quorum_regularContext) interface{} + + // Visit a parse tree produced by PlSqlParser#undrop_disk_clause. + VisitUndrop_disk_clause(ctx *Undrop_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#diskgroup_availability. + VisitDiskgroup_availability(ctx *Diskgroup_availabilityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#enable_disable_volume. + VisitEnable_disable_volume(ctx *Enable_disable_volumeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_function. + VisitDrop_function(ctx *Drop_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_flashback_archive. + VisitAlter_flashback_archive(ctx *Alter_flashback_archiveContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_hierarchy. + VisitAlter_hierarchy(ctx *Alter_hierarchyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_function. + VisitAlter_function(ctx *Alter_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_java. + VisitAlter_java(ctx *Alter_javaContext) interface{} + + // Visit a parse tree produced by PlSqlParser#match_string. + VisitMatch_string(ctx *Match_stringContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_function_body. + VisitCreate_function_body(ctx *Create_function_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sql_macro_body. + VisitSql_macro_body(ctx *Sql_macro_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parallel_enable_clause. + VisitParallel_enable_clause(ctx *Parallel_enable_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_by_clause. + VisitPartition_by_clause(ctx *Partition_by_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#result_cache_clause. + VisitResult_cache_clause(ctx *Result_cache_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#relies_on_part. + VisitRelies_on_part(ctx *Relies_on_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#streaming_clause. + VisitStreaming_clause(ctx *Streaming_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_outline. + VisitAlter_outline(ctx *Alter_outlineContext) interface{} + + // Visit a parse tree produced by PlSqlParser#outline_options. + VisitOutline_options(ctx *Outline_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_lockdown_profile. + VisitAlter_lockdown_profile(ctx *Alter_lockdown_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lockdown_feature. + VisitLockdown_feature(ctx *Lockdown_featureContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lockdown_options. + VisitLockdown_options(ctx *Lockdown_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lockdown_statements. + VisitLockdown_statements(ctx *Lockdown_statementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#statement_clauses. + VisitStatement_clauses(ctx *Statement_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#clause_options. + VisitClause_options(ctx *Clause_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#option_values. + VisitOption_values(ctx *Option_valuesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#string_list. + VisitString_list(ctx *String_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disable_enable. + VisitDisable_enable(ctx *Disable_enableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_lockdown_profile. + VisitDrop_lockdown_profile(ctx *Drop_lockdown_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_package. + VisitDrop_package(ctx *Drop_packageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_package. + VisitAlter_package(ctx *Alter_packageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_package. + VisitCreate_package(ctx *Create_packageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_package_body. + VisitCreate_package_body(ctx *Create_package_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#package_obj_spec. + VisitPackage_obj_spec(ctx *Package_obj_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#procedure_spec. + VisitProcedure_spec(ctx *Procedure_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_spec. + VisitFunction_spec(ctx *Function_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#package_obj_body. + VisitPackage_obj_body(ctx *Package_obj_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_pmem_filestore. + VisitAlter_pmem_filestore(ctx *Alter_pmem_filestoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_pmem_filestore. + VisitDrop_pmem_filestore(ctx *Drop_pmem_filestoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_procedure. + VisitDrop_procedure(ctx *Drop_procedureContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_procedure. + VisitAlter_procedure(ctx *Alter_procedureContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_body. + VisitFunction_body(ctx *Function_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#procedure_body. + VisitProcedure_body(ctx *Procedure_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_procedure_body. + VisitCreate_procedure_body(ctx *Create_procedure_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_resource_cost. + VisitAlter_resource_cost(ctx *Alter_resource_costContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_outline. + VisitDrop_outline(ctx *Drop_outlineContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_rollback_segment. + VisitAlter_rollback_segment(ctx *Alter_rollback_segmentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_restore_point. + VisitDrop_restore_point(ctx *Drop_restore_pointContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_rollback_segment. + VisitDrop_rollback_segment(ctx *Drop_rollback_segmentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_role. + VisitDrop_role(ctx *Drop_roleContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_pmem_filestore. + VisitCreate_pmem_filestore(ctx *Create_pmem_filestoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pmem_filestore_options. + VisitPmem_filestore_options(ctx *Pmem_filestore_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_path. + VisitFile_path(ctx *File_pathContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_rollback_segment. + VisitCreate_rollback_segment(ctx *Create_rollback_segmentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_trigger. + VisitDrop_trigger(ctx *Drop_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_trigger. + VisitAlter_trigger(ctx *Alter_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_trigger. + VisitCreate_trigger(ctx *Create_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trigger_follows_clause. + VisitTrigger_follows_clause(ctx *Trigger_follows_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trigger_when_clause. + VisitTrigger_when_clause(ctx *Trigger_when_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#simple_dml_trigger. + VisitSimple_dml_trigger(ctx *Simple_dml_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#for_each_row. + VisitFor_each_row(ctx *For_each_rowContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compound_dml_trigger. + VisitCompound_dml_trigger(ctx *Compound_dml_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#non_dml_trigger. + VisitNon_dml_trigger(ctx *Non_dml_triggerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trigger_body. + VisitTrigger_body(ctx *Trigger_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#routine_clause. + VisitRoutine_clause(ctx *Routine_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compound_trigger_block. + VisitCompound_trigger_block(ctx *Compound_trigger_blockContext) interface{} + + // Visit a parse tree produced by PlSqlParser#timing_point_section. + VisitTiming_point_section(ctx *Timing_point_sectionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#non_dml_event. + VisitNon_dml_event(ctx *Non_dml_eventContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dml_event_clause. + VisitDml_event_clause(ctx *Dml_event_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dml_event_element. + VisitDml_event_element(ctx *Dml_event_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dml_event_nested_clause. + VisitDml_event_nested_clause(ctx *Dml_event_nested_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#referencing_clause. + VisitReferencing_clause(ctx *Referencing_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#referencing_element. + VisitReferencing_element(ctx *Referencing_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_type. + VisitDrop_type(ctx *Drop_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_type. + VisitAlter_type(ctx *Alter_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compile_type_clause. + VisitCompile_type_clause(ctx *Compile_type_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#replace_type_clause. + VisitReplace_type_clause(ctx *Replace_type_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_method_spec. + VisitAlter_method_spec(ctx *Alter_method_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_method_element. + VisitAlter_method_element(ctx *Alter_method_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_attribute_definition. + VisitAlter_attribute_definition(ctx *Alter_attribute_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#attribute_definition. + VisitAttribute_definition(ctx *Attribute_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_collection_clauses. + VisitAlter_collection_clauses(ctx *Alter_collection_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dependent_handling_clause. + VisitDependent_handling_clause(ctx *Dependent_handling_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dependent_exceptions_part. + VisitDependent_exceptions_part(ctx *Dependent_exceptions_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_type. + VisitCreate_type(ctx *Create_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_definition. + VisitType_definition(ctx *Type_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_type_def. + VisitObject_type_def(ctx *Object_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_as_part. + VisitObject_as_part(ctx *Object_as_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_under_part. + VisitObject_under_part(ctx *Object_under_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#nested_table_type_def. + VisitNested_table_type_def(ctx *Nested_table_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sqlj_object_type. + VisitSqlj_object_type(ctx *Sqlj_object_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_body. + VisitType_body(ctx *Type_bodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_body_elements. + VisitType_body_elements(ctx *Type_body_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#map_order_func_declaration. + VisitMap_order_func_declaration(ctx *Map_order_func_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subprog_decl_in_type. + VisitSubprog_decl_in_type(ctx *Subprog_decl_in_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#proc_decl_in_type. + VisitProc_decl_in_type(ctx *Proc_decl_in_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#func_decl_in_type. + VisitFunc_decl_in_type(ctx *Func_decl_in_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constructor_declaration. + VisitConstructor_declaration(ctx *Constructor_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modifier_clause. + VisitModifier_clause(ctx *Modifier_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_member_spec. + VisitObject_member_spec(ctx *Object_member_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sqlj_object_type_attr. + VisitSqlj_object_type_attr(ctx *Sqlj_object_type_attrContext) interface{} + + // Visit a parse tree produced by PlSqlParser#element_spec. + VisitElement_spec(ctx *Element_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#element_spec_options. + VisitElement_spec_options(ctx *Element_spec_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subprogram_spec. + VisitSubprogram_spec(ctx *Subprogram_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#overriding_subprogram_spec. + VisitOverriding_subprogram_spec(ctx *Overriding_subprogram_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#overriding_function_spec. + VisitOverriding_function_spec(ctx *Overriding_function_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_procedure_spec. + VisitType_procedure_spec(ctx *Type_procedure_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_function_spec. + VisitType_function_spec(ctx *Type_function_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constructor_spec. + VisitConstructor_spec(ctx *Constructor_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#map_order_function_spec. + VisitMap_order_function_spec(ctx *Map_order_function_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pragma_clause. + VisitPragma_clause(ctx *Pragma_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pragma_elements. + VisitPragma_elements(ctx *Pragma_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_elements_parameter. + VisitType_elements_parameter(ctx *Type_elements_parameterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_sequence. + VisitDrop_sequence(ctx *Drop_sequenceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_sequence. + VisitAlter_sequence(ctx *Alter_sequenceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_session. + VisitAlter_session(ctx *Alter_sessionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_session_set_clause. + VisitAlter_session_set_clause(ctx *Alter_session_set_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_sequence. + VisitCreate_sequence(ctx *Create_sequenceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sequence_spec. + VisitSequence_spec(ctx *Sequence_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sequence_start_clause. + VisitSequence_start_clause(ctx *Sequence_start_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_analytic_view. + VisitCreate_analytic_view(ctx *Create_analytic_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#classification_clause. + VisitClassification_clause(ctx *Classification_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#caption_clause. + VisitCaption_clause(ctx *Caption_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#description_clause. + VisitDescription_clause(ctx *Description_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#classification_item. + VisitClassification_item(ctx *Classification_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#language. + VisitLanguage(ctx *LanguageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cav_using_clause. + VisitCav_using_clause(ctx *Cav_using_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dim_by_clause. + VisitDim_by_clause(ctx *Dim_by_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dim_key. + VisitDim_key(ctx *Dim_keyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dim_ref. + VisitDim_ref(ctx *Dim_refContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hier_ref. + VisitHier_ref(ctx *Hier_refContext) interface{} + + // Visit a parse tree produced by PlSqlParser#measures_clause. + VisitMeasures_clause(ctx *Measures_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#av_measure. + VisitAv_measure(ctx *Av_measureContext) interface{} + + // Visit a parse tree produced by PlSqlParser#base_meas_clause. + VisitBase_meas_clause(ctx *Base_meas_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#meas_aggregate_clause. + VisitMeas_aggregate_clause(ctx *Meas_aggregate_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#calc_meas_clause. + VisitCalc_meas_clause(ctx *Calc_meas_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_measure_clause. + VisitDefault_measure_clause(ctx *Default_measure_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_aggregate_clause. + VisitDefault_aggregate_clause(ctx *Default_aggregate_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cache_clause. + VisitCache_clause(ctx *Cache_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cache_specification. + VisitCache_specification(ctx *Cache_specificationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#levels_clause. + VisitLevels_clause(ctx *Levels_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#level_specification. + VisitLevel_specification(ctx *Level_specificationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#level_group_type. + VisitLevel_group_type(ctx *Level_group_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#fact_columns_clause. + VisitFact_columns_clause(ctx *Fact_columns_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#qry_transform_clause. + VisitQry_transform_clause(ctx *Qry_transform_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_attribute_dimension. + VisitCreate_attribute_dimension(ctx *Create_attribute_dimensionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ad_using_clause. + VisitAd_using_clause(ctx *Ad_using_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#source_clause. + VisitSource_clause(ctx *Source_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_path_clause. + VisitJoin_path_clause(ctx *Join_path_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_condition. + VisitJoin_condition(ctx *Join_conditionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_condition_item. + VisitJoin_condition_item(ctx *Join_condition_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#attributes_clause. + VisitAttributes_clause(ctx *Attributes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ad_attributes_clause. + VisitAd_attributes_clause(ctx *Ad_attributes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ad_level_clause. + VisitAd_level_clause(ctx *Ad_level_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#key_clause. + VisitKey_clause(ctx *Key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alternate_key_clause. + VisitAlternate_key_clause(ctx *Alternate_key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dim_order_clause. + VisitDim_order_clause(ctx *Dim_order_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#all_clause. + VisitAll_clause(ctx *All_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_audit_policy. + VisitCreate_audit_policy(ctx *Create_audit_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#privilege_audit_clause. + VisitPrivilege_audit_clause(ctx *Privilege_audit_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#action_audit_clause. + VisitAction_audit_clause(ctx *Action_audit_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#standard_actions. + VisitStandard_actions(ctx *Standard_actionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#actions_clause. + VisitActions_clause(ctx *Actions_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_action. + VisitObject_action(ctx *Object_actionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#system_action. + VisitSystem_action(ctx *System_actionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#component_actions. + VisitComponent_actions(ctx *Component_actionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#component_action. + VisitComponent_action(ctx *Component_actionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#role_audit_clause. + VisitRole_audit_clause(ctx *Role_audit_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_controlfile. + VisitCreate_controlfile(ctx *Create_controlfileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#controlfile_options. + VisitControlfile_options(ctx *Controlfile_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logfile_clause. + VisitLogfile_clause(ctx *Logfile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#character_set_clause. + VisitCharacter_set_clause(ctx *Character_set_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_specification. + VisitFile_specification(ctx *File_specificationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_diskgroup. + VisitCreate_diskgroup(ctx *Create_diskgroupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#qualified_disk_clause. + VisitQualified_disk_clause(ctx *Qualified_disk_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_edition. + VisitCreate_edition(ctx *Create_editionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_flashback_archive. + VisitCreate_flashback_archive(ctx *Create_flashback_archiveContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_archive_quota. + VisitFlashback_archive_quota(ctx *Flashback_archive_quotaContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_archive_retention. + VisitFlashback_archive_retention(ctx *Flashback_archive_retentionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_hierarchy. + VisitCreate_hierarchy(ctx *Create_hierarchyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hier_using_clause. + VisitHier_using_clause(ctx *Hier_using_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#level_hier_clause. + VisitLevel_hier_clause(ctx *Level_hier_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hier_attrs_clause. + VisitHier_attrs_clause(ctx *Hier_attrs_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hier_attr_clause. + VisitHier_attr_clause(ctx *Hier_attr_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hier_attr_name. + VisitHier_attr_name(ctx *Hier_attr_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_index. + VisitCreate_index(ctx *Create_indexContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cluster_index_clause. + VisitCluster_index_clause(ctx *Cluster_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cluster_name. + VisitCluster_name(ctx *Cluster_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_index_clause. + VisitTable_index_clause(ctx *Table_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#bitmap_join_index_clause. + VisitBitmap_join_index_clause(ctx *Bitmap_join_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_expr_option. + VisitIndex_expr_option(ctx *Index_expr_optionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_expr. + VisitIndex_expr(ctx *Index_exprContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_properties. + VisitIndex_properties(ctx *Index_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#domain_index_clause. + VisitDomain_index_clause(ctx *Domain_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#local_domain_index_clause. + VisitLocal_domain_index_clause(ctx *Local_domain_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlindex_clause. + VisitXmlindex_clause(ctx *Xmlindex_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#local_xmlindex_clause. + VisitLocal_xmlindex_clause(ctx *Local_xmlindex_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#global_partitioned_index. + VisitGlobal_partitioned_index(ctx *Global_partitioned_indexContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_partitioning_clause. + VisitIndex_partitioning_clause(ctx *Index_partitioning_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#local_partitioned_index. + VisitLocal_partitioned_index(ctx *Local_partitioned_indexContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_range_partitioned_table. + VisitOn_range_partitioned_table(ctx *On_range_partitioned_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_list_partitioned_table. + VisitOn_list_partitioned_table(ctx *On_list_partitioned_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partitioned_table. + VisitPartitioned_table(ctx *Partitioned_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_hash_partitioned_table. + VisitOn_hash_partitioned_table(ctx *On_hash_partitioned_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_hash_partitioned_clause. + VisitOn_hash_partitioned_clause(ctx *On_hash_partitioned_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_comp_partitioned_table. + VisitOn_comp_partitioned_table(ctx *On_comp_partitioned_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_comp_partitioned_clause. + VisitOn_comp_partitioned_clause(ctx *On_comp_partitioned_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_subpartition_clause. + VisitIndex_subpartition_clause(ctx *Index_subpartition_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_subpartition_subclause. + VisitIndex_subpartition_subclause(ctx *Index_subpartition_subclauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#odci_parameters. + VisitOdci_parameters(ctx *Odci_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#indextype. + VisitIndextype(ctx *IndextypeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_index. + VisitAlter_index(ctx *Alter_indexContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_index_ops_set1. + VisitAlter_index_ops_set1(ctx *Alter_index_ops_set1Context) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_index_ops_set2. + VisitAlter_index_ops_set2(ctx *Alter_index_ops_set2Context) interface{} + + // Visit a parse tree produced by PlSqlParser#visible_or_invisible. + VisitVisible_or_invisible(ctx *Visible_or_invisibleContext) interface{} + + // Visit a parse tree produced by PlSqlParser#monitoring_nomonitoring. + VisitMonitoring_nomonitoring(ctx *Monitoring_nomonitoringContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rebuild_clause. + VisitRebuild_clause(ctx *Rebuild_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_index_partitioning. + VisitAlter_index_partitioning(ctx *Alter_index_partitioningContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_index_default_attrs. + VisitModify_index_default_attrs(ctx *Modify_index_default_attrsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_hash_index_partition. + VisitAdd_hash_index_partition(ctx *Add_hash_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#coalesce_index_partition. + VisitCoalesce_index_partition(ctx *Coalesce_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_index_partition. + VisitModify_index_partition(ctx *Modify_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_index_partitions_ops. + VisitModify_index_partitions_ops(ctx *Modify_index_partitions_opsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rename_index_partition. + VisitRename_index_partition(ctx *Rename_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_index_partition. + VisitDrop_index_partition(ctx *Drop_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#split_index_partition. + VisitSplit_index_partition(ctx *Split_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_partition_description. + VisitIndex_partition_description(ctx *Index_partition_descriptionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_index_subpartition. + VisitModify_index_subpartition(ctx *Modify_index_subpartitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_name_old. + VisitPartition_name_old(ctx *Partition_name_oldContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_partition_name. + VisitNew_partition_name(ctx *New_partition_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_index_name. + VisitNew_index_name(ctx *New_index_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_inmemory_join_group. + VisitAlter_inmemory_join_group(ctx *Alter_inmemory_join_groupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_user. + VisitCreate_user(ctx *Create_userContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_user. + VisitAlter_user(ctx *Alter_userContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_user. + VisitDrop_user(ctx *Drop_userContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_identified_by. + VisitAlter_identified_by(ctx *Alter_identified_byContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identified_by. + VisitIdentified_by(ctx *Identified_byContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identified_other_clause. + VisitIdentified_other_clause(ctx *Identified_other_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_tablespace_clause. + VisitUser_tablespace_clause(ctx *User_tablespace_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quota_clause. + VisitQuota_clause(ctx *Quota_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#profile_clause. + VisitProfile_clause(ctx *Profile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#role_clause. + VisitRole_clause(ctx *Role_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_default_role_clause. + VisitUser_default_role_clause(ctx *User_default_role_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#password_expire_clause. + VisitPassword_expire_clause(ctx *Password_expire_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_lock_clause. + VisitUser_lock_clause(ctx *User_lock_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_editions_clause. + VisitUser_editions_clause(ctx *User_editions_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_user_editions_clause. + VisitAlter_user_editions_clause(ctx *Alter_user_editions_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#proxy_clause. + VisitProxy_clause(ctx *Proxy_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#container_names. + VisitContainer_names(ctx *Container_namesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_container_data. + VisitSet_container_data(ctx *Set_container_dataContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_rem_container_data. + VisitAdd_rem_container_data(ctx *Add_rem_container_dataContext) interface{} + + // Visit a parse tree produced by PlSqlParser#container_data_clause. + VisitContainer_data_clause(ctx *Container_data_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#administer_key_management. + VisitAdminister_key_management(ctx *Administer_key_managementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#keystore_management_clauses. + VisitKeystore_management_clauses(ctx *Keystore_management_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_keystore. + VisitCreate_keystore(ctx *Create_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#open_keystore. + VisitOpen_keystore(ctx *Open_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#force_keystore. + VisitForce_keystore(ctx *Force_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#close_keystore. + VisitClose_keystore(ctx *Close_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#backup_keystore. + VisitBackup_keystore(ctx *Backup_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_keystore_password. + VisitAlter_keystore_password(ctx *Alter_keystore_passwordContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_into_new_keystore. + VisitMerge_into_new_keystore(ctx *Merge_into_new_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_into_existing_keystore. + VisitMerge_into_existing_keystore(ctx *Merge_into_existing_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#isolate_keystore. + VisitIsolate_keystore(ctx *Isolate_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unite_keystore. + VisitUnite_keystore(ctx *Unite_keystoreContext) interface{} + + // Visit a parse tree produced by PlSqlParser#key_management_clauses. + VisitKey_management_clauses(ctx *Key_management_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_key. + VisitSet_key(ctx *Set_keyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_key. + VisitCreate_key(ctx *Create_keyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mkid. + VisitMkid(ctx *MkidContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mk. + VisitMk(ctx *MkContext) interface{} + + // Visit a parse tree produced by PlSqlParser#use_key. + VisitUse_key(ctx *Use_keyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_key_tag. + VisitSet_key_tag(ctx *Set_key_tagContext) interface{} + + // Visit a parse tree produced by PlSqlParser#export_keys. + VisitExport_keys(ctx *Export_keysContext) interface{} + + // Visit a parse tree produced by PlSqlParser#import_keys. + VisitImport_keys(ctx *Import_keysContext) interface{} + + // Visit a parse tree produced by PlSqlParser#migrate_keys. + VisitMigrate_keys(ctx *Migrate_keysContext) interface{} + + // Visit a parse tree produced by PlSqlParser#reverse_migrate_keys. + VisitReverse_migrate_keys(ctx *Reverse_migrate_keysContext) interface{} + + // Visit a parse tree produced by PlSqlParser#move_keys. + VisitMove_keys(ctx *Move_keysContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identified_by_store. + VisitIdentified_by_store(ctx *Identified_by_storeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_algorithm_clause. + VisitUsing_algorithm_clause(ctx *Using_algorithm_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_tag_clause. + VisitUsing_tag_clause(ctx *Using_tag_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#secret_management_clauses. + VisitSecret_management_clauses(ctx *Secret_management_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_update_secret. + VisitAdd_update_secret(ctx *Add_update_secretContext) interface{} + + // Visit a parse tree produced by PlSqlParser#delete_secret. + VisitDelete_secret(ctx *Delete_secretContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_update_secret_seps. + VisitAdd_update_secret_seps(ctx *Add_update_secret_sepsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#delete_secret_seps. + VisitDelete_secret_seps(ctx *Delete_secret_sepsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#zero_downtime_software_patching_clauses. + VisitZero_downtime_software_patching_clauses(ctx *Zero_downtime_software_patching_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#with_backup_clause. + VisitWith_backup_clause(ctx *With_backup_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identified_by_password_clause. + VisitIdentified_by_password_clause(ctx *Identified_by_password_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#keystore_password. + VisitKeystore_password(ctx *Keystore_passwordContext) interface{} + + // Visit a parse tree produced by PlSqlParser#path. + VisitPath(ctx *PathContext) interface{} + + // Visit a parse tree produced by PlSqlParser#secret. + VisitSecret(ctx *SecretContext) interface{} + + // Visit a parse tree produced by PlSqlParser#analyze. + VisitAnalyze(ctx *AnalyzeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_extention_clause. + VisitPartition_extention_clause(ctx *Partition_extention_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#validation_clauses. + VisitValidation_clauses(ctx *Validation_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compute_clauses. + VisitCompute_clauses(ctx *Compute_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#for_clause. + VisitFor_clause(ctx *For_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#online_or_offline. + VisitOnline_or_offline(ctx *Online_or_offlineContext) interface{} + + // Visit a parse tree produced by PlSqlParser#into_clause1. + VisitInto_clause1(ctx *Into_clause1Context) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_key_value. + VisitPartition_key_value(ctx *Partition_key_valueContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_key_value. + VisitSubpartition_key_value(ctx *Subpartition_key_valueContext) interface{} + + // Visit a parse tree produced by PlSqlParser#associate_statistics. + VisitAssociate_statistics(ctx *Associate_statisticsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_association. + VisitColumn_association(ctx *Column_associationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_association. + VisitFunction_association(ctx *Function_associationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#indextype_name. + VisitIndextype_name(ctx *Indextype_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_statistics_type. + VisitUsing_statistics_type(ctx *Using_statistics_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#statistics_type_name. + VisitStatistics_type_name(ctx *Statistics_type_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_cost_clause. + VisitDefault_cost_clause(ctx *Default_cost_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cpu_cost. + VisitCpu_cost(ctx *Cpu_costContext) interface{} + + // Visit a parse tree produced by PlSqlParser#io_cost. + VisitIo_cost(ctx *Io_costContext) interface{} + + // Visit a parse tree produced by PlSqlParser#network_cost. + VisitNetwork_cost(ctx *Network_costContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_selectivity_clause. + VisitDefault_selectivity_clause(ctx *Default_selectivity_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_selectivity. + VisitDefault_selectivity(ctx *Default_selectivityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#storage_table_clause. + VisitStorage_table_clause(ctx *Storage_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unified_auditing. + VisitUnified_auditing(ctx *Unified_auditingContext) interface{} + + // Visit a parse tree produced by PlSqlParser#policy_name. + VisitPolicy_name(ctx *Policy_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_traditional. + VisitAudit_traditional(ctx *Audit_traditionalContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_direct_path. + VisitAudit_direct_path(ctx *Audit_direct_pathContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_container_clause. + VisitAudit_container_clause(ctx *Audit_container_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_operation_clause. + VisitAudit_operation_clause(ctx *Audit_operation_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#auditing_by_clause. + VisitAuditing_by_clause(ctx *Auditing_by_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_user. + VisitAudit_user(ctx *Audit_userContext) interface{} + + // Visit a parse tree produced by PlSqlParser#audit_schema_object_clause. + VisitAudit_schema_object_clause(ctx *Audit_schema_object_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sql_operation. + VisitSql_operation(ctx *Sql_operationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#auditing_on_clause. + VisitAuditing_on_clause(ctx *Auditing_on_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_name. + VisitModel_name(ctx *Model_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_name. + VisitObject_name(ctx *Object_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#profile_name. + VisitProfile_name(ctx *Profile_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sql_statement_shortcut. + VisitSql_statement_shortcut(ctx *Sql_statement_shortcutContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_index. + VisitDrop_index(ctx *Drop_indexContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disassociate_statistics. + VisitDisassociate_statistics(ctx *Disassociate_statisticsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_indextype. + VisitDrop_indextype(ctx *Drop_indextypeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_inmemory_join_group. + VisitDrop_inmemory_join_group(ctx *Drop_inmemory_join_groupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_table. + VisitFlashback_table(ctx *Flashback_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#restore_point. + VisitRestore_point(ctx *Restore_pointContext) interface{} + + // Visit a parse tree produced by PlSqlParser#purge_statement. + VisitPurge_statement(ctx *Purge_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#noaudit_statement. + VisitNoaudit_statement(ctx *Noaudit_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rename_object. + VisitRename_object(ctx *Rename_objectContext) interface{} + + // Visit a parse tree produced by PlSqlParser#grant_statement. + VisitGrant_statement(ctx *Grant_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#container_clause. + VisitContainer_clause(ctx *Container_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#revoke_statement. + VisitRevoke_statement(ctx *Revoke_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#revoke_system_privilege. + VisitRevoke_system_privilege(ctx *Revoke_system_privilegeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#revokee_clause. + VisitRevokee_clause(ctx *Revokee_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#revoke_object_privileges. + VisitRevoke_object_privileges(ctx *Revoke_object_privilegesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_object_clause. + VisitOn_object_clause(ctx *On_object_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#revoke_roles_from_programs. + VisitRevoke_roles_from_programs(ctx *Revoke_roles_from_programsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#program_unit. + VisitProgram_unit(ctx *Program_unitContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_dimension. + VisitCreate_dimension(ctx *Create_dimensionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_directory. + VisitCreate_directory(ctx *Create_directoryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#directory_name. + VisitDirectory_name(ctx *Directory_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#directory_path. + VisitDirectory_path(ctx *Directory_pathContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_inmemory_join_group. + VisitCreate_inmemory_join_group(ctx *Create_inmemory_join_groupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_hierarchy. + VisitDrop_hierarchy(ctx *Drop_hierarchyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_library. + VisitAlter_library(ctx *Alter_libraryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_java. + VisitDrop_java(ctx *Drop_javaContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_library. + VisitDrop_library(ctx *Drop_libraryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_java. + VisitCreate_java(ctx *Create_javaContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_library. + VisitCreate_library(ctx *Create_libraryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#plsql_library_source. + VisitPlsql_library_source(ctx *Plsql_library_sourceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#credential_name. + VisitCredential_name(ctx *Credential_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#library_editionable. + VisitLibrary_editionable(ctx *Library_editionableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#library_debug. + VisitLibrary_debug(ctx *Library_debugContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compiler_parameters_clause. + VisitCompiler_parameters_clause(ctx *Compiler_parameters_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parameter_value. + VisitParameter_value(ctx *Parameter_valueContext) interface{} + + // Visit a parse tree produced by PlSqlParser#library_name. + VisitLibrary_name(ctx *Library_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_dimension. + VisitAlter_dimension(ctx *Alter_dimensionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#level_clause. + VisitLevel_clause(ctx *Level_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hierarchy_clause. + VisitHierarchy_clause(ctx *Hierarchy_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dimension_join_clause. + VisitDimension_join_clause(ctx *Dimension_join_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#attribute_clause. + VisitAttribute_clause(ctx *Attribute_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#extended_attribute_clause. + VisitExtended_attribute_clause(ctx *Extended_attribute_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_one_or_more_sub_clause. + VisitColumn_one_or_more_sub_clause(ctx *Column_one_or_more_sub_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_view. + VisitAlter_view(ctx *Alter_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_view_editionable. + VisitAlter_view_editionable(ctx *Alter_view_editionableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_view. + VisitCreate_view(ctx *Create_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#editioning_clause. + VisitEditioning_clause(ctx *Editioning_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#view_options. + VisitView_options(ctx *View_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#view_alias_constraint. + VisitView_alias_constraint(ctx *View_alias_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_view_clause. + VisitObject_view_clause(ctx *Object_view_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inline_constraint. + VisitInline_constraint(ctx *Inline_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inline_ref_constraint. + VisitInline_ref_constraint(ctx *Inline_ref_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#out_of_line_ref_constraint. + VisitOut_of_line_ref_constraint(ctx *Out_of_line_ref_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#out_of_line_constraint. + VisitOut_of_line_constraint(ctx *Out_of_line_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constraint_state. + VisitConstraint_state(ctx *Constraint_stateContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltype_view_clause. + VisitXmltype_view_clause(ctx *Xmltype_view_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_schema_spec. + VisitXml_schema_spec(ctx *Xml_schema_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_schema_url. + VisitXml_schema_url(ctx *Xml_schema_urlContext) interface{} + + // Visit a parse tree produced by PlSqlParser#element. + VisitElement(ctx *ElementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_tablespace. + VisitAlter_tablespace(ctx *Alter_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datafile_tempfile_clauses. + VisitDatafile_tempfile_clauses(ctx *Datafile_tempfile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_logging_clauses. + VisitTablespace_logging_clauses(ctx *Tablespace_logging_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_group_clause. + VisitTablespace_group_clause(ctx *Tablespace_group_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_group_name. + VisitTablespace_group_name(ctx *Tablespace_group_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_state_clauses. + VisitTablespace_state_clauses(ctx *Tablespace_state_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_mode_clause. + VisitFlashback_mode_clause(ctx *Flashback_mode_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_tablespace_name. + VisitNew_tablespace_name(ctx *New_tablespace_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_tablespace. + VisitCreate_tablespace(ctx *Create_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#permanent_tablespace_clause. + VisitPermanent_tablespace_clause(ctx *Permanent_tablespace_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_encryption_spec. + VisitTablespace_encryption_spec(ctx *Tablespace_encryption_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logging_clause. + VisitLogging_clause(ctx *Logging_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#extent_management_clause. + VisitExtent_management_clause(ctx *Extent_management_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#segment_management_clause. + VisitSegment_management_clause(ctx *Segment_management_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#temporary_tablespace_clause. + VisitTemporary_tablespace_clause(ctx *Temporary_tablespace_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#undo_tablespace_clause. + VisitUndo_tablespace_clause(ctx *Undo_tablespace_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_retention_clause. + VisitTablespace_retention_clause(ctx *Tablespace_retention_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_tablespace_set. + VisitCreate_tablespace_set(ctx *Create_tablespace_setContext) interface{} + + // Visit a parse tree produced by PlSqlParser#permanent_tablespace_attrs. + VisitPermanent_tablespace_attrs(ctx *Permanent_tablespace_attrsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_encryption_clause. + VisitTablespace_encryption_clause(ctx *Tablespace_encryption_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_tablespace_params. + VisitDefault_tablespace_params(ctx *Default_tablespace_paramsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_table_compression. + VisitDefault_table_compression(ctx *Default_table_compressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#low_high. + VisitLow_high(ctx *Low_highContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_index_compression. + VisitDefault_index_compression(ctx *Default_index_compressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmmemory_clause. + VisitInmmemory_clause(ctx *Inmmemory_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datafile_specification. + VisitDatafile_specification(ctx *Datafile_specificationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tempfile_specification. + VisitTempfile_specification(ctx *Tempfile_specificationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datafile_tempfile_spec. + VisitDatafile_tempfile_spec(ctx *Datafile_tempfile_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#redo_log_file_spec. + VisitRedo_log_file_spec(ctx *Redo_log_file_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#autoextend_clause. + VisitAutoextend_clause(ctx *Autoextend_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#maxsize_clause. + VisitMaxsize_clause(ctx *Maxsize_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#build_clause. + VisitBuild_clause(ctx *Build_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partial_index_clause. + VisitPartial_index_clause(ctx *Partial_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parallel_clause. + VisitParallel_clause(ctx *Parallel_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_materialized_view. + VisitAlter_materialized_view(ctx *Alter_materialized_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_mv_option1. + VisitAlter_mv_option1(ctx *Alter_mv_option1Context) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_mv_refresh. + VisitAlter_mv_refresh(ctx *Alter_mv_refreshContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rollback_segment. + VisitRollback_segment(ctx *Rollback_segmentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_mv_column_clause. + VisitModify_mv_column_clause(ctx *Modify_mv_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_materialized_view_log. + VisitAlter_materialized_view_log(ctx *Alter_materialized_view_logContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_mv_log_column_clause. + VisitAdd_mv_log_column_clause(ctx *Add_mv_log_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#move_mv_log_clause. + VisitMove_mv_log_clause(ctx *Move_mv_log_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mv_log_augmentation. + VisitMv_log_augmentation(ctx *Mv_log_augmentationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datetime_expr. + VisitDatetime_expr(ctx *Datetime_exprContext) interface{} + + // Visit a parse tree produced by PlSqlParser#interval_expr. + VisitInterval_expr(ctx *Interval_exprContext) interface{} + + // Visit a parse tree produced by PlSqlParser#synchronous_or_asynchronous. + VisitSynchronous_or_asynchronous(ctx *Synchronous_or_asynchronousContext) interface{} + + // Visit a parse tree produced by PlSqlParser#including_or_excluding. + VisitIncluding_or_excluding(ctx *Including_or_excludingContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_materialized_view_log. + VisitCreate_materialized_view_log(ctx *Create_materialized_view_logContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_values_clause. + VisitNew_values_clause(ctx *New_values_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mv_log_purge_clause. + VisitMv_log_purge_clause(ctx *Mv_log_purge_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_materialized_zonemap. + VisitCreate_materialized_zonemap(ctx *Create_materialized_zonemapContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_materialized_zonemap. + VisitAlter_materialized_zonemap(ctx *Alter_materialized_zonemapContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_materialized_zonemap. + VisitDrop_materialized_zonemap(ctx *Drop_materialized_zonemapContext) interface{} + + // Visit a parse tree produced by PlSqlParser#zonemap_refresh_clause. + VisitZonemap_refresh_clause(ctx *Zonemap_refresh_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#zonemap_attributes. + VisitZonemap_attributes(ctx *Zonemap_attributesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#zonemap_name. + VisitZonemap_name(ctx *Zonemap_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#operator_name. + VisitOperator_name(ctx *Operator_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#operator_function_name. + VisitOperator_function_name(ctx *Operator_function_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_zonemap_on_table. + VisitCreate_zonemap_on_table(ctx *Create_zonemap_on_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_zonemap_as_subquery. + VisitCreate_zonemap_as_subquery(ctx *Create_zonemap_as_subqueryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_operator. + VisitAlter_operator(ctx *Alter_operatorContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_operator. + VisitDrop_operator(ctx *Drop_operatorContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_operator. + VisitCreate_operator(ctx *Create_operatorContext) interface{} + + // Visit a parse tree produced by PlSqlParser#binding_clause. + VisitBinding_clause(ctx *Binding_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_binding_clause. + VisitAdd_binding_clause(ctx *Add_binding_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#implementation_clause. + VisitImplementation_clause(ctx *Implementation_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#primary_operator_list. + VisitPrimary_operator_list(ctx *Primary_operator_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#primary_operator_item. + VisitPrimary_operator_item(ctx *Primary_operator_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#operator_context_clause. + VisitOperator_context_clause(ctx *Operator_context_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_function_clause. + VisitUsing_function_clause(ctx *Using_function_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_binding_clause. + VisitDrop_binding_clause(ctx *Drop_binding_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_materialized_view. + VisitCreate_materialized_view(ctx *Create_materialized_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#scoped_table_ref_constraint. + VisitScoped_table_ref_constraint(ctx *Scoped_table_ref_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mv_column_alias. + VisitMv_column_alias(ctx *Mv_column_aliasContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_mv_refresh. + VisitCreate_mv_refresh(ctx *Create_mv_refreshContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_materialized_view. + VisitDrop_materialized_view(ctx *Drop_materialized_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_context. + VisitCreate_context(ctx *Create_contextContext) interface{} + + // Visit a parse tree produced by PlSqlParser#oracle_namespace. + VisitOracle_namespace(ctx *Oracle_namespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_cluster. + VisitCreate_cluster(ctx *Create_clusterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_profile. + VisitCreate_profile(ctx *Create_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#resource_parameters. + VisitResource_parameters(ctx *Resource_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#password_parameters. + VisitPassword_parameters(ctx *Password_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_lockdown_profile. + VisitCreate_lockdown_profile(ctx *Create_lockdown_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#static_base_profile. + VisitStatic_base_profile(ctx *Static_base_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dynamic_base_profile. + VisitDynamic_base_profile(ctx *Dynamic_base_profileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_outline. + VisitCreate_outline(ctx *Create_outlineContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_restore_point. + VisitCreate_restore_point(ctx *Create_restore_pointContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_role. + VisitCreate_role(ctx *Create_roleContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_table. + VisitCreate_table(ctx *Create_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltype_table. + VisitXmltype_table(ctx *Xmltype_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltype_virtual_columns. + VisitXmltype_virtual_columns(ctx *Xmltype_virtual_columnsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltype_column_properties. + VisitXmltype_column_properties(ctx *Xmltype_column_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltype_storage. + VisitXmltype_storage(ctx *Xmltype_storageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlschema_spec. + VisitXmlschema_spec(ctx *Xmlschema_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_table. + VisitObject_table(ctx *Object_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_type. + VisitObject_type(ctx *Object_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#oid_index_clause. + VisitOid_index_clause(ctx *Oid_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#oid_clause. + VisitOid_clause(ctx *Oid_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_properties. + VisitObject_properties(ctx *Object_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_table_substitution. + VisitObject_table_substitution(ctx *Object_table_substitutionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#relational_table. + VisitRelational_table(ctx *Relational_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#immutable_table_clauses. + VisitImmutable_table_clauses(ctx *Immutable_table_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#immutable_table_no_drop_clause. + VisitImmutable_table_no_drop_clause(ctx *Immutable_table_no_drop_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#immutable_table_no_delete_clause. + VisitImmutable_table_no_delete_clause(ctx *Immutable_table_no_delete_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#blockchain_table_clauses. + VisitBlockchain_table_clauses(ctx *Blockchain_table_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#blockchain_drop_table_clause. + VisitBlockchain_drop_table_clause(ctx *Blockchain_drop_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#blockchain_row_retention_clause. + VisitBlockchain_row_retention_clause(ctx *Blockchain_row_retention_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#blockchain_hash_and_data_format_clause. + VisitBlockchain_hash_and_data_format_clause(ctx *Blockchain_hash_and_data_format_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#collation_name. + VisitCollation_name(ctx *Collation_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_properties. + VisitTable_properties(ctx *Table_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#read_only_clause. + VisitRead_only_clause(ctx *Read_only_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#indexing_clause. + VisitIndexing_clause(ctx *Indexing_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#attribute_clustering_clause. + VisitAttribute_clustering_clause(ctx *Attribute_clustering_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#clustering_join. + VisitClustering_join(ctx *Clustering_joinContext) interface{} + + // Visit a parse tree produced by PlSqlParser#clustering_join_item. + VisitClustering_join_item(ctx *Clustering_join_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#equijoin_condition. + VisitEquijoin_condition(ctx *Equijoin_conditionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cluster_clause. + VisitCluster_clause(ctx *Cluster_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#clustering_columns. + VisitClustering_columns(ctx *Clustering_columnsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#clustering_column_group. + VisitClustering_column_group(ctx *Clustering_column_groupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#yes_no. + VisitYes_no(ctx *Yes_noContext) interface{} + + // Visit a parse tree produced by PlSqlParser#zonemap_clause. + VisitZonemap_clause(ctx *Zonemap_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logical_replication_clause. + VisitLogical_replication_clause(ctx *Logical_replication_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_name. + VisitTable_name(ctx *Table_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#relational_property. + VisitRelational_property(ctx *Relational_propertyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_partitioning_clauses. + VisitTable_partitioning_clauses(ctx *Table_partitioning_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#range_partitions. + VisitRange_partitions(ctx *Range_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#list_partitions. + VisitList_partitions(ctx *List_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hash_partitions. + VisitHash_partitions(ctx *Hash_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#individual_hash_partitions. + VisitIndividual_hash_partitions(ctx *Individual_hash_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hash_partitions_by_quantity. + VisitHash_partitions_by_quantity(ctx *Hash_partitions_by_quantityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hash_partition_quantity. + VisitHash_partition_quantity(ctx *Hash_partition_quantityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#composite_range_partitions. + VisitComposite_range_partitions(ctx *Composite_range_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#composite_list_partitions. + VisitComposite_list_partitions(ctx *Composite_list_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#composite_hash_partitions. + VisitComposite_hash_partitions(ctx *Composite_hash_partitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#reference_partitioning. + VisitReference_partitioning(ctx *Reference_partitioningContext) interface{} + + // Visit a parse tree produced by PlSqlParser#reference_partition_desc. + VisitReference_partition_desc(ctx *Reference_partition_descContext) interface{} + + // Visit a parse tree produced by PlSqlParser#system_partitioning. + VisitSystem_partitioning(ctx *System_partitioningContext) interface{} + + // Visit a parse tree produced by PlSqlParser#range_partition_desc. + VisitRange_partition_desc(ctx *Range_partition_descContext) interface{} + + // Visit a parse tree produced by PlSqlParser#list_partition_desc. + VisitList_partition_desc(ctx *List_partition_descContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_template. + VisitSubpartition_template(ctx *Subpartition_templateContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hash_subpartition_quantity. + VisitHash_subpartition_quantity(ctx *Hash_subpartition_quantityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_by_range. + VisitSubpartition_by_range(ctx *Subpartition_by_rangeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_by_list. + VisitSubpartition_by_list(ctx *Subpartition_by_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_by_hash. + VisitSubpartition_by_hash(ctx *Subpartition_by_hashContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_name. + VisitSubpartition_name(ctx *Subpartition_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#range_subpartition_desc. + VisitRange_subpartition_desc(ctx *Range_subpartition_descContext) interface{} + + // Visit a parse tree produced by PlSqlParser#list_subpartition_desc. + VisitList_subpartition_desc(ctx *List_subpartition_descContext) interface{} + + // Visit a parse tree produced by PlSqlParser#individual_hash_subparts. + VisitIndividual_hash_subparts(ctx *Individual_hash_subpartsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hash_subparts_by_quantity. + VisitHash_subparts_by_quantity(ctx *Hash_subparts_by_quantityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#range_values_clause. + VisitRange_values_clause(ctx *Range_values_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#list_values_clause. + VisitList_values_clause(ctx *List_values_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_partition_description. + VisitTable_partition_description(ctx *Table_partition_descriptionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partitioning_storage_clause. + VisitPartitioning_storage_clause(ctx *Partitioning_storage_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_partitioning_storage. + VisitLob_partitioning_storage(ctx *Lob_partitioning_storageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datatype_null_enable. + VisitDatatype_null_enable(ctx *Datatype_null_enableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#size_clause. + VisitSize_clause(ctx *Size_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_compression. + VisitTable_compression(ctx *Table_compressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_table_clause. + VisitInmemory_table_clause(ctx *Inmemory_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_attributes. + VisitInmemory_attributes(ctx *Inmemory_attributesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_memcompress. + VisitInmemory_memcompress(ctx *Inmemory_memcompressContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_priority. + VisitInmemory_priority(ctx *Inmemory_priorityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_distribute. + VisitInmemory_distribute(ctx *Inmemory_distributeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_duplicate. + VisitInmemory_duplicate(ctx *Inmemory_duplicateContext) interface{} + + // Visit a parse tree produced by PlSqlParser#inmemory_column_clause. + VisitInmemory_column_clause(ctx *Inmemory_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#physical_attributes_clause. + VisitPhysical_attributes_clause(ctx *Physical_attributes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#storage_clause. + VisitStorage_clause(ctx *Storage_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#deferred_segment_creation. + VisitDeferred_segment_creation(ctx *Deferred_segment_creationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#segment_attributes_clause. + VisitSegment_attributes_clause(ctx *Segment_attributes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#physical_properties. + VisitPhysical_properties(ctx *Physical_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_clause. + VisitIlm_clause(ctx *Ilm_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_policy_clause. + VisitIlm_policy_clause(ctx *Ilm_policy_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_compression_policy. + VisitIlm_compression_policy(ctx *Ilm_compression_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_tiering_policy. + VisitIlm_tiering_policy(ctx *Ilm_tiering_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_after_on. + VisitIlm_after_on(ctx *Ilm_after_onContext) interface{} + + // Visit a parse tree produced by PlSqlParser#segment_group. + VisitSegment_group(ctx *Segment_groupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_inmemory_policy. + VisitIlm_inmemory_policy(ctx *Ilm_inmemory_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ilm_time_period. + VisitIlm_time_period(ctx *Ilm_time_periodContext) interface{} + + // Visit a parse tree produced by PlSqlParser#heap_org_table_clause. + VisitHeap_org_table_clause(ctx *Heap_org_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#external_table_clause. + VisitExternal_table_clause(ctx *External_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#access_driver_type. + VisitAccess_driver_type(ctx *Access_driver_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#external_table_data_props. + VisitExternal_table_data_props(ctx *External_table_data_propsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#opaque_format_spec. + VisitOpaque_format_spec(ctx *Opaque_format_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#record_format_info. + VisitRecord_format_info(ctx *Record_format_infoContext) interface{} + + // Visit a parse tree produced by PlSqlParser#et_string. + VisitEt_string(ctx *Et_stringContext) interface{} + + // Visit a parse tree produced by PlSqlParser#et_record_spec_options. + VisitEt_record_spec_options(ctx *Et_record_spec_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#et_record_spec_option. + VisitEt_record_spec_option(ctx *Et_record_spec_optionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#et_output_files. + VisitEt_output_files(ctx *Et_output_filesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#et_output_file. + VisitEt_output_file(ctx *Et_output_fileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#directory_spec. + VisitDirectory_spec(ctx *Directory_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_spec. + VisitFile_spec(ctx *File_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_definitions. + VisitField_definitions(ctx *Field_definitionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_options. + VisitField_options(ctx *Field_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_option. + VisitField_option(ctx *Field_optionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_list. + VisitField_list(ctx *Field_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_item. + VisitField_item(ctx *Field_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_name. + VisitField_name(ctx *Field_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pos_spec. + VisitPos_spec(ctx *Pos_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pos_start. + VisitPos_start(ctx *Pos_startContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pos_increment. + VisitPos_increment(ctx *Pos_incrementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pos_end. + VisitPos_end(ctx *Pos_endContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pos_length. + VisitPos_length(ctx *Pos_lengthContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datatype_spec. + VisitDatatype_spec(ctx *Datatype_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#init_spec. + VisitInit_spec(ctx *Init_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lls_clause. + VisitLls_clause(ctx *Lls_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#delim_spec. + VisitDelim_spec(ctx *Delim_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trim_spec. + VisitTrim_spec(ctx *Trim_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_date_format. + VisitField_date_format(ctx *Field_date_formatContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_transforms. + VisitColumn_transforms(ctx *Column_transformsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#transform. + VisitTransform(ctx *TransformContext) interface{} + + // Visit a parse tree produced by PlSqlParser#source_field. + VisitSource_field(ctx *Source_fieldContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lobfile_item. + VisitLobfile_item(ctx *Lobfile_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lobfile_attr_list. + VisitLobfile_attr_list(ctx *Lobfile_attr_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#concat_item. + VisitConcat_item(ctx *Concat_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#row_movement_clause. + VisitRow_movement_clause(ctx *Row_movement_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_archive_clause. + VisitFlashback_archive_clause(ctx *Flashback_archive_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#log_grp. + VisitLog_grp(ctx *Log_grpContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_table_logging. + VisitSupplemental_table_logging(ctx *Supplemental_table_loggingContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_log_grp_clause. + VisitSupplemental_log_grp_clause(ctx *Supplemental_log_grp_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_id_key_clause. + VisitSupplemental_id_key_clause(ctx *Supplemental_id_key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#allocate_extent_clause. + VisitAllocate_extent_clause(ctx *Allocate_extent_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#deallocate_unused_clause. + VisitDeallocate_unused_clause(ctx *Deallocate_unused_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#shrink_clause. + VisitShrink_clause(ctx *Shrink_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#records_per_block_clause. + VisitRecords_per_block_clause(ctx *Records_per_block_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#upgrade_table_clause. + VisitUpgrade_table_clause(ctx *Upgrade_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#truncate_table. + VisitTruncate_table(ctx *Truncate_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_table. + VisitDrop_table(ctx *Drop_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_tablespace. + VisitDrop_tablespace(ctx *Drop_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_tablespace_set. + VisitDrop_tablespace_set(ctx *Drop_tablespace_setContext) interface{} + + // Visit a parse tree produced by PlSqlParser#including_contents_clause. + VisitIncluding_contents_clause(ctx *Including_contents_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_view. + VisitDrop_view(ctx *Drop_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#comment_on_column. + VisitComment_on_column(ctx *Comment_on_columnContext) interface{} + + // Visit a parse tree produced by PlSqlParser#enable_or_disable. + VisitEnable_or_disable(ctx *Enable_or_disableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#allow_or_disallow. + VisitAllow_or_disallow(ctx *Allow_or_disallowContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_synonym. + VisitAlter_synonym(ctx *Alter_synonymContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_synonym. + VisitCreate_synonym(ctx *Create_synonymContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_synonym. + VisitDrop_synonym(ctx *Drop_synonymContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_spfile. + VisitCreate_spfile(ctx *Create_spfileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#spfile_name. + VisitSpfile_name(ctx *Spfile_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pfile_name. + VisitPfile_name(ctx *Pfile_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#comment_on_table. + VisitComment_on_table(ctx *Comment_on_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#comment_on_materialized. + VisitComment_on_materialized(ctx *Comment_on_materializedContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_analytic_view. + VisitAlter_analytic_view(ctx *Alter_analytic_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_add_cache_clause. + VisitAlter_add_cache_clause(ctx *Alter_add_cache_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#levels_item. + VisitLevels_item(ctx *Levels_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#measure_list. + VisitMeasure_list(ctx *Measure_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_drop_cache_clause. + VisitAlter_drop_cache_clause(ctx *Alter_drop_cache_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_attribute_dimension. + VisitAlter_attribute_dimension(ctx *Alter_attribute_dimensionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_audit_policy. + VisitAlter_audit_policy(ctx *Alter_audit_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_cluster. + VisitAlter_cluster(ctx *Alter_clusterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_analytic_view. + VisitDrop_analytic_view(ctx *Drop_analytic_viewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_attribute_dimension. + VisitDrop_attribute_dimension(ctx *Drop_attribute_dimensionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_audit_policy. + VisitDrop_audit_policy(ctx *Drop_audit_policyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_flashback_archive. + VisitDrop_flashback_archive(ctx *Drop_flashback_archiveContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_cluster. + VisitDrop_cluster(ctx *Drop_clusterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_context. + VisitDrop_context(ctx *Drop_contextContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_directory. + VisitDrop_directory(ctx *Drop_directoryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_diskgroup. + VisitDrop_diskgroup(ctx *Drop_diskgroupContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_edition. + VisitDrop_edition(ctx *Drop_editionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#truncate_cluster. + VisitTruncate_cluster(ctx *Truncate_clusterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cache_or_nocache. + VisitCache_or_nocache(ctx *Cache_or_nocacheContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database_name. + VisitDatabase_name(ctx *Database_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_database. + VisitAlter_database(ctx *Alter_databaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database_clause. + VisitDatabase_clause(ctx *Database_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#startup_clauses. + VisitStartup_clauses(ctx *Startup_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#resetlogs_or_noresetlogs. + VisitResetlogs_or_noresetlogs(ctx *Resetlogs_or_noresetlogsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#upgrade_or_downgrade. + VisitUpgrade_or_downgrade(ctx *Upgrade_or_downgradeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#recovery_clauses. + VisitRecovery_clauses(ctx *Recovery_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#begin_or_end. + VisitBegin_or_end(ctx *Begin_or_endContext) interface{} + + // Visit a parse tree produced by PlSqlParser#general_recovery. + VisitGeneral_recovery(ctx *General_recoveryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#full_database_recovery. + VisitFull_database_recovery(ctx *Full_database_recoveryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partial_database_recovery. + VisitPartial_database_recovery(ctx *Partial_database_recoveryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partial_database_recovery_10g. + VisitPartial_database_recovery_10g(ctx *Partial_database_recovery_10gContext) interface{} + + // Visit a parse tree produced by PlSqlParser#managed_standby_recovery. + VisitManaged_standby_recovery(ctx *Managed_standby_recoveryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#db_name. + VisitDb_name(ctx *Db_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database_file_clauses. + VisitDatabase_file_clauses(ctx *Database_file_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_datafile_clause. + VisitCreate_datafile_clause(ctx *Create_datafile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_datafile_clause. + VisitAlter_datafile_clause(ctx *Alter_datafile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_tempfile_clause. + VisitAlter_tempfile_clause(ctx *Alter_tempfile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#move_datafile_clause. + VisitMove_datafile_clause(ctx *Move_datafile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logfile_clauses. + VisitLogfile_clauses(ctx *Logfile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_logfile_clauses. + VisitAdd_logfile_clauses(ctx *Add_logfile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#group_redo_logfile. + VisitGroup_redo_logfile(ctx *Group_redo_logfileContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_logfile_clauses. + VisitDrop_logfile_clauses(ctx *Drop_logfile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#switch_logfile_clause. + VisitSwitch_logfile_clause(ctx *Switch_logfile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_db_logging. + VisitSupplemental_db_logging(ctx *Supplemental_db_loggingContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_or_drop. + VisitAdd_or_drop(ctx *Add_or_dropContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_plsql_clause. + VisitSupplemental_plsql_clause(ctx *Supplemental_plsql_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logfile_descriptor. + VisitLogfile_descriptor(ctx *Logfile_descriptorContext) interface{} + + // Visit a parse tree produced by PlSqlParser#controlfile_clauses. + VisitControlfile_clauses(ctx *Controlfile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trace_file_clause. + VisitTrace_file_clause(ctx *Trace_file_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#standby_database_clauses. + VisitStandby_database_clauses(ctx *Standby_database_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#activate_standby_db_clause. + VisitActivate_standby_db_clause(ctx *Activate_standby_db_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#maximize_standby_db_clause. + VisitMaximize_standby_db_clause(ctx *Maximize_standby_db_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#register_logfile_clause. + VisitRegister_logfile_clause(ctx *Register_logfile_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#commit_switchover_clause. + VisitCommit_switchover_clause(ctx *Commit_switchover_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#start_standby_clause. + VisitStart_standby_clause(ctx *Start_standby_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#stop_standby_clause. + VisitStop_standby_clause(ctx *Stop_standby_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#convert_database_clause. + VisitConvert_database_clause(ctx *Convert_database_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_settings_clause. + VisitDefault_settings_clause(ctx *Default_settings_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_time_zone_clause. + VisitSet_time_zone_clause(ctx *Set_time_zone_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#instance_clauses. + VisitInstance_clauses(ctx *Instance_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#security_clause. + VisitSecurity_clause(ctx *Security_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#domain. + VisitDomain(ctx *DomainContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database. + VisitDatabase(ctx *DatabaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#edition_name. + VisitEdition_name(ctx *Edition_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#filenumber. + VisitFilenumber(ctx *FilenumberContext) interface{} + + // Visit a parse tree produced by PlSqlParser#filename. + VisitFilename(ctx *FilenameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#prepare_clause. + VisitPrepare_clause(ctx *Prepare_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_mirror_clause. + VisitDrop_mirror_clause(ctx *Drop_mirror_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lost_write_protection. + VisitLost_write_protection(ctx *Lost_write_protectionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cdb_fleet_clauses. + VisitCdb_fleet_clauses(ctx *Cdb_fleet_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lead_cdb_clause. + VisitLead_cdb_clause(ctx *Lead_cdb_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lead_cdb_uri_clause. + VisitLead_cdb_uri_clause(ctx *Lead_cdb_uri_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#property_clauses. + VisitProperty_clauses(ctx *Property_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#replay_upgrade_clauses. + VisitReplay_upgrade_clauses(ctx *Replay_upgrade_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_database_link. + VisitAlter_database_link(ctx *Alter_database_linkContext) interface{} + + // Visit a parse tree produced by PlSqlParser#password_value. + VisitPassword_value(ctx *Password_valueContext) interface{} + + // Visit a parse tree produced by PlSqlParser#link_authentication. + VisitLink_authentication(ctx *Link_authenticationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_database. + VisitCreate_database(ctx *Create_databaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database_logging_clauses. + VisitDatabase_logging_clauses(ctx *Database_logging_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#database_logging_sub_clause. + VisitDatabase_logging_sub_clause(ctx *Database_logging_sub_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_clauses. + VisitTablespace_clauses(ctx *Tablespace_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#enable_pluggable_database. + VisitEnable_pluggable_database(ctx *Enable_pluggable_databaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#file_name_convert. + VisitFile_name_convert(ctx *File_name_convertContext) interface{} + + // Visit a parse tree produced by PlSqlParser#filename_convert_sub_clause. + VisitFilename_convert_sub_clause(ctx *Filename_convert_sub_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace_datafile_clauses. + VisitTablespace_datafile_clauses(ctx *Tablespace_datafile_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#undo_mode_clause. + VisitUndo_mode_clause(ctx *Undo_mode_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_tablespace. + VisitDefault_tablespace(ctx *Default_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_temp_tablespace. + VisitDefault_temp_tablespace(ctx *Default_temp_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#undo_tablespace. + VisitUndo_tablespace(ctx *Undo_tablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_database. + VisitDrop_database(ctx *Drop_databaseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#create_database_link. + VisitCreate_database_link(ctx *Create_database_linkContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dblink. + VisitDblink(ctx *DblinkContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_database_link. + VisitDrop_database_link(ctx *Drop_database_linkContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_tablespace_set. + VisitAlter_tablespace_set(ctx *Alter_tablespace_setContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_tablespace_attrs. + VisitAlter_tablespace_attrs(ctx *Alter_tablespace_attrsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_tablespace_encryption. + VisitAlter_tablespace_encryption(ctx *Alter_tablespace_encryptionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ts_file_name_convert. + VisitTs_file_name_convert(ctx *Ts_file_name_convertContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_role. + VisitAlter_role(ctx *Alter_roleContext) interface{} + + // Visit a parse tree produced by PlSqlParser#role_identified_clause. + VisitRole_identified_clause(ctx *Role_identified_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_table. + VisitAlter_table(ctx *Alter_tableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#memoptimize_read_write_clause. + VisitMemoptimize_read_write_clause(ctx *Memoptimize_read_write_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_table_properties. + VisitAlter_table_properties(ctx *Alter_table_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_table_partitioning. + VisitAlter_table_partitioning(ctx *Alter_table_partitioningContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_table_partition. + VisitAdd_table_partition(ctx *Add_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_table_partition. + VisitDrop_table_partition(ctx *Drop_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_table_partition. + VisitMerge_table_partition(ctx *Merge_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_table_partition. + VisitModify_table_partition(ctx *Modify_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#split_table_partition. + VisitSplit_table_partition(ctx *Split_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#truncate_table_partition. + VisitTruncate_table_partition(ctx *Truncate_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exchange_table_partition. + VisitExchange_table_partition(ctx *Exchange_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#coalesce_table_partition. + VisitCoalesce_table_partition(ctx *Coalesce_table_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_interval_partition. + VisitAlter_interval_partition(ctx *Alter_interval_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_extended_names. + VisitPartition_extended_names(ctx *Partition_extended_namesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subpartition_extended_names. + VisitSubpartition_extended_names(ctx *Subpartition_extended_namesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_table_properties_1. + VisitAlter_table_properties_1(ctx *Alter_table_properties_1Context) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_iot_clauses. + VisitAlter_iot_clauses(ctx *Alter_iot_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_mapping_table_clause. + VisitAlter_mapping_table_clause(ctx *Alter_mapping_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_overflow_clause. + VisitAlter_overflow_clause(ctx *Alter_overflow_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_overflow_clause. + VisitAdd_overflow_clause(ctx *Add_overflow_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_index_clauses. + VisitUpdate_index_clauses(ctx *Update_index_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_global_index_clause. + VisitUpdate_global_index_clause(ctx *Update_global_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_all_indexes_clause. + VisitUpdate_all_indexes_clause(ctx *Update_all_indexes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_all_indexes_index_clause. + VisitUpdate_all_indexes_index_clause(ctx *Update_all_indexes_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_index_partition. + VisitUpdate_index_partition(ctx *Update_index_partitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_index_subpartition. + VisitUpdate_index_subpartition(ctx *Update_index_subpartitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#enable_disable_clause. + VisitEnable_disable_clause(ctx *Enable_disable_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_index_clause. + VisitUsing_index_clause(ctx *Using_index_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_attributes. + VisitIndex_attributes(ctx *Index_attributesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sort_or_nosort. + VisitSort_or_nosort(ctx *Sort_or_nosortContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exceptions_clause. + VisitExceptions_clause(ctx *Exceptions_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#move_table_clause. + VisitMove_table_clause(ctx *Move_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_org_table_clause. + VisitIndex_org_table_clause(ctx *Index_org_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#mapping_table_clause. + VisitMapping_table_clause(ctx *Mapping_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#key_compression. + VisitKey_compression(ctx *Key_compressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_org_overflow_clause. + VisitIndex_org_overflow_clause(ctx *Index_org_overflow_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_clauses. + VisitColumn_clauses(ctx *Column_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_collection_retrieval. + VisitModify_collection_retrieval(ctx *Modify_collection_retrievalContext) interface{} + + // Visit a parse tree produced by PlSqlParser#collection_item. + VisitCollection_item(ctx *Collection_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rename_column_clause. + VisitRename_column_clause(ctx *Rename_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#old_column_name. + VisitOld_column_name(ctx *Old_column_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_column_name. + VisitNew_column_name(ctx *New_column_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_modify_drop_column_clauses. + VisitAdd_modify_drop_column_clauses(ctx *Add_modify_drop_column_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_column_clause. + VisitDrop_column_clause(ctx *Drop_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_column_clauses. + VisitModify_column_clauses(ctx *Modify_column_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_col_visibility. + VisitModify_col_visibility(ctx *Modify_col_visibilityContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_col_properties. + VisitModify_col_properties(ctx *Modify_col_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_col_substitutable. + VisitModify_col_substitutable(ctx *Modify_col_substitutableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_column_clause. + VisitAdd_column_clause(ctx *Add_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#alter_varray_col_properties. + VisitAlter_varray_col_properties(ctx *Alter_varray_col_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#varray_col_properties. + VisitVarray_col_properties(ctx *Varray_col_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#varray_storage_clause. + VisitVarray_storage_clause(ctx *Varray_storage_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_segname. + VisitLob_segname(ctx *Lob_segnameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_item. + VisitLob_item(ctx *Lob_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_storage_parameters. + VisitLob_storage_parameters(ctx *Lob_storage_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_storage_clause. + VisitLob_storage_clause(ctx *Lob_storage_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_lob_storage_clause. + VisitModify_lob_storage_clause(ctx *Modify_lob_storage_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#modify_lob_parameters. + VisitModify_lob_parameters(ctx *Modify_lob_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_parameters. + VisitLob_parameters(ctx *Lob_parametersContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_deduplicate_clause. + VisitLob_deduplicate_clause(ctx *Lob_deduplicate_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_compression_clause. + VisitLob_compression_clause(ctx *Lob_compression_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_retention_clause. + VisitLob_retention_clause(ctx *Lob_retention_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#encryption_spec. + VisitEncryption_spec(ctx *Encryption_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tablespace. + VisitTablespace(ctx *TablespaceContext) interface{} + + // Visit a parse tree produced by PlSqlParser#varray_item. + VisitVarray_item(ctx *Varray_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_properties. + VisitColumn_properties(ctx *Column_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lob_partition_storage. + VisitLob_partition_storage(ctx *Lob_partition_storageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#period_definition. + VisitPeriod_definition(ctx *Period_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#start_time_column. + VisitStart_time_column(ctx *Start_time_columnContext) interface{} + + // Visit a parse tree produced by PlSqlParser#end_time_column. + VisitEnd_time_column(ctx *End_time_columnContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_definition. + VisitColumn_definition(ctx *Column_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_collation_name. + VisitColumn_collation_name(ctx *Column_collation_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identity_clause. + VisitIdentity_clause(ctx *Identity_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identity_options_parentheses. + VisitIdentity_options_parentheses(ctx *Identity_options_parenthesesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identity_options. + VisitIdentity_options(ctx *Identity_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#virtual_column_definition. + VisitVirtual_column_definition(ctx *Virtual_column_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#autogenerated_sequence_definition. + VisitAutogenerated_sequence_definition(ctx *Autogenerated_sequence_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#evaluation_edition_clause. + VisitEvaluation_edition_clause(ctx *Evaluation_edition_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#out_of_line_part_storage. + VisitOut_of_line_part_storage(ctx *Out_of_line_part_storageContext) interface{} + + // Visit a parse tree produced by PlSqlParser#nested_table_col_properties. + VisitNested_table_col_properties(ctx *Nested_table_col_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#nested_item. + VisitNested_item(ctx *Nested_itemContext) interface{} + + // Visit a parse tree produced by PlSqlParser#substitutable_column_clause. + VisitSubstitutable_column_clause(ctx *Substitutable_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_name. + VisitPartition_name(ctx *Partition_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#supplemental_logging_props. + VisitSupplemental_logging_props(ctx *Supplemental_logging_propsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_or_attribute. + VisitColumn_or_attribute(ctx *Column_or_attributeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_type_col_properties. + VisitObject_type_col_properties(ctx *Object_type_col_propertiesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constraint_clauses. + VisitConstraint_clauses(ctx *Constraint_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#old_constraint_name. + VisitOld_constraint_name(ctx *Old_constraint_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#new_constraint_name. + VisitNew_constraint_name(ctx *New_constraint_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_constraint_clause. + VisitDrop_constraint_clause(ctx *Drop_constraint_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_primary_key_or_unique_or_generic_clause. + VisitDrop_primary_key_or_unique_or_generic_clause(ctx *Drop_primary_key_or_unique_or_generic_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_constraint. + VisitAdd_constraint(ctx *Add_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#add_constraint_clause. + VisitAdd_constraint_clause(ctx *Add_constraint_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#check_constraint. + VisitCheck_constraint(ctx *Check_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#drop_constraint. + VisitDrop_constraint(ctx *Drop_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#enable_constraint. + VisitEnable_constraint(ctx *Enable_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#disable_constraint. + VisitDisable_constraint(ctx *Disable_constraintContext) interface{} + + // Visit a parse tree produced by PlSqlParser#foreign_key_clause. + VisitForeign_key_clause(ctx *Foreign_key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#references_clause. + VisitReferences_clause(ctx *References_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#on_delete_clause. + VisitOn_delete_clause(ctx *On_delete_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unique_key_clause. + VisitUnique_key_clause(ctx *Unique_key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#primary_key_clause. + VisitPrimary_key_clause(ctx *Primary_key_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#anonymous_block. + VisitAnonymous_block(ctx *Anonymous_blockContext) interface{} + + // Visit a parse tree produced by PlSqlParser#invoker_rights_clause. + VisitInvoker_rights_clause(ctx *Invoker_rights_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#call_spec. + VisitCall_spec(ctx *Call_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#java_spec. + VisitJava_spec(ctx *Java_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#c_spec. + VisitC_spec(ctx *C_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#c_agent_in_clause. + VisitC_agent_in_clause(ctx *C_agent_in_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#c_parameters_clause. + VisitC_parameters_clause(ctx *C_parameters_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parameter. + VisitParameter(ctx *ParameterContext) interface{} + + // Visit a parse tree produced by PlSqlParser#default_value_part. + VisitDefault_value_part(ctx *Default_value_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#seq_of_declare_specs. + VisitSeq_of_declare_specs(ctx *Seq_of_declare_specsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#declare_spec. + VisitDeclare_spec(ctx *Declare_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#variable_declaration. + VisitVariable_declaration(ctx *Variable_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subtype_declaration. + VisitSubtype_declaration(ctx *Subtype_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cursor_declaration. + VisitCursor_declaration(ctx *Cursor_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parameter_spec. + VisitParameter_spec(ctx *Parameter_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exception_declaration. + VisitException_declaration(ctx *Exception_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pragma_declaration. + VisitPragma_declaration(ctx *Pragma_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#record_type_def. + VisitRecord_type_def(ctx *Record_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#field_spec. + VisitField_spec(ctx *Field_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#ref_cursor_type_def. + VisitRef_cursor_type_def(ctx *Ref_cursor_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_declaration. + VisitType_declaration(ctx *Type_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_type_def. + VisitTable_type_def(ctx *Table_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_indexed_by_part. + VisitTable_indexed_by_part(ctx *Table_indexed_by_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#varray_type_def. + VisitVarray_type_def(ctx *Varray_type_defContext) interface{} + + // Visit a parse tree produced by PlSqlParser#seq_of_statements. + VisitSeq_of_statements(ctx *Seq_of_statementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#label_declaration. + VisitLabel_declaration(ctx *Label_declarationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#statement. + VisitStatement(ctx *StatementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#swallow_to_semi. + VisitSwallow_to_semi(ctx *Swallow_to_semiContext) interface{} + + // Visit a parse tree produced by PlSqlParser#assignment_statement. + VisitAssignment_statement(ctx *Assignment_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#continue_statement. + VisitContinue_statement(ctx *Continue_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exit_statement. + VisitExit_statement(ctx *Exit_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#goto_statement. + VisitGoto_statement(ctx *Goto_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#if_statement. + VisitIf_statement(ctx *If_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#elsif_part. + VisitElsif_part(ctx *Elsif_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#else_part. + VisitElse_part(ctx *Else_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#loop_statement. + VisitLoop_statement(ctx *Loop_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cursor_loop_param. + VisitCursor_loop_param(ctx *Cursor_loop_paramContext) interface{} + + // Visit a parse tree produced by PlSqlParser#forall_statement. + VisitForall_statement(ctx *Forall_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#bounds_clause. + VisitBounds_clause(ctx *Bounds_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#between_bound. + VisitBetween_bound(ctx *Between_boundContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lower_bound. + VisitLower_bound(ctx *Lower_boundContext) interface{} + + // Visit a parse tree produced by PlSqlParser#upper_bound. + VisitUpper_bound(ctx *Upper_boundContext) interface{} + + // Visit a parse tree produced by PlSqlParser#null_statement. + VisitNull_statement(ctx *Null_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#raise_statement. + VisitRaise_statement(ctx *Raise_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#return_statement. + VisitReturn_statement(ctx *Return_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#call_statement. + VisitCall_statement(ctx *Call_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pipe_row_statement. + VisitPipe_row_statement(ctx *Pipe_row_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#body. + VisitBody(ctx *BodyContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exception_handler. + VisitException_handler(ctx *Exception_handlerContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trigger_block. + VisitTrigger_block(ctx *Trigger_blockContext) interface{} + + // Visit a parse tree produced by PlSqlParser#block. + VisitBlock(ctx *BlockContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sql_statement. + VisitSql_statement(ctx *Sql_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#execute_immediate. + VisitExecute_immediate(ctx *Execute_immediateContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dynamic_returning_clause. + VisitDynamic_returning_clause(ctx *Dynamic_returning_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#data_manipulation_language_statements. + VisitData_manipulation_language_statements(ctx *Data_manipulation_language_statementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cursor_manipulation_statements. + VisitCursor_manipulation_statements(ctx *Cursor_manipulation_statementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#close_statement. + VisitClose_statement(ctx *Close_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#open_statement. + VisitOpen_statement(ctx *Open_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#fetch_statement. + VisitFetch_statement(ctx *Fetch_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#open_for_statement. + VisitOpen_for_statement(ctx *Open_for_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#transaction_control_statements. + VisitTransaction_control_statements(ctx *Transaction_control_statementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_transaction_command. + VisitSet_transaction_command(ctx *Set_transaction_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_constraint_command. + VisitSet_constraint_command(ctx *Set_constraint_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#commit_statement. + VisitCommit_statement(ctx *Commit_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#write_clause. + VisitWrite_clause(ctx *Write_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rollback_statement. + VisitRollback_statement(ctx *Rollback_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#savepoint_statement. + VisitSavepoint_statement(ctx *Savepoint_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#explain_statement. + VisitExplain_statement(ctx *Explain_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#select_only_statement. + VisitSelect_only_statement(ctx *Select_only_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#select_statement. + VisitSelect_statement(ctx *Select_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subquery_factoring_clause. + VisitSubquery_factoring_clause(ctx *Subquery_factoring_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#factoring_element. + VisitFactoring_element(ctx *Factoring_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#search_clause. + VisitSearch_clause(ctx *Search_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cycle_clause. + VisitCycle_clause(ctx *Cycle_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subquery. + VisitSubquery(ctx *SubqueryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subquery_basic_elements. + VisitSubquery_basic_elements(ctx *Subquery_basic_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subquery_operation_part. + VisitSubquery_operation_part(ctx *Subquery_operation_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#query_block. + VisitQuery_block(ctx *Query_blockContext) interface{} + + // Visit a parse tree produced by PlSqlParser#selected_list. + VisitSelected_list(ctx *Selected_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#from_clause. + VisitFrom_clause(ctx *From_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#select_list_elements. + VisitSelect_list_elements(ctx *Select_list_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_wild. + VisitTable_wild(ctx *Table_wildContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref_list. + VisitTable_ref_list(ctx *Table_ref_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref. + VisitTable_ref(ctx *Table_refContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref_aux. + VisitTable_ref_aux(ctx *Table_ref_auxContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref_aux_internal_one. + VisitTable_ref_aux_internal_one(ctx *Table_ref_aux_internal_oneContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref_aux_internal_two. + VisitTable_ref_aux_internal_two(ctx *Table_ref_aux_internal_twoContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_ref_aux_internal_three. + VisitTable_ref_aux_internal_three(ctx *Table_ref_aux_internal_threeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_clause. + VisitJoin_clause(ctx *Join_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_on_part. + VisitJoin_on_part(ctx *Join_on_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#join_using_part. + VisitJoin_using_part(ctx *Join_using_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#outer_join_type. + VisitOuter_join_type(ctx *Outer_join_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#query_partition_clause. + VisitQuery_partition_clause(ctx *Query_partition_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#flashback_query_clause. + VisitFlashback_query_clause(ctx *Flashback_query_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_clause. + VisitPivot_clause(ctx *Pivot_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_element. + VisitPivot_element(ctx *Pivot_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_for_clause. + VisitPivot_for_clause(ctx *Pivot_for_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_in_clause. + VisitPivot_in_clause(ctx *Pivot_in_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_in_clause_element. + VisitPivot_in_clause_element(ctx *Pivot_in_clause_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#pivot_in_clause_elements. + VisitPivot_in_clause_elements(ctx *Pivot_in_clause_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unpivot_clause. + VisitUnpivot_clause(ctx *Unpivot_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unpivot_in_clause. + VisitUnpivot_in_clause(ctx *Unpivot_in_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unpivot_in_elements. + VisitUnpivot_in_elements(ctx *Unpivot_in_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#hierarchical_query_clause. + VisitHierarchical_query_clause(ctx *Hierarchical_query_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#start_part. + VisitStart_part(ctx *Start_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#group_by_clause. + VisitGroup_by_clause(ctx *Group_by_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#group_by_elements. + VisitGroup_by_elements(ctx *Group_by_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rollup_cube_clause. + VisitRollup_cube_clause(ctx *Rollup_cube_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#grouping_sets_clause. + VisitGrouping_sets_clause(ctx *Grouping_sets_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#grouping_sets_elements. + VisitGrouping_sets_elements(ctx *Grouping_sets_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#having_clause. + VisitHaving_clause(ctx *Having_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_clause. + VisitModel_clause(ctx *Model_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cell_reference_options. + VisitCell_reference_options(ctx *Cell_reference_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#return_rows_clause. + VisitReturn_rows_clause(ctx *Return_rows_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#reference_model. + VisitReference_model(ctx *Reference_modelContext) interface{} + + // Visit a parse tree produced by PlSqlParser#main_model. + VisitMain_model(ctx *Main_modelContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_column_clauses. + VisitModel_column_clauses(ctx *Model_column_clausesContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_column_partition_part. + VisitModel_column_partition_part(ctx *Model_column_partition_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_column_list. + VisitModel_column_list(ctx *Model_column_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_column. + VisitModel_column(ctx *Model_columnContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_rules_clause. + VisitModel_rules_clause(ctx *Model_rules_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_rules_part. + VisitModel_rules_part(ctx *Model_rules_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_rules_element. + VisitModel_rules_element(ctx *Model_rules_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cell_assignment. + VisitCell_assignment(ctx *Cell_assignmentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_iterate_clause. + VisitModel_iterate_clause(ctx *Model_iterate_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#until_part. + VisitUntil_part(ctx *Until_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#order_by_clause. + VisitOrder_by_clause(ctx *Order_by_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#order_by_elements. + VisitOrder_by_elements(ctx *Order_by_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#offset_clause. + VisitOffset_clause(ctx *Offset_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#fetch_clause. + VisitFetch_clause(ctx *Fetch_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#for_update_clause. + VisitFor_update_clause(ctx *For_update_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#for_update_of_part. + VisitFor_update_of_part(ctx *For_update_of_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#for_update_options. + VisitFor_update_options(ctx *For_update_optionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_statement. + VisitUpdate_statement(ctx *Update_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#update_set_clause. + VisitUpdate_set_clause(ctx *Update_set_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_based_update_set_clause. + VisitColumn_based_update_set_clause(ctx *Column_based_update_set_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#delete_statement. + VisitDelete_statement(ctx *Delete_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#insert_statement. + VisitInsert_statement(ctx *Insert_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#single_table_insert. + VisitSingle_table_insert(ctx *Single_table_insertContext) interface{} + + // Visit a parse tree produced by PlSqlParser#multi_table_insert. + VisitMulti_table_insert(ctx *Multi_table_insertContext) interface{} + + // Visit a parse tree produced by PlSqlParser#multi_table_element. + VisitMulti_table_element(ctx *Multi_table_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#conditional_insert_clause. + VisitConditional_insert_clause(ctx *Conditional_insert_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#conditional_insert_when_part. + VisitConditional_insert_when_part(ctx *Conditional_insert_when_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#conditional_insert_else_part. + VisitConditional_insert_else_part(ctx *Conditional_insert_else_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#insert_into_clause. + VisitInsert_into_clause(ctx *Insert_into_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#values_clause. + VisitValues_clause(ctx *Values_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_statement. + VisitMerge_statement(ctx *Merge_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_update_clause. + VisitMerge_update_clause(ctx *Merge_update_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_element. + VisitMerge_element(ctx *Merge_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_update_delete_part. + VisitMerge_update_delete_part(ctx *Merge_update_delete_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#merge_insert_clause. + VisitMerge_insert_clause(ctx *Merge_insert_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#selected_tableview. + VisitSelected_tableview(ctx *Selected_tableviewContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lock_table_statement. + VisitLock_table_statement(ctx *Lock_table_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#wait_nowait_part. + VisitWait_nowait_part(ctx *Wait_nowait_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lock_table_element. + VisitLock_table_element(ctx *Lock_table_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#lock_mode. + VisitLock_mode(ctx *Lock_modeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#general_table_ref. + VisitGeneral_table_ref(ctx *General_table_refContext) interface{} + + // Visit a parse tree produced by PlSqlParser#static_returning_clause. + VisitStatic_returning_clause(ctx *Static_returning_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#error_logging_clause. + VisitError_logging_clause(ctx *Error_logging_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#error_logging_into_part. + VisitError_logging_into_part(ctx *Error_logging_into_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#error_logging_reject_part. + VisitError_logging_reject_part(ctx *Error_logging_reject_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dml_table_expression_clause. + VisitDml_table_expression_clause(ctx *Dml_table_expression_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_collection_expression. + VisitTable_collection_expression(ctx *Table_collection_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#subquery_restriction_clause. + VisitSubquery_restriction_clause(ctx *Subquery_restriction_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sample_clause. + VisitSample_clause(ctx *Sample_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#seed_part. + VisitSeed_part(ctx *Seed_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#condition. + VisitCondition(ctx *ConditionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_condition. + VisitJson_condition(ctx *Json_conditionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#expressions. + VisitExpressions(ctx *ExpressionsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#expression. + VisitExpression(ctx *ExpressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cursor_expression. + VisitCursor_expression(ctx *Cursor_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logical_expression. + VisitLogical_expression(ctx *Logical_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unary_logical_expression. + VisitUnary_logical_expression(ctx *Unary_logical_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#logical_operation. + VisitLogical_operation(ctx *Logical_operationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#multiset_expression. + VisitMultiset_expression(ctx *Multiset_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#relational_expression. + VisitRelational_expression(ctx *Relational_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#compound_expression. + VisitCompound_expression(ctx *Compound_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#relational_operator. + VisitRelational_operator(ctx *Relational_operatorContext) interface{} + + // Visit a parse tree produced by PlSqlParser#in_elements. + VisitIn_elements(ctx *In_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#between_elements. + VisitBetween_elements(ctx *Between_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#concatenation. + VisitConcatenation(ctx *ConcatenationContext) interface{} + + // Visit a parse tree produced by PlSqlParser#interval_expression. + VisitInterval_expression(ctx *Interval_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_expression. + VisitModel_expression(ctx *Model_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#model_expression_element. + VisitModel_expression_element(ctx *Model_expression_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#single_column_for_loop. + VisitSingle_column_for_loop(ctx *Single_column_for_loopContext) interface{} + + // Visit a parse tree produced by PlSqlParser#multi_column_for_loop. + VisitMulti_column_for_loop(ctx *Multi_column_for_loopContext) interface{} + + // Visit a parse tree produced by PlSqlParser#unary_expression. + VisitUnary_expression(ctx *Unary_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#case_statement. + VisitCase_statement(ctx *Case_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#simple_case_statement. + VisitSimple_case_statement(ctx *Simple_case_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#simple_case_when_part. + VisitSimple_case_when_part(ctx *Simple_case_when_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#searched_case_statement. + VisitSearched_case_statement(ctx *Searched_case_statementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#searched_case_when_part. + VisitSearched_case_when_part(ctx *Searched_case_when_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#case_else_part. + VisitCase_else_part(ctx *Case_else_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#atom. + VisitAtom(ctx *AtomContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quantified_expression. + VisitQuantified_expression(ctx *Quantified_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#string_function. + VisitString_function(ctx *String_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#standard_function. + VisitStandard_function(ctx *Standard_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_function. + VisitJson_function(ctx *Json_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_object_content. + VisitJson_object_content(ctx *Json_object_contentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_object_entry. + VisitJson_object_entry(ctx *Json_object_entryContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_table_clause. + VisitJson_table_clause(ctx *Json_table_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_array_element. + VisitJson_array_element(ctx *Json_array_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_on_null_clause. + VisitJson_on_null_clause(ctx *Json_on_null_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_return_clause. + VisitJson_return_clause(ctx *Json_return_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_transform_op. + VisitJson_transform_op(ctx *Json_transform_opContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_column_clause. + VisitJson_column_clause(ctx *Json_column_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_column_definition. + VisitJson_column_definition(ctx *Json_column_definitionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_query_returning_clause. + VisitJson_query_returning_clause(ctx *Json_query_returning_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_query_return_type. + VisitJson_query_return_type(ctx *Json_query_return_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_query_wrapper_clause. + VisitJson_query_wrapper_clause(ctx *Json_query_wrapper_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_query_on_error_clause. + VisitJson_query_on_error_clause(ctx *Json_query_on_error_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_query_on_empty_clause. + VisitJson_query_on_empty_clause(ctx *Json_query_on_empty_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_value_return_clause. + VisitJson_value_return_clause(ctx *Json_value_return_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_value_return_type. + VisitJson_value_return_type(ctx *Json_value_return_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#json_value_on_mismatch_clause. + VisitJson_value_on_mismatch_clause(ctx *Json_value_on_mismatch_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#literal. + VisitLiteral(ctx *LiteralContext) interface{} + + // Visit a parse tree produced by PlSqlParser#numeric_function_wrapper. + VisitNumeric_function_wrapper(ctx *Numeric_function_wrapperContext) interface{} + + // Visit a parse tree produced by PlSqlParser#numeric_function. + VisitNumeric_function(ctx *Numeric_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#listagg_overflow_clause. + VisitListagg_overflow_clause(ctx *Listagg_overflow_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#other_function. + VisitOther_function(ctx *Other_functionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#over_clause_keyword. + VisitOver_clause_keyword(ctx *Over_clause_keywordContext) interface{} + + // Visit a parse tree produced by PlSqlParser#within_or_over_clause_keyword. + VisitWithin_or_over_clause_keyword(ctx *Within_or_over_clause_keywordContext) interface{} + + // Visit a parse tree produced by PlSqlParser#standard_prediction_function_keyword. + VisitStandard_prediction_function_keyword(ctx *Standard_prediction_function_keywordContext) interface{} + + // Visit a parse tree produced by PlSqlParser#over_clause. + VisitOver_clause(ctx *Over_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#windowing_clause. + VisitWindowing_clause(ctx *Windowing_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#windowing_type. + VisitWindowing_type(ctx *Windowing_typeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#windowing_elements. + VisitWindowing_elements(ctx *Windowing_elementsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_clause. + VisitUsing_clause(ctx *Using_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#using_element. + VisitUsing_element(ctx *Using_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#collect_order_by_part. + VisitCollect_order_by_part(ctx *Collect_order_by_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#within_or_over_part. + VisitWithin_or_over_part(ctx *Within_or_over_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cost_matrix_clause. + VisitCost_matrix_clause(ctx *Cost_matrix_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_passing_clause. + VisitXml_passing_clause(ctx *Xml_passing_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_attributes_clause. + VisitXml_attributes_clause(ctx *Xml_attributes_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_namespaces_clause. + VisitXml_namespaces_clause(ctx *Xml_namespaces_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_table_column. + VisitXml_table_column(ctx *Xml_table_columnContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_general_default_part. + VisitXml_general_default_part(ctx *Xml_general_default_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_multiuse_expression_element. + VisitXml_multiuse_expression_element(ctx *Xml_multiuse_expression_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlroot_param_version_part. + VisitXmlroot_param_version_part(ctx *Xmlroot_param_version_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlroot_param_standalone_part. + VisitXmlroot_param_standalone_part(ctx *Xmlroot_param_standalone_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlserialize_param_enconding_part. + VisitXmlserialize_param_enconding_part(ctx *Xmlserialize_param_enconding_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlserialize_param_version_part. + VisitXmlserialize_param_version_part(ctx *Xmlserialize_param_version_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmlserialize_param_ident_part. + VisitXmlserialize_param_ident_part(ctx *Xmlserialize_param_ident_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sql_plus_command. + VisitSql_plus_command(ctx *Sql_plus_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#whenever_command. + VisitWhenever_command(ctx *Whenever_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#set_command. + VisitSet_command(ctx *Set_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#timing_command. + VisitTiming_command(ctx *Timing_commandContext) interface{} + + // Visit a parse tree produced by PlSqlParser#partition_extension_clause. + VisitPartition_extension_clause(ctx *Partition_extension_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_alias. + VisitColumn_alias(ctx *Column_aliasContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_alias. + VisitTable_alias(ctx *Table_aliasContext) interface{} + + // Visit a parse tree produced by PlSqlParser#where_clause. + VisitWhere_clause(ctx *Where_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quantitative_where_stmt. + VisitQuantitative_where_stmt(ctx *Quantitative_where_stmtContext) interface{} + + // Visit a parse tree produced by PlSqlParser#into_clause. + VisitInto_clause(ctx *Into_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xml_column_name. + VisitXml_column_name(ctx *Xml_column_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cost_class_name. + VisitCost_class_name(ctx *Cost_class_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#attribute_name. + VisitAttribute_name(ctx *Attribute_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#savepoint_name. + VisitSavepoint_name(ctx *Savepoint_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#rollback_segment_name. + VisitRollback_segment_name(ctx *Rollback_segment_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_var_name. + VisitTable_var_name(ctx *Table_var_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#schema_name. + VisitSchema_name(ctx *Schema_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#routine_name. + VisitRoutine_name(ctx *Routine_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#package_name. + VisitPackage_name(ctx *Package_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#implementation_type_name. + VisitImplementation_type_name(ctx *Implementation_type_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#parameter_name. + VisitParameter_name(ctx *Parameter_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#reference_model_name. + VisitReference_model_name(ctx *Reference_model_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#main_model_name. + VisitMain_model_name(ctx *Main_model_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#container_tableview_name. + VisitContainer_tableview_name(ctx *Container_tableview_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#aggregate_function_name. + VisitAggregate_function_name(ctx *Aggregate_function_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#query_name. + VisitQuery_name(ctx *Query_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#grantee_name. + VisitGrantee_name(ctx *Grantee_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#role_name. + VisitRole_name(ctx *Role_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constraint_name. + VisitConstraint_name(ctx *Constraint_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#label_name. + VisitLabel_name(ctx *Label_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_name. + VisitType_name(ctx *Type_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#sequence_name. + VisitSequence_name(ctx *Sequence_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#exception_name. + VisitException_name(ctx *Exception_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_name. + VisitFunction_name(ctx *Function_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#procedure_name. + VisitProcedure_name(ctx *Procedure_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#trigger_name. + VisitTrigger_name(ctx *Trigger_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#variable_name. + VisitVariable_name(ctx *Variable_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#index_name. + VisitIndex_name(ctx *Index_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#cursor_name. + VisitCursor_name(ctx *Cursor_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#record_name. + VisitRecord_name(ctx *Record_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#collection_name. + VisitCollection_name(ctx *Collection_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#link_name. + VisitLink_name(ctx *Link_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_name. + VisitColumn_name(ctx *Column_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#tableview_name. + VisitTableview_name(ctx *Tableview_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#xmltable. + VisitXmltable(ctx *XmltableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#char_set_name. + VisitChar_set_name(ctx *Char_set_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#synonym_name. + VisitSynonym_name(ctx *Synonym_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#schema_object_name. + VisitSchema_object_name(ctx *Schema_object_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#dir_object_name. + VisitDir_object_name(ctx *Dir_object_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#user_object_name. + VisitUser_object_name(ctx *User_object_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#grant_object_name. + VisitGrant_object_name(ctx *Grant_object_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#column_list. + VisitColumn_list(ctx *Column_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#paren_column_list. + VisitParen_column_list(ctx *Paren_column_listContext) interface{} + + // Visit a parse tree produced by PlSqlParser#keep_clause. + VisitKeep_clause(ctx *Keep_clauseContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_argument. + VisitFunction_argument(ctx *Function_argumentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_argument_analytic. + VisitFunction_argument_analytic(ctx *Function_argument_analyticContext) interface{} + + // Visit a parse tree produced by PlSqlParser#function_argument_modeling. + VisitFunction_argument_modeling(ctx *Function_argument_modelingContext) interface{} + + // Visit a parse tree produced by PlSqlParser#respect_or_ignore_nulls. + VisitRespect_or_ignore_nulls(ctx *Respect_or_ignore_nullsContext) interface{} + + // Visit a parse tree produced by PlSqlParser#argument. + VisitArgument(ctx *ArgumentContext) interface{} + + // Visit a parse tree produced by PlSqlParser#type_spec. + VisitType_spec(ctx *Type_specContext) interface{} + + // Visit a parse tree produced by PlSqlParser#datatype. + VisitDatatype(ctx *DatatypeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#precision_part. + VisitPrecision_part(ctx *Precision_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#native_datatype_element. + VisitNative_datatype_element(ctx *Native_datatype_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#bind_variable. + VisitBind_variable(ctx *Bind_variableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#general_element. + VisitGeneral_element(ctx *General_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#general_element_part. + VisitGeneral_element_part(ctx *General_element_partContext) interface{} + + // Visit a parse tree produced by PlSqlParser#table_element. + VisitTable_element(ctx *Table_elementContext) interface{} + + // Visit a parse tree produced by PlSqlParser#object_privilege. + VisitObject_privilege(ctx *Object_privilegeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#system_privilege. + VisitSystem_privilege(ctx *System_privilegeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constant. + VisitConstant(ctx *ConstantContext) interface{} + + // Visit a parse tree produced by PlSqlParser#constant_without_variable. + VisitConstant_without_variable(ctx *Constant_without_variableContext) interface{} + + // Visit a parse tree produced by PlSqlParser#numeric. + VisitNumeric(ctx *NumericContext) interface{} + + // Visit a parse tree produced by PlSqlParser#numeric_negative. + VisitNumeric_negative(ctx *Numeric_negativeContext) interface{} + + // Visit a parse tree produced by PlSqlParser#quoted_string. + VisitQuoted_string(ctx *Quoted_stringContext) interface{} + + // Visit a parse tree produced by PlSqlParser#char_str. + VisitChar_str(ctx *Char_strContext) interface{} + + // Visit a parse tree produced by PlSqlParser#identifier. + VisitIdentifier(ctx *IdentifierContext) interface{} + + // Visit a parse tree produced by PlSqlParser#id_expression. + VisitId_expression(ctx *Id_expressionContext) interface{} + + // Visit a parse tree produced by PlSqlParser#outer_join_sign. + VisitOuter_join_sign(ctx *Outer_join_signContext) interface{} + + // Visit a parse tree produced by PlSqlParser#regular_id. + VisitRegular_id(ctx *Regular_idContext) interface{} + + // Visit a parse tree produced by PlSqlParser#non_reserved_keywords_in_12c. + VisitNon_reserved_keywords_in_12c(ctx *Non_reserved_keywords_in_12cContext) interface{} + + // Visit a parse tree produced by PlSqlParser#non_reserved_keywords_pre12c. + VisitNon_reserved_keywords_pre12c(ctx *Non_reserved_keywords_pre12cContext) interface{} + + // Visit a parse tree produced by PlSqlParser#string_function_name. + VisitString_function_name(ctx *String_function_nameContext) interface{} + + // Visit a parse tree produced by PlSqlParser#numeric_function_name. + VisitNumeric_function_name(ctx *Numeric_function_nameContext) interface{} +}